@ordewell/core 0.4.9 → 0.4.11

package/dist/index.js

@@ -36,6 +36,7 @@ __export(index_exports, {
   AbstractRunner: () => AbstractRunner,
   AbstractTerminalSession: () => AbstractTerminalSession,
   ApprovalPolicy: () => ApprovalPolicy,
+  BUILTIN_SKILL_NAMES: () => BUILTIN_SKILL_NAMES,
   BaseAiService: () => BaseAiService,
   BaseConfig: () => BaseConfig,
   BaseFileSystem: () => BaseFileSystem,
@@ -94,8 +95,14 @@ __export(index_exports, {
   SYMBOL_LANGUAGES: () => SYMBOL_LANGUAGES,
   Session: () => Session,
   SettingsService: () => SettingsService,
+  SkillsService: () => SkillsService,
   StdioAgentAdapter: () => StdioAgentAdapter,
   TASK_OPS_ENVELOPE_KEY: () => TASK_OPS_ENVELOPE_KEY,
+  TASK_QUERY_ANSWER_OR_OPS: () => TASK_QUERY_ANSWER_OR_OPS,
+  TASK_QUERY_ENVELOPE_KEY: () => TASK_QUERY_ENVELOPE_KEY,
+  TASK_QUERY_FIELDS: () => TASK_QUERY_FIELDS,
+  TASK_QUERY_PROTOCOL: () => TASK_QUERY_PROTOCOL,
+  TASK_QUERY_REMINDER: () => TASK_QUERY_REMINDER,
   TRUNCATED_PLAN_REPAIR_INSTRUCTION: () => TRUNCATED_PLAN_REPAIR_INSTRUCTION,
   TaskOrchestrator: () => TaskOrchestrator,
   TmuxRunner: () => TmuxRunner,
@@ -154,6 +161,7 @@ __export(index_exports, {
   configuredProviders: () => configuredProviders,
   createAiService: () => createAiService,
   createEmptyPlan: () => createEmptyPlan,
+  createSkillsService: () => createSkillsService,
   createTask: () => createTask,
   daemonTokenPath: () => daemonTokenPath,
   defaultLogger: () => defaultLogger,
@@ -180,12 +188,14 @@ __export(index_exports, {
   filterModelsForPrompt: () => filterModelsForPrompt,
   filteredBuildModes: () => filteredBuildModes,
   flattenTasks: () => flattenTasks,
+  flattenTasksWithParents: () => flattenTasksWithParents,
   formatSearchOutput: () => formatSearchOutput,
   generatePlanWithRepair: () => generatePlanWithRepair,
   getLatestSession: () => getLatestSession,
   getProviderMeta: () => getProviderMeta,
   getSettingsPath: () => getSettingsPath,
   getStateDir: () => getStateDir,
+  globalDataDir: () => globalDataDir,
   grantScopeFor: () => grantScopeFor,
   hasTmux: () => hasTmux,
   includeGlobFor: () => includeGlobFor,
@@ -205,6 +215,7 @@ __export(index_exports, {
   looksLikePlanAttempt: () => looksLikePlanAttempt,
   mapAgentTool: () => mapAgentTool,
   migrateLegacyPlan: () => migrateLegacyPlan,
+  migrateOldConfigDir: () => migrateOldConfigDir,
   migratePlanState: () => migratePlanState,
   migrateTask: () => migrateTask,
   mintDaemonToken: () => mintDaemonToken,
@@ -216,6 +227,7 @@ __export(index_exports, {
   parsePartialPlan: () => parsePartialPlan,
   parsePlanJson: () => parsePlanJson,
   parseTaskOpsJson: () => parseTaskOpsJson,
+  parseTaskQueryJson: () => parseTaskQueryJson,
   pendingEditRulesBlock: () => pendingEditRulesBlock,
   planDirectLaunch: () => planDirectLaunch,
   planShellLaunch: () => planShellLaunch,
@@ -224,11 +236,13 @@ __export(index_exports, {
   providerForRunner: () => providerForRunner,
   reEmitPlanPrompt: () => reEmitPlanPrompt,
   reEmitTaskOpsPrompt: () => reEmitTaskOpsPrompt,
+  reEmitTaskQueryPrompt: () => reEmitTaskQueryPrompt,
   readDaemonToken: () => readDaemonToken,
   referencePattern: () => referencePattern,
   removeTaskFromPlan: () => removeTaskFromPlan,
   renderPlanMap: () => renderPlanMap,
   renderPriorOutputs: () => renderPriorOutputs,
+  renderTaskQueryAnswer: () => renderTaskQueryAnswer,
   renumberTasks: () => renumberTasks,
   repairLoop: () => repairLoop,
   researchShellWarning: () => researchShellWarning,
@@ -236,10 +250,12 @@ __export(index_exports, {
   resolveArgs: () => resolveArgs,
   resolveDefaultMode: () => resolveDefaultMode,
   resolveModelShortcut: () => resolveModelShortcut,
+  resolveOrderLabel: () => resolveOrderLabel,
   resolvePluginInstallDir: () => resolvePluginInstallDir,
   resolveProvider: () => resolveProvider,
   resolveProviderFromPrefix: () => resolveProviderFromPrefix,
   resolveResearchShell: () => resolveResearchShell,
+  resolveSkillInvocation: () => resolveSkillInvocation,
   resolveTaskMode: () => resolveTaskMode,
   resolveWithin: () => resolveWithin,
   retargetTaskRunner: () => retargetTaskRunner,
@@ -262,7 +278,10 @@ __export(index_exports, {
   summarizeOutput: () => summarizeOutput,
   summarizeToolCall: () => summarizeToolCall,
   taskOpsRejectedPrompt: () => taskOpsRejectedPrompt,
+  taskOrderLabel: () => taskOrderLabel,
+  taskQuerySignature: () => taskQuerySignature,
   textHasTaskOps: () => textHasTaskOps,
+  textHasTaskQuery: () => textHasTaskQuery,
   tmuxSessionName: () => tmuxSessionName,
   tmuxSocketName: () => tmuxSocketName,
   tmuxWindowName: () => tmuxWindowName,
@@ -283,6 +302,22 @@ module.exports = __toCommonJS(index_exports);
 
 // src/models/Task.ts
 var import_uuid = require("uuid");
+
+// src/order-labels.ts
+function taskOrderLabel(task, parent) {
+  return parent ? `${parent.order}.${task.order}` : String(task.order);
+}
+function resolveOrderLabel(tasks, label) {
+  const parts = label.split(".");
+  if (parts.length > 2 || parts.some((p) => !/^\d+$/.test(p))) return void 0;
+  const [topOrder, childOrder] = parts.map(Number);
+  const top = tasks.find((t) => t.order === topOrder);
+  if (!top) return void 0;
+  if (childOrder === void 0) return top;
+  return top.subtasks.find((s) => s.order === childOrder);
+}
+
+// src/models/Task.ts
 function emptyWarnings() {
   return { deletedCompleted: [], changedCompleted: [], deletedInProgress: [], modifiedInProgress: [], brokenDependencies: [] };
 }
@@ -467,6 +502,15 @@ function createEmptyPlan() {
 function flattenTasks(tasks) {
   return tasks.flatMap((t) => [t, ...flattenTasks(t.subtasks ?? [])]);
 }
+function flattenTasksWithParents(tasks) {
+  const rows = [];
+  const walk = (t, parent) => {
+    rows.push({ task: t, parent });
+    for (const sub of t.subtasks ?? []) walk(sub, t);
+  };
+  for (const t of tasks) walk(t, null);
+  return rows;
+}
 function migrateTask(task) {
   if (!task.assignedModel) {
     task.assignedModel = void 0;
@@ -3093,7 +3137,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;
@@ -3132,33 +3176,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 ?? "");
@@ -4237,7 +4281,7 @@ function formatError(err) {
 var defaultLogger = new ConsoleLogger();
 
 // src/services/BaseAiService.ts
-var import_uuid2 = require("uuid");
+var import_uuid3 = require("uuid");
 
 // src/services/ModeResolver.ts
 function runnerModesFrom(registry, runners) {
@@ -4310,14 +4354,7 @@ function resolveTaskMode(emittedMode, runnerId, runnerModes, autonomousDefault =
 
 // 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) {
@@ -4327,28 +4364,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) {
@@ -4360,8 +4385,323 @@ function modesFor(scope, modes) {
   return scoped;
 }
 
+// src/services/JsonExtractor.ts
+var PLAN_ENVELOPE_KEY = "tasks";
+var TASK_OPS_ENVELOPE_KEY = "taskOps";
+var TASK_QUERY_ENVELOPE_KEY = "taskQuery";
+var PlanParseError = class extends Error {
+  raw;
+  /**
+   * True when the reply was cut off mid-object (output-token limit) rather
+   * than malformed — the two need different repairs: a truncated emission will
+   * be cut at the same point again unless the retry frees context or asks for
+   * terser output.
+   */
+  truncated;
+  /**
+   * True when the JSON parsed fine and a *shape* rule rejected it. The generic
+   * "could not be parsed as JSON" corrective is a lie for these, so the model
+   * re-sends the same object; a semantic rejection must be repaired by naming
+   * the rule it broke.
+   */
+  semantic;
+  constructor(message, raw, opts) {
+    super(message);
+    this.name = "PlanParseError";
+    this.raw = raw;
+    this.truncated = opts?.truncated ?? false;
+    this.semantic = opts?.semantic ?? false;
+  }
+};
+function stripModelNoise(raw) {
+  return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
+}
+function balancedObjectAt(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return { json: text.slice(start, i + 1), balanced: true };
+    }
+  }
+  return { json: text.slice(start), balanced: false };
+}
+function extractObjectsWithKey(raw, key) {
+  const stripped = stripModelNoise(raw);
+  const keyRe = new RegExp(`"${key}"\\s*:`);
+  const matches = [];
+  let firstObject = null;
+  let sawBrace = false;
+  let sawUnbalanced = false;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < stripped.length; i++) {
+    const ch = stripped[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch !== "{") continue;
+    sawBrace = true;
+    const obj = balancedObjectAt(stripped, i);
+    if (obj.balanced && keyRe.test(obj.json)) {
+      matches.push(obj.json);
+      i += obj.json.length - 1;
+      continue;
+    }
+    if (!obj.balanced) sawUnbalanced = true;
+    if (!firstObject && obj.balanced) firstObject = obj.json;
+  }
+  return {
+    matches,
+    fallback: firstObject !== null ? { json: firstObject, balanced: true } : { json: stripped, balanced: false },
+    sawBrace,
+    sawUnbalanced
+  };
+}
+function extractObjectWithBalance(raw) {
+  const { matches, fallback, sawBrace } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);
+  if (matches.length > 0) return { json: matches[0], balanced: true, sawBrace };
+  return { ...fallback, sawBrace };
+}
+function extractJsonObject(raw) {
+  return extractObjectWithBalance(raw).json;
+}
+function stripTrailingCommas(json) {
+  return json.replace(/,(\s*[}\]])/g, "$1");
+}
+function escapeControlCharsInStrings(json) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (const ch of json) {
+    if (inString) {
+      if (escaped) {
+        out += ch;
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        out += ch;
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        out += ch;
+        inString = false;
+        continue;
+      }
+      if (ch === "\n") {
+        out += "\\n";
+        continue;
+      }
+      if (ch === "\r") {
+        out += "\\r";
+        continue;
+      }
+      if (ch === "	") {
+        out += "\\t";
+        continue;
+      }
+      out += ch;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    out += ch;
+  }
+  return out;
+}
+
+// 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:",
     "",
@@ -4377,15 +4717,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() {
@@ -4423,11 +4759,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',
@@ -4449,7 +4785,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",
@@ -4462,35 +4799,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,
@@ -4499,34 +4815,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.",
     "",
@@ -4537,9 +4829,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:",
@@ -4614,6 +4903,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}
 ` : "",
@@ -4721,7 +5015,6 @@ function getPlanTemplate() {
     "",
     "TASK MODE:",
     "{{MODE_GUIDE}}",
-    "{{REVIEW_BLOCK}}",
     "{{VERIFICATION_BLOCK}}",
     "",
     "CONTEXT:",
@@ -4768,10 +5061,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:
@@ -4921,7 +5212,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) {
@@ -4933,153 +5225,11 @@ 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");
 }
 
-// src/services/JsonExtractor.ts
-var PLAN_ENVELOPE_KEY = "tasks";
-var TASK_OPS_ENVELOPE_KEY = "taskOps";
-var PlanParseError = class extends Error {
-  raw;
-  /**
-   * True when the reply was cut off mid-object (output-token limit) rather
-   * than malformed — the two need different repairs: a truncated emission will
-   * be cut at the same point again unless the retry frees context or asks for
-   * terser output.
-   */
-  truncated;
-  /**
-   * True when the JSON parsed fine and a *shape* rule rejected it. The generic
-   * "could not be parsed as JSON" corrective is a lie for these, so the model
-   * re-sends the same object; a semantic rejection must be repaired by naming
-   * the rule it broke.
-   */
-  semantic;
-  constructor(message, raw, opts) {
-    super(message);
-    this.name = "PlanParseError";
-    this.raw = raw;
-    this.truncated = opts?.truncated ?? false;
-    this.semantic = opts?.semantic ?? false;
-  }
-};
-function stripModelNoise(raw) {
-  return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
-}
-function balancedObjectAt(text, start) {
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (ch === '"') inString = true;
-    else if (ch === "{") depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0) return { json: text.slice(start, i + 1), balanced: true };
-    }
-  }
-  return { json: text.slice(start), balanced: false };
-}
-function extractObjectsWithKey(raw, key) {
-  const stripped = stripModelNoise(raw);
-  const keyRe = new RegExp(`"${key}"\\s*:`);
-  const matches = [];
-  let firstObject = null;
-  let sawBrace = false;
-  let sawUnbalanced = false;
-  let inString = false;
-  let escaped = false;
-  for (let i = 0; i < stripped.length; i++) {
-    const ch = stripped[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      continue;
-    }
-    if (ch !== "{") continue;
-    sawBrace = true;
-    const obj = balancedObjectAt(stripped, i);
-    if (obj.balanced && keyRe.test(obj.json)) {
-      matches.push(obj.json);
-      i += obj.json.length - 1;
-      continue;
-    }
-    if (!obj.balanced) sawUnbalanced = true;
-    if (!firstObject && obj.balanced) firstObject = obj.json;
-  }
-  return {
-    matches,
-    fallback: firstObject !== null ? { json: firstObject, balanced: true } : { json: stripped, balanced: false },
-    sawBrace,
-    sawUnbalanced
-  };
-}
-function extractObjectWithBalance(raw) {
-  const { matches, fallback, sawBrace } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);
-  if (matches.length > 0) return { json: matches[0], balanced: true, sawBrace };
-  return { ...fallback, sawBrace };
-}
-function extractJsonObject(raw) {
-  return extractObjectWithBalance(raw).json;
-}
-function stripTrailingCommas(json) {
-  return json.replace(/,(\s*[}\]])/g, "$1");
-}
-function escapeControlCharsInStrings(json) {
-  let out = "";
-  let inString = false;
-  let escaped = false;
-  for (const ch of json) {
-    if (inString) {
-      if (escaped) {
-        out += ch;
-        escaped = false;
-        continue;
-      }
-      if (ch === "\\") {
-        out += ch;
-        escaped = true;
-        continue;
-      }
-      if (ch === '"') {
-        out += ch;
-        inString = false;
-        continue;
-      }
-      if (ch === "\n") {
-        out += "\\n";
-        continue;
-      }
-      if (ch === "\r") {
-        out += "\\r";
-        continue;
-      }
-      if (ch === "	") {
-        out += "\\t";
-        continue;
-      }
-      out += ch;
-      continue;
-    }
-    if (ch === '"') inString = true;
-    out += ch;
-  }
-  return out;
-}
-
 // src/services/PlanValidator.ts
 function parsePlanJson(raw, runners, runnerModes, autonomousDefault = true) {
   const { matches, fallback, sawUnbalanced } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);
@@ -5320,6 +5470,171 @@ function validatePlanModification(ctx) {
   return { valid: allErrors.length === 0, errors: allErrors };
 }
 
+// src/services/TaskOps.ts
+var import_uuid2 = require("uuid");
+
+// 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/TaskEditValidator.ts
+var AI_ONLY_FIELDS = ["assignedModel", "thinkingEffort", "taskMode", "autonomy"];
+function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
+  if (!catalog) return { ok: true };
+  if (assignedModel) {
+    const models = catalog.modelsByRunner[runner];
+    if (models) {
+      const modelId = assignedModel.modelId;
+      if (!models.some((m) => m.modelId === modelId)) {
+        return { ok: false, error: `Runner "${runner}" does not offer model "${modelId}"` };
+      }
+      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
+      if (allowed && !allowed.includes(modelId)) {
+        return { ok: false, error: `Model "${modelId}" is excluded by the allowlist for runner "${runner}"` };
+      }
+    }
+  }
+  if (taskMode !== void 0) {
+    const modes = catalog.runnerModes[runner];
+    if (modes && modes.length > 0 && !modes.some((m) => m.id === taskMode)) {
+      return { ok: false, error: `Runner "${runner}" has no task mode "${taskMode}" \u2014 valid modes: ${modes.map((m) => m.id).join(", ")}` };
+    }
+  }
+  return { ok: true };
+}
+function typeCoherenceCheck(target, changes) {
+  if (!changes.type || changes.type === target.type) return null;
+  if (changes.type === "user") {
+    if (!Array.isArray(changes.userSteps) || changes.userSteps.length === 0) {
+      return { ok: false, error: `"${target.title}" cannot become a manual task without user steps \u2014 include "userSteps" in this edit` };
+    }
+    return { ok: true, clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0) };
+  }
+  if (!changes.prompt || !changes.prompt.trim()) {
+    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt \u2014 include "prompt" in this edit` };
+  }
+  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
+}
+function validateTaskEdit(actor, tasks, taskId, changes, catalog) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  if (actor === "planner") {
+    if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be modified` };
+    if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be modified` };
+  }
+  if (changes.dependencies) {
+    const depCheck = canSetDependencies(tasks, taskId, changes.dependencies);
+    if (!depCheck.ok) return depCheck;
+  }
+  const coherence = typeCoherenceCheck(target, changes);
+  if (coherence && !coherence.ok) return coherence;
+  const runner = changes.assignedRunner ?? target.assignedRunner;
+  const validity = checkModelAndModeValidity(runner, changes.assignedModel, changes.taskMode, catalog);
+  if (!validity.ok) return validity;
+  return coherence ?? { ok: true };
+}
+
 // src/services/TaskOps.ts
 var UPDATABLE_FIELDS = [
   "title",
@@ -5332,7 +5647,8 @@ var UPDATABLE_FIELDS = [
   "thinkingEffort",
   "type",
   "userSteps",
-  "autonomy"
+  "autonomy",
+  "sliceType"
 ];
 function textHasTaskOps(text) {
   return text.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
@@ -5369,18 +5685,41 @@ function parseTaskOpsObject(json, text) {
   }
   return ops;
 }
-function resolveRef(ref, tasks) {
-  if (typeof ref !== "string" && typeof ref !== "number") return void 0;
+function resolveRef(ref, originalScope, liveScope, handleOwner, handleId, opIndex) {
+  if (typeof ref !== "string" && typeof ref !== "number") return { error: `invalid reference "${String(ref)}"` };
   const s = String(ref).trim();
-  const byId = tasks.find((t) => t.id === s);
-  if (byId) return byId;
+  const ownerIdx = handleOwner.get(s);
+  if (ownerIdx !== void 0) {
+    if (ownerIdx >= opIndex) {
+      return { error: `handle "${s}" is defined later in this batch (op ${ownerIdx + 1}) and cannot be referenced yet` };
+    }
+    const id = handleId.get(s);
+    if (!id) return { error: `handle "${s}" was never resolved` };
+    return { id };
+  }
+  const byLiveId = liveScope.find((t) => t.id === s);
+  if (byLiveId) return { id: byLiveId.id };
   const orderStr = s.startsWith("#") ? s.slice(1) : s;
   if (/^\d+$/.test(orderStr)) {
     const order = Number(orderStr);
-    const byOrder = tasks.filter((t) => t.order === order);
-    if (byOrder.length === 1) return byOrder[0];
+    const byOrder = originalScope.filter((t) => t.order === order);
+    if (byOrder.length === 1) return { id: byOrder[0].id };
   }
-  return tasks.find((t) => t.title === s);
+  const byTitle = originalScope.find((t) => t.title === s);
+  if (byTitle) return { id: byTitle.id };
+  return { error: `task "${s}" not found` };
+}
+function refCollidesWithExisting(name, originalFlatAll) {
+  if (originalFlatAll.some((t) => t.id === name)) return true;
+  const orderStr = name.startsWith("#") ? name.slice(1) : name;
+  if (/^\d+$/.test(orderStr) && originalFlatAll.some((t) => t.order === Number(orderStr))) return true;
+  return originalFlatAll.some((t) => t.title === name);
+}
+function findInTasks(tasks, id) {
+  return flattenTasks(tasks).find((t) => t.id === id);
+}
+function findTopLevel(tasks, id) {
+  return tasks.find((t) => t.id === id);
 }
 function detectCycle(tasks) {
   const byId = new Map(tasks.map((t) => [t.id, t]));
@@ -5404,6 +5743,55 @@ function detectCycle(tasks) {
   }
   return null;
 }
+function isPinned(t) {
+  return t.status === "in_progress" || t.status === "completed";
+}
+function repairOrder(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const placed = /* @__PURE__ */ new Set();
+  const movable = tasks.filter((t) => !isPinned(t));
+  const result = [];
+  const blockerOf = (t) => {
+    const id = t.dependencies.find((d) => byId.has(d) && !placed.has(d));
+    return id ? byId.get(id) : void 0;
+  };
+  const place = (t) => {
+    result.push(t);
+    placed.add(t.id);
+  };
+  for (const occupant of tasks) {
+    if (isPinned(occupant)) {
+      const blocker = blockerOf(occupant);
+      if (blocker) return { error: pinnedRefusal(blocker, occupant, "before") };
+      place(occupant);
+      continue;
+    }
+    const next = movable.findIndex((t) => !blockerOf(t));
+    if (next < 0) {
+      const [stuck, pin] = trailToPin(movable[0], blockerOf);
+      return { error: pinnedRefusal(stuck, pin, "after") };
+    }
+    place(movable.splice(next, 1)[0]);
+  }
+  return { tasks: result };
+}
+function trailToPin(task, blockerOf) {
+  let at = task;
+  for (; ; ) {
+    const blocker = blockerOf(at);
+    if (!blocker || isPinned(blocker)) return [at, blocker ?? at];
+    at = blocker;
+  }
+}
+function describeMoves(before, after) {
+  const wasAt = new Map(before.map((t, i) => [t.id, i + 1]));
+  const moved = after.map((t, i) => ({ t, from: wasAt.get(t.id), to: i + 1 })).filter((m) => m.from !== m.to);
+  return moved.length ? moved.map((m) => `"${m.t.title}" #${m.from}\u2192#${m.to}`).join(", ") : null;
+}
+function pinnedRefusal(other, pin, side) {
+  const word = pin.status === "in_progress" ? "running" : "completed";
+  return `"${other.title}" would have to run ${side} "${pin.title}", which is ${word} and cannot be moved`;
+}
 function canMergeTasks(tasks, selectedIds) {
   if (selectedIds.length < 2) return { ok: false, error: "Select at least two tasks to merge" };
   const idSet = new Set(selectedIds);
@@ -5420,15 +5808,6 @@ function canMergeTasks(tasks, selectedIds) {
   sim.push({ ...ordered[0], id: survivorId, title: "__merge_sim__", order: ordered[0].order, dependencies: unionDeps });
   const cycle = detectCycle(sim);
   if (cycle) return { ok: false, error: `Merging would create a dependency cycle involving "${cycle}"` };
-  const orderById = new Map(sim.map((t) => [t.id, t.order]));
-  for (const t of sim) {
-    for (const dep of t.dependencies) {
-      const depOrder = orderById.get(dep);
-      if (depOrder !== void 0 && depOrder >= t.order) {
-        return { ok: false, error: "Merging would break task ordering \u2014 a dependency of the merged set comes after it" };
-      }
-    }
-  }
   return { ok: true };
 }
 function dependentsOf(tasks, taskId) {
@@ -5460,17 +5839,46 @@ function canSplitTask(tasks, taskId) {
   if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be split` };
   return { ok: true };
 }
-function applyTaskOps(currentTasks, ops, runners) {
+function applyTaskOps(currentTasks, ops, runners, catalog) {
   let tasks = JSON.parse(JSON.stringify(currentTasks));
   const errors = [];
   const summary = [];
-  const resolveDeps = (deps) => {
+  const originalFlatAll = flattenTasks(currentTasks);
+  const handleOwner = /* @__PURE__ */ new Map();
+  const handleId = /* @__PURE__ */ new Map();
+  for (const [i, op] of ops.entries()) {
+    const handle = op.handle;
+    if (handle === void 0) continue;
+    if (typeof handle !== "string" || !handle.trim()) {
+      errors.push(`op ${i + 1} (${op.op}): handle must be a non-empty string`);
+      continue;
+    }
+    if (handleOwner.has(handle)) {
+      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" is already used earlier in this batch`);
+      continue;
+    }
+    if (refCollidesWithExisting(handle, originalFlatAll)) {
+      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" collides with an existing task reference`);
+      continue;
+    }
+    handleOwner.set(handle, i);
+  }
+  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
+  const resolveDeps = (deps, opIndex) => {
     const ids = [];
     const bad = [];
+    const liveFlat = flattenTasks(tasks);
     for (const d of Array.isArray(deps) ? deps : []) {
-      const t = resolveRef(d, flattenTasks(tasks));
-      if (t) ids.push(t.id);
-      else bad.push(String(d));
+      const r = resolveRef(d, originalFlatAll, liveFlat, handleOwner, handleId, opIndex);
+      if ("error" in r) {
+        bad.push(`${String(d)} (${r.error})`);
+        continue;
+      }
+      if (!liveFlat.some((t) => t.id === r.id)) {
+        bad.push(`${String(d)} (no longer exists in this batch)`);
+        continue;
+      }
+      ids.push(r.id);
     }
     return { ids, bad };
   };
@@ -5478,41 +5886,47 @@ function applyTaskOps(currentTasks, ops, runners) {
     const label = `op ${i + 1} (${op.op})`;
     switch (op.op) {
       case "update": {
-        const target = resolveRef(op.taskId, flattenTasks(tasks));
-        if (!target) {
-          errors.push(`${label}: task "${op.taskId}" not found`);
-          break;
-        }
-        if (target.status === "in_progress") {
-          errors.push(`${label}: "${target.title}" is running and cannot be modified`);
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
           break;
         }
-        if (target.status === "completed") {
-          errors.push(`${label}: "${target.title}" is completed and cannot be modified`);
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
           break;
         }
         const changes = {};
         for (const key of UPDATABLE_FIELDS) {
           if (op.changes && key in op.changes) changes[key] = op.changes[key];
         }
+        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
+          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
+          break;
+        }
+        const changesForCheck = { ...changes };
+        delete changesForCheck.dependencies;
+        const check = validateTaskEdit("planner", flattenTasks(tasks), target.id, changesForCheck, catalog);
+        if (!check.ok) {
+          errors.push(`${label}: ${check.error}`);
+          break;
+        }
+        for (const field of check.clear ?? []) changes[field] = void 0;
         if ("dependencies" in changes) {
-          const { ids, bad } = resolveDeps(changes.dependencies);
+          const { ids, bad } = resolveDeps(changes.dependencies, i);
           if (bad.length) {
             errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
             break;
           }
           changes.dependencies = ids.filter((id) => id !== target.id);
         }
-        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
-          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
-          break;
-        }
         if (Object.keys(changes).length === 0) {
           errors.push(`${label}: no valid changes provided`);
           break;
         }
         tasks = updateTaskInPlan(tasks, target.id, changes);
-        summary.push(`Updated "${target.title}" (${Object.keys(changes).join(", ")})`);
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        summary.push(`Updated "${target.title}" (${Object.keys(changes).join(", ")})${clearedNote}`);
         break;
       }
       case "add": {
@@ -5521,27 +5935,39 @@ function applyTaskOps(currentTasks, ops, runners) {
           errors.push(`${label}: new task needs a title`);
           break;
         }
-        const { ids, bad } = resolveDeps(spec.dependencies);
+        const { ids, bad } = resolveDeps(spec.dependencies, i);
         if (bad.length) {
           errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
           break;
         }
         const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : runners[0];
+        const validity = checkModelAndModeValidity(runner, spec.assignedModel, spec.taskMode, catalog);
+        if (!validity.ok) {
+          errors.push(`${label}: ${validity.error}`);
+          break;
+        }
+        const newId = (0, import_uuid2.v4)();
         tasks = addTaskToPlan(tasks, {
           ...spec,
-          id: void 0,
+          id: newId,
           dependencies: ids,
           assignedRunner: runner,
           description: spec.description ?? spec.title,
           prompt: spec.prompt ?? spec.description ?? spec.title
         });
+        if (op.handle) handleId.set(op.handle, newId);
         summary.push(`Added "${spec.title}"`);
         break;
       }
       case "remove": {
-        const target = resolveRef(op.taskId, flattenTasks(tasks));
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
         if (!target) {
-          errors.push(`${label}: task "${op.taskId}" not found`);
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
           break;
         }
         if (target.status === "in_progress") {
@@ -5557,7 +5983,13 @@ function applyTaskOps(currentTasks, ops, runners) {
         break;
       }
       case "reorder": {
-        const resolved = (op.taskIds ?? []).map((r) => resolveRef(r, tasks));
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const badRef = refs.find((r) => "error" in r);
+        if (badRef) {
+          errors.push(`${label}: ${badRef.error}`);
+          break;
+        }
+        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
         if (resolved.some((t) => !t)) {
           errors.push(`${label}: unknown task in reorder list`);
           break;
@@ -5573,9 +6005,15 @@ function applyTaskOps(currentTasks, ops, runners) {
         break;
       }
       case "merge": {
-        const resolved = (op.taskIds ?? []).map((r) => resolveRef(r, tasks));
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const badRef = refs.find((r) => "error" in r);
+        if (badRef) {
+          errors.push(`${label}: ${badRef.error}`);
+          break;
+        }
+        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
         if (resolved.some((t) => !t)) {
-          errors.push(`${label}: unknown task in merge list`);
+          errors.push(`${label}: unknown task in merge list (already removed, merged, or split by an earlier op)`);
           break;
         }
         const toMerge = resolved.map((t) => t).sort((a, b) => a.order - b.order);
@@ -5590,7 +6028,7 @@ function applyTaskOps(currentTasks, ops, runners) {
         }
         const idSet = new Set(toMerge.map((t) => t.id));
         const unionDepsRaw = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
-        const { ids, bad } = resolveDeps(unionDepsRaw);
+        const { ids, bad } = resolveDeps(unionDepsRaw, i);
         if (bad.length) {
           errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
           break;
@@ -5631,11 +6069,17 @@ function applyTaskOps(currentTasks, ops, runners) {
         }
         if (!inserted) result.push(mergedTask);
         tasks = renumberTasks(result);
+        if (op.handle) handleId.set(op.handle, mergedId);
         summary.push(`Merged ${toMerge.length} tasks into "${spec.title}"`);
         break;
       }
       case "split": {
-        const target = resolveRef(op.taskId, tasks);
+        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findTopLevel(tasks, ref.id);
         if (!target) {
           errors.push(`${label}: task "${op.taskId}" not found`);
           break;
@@ -5656,16 +6100,16 @@ function applyTaskOps(currentTasks, ops, runners) {
         const newTasks = [];
         let prevId;
         let buildError = false;
-        for (let i2 = 0; i2 < parts.length; i2++) {
-          const spec = parts[i2];
+        for (let p = 0; p < parts.length; p++) {
+          const spec = parts[p];
           if (!spec || !spec.title) {
-            errors.push(`${label}: split part ${i2 + 1} needs a title`);
+            errors.push(`${label}: split part ${p + 1} needs a title`);
             buildError = true;
             break;
           }
           let deps;
-          if (i2 === 0) {
-            const { ids, bad } = resolveDeps(target.dependencies);
+          if (p === 0) {
+            const { ids, bad } = resolveDeps(target.dependencies, i);
             if (bad.length) {
               errors.push(`${label}: split part 1 unknown dependencies: ${bad.join(", ")}`);
               buildError = true;
@@ -5703,9 +6147,60 @@ function applyTaskOps(currentTasks, ops, runners) {
           result.push({ ...t, dependencies: t.dependencies.map((d) => d === target.id ? tailId : d) });
         }
         tasks = renumberTasks(result);
+        if (op.handle) handleId.set(op.handle, tailId);
         summary.push(`Split "${target.title}" into ${newTasks.length} tasks`);
         break;
       }
+      case "rearm": {
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be re-armed`);
+          break;
+        }
+        const changes = {};
+        for (const key of UPDATABLE_FIELDS) {
+          if (op.changes && key in op.changes) changes[key] = op.changes[key];
+        }
+        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
+          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
+          break;
+        }
+        const changesForCheck = { ...changes };
+        delete changesForCheck.dependencies;
+        const check = validateTaskEdit("direct", flattenTasks(tasks), target.id, changesForCheck, catalog);
+        if (!check.ok) {
+          errors.push(`${label}: ${check.error}`);
+          break;
+        }
+        for (const field of check.clear ?? []) changes[field] = void 0;
+        if ("dependencies" in changes) {
+          const { ids, bad } = resolveDeps(changes.dependencies, i);
+          if (bad.length) {
+            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+            break;
+          }
+          changes.dependencies = ids.filter((id) => id !== target.id);
+        }
+        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0 });
+        for (const dep of flattenTasks(tasks)) {
+          if (dep.status === "blocked" && dep.dependencies.includes(target.id)) {
+            tasks = updateTaskInPlan(tasks, dep.id, { status: "pending" });
+          }
+        }
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        const changedNote = Object.keys(changes).length ? ` (${Object.keys(changes).join(", ")})` : "";
+        summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
+        break;
+      }
       default:
         errors.push(`${label}: unknown op "${op.op}"`);
     }
@@ -5721,13 +6216,14 @@ function applyTaskOps(currentTasks, ops, runners) {
     }
     const cycleAt = detectCycle(flat);
     if (cycleAt) errors.push(`Dependency cycle detected involving "${cycleAt}"`);
-    const orderById = new Map(tasks.map((t) => [t.id, t.order]));
-    for (const t of tasks) {
-      for (const dep of t.dependencies) {
-        const depOrder = orderById.get(dep);
-        if (depOrder !== void 0 && depOrder >= t.order) {
-          errors.push(`"${t.title}" is ordered before its dependency; move the dependency earlier`);
-        }
+    if (!errors.length) {
+      const repaired = repairOrder(tasks);
+      if ("error" in repaired) {
+        errors.push(repaired.error);
+      } else {
+        const moves = describeMoves(tasks, repaired.tasks);
+        if (moves) summary.push(`Reordered to keep dependencies first: ${moves}`);
+        tasks = renumberTasks(repaired.tasks);
       }
     }
   }
@@ -5757,6 +6253,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- ")}
@@ -5783,6 +6282,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) };
@@ -5916,8 +6425,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) => ({
@@ -5938,8 +6447,8 @@ function projectOpenAi(specs) {
     }
   }));
 }
-function toOpenAiTools(includeSubagents = false) {
-  return projectOpenAi(withSpawn(includeSubagents));
+function toOpenAiTools() {
+  return projectOpenAi(withSpawn());
 }
 function toOpenAiSubagentTools() {
   return projectOpenAi(subagentToolSpecs());
@@ -5950,8 +6459,8 @@ var SCHEMA_TYPE = {
   array: import_generative_ai.SchemaType.ARRAY,
   boolean: import_generative_ai.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] = {
@@ -6048,33 +6557,10 @@ function compactResearchResults(resultsText, maxChars = COMPACTION_LIMITS.resear
   return (blocks[0].lines.length === 0 ? texts.slice(1) : texts).join("\n");
 }
 
-// src/utils/prdStore.ts
-var fs = __toESM(require("fs"));
-var path4 = __toESM(require("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) {
@@ -6101,8 +6587,8 @@ ${firstContext.dirStructure}
   return contextStr;
 }
 var ContextCollector = class {
-  constructor(fs10, registry) {
-    this.fs = fs10;
+  constructor(fs12, registry) {
+    this.fs = fs12;
     this.registry = registry;
   }
   fs;
@@ -6183,9 +6669,9 @@ function summarizeToolCall(tool, argsJson, toolLabel) {
       const scope = args.include ? ` in ${args.include}` : "";
       return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
     }
-    const path17 = args.filePath || args.file_path || args.path;
-    if (path17) {
-      const basename = String(path17).split("/").pop() || String(path17);
+    const path20 = args.filePath || args.file_path || args.path;
+    if (path20) {
+      const basename = String(path20).split("/").pop() || String(path20);
       return `${display} ${basename}`;
     }
     if (args.pattern) {
@@ -6219,22 +6705,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 });
@@ -6245,13 +6731,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++) {
@@ -6268,7 +6754,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 = {
@@ -6326,8 +6812,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;
   }
@@ -6383,10 +6867,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 };
@@ -6397,20 +6878,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 = "";
@@ -6426,21 +6907,21 @@ var BaseAiService = class _BaseAiService {
     const parallelIndexes = toolCalls.flatMap((tc, i) => PARALLEL_SAFE_TOOLS.has(tc.name) ? [i] : []);
     await Promise.all([
       spawnIndexes.length > 0 ? mapWithConcurrency(spawnIndexes, SUBAGENT_LIMITS.maxConcurrent, async (i) => {
-        const subagentId = (0, import_uuid2.v4)();
+        const subagentId = (0, import_uuid3.v4)();
         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) + `
@@ -6572,7 +7053,6 @@ ${llmOutput}
           researchLog
         };
       }
-      if (extractPrdBlock(turn.text)) ctx.prdCaptured = true;
       const reply = classifyPlannerReply(turn.text, {
         runners: ctx.runners,
         runnerModes: ctx.runnerModes,
@@ -6581,17 +7061,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
@@ -6603,6 +7077,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++;
@@ -6626,7 +7107,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({
@@ -6653,7 +7134,7 @@ ${llmOutput}
       if (!turn.hasToolCalls) break;
       const { toolResults, logEntries, resultsText } = await this.executeToolCalls(
         turn.toolCalls,
-        fs10,
+        fs12,
         onProgress,
         fetcher,
         step,
@@ -6789,9 +7270,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 = [
@@ -6830,8 +7308,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;
@@ -6889,11 +7366,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()}
 
@@ -6904,17 +7381,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}
@@ -6930,12 +7407,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);
@@ -7118,7 +7595,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,
@@ -7127,16 +7603,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 });
@@ -7146,7 +7619,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 })
     );
@@ -7156,8 +7629,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,
@@ -7175,15 +7647,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.
 
@@ -7195,20 +7666,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}
@@ -7224,12 +7695,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);
@@ -7318,21 +7789,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)` : "";
@@ -7397,7 +7875,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());
@@ -7576,6 +8055,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();
@@ -7583,6 +8063,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
@@ -7590,12 +8071,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) {
@@ -7626,6 +8142,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);
@@ -7637,6 +8154,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);
@@ -7661,6 +8179,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);
     });
@@ -7671,6 +8190,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",
@@ -7692,6 +8212,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). */
@@ -7700,6 +8221,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) {
@@ -8105,6 +8629,7 @@ var TaskOrchestrator = class {
       this.store.markAwaitingUser(taskId);
       this.emit("onCheckpoint", { taskId, taskTitle: task.title, summary });
     });
+    this.verifier.onIdleChange(() => this.emit("onTaskChanged"));
   }
   config;
   notifications;
@@ -8129,6 +8654,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;
   }
@@ -8516,8 +9045,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;
@@ -8544,148 +9075,43 @@ ${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()
       });
-      const session = await this.terminalRunner.spawn({
-        taskId: task.id,
-        runner,
-        prompt: finalPrompt,
-        modelId: task.assignedModel?.modelId,
-        thinkingEffort: task.assignedModel?.thinkingEffort,
-        modelVariants: task.assignedModel?.availableVariants,
-        mode: task.taskMode ?? "build",
-        cwd,
-        registry: this.registry ?? void 0,
-        order: task.order,
-        title: task.title
-      });
-      if (!this.startingTaskIds.delete(task.id)) {
-        session.kill();
-        this.store.markPending(task.id);
-        this.emit("onTaskChanged");
-        return;
-      }
-      this.activeTaskSessions.set(task.id, session.id);
-      this.verifier.watch(task, session);
-      this.emit("onTaskChanged");
-      this.notifications.info(`Task "${task.title}" started (${runner})`);
-    } catch (err) {
-      this.startingTaskIds.delete(task.id);
-      this.store.markPending(task.id);
-      this.onHold.add(task.id);
-      this.notifications.error(`Failed to start task "${task.title}": ${err}`);
-      this.emit("onTaskChanged");
-      await this.tick();
-    }
-  }
-};
-
-// 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 session = await this.terminalRunner.spawn({
+        taskId: task.id,
+        runner,
+        prompt: finalPrompt,
+        modelId: task.assignedModel?.modelId,
+        thinkingEffort: task.assignedModel?.thinkingEffort,
+        modelVariants: task.assignedModel?.availableVariants,
+        mode: task.taskMode ?? "build",
+        cwd,
+        registry: this.registry ?? void 0,
+        order: task.order,
+        title: task.title
       });
-    }
-    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) });
+      if (!this.startingTaskIds.delete(task.id)) {
+        session.kill();
+        this.store.markPending(task.id);
+        this.emit("onTaskChanged");
+        return;
       }
-      return task;
+      this.activeTaskSessions.set(task.id, session.id);
+      this.verifier.watch(task, session);
+      this.emit("onTaskChanged");
+      this.notifications.info(`Task "${task.title}" started (${runner})`);
+    } catch (err) {
+      this.startingTaskIds.delete(task.id);
+      this.store.markPending(task.id);
+      this.onHold.add(task.id);
+      this.notifications.error(`Failed to start task "${task.title}": ${err}`);
+      this.emit("onTaskChanged");
+      await this.tick();
     }
-    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) {
@@ -8823,7 +9249,7 @@ var osMod = __toESM(require("os"));
 var import_child_process = require("child_process");
 var import_util = require("util");
 var os2 = __toESM(require("os"));
-var path5 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var execAsync = (0, import_util.promisify)(import_child_process.exec);
 var LOGIN_SHELL_TIMEOUT_MS = 5e3;
 var PATH_MARKER = "__ORDEWELL_PATH__";
@@ -8834,40 +9260,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"),
@@ -8877,7 +9303,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 = {}) {
@@ -8906,14 +9332,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;
@@ -8933,6 +9359,50 @@ function withPath(base, resolvedPath, overrides = {}) {
   return env;
 }
 
+// src/utils/globalDataDir.ts
+var fs = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var os3 = __toESM(require("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
 var fsSync2 = __toESM(require("fs"));
 var path6 = __toESM(require("path"));
@@ -9258,7 +9728,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}`,
@@ -9788,12 +10258,14 @@ var ModelDiscovery = class {
 // src/services/ModelCatalog.ts
 var fs2 = __toESM(require("fs"));
 var path8 = __toESM(require("path"));
-var os3 = __toESM(require("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(/\/+$/, "");
@@ -9836,7 +10308,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 {
@@ -9844,7 +10316,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");
@@ -9857,7 +10329,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(
@@ -10398,12 +10870,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;
@@ -10438,7 +10917,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);
         }
       }));
@@ -10470,6 +10949,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);
@@ -10548,6 +11028,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)) {
@@ -10557,6 +11038,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",
@@ -10581,6 +11064,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 }] }
@@ -10591,6 +11075,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 —
@@ -10615,8 +11100,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 ?? {} });
           }
@@ -10625,11 +11114,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
           });
         }
@@ -11049,6 +11542,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 });
@@ -11116,6 +11611,7 @@ ${this.stderrTail.trim()}` : ""}`);
       return;
     }
     const seen = /* @__PURE__ */ new Set();
+    this.turnHasText = false;
     const streamAbort = new AbortController();
     let connected = () => {
     };
@@ -11184,7 +11680,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) {
@@ -11272,14 +11771,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() {
@@ -11351,6 +11850,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) {
@@ -11433,9 +11933,6 @@ var CliAgentAiService = class {
       req.runners,
       req.runnerModes,
       req.autonomousDefault ?? true,
-      req.grillMeEnabled ?? false,
-      req.prdEnabled ?? false,
-      req.reviewEnabled ?? false,
       req.verificationEnabled ?? false,
       true
     );
@@ -11450,10 +11947,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);
@@ -11481,8 +11975,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;
@@ -11491,13 +11985,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 };
@@ -11515,7 +12012,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,
@@ -11523,20 +12031,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++;
@@ -11544,6 +12046,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++;
@@ -11554,7 +12063,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;
@@ -11574,6 +12083,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) => {
@@ -11613,6 +12123,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 });
@@ -11643,7 +12156,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) {
@@ -11702,10 +12215,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.",
@@ -11722,8 +12232,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() }
     ];
@@ -12046,6 +12556,181 @@ function retargetTaskRunner(task, runner, catalog) {
   return { assignedRunner: runner, ...runnerAssignment(catalog, task) };
 }
 
+// src/services/SkillsService.ts
+var fs4 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+
+// src/services/builtinSkills.ts
+var path10 = __toESM(require("path"));
+var import_url = require("url");
+var import_meta = {};
+function builtinSkillsDir() {
+  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path10.dirname((0, import_url.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 {
@@ -12067,11 +12752,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) {
@@ -12093,27 +12779,27 @@ function executionSummary(tasks) {
 }
 
 // src/utils/sessionStore.ts
-var fs5 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 
 // src/utils/fsHelpers.ts
-var fs4 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path12 = __toESM(require("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;
   }
@@ -12128,7 +12814,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) {
@@ -12163,17 +12849,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}`);
@@ -12188,10 +12874,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) {
@@ -12202,11 +12888,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}`);
@@ -12236,11 +12922,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) {
@@ -12249,7 +12935,36 @@ function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   return false;
 }
 
+// src/utils/prdStore.ts
+var fs7 = __toESM(require("fs"));
+var path14 = __toESM(require("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);
@@ -12259,6 +12974,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;
@@ -12286,6 +13012,7 @@ var Session = class {
   unsubObserver = null;
   hostSessionId;
   currentSessionId;
+  skillsService;
   constructor(deps) {
     this.config = deps.config;
     this.registry = deps.registry;
@@ -12304,6 +13031,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",
@@ -12398,7 +13126,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" });
@@ -12416,7 +13144,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;
@@ -12486,6 +13214,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;
   }
@@ -12613,7 +13356,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;
@@ -12622,7 +13365,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();
@@ -12632,22 +13375,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),
@@ -12659,19 +13398,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);
@@ -12681,6 +13423,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();
@@ -12690,11 +13434,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
@@ -12702,7 +13509,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",
@@ -12714,11 +13521,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 } };
@@ -12738,6 +13549,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
@@ -12747,44 +13604,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:
@@ -12824,7 +13685,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;
@@ -12834,11 +13695,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),
@@ -12851,6 +13708,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;
@@ -13051,15 +13919,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)),
@@ -14059,13 +14934,12 @@ var TmuxRunner = class extends AbstractRunner {
 // src/utils/daemonToken.ts
 var import_crypto2 = require("crypto");
 var import_fs2 = require("fs");
-var import_os2 = require("os");
 var import_path2 = require("path");
 var BEARER_PREFIX = "bearer ";
 var DAEMON_TOKEN_SUBPROTOCOL_PREFIX = "ordewell.token.";
 var DAEMON_SUBPROTOCOL = "ordewell.v1";
 function configDir() {
-  return (0, import_path2.join)((0, import_os2.homedir)(), ".config", "ordewell");
+  return globalDataDir();
 }
 function daemonTokenPath(port) {
   return (0, import_path2.join)(configDir(), `server-${port}.token`);
@@ -14129,19 +15003,18 @@ function tokensMatch(presented, expected) {
 }
 
 // src/plugins/RunnerRegistry.ts
-var fs7 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
-var os5 = __toESM(require("os"));
+var fs9 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
+var os4 = __toESM(require("os"));
 var import_child_process9 = require("child_process");
 var import_crypto3 = require("crypto");
 
 // src/plugins/FsPluginStore.ts
-var fs6 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-var os4 = __toESM(require("os"));
+var fs8 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 
 // src/plugins/pluginNames.ts
-var path12 = __toESM(require("path"));
+var path15 = __toESM(require("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) {
@@ -14156,10 +15029,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;
@@ -14174,13 +15047,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;
@@ -14188,31 +15061,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() {
@@ -14220,10 +15093,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 [];
     }
@@ -14231,7 +15104,7 @@ var FsPluginStore = class {
   }
   listDir(dir) {
     try {
-      return fs6.readdirSync(dir);
+      return fs8.readdirSync(dir);
     } catch {
       return [];
     }
@@ -14240,7 +15113,7 @@ var FsPluginStore = class {
     return loadManifestFromDir(pluginDir);
   }
   copyDir(sourceDir, destDir) {
-    copyDirSync(sourceDir, destDir);
+    copyDirSync3(sourceDir, destDir);
   }
   removeDir(dir) {
     rmDirSync(dir);
@@ -14249,20 +15122,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);
   }
 };
 
@@ -14689,7 +15562,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}`);
     }
@@ -14701,7 +15574,7 @@ var RunnerRegistry = class {
   }
   installFromGit(url) {
     const validated = assertInstallablePluginUrl(url);
-    const tmpDir = path14.join(os5.tmpdir(), `ordewell-plugin-${(0, import_crypto3.randomBytes)(12).toString("hex")}`);
+    const tmpDir = path17.join(os4.tmpdir(), `ordewell-plugin-${(0, import_crypto3.randomBytes)(12).toString("hex")}`);
     this.store.ensureDir(tmpDir);
     try {
       try {
@@ -14714,7 +15587,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()}`);
         }
@@ -14762,7 +15635,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,
@@ -14794,8 +15667,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:
@@ -14821,30 +15694,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
-var fs8 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path18 = __toESM(require("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.`);
@@ -14859,29 +15732,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
-var fs9 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
-var os6 = __toESM(require("os"));
+var fs11 = __toESM(require("fs"));
+var path19 = __toESM(require("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;
@@ -14914,43 +15782,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;
   }
@@ -14959,14 +15803,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];
   }
@@ -15016,18 +15852,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;
@@ -15043,14 +15874,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();
   }
 };
@@ -15097,6 +15928,7 @@ var PlannerModelMemory = class {
   AbstractRunner,
   AbstractTerminalSession,
   ApprovalPolicy,
+  BUILTIN_SKILL_NAMES,
   BaseAiService,
   BaseConfig,
   BaseFileSystem,
@@ -15155,8 +15987,14 @@ var PlannerModelMemory = class {
   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,
@@ -15215,6 +16053,7 @@ var PlannerModelMemory = class {
   configuredProviders,
   createAiService,
   createEmptyPlan,
+  createSkillsService,
   createTask,
   daemonTokenPath,
   defaultLogger,
@@ -15241,12 +16080,14 @@ var PlannerModelMemory = class {
   filterModelsForPrompt,
   filteredBuildModes,
   flattenTasks,
+  flattenTasksWithParents,
   formatSearchOutput,
   generatePlanWithRepair,
   getLatestSession,
   getProviderMeta,
   getSettingsPath,
   getStateDir,
+  globalDataDir,
   grantScopeFor,
   hasTmux,
   includeGlobFor,
@@ -15266,6 +16107,7 @@ var PlannerModelMemory = class {
   looksLikePlanAttempt,
   mapAgentTool,
   migrateLegacyPlan,
+  migrateOldConfigDir,
   migratePlanState,
   migrateTask,
   mintDaemonToken,
@@ -15277,6 +16119,7 @@ var PlannerModelMemory = class {
   parsePartialPlan,
   parsePlanJson,
   parseTaskOpsJson,
+  parseTaskQueryJson,
   pendingEditRulesBlock,
   planDirectLaunch,
   planShellLaunch,
@@ -15285,11 +16128,13 @@ var PlannerModelMemory = class {
   providerForRunner,
   reEmitPlanPrompt,
   reEmitTaskOpsPrompt,
+  reEmitTaskQueryPrompt,
   readDaemonToken,
   referencePattern,
   removeTaskFromPlan,
   renderPlanMap,
   renderPriorOutputs,
+  renderTaskQueryAnswer,
   renumberTasks,
   repairLoop,
   researchShellWarning,
@@ -15297,10 +16142,12 @@ var PlannerModelMemory = class {
   resolveArgs,
   resolveDefaultMode,
   resolveModelShortcut,
+  resolveOrderLabel,
   resolvePluginInstallDir,
   resolveProvider,
   resolveProviderFromPrefix,
   resolveResearchShell,
+  resolveSkillInvocation,
   resolveTaskMode,
   resolveWithin,
   retargetTaskRunner,
@@ -15323,7 +16170,10 @@ var PlannerModelMemory = class {
   summarizeOutput,
   summarizeToolCall,
   taskOpsRejectedPrompt,
+  taskOrderLabel,
+  taskQuerySignature,
   textHasTaskOps,
+  textHasTaskQuery,
   tmuxSessionName,
   tmuxSocketName,
   tmuxWindowName,