@ordewell/core 0.4.9 → 0.4.11

package/dist/index.mjs

@@ -13,23 +13,30 @@ import {
   resolveTaskMode,
   runnerModesFrom,
   validatePlanModification
-} from "./chunk-YXAIQKVE.mjs";
+} from "./chunk-UEJ3SZQ7.mjs";
 import {
+  UPDATABLE_FIELDS,
   applyTaskOps,
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
+  clampThinkingEffort,
   classifyOutcome,
+  coerceAssignments,
   dependencyCandidates,
   dependentsOf,
+  effectiveAllowlist,
+  filterModelsForPrompt,
   parseTaskOpsJson,
   summarizeToolCall,
-  textHasTaskOps
-} from "./chunk-4KIWPW4K.mjs";
+  textHasTaskOps,
+  validateTaskEdit
+} from "./chunk-DNNZGH3I.mjs";
 import {
   PLAN_ENVELOPE_KEY,
   PlanParseError,
   TASK_OPS_ENVELOPE_KEY,
+  TASK_QUERY_ENVELOPE_KEY,
   addTaskToPlan,
   createEmptyPlan,
   createTask,
@@ -39,6 +46,7 @@ import {
   extractObjectWithBalance,
   extractObjectsWithKey,
   flattenTasks,
+  flattenTasksWithParents,
   migrateLegacyPlan,
   migratePlanState,
   migrateTask,
@@ -49,7 +57,11 @@ import {
   updateTaskInPlan,
   validateModifiedPlan,
   warningsText
-} from "./chunk-SRGQBGI5.mjs";
+} from "./chunk-N6HTBUKG.mjs";
+import {
+  resolveOrderLabel,
+  taskOrderLabel
+} from "./chunk-HPNUFBIT.mjs";
 
 // src/interfaces/IFileSystem.ts
 var GREP_DEFAULT_HEAD_LIMIT = 100;
@@ -2568,7 +2580,7 @@ function redactSecrets(text) {
     const { value, tail } = trimTrailingPunctuation(raw);
     if (value.length < 8) return full;
     if (looksLikeCode(value) || value.startsWith("$")) return full;
-    if (UNAMBIGUOUS_CREDENTIAL_NAME.test(head) && /\d/.test(value)) {
+    if (UNAMBIGUOUS_CREDENTIAL_NAME.test(head) && (/\d/.test(value) || value.length >= 12)) {
       return `${head}${quote}${marker("credential", value.length)}${quote}${tail}`;
     }
     if (IDENTIFIER.test(value) || SLUG.test(value)) return full;
@@ -2607,33 +2619,33 @@ function grepOptions(args) {
   };
 }
 var STOPPED_TOOL_RESULT = "Stopped by the user \u2014 this call was not executed, and no further tool calls will run this turn.";
-async function executeTool(name, args, fs10, fetcher, signal) {
-  const outcome = await runTool(name, args, fs10, fetcher, signal);
+async function executeTool(name, args, fs12, fetcher, signal) {
+  const outcome = await runTool(name, args, fs12, fetcher, signal);
   return { ...outcome, output: redactSecrets(outcome.output) };
 }
-async function runTool(name, args, fs10, fetcher, signal) {
+async function runTool(name, args, fs12, fetcher, signal) {
   if (signal?.aborted) return { success: false, output: STOPPED_TOOL_RESULT, truncated: false };
   switch (name) {
     case "read_file": {
       const offset = num(args.offset);
       const limit = num(args.limit);
       const maxBytes = num(args.maxBytes);
-      return fs10.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
+      return fs12.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
     }
     case "read_files": {
       const paths = Array.isArray(args.paths) ? args.paths.map(String) : [];
-      return fs10.readFiles(paths);
+      return fs12.readFiles(paths);
     }
     case "glob":
-      return fs10.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
+      return fs12.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
     case "grep":
-      return fs10.grep(String(args.pattern ?? ""), grepOptions(args));
+      return fs12.grep(String(args.pattern ?? ""), grepOptions(args));
     case "find_symbol":
-      return fs10.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
+      return fs12.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
     case "list_dir":
-      return fs10.listDir(String(args.path ?? ""), num(args.depth));
+      return fs12.listDir(String(args.path ?? ""), num(args.depth));
     case "bash":
-      return fs10.bash(String(args.command ?? ""), signal);
+      return fs12.bash(String(args.command ?? ""), signal);
     case "fetch": {
       if (!fetcher) return { success: false, output: "Web fetching is not available in this environment.", truncated: false };
       const url = String(args.url ?? "");
@@ -3716,14 +3728,7 @@ import { v4 as uuidv4 } from "uuid";
 
 // src/services/plannerModes.ts
 var MODE_TOGGLES = [
-  // Both of these interview the user, and a one-shot run has nobody to ask —
-  // its prompt says so outright. Their absence there is a decision, not a gap.
-  { id: "grill-me", settingsKey: "grillMe", runtimeKey: "grillMeEnabled", scopes: ["chat"] },
-  { id: "prd", settingsKey: "prd", runtimeKey: "prdEnabled", scopes: ["chat"] },
-  // Structural: append a final review task. Nothing about it needs a dialogue.
-  { id: "review", settingsKey: "review", runtimeKey: "reviewEnabled", scopes: ["chat", "one-shot"] },
   { id: "verify", settingsKey: "verification", runtimeKey: "verificationEnabled", scopes: ["chat", "one-shot"] },
-  { id: "research-subagents", settingsKey: "researchSubagents", runtimeKey: "researchSubagentsEnabled", scopes: ["chat", "one-shot"] },
   { id: "tdd", settingsKey: "tdd", runtimeKey: "tddEnabled", scopes: ["task"] }
 ];
 function plannerRuntimeToggles(settings) {
@@ -3733,28 +3738,16 @@ function plannerRuntimeToggles(settings) {
 }
 var DEFAULT_PLANNER_MODES = {
   autonomousDefault: true,
-  grillMe: false,
-  prd: false,
-  review: false,
-  verification: false,
-  researchSubagents: false
+  verification: false
 };
 function plannerModesFrom(settings, autonomousDefault) {
   return {
     autonomousDefault,
-    grillMe: settings.grillMeEnabled ?? false,
-    prd: settings.prdEnabled ?? false,
-    review: settings.reviewEnabled ?? false,
-    verification: settings.verificationEnabled ?? false,
-    researchSubagents: settings.researchSubagentsEnabled ?? false
+    verification: settings.verificationEnabled ?? false
   };
 }
 var MODE_FIELD = {
-  "grill-me": "grillMe",
-  prd: "prd",
-  review: "review",
   verify: "verification",
-  "research-subagents": "researchSubagents",
   tdd: null
 };
 function modesFor(scope, modes) {
@@ -3766,8 +3759,179 @@ function modesFor(scope, modes) {
   return scoped;
 }
 
+// src/services/TaskQuery.ts
+var TASK_QUERY_FIELDS = [
+  "description",
+  "prompt",
+  "userSteps",
+  "verdict",
+  "outputSummary",
+  "userStoriesCovered"
+];
+function textHasTaskQuery(text) {
+  return text.includes(`"${TASK_QUERY_ENVELOPE_KEY}"`);
+}
+function parseTaskQueryJson(text) {
+  const { matches, fallback } = extractObjectsWithKey(text, TASK_QUERY_ENVELOPE_KEY);
+  const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];
+  let lastError = null;
+  for (const json of candidates) {
+    try {
+      return parseTaskQueryObject(json, text);
+    } catch (err) {
+      if (!(err instanceof PlanParseError)) throw err;
+      if (!lastError) lastError = err;
+    }
+  }
+  throw lastError ?? new PlanParseError("No JSON object found in task-query reply", text);
+}
+function parseTaskQueryObject(json, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(escapeControlCharsInStrings(stripTrailingCommas(json)));
+  } catch (err) {
+    throw new PlanParseError(`Task-query JSON is invalid: ${err instanceof Error ? err.message : String(err)}`, text);
+  }
+  const raw = parsed.taskQuery;
+  const body = Array.isArray(raw) ? { tasks: raw } : raw;
+  if (typeof body !== "object" || body === null) {
+    throw new PlanParseError('"taskQuery" must be an object (or an array of task references)', text);
+  }
+  const { tasks: rawTasks, fields: rawFields, catalog: rawCatalog } = body;
+  const tasks = [];
+  if (rawTasks !== void 0) {
+    if (!Array.isArray(rawTasks)) throw new PlanParseError('"tasks" in a taskQuery must be an array of task references', text);
+    for (const ref of rawTasks) {
+      if (typeof ref !== "string" && typeof ref !== "number") {
+        throw new PlanParseError(`Invalid task reference "${String(ref)}" in taskQuery`, text);
+      }
+      tasks.push(String(ref).trim());
+    }
+  }
+  let fields;
+  if (rawFields !== void 0) {
+    if (!Array.isArray(rawFields)) throw new PlanParseError('"fields" in a taskQuery must be an array of field names', text);
+    fields = [];
+    for (const f of rawFields) {
+      if (typeof f !== "string" || !TASK_QUERY_FIELDS.includes(f)) {
+        throw new PlanParseError(`Unknown taskQuery field "${String(f)}" \u2014 choose from ${TASK_QUERY_FIELDS.join(", ")}`, text);
+      }
+      fields.push(f);
+    }
+  }
+  const catalog = rawCatalog === true;
+  if (tasks.length === 0 && !catalog) {
+    throw new PlanParseError('A taskQuery must name at least one task or set "catalog": true', text);
+  }
+  return { tasks, fields, catalog };
+}
+function taskQuerySignature(query) {
+  return JSON.stringify([query.tasks, query.fields ?? null, query.catalog]);
+}
+var TASK_QUERY_ANSWER_OR_OPS = "You have now read everything you asked for. Do not send another taskQuery this turn: answer the user in prose, or emit the taskOps JSON for the change you came to make.";
+var TASK_QUERY_PROTOCOL = [
+  "READING A TASK BEFORE YOU EDIT IT:",
+  "The plan block you are shown each turn carries only short fields \u2014 it never contains a task's prompt, its user steps, or a completed task's verdict. Never rewrite a field you have not read. To read one, reply with ONLY this JSON object:",
+  `  {"${TASK_QUERY_ENVELOPE_KEY}":{"tasks":["<id or #order>", "..."],"fields":[${TASK_QUERY_FIELDS.map((f) => `"${f}"`).join(", ")}],"catalog":true}}`,
+  '- "tasks": one or more task references. Ask for everything you need in ONE query \u2014 each query costs a round-trip.',
+  '- "fields": optional. Omit it to get every field above.',
+  '- "catalog": optional. Set it to true for the full runner and model catalog \u2014 every model id with its label and thinking-effort variants, and every task mode with its description. It works before any task exists, and may be used on its own.',
+  "Ordewell answers immediately with the detail and changes nothing. Then reply again with your taskOps JSON, or with prose for the user.",
+  "Three queries per user message; after that every answer also tells you to land the turn. Do not ask the same question twice."
+];
+var TASK_QUERY_REMINDER = `- To READ a task in full (prompt, user steps, verdict, output, user stories) or the whole model/mode catalog before editing, reply with ONLY {"${TASK_QUERY_ENVELOPE_KEY}":{"tasks":["<id or #order>"],"catalog":true}} \u2014 it changes nothing, and you then reply again with your ops.`;
+function findTask(tasks, ref) {
+  const byId = tasks.find((t) => t.id === ref);
+  if (byId) return byId;
+  const orderStr = ref.startsWith("#") ? ref.slice(1) : ref;
+  if (/^\d+$/.test(orderStr)) {
+    const byOrder = tasks.filter((t) => t.order === Number(orderStr));
+    if (byOrder.length === 1) return byOrder[0];
+  }
+  return tasks.find((t) => t.title === ref);
+}
+function renderField(task, field) {
+  switch (field) {
+    case "description":
+      return [`description: ${task.description || "(none)"}`];
+    case "prompt":
+      return task.prompt ? ["prompt:", task.prompt] : ["prompt: (none)"];
+    case "userSteps": {
+      const steps = task.userSteps ?? [];
+      if (steps.length === 0) return ["userSteps: (none)"];
+      return ["userSteps:", ...steps.map((s) => `  ${s.order}. [${s.completed ? "x" : " "}] ${s.instruction}`)];
+    }
+    case "verdict": {
+      const v = task.verdict;
+      if (!v) return ["verdict: (none)"];
+      const checks = v.checks.map((c) => `${c.name}=${c.skipped ? "skipped" : c.passed ? "pass" : "fail"}`).join(", ");
+      return [`verdict: ${v.outcome.toUpperCase()} \u2014 ${v.reason}${checks ? ` [${checks}]` : ""}`];
+    }
+    case "outputSummary": {
+      const o = task.outputSummary;
+      if (!o) return ["outputSummary: (none)"];
+      return [`outputSummary: ${o.reviewReason}`, ...o.logTail ? ["log tail:", o.logTail] : []];
+    }
+    case "userStoriesCovered": {
+      const stories = task.userStoriesCovered ?? [];
+      if (stories.length === 0) return ["userStoriesCovered: (none)"];
+      return ["userStoriesCovered:", ...stories.map((s) => `  - ${s}`)];
+    }
+  }
+}
+function renderTask(task, fields) {
+  return [
+    `#${task.order} id=${task.id} "${task.title}" [${task.status}] type:${task.type === "user" ? "MAN" : "AI"}`,
+    ...fields.flatMap((f) => renderField(task, f)),
+    ""
+  ];
+}
+function renderCatalog(catalog) {
+  const lines = [];
+  for (const runner of catalog.runners) {
+    const models = catalog.models[runner] ?? [];
+    lines.push(`${runner} models:`);
+    if (models.length === 0) lines.push("  (none discovered)");
+    for (const m of models) {
+      const variants = m.variants?.length ? ` variants: ${m.variants.map((v) => `${v.id}${v.label && v.label !== v.id ? ` (${v.label})` : ""}`).join(", ")}` : " variants: none";
+      lines.push(`  - ${m.modelId} \u2014 ${m.modelLabel}${variants}`);
+    }
+    const modes = catalog.modes[runner] ?? [];
+    lines.push(`${runner} task modes:`);
+    if (modes.length === 0) lines.push("  (none declared)");
+    const defaultId = resolveDefaultMode(modes, catalog.autonomousDefault);
+    for (const mode of modes) {
+      lines.push(`  - ${mode.id} \u2014 ${mode.label}: ${mode.description}${mode.id === defaultId ? " (default)" : ""}`);
+    }
+  }
+  return lines;
+}
+function renderTaskQueryAnswer(query, tasks, catalog) {
+  const fields = query.fields ?? TASK_QUERY_FIELDS;
+  const blocks = [];
+  if (query.tasks.length > 0) {
+    const body = [];
+    for (const ref of query.tasks) {
+      const task = findTask(tasks, ref);
+      if (!task) {
+        body.push(`${ref}: no task matches this reference in the current plan.`, "");
+        continue;
+      }
+      body.push(...renderTask(task, fields));
+    }
+    blocks.push(["<task_detail>", ...body, "</task_detail>"].join("\n"));
+  }
+  if (query.catalog) {
+    blocks.push(["<runner_catalog>", ...renderCatalog(catalog), "</runner_catalog>"].join("\n"));
+  }
+  blocks.push(
+    "That is everything you asked for. Nothing has changed. Reply now with the taskOps JSON for the edit you intended, or answer the user in prose."
+  );
+  return blocks.join("\n\n");
+}
+
 // src/services/PlanPrompts.ts
-function buildResearchToolsPrompt(subagentsEnabled = false) {
+function buildResearchToolsPrompt() {
   const lines = [
     "You have access to the following tools to explore the workspace:",
     "",
@@ -3783,15 +3947,11 @@ function buildResearchToolsPrompt(subagentsEnabled = false) {
     "- glob: for finding files by name/path pattern",
     "- grep: for searching inside file contents",
     "",
-    "When multiple independent tool calls are needed, batch them in a single response to save round-trips. For example, if you need to read README.md and AGENTS.md, call read_files with both paths at once."
+    "When multiple independent tool calls are needed, batch them in a single response to save round-trips. For example, if you need to read README.md and AGENTS.md, call read_files with both paths at once.",
+    "",
+    'spawn_research_agent(prompt: string) - Launch a stateless read-only research agent that explores the workspace with its own tools and returns a digest. Use it to delegate an open-ended exploration thread \u2014 a subsystem to map, or a "how does X work here" question \u2014 whenever one emerges during research. To explore several independent areas, launch the agents CONCURRENTLY: put multiple spawn_research_agent calls in one reply and they run in parallel.',
+    "The agent sees nothing of this conversation, so its prompt must be self-contained: the area or question, the paths/symbols to start from, and exactly what the digest must report back. Do NOT use it on small or single-subsystem repos, or to read one known file \u2014 direct tools are faster there."
   ];
-  if (subagentsEnabled) {
-    lines.push(
-      "",
-      'spawn_research_agent(prompt: string) - Launch a stateless read-only research agent that explores the workspace with its own tools and returns a digest. Use it to delegate an open-ended exploration thread \u2014 a subsystem to map, or a "how does X work here" question \u2014 whenever one emerges during research. To explore several independent areas, launch the agents CONCURRENTLY: put multiple spawn_research_agent calls in one reply and they run in parallel.',
-      "The agent sees nothing of this conversation, so its prompt must be self-contained: the area or question, the paths/symbols to start from, and exactly what the digest must report back. Do NOT use it on small or single-subsystem repos, or to read one known file \u2014 direct tools are faster there."
-    );
-  }
   return lines.join("\n");
 }
 function buildSubagentSystemPrompt() {
@@ -3829,11 +3989,11 @@ function buildModeExamplesForRunners(runners) {
     return `${r}: default|plan`;
   }).join(", ");
 }
-function verificationModeBlock(reviewAlsoEnabled = false) {
+function verificationModeBlock() {
   return [
     "",
     "VERIFICATION MODE:",
-    reviewAlsoEnabled ? "Add a FINAL verification task immediately before the review task. The review task keeps the highest order number and must list the verification task among its dependencies." : "Add a FINAL verification task to the end of the plan (highest order number).",
+    "Add a FINAL verification task to the end of the plan (highest order number).",
     'This task closes the gap between "every task finished" and "the feature is correct": tasks executed in isolated sessions can each pass while the integrated feature is still short. Its outcome must come from commands and exit codes, never from judgement.',
     "This task must:",
     '- Have type "ai" and autonomy "AFK" \u2014 it needs no human input',
@@ -3855,7 +4015,8 @@ function researchPhaseBlock(harnessMode) {
   ];
   const toolSpecific = harnessMode ? [
     "- Explore the repository with your own tools until you understand its architecture",
-    "- You are planning, not implementing: do NOT edit, create, or delete any file, and do not run commands that change the workspace"
+    "- You are planning, not implementing: do NOT edit, create, or delete any file, and do not run commands that change the workspace",
+    "- If you delegate exploration to your own agents, WAIT for their results inside this reply. Do NOT launch them in the background or async and end your turn saying you will report back later: your turn ending is what hands the conversation back to the user, and anything you say after it never reaches them."
   ] : [
     "- Use list_dir with depth=2-3 for a tree overview",
     "- Use glob and grep to find relevant source files",
@@ -3868,35 +4029,14 @@ function researchPhaseBlock(harnessMode) {
     "- Research and questions can interleave \u2014 you can explore a file, then ask a question grounded in it, in one response"
   ].join("\n");
 }
-function buildConversationSystemPrompt(goal, context, modelsByRunner, runners, runnerModes, autonomousDefault = true, grillMeEnabled = false, prdEnabled = false, reviewEnabled = false, verificationEnabled = false, harnessMode = false) {
+function buildConversationSystemPrompt(goal, context, modelsByRunner, runners, runnerModes, autonomousDefault = true, verificationEnabled = false, harnessMode = false) {
   const modelsJson = modelsJsonFor(modelsByRunner, runners);
   const modeGuide = runnerModes ? buildModeGuide(runnerModes, autonomousDefault) : buildModeGuideForRunners(runners, autonomousDefault);
   const modeExamples = runnerModes ? Object.entries(runnerModes).map(([r, ms]) => {
     const filtered = filteredBuildModes(ms, autonomousDefault);
     return `${r}: ${filtered.map((m) => m.id).join("|")}${ms.some((m) => m.id === "plan") ? "|plan" : ""}`;
   }).join(", ") : buildModeExamplesForRunners(runners);
-  const grillMeBlock = grillMeEnabled ? [
-    "",
-    "INTERVIEW MODE \u2014 GRILL-ME:",
-    "Interview the user relentlessly about every aspect of their goal until you reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one.",
-    "Ask one question at a time, waiting for the user's answer before continuing. For each question, propose your recommended answer so they can confirm or correct it. Asking multiple questions at once is bewildering.",
-    "If a fact can be found by exploring the codebase, look it up instead of asking. The decisions, though, are the user's \u2014 put each one to them and wait.",
-    "Only propose an outline after the user has answered enough questions that you genuinely understand the goal. Then present the prose outline and wait for explicit confirmation before emitting the task plan JSON."
-  ].join("\n") : "";
-  const prdBlock = prdEnabled ? [
-    "",
-    "PRD MODE: Before producing the outline, generate a PRD in two steps.",
-    "Step 1 \u2014 Propose a short prose preview containing: the problem statement, the proposed approach, the testing seams, and the main risks. Prefer existing seams over new ones; propose new seams at the highest point possible. The fewer seams across the codebase, the better \u2014 the ideal number is one. Propose a feature-slug for saving the PRD (e.g. `my-feature`). Ask the user whether they agree.",
-    "Step 2 \u2014 Only after the user explicitly agrees, write the full markdown PRD using the standard PRD format (problem, user stories, implementation decisions, testing seams, out of scope). The user may edit the proposed feature-slug before you write the PRD; use the agreed slug in the final output.",
-    'PRD content rules: user stories are an extensive numbered list, each "As an <actor>, I want <feature>, so that <benefit>". Record implementation decisions as decisions (modules, interfaces, schema changes, API contracts) \u2014 do NOT include specific file paths or code snippets; they go stale fast. Exception: a snippet from a prototype that encodes a decision more precisely than prose (state machine, reducer, schema, type shape) may be inlined, trimmed to the decision-rich parts.',
-    "When writing the full PRD, wrap it EXACTLY with these markers so the system can save it automatically:",
-    '<!-- ORDEWELL_PRD_START slug="<feature-slug>" -->',
-    "... full markdown PRD ...",
-    "<!-- ORDEWELL_PRD_END -->",
-    "Do NOT emit the full PRD before the user agrees to the preview. Do NOT emit task plan JSON before the PRD is agreed and the outline is confirmed."
-  ].join("\n") : "";
-  const reviewBlock = reviewEnabled ? reviewModeBlock() : "";
-  const verificationBlock = verificationEnabled ? verificationModeBlock(reviewEnabled) : "";
+  const verificationBlock = verificationEnabled ? verificationModeBlock() : "";
   return buildConversationBody(
     goal,
     context,
@@ -3905,34 +4045,10 @@ function buildConversationSystemPrompt(goal, context, modelsByRunner, runners, r
     modeGuide,
     modeExamples,
     harnessMode,
-    grillMeBlock,
-    prdBlock,
-    reviewBlock,
     verificationBlock
   );
 }
-function reviewModeBlock() {
-  return [
-    "",
-    "REVIEW MODE:",
-    "Add a FINAL review task to the end of the plan (highest order number).",
-    "This task must:",
-    '- Have type "ai" and use the STRONGEST available model',
-    "- Have dependencies on ALL other AI/user tasks in the plan",
-    "- Be assigned appropriately as HITL (human review) since the results need human sign-off",
-    "- Its prompt should instruct the agent to:",
-    "  * Review every completed task's outputs and verify the original goal was met",
-    "  * Check that each task delivers what its description promised",
-    "  * Review the work on two axes, reported SEPARATELY so one cannot mask the other:",
-    "    - SPEC axis: if a PRD exists for this plan (`.scratch/<slug>/PRD.md`), verify against it: (a) requirements asked for but missing or partial; (b) behaviour delivered that the PRD never asked for (scope creep); (c) requirements that look implemented but wrongly. Quote the PRD line for each finding. With no PRD, review against the original goal.",
-    "    - STANDARDS axis: check the diff against the repo's documented coding standards (CONTRIBUTING.md, CLAUDE.md, etc.) plus this smell baseline: Mysterious Name (rename), Duplicated Code (extract shared shape), Feature Envy (move method to the data), Data Clumps (bundle into a type), Primitive Obsession (give the concept a type), Repeated Switches (polymorphism or shared map), Shotgun Surgery (gather into one module), Divergent Change (split by reason to change), Speculative Generality (delete it), Message Chains (hide the walk), Middle Man (call the target direct), Refused Bequest (composition over inheritance). Smell findings are always judgement calls, never hard failures; documented repo standards override the baseline; skip anything tooling already enforces.",
-    "  * Produce a structured review report listing what was checked and whether each check passed",
-    "  * Flag any gaps, bugs, or incomplete work",
-    "  * Output a final PASS/FAIL conclusion with evidence (standards-axis judgement calls alone must not fail the verification)",
-    "- Use the same runner as the other tasks"
-  ].join("\n");
-}
-function buildConversationBody(goal, context, modelsJson, runners, modeGuide, modeExamples, harnessMode, grillMeBlock, prdBlock, reviewBlock, verificationBlock) {
+function buildConversationBody(goal, context, modelsJson, runners, modeGuide, modeExamples, harnessMode, verificationBlock) {
   return [
     "You are Ordewell's project planner. You explore the codebase, ask concise clarifying questions grounded in your findings, and produce structured task plans as JSON. Be direct: avoid unnecessary preamble, summaries, or explanations unless the user asks for detail.",
     "",
@@ -3943,9 +4059,6 @@ function buildConversationBody(goal, context, modelsJson, runners, modeGuide, mo
     '4. After the user confirms the outline, emit the final task plan as a JSON object with a "tasks" array.',
     "",
     researchPhaseBlock(harnessMode),
-    grillMeBlock,
-    prdBlock,
-    reviewBlock,
     verificationBlock,
     "",
     "OUTLINE PHASE:",
@@ -4020,6 +4133,11 @@ function buildConversationBody(goal, context, modelsJson, runners, modeGuide, mo
     "TASK MODE:",
     modeGuide,
     "",
+    // Shared by both variants on purpose: the read channel is a text envelope
+    // exactly so a harness planner, which Ordewell cannot hand tools to, speaks
+    // the same protocol as an API-backed one (ADR-0009).
+    ...TASK_QUERY_PROTOCOL,
+    "",
     context ? `PROJECT CONTEXT:
 ${context}
 ` : "",
@@ -4127,7 +4245,6 @@ function getPlanTemplate() {
     "",
     "TASK MODE:",
     "{{MODE_GUIDE}}",
-    "{{REVIEW_BLOCK}}",
     "{{VERIFICATION_BLOCK}}",
     "",
     "CONTEXT:",
@@ -4174,10 +4291,8 @@ function buildPlanPromptBase(userGoal, context, researchResults, modelsByRunner,
     const filtered = filteredBuildModes(ms, autonomousDefault);
     return `${r}: ${filtered.map((m) => m.id).join("|")}${ms.some((m) => m.id === "plan") ? "|plan" : ""}`;
   }).join(", ") : buildModeExamplesForRunners(runners);
-  return template.replace("{{RESEARCH_SECTION}}", researchReplacement).replace("{{CLARIFICATION_INSTRUCTIONS}}", ONE_SHOT_INSTRUCTIONS).replace("{{MODELS_JSON}}", modelsJson).replace("{{RUNNER_CHOICES}}", runners.join("|")).replace("{{RUNNER_INSTRUCTION}}", runnerInstruction(runners)).replace("{{MODE_GUIDE}}", modeGuide).replace("{{REVIEW_BLOCK}}", scoped.review ? `
-${reviewModeBlock()}
-` : "").replace("{{VERIFICATION_BLOCK}}", scoped.verification ? `
-${verificationModeBlock(scoped.review)}
+  return template.replace("{{RESEARCH_SECTION}}", researchReplacement).replace("{{CLARIFICATION_INSTRUCTIONS}}", ONE_SHOT_INSTRUCTIONS).replace("{{MODELS_JSON}}", modelsJson).replace("{{RUNNER_CHOICES}}", runners.join("|")).replace("{{RUNNER_INSTRUCTION}}", runnerInstruction(runners)).replace("{{MODE_GUIDE}}", modeGuide).replace("{{VERIFICATION_BLOCK}}", scoped.verification ? `
+${verificationModeBlock()}
 ` : "").replace("{{MODE_EXAMPLES}}", modeExamples).replace("{{CONTEXT}}", context || "(no additional context)").replace("{{RESEARCH_RESULTS}}", researchResults ? `
 
 RESEARCH FINDINGS:
@@ -4327,7 +4442,8 @@ function buildMergePrompt(taskIds, tasks) {
     "The merged task takes the union of their dependencies (excluding the merged tasks themselves) and preserves their user stories.",
     'Set "assignedRunner" and "assignedModel" on the merged task \u2014 use one of the runners and models listed in <available_models> above. Prefer the strongest model if the merged work is complex.',
     'Reply with ONLY a taskOps JSON object using a single "merge" op:',
-    `  {"taskOps":[{"op":"merge","taskIds":[${selected.map((t) => `"${t.id}"`).join(", ")}],"merged":{"title":"...","description":"...","prompt":"...","assignedRunner":"...","assignedModel":{"modelId":"...","modelLabel":"..."}}}]}`
+    `  {"taskOps":[{"op":"merge","taskIds":[${selected.map((t) => `"${t.id}"`).join(", ")}],"merged":{"title":"...","description":"...","prompt":"...","assignedRunner":"...","assignedModel":{"modelId":"...","modelLabel":"..."}}}]}`,
+    `If this merge needs a companion op in the same batch (e.g. an added task that should depend on the merge result), give the merge op a "handle" (any unused name) and reference it from the later op's taskId/dependencies.`
   ].join("\n");
 }
 function buildSplitPrompt(taskId, tasks) {
@@ -4339,7 +4455,8 @@ function buildSplitPrompt(taskId, tasks) {
     "The first part inherits the original task's dependencies. Each later part depends on the previous part. Tasks that depended on the original now depend on the LAST part.",
     'Set "assignedRunner" and "assignedModel" on each part \u2014 use the runners and models listed in <available_models> above. You may assign different models to different parts (e.g. a stronger model for a complex part, a faster one for a simple part).',
     'Reply with ONLY a taskOps JSON object using a single "split" op:',
-    `  {"taskOps":[{"op":"split","taskId":"${task.id}","parts":[{"title":"...","description":"...","prompt":"...","assignedRunner":"...","assignedModel":{"modelId":"...","modelLabel":"..."}},...]}]}`
+    `  {"taskOps":[{"op":"split","taskId":"${task.id}","parts":[{"title":"...","description":"...","prompt":"...","assignedRunner":"...","assignedModel":{"modelId":"...","modelLabel":"..."}},...]}]}`,
+    `If this split needs a companion op in the same batch (e.g. another task that should depend on the last part), give the split op a "handle" (any unused name) \u2014 it names the last part \u2014 and reference it from the later op's taskId/dependencies.`
   ].join("\n");
 }
 
@@ -4366,6 +4483,9 @@ function truncatedPlanReEmitPrompt(historyCompacted) {
 function reEmitTaskOpsPrompt(detail) {
   return `Your task edits could not be applied: ${detail}. Re-emit ONLY a corrected {"${TASK_OPS_ENVELOPE_KEY}":[...]} JSON object \u2014 no prose, no code fences \u2014 or reply in prose if you did not intend to edit tasks.`;
 }
+function reEmitTaskQueryPrompt(detail) {
+  return `Your task-detail request could not be read: ${detail}. Re-emit ONLY a corrected {"${TASK_QUERY_ENVELOPE_KEY}":{"tasks":["<id or #order>"],"fields"?:[...],"catalog"?:true}} JSON object \u2014 no prose, no code fences \u2014 or reply in prose if you did not mean to look anything up.`;
+}
 function taskOpsRejectedPrompt(errors) {
   return `Those task edits were rejected:
 - ${errors.join("\n- ")}
@@ -4392,6 +4512,16 @@ function classifyPlannerReply(text, opts) {
       }
     }
   }
+  if (textHasTaskQuery(text)) {
+    try {
+      return { kind: "task_query", query: parseTaskQueryJson(text) };
+    } catch (err) {
+      if (!(err instanceof PlanParseError)) throw err;
+      if (extractObjectsWithKey(text, TASK_QUERY_ENVELOPE_KEY).matches.length > 0) {
+        return { kind: "broken_task_query", error: err };
+      }
+    }
+  }
   if (text.includes(`"${PLAN_ENVELOPE_KEY}"`)) {
     try {
       return { kind: "plan", tasks: parsePlanJson(text, opts.runners, opts.runnerModes, opts.autonomousDefault) };
@@ -4525,8 +4655,8 @@ var SUBAGENT_EXCLUDED = /* @__PURE__ */ new Set(["fetch", "web_search"]);
 function subagentToolSpecs() {
   return RESEARCH_TOOLS.filter((t) => !SUBAGENT_EXCLUDED.has(t.name));
 }
-function withSpawn(includeSubagents) {
-  return includeSubagents ? [...RESEARCH_TOOLS, SPAWN_RESEARCH_AGENT_SPEC] : RESEARCH_TOOLS;
+function withSpawn() {
+  return [...RESEARCH_TOOLS, SPAWN_RESEARCH_AGENT_SPEC];
 }
 function projectOpenAi(specs) {
   return specs.map((t) => ({
@@ -4547,8 +4677,8 @@ function projectOpenAi(specs) {
     }
   }));
 }
-function toOpenAiTools(includeSubagents = false) {
-  return projectOpenAi(withSpawn(includeSubagents));
+function toOpenAiTools() {
+  return projectOpenAi(withSpawn());
 }
 function toOpenAiSubagentTools() {
   return projectOpenAi(subagentToolSpecs());
@@ -4559,8 +4689,8 @@ var SCHEMA_TYPE = {
   array: SchemaType.ARRAY,
   boolean: SchemaType.BOOLEAN
 };
-function toGeminiToolDeclarations(includeSubagents = false) {
-  return withSpawn(includeSubagents).map((t) => {
+function toGeminiToolDeclarations() {
+  return withSpawn().map((t) => {
     const properties = {};
     for (const [key, param] of Object.entries(t.properties)) {
       properties[key] = {
@@ -4657,33 +4787,10 @@ function compactResearchResults(resultsText, maxChars = COMPACTION_LIMITS.resear
   return (blocks[0].lines.length === 0 ? texts.slice(1) : texts).join("\n");
 }
 
-// src/utils/prdStore.ts
-import * as fs from "fs";
-import * as path4 from "path";
-var PRD_BLOCK_RE = /<!--\s*ORDEWELL_PRD_START\s+slug="([^"]+)"\s*-->\s*([\s\S]*?)\s*<!--\s*ORDEWELL_PRD_END\s*-->/;
-function extractPrdBlock(text) {
-  const match = PRD_BLOCK_RE.exec(text);
-  if (!match) return null;
-  const slug2 = sanitizeSlug(match[1]);
-  const markdown = match[2].trim();
-  if (!slug2 || !markdown) return null;
-  return { slug: slug2, markdown };
-}
-function sanitizeSlug(raw) {
-  return raw.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
-}
-function savePrdMarkdown(workspace, slug2, markdown) {
-  const dir = path4.join(workspace, ".scratch", sanitizeSlug(slug2));
-  fs.mkdirSync(dir, { recursive: true });
-  const file = path4.join(dir, "PRD.md");
-  fs.writeFileSync(file, markdown.endsWith("\n") ? markdown : markdown + "\n", "utf8");
-  return file;
-}
-
 // src/services/ContextCollector.ts
 var ORDEWELL_CONTEXT_MAX = 8e3;
-async function collectResearchContext(fs10, runners) {
-  const collector = new ContextCollector(fs10);
+async function collectResearchContext(fs12, runners) {
+  const collector = new ContextCollector(fs12);
   let contextStr = "";
   let firstContext = null;
   for (const r of runners) {
@@ -4710,8 +4817,8 @@ ${firstContext.dirStructure}
   return contextStr;
 }
 var ContextCollector = class {
-  constructor(fs10, registry) {
-    this.fs = fs10;
+  constructor(fs12, registry) {
+    this.fs = fs12;
     this.registry = registry;
   }
   fs;
@@ -4759,22 +4866,22 @@ var ALLOWED_TOOL_NAMES = new Set(subagentToolSpecs().map((t) => t.name));
 function refused(output) {
   return { success: false, output, truncated: false };
 }
-function nonPromptingFs(fs10) {
-  const withinWorkspace = (p) => resolveWithin(fs10.getWorkspaceRoot(), p ?? ".").inside;
+function nonPromptingFs(fs12) {
+  const withinWorkspace = (p) => resolveWithin(fs12.getWorkspaceRoot(), p ?? ".").inside;
   const outsideRefusal = (p) => refused(
     `Path "${p}" is outside the workspace. Research agents are confined to the workspace root \u2014 note the gap in your digest and let the planner request it directly.`
   );
   return {
-    getWorkspaceRoot: () => fs10.getWorkspaceRoot(),
-    readFile: (p, opts) => withinWorkspace(p) ? fs10.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
+    getWorkspaceRoot: () => fs12.getWorkspaceRoot(),
+    readFile: (p, opts) => withinWorkspace(p) ? fs12.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
     readFiles: (paths) => {
       const escaping = paths.find((p) => !withinWorkspace(p));
-      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs10.readFiles(paths);
+      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs12.readFiles(paths);
     },
-    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs10.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs10.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs10.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    listDir: (p, depth) => withinWorkspace(p) ? fs10.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
+    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs12.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs12.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs12.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    listDir: (p, depth) => withinWorkspace(p) ? fs12.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
     bash: async (command, signal) => {
       const dialect = resolveResearchShell().dialect;
       const { tier, reason } = classifyCommand(command, { dialect });
@@ -4785,13 +4892,13 @@ function nonPromptingFs(fs10) {
       }
       const escaping = pathLikeArgs(command, { dialect }).find((p) => !withinWorkspace(p));
       if (escaping) return outsideRefusal(escaping);
-      return fs10.bash(command, signal);
+      return fs12.bash(command, signal);
     }
   };
 }
 async function runLoop(prompt, deps) {
   if (deps.signal?.aborted) return "[research agent aborted before starting]";
-  const fs10 = nonPromptingFs(deps.fs);
+  const fs12 = nonPromptingFs(deps.fs);
   const chat = deps.createChat((delta) => deps.onProgress?.({ type: "thinking", text: delta }));
   let turn = await chat.sendMessage(prompt, deps.signal);
   for (let step = 0; turn.hasToolCalls && step < SUBAGENT_LIMITS.maxSteps; step++) {
@@ -4808,7 +4915,7 @@ ${turn.text}`;
       if (tc.name === "read_file" && !("maxBytes" in args) && !("limit" in args)) args.limit = 2e3;
       const toolArgs = JSON.stringify(tc.args);
       deps.onProgress?.({ type: "tool_call", tool: tc.name, toolArgs, toolCallId: tc.id });
-      const res = await executeTool(tc.name, args, fs10, void 0, deps.signal);
+      const res = await executeTool(tc.name, args, fs12, void 0, deps.signal);
       const output = res.output.length > SUBAGENT_LIMITS.toolOutputMaxChars ? res.output.slice(0, SUBAGENT_LIMITS.toolOutputMaxChars) + `
 [... truncated to ${SUBAGENT_LIMITS.toolOutputMaxChars} chars, total ${res.output.length}]` : res.output;
       const stepEntry = {
@@ -4866,8 +4973,6 @@ var BaseAiService = class _BaseAiService {
   config;
   conversation = null;
   activeAbort = null;
-  /** researchSubagents toggle (issue #34): set per operation from the live settings snapshot; off means bit-for-bit sequential behavior. */
-  researchSubagentsEnabled = false;
   hasActiveConversation() {
     return this.conversation !== null;
   }
@@ -4923,10 +5028,7 @@ var BaseAiService = class _BaseAiService {
    * steering/failed result and the loop continues sequentially: a subagent can
    * never fail a plan or a turn.
    */
-  async executeSpawnAgent(args, fs10, onProgress, signal, subagentId) {
-    if (!this.researchSubagentsEnabled) {
-      return { success: false, output: "spawn_research_agent is not available in this session. Continue researching sequentially with your other tools (read_file, glob, grep, list_dir, bash).", truncated: false };
-    }
+  async executeSpawnAgent(args, fs12, onProgress, signal, subagentId) {
     const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
     if (!prompt) {
       return { success: false, output: 'spawn_research_agent requires a non-empty "prompt" string: a self-contained task for the agent, including what its digest must report back.', truncated: false };
@@ -4937,20 +5039,20 @@ var BaseAiService = class _BaseAiService {
         if (!chat) throw new Error("subagent chats are not available for this provider");
         return chat;
       },
-      fs: fs10,
+      fs: fs12,
       signal,
       onProgress: (progress) => onProgress({ ...progress, subagentId })
     });
   }
   /** Collect project context for the planning phase. Shared with the harness backend. */
-  static async collectResearchContext(fs10, runners) {
-    return collectResearchContext(fs10, runners);
+  static async collectResearchContext(fs12, runners) {
+    return collectResearchContext(fs12, runners);
   }
   /**
    * Execute one round of tool calls and report each through onProgress.
    * Returns the results to feed back plus the log entries produced.
    */
-  async executeToolCalls(toolCalls, fs10, onProgress, fetcher, stepIndex, thinking, signal) {
+  async executeToolCalls(toolCalls, fs12, onProgress, fetcher, stepIndex, thinking, signal) {
     const toolResults = [];
     const logEntries = [];
     let resultsText = "";
@@ -4969,18 +5071,18 @@ var BaseAiService = class _BaseAiService {
         const subagentId = uuidv4();
         spawnSubagentIds.set(i, subagentId);
         onProgress({ type: "tool_call", tool: toolCalls[i].name, toolArgs: JSON.stringify(toolCalls[i].args), subagentId, toolCallId: toolCalls[i].id });
-        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs10, onProgress, signal, subagentId));
+        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs12, onProgress, signal, subagentId));
       }) : Promise.resolve(),
       parallelIndexes.length > 1 ? mapWithConcurrency(parallelIndexes, TOOL_ROUND_CONCURRENCY, async (i) => {
         onProgress({ type: "tool_call", tool: toolCalls[i].name, toolArgs: JSON.stringify(toolCalls[i].args), toolCallId: toolCalls[i].id });
-        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs10, fetcher, signal));
+        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs12, fetcher, signal));
       }) : Promise.resolve()
     ]);
     for (const [index, tc] of toolCalls.entries()) {
       const toolArgs = normalizedArgs[index];
       const preResult = precomputed.get(index);
       if (!preResult) onProgress({ type: "tool_call", tool: tc.name, toolArgs: JSON.stringify(tc.args), toolCallId: tc.id });
-      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs10, fetcher, signal);
+      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs12, fetcher, signal);
       const MAX_RESPONSE_CHARS = 5e4;
       const truncatedResponse = toolResult.success && (toolResult.truncated || toolResult.output.length > MAX_RESPONSE_CHARS);
       const llmOutput = toolResult.output.length > MAX_RESPONSE_CHARS ? toolResult.output.slice(0, MAX_RESPONSE_CHARS) + `
@@ -5112,7 +5214,6 @@ ${llmOutput}
           researchLog
         };
       }
-      if (extractPrdBlock(turn.text)) ctx.prdCaptured = true;
       const reply = classifyPlannerReply(turn.text, {
         runners: ctx.runners,
         runnerModes: ctx.runnerModes,
@@ -5121,17 +5222,11 @@ ${llmOutput}
       switch (reply.kind) {
         case "task_ops":
           return { kind: "task_ops", ops: reply.ops, text: turn.text, researchLog };
+        // A read is settled by the Session (it owns the plan and the catalog),
+        // so it leaves this loop the same way a plan or an edit does.
+        case "task_query":
+          return { kind: "task_query", query: reply.query, text: turn.text, researchLog };
         case "plan":
-          if (ctx.prdEnabled && !ctx.prdCaptured && !ctx.prdNudgeSent && !signal?.aborted) {
-            ctx.prdNudgeSent = true;
-            pending = [
-              "PRD mode is enabled but no PRD has been produced yet, so the plan was NOT committed.",
-              "In your next reply: first output the full markdown PRD wrapped EXACTLY in",
-              '<!-- ORDEWELL_PRD_START slug="<feature-slug>" --> and <!-- ORDEWELL_PRD_END -->,',
-              "then re-emit the exact same task plan JSON after the PRD block."
-            ].join(" ");
-            continue;
-          }
           return { kind: "plan", tasks: reply.tasks, text: turn.text, researchLog };
         // Botched attempts get a bounded corrective retry — otherwise the
         // broken JSON would surface as a prose bubble and the edit or plan
@@ -5143,6 +5238,13 @@ ${llmOutput}
             continue;
           }
           break;
+        case "broken_task_query":
+          if (jsonRepairAttempts < MAX_JSON_REPAIRS2 && !signal?.aborted) {
+            jsonRepairAttempts++;
+            pending = reEmitTaskQueryPrompt(reply.error.message);
+            continue;
+          }
+          break;
         case "broken_plan":
           if (jsonRepairAttempts < MAX_JSON_REPAIRS2 && !signal?.aborted) {
             jsonRepairAttempts++;
@@ -5166,7 +5268,7 @@ ${llmOutput}
    * parsed tasks if a plan was emitted mid-loop, or null if the loop
    * exhausted without a valid plan.
    */
-  async runResearchLoop(chat, firstMessage, fs10, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
+  async runResearchLoop(chat, firstMessage, fs12, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
     const researchLog = initialLog ? [...initialLog] : [];
     if (!initialLog && userGoal) {
       researchLog.push({
@@ -5193,7 +5295,7 @@ ${llmOutput}
       if (!turn.hasToolCalls) break;
       const { toolResults, logEntries, resultsText } = await this.executeToolCalls(
         turn.toolCalls,
-        fs10,
+        fs12,
         onProgress,
         fetcher,
         step,
@@ -5331,9 +5433,6 @@ var GeminiService = class extends BaseAiService {
       req.runners,
       req.runnerModes,
       req.autonomousDefault ?? true,
-      req.grillMeEnabled ?? false,
-      req.prdEnabled ?? false,
-      req.reviewEnabled ?? false,
       req.verificationEnabled ?? false
     );
     const seededHistory = [
@@ -5372,8 +5471,7 @@ ${m.content}` });
       runners: req.runners,
       runnerModes: req.runnerModes,
       autonomousDefault: req.autonomousDefault,
-      fetcher: req.fetcher,
-      prdEnabled: req.prdEnabled ?? false
+      fetcher: req.fetcher
     };
     this.conversation = { ctx, setProgress: (onProgress) => {
       currentProgress = onProgress;
@@ -5431,11 +5529,11 @@ ${repairHint}` }] : parts;
     return this.consumePlanStream(result, onToken);
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs10, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs12, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     const genModel = this.getPlanningModel();
-    const contextStr = await BaseAiService.collectResearchContext(fs10, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs12, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const firstMessage = `${buildResearchToolsPrompt()}
 
@@ -5446,17 +5544,17 @@ Explore the workspace to understand the codebase, then generate the plan.`;
       generationConfig: { temperature: 0.3, topP: 0.95, maxOutputTokens: 16384 }
     });
     const researchChat = new GeminiResearchChat(chat);
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs10, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs12, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
     return { tasks: fallback.tasks, researchLog: fallback.researchLog, researchResults: result.researchResults };
   }
-  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs12, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs10) {
-      const collected = await new ContextCollector(fs10).collect(runners[0] ?? "claude-code");
+    if (fs12) {
+      const collected = await new ContextCollector(fs12).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -5472,12 +5570,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs12, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs10) {
-      const collected = await new ContextCollector(fs10).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs12) {
+      const collected = await new ContextCollector(fs12).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -5660,7 +5758,6 @@ var OpenAiService = class extends BaseAiService {
   async startConversation(req) {
     this.ensureInit();
     const client = this.getClient();
-    this.researchSubagentsEnabled = req.researchSubagentsEnabled ?? false;
     const contextStr = await BaseAiService.collectResearchContext(req.fs, req.runners);
     const systemPrompt = buildConversationSystemPrompt(
       req.goal,
@@ -5669,16 +5766,13 @@ var OpenAiService = class extends BaseAiService {
       req.runners,
       req.runnerModes,
       req.autonomousDefault ?? true,
-      req.grillMeEnabled ?? false,
-      req.prdEnabled ?? false,
-      req.reviewEnabled ?? false,
       req.verificationEnabled ?? false
     );
     const userText = req.goal;
     const messages = [
       { role: "system", content: `${systemPrompt}
 
-${buildResearchToolsPrompt(this.researchSubagentsEnabled)}` }
+${buildResearchToolsPrompt()}` }
     ];
     for (const m of req.priorHistory ?? []) {
       messages.push({ role: m.role, content: m.content });
@@ -5688,7 +5782,7 @@ ${buildResearchToolsPrompt(this.researchSubagentsEnabled)}` }
       messages,
       client,
       this.requireModel("orchestratorModel", this.config.orchestratorModel),
-      toOpenAiTools(this.researchSubagentsEnabled),
+      toOpenAiTools(),
       (delta) => currentProgress({ type: "thinking", text: delta }),
       (delta) => currentProgress({ type: "plan_token", planToken: delta })
     );
@@ -5698,8 +5792,7 @@ ${buildResearchToolsPrompt(this.researchSubagentsEnabled)}` }
       runners: req.runners,
       runnerModes: req.runnerModes,
       autonomousDefault: req.autonomousDefault,
-      fetcher: req.fetcher,
-      prdEnabled: req.prdEnabled ?? false
+      fetcher: req.fetcher
     };
     this.conversation = {
       ctx,
@@ -5717,15 +5810,14 @@ ${buildResearchToolsPrompt(this.researchSubagentsEnabled)}` }
     }
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs10, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs12, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const client = this.getClient();
-    const { autonomousDefault, researchSubagents: researchSubagentsEnabled } = modes;
-    this.researchSubagentsEnabled = researchSubagentsEnabled;
-    const contextStr = await BaseAiService.collectResearchContext(fs10, runners);
+    const { autonomousDefault } = modes;
+    const contextStr = await BaseAiService.collectResearchContext(fs12, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const userText = `User goal: ${userDescription}`;
-    const firstMessage = `${buildResearchToolsPrompt(researchSubagentsEnabled)}
+    const firstMessage = `${buildResearchToolsPrompt()}
 
 Explore the workspace to understand the codebase, then generate the plan.
 
@@ -5737,20 +5829,20 @@ ${userText}`;
       messages,
       client,
       this.requireModel("orchestratorModel", this.config.orchestratorModel),
-      toOpenAiTools(researchSubagentsEnabled),
+      toOpenAiTools(),
       (delta) => onProgress({ type: "thinking", text: delta })
     );
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs10, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs12, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
     return { tasks: fallback.tasks, researchLog: fallback.researchLog, researchResults: result.researchResults };
   }
-  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs12, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs10) {
-      const collected = await new ContextCollector(fs10).collect(runners[0] ?? "claude-code");
+    if (fs12) {
+      const collected = await new ContextCollector(fs12).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -5766,12 +5858,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs12, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs10) {
-      const collected = await new ContextCollector(fs10).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs12) {
+      const collected = await new ContextCollector(fs12).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -5860,21 +5952,28 @@ function pickWindow(sorted, currentIdx, max) {
   const window = sorted.slice(start, start + max);
   return { window, omitted: sorted.length - window.length };
 }
-function renderPlanMap(allTasks, currentTaskId, opts) {
-  if (allTasks.length < PLAN_MAP_MIN_TASKS) return "";
-  const sorted = [...allTasks].sort((a, b) => a.order - b.order);
+function renderPlanMap(planTasks, currentTaskId, opts) {
+  const rows = flattenTasksWithParents(planTasks);
+  if (rows.length < PLAN_MAP_MIN_TASKS) return "";
+  const sorted = rows.map((r) => ({
+    ...r,
+    label: taskOrderLabel(r.task, r.parent ?? void 0)
+  })).sort((a, b) => {
+    const parentDiff = (a.parent?.order ?? -1) - (b.parent?.order ?? -1);
+    if (parentDiff !== 0) return parentDiff;
+    return a.task.order - b.task.order;
+  });
   const max = opts?.maxEntries ?? DEFAULT_PLAN_MAP_MAX_ENTRIES;
-  const currentIdx = sorted.findIndex((t) => t.id === currentTaskId);
+  const currentIdx = sorted.findIndex((r) => r.task.id === currentTaskId);
   const { window, omitted } = pickWindow(sorted, currentIdx, max);
-  const currentTask = sorted.find((t) => t.id === currentTaskId);
-  const widthOrder = Math.max(2, String(sorted[sorted.length - 1]?.order ?? sorted.length).length);
-  const lines = window.map((t) => {
-    const isCurrent = t.id === currentTaskId;
-    const tag = planMapStatus(t, isCurrent);
-    const order = String(t.order).padStart(widthOrder, " ");
+  const currentTask = sorted.find((r) => r.task.id === currentTaskId)?.task;
+  const lines = window.map((row) => {
+    const isCurrent = row.task.id === currentTaskId;
+    const tag = planMapStatus(row.task, isCurrent);
+    const order = row.parent ? row.label : row.label.padStart(2, " ");
     const arrow = isCurrent ? "   \u2190 you are here" : "";
-    const runner = t.assignedRunner ? ` (${t.assignedRunner})` : "";
-    return `${order}. [${tag.padEnd(7, " ")}] ${t.title}${runner}${arrow}`;
+    const runner = row.task.assignedRunner ? ` (${row.task.assignedRunner})` : "";
+    return `${order}. [${tag.padEnd(7, " ")}] ${row.task.title}${runner}${arrow}`;
   });
   const footer = omitted > 0 ? `
 (${omitted} task${omitted === 1 ? "" : "s"} omitted from this view)` : "";
@@ -5939,7 +6038,8 @@ function composeAugmentedPrompt(task, allTasks, opts) {
     const map = renderPlanMap(allTasks, task.id, { maxEntries: opts?.planMapMaxEntries });
     if (map) blocks.push(map);
   }
-  const outputs = collectDirectDependencyOutputs(task, allTasks);
+  const flat = flattenTasks(allTasks);
+  const outputs = collectDirectDependencyOutputs(task, flat);
   if (outputs.length > 0) blocks.push(renderPriorOutputs(outputs));
   if (opts?.tddEnabled) {
     blocks.push(renderTddInstruction());
@@ -6118,6 +6218,7 @@ function renderTerminalOutput(raw) {
   return populated.map((r) => cells(r).join("")).join("\n");
 }
 var MARKER_SCAN_TAIL = 16384;
+var IDLE_TIMEOUT_MS = 6e4;
 var VerdictEngine = class {
   markerSeen = /* @__PURE__ */ new Set();
   buffers = /* @__PURE__ */ new Map();
@@ -6125,6 +6226,7 @@ var VerdictEngine = class {
   pausedSessions = /* @__PURE__ */ new Map();
   listeners = [];
   checkpointListeners = [];
+  idleListeners = [];
   /**
    * Per-task generation counter. Incremented on every watch() and clear().
    * Stale callbacks (from a prior session whose generation doesn't match
@@ -6132,12 +6234,47 @@ var VerdictEngine = class {
    * wrong session.
    */
   generations = /* @__PURE__ */ new Map();
+  idleTimers = /* @__PURE__ */ new Map();
+  idleSince = /* @__PURE__ */ new Map();
   onVerdict(listener) {
     this.listeners.push(listener);
   }
   onCheckpoint(listener) {
     this.checkpointListeners.push(listener);
   }
+  onIdleChange(listener) {
+    this.idleListeners.push(listener);
+  }
+  /** Advisory silence timestamp for a task, or null if it isn't idle. */
+  getIdleSince(taskId) {
+    return this.idleSince.get(taskId) ?? null;
+  }
+  /** Restart the silence timer on fresh output; broadcasts the null transition if it was idle. */
+  touchIdle(taskId, gen) {
+    const existing = this.idleTimers.get(taskId);
+    if (existing) clearTimeout(existing);
+    if (this.idleSince.get(taskId)) {
+      this.idleSince.set(taskId, null);
+      for (const l of this.idleListeners) l(taskId, null);
+    }
+    this.idleTimers.set(taskId, setTimeout(() => {
+      if (this.generations.get(taskId) !== gen) return;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.idleSince.set(taskId, now);
+      for (const l of this.idleListeners) l(taskId, now);
+    }, IDLE_TIMEOUT_MS));
+  }
+  /** Tear down idle tracking for a task; broadcasts the null transition if it was idle. */
+  clearIdle(taskId) {
+    const timer = this.idleTimers.get(taskId);
+    if (timer) clearTimeout(timer);
+    this.idleTimers.delete(taskId);
+    const wasIdle = this.idleSince.get(taskId);
+    this.idleSince.delete(taskId);
+    if (wasIdle) {
+      for (const l of this.idleListeners) l(taskId, null);
+    }
+  }
   approveCheckpoint(taskId) {
     const session = this.pausedSessions.get(taskId);
     if (session) {
@@ -6168,6 +6305,7 @@ ORDEWELL_REJECT: ${reason}
     this.checkpointCounts.set(task.id, 0);
     session.onOutput((text) => {
       if (this.generations.get(task.id) !== gen) return;
+      this.touchIdle(task.id, gen);
       if (this.markerSeen.has(task.id)) return;
       const buf = (this.buffers.get(task.id) ?? "") + text;
       this.buffers.set(task.id, buf);
@@ -6179,6 +6317,7 @@ ORDEWELL_REJECT: ${reason}
         this.buffers.delete(task.id);
         this.checkpointCounts.delete(task.id);
         this.pausedSessions.delete(task.id);
+        this.clearIdle(task.id);
         this.generations.set(task.id, gen + 1);
         const verdict = this.decide(task, 0);
         for (const l of this.listeners) l(task.id, verdict, output);
@@ -6203,6 +6342,7 @@ ORDEWELL_REJECT: ${reason}
       this.buffers.delete(task.id);
       this.checkpointCounts.delete(task.id);
       this.pausedSessions.delete(task.id);
+      this.clearIdle(task.id);
       const verdict = this.decide(task, exitCode);
       for (const l of this.listeners) l(task.id, verdict, output);
     });
@@ -6213,6 +6353,7 @@ ORDEWELL_REJECT: ${reason}
     this.buffers.delete(task.id);
     this.checkpointCounts.delete(task.id);
     this.pausedSessions.delete(task.id);
+    this.clearIdle(task.id);
     this.generations.set(task.id, (this.generations.get(task.id) ?? 0) + 1);
     return {
       outcome: "pass",
@@ -6234,6 +6375,7 @@ ORDEWELL_REJECT: ${reason}
     this.buffers.delete(task.id);
     this.checkpointCounts.delete(task.id);
     this.pausedSessions.delete(task.id);
+    this.clearIdle(task.id);
     this.generations.set(task.id, (this.generations.get(task.id) ?? 0) + 1);
   }
   /** Drop all tracking state (used on stop / loadPlan). */
@@ -6242,6 +6384,9 @@ ORDEWELL_REJECT: ${reason}
     this.buffers.clear();
     this.checkpointCounts.clear();
     this.pausedSessions.clear();
+    for (const timer of this.idleTimers.values()) clearTimeout(timer);
+    this.idleTimers.clear();
+    this.idleSince.clear();
     this.generations.clear();
   }
   decide(task, exitCode) {
@@ -6647,6 +6792,7 @@ var TaskOrchestrator = class {
       this.store.markAwaitingUser(taskId);
       this.emit("onCheckpoint", { taskId, taskTitle: task.title, summary });
     });
+    this.verifier.onIdleChange(() => this.emit("onTaskChanged"));
   }
   config;
   notifications;
@@ -6671,6 +6817,10 @@ var TaskOrchestrator = class {
   workspaceRootFn = () => process.cwd();
   observers = [];
   tddEnabled = () => false;
+  /** Advisory silence timestamp for a task's live runner, or null if not idle. */
+  getIdleSince(taskId) {
+    return this.verifier.getIdleSince(taskId);
+  }
   get storeInstance() {
     return this.store;
   }
@@ -7058,8 +7208,10 @@ ${output.slice(-3e3)}`);
     if (ready.length === 0 && this.activeTaskSessions.size === 0) {
       const remaining = this.store.allTasks.filter((t) => t.status !== "completed");
       console.log(`[TaskOrchestrator] tick(): no work. remaining=${remaining.length}, completed=${this.store.isAllComplete()}`);
-      for (const t of remaining) {
-        console.log(`  - ${t.order}. ${t.title} [${t.type}/${t.status}] prompt=${!!t.prompt}`);
+      const remainingById = new Map(remaining.map((t) => [t.id, t]));
+      for (const { task, parent } of flattenTasksWithParents(this.store.planTasks)) {
+        if (!remainingById.has(task.id)) continue;
+        console.log(`  - ${taskOrderLabel(task, parent ?? void 0)}. ${task.title} [${task.type}/${task.status}] prompt=${!!task.prompt}`);
       }
       if (this.store.isAllComplete()) {
         this.running = false;
@@ -7086,7 +7238,7 @@ ${output.slice(-3e3)}`);
     try {
       const cwd = this.workspaceRootFn();
       const runner = this.store.resolveTaskRunner(task);
-      const finalPrompt = composeAugmentedPrompt(task, this.store.allTasks, {
+      const finalPrompt = composeAugmentedPrompt(task, this.store.planTasks, {
         planMapEnabled: this.config.planMapEnabled,
         tddEnabled: this.tddEnabled()
       });
@@ -7124,111 +7276,6 @@ ${output.slice(-3e3)}`);
   }
 };
 
-// src/services/ModelAllowlistResolver.ts
-function effectiveAllowlist(allowlist, runner, modelsByRunner) {
-  if (!allowlist || allowlist.length === 0) return void 0;
-  if (!modelsByRunner) return allowlist;
-  const own = new Set((modelsByRunner[runner] ?? []).map((m) => m.modelId));
-  const elsewhere = /* @__PURE__ */ new Set();
-  for (const [other, models] of Object.entries(modelsByRunner)) {
-    if (other === runner) continue;
-    for (const m of models ?? []) elsewhere.add(m.modelId);
-  }
-  const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
-  return kept.length > 0 ? kept : void 0;
-}
-function filterModelsForPrompt(modelsByRunner, perRunnerAllowlist) {
-  const result = {};
-  for (const [runner, models] of Object.entries(modelsByRunner)) {
-    if (!models) continue;
-    const allowed = effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
-    if (!allowed) {
-      result[runner] = models;
-      continue;
-    }
-    const allowedSet = new Set(allowed);
-    const intersection = models.filter((m) => allowedSet.has(m.modelId));
-    const covered = new Set(intersection.map((m) => m.modelId));
-    const missing = allowed.filter((id) => !covered.has(id)).map((id) => ({ modelId: id, modelLabel: id.split("/").pop() || id, variants: [] }));
-    result[runner] = [...intersection, ...missing];
-  }
-  return result;
-}
-var EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
-var EFFORT_ALIASES = { disabled: "none", adaptive: "medium" };
-function clampThinkingEffort(effort, variants) {
-  if (!effort) return void 0;
-  if (variants.length === 0) return void 0;
-  const ids = new Set(variants.map((v) => v.id));
-  if (ids.has(effort)) return effort;
-  const canon = EFFORT_ALIASES[effort] ?? effort;
-  if (ids.has(canon)) return canon;
-  const idx = EFFORT_LADDER.indexOf(canon);
-  if (idx < 0) return void 0;
-  for (let d = 1; d < EFFORT_LADDER.length; d++) {
-    const lower = EFFORT_LADDER[idx - d];
-    if (lower && ids.has(lower)) return lower;
-    const higher = EFFORT_LADDER[idx + d];
-    if (higher && ids.has(higher)) return higher;
-  }
-  return void 0;
-}
-function coerceAssignments(tasks, perRunnerAllowlist, allowedRunners, modelsByRunner) {
-  const clampVariant = (task) => {
-    if (!task.assignedModel || !modelsByRunner) return task;
-    const model = modelsByRunner[task.assignedRunner]?.find(
-      (m) => m.modelId === task.assignedModel.modelId
-    );
-    if (!model) return task;
-    const clamped = clampThinkingEffort(task.assignedModel.thinkingEffort, model.variants);
-    return {
-      ...task,
-      assignedModel: {
-        ...task.assignedModel,
-        thinkingEffort: clamped,
-        availableVariants: model.variants.map((v) => v.id)
-      }
-    };
-  };
-  const allowedFor = (runner) => effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
-  const assignmentFor = (runner, modelId) => {
-    const known = modelsByRunner?.[runner]?.find((m) => m.modelId === modelId);
-    return {
-      modelId,
-      modelLabel: known?.modelLabel ?? modelId,
-      thinkingEffort: void 0,
-      ...known ? { availableVariants: known.variants.map((v) => v.id) } : {}
-    };
-  };
-  return tasks.map((task) => {
-    if (task.type === "user") return task;
-    if (allowedRunners && !allowedRunners.includes(task.assignedRunner)) {
-      const fallbackRunner = allowedRunners[0];
-      const fallbackModels = allowedFor(fallbackRunner);
-      const fallbackModel = fallbackModels?.length ? assignmentFor(fallbackRunner, fallbackModels[0]) : modelsByRunner?.[fallbackRunner]?.[0] ? assignmentFor(fallbackRunner, modelsByRunner[fallbackRunner][0].modelId) : task.assignedModel;
-      return clampVariant({
-        ...task,
-        assignedRunner: fallbackRunner,
-        assignedModel: fallbackModel
-      });
-    }
-    const allowlist = allowedFor(task.assignedRunner);
-    if (!task.assignedModel) {
-      if (allowlist && allowlist.length > 0) {
-        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) });
-      }
-      const discovered = modelsByRunner?.[task.assignedRunner]?.[0];
-      if (discovered) {
-        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, discovered.modelId) });
-      }
-      return task;
-    }
-    if (!allowlist || allowlist.length === 0) return clampVariant(task);
-    if (allowlist.includes(task.assignedModel.modelId)) return clampVariant(task);
-    return { ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) };
-  });
-}
-
 // src/services/Planner.ts
 function plannerModesWith(req) {
   const modes = req.modes ?? DEFAULT_PLANNER_MODES;
@@ -7365,7 +7412,7 @@ import * as osMod from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path4 from "path";
 var execAsync = promisify(exec);
 var LOGIN_SHELL_TIMEOUT_MS = 5e3;
 var PATH_MARKER = "__ORDEWELL_PATH__";
@@ -7376,40 +7423,40 @@ var defaultExec = async (command, options) => {
 function posixBinDirs() {
   const home = os2.homedir();
   return [
-    path5.join(home, ".local", "bin"),
-    path5.join(home, ".opencode", "bin"),
-    path5.join(home, ".claude", "bin"),
-    path5.join(home, ".bun", "bin"),
-    path5.join(home, ".volta", "bin"),
-    path5.join(home, ".npm-global", "bin"),
-    path5.join(home, "bin"),
+    path4.join(home, ".local", "bin"),
+    path4.join(home, ".opencode", "bin"),
+    path4.join(home, ".claude", "bin"),
+    path4.join(home, ".bun", "bin"),
+    path4.join(home, ".volta", "bin"),
+    path4.join(home, ".npm-global", "bin"),
+    path4.join(home, "bin"),
     "/usr/local/bin",
     "/opt/homebrew/bin"
   ];
 }
 function windowsBinDirs(env, home) {
-  const join16 = (...parts) => path5.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join16(base, ...parts)] : [];
+  const join19 = (...parts) => path4.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join19(base, ...parts)] : [];
   const appData = env.APPDATA;
   const localAppData = env.LOCALAPPDATA;
   const programData = env.ProgramData;
   return [
     // Native per-user installers, PowerShell-driven and otherwise.
-    join16(home, ".local", "bin"),
-    join16(home, ".opencode", "bin"),
-    join16(home, ".claude", "bin"),
-    join16(home, ".codex", "bin"),
+    join19(home, ".local", "bin"),
+    join19(home, ".opencode", "bin"),
+    join19(home, ".claude", "bin"),
+    join19(home, ".codex", "bin"),
     ...under(localAppData, "Programs", "claude"),
     // Node package managers. npm's global prefix is `%APPDATA%\npm`; the
     // literal spelling is kept as a fallback for a host that does not export
     // APPDATA (a service account, a stripped CI container).
     ...under(appData, "npm"),
-    join16(home, "AppData", "Roaming", "npm"),
+    join19(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join16(home, ".bun", "bin"),
+    join19(home, ".bun", "bin"),
     // Windows package managers.
-    join16(home, "scoop", "shims"),
+    join19(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -7419,7 +7466,7 @@ function windowsBinDirs(env, home) {
     ...under(localAppData, "Microsoft", "WindowsApps"),
     // Version managers. Volta's Windows home is not the POSIX `~/.volta`.
     ...under(localAppData, "Volta", "bin"),
-    join16(home, ".volta", "bin")
+    join19(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -7448,14 +7495,14 @@ function augmentedPath(execImpl = defaultExec) {
       const segments = [];
       const push = (p) => {
         if (!p) return;
-        for (const seg of p.split(path5.delimiter)) {
+        for (const seg of p.split(path4.delimiter)) {
           if (seg && !segments.includes(seg)) segments.push(seg);
         }
       };
       push(process.env.PATH);
       push(await loginShellPath(execImpl));
       for (const dir of wellKnownBinDirs()) push(dir);
-      return segments.join(path5.delimiter);
+      return segments.join(path4.delimiter);
     })();
   }
   return cachedPath;
@@ -7475,6 +7522,50 @@ function withPath(base, resolvedPath, overrides = {}) {
   return env;
 }
 
+// src/utils/globalDataDir.ts
+import * as fs from "fs";
+import * as path5 from "path";
+import * as os3 from "os";
+function globalDataDir() {
+  return path5.join(os3.homedir(), ".ordewell");
+}
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path5.join(src, entry.name);
+    const destPath = path5.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+var migrated = false;
+function migrateOldConfigDir() {
+  if (migrated) return;
+  migrated = true;
+  const oldDir = path5.join(os3.homedir(), ".config", "ordewell");
+  if (!fs.existsSync(oldDir)) return;
+  const newDir = globalDataDir();
+  const liftFile = (name) => {
+    const oldFile = path5.join(oldDir, name);
+    const newFile = path5.join(newDir, name);
+    if (fs.existsSync(oldFile) && !fs.existsSync(newFile)) {
+      fs.mkdirSync(newDir, { recursive: true });
+      fs.copyFileSync(oldFile, newFile);
+    }
+  };
+  liftFile("settings.json");
+  liftFile(".env");
+  const oldPlugins = path5.join(oldDir, "plugins");
+  const newPlugins = path5.join(newDir, "plugins");
+  if (fs.existsSync(oldPlugins) && !fs.existsSync(newPlugins)) {
+    copyDirSync(oldPlugins, newPlugins);
+  }
+}
+
 // src/utils/launch.ts
 import * as fsSync2 from "fs";
 import * as path6 from "path";
@@ -7800,7 +7891,7 @@ function parseCodexModelsCache(content) {
 }
 var GEMINI_MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function geminiDiscoveryCacheKey(apiKey) {
-  const dir = path7.join(osMod.homedir(), ".config", "ordewell");
+  const dir = globalDataDir();
   const hash = apiKey.slice(-8);
   return {
     key: `gemini-models:${hash}`,
@@ -8330,12 +8421,14 @@ var ModelDiscovery = class {
 // src/services/ModelCatalog.ts
 import * as fs2 from "fs";
 import * as path8 from "path";
-import * as os3 from "os";
 var CACHE_KEY = "model-catalog";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function storageKey(baseUrl) {
   return `${CACHE_KEY}:${baseUrl}`;
 }
+function globalCacheDir() {
+  return globalDataDir();
+}
 var ModelCatalog = class {
   static async fetchModels(apiKey, baseUrl, fetchImpl) {
     const url = (baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
@@ -8378,7 +8471,7 @@ var ModelCatalog = class {
     try {
       const url = (baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
       const key = storageKey(url);
-      const cacheDir = path8.join(os3.homedir(), ".config", "ordewell");
+      const cacheDir = globalCacheDir();
       const cacheFile = path8.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       if (fs2.existsSync(cacheFile)) fs2.rmSync(cacheFile);
     } catch {
@@ -8386,7 +8479,7 @@ var ModelCatalog = class {
   }
   static readCache(key) {
     try {
-      const cacheDir = path8.join(os3.homedir(), ".config", "ordewell");
+      const cacheDir = globalCacheDir();
       const cacheFile = path8.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       if (!fs2.existsSync(cacheFile)) return null;
       const raw = fs2.readFileSync(cacheFile, "utf8");
@@ -8399,7 +8492,7 @@ var ModelCatalog = class {
   }
   static writeCache(key, models) {
     try {
-      const cacheDir = path8.join(os3.homedir(), ".config", "ordewell");
+      const cacheDir = globalCacheDir();
       fs2.mkdirSync(cacheDir, { recursive: true });
       const cacheFile = path8.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       fs2.writeFileSync(
@@ -8940,12 +9033,19 @@ var StdioAgentAdapter = class {
   /** Set for the duration of a turn. Outside one, events are buffered rather than dropped. */
   turnEmit = null;
   /**
-   * Events the agent produced between turns — in practice the startup warnings
-   * that arrive during the handshake. Dropping them hid the one diagnostic
-   * that explains a planner which cannot read the workspace, so they are held
-   * until a turn exists to show them in.
+   * Events the agent produced before its first turn — in practice the startup
+   * warnings that arrive during the handshake. Dropping them hid the one
+   * diagnostic that explains a planner which cannot read the workspace, so they
+   * are held until a turn exists to show them in.
+   *
+   * Only before the *first* turn. Once one has run, anything arriving outside a
+   * turn is that closed turn's straggling work — a backgrounded subagent
+   * finishing, a late read — and replaying it into the next turn presents it as
+   * research done for the user's new message.
    */
   betweenTurns = [];
+  /** Set once a turn has ended: after that, out-of-turn events are stale, not startup. */
+  hadTurn = false;
   disposed = false;
   /** Resolves when the process ends, so a handshake can lose the race instead of waiting out its timeout. */
   processEnded;
@@ -8980,7 +9080,7 @@ var StdioAgentAdapter = class {
     this.process.stdout?.on("data", (chunk) => {
       this.stdout.push(chunk.toString(), (line) => this.handleLine(line, (event) => {
         if (this.turnEmit) this.turnEmit(event);
-        else if (!TURN_SCOPED_EVENTS.has(event.type) && this.betweenTurns.length < BETWEEN_TURN_EVENT_CAP) {
+        else if (!this.hadTurn && !TURN_SCOPED_EVENTS.has(event.type) && this.betweenTurns.length < BETWEEN_TURN_EVENT_CAP) {
           this.betweenTurns.push(event);
         }
       }));
@@ -9012,6 +9112,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
         if (settled) return;
         settled = true;
         this.turnEmit = null;
+        this.hadTurn = true;
         signal?.removeEventListener("abort", onAbort);
         this.process?.removeListener("exit", onExit);
         this.process?.removeListener("error", onExit);
@@ -9090,6 +9191,7 @@ ${tail}` : ""}`;
 
 // src/services/harness/ClaudeCodeAdapter.ts
 var DISALLOWED_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit", "KillShell"];
+var ASYNC_LAUNCH_MARKER = "Async agent launched successfully";
 function flattenContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -9099,6 +9201,8 @@ function flattenContent(content) {
 }
 var ClaudeCodeAdapter = class extends StdioAgentAdapter {
   agentId = "claude-code";
+  /** Whether this turn has already emitted reply text — see {@link handleLine}. */
+  turnHasText = false;
   spawnSpec(opts) {
     const args = [
       "-p",
@@ -9123,6 +9227,7 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     return { command: "claude", args };
   }
   turnPayload(message) {
+    this.turnHasText = false;
     return `${JSON.stringify({
       type: "user",
       message: { role: "user", content: [{ type: "text", text: message }] }
@@ -9133,6 +9238,7 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     const msg = StdioAgentAdapter.parse(line);
     if (!msg) return;
     if (msg.session_id) this.sessionId = msg.session_id;
+    if (msg.parent_tool_use_id) return;
     switch (msg.type) {
       // The control channel: Claude asks whether a tool may run when its mode
       // cannot decide alone. A read-only planner answers "deny", every time —
@@ -9157,8 +9263,12 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
       }
       case "assistant":
         for (const block of Array.isArray(msg.message?.content) ? msg.message.content : []) {
-          if (block.type === "text" && block.text) emit({ type: "assistant_text", text: block.text });
-          else if (block.type === "thinking" && block.thinking) emit({ type: "thinking", text: block.thinking });
+          if (block.type === "text" && block.text) {
+            emit({ type: "assistant_text", text: this.turnHasText ? `
+
+${block.text}` : block.text });
+            this.turnHasText = true;
+          } else if (block.type === "thinking" && block.thinking) emit({ type: "thinking", text: block.thinking });
           else if (block.type === "tool_use" && block.name) {
             emit({ type: "tool_call", id: block.id ?? block.name, name: block.name, args: block.input ?? {} });
           }
@@ -9167,11 +9277,15 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
       case "user":
         for (const block of Array.isArray(msg.message?.content) ? msg.message.content : []) {
           if (block.type !== "tool_result") continue;
+          const output = flattenContent(block.content);
+          if (output.includes(ASYNC_LAUNCH_MARKER)) {
+            emit({ type: "background_agent", id: block.tool_use_id ?? "" });
+          }
           emit({
             type: "tool_result",
             id: block.tool_use_id ?? "",
             name: "",
-            output: flattenContent(block.content),
+            output,
             success: block.is_error !== true
           });
         }
@@ -9591,6 +9705,8 @@ var OpenCodeAdapter = class {
   exited = false;
   disposed = false;
   opts = null;
+  /** Whether this turn has already emitted reply text — see {@link emitPart}. */
+  turnHasText = false;
   async start(opts) {
     this.opts = opts;
     assertWorkspaceExists(opts.cwd, { isDirectory: this.deps.isDirectory });
@@ -9658,6 +9774,7 @@ ${this.stderrTail.trim()}` : ""}`);
       return;
     }
     const seen = /* @__PURE__ */ new Set();
+    this.turnHasText = false;
     const streamAbort = new AbortController();
     let connected = () => {
     };
@@ -9726,7 +9843,10 @@ ${this.stderrTail.trim()}` : ""}`);
     if (part.type === "text" && part.text) {
       if (seen.has(`text:${id}`)) return;
       seen.add(`text:${id}`);
-      onEvent({ type: "assistant_text", text: part.text });
+      onEvent({ type: "assistant_text", text: this.turnHasText ? `
+
+${part.text}` : part.text });
+      this.turnHasText = true;
       return;
     }
     if (part.type === "reasoning" && part.text) {
@@ -9814,14 +9934,14 @@ ${this.stderrTail.trim()}` : ""}`);
       }
     }
   }
-  async json(method, path17, body, signal) {
-    const response = await this.deps.fetch(`${this.baseUrl}${path17}`, {
+  async json(method, path20, body, signal) {
+    const response = await this.deps.fetch(`${this.baseUrl}${path20}`, {
       method,
       headers: { "content-type": "application/json" },
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
       ...signal ? { signal } : {}
     });
-    if (!response.ok) throw new Error(`${method} ${path17} failed: ${response.status} ${response.statusText}`);
+    if (!response.ok) throw new Error(`${method} ${path20} failed: ${response.status} ${response.statusText}`);
     return await response.json().catch(() => null);
   }
   nativeSessionId() {
@@ -9893,6 +10013,7 @@ function normalizeAgentArgs(tool, args) {
 
 // src/services/harness/CliAgentAiService.ts
 var MAX_JSON_REPAIRS = 2;
+var MAX_AGENT_WAITS = 2;
 var LOG_MAX_CHARS = 1e4;
 function defaultAdapter(runner, deps) {
   switch (runner) {
@@ -9975,9 +10096,6 @@ var CliAgentAiService = class {
       req.runners,
       req.runnerModes,
       req.autonomousDefault ?? true,
-      req.grillMeEnabled ?? false,
-      req.prdEnabled ?? false,
-      req.reviewEnabled ?? false,
       req.verificationEnabled ?? false,
       true
     );
@@ -9992,10 +10110,7 @@ var CliAgentAiService = class {
       startOptions,
       runners: req.runners,
       runnerModes: req.runnerModes,
-      autonomousDefault: req.autonomousDefault,
-      prdEnabled: req.prdEnabled ?? false,
-      prdCaptured: false,
-      prdNudgeSent: false
+      autonomousDefault: req.autonomousDefault
     };
     const opening = this.openingMessage(req);
     return this.runConversation(opening, req.onProgress, req.signal);
@@ -10023,8 +10138,8 @@ var CliAgentAiService = class {
   /**
    * Drive one user message to a settled planner turn. Same shape as the API
    * backend's conversation loop minus the tool rounds — those belong to the
-   * agent now — and with the same three policies layered on top: the PRD gate,
-   * the empty-reply nudge, and a bounded corrective re-emit for botched JSON.
+   * agent now — and with the same two policies layered on top: the
+   * empty-reply nudge, and a bounded corrective re-emit for botched JSON.
    */
   async runConversation(message, onProgress, signal) {
     const conversation = this.conversation;
@@ -10033,13 +10148,16 @@ var CliAgentAiService = class {
     let pending = message;
     let emptyNudgeSent = false;
     let jsonRepairAttempts = 0;
+    let agentWaits = 0;
+    const carried = [];
+    const replyText = (text) => [...carried, text].filter((part) => part.trim()).join("\n\n");
     try {
       for (; ; ) {
         const turn = await this.runTurn(pending, onProgress, combined);
         researchLog.push(...turn.researchLog);
         if (turn.aborted || combined?.aborted) {
           onProgress({ type: "interrupted" });
-          return { kind: "message", text: turn.text, researchLog };
+          return { kind: "message", text: replyText(turn.text), researchLog };
         }
         if (turn.error) {
           return { kind: "message", text: turn.error, researchLog };
@@ -10057,7 +10175,18 @@ var CliAgentAiService = class {
             researchLog
           };
         }
-        if (extractPrdBlock(turn.text)) conversation.prdCaptured = true;
+        if (turn.backgroundAgents > 0 && agentWaits < MAX_AGENT_WAITS && !combined?.aborted) {
+          agentWaits++;
+          carried.push(turn.text);
+          pending = [
+            `You ended your turn with ${turn.backgroundAgents} subagent(s) still running in the background.`,
+            "Ordewell hands the conversation back to the user when your turn ends, so anything you say after it never reaches them \u2014",
+            "the results you promised to report would be lost.",
+            "Wait for those agents to finish NOW, in this reply, and do not end your turn until you have their results.",
+            "Then give the user your synthesis. In future replies, await your agents inside the turn rather than backgrounding them."
+          ].join(" ");
+          continue;
+        }
         const reply = classifyPlannerReply(turn.text, {
           runners: conversation.runners,
           runnerModes: conversation.runnerModes,
@@ -10065,20 +10194,14 @@ var CliAgentAiService = class {
         });
         switch (reply.kind) {
           case "task_ops":
-            return { kind: "task_ops", ops: reply.ops, text: turn.text, researchLog };
+            return { kind: "task_ops", ops: reply.ops, text: replyText(turn.text), researchLog };
+          // The read channel is a text envelope precisely so it reaches here
+          // too: a harness planner has no Ordewell tool loop to call into.
+          case "task_query":
+            return { kind: "task_query", query: reply.query, text: replyText(turn.text), researchLog };
           case "plan":
-            if (conversation.prdEnabled && !conversation.prdCaptured && !conversation.prdNudgeSent && !combined?.aborted) {
-              conversation.prdNudgeSent = true;
-              pending = [
-                "PRD mode is enabled but no PRD has been produced yet, so the plan was NOT committed.",
-                "In your next reply: first output the full markdown PRD wrapped EXACTLY in",
-                '<!-- ORDEWELL_PRD_START slug="<feature-slug>" --> and <!-- ORDEWELL_PRD_END -->,',
-                "then re-emit the exact same task plan JSON after the PRD block."
-              ].join(" ");
-              continue;
-            }
             this.conversation = null;
-            return { kind: "plan", tasks: reply.tasks, text: turn.text, researchLog };
+            return { kind: "plan", tasks: reply.tasks, text: replyText(turn.text), researchLog };
           case "broken_task_ops":
             if (jsonRepairAttempts < MAX_JSON_REPAIRS && !combined?.aborted) {
               jsonRepairAttempts++;
@@ -10086,6 +10209,13 @@ var CliAgentAiService = class {
               continue;
             }
             break;
+          case "broken_task_query":
+            if (jsonRepairAttempts < MAX_JSON_REPAIRS && !combined?.aborted) {
+              jsonRepairAttempts++;
+              pending = reEmitTaskQueryPrompt(reply.error.message);
+              continue;
+            }
+            break;
           case "broken_plan":
             if (jsonRepairAttempts < MAX_JSON_REPAIRS && !combined?.aborted) {
               jsonRepairAttempts++;
@@ -10096,7 +10226,7 @@ var CliAgentAiService = class {
           case "prose":
             break;
         }
-        return { kind: "message", text: turn.text, researchLog };
+        return { kind: "message", text: replyText(turn.text), researchLog };
       }
     } finally {
       this.activeAbort = null;
@@ -10116,6 +10246,7 @@ var CliAgentAiService = class {
     let text = "";
     let error;
     let stepIndex = 0;
+    let backgroundAgents = 0;
     const truncate = (value) => value.length > LOG_MAX_CHARS ? `${value.slice(0, LOG_MAX_CHARS)}
 [... truncated, total ${value.length} chars]` : value;
     const settle = (id, rawOutput, success, outcome) => {
@@ -10155,6 +10286,9 @@ var CliAgentAiService = class {
         case "tool_result":
           settle(event.id, event.output, event.success, event.success ? "success" : "failure");
           return;
+        case "background_agent":
+          backgroundAgents++;
+          return;
         case "permission_request": {
           const mapped = mapAgentTool(event.name);
           const args = JSON.stringify({ detail: event.detail });
@@ -10185,7 +10319,7 @@ var CliAgentAiService = class {
       adapter.dispose();
       this.adapter = null;
     }
-    return { text, researchLog, error, aborted: signal?.aborted };
+    return { text, researchLog, error, aborted: signal?.aborted, backgroundAgents };
   }
   // --- Process lifecycle ---
   async startAdapter(opts) {
@@ -10244,10 +10378,7 @@ var CliAgentAiService = class {
       oneShotAdapter = await this.startAdapter(startOptions);
       this.conversation = {
         startOptions,
-        runners: [],
-        prdEnabled: false,
-        prdCaptured: false,
-        prdNudgeSent: false
+        runners: []
       };
       const turn = await this.runTurn(
         "Follow the instructions in your system prompt and produce the plan now.",
@@ -10264,8 +10395,8 @@ var CliAgentAiService = class {
       this.lastNativeSessionId = previousSessionId;
     }
   }
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs10, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
-    const contextStr = await collectResearchContext(fs10, runners);
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs12, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+    const contextStr = await collectResearchContext(fs12, runners);
     const researchLog = [
       { id: `up-${Date.now()}`, type: "user_prompt", content: userDescription, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
     ];
@@ -10588,6 +10719,180 @@ function retargetTaskRunner(task, runner, catalog) {
   return { assignedRunner: runner, ...runnerAssignment(catalog, task) };
 }
 
+// src/services/SkillsService.ts
+import * as fs4 from "fs";
+import * as path11 from "path";
+
+// src/services/builtinSkills.ts
+import * as path10 from "path";
+import { fileURLToPath } from "url";
+function builtinSkillsDir() {
+  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path10.dirname(fileURLToPath(
+    // @ts-expect-error - import.meta is only valid under an ESM module setting
+    import.meta.url
+  ));
+  return path10.join(dir, "..", "skills");
+}
+
+// src/services/SkillsService.ts
+var BUILTIN_SKILL_NAMES = ["grilling", "to-spec"];
+var RETIRED_BUILTIN_SKILL_NAMES = ["grill-me"];
+function parseSkillFile(filePath, name, source) {
+  const raw = fs4.readFileSync(filePath, "utf8");
+  const frontmatter = {};
+  let content = raw;
+  if (raw.startsWith("---\n")) {
+    const end = raw.indexOf("\n---", 4);
+    if (end !== -1) {
+      const fmText = raw.slice(4, end);
+      for (const line of fmText.split("\n")) {
+        const idx = line.indexOf(":");
+        if (idx === -1) continue;
+        const key = line.slice(0, idx).trim();
+        const value = line.slice(idx + 1).trim();
+        if (key === "disable-model-invocation") {
+          frontmatter[key] = value === "true";
+        } else if (key === "name" || key === "description") {
+          frontmatter[key] = value.replace(/^"|"$/g, "");
+        }
+      }
+      content = raw.slice(end + 4).replace(/^\n+/, "");
+    }
+  }
+  const metadata = {
+    name: frontmatter.name ?? name,
+    description: frontmatter.description ?? "",
+    ...frontmatter["disable-model-invocation"] !== void 0 ? { disableModelInvocation: frontmatter["disable-model-invocation"] } : {}
+  };
+  return { name, description: metadata.description, metadata, content, path: filePath, source };
+}
+function copyDirSync2(src, dest) {
+  fs4.mkdirSync(dest, { recursive: true });
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path11.join(src, entry.name);
+    const destPath = path11.join(dest, entry.name);
+    if (entry.isDirectory()) copyDirSync2(srcPath, destPath);
+    else fs4.copyFileSync(srcPath, destPath);
+  }
+}
+function readDir(dir, source) {
+  if (!fs4.existsSync(dir)) return [];
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = path11.join(dir, entry.name, "SKILL.md");
+    if (!fs4.existsSync(skillFile)) continue;
+    const parsed = parseSkillFile(skillFile, entry.name, source);
+    if (parsed) skills.push(parsed);
+  }
+  return skills;
+}
+var SkillsService = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+  workspaceRoot;
+  localDir() {
+    return this.workspaceRoot ? path11.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
+  }
+  globalDir() {
+    return path11.join(globalDataDir(), "skills");
+  }
+  seed(name) {
+    const dest = path11.join(this.globalDir(), name);
+    if (fs4.existsSync(dest)) return false;
+    let srcDir;
+    try {
+      srcDir = path11.join(builtinSkillsDir(), name);
+    } catch (err) {
+      console.warn(`Could not locate built-in skills dir: ${String(err)}`);
+      return false;
+    }
+    if (!fs4.existsSync(srcDir)) {
+      console.warn(`Built-in skill not found in package: ${name}`);
+      return false;
+    }
+    copyDirSync2(srcDir, dest);
+    return true;
+  }
+  seedBuiltinSkill(name) {
+    return this.seed(name);
+  }
+  /** Removes a retired built-in's seed from the global dir, but only if it's untouched by the user. */
+  isUnmodifiedRetiredSeed(dir, expectedName) {
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    if (entries.length !== 1 || entries[0].name !== "SKILL.md" || !entries[0].isFile()) return false;
+    let raw;
+    try {
+      raw = fs4.readFileSync(path11.join(dir, "SKILL.md"), "utf8");
+    } catch {
+      return false;
+    }
+    if (!raw.startsWith("---\n")) return false;
+    const end = raw.indexOf("\n---", 4);
+    if (end === -1) return false;
+    for (const line of raw.slice(4, end).split("\n")) {
+      const idx = line.indexOf(":");
+      if (idx === -1) continue;
+      const key = line.slice(0, idx).trim();
+      if (key === "name") return line.slice(idx + 1).trim().replace(/^"|"$/g, "") === expectedName;
+    }
+    return false;
+  }
+  pruneRetired() {
+    for (const name of RETIRED_BUILTIN_SKILL_NAMES) {
+      const dest = path11.join(this.globalDir(), name);
+      if (!fs4.existsSync(dest)) continue;
+      if (!this.isUnmodifiedRetiredSeed(dest, name)) continue;
+      try {
+        fs4.rmSync(dest, { recursive: true, force: true });
+      } catch (err) {
+        console.warn(`Could not prune retired skill ${name}: ${String(err)}`);
+      }
+    }
+  }
+  findSkill(name) {
+    this.pruneRetired();
+    if (BUILTIN_SKILL_NAMES.includes(name)) this.seed(name);
+    const localDir = this.localDir();
+    if (localDir) {
+      const localFile = path11.join(localDir, name, "SKILL.md");
+      if (fs4.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
+    }
+    const globalFile = path11.join(this.globalDir(), name, "SKILL.md");
+    if (fs4.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
+    return void 0;
+  }
+  listSkills() {
+    this.pruneRetired();
+    for (const name of BUILTIN_SKILL_NAMES) this.seed(name);
+    const byName = /* @__PURE__ */ new Map();
+    for (const skill of readDir(this.globalDir(), "global")) {
+      byName.set(skill.name, skill);
+    }
+    const localDir = this.localDir();
+    if (localDir) {
+      for (const skill of readDir(localDir, "local")) {
+        byName.set(skill.name, skill);
+      }
+    }
+    return [...byName.values()];
+  }
+  getSkillContent(name) {
+    return this.findSkill(name)?.content;
+  }
+};
+function createSkillsService(workspaceRoot) {
+  return new SkillsService(workspaceRoot);
+}
+
 // src/services/SessionMessage.ts
 function serializeTask(t) {
   return {
@@ -10609,11 +10914,12 @@ function serializeTask(t) {
     userStoriesCovered: t.userStoriesCovered || void 0
   };
 }
-function serializeTaskStatus(t) {
+function serializeTaskStatus(t, idleSince = null) {
   return {
     id: t.id,
     status: t.status,
-    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null
+    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null,
+    idleSince
   };
 }
 function serializePlan(plan) {
@@ -10635,27 +10941,27 @@ function executionSummary(tasks) {
 }
 
 // src/utils/sessionStore.ts
-import * as fs5 from "fs";
-import * as path11 from "path";
+import * as fs6 from "fs";
+import * as path13 from "path";
 
 // src/utils/fsHelpers.ts
-import * as fs4 from "fs";
-import * as path10 from "path";
+import * as fs5 from "fs";
+import * as path12 from "path";
 var STATE_DIR = ".ordewell";
 function ensureDir(dir) {
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
 }
 function getStateDir(baseDir) {
-  return path10.join(baseDir ?? process.cwd(), STATE_DIR);
+  return path12.join(baseDir ?? process.cwd(), STATE_DIR);
 }
 var IGNORE_FILE = ".gitignore";
 function ensureStateDirIgnored(baseDir) {
   const dir = getStateDir(baseDir);
   ensureDir(dir);
   try {
-    fs4.writeFileSync(path10.join(dir, IGNORE_FILE), "*\n", { flag: "wx" });
+    fs5.writeFileSync(path12.join(dir, IGNORE_FILE), "*\n", { flag: "wx" });
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
   }
@@ -10670,7 +10976,7 @@ function mintSessionId() {
 // src/utils/sessionStore.ts
 var SESSIONS_SUBDIR = "sessions";
 function getSessionsDir(baseDir) {
-  return path11.join(getStateDir(baseDir), SESSIONS_SUBDIR);
+  return path13.join(getStateDir(baseDir), SESSIONS_SUBDIR);
 }
 var REJECTION_MESSAGE = "This session was created with an older version of Ordewell. Please re-plan.";
 function hasScalarRunner(parsed) {
@@ -10705,17 +11011,17 @@ function saveSession(plan, goal, baseDir, id) {
     plan: JSON.parse(JSON.stringify(plan))
   };
   const filename = sessionFilename(meta);
-  const filePath = path11.join(sessionsDir, filename);
-  fs5.writeFileSync(filePath, JSON.stringify(session, null, 2));
+  const filePath = path13.join(sessionsDir, filename);
+  fs6.writeFileSync(filePath, JSON.stringify(session, null, 2));
   return meta;
 }
 function listSessions(baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs5.existsSync(sessionsDir)) return [];
-  const files = fs5.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  if (!fs6.existsSync(sessionsDir)) return [];
+  const files = fs6.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   return files.map((f) => {
     try {
-      const raw = fs5.readFileSync(path11.join(sessionsDir, f), "utf-8");
+      const raw = fs6.readFileSync(path13.join(sessionsDir, f), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${f}: ${REJECTION_MESSAGE}`);
@@ -10730,10 +11036,10 @@ function listSessions(baseDir, logger = defaultLogger) {
   }).filter((m) => m !== null).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 }
 function findSessionFile(sessionsDir, sessionId, logger) {
-  const files = fs5.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const files = fs6.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   for (const f of files) {
     try {
-      const raw = fs5.readFileSync(path11.join(sessionsDir, f), "utf-8");
+      const raw = fs6.readFileSync(path13.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -10744,11 +11050,11 @@ function findSessionFile(sessionsDir, sessionId, logger) {
 }
 function loadSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs5.existsSync(sessionsDir)) return null;
+  if (!fs6.existsSync(sessionsDir)) return null;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      const raw = fs5.readFileSync(path11.join(sessionsDir, file), "utf-8");
+      const raw = fs6.readFileSync(path13.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -10778,11 +11084,11 @@ function getLatestSession(baseDir, logger = defaultLogger) {
 }
 function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs5.existsSync(sessionsDir)) return false;
+  if (!fs6.existsSync(sessionsDir)) return false;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      fs5.unlinkSync(path11.join(sessionsDir, file));
+      fs6.unlinkSync(path13.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -10791,7 +11097,36 @@ function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   return false;
 }
 
+// src/utils/prdStore.ts
+import * as fs7 from "fs";
+import * as path14 from "path";
+var PRD_BLOCK_RE = /<!--\s*ORDEWELL_PRD_START\s+slug="([^"]+)"\s*-->\s*([\s\S]*?)\s*<!--\s*ORDEWELL_PRD_END\s*-->/;
+function extractPrdBlock(text) {
+  const match = PRD_BLOCK_RE.exec(text);
+  if (!match) return null;
+  const slug2 = sanitizeSlug(match[1]);
+  const markdown = match[2].trim();
+  if (!slug2 || !markdown) return null;
+  return { slug: slug2, markdown };
+}
+function sanitizeSlug(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function savePrdMarkdown(workspace, slug2, markdown) {
+  const dir = path14.join(workspace, ".scratch", sanitizeSlug(slug2));
+  fs7.mkdirSync(dir, { recursive: true });
+  const file = path14.join(dir, "PRD.md");
+  fs7.writeFileSync(file, markdown.endsWith("\n") ? markdown : markdown + "\n", "utf8");
+  return file;
+}
+
 // src/services/createSession.ts
+var CATALOG_MODEL_CAP = 100;
+var MAX_TASK_QUERIES = 3;
+var MAX_TASK_QUERIES_HARD = 6;
+function freshReadBudget() {
+  return { answered: 0, seen: /* @__PURE__ */ new Set() };
+}
 var PlanEditError = class extends Error {
   constructor(message) {
     super(message);
@@ -10801,6 +11136,17 @@ var PlanEditError = class extends Error {
 function sessionRuntimeSettings(settings) {
   return { ...plannerRuntimeToggles(settings), modelAllowlist: settings.modelAllowlist };
 }
+function resolveSkillInvocation(text, skillsService) {
+  const match = text.trim().match(/^\/([a-z][a-z0-9_-]*)$/im);
+  if (!match) return text;
+  const skillName = match[1].toLowerCase();
+  const skill = skillsService.findSkill(skillName);
+  if (!skill) {
+    const available = typeof skillsService.listSkills === "function" ? skillsService.listSkills().map((s) => s.name).join(", ") : "";
+    return `Unknown skill: ${skillName}. Available skills: ${available}`;
+  }
+  return skill.content;
+}
 var Session = class {
   /** Injected by a test; when present it is the service, forever. */
   pinnedAiService;
@@ -10828,6 +11174,7 @@ var Session = class {
   unsubObserver = null;
   hostSessionId;
   currentSessionId;
+  skillsService;
   constructor(deps) {
     this.config = deps.config;
     this.registry = deps.registry;
@@ -10846,6 +11193,7 @@ var Session = class {
     this.settingsFn = deps.settings;
     this.hostSessionId = deps.sessionId;
     this.currentSessionId = deps.sessionId ?? mintSessionId();
+    this.skillsService = deps.skillsService ?? new SkillsService(this.workspaceRootFn());
     this.approvals = new PendingApprovals({
       onRequest: ({ id, request }) => this.broadcast({
         type: "approval_request",
@@ -10940,7 +11288,7 @@ var Session = class {
       onTaskChanged: () => {
         if (!this.plan) return;
         const tasks = this.store.allTasks;
-        this.broadcast({ type: "status_update", tasks: tasks.map(serializeTaskStatus) });
+        this.broadcast({ type: "status_update", tasks: tasks.map((t) => serializeTaskStatus(t, this.orchestrator.getIdleSince(t.id))) });
       },
       onQueueReady: () => {
         this.broadcast({ type: "queue_ready" });
@@ -10958,7 +11306,7 @@ var Session = class {
       onTick: () => {
         if (!this.plan) return;
         const tasks = this.store.allTasks;
-        this.broadcast({ type: "status_update", tasks: tasks.map(serializeTaskStatus) });
+        this.broadcast({ type: "status_update", tasks: tasks.map((t) => serializeTaskStatus(t, this.orchestrator.getIdleSince(t.id))) });
       },
       onExecutionComplete: () => {
         if (!this.plan) return;
@@ -11028,6 +11376,21 @@ var Session = class {
   runnerModesFor(runners) {
     return runnerModesFrom(this.registry, runners);
   }
+  /**
+   * The catalog a model/task-mode edit is checked against — the same
+   * discovered models and manifest modes the per-turn catalog block shows the
+   * planner, so a refusal here can never name something invalid that the
+   * planner was never told about. `modelsCache` is read live, not filtered by
+   * the allowlist here — {@link checkModelAndModeValidity} narrows by
+   * allowlist itself, the same way `coerceAssignments` does.
+   */
+  editCatalog() {
+    return {
+      modelsByRunner: this.modelsCache,
+      runnerModes: this.runnerModesFor(this.plan?.runners ?? []),
+      perRunnerAllowlist: this.settingsFn().modelAllowlist ?? this.currentAllowlist
+    };
+  }
   get planState() {
     return this.plan;
   }
@@ -11155,7 +11518,7 @@ var Session = class {
    */
   async startPlanning(goal, runners, options) {
     this.plan = null;
-    this.goal = goal;
+    this.goal = this.resolveSkillInvocation(goal);
     this.remintSessionId();
     this.beginFreshPlan();
     const enabled = this.config.enabledRunners;
@@ -11164,7 +11527,7 @@ var Session = class {
     const modelsByRunner = await this.modelResolver.modelsForRunners(chosenRunners);
     this.modelsCache = modelsByRunner;
     const runnerModes = this.runnerModesFor(chosenRunners);
-    const { grillMeEnabled, prdEnabled, reviewEnabled, verificationEnabled, researchSubagentsEnabled, modelAllowlist } = this.settingsFn();
+    const { verificationEnabled, modelAllowlist } = this.settingsFn();
     this.currentAllowlist = modelAllowlist ?? {};
     const filteredModels = filterModelsForPrompt(modelsByRunner, this.currentAllowlist);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -11174,22 +11537,18 @@ var Session = class {
       status: "draft",
       runners: chosenRunners,
       lastUpdated: now,
-      researchLog: [{ id: `up-${Date.now()}`, type: "user_prompt", content: goal, timestamp: now }],
-      conversationHistory: [{ role: "user", content: goal, timestamp: now }]
+      researchLog: [{ id: `up-${Date.now()}`, type: "user_prompt", content: this.goal, timestamp: now }],
+      conversationHistory: [{ role: "user", content: this.goal, timestamp: now }]
     };
     const releaseAbort = this.denyApprovalsOnAbort(options?.signal);
     try {
       const turn = await this.aiService.startConversation({
-        goal,
+        goal: this.goal,
         runners: chosenRunners,
         modelsByRunner: filteredModels,
         runnerModes,
         autonomousDefault: this.config.autonomousMode,
-        grillMeEnabled: grillMeEnabled ?? false,
-        prdEnabled: prdEnabled ?? false,
-        reviewEnabled: reviewEnabled ?? false,
         verificationEnabled: verificationEnabled ?? false,
-        researchSubagentsEnabled: researchSubagentsEnabled ?? false,
         fs: this.fsAdapter,
         fetcher: this.fetcher,
         onProgress: (p) => this.translateProgress(p),
@@ -11201,19 +11560,22 @@ var Session = class {
     }
   }
   /**
-   * Every subsequent user reply in the planning conversation — grill-me
-   * answers, PRD accept/adjust, outline confirm. One branch, no phase ladder.
+   * Every subsequent user reply in the planning conversation — clarifying
+   * answers, outline confirm. One branch, no phase ladder.
    */
   async continueConversation(userMessage, options) {
     if (!this.plan) throw new Error("No planning conversation to continue");
     const priorHistory = this.plan.conversationHistory ?? [];
+    const priorResearchLog = this.plan.researchLog ?? [];
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.appendTranscript("user", userMessage, now);
-    this.plan.researchLog = [...this.plan.researchLog ?? [], { id: `up-${Date.now()}`, type: "user_prompt", content: userMessage, timestamp: now }];
-    const contextBlock = this.planContextBlock();
+    const resolved = this.resolveSkillInvocation(userMessage);
+    this.appendTranscript("user", resolved, now);
+    const historyAfterOwnAppend = this.plan.conversationHistory;
+    this.plan.researchLog = [...this.plan.researchLog ?? [], { id: `up-${Date.now()}`, type: "user_prompt", content: resolved, timestamp: now }];
+    const contextBlock = [this.catalogBlock(), this.planContextBlock()].filter(Boolean).join("\n\n");
     const outgoing = contextBlock ? `${contextBlock}
 
-${userMessage}` : userMessage;
+${resolved}` : resolved;
     const aiService = this.aiService;
     const canContinueLive = aiService.hasActiveConversation() && (aiService.conversationMatchesConfig?.() ?? true);
     const releaseAbort = this.denyApprovalsOnAbort(options?.signal);
@@ -11223,6 +11585,8 @@ ${userMessage}` : userMessage;
         (p) => this.translateProgress(p),
         options?.signal
       ) : await this.resumeConversation(outgoing, priorHistory, options);
+      const reads = freshReadBudget();
+      turn = await this.drainTaskQueries(turn, reads, options);
       if ((turn.kind === "task_ops" || turn.kind === "plan") && this.hasLiveWork) {
         this.queueMessage(userMessage);
         this.plan.queuedMessages = this.getQueuedMessages();
@@ -11232,11 +11596,74 @@ ${userMessage}` : userMessage;
           researchLog: turn.researchLog
         };
       }
-      return await this.settleTurn(turn, options);
+      return await this.settleTurn(turn, options, reads);
+    } catch (err) {
+      if (this.plan && this.plan.conversationHistory === historyAfterOwnAppend) {
+        this.plan.conversationHistory = priorHistory;
+        this.plan.researchLog = priorResearchLog;
+      }
+      throw err;
     } finally {
       releaseAbort();
     }
   }
+  /**
+   * Answer every read the planner emits until it says something else.
+   *
+   * The channel is a text envelope rather than a registered tool because the
+   * protocol has to be identical on both planner backends (ADR-0009): Ordewell
+   * owns a tool loop only in the API case, and a harness planner running as a
+   * coding-agent subprocess can only be reached this way.
+   *
+   * Draining here — outside {@link repairLoop} — is what keeps reads free of
+   * the repair budget. A planner that looks a task up and *then* fumbles its
+   * ops JSON still gets its two corrective retries; charging it for the read
+   * would cost it the chance to fix the edit.
+   */
+  async drainTaskQueries(turn, reads, options) {
+    const carried = [];
+    let current = turn;
+    while (current.kind === "task_query") {
+      carried.push(...current.researchLog);
+      if (reads.answered >= MAX_TASK_QUERIES_HARD || !this.aiService.hasActiveConversation() || options?.signal?.aborted) {
+        return {
+          kind: "message",
+          text: "The planner kept asking to read tasks instead of answering. Nothing was changed \u2014 ask again, or be more specific about the edit you want.",
+          researchLog: carried
+        };
+      }
+      const signature = taskQuerySignature(current.query);
+      const insist = reads.seen.has(signature) || reads.answered >= MAX_TASK_QUERIES;
+      reads.seen.add(signature);
+      reads.answered++;
+      const answer = this.taskQueryAnswer(current.query);
+      current = await this.aiService.continueConversation(
+        insist ? `${answer}
+
+${TASK_QUERY_ANSWER_OR_OPS}` : answer,
+        (p) => this.translateProgress(p),
+        options?.signal
+      );
+    }
+    return carried.length > 0 ? { ...current, researchLog: [...carried, ...current.researchLog] } : current;
+  }
+  /**
+   * Render one read out of live state. Never persisted to the transcript: the
+   * detail is context for the planner's next reply, and re-sending it on every
+   * later turn is exactly the cost this channel exists to avoid.
+   */
+  taskQueryAnswer(query) {
+    const runners = this.plan?.runners ?? [];
+    const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
+    return renderTaskQueryAnswer(query, this.store.planTasks, {
+      runners,
+      // Allowlist-filtered like the always-on block: a read must not offer a
+      // model the planner is forbidden to assign.
+      models: filterModelsForPrompt(this.modelsCache, allowlist),
+      modes: this.runnerModesFor(runners),
+      autonomousDefault: this.config.autonomousMode
+    });
+  }
   /**
    * Drive a planner turn to a persisted, broadcast outcome. Task edits apply
    * atomically; validation failures are fed back to the model for up to 2
@@ -11244,7 +11671,7 @@ ${userMessage}` : userMessage;
    * first turn (startPlanning) and every later turn route through here — one
    * path, not two.
    */
-  async settleTurn(turn, options) {
+  async settleTurn(turn, options, reads = freshReadBudget()) {
     const invalidOps = (errors, researchLog) => ({
       turn: {
         kind: "message",
@@ -11256,11 +11683,15 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
       }
     });
     const settled = await repairLoop({
-      first: () => turn,
-      resend: (corrective) => this.aiService.continueConversation(
-        corrective,
-        (p) => this.translateProgress(p),
-        options?.signal
+      first: () => this.drainTaskQueries(turn, reads, options),
+      resend: async (corrective) => this.drainTaskQueries(
+        await this.aiService.continueConversation(
+          corrective,
+          (p) => this.translateProgress(p),
+          options?.signal
+        ),
+        reads,
+        options
       ),
       interpret: (t) => {
         if (t.kind !== "task_ops") return { done: { turn: t } };
@@ -11280,6 +11711,52 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
     }
     return this.applyConversationTurn(settled.turn);
   }
+  /**
+   * The catalog the planner may actually draw from — model ids and task-mode
+   * ids, per selected runner — emitted on EVERY turn, before any plan exists
+   * or after. The system prompt shows this once at conversation start; a long
+   * clarifying conversation outlives that single showing and the planner
+   * starts misquoting it, so this re-states it per turn instead.
+   *
+   * Built from the allowlist-filtered view (`filterModelsForPrompt`), the same
+   * one the system prompt used — a restricted allowlist stays a hard bound on
+   * every turn, not just the first. `this.modelsCache` itself is never
+   * filtered: `coerceAssignments` needs the full discovered catalog alongside
+   * the allowlist to resolve labels and clamp effort to real variants.
+   *
+   * Reads `this.plan.runners` live, so a runner admitted mid-session by a
+   * retarget (`admitRunner`) is filtered and shown like every other — there is
+   * no separate "originally selected" list to fall stale.
+   */
+  catalogBlock() {
+    if (!this.plan) return null;
+    const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
+    const filteredModels = filterModelsForPrompt(this.modelsCache, allowlist);
+    const runnerModes = this.runnerModesFor(this.plan.runners);
+    const autonomousDefault = this.config.autonomousMode;
+    const modelLines = this.plan.runners.map((runner) => {
+      const models = filteredModels[runner] ?? [];
+      const capped = models.slice(0, CATALOG_MODEL_CAP);
+      const remainder = models.length - capped.length;
+      const ids = capped.map((m) => m.modelId).join(", ") || "(no models discovered)";
+      return `${runner}: ${ids}${remainder > 0 ? ` \u2026 +${remainder} more not shown` : ""}`;
+    });
+    const modeLines = this.plan.runners.map((runner) => {
+      const modes = runnerModes[runner] ?? [];
+      if (modes.length === 0) return `${runner}: (no modes declared)`;
+      const defaultId = resolveDefaultMode(modes, autonomousDefault);
+      const ids = modes.map((m) => `${m.id}${m.id === defaultId ? " (default)" : ""}`).join(", ");
+      return `${runner}: ${ids}`;
+    });
+    return [
+      "<available_models>",
+      ...modelLines,
+      "</available_models>",
+      "<available_task_modes>",
+      ...modeLines,
+      "</available_task_modes>"
+    ].join("\n");
+  }
   /**
    * The "you are here" block for post-plan chat: current tasks with stable
    * references, plus the task-ops protocol. Injected per turn (never
@@ -11289,44 +11766,48 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
   planContextBlock() {
     if (!this.plan || this.store.planTasks.length === 0) return null;
     const orderOf = new Map(this.store.planTasks.map((t) => [t.id, `#${t.order}`]));
-    const lines = this.store.planTasks.map(
-      (t) => `#${t.order} id=${t.id} "${t.title}" [${t.status}] runner:${t.assignedRunner}${t.assignedModel ? ` model:${t.assignedModel.modelId}` : ""} deps:[${t.dependencies.map((d) => orderOf.get(d) ?? d).join(", ")}]`
-    );
+    const lines = this.store.planTasks.map((t) => {
+      const isMan = t.type === "user";
+      const runFields = isMan ? `steps:${t.userSteps?.length ?? 0}` : `${t.assignedModel ? `model:${t.assignedModel.modelId} ` : ""}mode:${t.taskMode ?? "build"} effort:${t.thinkingEffort ?? "-"}`;
+      return `#${t.order} id=${t.id} "${t.title}" [${t.status}] type:${isMan ? "MAN" : "AI"} runner:${t.assignedRunner} ${runFields} autonomy:${t.autonomy ?? "-"} slice:${t.sliceType ?? "-"} deps:[${t.dependencies.map((d) => orderOf.get(d) ?? d).join(", ")}]`;
+    });
     const locked = this.store.planTasks.filter((t) => t.status === "in_progress");
     const execNote = this.hasLiveWork ? `
 Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.map((t) => `#${t.order}`).join(", ")}` : ""}. Any task edits you emit will be queued and applied between batches.` : "";
-    const modelLines = [];
-    for (const runner of this.plan.runners) {
-      const models = this.modelsCache[runner] ?? [];
-      const ids = models.map((m) => m.modelId).join(", ");
-      modelLines.push(`${runner}: ${ids || "(no models discovered)"}`);
-    }
-    const modelBlock = modelLines.length > 0 ? ["<available_models>", ...modelLines, "</available_models>"].join("\n") : "";
+    const updateChanges = UPDATABLE_FIELDS.map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
     return [
       "<current_plan>",
       ...lines,
       "</current_plan>",
-      modelBlock,
-      "The block above is the CURRENT task plan. Choose how to respond:",
+      "The block above is the CURRENT task plan \u2014 short fields only. Choose how to respond:",
       "- To answer a question or discuss, reply in plain prose (no JSON).",
+      // The reminder text is owned by TaskQuery beside the parser, so the
+      // protocol the planner reads and the one Ordewell accepts stay one thing.
+      TASK_QUERY_REMINDER,
       "- To modify specific tasks, reply with ONLY this JSON object:",
       '  {"taskOps": [',
-      '    {"op":"update","taskId":"<id or #order>","changes":{"title"?,"description"?,"prompt"?,"dependencies"?:["<id or #order>"],"assignedRunner"?,"assignedModel"?,"taskMode"?}},',
-      '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?}},',
+      `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
+      '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?},"handle"?:"<name>"},',
       '    {"op":"remove","taskId":"<id or #order>"},',
-      '    {"op":"reorder","taskIds":["<id or #order>", "... every task exactly once"]},',
-      '    {"op":"merge","taskIds":["<id or #order>", "..."],"merged":{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...}},',
-      '    {"op":"split","taskId":"<id or #order>","parts":[{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...}, ...]}',
+      '    {"op":"reorder","taskIds":["<id or #order>", "... every task exactly once"]},   // only to re-prioritise INDEPENDENT tasks',
+      '    {"op":"merge","taskIds":["<id or #order>", "..."],"merged":{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...},"handle"?:"<name>"},',
+      '    {"op":"split","taskId":"<id or #order>","parts":[{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...}, ...],"handle"?:"<name>"},',
+      `    {"op":"rearm","taskId":"<id or #order>","changes"?:{${updateChanges}}}`,
       "  ]}",
       '- For sweeping changes, you may instead emit a full {"tasks":[...]} plan JSON.',
+      'Every "<id or #order>" ref in a batch resolves against the plan shown above, before any op in the batch runs \u2014 an earlier remove/merge/split never shifts what a later "#N" means.',
+      'Give "add", "merge", or "split" a "handle" (any name you choose, unused elsewhere in this batch) to let a LATER op in the same batch reference the task it produces \u2014 for "split", the handle names its last part. A handle used before its defining op is rejected.',
       'When creating or changing tasks, set "assignedRunner" and "assignedModel" ({"modelId","modelLabel","thinkingEffort"?}) using only the runners and models listed in <available_models>.',
-      "Keep dependencies consistent: no cycles, no references to removed tasks, dependencies must come before dependents, and never touch running or completed tasks." + execNote
+      'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
+      'Just declare the dependencies you want \u2014 display order is repaired for you afterwards, so a rewire or a newly added prerequisite never needs a "reorder" op. Only a task that is running or completed cannot be shifted, so an edit that would need one to move is rejected.' + execNote,
+      'Flipping "type" between "ai" and "user" is a content change, not just a label: an update to "user" needs "userSteps" in the SAME op, and an update to "ai" needs "prompt" in the SAME op \u2014 the model/mode/effort/autonomy fields (flipping to "user") or the userSteps (flipping to "ai") are cleared automatically.',
+      '"rearm" puts a failed OR completed task back to pending \u2014 verdict and output summary are cleared, any dependents it had blocked are released, and it may carry field changes (e.g. a corrected "prompt") applied in the same op. A running task cannot be re-armed. Never rearm a task just to relabel it \u2014 only when it should actually run again.'
     ].filter(Boolean).join("\n");
   }
   /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
   applyTaskOpsTurn(turn) {
     if (!this.plan) throw new Error("No active plan state");
-    const result = applyTaskOps(this.store.planTasks, turn.ops, this.plan.runners);
+    const result = applyTaskOps(this.store.planTasks, turn.ops, this.plan.runners, this.editCatalog());
     if (!result.ok) return { errors: result.errors };
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const content = `Tasks updated:
@@ -11366,7 +11847,7 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
     const modelsByRunner = await this.modelResolver.modelsForRunners(runners);
     this.modelsCache = modelsByRunner;
     const runnerModes = this.runnerModesFor(runners);
-    const { grillMeEnabled, prdEnabled, reviewEnabled, verificationEnabled, researchSubagentsEnabled, modelAllowlist } = this.settingsFn();
+    const { verificationEnabled, modelAllowlist } = this.settingsFn();
     this.currentAllowlist = modelAllowlist ?? {};
     const filteredModels = filterModelsForPrompt(modelsByRunner, this.currentAllowlist);
     const goal = this.goal || priorHistory.find((m) => m.role === "user")?.content || userMessage;
@@ -11376,11 +11857,7 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
       modelsByRunner: filteredModels,
       runnerModes,
       autonomousDefault: this.config.autonomousMode,
-      grillMeEnabled: grillMeEnabled ?? false,
-      prdEnabled: prdEnabled ?? false,
-      reviewEnabled: reviewEnabled ?? false,
       verificationEnabled: verificationEnabled ?? false,
-      researchSubagentsEnabled: researchSubagentsEnabled ?? false,
       fs: this.fsAdapter,
       fetcher: this.fetcher,
       onProgress: (p) => this.translateProgress(p),
@@ -11393,6 +11870,17 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
   get isConversationActive() {
     return this.aiService.hasActiveConversation();
   }
+  /**
+   * Intercept a skill invocation (/skill-name) and substitute the skill's
+   * markdown content BEFORE the message reaches the planner. Prevents runners
+   * (Claude Code, OpenCode) from trying to resolve the skill in their own
+   * directory instead of .ordewell/skills/. An unknown skill is surfaced to
+   * the planner as a notice naming what IS available, rather than passing a
+   * bare /unknown through to be mis-resolved.
+   */
+  resolveSkillInvocation(text) {
+    return resolveSkillInvocation(text, this.skillsService);
+  }
   /** Append one dialogue entry to the persisted transcript. Callers persist via the mutatePlan ritual. */
   appendTranscript(role, content, timestamp, kind) {
     if (!this.plan) return;
@@ -11593,15 +12081,22 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
     return plan;
   }
   /**
-   * Patch one task's fields. A hand-set dependency list is the one patch that
-   * can leave the plan unschedulable, so it goes through the same
-   * {@link canSetDependencies} guard the planner's pickers use rather than a
-   * second copy of the rule — and throws, so the surface can say why.
+   * Patch one task's fields. A hand-set dependency list, or a type flip
+   * between AI and MAN, are the patches that can leave a task incoherent
+   * (unschedulable, or carrying fields that mean nothing for its new type),
+   * so both go through the same {@link validateTaskEdit} guard the planner's
+   * task-ops applier uses (as the 'direct' actor, which skips the lock rule)
+   * rather than a second copy of the rules — and throws, so the surface can
+   * say why. Gated on the task existing so an edit to an unknown id still
+   * falls through to the no-op `store.update` below instead of throwing.
    */
   async updateTask(taskId, changes) {
-    if (changes.dependencies) {
-      const check = canSetDependencies(this.store.planTasks, taskId, changes.dependencies);
-      if (!check.ok) throw new PlanEditError(check.error ?? "Those dependencies are not valid");
+    if ((changes.dependencies || changes.type || changes.assignedModel || changes.taskMode) && this.store.get(taskId)) {
+      const check = validateTaskEdit("direct", this.store.planTasks, taskId, changes, this.editCatalog());
+      if (!check.ok) throw new PlanEditError(check.error ?? "Those changes are not valid");
+      if (check.clear?.length) {
+        changes = { ...changes, ...Object.fromEntries(check.clear.map((f) => [f, void 0])) };
+      }
     }
     return this.editPlan(
       () => Boolean(this.store.update(taskId, changes)),
@@ -12241,8 +12736,8 @@ var HeadlessRunner = class extends AbstractRunner {
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify4 } from "util";
 import { tmpdir } from "os";
-import { join as join10 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 
 // src/utils/tmux.ts
 import { execSync as execSync2 } from "child_process";
@@ -12347,7 +12842,7 @@ var TmuxSession = class extends AbstractTerminalSession {
     if (this.exited) return;
     let content;
     try {
-      content = existsSync6(this.logPath) ? readFileSync4(this.logPath, "utf8") : "";
+      content = existsSync8(this.logPath) ? readFileSync5(this.logPath, "utf8") : "";
     } catch {
       return;
     }
@@ -12526,7 +13021,7 @@ var TmuxRunner = class extends AbstractRunner {
       windowName,
       this.execFileImpl,
       this.pollIntervalMs,
-      join10(this.logDir, `${id}.log`),
+      join13(this.logDir, `${id}.log`),
       this.socket
     );
     invocation.env = { ...invocation.env, PATH: await this.resolvePath() };
@@ -12538,22 +13033,21 @@ var TmuxRunner = class extends AbstractRunner {
 
 // src/utils/daemonToken.ts
 import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
-import { closeSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync5, unlinkSync as unlinkSync3, writeSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join11 } from "path";
+import { closeSync, mkdirSync as mkdirSync7, openSync, readFileSync as readFileSync6, unlinkSync as unlinkSync3, writeSync } from "fs";
+import { join as join14 } from "path";
 var BEARER_PREFIX = "bearer ";
 var DAEMON_TOKEN_SUBPROTOCOL_PREFIX = "ordewell.token.";
 var DAEMON_SUBPROTOCOL = "ordewell.v1";
 function configDir() {
-  return join11(homedir5(), ".config", "ordewell");
+  return globalDataDir();
 }
 function daemonTokenPath(port) {
-  return join11(configDir(), `server-${port}.token`);
+  return join14(configDir(), `server-${port}.token`);
 }
 function mintDaemonToken(port) {
   const token = randomBytes2(32).toString("base64url");
   const file = daemonTokenPath(port);
-  mkdirSync5(configDir(), { recursive: true });
+  mkdirSync7(configDir(), { recursive: true });
   try {
     unlinkSync3(file);
   } catch {
@@ -12568,7 +13062,7 @@ function mintDaemonToken(port) {
 }
 function readDaemonToken(port) {
   try {
-    const token = readFileSync5(daemonTokenPath(port), "utf8").trim();
+    const token = readFileSync6(daemonTokenPath(port), "utf8").trim();
     return token === "" ? void 0 : token;
   } catch {
     return void 0;
@@ -12609,19 +13103,18 @@ function tokensMatch(presented, expected) {
 }
 
 // src/plugins/RunnerRegistry.ts
-import * as fs7 from "fs";
-import * as path14 from "path";
-import * as os5 from "os";
+import * as fs9 from "fs";
+import * as path17 from "path";
+import * as os4 from "os";
 import { execFileSync } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/plugins/FsPluginStore.ts
-import * as fs6 from "fs";
-import * as path13 from "path";
-import * as os4 from "os";
+import * as fs8 from "fs";
+import * as path16 from "path";
 
 // src/plugins/pluginNames.ts
-import * as path12 from "path";
+import * as path15 from "path";
 var PLUGIN_NAME_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
 var MAX_PLUGIN_NAME_LENGTH = 64;
 function isPlainPluginName(name) {
@@ -12636,10 +13129,10 @@ function assertPlainPluginName(name) {
 }
 function resolvePluginInstallDir(pluginsDir, name) {
   assertPlainPluginName(name);
-  const root = path12.resolve(pluginsDir);
-  const dest = path12.resolve(root, name);
-  const relative3 = path12.relative(root, dest);
-  if (relative3 !== name || relative3 === "" || path12.isAbsolute(relative3)) {
+  const root = path15.resolve(pluginsDir);
+  const dest = path15.resolve(root, name);
+  const relative3 = path15.relative(root, dest);
+  if (relative3 !== name || relative3 === "" || path15.isAbsolute(relative3)) {
     throw new Error(`Plugin install path escapes the plugins directory: ${JSON.stringify(name)}`);
   }
   return dest;
@@ -12654,13 +13147,13 @@ function isValidManifest(obj) {
 
 // src/plugins/FsPluginStore.ts
 function userPluginsDir() {
-  return path13.join(os4.homedir(), ".config", "ordewell", "plugins");
+  return path16.join(globalDataDir(), "plugins");
 }
 function loadManifestFromDir(dir) {
-  const manifestPath = path13.join(dir, "manifest.json");
-  if (!fs6.existsSync(manifestPath)) return null;
+  const manifestPath = path16.join(dir, "manifest.json");
+  if (!fs8.existsSync(manifestPath)) return null;
   try {
-    const raw = fs6.readFileSync(manifestPath, "utf8");
+    const raw = fs8.readFileSync(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isValidManifest(parsed)) return null;
     return parsed;
@@ -12668,31 +13161,31 @@ function loadManifestFromDir(dir) {
     return null;
   }
 }
-function copyDirSync(src, dest) {
+function copyDirSync3(src, dest) {
   ensureDir(dest);
-  const entries = fs6.readdirSync(src, { withFileTypes: true });
+  const entries = fs8.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path13.join(src, entry.name);
-    const destPath = path13.join(dest, entry.name);
+    const srcPath = path16.join(src, entry.name);
+    const destPath = path16.join(dest, entry.name);
     if (entry.isDirectory()) {
-      copyDirSync(srcPath, destPath);
+      copyDirSync3(srcPath, destPath);
     } else {
-      fs6.copyFileSync(srcPath, destPath);
+      fs8.copyFileSync(srcPath, destPath);
     }
   }
 }
 function rmDirSync(dir) {
-  if (!fs6.existsSync(dir)) return;
-  const entries = fs6.readdirSync(dir, { withFileTypes: true });
+  if (!fs8.existsSync(dir)) return;
+  const entries = fs8.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const p = path13.join(dir, entry.name);
+    const p = path16.join(dir, entry.name);
     if (entry.isDirectory()) {
       rmDirSync(p);
     } else {
-      fs6.unlinkSync(p);
+      fs8.unlinkSync(p);
     }
   }
-  fs6.rmdirSync(dir);
+  fs8.rmdirSync(dir);
 }
 var FsPluginStore = class {
   getUserPluginsDir() {
@@ -12700,10 +13193,10 @@ var FsPluginStore = class {
   }
   listUserPluginDirs() {
     const dir = userPluginsDir();
-    if (!fs6.existsSync(dir)) return [];
+    if (!fs8.existsSync(dir)) return [];
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -12711,7 +13204,7 @@ var FsPluginStore = class {
   }
   listDir(dir) {
     try {
-      return fs6.readdirSync(dir);
+      return fs8.readdirSync(dir);
     } catch {
       return [];
     }
@@ -12720,7 +13213,7 @@ var FsPluginStore = class {
     return loadManifestFromDir(pluginDir);
   }
   copyDir(sourceDir, destDir) {
-    copyDirSync(sourceDir, destDir);
+    copyDirSync3(sourceDir, destDir);
   }
   removeDir(dir) {
     rmDirSync(dir);
@@ -12729,20 +13222,20 @@ var FsPluginStore = class {
     ensureDir(dir);
   }
   writeFile(filePath, content) {
-    fs6.writeFileSync(filePath, content);
+    fs8.writeFileSync(filePath, content);
   }
   readFile(filePath) {
     try {
-      return fs6.readFileSync(filePath, "utf8");
+      return fs8.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
   }
-  dirExists(path17) {
-    return fs6.existsSync(path17) && fs6.statSync(path17).isDirectory();
+  dirExists(path20) {
+    return fs8.existsSync(path20) && fs8.statSync(path20).isDirectory();
   }
-  exists(path17) {
-    return fs6.existsSync(path17);
+  exists(path20) {
+    return fs8.existsSync(path20);
   }
 };
 
@@ -13169,7 +13662,7 @@ var RunnerRegistry = class {
     return entry?.source === "builtin";
   }
   installFromPath(sourcePath) {
-    const absPath = path14.resolve(sourcePath);
+    const absPath = path17.resolve(sourcePath);
     if (!this.store.dirExists(absPath)) {
       throw new Error(`Plugin source must be a directory: ${absPath}`);
     }
@@ -13181,7 +13674,7 @@ var RunnerRegistry = class {
   }
   installFromGit(url) {
     const validated = assertInstallablePluginUrl(url);
-    const tmpDir = path14.join(os5.tmpdir(), `ordewell-plugin-${randomBytes3(12).toString("hex")}`);
+    const tmpDir = path17.join(os4.tmpdir(), `ordewell-plugin-${randomBytes3(12).toString("hex")}`);
     this.store.ensureDir(tmpDir);
     try {
       try {
@@ -13194,7 +13687,7 @@ var RunnerRegistry = class {
       const hasManifest = contents.some((f) => f === "manifest.json");
       let sourceDir = tmpDir;
       if (!hasManifest) {
-        const onlyEntry = contents.length === 1 ? path14.join(tmpDir, contents[0]) : void 0;
+        const onlyEntry = contents.length === 1 ? path17.join(tmpDir, contents[0]) : void 0;
         if (!onlyEntry || !this.store.dirExists(onlyEntry)) {
           throw new Error(`No manifest.json found in repository: ${validated.toString()}`);
         }
@@ -13242,7 +13735,7 @@ var RunnerRegistry = class {
   }
   createSkeleton(name, outputDir) {
     assertPlainPluginName(name);
-    const dir = path14.resolve(outputDir, name);
+    const dir = path17.resolve(outputDir, name);
     this.store.ensureDir(dir);
     const manifest = {
       name,
@@ -13274,8 +13767,8 @@ var RunnerRegistry = class {
         ]
       }
     };
-    this.store.writeFile(path14.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
-    const runSh = path14.join(dir, "run.sh");
+    this.store.writeFile(path17.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const runSh = path17.join(dir, "run.sh");
     const scriptContent = `#!/usr/bin/env bash
 # Custom runner script for ${name}
 # Receives:
@@ -13301,30 +13794,30 @@ echo "Running ${name} with prompt: $prompt"
 };
 function fsChmodSync(fpath, mode) {
   try {
-    fs7.chmodSync(fpath, mode);
+    fs9.chmodSync(fpath, mode);
   } catch {
   }
 }
 
 // src/utils/stateStore.ts
-import * as fs8 from "fs";
-import * as path15 from "path";
+import * as fs10 from "fs";
+import * as path18 from "path";
 var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
-  return path15.join(getStateDir(baseDir), STATE_FILE);
+  return path18.join(getStateDir(baseDir), STATE_FILE);
 }
 function saveState(plan, baseDir) {
   const statePath = getStatePath(baseDir ?? process.cwd());
-  ensureDir(path15.dirname(statePath));
+  ensureDir(path18.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  fs8.writeFileSync(statePath, JSON.stringify(plan, null, 2));
+  fs10.writeFileSync(statePath, JSON.stringify(plan, null, 2));
 }
 function loadState(baseDir, logger = defaultLogger) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (!fs8.existsSync(statePath)) return null;
+  if (!fs10.existsSync(statePath)) return null;
   try {
-    const raw = fs8.readFileSync(statePath, "utf-8");
+    const raw = fs10.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.runners)) {
       logger.warn("stateStore", `rejecting state from ${statePath}: old format (scalar "runner" instead of "runners" array). Please re-plan.`);
@@ -13339,29 +13832,24 @@ function loadState(baseDir, logger = defaultLogger) {
 function clearState(baseDir) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (fs8.existsSync(statePath)) fs8.unlinkSync(statePath);
+  if (fs10.existsSync(statePath)) fs10.unlinkSync(statePath);
 }
 function stateExists(baseDir) {
   const dir = baseDir ?? process.cwd();
-  return fs8.existsSync(getStatePath(dir));
+  return fs10.existsSync(getStatePath(dir));
 }
 
 // src/services/SettingsService.ts
-import * as fs9 from "fs";
-import * as path16 from "path";
-import * as os6 from "os";
+import * as fs11 from "fs";
+import * as path19 from "path";
 var DEFAULTS = {
-  grillMe: { enabled: false },
   tdd: { enabled: true },
-  prd: { enabled: false },
-  review: { enabled: false },
-  verification: { enabled: false },
-  researchSubagents: { enabled: false }
+  verification: { enabled: false }
 };
 function getSettingsPath() {
   const override = process.env.ORDEWELL_SETTINGS_PATH;
   if (override && override.trim()) return override.trim();
-  return path16.join(os6.homedir(), ".config", "ordewell", "settings.json");
+  return path19.join(globalDataDir(), "settings.json");
 }
 function readPlannerModels(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
@@ -13394,43 +13882,19 @@ var SettingsService = class {
   }
   fileMtimeMs() {
     try {
-      return fs9.statSync(this.filePath).mtimeMs;
+      return fs11.statSync(this.filePath).mtimeMs;
     } catch {
       return null;
     }
   }
-  getGrillMe() {
-    return this.getAll().grillMe.enabled;
-  }
   getTdd() {
     return this.getAll().tdd.enabled;
   }
-  getPrd() {
-    return this.getAll().prd.enabled;
-  }
-  setGrillMe(enabled) {
-    this.getAll();
-    this.cache.grillMe.enabled = enabled;
-    this.persist();
-  }
   setTdd(enabled) {
     this.getAll();
     this.cache.tdd.enabled = enabled;
     this.persist();
   }
-  setPrd(enabled) {
-    this.getAll();
-    this.cache.prd.enabled = enabled;
-    this.persist();
-  }
-  getReview() {
-    return this.getAll().review.enabled;
-  }
-  setReview(enabled) {
-    this.getAll();
-    this.cache.review.enabled = enabled;
-    this.persist();
-  }
   getVerification() {
     return this.getAll().verification.enabled;
   }
@@ -13439,14 +13903,6 @@ var SettingsService = class {
     this.cache.verification.enabled = enabled;
     this.persist();
   }
-  getResearchSubagents() {
-    return this.getAll().researchSubagents.enabled;
-  }
-  setResearchSubagents(enabled) {
-    this.getAll();
-    this.cache.researchSubagents.enabled = enabled;
-    this.persist();
-  }
   getModelAllowlist(runner) {
     return this.getAll().modelAllowlist?.[runner];
   }
@@ -13496,18 +13952,13 @@ var SettingsService = class {
     this.persist();
   }
   load() {
+    migrateOldConfigDir();
     try {
-      if (fs9.existsSync(this.filePath)) {
-        const raw = JSON.parse(fs9.readFileSync(this.filePath, "utf-8"));
+      if (fs11.existsSync(this.filePath)) {
+        const raw = JSON.parse(fs11.readFileSync(this.filePath, "utf-8"));
         const settings = {
-          grillMe: { enabled: raw.grillMe?.enabled ?? DEFAULTS.grillMe.enabled },
           tdd: { enabled: raw.tdd?.enabled ?? DEFAULTS.tdd.enabled },
-          prd: { enabled: raw.prd?.enabled ?? DEFAULTS.prd.enabled },
-          // `verify` is the legacy key for review mode; keep reading it so old settings files survive the rename.
-          // The evidence-based verification mode uses the distinct `verification` key to avoid colliding with it.
-          review: { enabled: raw.review?.enabled ?? raw.verify?.enabled ?? DEFAULTS.review.enabled },
-          verification: { enabled: raw.verification?.enabled ?? DEFAULTS.verification.enabled },
-          researchSubagents: { enabled: raw.researchSubagents?.enabled ?? DEFAULTS.researchSubagents.enabled }
+          verification: { enabled: raw.verification?.enabled ?? DEFAULTS.verification.enabled }
         };
         if (raw.modelAllowlist !== void 0) {
           settings.modelAllowlist = raw.modelAllowlist;
@@ -13523,14 +13974,14 @@ var SettingsService = class {
       }
     } catch {
     }
-    return { ...DEFAULTS, grillMe: { ...DEFAULTS.grillMe }, tdd: { ...DEFAULTS.tdd }, prd: { ...DEFAULTS.prd }, review: { ...DEFAULTS.review }, verification: { ...DEFAULTS.verification }, researchSubagents: { ...DEFAULTS.researchSubagents } };
+    return { ...DEFAULTS, tdd: { ...DEFAULTS.tdd }, verification: { ...DEFAULTS.verification } };
   }
   persist() {
-    const dir = path16.dirname(this.filePath);
-    if (!fs9.existsSync(dir)) {
-      fs9.mkdirSync(dir, { recursive: true });
+    const dir = path19.dirname(this.filePath);
+    if (!fs11.existsSync(dir)) {
+      fs11.mkdirSync(dir, { recursive: true });
     }
-    fs9.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
+    fs11.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
     this.cachedMtimeMs = this.fileMtimeMs();
   }
 };
@@ -13576,6 +14027,7 @@ export {
   AbstractRunner,
   AbstractTerminalSession,
   ApprovalPolicy,
+  BUILTIN_SKILL_NAMES,
   BaseAiService,
   BaseConfig,
   BaseFileSystem,
@@ -13634,8 +14086,14 @@ export {
   SYMBOL_LANGUAGES,
   Session,
   SettingsService,
+  SkillsService,
   StdioAgentAdapter,
   TASK_OPS_ENVELOPE_KEY,
+  TASK_QUERY_ANSWER_OR_OPS,
+  TASK_QUERY_ENVELOPE_KEY,
+  TASK_QUERY_FIELDS,
+  TASK_QUERY_PROTOCOL,
+  TASK_QUERY_REMINDER,
   TRUNCATED_PLAN_REPAIR_INSTRUCTION,
   TaskOrchestrator,
   TmuxRunner,
@@ -13694,6 +14152,7 @@ export {
   configuredProviders,
   createAiService,
   createEmptyPlan,
+  createSkillsService,
   createTask,
   daemonTokenPath,
   defaultLogger,
@@ -13720,12 +14179,14 @@ export {
   filterModelsForPrompt,
   filteredBuildModes,
   flattenTasks,
+  flattenTasksWithParents,
   formatSearchOutput,
   generatePlanWithRepair,
   getLatestSession,
   getProviderMeta,
   getSettingsPath,
   getStateDir,
+  globalDataDir,
   grantScopeFor,
   hasTmux,
   includeGlobFor,
@@ -13745,6 +14206,7 @@ export {
   looksLikePlanAttempt,
   mapAgentTool,
   migrateLegacyPlan,
+  migrateOldConfigDir,
   migratePlanState,
   migrateTask,
   mintDaemonToken,
@@ -13756,6 +14218,7 @@ export {
   parsePartialPlan,
   parsePlanJson,
   parseTaskOpsJson,
+  parseTaskQueryJson,
   pendingEditRulesBlock,
   planDirectLaunch,
   planShellLaunch,
@@ -13764,11 +14227,13 @@ export {
   providerForRunner,
   reEmitPlanPrompt,
   reEmitTaskOpsPrompt,
+  reEmitTaskQueryPrompt,
   readDaemonToken,
   referencePattern,
   removeTaskFromPlan,
   renderPlanMap,
   renderPriorOutputs,
+  renderTaskQueryAnswer,
   renumberTasks,
   repairLoop,
   researchShellWarning,
@@ -13776,10 +14241,12 @@ export {
   resolveArgs,
   resolveDefaultMode,
   resolveModelShortcut,
+  resolveOrderLabel,
   resolvePluginInstallDir,
   resolveProvider,
   resolveProviderFromPrefix,
   resolveResearchShell,
+  resolveSkillInvocation,
   resolveTaskMode,
   resolveWithin,
   retargetTaskRunner,
@@ -13802,7 +14269,10 @@ export {
   summarizeOutput,
   summarizeToolCall,
   taskOpsRejectedPrompt,
+  taskOrderLabel,
+  taskQuerySignature,
   textHasTaskOps,
+  textHasTaskQuery,
   tmuxSessionName,
   tmuxSocketName,
   tmuxWindowName,