@mjasnikovs/pi-task 0.17.3 → 0.17.5

package/dist/task/auto-orchestrator.js

@@ -8,9 +8,10 @@
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { gateRunTask } from './orchestrator.js';
-import { parseClarifyList, deriveTitle } from './parsers.js';
+import { parseClarifyList, parseAutoAnswer, autoAnswerHasTag, deriveTitle } from './parsers.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT } from './auto-prompts.js';
+import { GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT } from './prompts.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
@@ -54,6 +55,56 @@ function logPlanDebug(cwd, msg) {
         .then(() => fsp.appendFile(path.join(dir, 'plan-debug.log'), line))
         .catch(() => { });
 }
+/**
+ * Clarify's answer-side TRIAGE — the second stage /task-auto's clarify gate was
+ * missing that /task's grill already had. /task-auto's clarify was single-stage:
+ * it generated a question and went straight to the user, with the gen prompt's
+ * own "do not re-ask what the spec settles" prose as the only guard — and a weak
+ * local model ignores that prose, surfacing questions the inlined spec already
+ * answers (the "use Hono's Bun adapter or node adapter?" question when the spec
+ * pins the Bun adapter outright).
+ *
+ * grill is gen → AUTO-ANSWER triage → user; clarify was gen → user. This runs
+ * grill's exact triage (ALREADY-DECIDED → FUNCTIONAL-REQUIREMENT → reversibility,
+ * see GRILL_AUTO_ANSWER_PROMPT) against the inlined spec BEFORE a question reaches
+ * the user. If the spec already settles the answer (or it's a cheap-to-undo
+ * default the user would accept without thinking), the question is auto-resolved
+ * and never shown — the resolved value still flows into the clarify transcript so
+ * decompose sees the decision and the next gen call won't re-ask it. Only a
+ * genuine UNKNOWN — a fork the spec leaves open — survives to the user.
+ *
+ * Returns the auto-resolved answer string when the question is settled, or null
+ * to surface it. The source fed to the triage is the feature spec itself; there
+ * is no per-feature research blob at this pre-decomposition stage (each task does
+ * its own research downstream), so the "Research" slot is a stub. Best-effort: a
+ * throw or an untagged reply falls back to surfacing the question (the prior
+ * behavior), never dropping it silently.
+ */
+async function triageClarifyQuestion(deps, cwd, featureForModel, question) {
+    try {
+        const basePrompt = GRILL_AUTO_ANSWER_PROMPT(featureForModel, '(none — clarify runs before decomposition; each task researches itself later)', question);
+        let text = await deps.runChild('clarify-triage', 'read', basePrompt);
+        if (!autoAnswerHasTag(text)) {
+            // No ANSWER/UNKNOWN/ALT tag — the model wrote prose. Reprompt once for
+            // the tagged form before trusting parseAutoAnswer's lenient salvage,
+            // exactly as phaseAutoAnswer does, so a preamble line can't masquerade
+            // as a decision.
+            text = await deps.runChild('clarify-triage', 'read', prependHint(GRILL_AUTO_FORMAT_HINT, basePrompt));
+        }
+        const parsed = parseAutoAnswer(text);
+        if (parsed.kind === 'answered') {
+            logPlanDebug(cwd, `clarify-triage auto-resolved (spec-settled): ${question.replace(/\s+/g, ' ').slice(0, 100)}`
+                + ` → ${parsed.text.replace(/\s+/g, ' ').slice(0, 100)}`);
+            return parsed.text;
+        }
+        return null;
+    }
+    catch {
+        // Triage is a best-effort filter, not a gate: on any failure, surface the
+        // question rather than silently dropping it.
+        return null;
+    }
+}
 /**
  * Expand any @file references in the feature text by appending each referenced
  * file's contents, so the planning children (clarify, decompose) always see the
@@ -186,8 +237,10 @@ export async function planAuto(ctx, cwd, feature, deps) {
     // otherwise the model's recommendation is shown as the input placeholder and
     // in the title. Nothing is pre-filled into the editor — submitting an empty
     // field is what accepts the recommendation (see the typed.length === 0 branch
-    // below); typing overrides it. We never auto-answer; the model emits NONE when
-    // nothing remains.
+    // below); typing overrides it. Each generated question first runs the
+    // answer-side TRIAGE (triageClarifyQuestion): a question the inlined spec
+    // already settles is auto-resolved and never shown — only genuine open forks
+    // reach the user. The model emits NONE when nothing remains.
     const theme = ctx.ui.theme;
     const ui = new SessionUI(ctx);
     // Inline any @file spec the user referenced so clarify/decompose reason over
@@ -242,6 +295,16 @@ export async function planAuto(ctx, cwd, feature, deps) {
         const shownQ = renderInlineMarkdown(question, theme);
         const plainQ = stripInlineMarkdown(question);
         askedQuestions.push(plainQ);
+        // Answer-side triage (grill parity): if the inlined spec already settles
+        // this question, auto-resolve it and never show it. The resolved value is
+        // recorded so decompose sees the decision and the next gen call's priorQA
+        // won't re-ask it.
+        const autoResolved = await triageClarifyQuestion(deps, cwd, featureForModel, plainQ);
+        if (autoResolved !== null) {
+            answers.push(`Q${answers.length + 1}: ${plainQ}\n`
+                + `A${answers.length + 1}: ${autoResolved} (auto-resolved — already settled by the spec)`);
+            continue;
+        }
         const plainSuggested = suggested === undefined ? undefined : stripInlineMarkdown(suggested);
         const plainAlt = alt === undefined ? undefined : stripInlineMarkdown(alt);
         // Identical to /task's grill dialog: a recommendation (or A/B fork)

package/dist/task/prompts.js

@@ -222,6 +222,14 @@ LIVE-DATA RULE:
 - "### freshness-check skipped" → tag UNKNOWN and say current state needs verification.
 - No npm block + question is about latest/current version → tag UNKNOWN (training data goes stale).
 
+TRIAGE — run these checks IN ORDER first. The REVERSIBILITY TEST below applies ONLY to a question that survives all checks as a genuine preference.
+
+1. ALREADY-DECIDED CHECK — scan the refined task and research for a value, shape, response body, schema, route, or requirement that ALREADY determines the answer. If one does, this is a fact, not a preference. Emit "ANSWER: <value taken from that source>". If your instinct or a "nicer" alternative contradicts that source, the SOURCE WINS — never override a stated contract with a preferred default. (E.g. a stated response shape { items, total, page, pageSize } already answers a pagination question — page/offset — you may NOT answer "cursor".)
+
+2. FUNCTIONAL-REQUIREMENT CHECK — if the question is whether to include or defer a package, config file, or setup that something THIS task configures needs in order to FUNCTION (a build plugin's engine or required peer dependency, an entry file the build reads, a runtime module an import resolves to), then a "minimize / keep it minimal / defer to the step that uses it" preference does NOT override that functional requirement. A tool you wire up this step must have its required pieces present this step or the build/step is broken. Emit "ANSWER: <include it now, because configuring X requires it>". Do not defer something the step's own configuration depends on.
+
+3. PREFERENCE — only if neither check fires (a genuine choice the sources do not determine), apply the REVERSIBILITY TEST.
+
 REVERSIBILITY TEST:
   ANSWER: cheap to undo (output style, policy, report format, obvious scope, standard convention).
   UNKNOWN: costly to reverse (file mutations, tool/dependency choice, approach/algorithm, format that shapes downstream artifacts).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.17.3",
+    "version": "0.17.5",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",