Fix live conditions bugs: 10min is a delay, bare hours pick the next one, with you means the host, missed words are said back, tap-to-fill chips

Friend's sentence 'After 10min, a quick visit works' at 8:22 PM: before 'after 10 AM', now
'you can come in 10 min' plus 'I didn't catch: a quick visit works'. blind_40 30/40 before and after.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Entire-Checkpoint: 01M4PRC68GKG4JQGEDGSRZJRA7

Author: Hotragn

apps/web/src/lib/conditions/index.ts

@@ -16,15 +16,42 @@ const ORDER: Rule["type"][] = ["max_step", "min_step", "with", "after", "back_by
 
 export const countWords = (s: string): number => s.split(/\s+/).filter((w) => /[\p{L}\p{N}]/u.test(w)).length;
 
+const MIN = 60_000;
+// Rules made from a delay ("in 10 min"), so the read-back says it the way it was said.
+const delayMin = new WeakMap<Rule, number>();
+
+/**
+ * A bare hour ("after 10") means the next one coming up from now: 8:22 PM plus "after 10" is
+ * 10 PM, 9 AM plus "after 10" is 10 AM. Never a time already gone (live bug, Oct 11).
+ */
+function upcoming(hhmm: string, ctx: ParseContext): string {
+  const [h, mi] = hhmm.split(":").map(Number) as [number, number];
+  const h12 = h % 12;
+  const mm = String(mi).padStart(2, "0");
+  const now = Date.parse(ctx.now);
+  const tomorrow = new Date(now + 24 * 60 * MIN).toISOString();
+  const tries = [
+    localToIso(`${String(h).padStart(2, "0")}:${mm}`, ctx.now, ctx.tz), // the usual reading first
+    localToIso(`${String(h12 + (h >= 12 ? 0 : 12)).padStart(2, "0")}:${mm}`, ctx.now, ctx.tz),
+    localToIso(`${String(h12).padStart(2, "0")}:${mm}`, tomorrow, ctx.tz),
+  ];
+  return tries.find((iso) => Date.parse(iso) >= now - MIN) ?? (tries[2] as string);
+}
+
 function toRule(r: RawRule, ctx: ParseContext): Rule | null {
   switch (r.type) {
+    case "after_in": {
+      const rule: Rule = { type: "after", at: new Date(Date.parse(ctx.now) + r.value * MIN).toISOString() };
+      delayMin.set(rule, r.value);
+      return rule;
+    }
     case "with": {
       const m = ctx.members.find((x) => x.name.toLowerCase() === r.value.toLowerCase());
       return m ? { type: "with", member_id: m.id } : null;
     }
     case "after":
     case "back_by":
-      return { type: r.type, at: localToIso(r.value, ctx.now, ctx.tz) };
+      return { type: r.type, at: r.bare ? upcoming(r.value, ctx) : localToIso(r.value, ctx.now, ctx.tz) };
     case "max_walk":
       return { type: "max_walk", minutes: r.value };
     case "max_step":
@@ -47,7 +74,9 @@ function fragments(rules: Rule[], ctx: ParseContext, style: "rule" | "chip"): st
       namesDone = true;
       const joined = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
       out.push(t(`readback.${style}.with`, { name: joined ?? "" }));
-    } else if (r.type === "after") out.push(t(`readback.${style}.after`, { time: timeLabel(r.at, ctx.tz) }));
+    } else if (r.type === "after" && style === "rule" && delayMin.has(r))
+      out.push(t("readback.rule.afterIn", { min: delayMin.get(r) ?? 0 }));
+    else if (r.type === "after") out.push(t(`readback.${style}.after`, { time: timeLabel(r.at, ctx.tz) }));
     else if (r.type === "back_by") out.push(t(`readback.${style}.backBy`, { time: timeLabel(r.at, ctx.tz) }));
     else if (r.type === "max_walk") out.push(t(`readback.${style}.maxWalk`, { min: r.minutes }));
     else if (r.type === "max_step") out.push(t(`readback.${style}.maxStep`, { k: r.step }));
@@ -67,11 +96,36 @@ export function readBack(rules: Rule[], ctx: ParseContext): string {
 /** One chip label per rule group, for the I3 sheet ("Rules that will be sent"). */
 export const readBackChips = (rules: Rule[], ctx: ParseContext): string[] => fragments(rules, ctx, "chip");
 
+// Words that carry no rule on their own, so a clause made only of them isn't "missed".
+const FILLER = new Set(
+  "i im i'm can could come make it works work fine ok okay yes yeah yep sure but so and then me count in sounds good totally lol haha maybe probably will be there down great cool love to the a an that this we us go going lets let's do i'll ill would should too also".split(
+    " ",
+  ),
+);
+
+/** Clauses the parser read nothing from, so the read-back never drops words quietly. */
+function missedWords(text: string, ctx: ParseContext): string {
+  const names = ctx.members.map((m) => m.name);
+  const out: string[] = [];
+  for (const clause of text.split(/[,;.!?]+|\s+but\s+/i)) {
+    const c = clause.trim();
+    const words = c.toLowerCase().match(/[\p{L}'0-9]+/gu) ?? [];
+    if (!words.some((w) => !FILLER.has(w))) continue;
+    const r = parseRaw(c, names, ctx.steps ?? [], ctx.host ?? "");
+    if (r.ok && r.rules.some((x) => toRule(x, ctx))) continue;
+    if (!r.ok && r.reason !== "didnt_catch") continue;
+    out.push(c);
+  }
+  const all = out.join(", ").split(/\s+/);
+  return all.length > 8 ? `${all.slice(0, 8).join(" ")}...` : all.join(" ");
+}
+
 export function parse(text: string, ctx: ParseContext): ParseResult {
   const raw = parseRaw(
     text,
     ctx.members.map((m) => m.name),
     ctx.steps ?? [],
+    ctx.host ?? "",
   );
   if (!raw.ok) return raw.reason === "not_in_group" ? { ok: false, reason: raw.reason, name: raw.name } : raw;
   const rules: Rule[] = [];
@@ -81,7 +135,25 @@ export function parse(text: string, ctx: ParseContext): ParseResult {
   }
   // Only step words on a Flare: nothing usable was said.
   if (raw.rules.length && !rules.length) return { ok: false, reason: "didnt_catch" };
-  return { ok: true, rules, readBack: readBack(rules, ctx) };
+  const missed = rules.length ? missedWords(text, ctx) : "";
+  return { ok: true, rules, readBack: readBack(rules, ctx), ...(missed ? { missed } : {}) };
+}
+
+/**
+ * Tap-to-fill rules for when typing didn't work (live bug, Oct 11): built from the time of day
+ * and the host's name, never the reader's. Each `text` parses back to exactly its rule.
+ */
+export function suggestions(ctx: ParseContext): { label: string; text: string }[] {
+  const out: { label: string; text: string }[] = [{ label: t("cond.chip.in", { min: 10 }), text: "in 10 min" }];
+  const host = ctx.host && ctx.members.some((m) => m.name.toLowerCase() === ctx.host?.toLowerCase()) ? ctx.host : "";
+  if (host) out.push({ label: t("cond.chip.with", { name: host }), text: `only with ${host}` });
+  const now = Date.parse(ctx.now);
+  const at = new Date(Math.ceil((now + 30 * MIN) / (60 * MIN)) * 60 * MIN).toISOString(); // the next full hour, 30+ min away
+  const label = timeLabel(at, ctx.tz);
+  const [h, ap] = label.split(" ");
+  out.push({ label: t("cond.chip.after", { time: label }), text: `after ${h}${(ap ?? "").toLowerCase()}` });
+  out.push({ label: t("cond.chip.walk", { min: 15 }), text: "15 min walk max" });
+  return out;
 }
 
 /** User-facing message for a failed parse (SRS-COND-7, SRS-COND-8, BR-C-2). */
@@ -91,4 +163,4 @@ export function parseError(r: Extract<ParseResult, { ok: false }>): string {
   return t("cond.didntCatch");
 }
 
-export const conditions: ConditionsIcd.Conditions = { parse, readBack };
+export const conditions: ConditionsIcd.Conditions = { parse, readBack, suggestions };

apps/web/src/lib/conditions/rules.ts

@@ -6,7 +6,8 @@
 
 export type RawRule =
   | { type: "with"; value: string } // canonical member name as the group knows it
-  | { type: "after" | "back_by"; value: string } // "HH:MM", 24 h, group time zone
+  | { type: "after" | "back_by"; value: string; bare?: boolean } // "HH:MM", 24 h, group time zone; bare: no am/pm said
+  | { type: "after_in"; value: number } // a delay from now in minutes: "in 10 min", "10min", "give me 10"
   | { type: "max_walk"; value: number }
   | { type: "max_step" | "min_step"; value: 1 | 2 | 3 | 4 };
 
@@ -67,7 +68,36 @@ export function parseTime(raw: string): string | null {
   return `${String(h).padStart(2, "0")}:${String(min).padStart(2, "0")}`;
 }
 
-const TIME = String.raw`(noon|midday|(?:quarter|half) (?:past|after|to) \w+|half \w+|\d{1,2}(?::\d{2})?\s*(?:am|pm|o'?clock)?)`;
+/** True when a spoken time names an hour with no am or pm ("after 10"), so the next upcoming one is meant. */
+export const isBareTime = (raw: string): boolean => {
+  const s = raw.trim().toLowerCase().replace(/\./g, "");
+  if (/(am|pm)\b|\b(noon|midday)\b/.test(s)) return false;
+  const h = Number(s.match(/(\d{1,2})/)?.[1] ?? WORD_NUM[s.split(" ").at(-1) ?? ""] ?? 0);
+  return h >= 1 && h <= 12;
+};
+
+// A number followed by a minutes unit is a length of time, never a clock time ("after 10min").
+const TIME = String.raw`(noon|midday|(?:quarter|half) (?:past|after|to) \w+|half \w+|\d{1,2}(?::\d{2})?(?!\s*(?:m|mins?|minutes?)\b)\s*(?:am|pm|o'?clock)?)`;
+// Delays from now (live bug, Oct 11): "after 10min", "can come in 10", "give me 10", "in half an hour".
+const UNIT = String.raw`(?:m|mins?|minutes?)`;
+const DELAY = [
+  new RegExp(
+    String.raw`\b(?:in|after|give me|gimme|there in|here in)\s+(?:about\s+|like\s+)?(\d{1,3})\s*${UNIT}\b(?!\s*(?:walk|away|on foot|of walk))`,
+    "gi",
+  ),
+  new RegExp(
+    String.raw`\b(?:in|give me|gimme)\s+(?:about\s+|like\s+)?(\d{1,3})\b(?!\s*(?::|am\b|pm\b|o'?clock|${UNIT}\b|walk|step))`,
+    "gi",
+  ),
+  // A bare "10min" opening a sentence or clause: "10min only with you".
+  new RegExp(
+    String.raw`(?:^|[,;.!]\s*)(\d{1,3})\s*${UNIT}\b(?!\s*(?:walk|away|on foot|of walk|max|tops|at most|or less|no more))`,
+    "gi",
+  ),
+];
+// "with you", "only if you come", "you and me": the friend is talking to the host.
+const WITH_YOU =
+  /\b(?:only with|with|only if|if|as long as)\s+you\b(?!\s+(?:guys|all|two|lot))|\b(?:you and me|me and you|you and i)\b/i;
 const AFTER = [
   new RegExp(String.raw`\b(?:after|not before|earliest|from)\s+${TIME}`, "gi"),
   new RegExp(String.raw`\bafter my\s+${TIME}`, "gi"),
@@ -136,7 +166,9 @@ const softName = (n: string) =>
 // Step words that need no Plan context (fixture core_40 and hard_20).
 // S1 (fine-tune): sitting or saying hi is the smallest step ("sit somewhere close", "just wanna say hi").
 const SMALLEST = /\b(porch|smallest|tiniest|only the small one|the small one|say (?:hi|hello)|sit(?:ting)?)\b/;
-const SHORT = /\b(short one|quick (one|version|lap)|shortest|short (?:lap|version))\b/;
+// Short-stay words (live bug, Oct 11) read as the shorter steps on a Plan; a Flare has no steps.
+const SHORT =
+  /\b(short one|quick (one|version|lap|visit|stop)|shortest|short (?:lap|version|visit)|for a bit|stopping by|pop(?:ping)? by|swing by)\b/;
 const LONGEST = /\b(long one|longest|full walk|full loop|whole (walk|loop|thing)|biggest|big one)\b/;
 
 const MIN_WORD: Record<string, number> = { five: 5, ten: 10, fifteen: 15, twenty: 20, thirty: 30 };
@@ -187,25 +219,37 @@ function stepRules(low: string, steps: StepName[]): RawRule[] {
  * Text to raw rules. `members` are display names already decrypted on this phone (BR-C-3).
  * Returns [] for a plain yes, didnt_catch for anything it can't read (SRS-COND-8).
  */
-export function parseRaw(text: string, members: string[], steps: StepName[] = []): RawResult {
+export function parseRaw(text: string, members: string[], steps: StepName[] = [], host = ""): RawResult {
   // M0 (fine-tune): spoken durations to minutes before anything else, so "half hour" never reads as a time.
   const t = text
     .trim()
     .replace(/\bhalf(?:\s+an|\s+a|-|\s+)\s*hour\b/gi, "30 min")
     .replace(/\b(?:an|one) hour\b/gi, "60 min")
     .replace(/\b(five|ten|fifteen|twenty|thirty)(?:\s+|-)min/gi, (_, w: string) => `${MIN_WORD[w.toLowerCase()]} min`);
   if (!t) return { ok: false, reason: "didnt_catch" };
+  const delays: number[] = [];
+  let rest = t;
+  for (const re of DELAY)
+    rest = rest.replace(re, (_, n: string) => {
+      delays.push(Number(n));
+      return " ";
+    });
   if (PLAIN_YES.test(t)) return { ok: true, rules: [] };
   if (OR_ALTERNATIVE.test(t)) return { ok: false, reason: "didnt_catch" };
   const out: RawRule[] = [];
-  const low = t.toLowerCase();
+  const low = rest.toLowerCase();
   const add = (r: RawRule) => {
     if (!out.some((x) => x.type === r.type && x.value === r.value)) out.push(r);
   };
+  for (const n of delays) {
+    if (n < 1 || n > 240) return { ok: false, reason: "didnt_catch" };
+    add({ type: "after_in", value: n });
+  }
+  if (host && WITH_YOU.test(rest)) add({ type: "with", value: host });
 
   // with(X): names after with / if / only if, joined by "and".
   const byLower = new Map(members.map((n) => [n.toLowerCase(), n]));
-  for (const m of t.matchAll(NAME_RE)) {
+  for (const m of rest.matchAll(NAME_RE)) {
     for (const cand of [m[1], m[2]]) {
       if (!cand) continue;
       const k = cand.toLowerCase();
@@ -214,22 +258,22 @@ export function parseRaw(text: string, members: string[], steps: StepName[] = []
       else if (/^[A-Z]/.test(cand) && !NOT_NAMES.has(k)) return { ok: false, reason: "not_in_group", name: cand };
     }
   }
-  for (const name of members) if (softName(escapeRe(name)).test(t)) add({ type: "with", value: name });
+  for (const name of members) if (softName(escapeRe(name)).test(rest)) add({ type: "with", value: name });
 
   for (const re of AFTER)
-    for (const m of t.matchAll(re)) {
+    for (const m of rest.matchAll(re)) {
       const v = parseTime(m[1] ?? "");
       if (!v) return { ok: false, reason: "didnt_catch" };
-      add({ type: "after", value: v });
+      add({ type: "after", value: v, ...(isBareTime(m[1] ?? "") ? { bare: true } : {}) });
     }
   for (const re of BACK_BY)
-    for (const m of t.matchAll(re)) {
+    for (const m of rest.matchAll(re)) {
       const v = parseTime(m[1] ?? "");
       if (!v) return { ok: false, reason: "didnt_catch" };
-      add({ type: "back_by", value: v });
+      add({ type: "back_by", value: v, ...(isBareTime(m[1] ?? "") ? { bare: true } : {}) });
     }
   if (!out.some((r) => r.type === "back_by") && EVENT_BACK.test(low) && !/\bafter\b/.test(low)) {
-    const m = t.match(EVENT_AT);
+    const m = rest.match(EVENT_AT);
     const v = m?.[1] ? parseTime(m[1]) : null;
     if (v) add({ type: "back_by", value: v });
   }

apps/web/src/lib/screens/I2Condition.svelte

@@ -15,6 +15,7 @@
     listening = false,
     canDictate = false,
     sample = false,
+    suggest = [],
     oncheck,
     ondictate,
     onclose,
@@ -26,6 +27,8 @@
     listening?: boolean;
     canDictate?: boolean;
     sample?: boolean;
+    /** Tap-to-fill rules after a miss: one tap fills and checks it. */
+    suggest?: { label: string; text: string }[];
     oncheck?: (text: string) => void;
     ondictate?: () => void;
     onclose?: () => void;
@@ -37,7 +40,17 @@
   {#snippet overlay()}
     <Sheet inline title={t("cond.title")} description={t("cond.body")}>
       <TextField label={t("cond.label")} bind:value={text} placeholder={t("cond.placeholder")} mic={canDictate} {listening} onmic={ondictate} {error} multiline max={120} />
+      {#if suggest.length}
+        <ul class="chips" aria-label={t("cond.chipsAria")}>
+          {#each suggest as c (c.text)}<li><button type="button" onclick={() => { text = c.text; oncheck?.(c.text); }}>{c.label}</button></li>{/each}
+        </ul>
+      {/if}
       <Button onclick={() => oncheck?.(text)} disabled={!text.trim()}>{t("cond.check")}</Button>
     </Sheet>
   {/snippet}
 </Screen>
+
+<style>
+  .chips { list-style: none; margin: 0; padding: 0; display: flex; gap: 8px; flex-wrap: wrap; }
+  .chips button { min-height: 44px; padding: 0 14px; border-radius: var(--r-pill); background: var(--bg); border: 2px solid var(--line); color: inherit; font: inherit; font-weight: 700; }
+</style>

apps/web/src/lib/screens/I3Readback.svelte

@@ -13,6 +13,7 @@
     chips = [],
     busy = false,
     sample = false,
+    missed = "",
     onyes,
     onfix,
     onclose,
@@ -23,6 +24,8 @@
     chips?: string[];
     busy?: boolean;
     sample?: boolean;
+    /** Words that made no rule: said back, never dropped quietly. */
+    missed?: string;
     onyes?: () => void;
     onfix?: () => void;
     onclose?: () => void;
@@ -34,6 +37,7 @@
   {#snippet overlay()}
     <Sheet inline title={t("readback.title")}>
       <p class="t-title readback" aria-live="polite">{line}</p>
+      {#if missed}<p class="missed">{t("readback.missed", { words: missed })}</p>{/if}
       {#if chips.length}
         <ul class="chips" aria-label={t("readback.chipsAria")}>
           {#each chips as c (c)}<li>{c}</li>{/each}
@@ -47,6 +51,7 @@
 
 <style>
   .readback { margin: 0; }
+  .missed { margin: 0; font-weight: 700; }
   .chips { list-style: none; margin: 0; padding: 0; display: flex; gap: 8px; flex-wrap: wrap; }
   .chips li { padding: 8px 14px; border-radius: var(--r-pill); background: var(--bg); border: 2px solid var(--line); font-weight: 700; }
 </style>

apps/web/src/lib/screens/LinkPage.svelte

@@ -185,9 +185,9 @@
   {#if flow.screen === "invite"}
     <I1Invite view={v.state === "lit" ? "lit" : "kindling"} {info} have={flow.have} quorum={v.quorum} error={flow.error} busy={flow.busy} canCondition={flow.canCondition} onyes={() => flow.yes()} oncondition={() => flow.startCondition()} onclose={exit} />
   {:else if flow.screen === "condition"}
-    <I2Condition {info} bind:text={condText} error={flow.condError} oncheck={(x) => flow.check(x)} onclose={() => flow.notNow()} />
+    <I2Condition {info} bind:text={condText} error={flow.condError} suggest={flow.suggest} oncheck={(x) => flow.check(x)} onclose={() => flow.notNow()} />
   {:else if flow.screen === "readback"}
-    <I3Readback {info} line={flow.readBack} chips={flow.chips} busy={flow.busy} onyes={() => flow.confirmReadBack()} onfix={() => flow.fix()} onclose={() => flow.notNow()} />
+    <I3Readback {info} line={flow.readBack} missed={flow.missed} chips={flow.chips} busy={flow.busy} onyes={() => flow.confirmReadBack()} onfix={() => flow.fix()} onclose={() => flow.notNow()} />
   {:else if flow.screen === "not-suit"}
     <I5NotSuit {info} reasons={flow.notSuit} busy={flow.busy} onyes={() => flow.closerOne()} onno={() => flow.notNow()} />
   {:else if flow.screen === "in"}

apps/web/src/lib/screens/flow/link.svelte.ts

@@ -71,6 +71,10 @@ export class LinkFlow {
   walkMin = $state<number | null>(null);
   /** Read-back of the parsed condition (I3). */
   readBack = $state("");
+  /** Words the read-back couldn't turn into a rule, named back to the friend (live bug, Oct 11). */
+  missed = $state("");
+  /** Tap-to-fill rules after a miss, from the time of day and the host's name. */
+  suggest = $state<{ label: string; text: string }[]>([]);
   chips = $state<string[]>([]);
   condError = $state("");
   notSuit = $state<{ icon: string; text: string }[]>([]);
@@ -502,22 +506,29 @@ export class LinkFlow {
     const c = this.#d.conditions;
     if (!c || !this.view) return;
     const steps = this.view.plan?.steps.map((s) => ({ step: s.step, name: this.stepName(s.step) }));
-    const res = c.parse(text, {
+    const ctx = {
       members: Object.entries(this.#names).map(([id, name]) => ({ id, name })),
       tz: this.#d.tz,
       now: new Date(this.serverNow).toISOString(),
       kind: this.view.kind,
       steps,
-    });
+      host: this.sealed?.host_name ?? "",
+    };
+    const res = c.parse(text, ctx);
+    this.suggest = [];
     if (!res.ok) {
-      this.condError =
-        res.reason === "not_in_group"
-          ? t("cond.notInGroup", { name: res.name ?? "" })
-          : res.reason === "too_many"
-            ? t("cond.tooMany")
-            : t("cond.didntCatch");
+      if (res.reason === "not_in_group") this.condError = t("cond.notInGroup", { name: res.name ?? "" });
+      else if (res.reason === "too_many") this.condError = t("cond.tooMany");
+      else {
+        // Examples for this moment and this host, never the reader's own name; one tap fills one.
+        this.suggest = c.suggestions?.(ctx) ?? [];
+        const [a, b] = this.suggest;
+        this.condError =
+          a && b ? t("cond.didntCatchNow", { a: `"${a.text}"`, b: `"${b.text}"` }) : t("cond.didntCatch");
+      }
       return;
     }
+    this.missed = res.missed ?? "";
     this.#parsed = res.rules;
     this.readBack = res.readBack;
     this.chips = res.rules.map((r) => ruleChip(r, this.#d.tz, this.#names));