@mjasnikovs/pi-task 0.38.2 → 0.38.3

package/dist/task/orchestrator.js

@@ -42,6 +42,7 @@ import { beginRun, endRun, takeHeldInput } from './mid-run-input.js';
 import { reportDroppedInput } from './dropped-input.js';
 import { formatTimings } from './timings.js';
 import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
+import { TERMINAL_OUTCOMES, formatAt, formatWhy } from './terminal-outcome.js';
 // ─── Module-level state ──────────────────────────────────────────────────────
 let activeTask = null;
 /** Set the module-level active task (avoids `this` aliasing in TaskRunner.run). */
@@ -792,28 +793,18 @@ async function runGatedTaskInner(ctx, cwd, raw, opts = {}) {
         // No sibling plan → no scope fence; no parent list → no check-off.
     });
     active = gate.ctx;
-    switch (gate.kind) {
-        case 'paused':
-            await markResumable(cwd, res.taskId);
-            announce(`${tag} paused — verification failed and you dismissed the choice; resume with /task-resume.`, 'warning');
-            return;
-        case 'session-cancelled':
-            announce(`${tag} paused — could not start a session for autofix. Run /task-resume to retry.`, 'warning');
-            return;
-        case 'interrupted':
-            await markResumable(cwd, res.taskId);
-            announce(`${tag} paused — resume with /task-resume.`, 'warning');
-            return;
-        case 'failed': {
-            await markResumable(cwd, res.taskId);
-            const why = gate.reason ? ` — ${gate.reason.slice(0, 160)}` : '';
-            announce(`${tag} stopped${why} — fix and run /task-resume.`, 'error');
-            return;
-        }
-        case 'done':
-            announce(`${tag} complete — verified.`, 'info');
-            return;
-    }
+    // What each outcome means for persistence and for the user is stated once, in
+    // TERMINAL_OUTCOMES, and shared with /task-auto's loop. `failParent` is
+    // ignored here: /task runs one task and has no parent run file to fail.
+    const outcome = TERMINAL_OUTCOMES[gate.kind];
+    if (outcome.markResumable)
+        await markResumable(cwd, res.taskId);
+    announce(outcome.message({
+        tag,
+        at: formatAt(),
+        why: formatWhy(gate.kind === 'failed' ? gate.reason : undefined),
+        resumeCmd: '/task-resume'
+    }), outcome.level);
 }
 // ─── Command handlers ────────────────────────────────────────────────────────
 async function handleTask(args, ctx) {

package/dist/task/phases.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { docsFocused } from '../workers/docs-core.js';
 import { fetchFocused } from '../workers/fetch-core.js';
 import { runWorker } from '../workers/pi-worker-core.js';
+import { classifyWorkerFailure } from '../workers/worker-failure.js';
 import { findPhantomImports, formatApiCorrections, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { fanoutTimeoutPolicy, workerCarryForward, workerProgressCeilingMs, projectDocsBudget, projectDocsBudgetNotice } from './research-fanout-budget.js';
 import { isIntegrationUnknown } from './unknown-routing.js';
@@ -27,14 +28,10 @@ import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './quest
 import { parseGrillQuestions, parseAutoAnswer, autoAnswerHasTag, parseVerifyToolingOutput, deriveTitle } from './parsers.js';
 import { compressTitle } from './title-label.js';
 import { parseVerifyBlock, validateSpecShape, stripSpecPreamble, isCritiqueClean } from './spec-validation.js';
-import { findSkipEscapes, skipEscapeDefectText } from './skip-escape.js';
-import { findScriptEscapesInText, scriptEscapeDefectText } from './script-escape.js';
-import { findSynthesizedWiring, wiringProbeText, readReferencedDocs } from './wiring-claims.js';
-import { findAbsenceConflicts, absenceProbeText, siblingTitlesFromPlanContext } from './verify-reconcile.js';
-import { findFrozenPathConflicts, frozenConflictProbeText } from './frozen-conflict.js';
+import { collectCritiqueDefects } from './critique-probes.js';
+import { buildOptionCards, resolveAnswer } from './question-dialog.js';
 import { findSynthesizedApis, synthesizedApiReaskHint } from './api-synthesis.js';
-import { findGrepOnlyVerify, grepOnlyVerifyDefectText, GREP_THEATER_RETRY_HINT } from './verify-quality.js';
-import { existsSync } from 'node:fs';
+import { GREP_THEATER_RETRY_HINT } from './verify-quality.js';
 import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from './contracts.js';
 import { readRequirements, buildRequirementsBlock, buildOwnedRequirementsBlock, readOwnedRequirements, writeOwnedRequirements, ownedForTitle, appendOwnedConstraints } from './requirements.js';
 import { detachUnsatisfiableRequirements, claimPendingRequirements, unclaimedPendingRequirements, formatReassignActions } from './owned-freeze-reassign.js';
@@ -405,23 +402,55 @@ export function scopedToolingGoal(refined) {
  * Returns null when the result is trustworthy.
  */
 function classifyResearchWorker(name, result) {
-    if (result.loopHit) {
-        const argsStr = JSON.stringify(result.loopHit.call.args);
-        return {
-            kind: 'runaway',
-            reason: `stuck in a loop — called ${result.loopHit.call.name}(${argsStr}) `
-                + `×${result.loopHit.count} in the last ${result.loopHit.windowSize} calls `
-                + `and still looped after restarts`
-        };
-    }
-    if (result.timedOut) {
-        return { kind: 'runaway', reason: 'timed out after restarts' };
-    }
-    if (result.exitCode !== 0) {
-        return {
-            kind: 'fatal',
-            error: new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`)
-        };
+    // What KILLED the child, if anything — classified once, in the ladder that
+    // owns the precedence (workers/worker-failure.ts), because every kill path
+    // also sets `aborted` and a non-zero exit. This switch says only what each
+    // cause means to RESEARCH; being exhaustive, a new cause is a compile error
+    // here instead of falling through to the generic "exit N".
+    const failure = classifyWorkerFailure(result);
+    if (failure) {
+        switch (failure.kind) {
+            case 'loop': {
+                const argsStr = JSON.stringify(failure.hit.call.args);
+                return {
+                    kind: 'runaway',
+                    reason: `stuck in a loop — called ${failure.hit.call.name}(${argsStr}) `
+                        + `×${failure.hit.count} in the last ${failure.hit.windowSize} calls `
+                        + `and still looped after restarts`
+                };
+            }
+            case 'worker-timeout':
+                return { kind: 'runaway', reason: 'timed out after restarts' };
+            case 'command-timeout':
+                return {
+                    kind: 'runaway',
+                    reason: `ran a \`${failure.toolName}\` command that never returned and was killed `
+                        + 'after restarts'
+                };
+            case 'stream-stall':
+                return {
+                    kind: 'runaway',
+                    reason: `model stream went silent for ${failure.idleMs}ms after restarts`
+                };
+            case 'stalled':
+                return {
+                    kind: 'fatal',
+                    error: new Error(`Research ${name} worker: model server unreachable — the child produced no `
+                        + 'output and the model endpoint did not respond')
+                };
+            case 'leaked-tool-call':
+                return {
+                    kind: 'fatal',
+                    error: new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
+                        + `(${failure.text.trim()}) — it never ran`)
+                };
+            case 'aborted':
+            case 'exit':
+                return {
+                    kind: 'fatal',
+                    error: new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`)
+                };
+        }
     }
     if (result.text.trim().length === 0) {
         // NOTHING CAME BACK — two different events wear the same face, and the whole
@@ -452,13 +481,6 @@ function classifyResearchWorker(name, result) {
         }
         return { kind: 'empty' };
     }
-    if (result.leakedToolCall) {
-        return {
-            kind: 'fatal',
-            error: new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
-                + `(${result.leakedToolCall.trim()}) — it never ran`)
-        };
-    }
     return null;
 }
 /**
@@ -1221,10 +1243,6 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
         else {
             const plainSuggested = auto.suggested === undefined ? undefined : stripInlineMarkdown(auto.suggested);
             const plainAlt = auto.alt === undefined ? undefined : stripInlineMarkdown(auto.alt);
-            // A recommendation (or suggested+alt fork) becomes the boxed picker
-            // locally — each answer in its own bounding box, the recommended one
-            // tinted green; an open question shows the bare text prompt.
-            const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
             // YOLO: take the recommended option and never build the prompt (which
             // is also what suppresses its notification — see yolo.ts). An answer the
             // anti-synthesis guard demoted, or a question with no recommendation at
@@ -1240,17 +1258,22 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
                 qa.push(`Q${n + 1}: ${plainQ}\nA${n + 1}: ${answer} ${YOLO_STAMP}`);
                 continue;
             }
-            const options = twoOption ?
-                [
-                    {
-                        label: `A: ${renderInlineMarkdown(auto.suggested, theme)}`,
-                        value: plainSuggested
-                    },
-                    { label: `B: ${renderInlineMarkdown(auto.alt, theme)}`, value: plainAlt }
-                ]
-                : plainSuggested !== undefined ?
-                    [{ label: renderInlineMarkdown(auto.suggested, theme), value: plainSuggested }]
-                    : undefined;
+            // The picker cards and the reply mapping are shared with /task-auto's
+            // clarify loop and the plan session (question-dialog.ts) — all three
+            // used to write them out, and had drifted.
+            const pending = {
+                plain: plainQ,
+                shown: shownQ,
+                ...(plainSuggested !== undefined && {
+                    suggested: plainSuggested,
+                    shownSuggested: renderInlineMarkdown(auto.suggested, theme)
+                }),
+                ...(plainAlt !== undefined && {
+                    alt: plainAlt,
+                    shownAlt: renderInlineMarkdown(auto.alt, theme)
+                })
+            };
+            const options = buildOptionCards(pending);
             widgetState.lastLine = `awaiting Q${n + 1}`;
             const a = await ui.ask({
                 localTitle: shownQ,
@@ -1263,27 +1286,10 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
             });
             if (a === undefined)
                 throw new Error(USER_CANCELLED);
-            const typed = a.trim();
-            // The local picker resolves to the chosen option's full value, but a
-            // remote user (or the picker's free-text fallback) may still type a
-            // bare "A"/"B" — map those back to the option's full text, since
-            // storing the literal letter leaves the next grill-gen call a
-            // dangling reference it can't decode.
-            if (typed.length === 0 && plainSuggested) {
-                answer = plainSuggested;
-            }
-            else if (typed.length === 0) {
-                answer = '(skipped)';
-            }
-            else if (twoOption && /^a[.)]?$/i.test(typed)) {
-                answer = plainSuggested;
-            }
-            else if (twoOption && /^b[.)]?$/i.test(typed)) {
-                answer = plainAlt;
-            }
-            else {
-                answer = typed;
-            }
+            // No provenance stamp here, unlike clarify's transcript: this string is
+            // fed back VERBATIM into the next grill-gen prompt, so a
+            // "(accepted recommendation)" suffix would become model input.
+            answer = resolveAnswer(pending, a).answer;
             out.push(`A${n + 1}: ${answer}`);
         }
         qa.push(`Q${n + 1}: ${plainQ}\nA${n + 1}: ${answer}`);
@@ -1372,90 +1378,29 @@ extraDefects) {
     // When the draft is structurally sound and triage says CLEAN, return it as
     // is. Otherwise fall through to the rewrite, feeding the triage defects in
     // as a focus list. Triage failures are non-fatal — we just do the rewrite.
-    // DETERMINISTIC skip-escape gate (run-8 F2): a required VERIFY check wrapped in a
-    // skip-announcing `||` fallback (`… || echo "skipping (tool absent)"`) lets the
-    // check pass while never running. FP-measured 0/20 on the historical specs. When
-    // present, force the rewrite to strip it — never let the triage CLEAN short-circuit
-    // ship a self-waiving VERIFY block — and feed the offending lines in as defects.
-    const skipEscapes = findSkipEscapes(spec);
-    const skipDefects = skipEscapes.length > 0 ? skipEscapeDefectText(skipEscapes) : null;
-    // The cross-slice contract registry (run-8 F3): the design's pinned interface
-    // facts, quoted verbatim, that more than one slice touches. Threading them into
-    // critique lets the triage/rewrite RECONCILE a synthesized wiring specific (a
-    // fabricated uniform mount table) against the facts it must reproduce — the
-    // generation-side complement of the verify-side boundary check. Empty (single
-    // /task, or a design that pins no shared boundary) ⇒ no-op.
+    // The DETERMINISTIC half of critique: six scanners, each finding a defect the
+    // model does not self-discover reliably, each forced into the rewrite and each
+    // overriding a CLEAN triage. They live as rows in CRITIQUE_PROBES
+    // (critique-probes.ts) so the override and the merge below are DERIVED from
+    // the table rather than retyped — a probe used to be listed by hand in three
+    // places, and forgetting the override term shipped the very defect it was
+    // added to catch.
+    //
+    // The contract registry is read here rather than inside the table because the
+    // critique PROMPT needs it too (run-8 F3): threading the design's pinned
+    // interface facts into the rewrite lets it RECONCILE a synthesized wiring
+    // specific against the facts it must reproduce — the generation-side
+    // complement of the verify-side boundary check.
     const registryRaw = await readContracts(deps.cwd).catch(() => '');
     const contractsBlock = buildContractsVerifyBlock(registryRaw);
-    // DETERMINISTIC synthesized-wiring probe (run-8 F3, generation side). The registry
-    // alone is a WEAK catcher (live A/B: prompt+registry ~1/8) — the model's attention
-    // goes to the obvious VERIFY weakness and it rarely does the path-composition
-    // reasoning. The scanner NAMES the inferred mount mappings and juxtaposes the
-    // verbatim pinned facts, forcing focused reconciliation (probe+rule pattern, same
-    // lever as skip-escape / substitution-probe). FP-clean (1/18 files on the run-8
-    // trees). Grounding = the registry ∪ any design doc the spec/refined @-reference.
-    const wiring = registryRaw.trim().length > 0 ?
-        findSynthesizedWiring(spec, registryRaw + '\n' + readReferencedDocs(deps.cwd, refined, spec), registryRaw)
-        : [];
-    const wiringProbe = wiring.length > 0 ? wiringProbeText(wiring, registryRaw) : null;
-    if (wiringProbe) {
-        deps.logDebug?.(`synthesized wiring flagged in spec: ${wiring.map(w => w.line).join(' | ')}`);
-    }
-    // DETERMINISTIC plan-contradiction probe (mx5 run 11, goal D): a VERIFY line
-    // asserting the ABSENCE of an artifact the plan pins elsewhere — a path a prior
-    // task already shipped to disk, a sibling title's deliverable, a contract-pinned
-    // boundary. Run 11: the scope fence leaked into TASK_0009's verify as "the admin
-    // page must NOT exist" (TASK_0008's deliverable); the guaranteed FAIL became an
-    // accepted debt that the final-gate autofix then "fixed" by deleting the sibling's
-    // work. The conflict must die here, at spec time — forced into the rewrite like
-    // the skip-escape finding; delete-tasks keep their check by declaring the delete.
-    const absenceConflicts = findAbsenceConflicts(spec, {
-        fileExists: p => existsSync(resolve(deps.cwd, p)),
-        siblingTitles: siblingTitlesFromPlanContext(planContext),
-        contracts: registryRaw
-    });
-    const absenceProbe = absenceConflicts.length > 0 ? absenceProbeText(absenceConflicts) : null;
-    if (absenceProbe) {
-        deps.logDebug?.('plan-contradiction flagged in VERIFY: '
-            + absenceConflicts.map(c => `${c.assertion.target} (${c.against})`).join(' | '));
-    }
-    // DETERMINISTIC unsatisfiable-pair probe (mx5 run 12 root cause): a blanket
-    // frozen path ("Do NOT modify `tsconfig.json` … handled in steps 1–2") whose
-    // registration edit the spec's OWN body — or the task's RESEARCH the spec was
-    // composed from (live drafts sometimes drop the nuance while shipping the
-    // freeze and the creation) — says the deliverable requires ("must also be
-    // included …"). Shipped as-is, the created files turn the repo-wide static
-    // check permanently red and no task is allowed to fix it — every later task
-    // burns its AUTOFIX rounds on it. Forced into the rewrite like the other
-    // probes: the rewrite must grant scoped ownership or drop the creation.
-    const frozenConflicts = findFrozenPathConflicts(spec, research);
-    const frozenProbe = frozenConflicts.length > 0 ? frozenConflictProbeText(frozenConflicts) : null;
-    if (frozenProbe) {
-        deps.logDebug?.('unsatisfiable freeze/requires-edit pair flagged in spec: '
-            + frozenConflicts.map(c => c.path).join(' | '));
-    }
-    // DETERMINISTIC grep-theater probe (mx5 run 13, Bug B): a VERIFY block that
-    // grep-asserts the SOURCE of a runnable deliverable while every command in
-    // the block is static inspection — the build script "verified" by three
-    // greps that was never run, shipping broken for 14 tasks. Forced into the
-    // rewrite like the skip-escape finding: VERIFY must EXECUTE the artifact
-    // and assert an observable outcome of that run.
-    const grepOnly = findGrepOnlyVerify(spec);
-    const grepOnlyProbe = grepOnly.length > 0 ? grepOnlyVerifyDefectText(grepOnly) : null;
-    if (grepOnlyProbe) {
-        deps.logDebug?.('grep-theater VERIFY flagged in spec: ' + grepOnly.map(f => f.target).join(' | '));
-    }
-    // DETERMINISTIC neutered-check-script probe (mx5 run 13, PROMPT 4 item 4): a
-    // spec that DICTATES a check script which cannot fail — `"lint": "… || true"`,
-    // or a checker laundered through an inverted grep. Whatever task implements
-    // that spec writes the disarmed script into package.json, and from then on
-    // every gate that runs it (repo-health verify, the final integration gate)
-    // reads a constant. Cheapest to kill here, in the spec, before it is authored.
-    const scriptEscapes = findScriptEscapesInText(spec);
-    const scriptProbe = scriptEscapes.length > 0 ? scriptEscapeDefectText(scriptEscapes) : null;
-    if (scriptProbe) {
-        deps.logDebug?.('neutered check script dictated by spec: ' + scriptEscapes.map(f => f.name).join(' | '));
-    }
+    const probes = collectCritiqueDefects({
+        spec,
+        refined,
+        ...(research === undefined ? {} : { research }),
+        cwd: deps.cwd,
+        registryRaw,
+        ...(planContext === undefined ? {} : { planContext })
+    }, deps.logDebug);
     let triageDefects = null;
     if (parseVerifyBlock(spec) !== null) {
         const tTriage = Date.now();
@@ -1472,19 +1417,12 @@ extraDefects) {
         }
         deps.recordSubStep?.('triage', Date.now() - tTriage);
         if (verdict !== null) {
-            // A deterministic skip-escape, synthesized-wiring, plan-contradiction,
-            // unsatisfiable-pair, grep-theater, or neutered-check-script finding
-            // overrides a CLEAN triage: the draft must be rewritten to resolve it
-            // even if the model judged the rest clean (the model does not
-            // self-discover any of them reliably).
+            // ANY deterministic finding overrides a CLEAN triage: the draft must be
+            // rewritten to resolve it even if the model judged the rest clean (the
+            // model does not self-discover any of them reliably). Derived from the
+            // table, so a new probe joins this rule by existing.
             if (isCritiqueClean(verdict)) {
-                if (skipDefects === null
-                    && wiringProbe === null
-                    && absenceProbe === null
-                    && frozenProbe === null
-                    && grepOnlyProbe === null
-                    && scriptProbe === null
-                    && (extraDefects ?? null) === null) {
+                if (!probes.forced && (extraDefects ?? null) === null) {
                     return spec;
                 }
             }
@@ -1493,21 +1431,9 @@ extraDefects) {
             }
         }
     }
-    // Merge the deterministic skip-escape + synthesized-wiring + plan-contradiction
-    // + unsatisfiable-pair + grep-theater + neutered-script defects with any triage
-    // defects for the rewrite (all are forced FOCUS items).
-    const rewriteDefects = [
-        skipDefects,
-        wiringProbe,
-        absenceProbe,
-        frozenProbe,
-        grepOnlyProbe,
-        scriptProbe,
-        extraDefects ?? null,
-        triageDefects
-    ]
-        .filter(Boolean)
-        .join('\n\n') || null;
+    // Merge every deterministic defect with any triage defects for the rewrite
+    // (all are forced FOCUS items).
+    const rewriteDefects = [...probes.blocks, extraDefects ?? null, triageDefects].filter(Boolean).join('\n\n') || null;
     const tRewrite = Date.now();
     try {
         return await runWithEmphasisRetry(deps, 'critique', 'read', problem => {
@@ -1526,13 +1452,14 @@ extraDefects) {
             if (parseVerifyBlock(stripped) === null) {
                 return { ok: false, problem: 'no_verify_block' };
             }
-            // Detector-backed closure on the grep-theater defect: when the
-            // draft was flagged, the rewrite must actually resolve it (live
-            // A/B: 1/5 rewrites ignored the injected defect and re-shipped
-            // the grep-only block). One emphasis retry with a targeted hint;
+            // Detector-backed closure: a rewrite HANDED a defect and shipping
+            // it anyway is a failed rewrite. Only probes that actually fired
+            // are re-checked — a defect the draft never had is not the
+            // rewrite's to resolve. One emphasis retry with a targeted hint;
             // a second miss falls back to the draft in critiqueWithFallback.
-            if (grepOnlyProbe !== null && findGrepOnlyVerify(stripped).length > 0) {
-                return { ok: false, problem: 'verify_grep_theater' };
+            const unresolved = probes.unresolvedIn(stripped);
+            if (unresolved !== null) {
+                return { ok: false, problem: unresolved };
             }
             return { ok: true, value: stripped };
         }, problem => new Error(problem));

package/dist/task/plan-session.d.ts

@@ -30,7 +30,10 @@
  * is unit-testable without a TUI or a model.
  */
 import type { AskSpec } from '../remote/bridge.js';
-import { type PlanEntry, type AnswerSource } from './plan-io.js';
+import { type PlanEntry } from './plan-io.js';
+import { type PendingQuestion } from './question-dialog.js';
+export { resolveAnswer } from './question-dialog.js';
+export type { PendingQuestion } from './question-dialog.js';
 /**
  * Sentinel values the picker resolves to when the user takes a control action
  * instead of answering. Deliberately shaped like the existing `USER_CANCELLED`
@@ -172,16 +175,6 @@ export type PlanOutcome = {
     kind: 'cancelled';
     entries: PlanEntry[];
 };
-interface PendingQuestion {
-    /** Plain text — persisted, and fed back to the model. */
-    plain: string;
-    /** Markdown-rendered — displayed. */
-    shown: string;
-    suggested?: string;
-    shownSuggested?: string;
-    alt?: string;
-    shownAlt?: string;
-}
 /**
  * Build the picker for a pending model question: the recommendation first (index
  * 0 is the green RECOMMENDED card), the alternative second when the question is a
@@ -200,18 +193,7 @@ export declare function buildQuestionSpec(p: PendingQuestion): PlanAskSpec;
  * planning, so it never sits where a reflexive first-item press can hit it.
  */
 export declare function buildIdleSpec(): PlanAskSpec;
-/**
- * Map what the picker returned onto the answer that gets recorded. Mirrors the
- * identical mapping in phaseGrill and planAuto: an empty submit accepts the
- * recommendation, a bare "A"/"B" from a remote user or the free-text fallback maps
- * back to the option's full text, and anything else is taken verbatim.
- */
-export declare function resolveAnswer(p: PendingQuestion, raw: string): {
-    answer: string;
-    source: AnswerSource;
-};
 /** Copy for the dialog that collects the user's own question. */
 export declare const ASK_TITLE = "Ask the model";
 export declare const ASK_QUESTION = "What do you want to ask about this task? The answer is recorded as a note; it does not decide anything by itself.";
 export declare function runPlanSession(deps: PlanSessionDeps): Promise<PlanOutcome>;
-export {};

package/dist/task/plan-session.js

@@ -34,6 +34,8 @@ import { stripInlineMarkdown } from './inline-markdown.js';
 import { isDuplicateQuestion, DUP_REPROMPT_HINT, MAX_DUP_STRIKES } from './question-dedup.js';
 import { yoloPickAnswer } from './yolo.js';
 import { formatPlanTranscript } from './plan-io.js';
+import { buildOptionCards, resolveAnswer } from './question-dialog.js';
+export { resolveAnswer } from './question-dialog.js';
 // ─── Control actions ─────────────────────────────────────────────────────────
 /**
  * Sentinel values the picker resolves to when the user takes a control action
@@ -169,6 +171,7 @@ export function planForkHint(question) {
         + 'time emit BOTH lines:\nSUGGESTED: <the option you recommend>\nALT: <the other option>\n'
         + 'Nothing else.]');
 }
+// ─── Pending question ────────────────────────────────────────────────────────
 /**
  * Build the picker for a pending model question: the recommendation first (index
  * 0 is the green RECOMMENDED card), the alternative second when the question is a
@@ -178,14 +181,7 @@ export function planForkHint(question) {
  * trailing "proceed to execution" card so proceed stays last.
  */
 export function buildQuestionSpec(p) {
-    const options = [];
-    if (p.suggested !== undefined && p.alt !== undefined) {
-        options.push({ label: `A: ${p.shownSuggested ?? p.suggested}`, value: p.suggested });
-        options.push({ label: `B: ${p.shownAlt ?? p.alt}`, value: p.alt });
-    }
-    else if (p.suggested !== undefined) {
-        options.push({ label: p.shownSuggested ?? p.suggested, value: p.suggested });
-    }
+    const options = buildOptionCards(p) ?? [];
     const actions = [
         { label: PLAN_ASK_LABEL, value: PLAN_ASK },
         { label: PLAN_PROCEED_LABEL, value: PLAN_PROCEED }
@@ -235,31 +231,6 @@ export function buildIdleSpec() {
         manualPosition: actions.length - 1
     };
 }
-/**
- * Map what the picker returned onto the answer that gets recorded. Mirrors the
- * identical mapping in phaseGrill and planAuto: an empty submit accepts the
- * recommendation, a bare "A"/"B" from a remote user or the free-text fallback maps
- * back to the option's full text, and anything else is taken verbatim.
- */
-export function resolveAnswer(p, raw) {
-    const typed = raw.trim();
-    const twoOption = p.suggested !== undefined && p.alt !== undefined;
-    if (typed.length === 0 && p.suggested !== undefined) {
-        return { answer: p.suggested, source: 'accepted' };
-    }
-    if (typed.length === 0)
-        return { answer: '(skipped)', source: 'skipped' };
-    if (twoOption && /^a[.)]?$/i.test(typed))
-        return { answer: p.suggested, source: 'chosen' };
-    if (twoOption && /^b[.)]?$/i.test(typed))
-        return { answer: p.alt, source: 'chosen' };
-    if (p.suggested !== undefined && typed === p.suggested) {
-        return { answer: p.suggested, source: twoOption ? 'chosen' : 'accepted' };
-    }
-    if (p.alt !== undefined && typed === p.alt)
-        return { answer: p.alt, source: 'chosen' };
-    return { answer: typed, source: 'typed' };
-}
 // ─── The loop ────────────────────────────────────────────────────────────────
 /** Copy for the dialog that collects the user's own question. */
 export const ASK_TITLE = 'Ask the model';

package/dist/task/question-dialog.d.ts

@@ -0,0 +1,71 @@
+/**
+ * question-dialog — the one-question-at-a-time picker shared by the three places
+ * that ask the user to settle a fork: `/task`'s grill phase, `/task-auto`'s
+ * clarify loop, and the Plan session.
+ *
+ * All three do the same thing. Strip markdown for storage and render it for
+ * display; decide whether the question is a binary fork; short-circuit under
+ * YOLO; build `A: …` / `B: …` cards; call `ui.ask`; treat `undefined` as a
+ * cancel; and map the reply back onto an answer — where an empty submit accepts
+ * the recommendation, a bare "A"/"B" from a remote user (or the picker's
+ * free-text fallback) maps back to the option's full text, and anything else is
+ * taken verbatim.
+ *
+ * The mapping is the load-bearing part. Storing the literal letter "A" leaves the
+ * next generation call a dangling reference it cannot decode, so getting it wrong
+ * is not cosmetic.
+ *
+ * It was written three times. The Plan session factored its copy into a pure
+ * `resolveAnswer` returning a typed `AnswerSource`, and its own docstring said so
+ * out loud — "Mirrors the identical mapping in phaseGrill and planAuto" — but the
+ * two mirrors were never converted, and they had already drifted apart in three
+ * ways (which of them stamps an accepted recommendation, which has a
+ * single-option card branch, which handles a typed reply that equals an option).
+ * None was a crash. The next edit to any of them is where the bug lands, which is
+ * why they now share this.
+ *
+ * What stays at the call sites is POLICY, not mechanics: grill's auto-answer and
+ * widget line, clarify's plan-shape and triage pre-emption, plan's control
+ * actions. Those genuinely differ.
+ */
+import type { AnswerSource } from './plan-io.js';
+/** One question awaiting an answer, in both the stored and the displayed form. */
+export interface PendingQuestion {
+    /** Plain text — persisted, and fed back to the model. */
+    plain: string;
+    /** Markdown-rendered — displayed. */
+    shown: string;
+    suggested?: string;
+    shownSuggested?: string;
+    alt?: string;
+    shownAlt?: string;
+}
+/** True when the question is a binary fork rather than a single recommendation. */
+export declare function isTwoOption(p: PendingQuestion): boolean;
+/**
+ * The answer cards: the recommendation first (index 0 is the green RECOMMENDED
+ * card), the alternative second when the question is a fork. `undefined` — not an
+ * empty array — when there is nothing to recommend, because that is what makes
+ * `ui.ask` fall back to a bare text prompt instead of an empty picker.
+ */
+export declare function buildOptionCards(p: PendingQuestion): Array<{
+    label: string;
+    value: string;
+}> | undefined;
+/**
+ * Map what the picker returned onto the answer that gets recorded, and say WHERE
+ * the answer came from.
+ *
+ * The `source` is returned rather than baked into the string because the three
+ * call sites disagree about provenance stamping, and that disagreement is real:
+ * `/task-auto`'s clarify transcript marks an accepted recommendation
+ * ("… (accepted recommendation)") while grill's does not, because grill's
+ * transcript is fed back verbatim into the next grill-gen prompt and the stamp
+ * would become model input. Keeping the stamp at the call site makes that a
+ * one-line difference you can see instead of a divergence hidden inside two
+ * six-branch ladders.
+ */
+export declare function resolveAnswer(p: PendingQuestion, raw: string): {
+    answer: string;
+    source: AnswerSource;
+};