@hizliemre/horse-code 0.3.0 → 0.4.0

package/dist/{chunk-LLL7QWXB.js → chunk-BFIZMM4G.js}

@@ -3,20 +3,20 @@ import {
   loadMigratedSync,
   migratedNotice
 } from "./chunk-63E73TGI.js";
-import {
-  telemetry
-} from "./chunk-AE36LLL2.js";
 import {
   readBriefSync
-} from "./chunk-6OSEQOYY.js";
+} from "./chunk-6S4WWQMN.js";
+import {
+  telemetry
+} from "./chunk-JLWQCA7B.js";
 import {
   everTraceable,
   readTraceSync
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import {
   areaOf,
   loadGraphSync
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 
 // src/tools/read.ts
 import { readFile } from "fs/promises";

package/dist/chunk-CYLPQWIF.js

@@ -0,0 +1,214 @@
+import {
+  runRoleAgent
+} from "./chunk-JLWQCA7B.js";
+
+// src/tools/registry.ts
+import { z } from "zod";
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Registered and callable, but whose SCHEMA is withheld until something asks for it.
+   *
+   * A schema is paid for on every turn, whether or not the tool is ever used. Measured across twelve runs:
+   * 49 MCP tool schemas came to 86,620 characters (~21,655 tokens), 242 calls carried them, and that is
+   * ~5.2M of the 21.7M input tokens billed — 24% of everything — for FIVE tool calls, of two distinct tools.
+   * The catalogue that names them costs 900 characters (see MAX_TOOL_NOTE_CHARS); it is the schemas that are
+   * expensive, and a schema nobody is about to use buys nothing.
+   */
+  deferred = /* @__PURE__ */ new Set();
+  /** Bumped by anything that changes what `schemas()` would return, so the derivation can be cached. */
+  version = 0;
+  cached;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+    this.deferred.delete(tool.name);
+    this.version++;
+  }
+  /** Callable by name from the moment it is registered; sent to the model only once {@link surface}d. */
+  registerDeferred(tool) {
+    this.tools.set(tool.name, tool);
+    this.deferred.add(tool.name);
+    this.version++;
+  }
+  /**
+   * Hands over the schemas for these names, from the next turn onward.
+   *
+   * Returns the ones that were actually withheld, so a caller can say what it just made available and stay
+   * quiet about what was already there.
+   */
+  surface(names) {
+    const opened = names.filter((n) => this.deferred.has(n));
+    for (const n of opened) this.deferred.delete(n);
+    if (opened.length) this.version++;
+    return opened;
+  }
+  /** Everything still withheld — what a search tool searches. */
+  deferredTools() {
+    return [...this.deferred].map((n) => this.tools.get(n)).filter((t) => t !== void 0);
+  }
+  /**
+   * A withheld tool is still CALLABLE.
+   *
+   * A model that reads the catalogue and calls the name straight off is right, and refusing it to enforce a
+   * search step would spend a turn teaching it a rule that exists for our benefit, not its.
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  /**
+   * Tool schemas to send to the LLM: zod parameters → JSON Schema (zod 4 native). Withheld ones are omitted.
+   *
+   * …and so is a tool that has withdrawn itself. `Tool.broken` was documented as being read "where tools are
+   * OFFERED, so a broken one stops being handed to fresh agents" — and only `find_tool` ever read it, which
+   * covers the deferred tools and not the ones already on the list.
+   *
+   * Measured on one run: `mcp__angular-cli__list_projects` answered its first caller with a reply that failed
+   * its own declared output schema and withdrew itself. It was then offered to seventeen more agents, who
+   * called it twenty-eight more times. Every one of those was answered instantly, without touching the
+   * server — and still cost a whole model turn to learn what the run already knew.
+   */
+  schemas() {
+    const withdrawn = this.list().reduce((n, t) => n + (t.broken === void 0 ? 0 : 1), 0);
+    if (this.cached?.version === this.version && this.cached.withdrawn === withdrawn) return this.cached.schemas;
+    const schemas = this.list().filter((t) => !this.deferred.has(t.name) && t.broken === void 0).map((t) => ({
+      name: t.name,
+      description: t.description,
+      // MCP tools already carry a JSON Schema; everyone else derives it from their zod parameters.
+      parameters: t.rawSchema ?? z.toJSONSchema(t.parameters, { target: "draft-7" })
+    }));
+    this.cached = { version: this.version, withdrawn, schemas };
+    return schemas;
+  }
+};
+
+// src/core/types.ts
+var DEADLINE_MESSAGE = "the model did not answer within its deadline";
+var CHAIN_BUDGET_MESSAGE = "the chain's total budget ran out before this model was given a fair turn";
+
+// src/agent/structured.ts
+function valueAt(args, path) {
+  let cur = args;
+  for (const key of path) {
+    if (typeof cur !== "object" || cur === null) return void 0;
+    cur = cur[key];
+  }
+  return cur;
+}
+function whatWasWrong(issues, args) {
+  return issues.map((i) => {
+    const where = i.path.length ? i.path.join(".") : void 0;
+    const got = valueAt(args, i.path);
+    const shown = got === void 0 ? "nothing" : JSON.stringify(got);
+    const head = where ? `${where}: ${i.message}` : i.message;
+    if (got === void 0 && /received\s+(undefined|null|nothing)/i.test(i.message)) {
+      const parent = i.path.length > 1 ? valueAt(args, i.path.slice(0, -1)) : args;
+      const sent = parent && typeof parent === "object" ? Object.keys(parent) : [];
+      return sent.length ? `${head} \u2014 you sent only ${sent.map((k) => `\`${k}\``).join(", ")}` : head;
+    }
+    return `${head} \u2014 got ${shown.length > 120 ? `${shown.slice(0, 120)}\u2026` : shown}`;
+  }).join("; ");
+}
+function buildSubmitTool(schema) {
+  let box;
+  const tool = {
+    name: "submit",
+    description: "When you are done, submit your result in structured form with this tool.",
+    permissionLevel: "safe",
+    parameters: schema,
+    run: async (rawArgs) => {
+      const parsed = schema.safeParse(rawArgs);
+      if (!parsed.success) {
+        return { content: `submit: invalid output: ${whatWasWrong(parsed.error.issues, rawArgs)}`, isError: true };
+      }
+      box = { value: parsed.data };
+      return { content: "received", isError: false };
+    }
+  };
+  return { tool, result: () => box };
+}
+function extractStructured(text, schema) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  const candidates = [trimmed];
+  const block = trimmed.match(/\{[\s\S]*\}/);
+  if (block) candidates.push(block[0]);
+  for (const c of candidates) {
+    try {
+      const parsed = schema.safeParse(JSON.parse(c));
+      if (parsed.success) return parsed.data;
+    } catch {
+    }
+  }
+  return void 0;
+}
+var TURN_LIMIT_RE = /maximum turn count exceeded/i;
+async function runStructuredRole(opts, schema, maxAttempts = 2) {
+  const handle = buildSubmitTool(schema);
+  const registry = new ToolRegistry();
+  for (const t of opts.tools.list()) registry.register(t);
+  registry.register(handle.tool);
+  const chain = [opts.model, ...opts.fallbacks ?? []];
+  const total = opts.totalMs ? AbortSignal.timeout(opts.totalMs) : void 0;
+  const outOfTime = () => total?.aborted === true;
+  const signalFor = () => {
+    const parts = [opts.signal];
+    if (total) parts.push(total);
+    if (opts.perAttemptMs) parts.push(AbortSignal.timeout(opts.perAttemptMs));
+    return parts.length === 1 ? opts.signal : AbortSignal.any(parts);
+  };
+  let lastError;
+  for (let ci = 0; ci < chain.length; ci++) {
+    const model = chain[ci];
+    if (ci > 0) opts.onFallback?.(chain[ci - 1], model, "structured: previous model returned no valid result");
+    const messages = [...opts.messages];
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (opts.signal.aborted) throw new Error("cancelled");
+      if (outOfTime()) break;
+      let lastText = "";
+      let errored;
+      for await (const ev of runRoleAgent({ ...opts, model, fallbacks: [], messages, tools: registry, signal: signalFor() })) {
+        if (ev.type === "error") {
+          errored = ev.message;
+          break;
+        }
+        if (ev.type === "abort") {
+          if (opts.signal.aborted) throw new Error("cancelled");
+          errored = total?.aborted ? CHAIN_BUDGET_MESSAGE : DEADLINE_MESSAGE;
+          break;
+        }
+        if (ev.type === "message.done") lastText = ev.message.content ?? lastText;
+        if (handle.result() !== void 0) break;
+      }
+      const r = handle.result();
+      if (r !== void 0) return r.value;
+      const salvaged = extractStructured(lastText, schema);
+      if (salvaged !== void 0) return salvaged;
+      if (errored !== void 0) {
+        if (TURN_LIMIT_RE.test(errored) && attempt < maxAttempts - 1) {
+          messages.push({ role: "assistant", content: lastText });
+          messages.push({ role: "user", content: "You have used your entire tool-call budget. Call `submit` NOW with the findings you already have. Do not read, grep or inspect anything else." });
+          continue;
+        }
+        lastError = errored;
+        break;
+      }
+      messages.push({ role: "assistant", content: lastText });
+      messages.push({
+        role: "user",
+        content: "You did not call the `submit` tool. Call `submit` now with your result as structured arguments \u2014 do not answer in prose."
+      });
+    }
+    if (opts.signal.aborted) throw new Error("cancelled");
+    if (outOfTime()) throw new Error("the model chain did not produce a result within its total budget");
+    opts.onStructuralFailure?.(model, "answered in prose instead of calling submit");
+  }
+  throw new Error(lastError ?? "structured role: submit was not called (whole model chain tried)");
+}
+
+export {
+  ToolRegistry,
+  runStructuredRole
+};

package/dist/{chunk-AE36LLL2.js → chunk-JLWQCA7B.js}

@@ -1160,212 +1160,6 @@ async function runToCompletion(opts) {
   return last;
 }
 
-// src/tools/registry.ts
-import { z } from "zod";
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  /**
-   * Registered and callable, but whose SCHEMA is withheld until something asks for it.
-   *
-   * A schema is paid for on every turn, whether or not the tool is ever used. Measured across twelve runs:
-   * 49 MCP tool schemas came to 86,620 characters (~21,655 tokens), 242 calls carried them, and that is
-   * ~5.2M of the 21.7M input tokens billed — 24% of everything — for FIVE tool calls, of two distinct tools.
-   * The catalogue that names them costs 900 characters (see MAX_TOOL_NOTE_CHARS); it is the schemas that are
-   * expensive, and a schema nobody is about to use buys nothing.
-   */
-  deferred = /* @__PURE__ */ new Set();
-  /** Bumped by anything that changes what `schemas()` would return, so the derivation can be cached. */
-  version = 0;
-  cached;
-  register(tool) {
-    this.tools.set(tool.name, tool);
-    this.deferred.delete(tool.name);
-    this.version++;
-  }
-  /** Callable by name from the moment it is registered; sent to the model only once {@link surface}d. */
-  registerDeferred(tool) {
-    this.tools.set(tool.name, tool);
-    this.deferred.add(tool.name);
-    this.version++;
-  }
-  /**
-   * Hands over the schemas for these names, from the next turn onward.
-   *
-   * Returns the ones that were actually withheld, so a caller can say what it just made available and stay
-   * quiet about what was already there.
-   */
-  surface(names) {
-    const opened = names.filter((n) => this.deferred.has(n));
-    for (const n of opened) this.deferred.delete(n);
-    if (opened.length) this.version++;
-    return opened;
-  }
-  /** Everything still withheld — what a search tool searches. */
-  deferredTools() {
-    return [...this.deferred].map((n) => this.tools.get(n)).filter((t) => t !== void 0);
-  }
-  /**
-   * A withheld tool is still CALLABLE.
-   *
-   * A model that reads the catalogue and calls the name straight off is right, and refusing it to enforce a
-   * search step would spend a turn teaching it a rule that exists for our benefit, not its.
-   */
-  get(name) {
-    return this.tools.get(name);
-  }
-  list() {
-    return [...this.tools.values()];
-  }
-  /**
-   * Tool schemas to send to the LLM: zod parameters → JSON Schema (zod 4 native). Withheld ones are omitted.
-   *
-   * …and so is a tool that has withdrawn itself. `Tool.broken` was documented as being read "where tools are
-   * OFFERED, so a broken one stops being handed to fresh agents" — and only `find_tool` ever read it, which
-   * covers the deferred tools and not the ones already on the list.
-   *
-   * Measured on one run: `mcp__angular-cli__list_projects` answered its first caller with a reply that failed
-   * its own declared output schema and withdrew itself. It was then offered to seventeen more agents, who
-   * called it twenty-eight more times. Every one of those was answered instantly, without touching the
-   * server — and still cost a whole model turn to learn what the run already knew.
-   */
-  schemas() {
-    const withdrawn = this.list().reduce((n, t) => n + (t.broken === void 0 ? 0 : 1), 0);
-    if (this.cached?.version === this.version && this.cached.withdrawn === withdrawn) return this.cached.schemas;
-    const schemas = this.list().filter((t) => !this.deferred.has(t.name) && t.broken === void 0).map((t) => ({
-      name: t.name,
-      description: t.description,
-      // MCP tools already carry a JSON Schema; everyone else derives it from their zod parameters.
-      parameters: t.rawSchema ?? z.toJSONSchema(t.parameters, { target: "draft-7" })
-    }));
-    this.cached = { version: this.version, withdrawn, schemas };
-    return schemas;
-  }
-};
-
-// src/core/types.ts
-var DEADLINE_MESSAGE = "the model did not answer within its deadline";
-var CHAIN_BUDGET_MESSAGE = "the chain's total budget ran out before this model was given a fair turn";
-
-// src/agent/structured.ts
-function valueAt(args, path) {
-  let cur = args;
-  for (const key of path) {
-    if (typeof cur !== "object" || cur === null) return void 0;
-    cur = cur[key];
-  }
-  return cur;
-}
-function whatWasWrong(issues, args) {
-  return issues.map((i) => {
-    const where = i.path.length ? i.path.join(".") : void 0;
-    const got = valueAt(args, i.path);
-    const shown = got === void 0 ? "nothing" : JSON.stringify(got);
-    const head = where ? `${where}: ${i.message}` : i.message;
-    if (got === void 0 && /received\s+(undefined|null|nothing)/i.test(i.message)) {
-      const parent = i.path.length > 1 ? valueAt(args, i.path.slice(0, -1)) : args;
-      const sent = parent && typeof parent === "object" ? Object.keys(parent) : [];
-      return sent.length ? `${head} \u2014 you sent only ${sent.map((k) => `\`${k}\``).join(", ")}` : head;
-    }
-    return `${head} \u2014 got ${shown.length > 120 ? `${shown.slice(0, 120)}\u2026` : shown}`;
-  }).join("; ");
-}
-function buildSubmitTool(schema) {
-  let box;
-  const tool = {
-    name: "submit",
-    description: "When you are done, submit your result in structured form with this tool.",
-    permissionLevel: "safe",
-    parameters: schema,
-    run: async (rawArgs) => {
-      const parsed = schema.safeParse(rawArgs);
-      if (!parsed.success) {
-        return { content: `submit: invalid output: ${whatWasWrong(parsed.error.issues, rawArgs)}`, isError: true };
-      }
-      box = { value: parsed.data };
-      return { content: "received", isError: false };
-    }
-  };
-  return { tool, result: () => box };
-}
-function extractStructured(text, schema) {
-  const trimmed = text.trim();
-  if (!trimmed) return void 0;
-  const candidates = [trimmed];
-  const block = trimmed.match(/\{[\s\S]*\}/);
-  if (block) candidates.push(block[0]);
-  for (const c of candidates) {
-    try {
-      const parsed = schema.safeParse(JSON.parse(c));
-      if (parsed.success) return parsed.data;
-    } catch {
-    }
-  }
-  return void 0;
-}
-var TURN_LIMIT_RE = /maximum turn count exceeded/i;
-async function runStructuredRole(opts, schema, maxAttempts = 2) {
-  const handle = buildSubmitTool(schema);
-  const registry = new ToolRegistry();
-  for (const t of opts.tools.list()) registry.register(t);
-  registry.register(handle.tool);
-  const chain = [opts.model, ...opts.fallbacks ?? []];
-  const total = opts.totalMs ? AbortSignal.timeout(opts.totalMs) : void 0;
-  const outOfTime = () => total?.aborted === true;
-  const signalFor = () => {
-    const parts = [opts.signal];
-    if (total) parts.push(total);
-    if (opts.perAttemptMs) parts.push(AbortSignal.timeout(opts.perAttemptMs));
-    return parts.length === 1 ? opts.signal : AbortSignal.any(parts);
-  };
-  let lastError;
-  for (let ci = 0; ci < chain.length; ci++) {
-    const model = chain[ci];
-    if (ci > 0) opts.onFallback?.(chain[ci - 1], model, "structured: previous model returned no valid result");
-    const messages = [...opts.messages];
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      if (opts.signal.aborted) throw new Error("cancelled");
-      if (outOfTime()) break;
-      let lastText = "";
-      let errored;
-      for await (const ev of runRoleAgent({ ...opts, model, fallbacks: [], messages, tools: registry, signal: signalFor() })) {
-        if (ev.type === "error") {
-          errored = ev.message;
-          break;
-        }
-        if (ev.type === "abort") {
-          if (opts.signal.aborted) throw new Error("cancelled");
-          errored = total?.aborted ? CHAIN_BUDGET_MESSAGE : DEADLINE_MESSAGE;
-          break;
-        }
-        if (ev.type === "message.done") lastText = ev.message.content ?? lastText;
-        if (handle.result() !== void 0) break;
-      }
-      const r = handle.result();
-      if (r !== void 0) return r.value;
-      const salvaged = extractStructured(lastText, schema);
-      if (salvaged !== void 0) return salvaged;
-      if (errored !== void 0) {
-        if (TURN_LIMIT_RE.test(errored) && attempt < maxAttempts - 1) {
-          messages.push({ role: "assistant", content: lastText });
-          messages.push({ role: "user", content: "You have used your entire tool-call budget. Call `submit` NOW with the findings you already have. Do not read, grep or inspect anything else." });
-          continue;
-        }
-        lastError = errored;
-        break;
-      }
-      messages.push({ role: "assistant", content: lastText });
-      messages.push({
-        role: "user",
-        content: "You did not call the `submit` tool. Call `submit` now with your result as structured arguments \u2014 do not answer in prose."
-      });
-    }
-    if (opts.signal.aborted) throw new Error("cancelled");
-    if (outOfTime()) throw new Error("the model chain did not produce a result within its total budget");
-    opts.onStructuralFailure?.(model, "answered in prose instead of calling submit");
-  }
-  throw new Error(lastError ?? "structured role: submit was not called (whole model chain tried)");
-}
-
 export {
   fmtTokens,
   fmtDuration,
@@ -1381,7 +1175,6 @@ export {
   setTelemetry,
   telemetry,
   redactSecrets,
-  runToCompletion,
-  ToolRegistry,
-  runStructuredRole
+  runRoleAgent,
+  runToCompletion
 };

package/dist/{chunk-XYZVZPAY.js → chunk-KXBYRU4W.js}

@@ -1,56 +1,60 @@
 import {
   respondIn
 } from "./chunk-M2RKCIGV.js";
+import {
+  askInUserLanguage,
+  inUserLanguage
+} from "./chunk-UTHLEW5V.js";
 import {
   Board,
   LONG_CALL_MS,
   WHAT_IT_COST,
-  applySkills,
   buildAskUserTool,
-  buildRememberTool,
-  buildSkillTool,
   changedByMerge,
   commitFile,
   commitStep,
-  constitutionNote,
-  constitutionPath,
   createDefaultRegistry,
-  describeInherited,
-  describeTopUp,
   editFileTool,
   extractChoicesFrom,
   hasWorkAgainst,
-  nextFeatureSlug,
   normalizeQuestion,
-  placedSkills,
-  readOnlyRegistry,
   refreshAfterChange,
-  routeSkills,
   routeTask,
   runCycleWithRole,
   runImplementer,
   runReviewLoop,
-  runReviewer,
-  scaffoldFeature,
   squashTask,
   subjectOf,
   worktreeState,
   writeFileTool,
   writerRegistry
-} from "./chunk-UEWVVN5L.js";
-import {
-  resolveMainBranch
-} from "./chunk-QF4MP6BS.js";
+} from "./chunk-PIG54WFU.js";
 import {
-  askInUserLanguage,
-  inUserLanguage
-} from "./chunk-UGESK765.js";
+  buildRememberTool,
+  constitutionNote,
+  constitutionPath,
+  describeInherited,
+  describeTopUp,
+  nextFeatureSlug,
+  readOnlyRegistry,
+  routeSkills,
+  runReviewer,
+  scaffoldFeature
+} from "./chunk-NBTH2VVI.js";
 import {
   clearCheckpoint,
   isContinuePrompt,
   readCheckpoint,
   writeCheckpoint
 } from "./chunk-ZSQ24YDJ.js";
+import {
+  resolveMainBranch
+} from "./chunk-QF4MP6BS.js";
+import {
+  applySkills,
+  buildSkillTool,
+  placedSkills
+} from "./chunk-MZM24M5M.js";
 import {
   defaultGitRunner
 } from "./chunk-LPQU436C.js";
@@ -72,25 +76,27 @@ import {
   relationStrength,
   supersedes,
   verifyAnchors
-} from "./chunk-LLL7QWXB.js";
+} from "./chunk-BFIZMM4G.js";
 import {
   ToolRegistry,
+  runStructuredRole
+} from "./chunk-CYLPQWIF.js";
+import {
   handedOver,
-  runStructuredRole,
   runToCompletion,
   stripThinking,
   telemetry
-} from "./chunk-AE36LLL2.js";
+} from "./chunk-JLWQCA7B.js";
 import {
   TRACE_INDEX,
   mergeTraceIndexes,
   parseTraceIndex,
   serializeTraceIndex,
   traceRootRel
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import {
   loadGraphSync
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 import {
   inLinkedWorktree,
   sessionBase,
@@ -2733,7 +2739,7 @@ var RefinerSchema = z6.object({
    * needs no specification. The prompt's own words for `verify` describe that request exactly; they were just
    * nowhere near the field being filled in.
    */
-  intent: z6.enum(["chat", "feature", "bugfix", "govern", "undo", "verify"]).describe(
+  intent: z6.enum(["chat", "feature", "bugfix", "govern", "undo", "verify", "research"]).describe(
     "What the request PRODUCES, not what it mentions. `verify`: a record of what EXISTING software DID \u2014 running scenarios, querying the database or logs for evidence, writing or extending a test report. Anything whose output is findings rather than changed behaviour is verify, including a follow-up that only adds more evidence to a report already being written. `feature`: new or changed behaviour in the product. `bugfix`: existing behaviour is wrong and must be corrected. `govern`: the output is a governing document (constitution, conventions), no source changes. `undo`: reverse what the previous turn did. `chat`: a question or conversation, nothing to build. A verify request never needs a specification or a plan: if the answer is 'run it and write down what happened', it is verify."
   ),
   // The natural language the user wrote in (English name, e.g. "Turkish") → the coach replies in it.
@@ -2761,6 +2767,7 @@ function routeIntent(intent) {
   if (intent === "chat") return "chat";
   if (intent === "undo") return "undo";
   if (intent === "verify") return "verify";
+  if (intent === "research") return "research";
   return intent === "govern" ? "govern" : "pipeline";
 }
 
@@ -3217,7 +3224,7 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
     emitPhase("verify");
     const cwd = await documentWorkdir(process.cwd(), prompt, ensureWorktree, r.title);
     laneCheckpoint(cwd, "verify", resume, prompt, r);
-    const { runVerify, describeVerify, currentBranchOf } = await import("./verify-LC57A6H2.js");
+    const { runVerify, describeVerify, currentBranchOf } = await import("./verify-2DTBG6RG.js");
     const branch = await currentBranchOf(cwd);
     const res = await runVerify({
       deps,
@@ -3238,6 +3245,31 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
       written: res.reportWritten
     };
   }
+  if (laneFor(r, prompt, resume) === "research") {
+    emitPhase("research");
+    const cwd = await documentWorkdir(process.cwd(), prompt, ensureWorktree, r.title);
+    laneCheckpoint(cwd, "research", resume, prompt, r);
+    const { runResearch, describeResearch } = await import("./research-MHBNZ6SA.js");
+    const { currentBranchOf } = await import("./verify-2DTBG6RG.js");
+    const branch = await currentBranchOf(cwd);
+    const res = await runResearch({
+      deps,
+      workdir: cwd,
+      prompt: r.refinedPrompt,
+      title: r.title,
+      // The report is read by a person, so it is written in theirs — see src/engine/language.ts.
+      ...r.language ? { language: r.language } : {},
+      note: (text) => emit({ kind: "note", text })
+    });
+    return {
+      intent: r.intent,
+      refinedPrompt: r.refinedPrompt,
+      kind: "researched",
+      report: describeResearch(res, branch),
+      reportPath: res.reportPath,
+      written: res.written
+    };
+  }
   if (laneFor(r, prompt, resume) === "govern") {
     emitPhase("constitution");
     const templates2 = await deps.specKit();
@@ -3260,11 +3292,11 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
   if (!resume && !hasPreservedWork && routeIntent(r.intent) === "pipeline") {
     const cwd = workingIn?.() ?? process.cwd();
     emitPhase("sizing");
-    const { sizeRequest } = await import("./triage-FCYHD2AQ.js");
+    const { sizeRequest } = await import("./triage-IFCVL5MA.js");
     const size = await sizeRequest(deps, cwd, r.refinedPrompt);
     let small = size.verdict === "small";
     if (size.verdict === "unsure") {
-      const { describeSizeDoubt } = await import("./triage-FCYHD2AQ.js");
+      const { describeSizeDoubt } = await import("./triage-IFCVL5MA.js");
       const answer = await askInUserLanguage(
         deps,
         askUser,
@@ -3282,8 +3314,8 @@ Which is it?`,
     if (small) {
       emitPhase("small change");
       emit({ kind: "note", text: `\u26A1 Small change \u2014 ${size.reason}. No branch, no spec, no plan.` });
-      const { runSmallChange, describeSmallChange } = await import("./fix-ONLA45HD.js");
-      const { currentBranchOf } = await import("./verify-LC57A6H2.js");
+      const { runSmallChange, describeSmallChange } = await import("./fix-SSDUVV4T.js");
+      const { currentBranchOf } = await import("./verify-2DTBG6RG.js");
       const res = await runSmallChange(deps, cwd, r.title, r.refinedPrompt, size);
       return {
         intent: r.intent,
@@ -4044,6 +4076,9 @@ async function runJob(deps, opts) {
     if (up.kind === "tweaked") {
       return { kind: "tweaked", report: up.report, done: up.done, refinedPrompt: up.refinedPrompt };
     }
+    if (up.kind === "researched") {
+      return { kind: "researched", report: up.report, reportPath: up.reportPath, written: up.written, refinedPrompt: up.refinedPrompt };
+    }
     if (up.kind === "verified") {
       return { kind: "verified", report: up.report, reportPath: up.reportPath, written: up.written, refinedPrompt: up.refinedPrompt };
     }