@nodii/dev 0.6.34 → 0.6.36

package/dist/freeze.js

@@ -29,9 +29,43 @@ export function shouldReground(argv) {
 
 /**
  * The only Gather → Freeze shape adapter. Gather may add display metadata,
- * but Freeze retains the stable clause identity/tags and full text only for ⚑.
+ * but Freeze pins only the ⚑ clauses, in full (hub-58): every other clause
+ * stays in the Clause map, which the Freeze references.
  */
 export function pinnedClausesFromGather(clauses) {
+  return checkedGatherClauses(clauses)
+    .filter((clause) => clause.counterInstinct)
+    .map((clause) => ({
+      documentCode: clause.documentCode,
+      documentVersion: clause.documentVersion,
+      clauseId: clause.clauseId,
+      ...(clause.breadcrumb || clause.sectionId
+        ? { section: clause.breadcrumb ?? clause.sectionId }
+        : {}),
+      gist: clause.gist,
+      text: clause.text,
+      counterInstinct: true,
+      repos: clause.repos,
+      steps: clause.steps,
+    }));
+}
+
+/**
+ * The Freeze's reference to the Clause map: its Gather id and the non-flagged
+ * clauses' one-line gists in rank order (Dev cuts them at the token cap).
+ */
+export function clauseMapFromGather(gather) {
+  if (typeof gather?.gatherId !== "string" || !gather.gatherId)
+    throw new CliError("GATHER_CLAUSE_MAP_INVALID", "Gather returned no gather id", 1);
+  const clauses = checkedGatherClauses(gather.clauses)
+    .map((clause, index) => ({ clause, index }))
+    .filter(({ clause }) => !clause.counterInstinct)
+    .sort((a, b) => (a.clause.rank ?? Infinity) - (b.clause.rank ?? Infinity) || a.index - b.index)
+    .map(({ clause }) => ({ clauseId: clause.clauseId, gist: clause.gist }));
+  return { gatherId: gather.gatherId, clauses };
+}
+
+function checkedGatherClauses(clauses) {
   if (!Array.isArray(clauses))
     throw new CliError("GATHER_CLAUSE_MAP_INVALID", "Gather returned no clause map", 1);
   return clauses.map((clause) => {
@@ -66,25 +100,13 @@ export function pinnedClausesFromGather(clauses) {
         ].join(", ")}`,
         1,
       );
-    return {
-      documentCode: clause.documentCode,
-      documentVersion: clause.documentVersion,
-      clauseId: clause.clauseId,
-      ...(clause.breadcrumb || clause.sectionId
-        ? { section: clause.breadcrumb ?? clause.sectionId }
-        : {}),
-      gist: clause.gist,
-      ...(clause.counterInstinct ? { text: clause.text } : {}),
-      counterInstinct: clause.counterInstinct,
-      repos: clause.repos,
-      steps: clause.steps,
-    };
+    return clause;
   });
 }
 
 export const GATHER_LOOKUP_IDS = ["figma-guidelines"];
 
-/** Build the six-section stored contract; Delta Gather keeps lane-authored sections. */
+/** Build the stored contract; Delta Gather keeps lane-authored sections. */
 export function freezeFromGather({
   gather,
   boundaries,
@@ -119,6 +141,7 @@ export function freezeFromGather({
     },
     boundaries,
     pinnedClauses: pinnedClausesFromGather(gather.clauses),
+    clauseMap: clauseMapFromGather(gather),
     // Gather owns the lookups it derives (the Figma scope's guidelines): each
     // Gather replaces them, or drops them when the scope no longer yields any.
     // Lookups the lane added itself are kept.

package/dist/gather.js

@@ -2,8 +2,8 @@ import { execFile } from "node:child_process";
 import { homedir, platform } from "node:os";
 import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
-import { link, lstat, mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { appendFile, link, lstat, mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { CliError } from "./core.js";
 
 const execFileAsync = promisify(execFile);
@@ -21,6 +21,10 @@ export const PICKER_CONTEXT = 8192;
 // A hard per-pick deadline: a pick that has not answered by then is stopped
 // (PICKER_TIMEOUT) so the next one never queues behind it.
 export const PICKER_TIMEOUT_MS = 30_000;
+// A lane Gather's first pick, timed only once the model is warm: real lanes
+// hit the 60 s Gather cap on a cold 12B (GATHER_TIMEOUT, 30 Oct).
+export const PICKER_FIRST_PICK_TIMEOUT_MS = 120_000;
+// Dev's requests in a Gather; the local warm-up and pick run on their own budgets.
 export const GATHER_TIMEOUT_MS = 60_000;
 export const PICKER_WARM_TIMEOUT_MS = 180_000;
 export const OLLAMA_URL = "http://127.0.0.1:11434";
@@ -79,9 +83,8 @@ async function jsonRequest(path, { baseUrl = ollamaUrl(), fetchImpl = fetch, tim
     }), requestSignal);
   } catch (error) {
     const timedOut = requestSignal.aborted || error?.name === "TimeoutError" || error?.name === "AbortError";
-    throw new CliError("PICKER_UNAVAILABLE", timedOut
-      ? `Local Gather picker timed out after ${timeoutMs} ms.`
-      : `Local Gather picker is unavailable at ${baseUrl}: ${error.message}. ${SETUP_FIX}`, 1);
+    if (timedOut) throw new CliError("PICKER_UNAVAILABLE", `Local Gather picker timed out after ${timeoutMs} ms.`, 1);
+    throw new CliError("PICKER_UNAVAILABLE", `Local Gather picker is unavailable at ${baseUrl}: ${error.message}. ${SETUP_FIX}`, 1, { unreachable: true, url: baseUrl });
   }
   let raw;
   try {
@@ -139,8 +142,41 @@ export async function requirePicker(options = {}) {
  */
 export async function warmPicker(options = {}) {
   const status = await requirePicker(options);
-  await jsonRequest("/api/generate", { ...options, timeoutMs: options.timeoutMs ?? PICKER_WARM_TIMEOUT_MS, body: { model: (options.model ?? PINNED).name, prompt: "", stream: false } });
-  return status;
+  const started = Date.now();
+  const payload = await jsonRequest("/api/generate", { ...options, timeoutMs: options.timeoutMs ?? PICKER_WARM_TIMEOUT_MS, body: { model: (options.model ?? PINNED).name, prompt: "", stream: false } });
+  return { ...status, latency: pickLatency(payload, Date.now() - started) };
+}
+
+/**
+ * Gather's deadline for Dev's requests. It stops while `hold` runs the local
+ * pick, which has its own budgets (warm-up, then the first pick), so a cold
+ * model never spends the requests' time.
+ */
+export function gatherDeadline(ms) {
+  const controller = new AbortController();
+  let remaining = ms;
+  let since = Date.now();
+  let timer = setTimeout(() => controller.abort(), remaining);
+  let holds = 0;
+  return {
+    ms,
+    signal: controller.signal,
+    async hold(task) {
+      if (holds++ === 0) {
+        clearTimeout(timer);
+        remaining -= Date.now() - since;
+      }
+      try {
+        return await task();
+      } finally {
+        if (--holds === 0 && !controller.signal.aborted) {
+          since = Date.now();
+          timer = setTimeout(() => controller.abort(), Math.max(0, remaining));
+        }
+      }
+    },
+    clear: () => clearTimeout(timer),
+  };
 }
 
 function pickerPrompt({ objective, files = [], triggers }) {
@@ -156,6 +192,16 @@ function pickerPrompt({ objective, files = [], triggers }) {
 
 const forced = (trigger) => Array.isArray(trigger?.forcedBy) ? trigger.forcedBy.length > 0 : Boolean(trigger?.forcedBy);
 
+/**
+ * Why a lane Gather hands the pick to the agent instead (hub-58, 30 Oct): this
+ * Mac has no picker model, or no Ollama at all. Null for every other failure.
+ */
+export function agentFallbackReason(error) {
+  if (error?.code === "PICKER_MODEL_MISSING") return `${error.details?.model ?? PICKER_MODEL} not installed; run nodii-dev setup`;
+  if (error?.code === "PICKER_UNAVAILABLE" && error.details?.unreachable) return `no local Ollama at ${error.details.url}; run nodii-dev setup`;
+  return null;
+}
+
 export async function pickDocuments(input, options = {}) {
   if (!input || typeof input.objective !== "string" || !input.objective.trim())
     throw new CliError("PICKER_INPUT_INVALID", "Gather needs a non-empty objective.", 2);
@@ -287,7 +333,7 @@ async function removeIfStale(lock, token, { alive, now, staleMs }) {
  * long). Takeovers are serialized, so the lock path is never emptied under a
  * live pick.
  */
-export async function withPickLock(lane, task, { dir = pickLockDir(), pid = process.pid, alive = processAlive, now = Date.now, staleMs = 2 * PICKER_TIMEOUT_MS, attempts = 40, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+export async function withPickLock(lane, task, { dir = pickLockDir(), pid = process.pid, alive = processAlive, now = Date.now, staleMs = 2 * PICKER_FIRST_PICK_TIMEOUT_MS, attempts = 40, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
   await privateDir(dir);
   const name = encodeURIComponent(lane);
   const lock = join(dir, `${name}.lock`);
@@ -306,7 +352,7 @@ export async function withPickLock(lane, task, { dir = pickLockDir(), pid = proc
       }
       const verdict = await removeIfStale(lock, token, { alive, now, staleMs });
       if (!verdict.retry)
-        throw new CliError("PICKER_BUSY", `A Gather pick for lane ${lane} is already running (pid ${verdict.holder ?? "unknown"}); it ends within ${Math.round(PICKER_TIMEOUT_MS / 1000)} s. Rerun after it finishes (lock: ${lock}).`, 1, { pid: verdict.holder, lock });
+        throw new CliError("PICKER_BUSY", `A Gather pick for lane ${lane} is already running (pid ${verdict.holder ?? "unknown"}); it ends within ${Math.round(PICKER_FIRST_PICK_TIMEOUT_MS / 1000)} s. Rerun after it finishes (lock: ${lock}).`, 1, { pid: verdict.holder, lock });
       await sleep(5 + Math.random() * 20);
     }
   } finally {
@@ -325,6 +371,56 @@ const processAlive = (pid) => {
   catch (error) { return error?.code === "EPERM"; }
 };
 
+/** This Mac's Gather pick timings, one JSON line per lane pick (the p50/p95 evidence). */
+export const pickTimingsPath = (env = process.env) => env.NODII_DEV_GATHER_TIMINGS || join(homedir(), ".cache", "nodii-dev", "gather-timings.jsonl");
+
+export async function recordPickTiming(entry, { path = pickTimingsPath() } = {}) {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await appendFile(path, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+}
+
+/** The newest `last` timings, optionally for one model; unreadable lines are skipped. */
+export async function readPickTimings({ path = pickTimingsPath(), model, last = 50 } = {}) {
+  const raw = await readFile(path, "utf8").catch((error) => { if (error?.code === "ENOENT") return ""; throw error; });
+  const entries = raw.split("\n").flatMap((line) => { try { return line ? [JSON.parse(line)] : []; } catch { return []; } });
+  return entries.filter((x) => !model || x.model === model).slice(-last);
+}
+
+/** Nearest-rank percentile; null for no values. */
+export function percentile(values, p) {
+  const sorted = values.filter((x) => typeof x === "number").sort((a, b) => a - b);
+  if (!sorted.length) return null;
+  return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1))];
+}
+
+export function pickTimingStats(entries) {
+  const ok = entries.filter((x) => x.outcome === "ok");
+  const spread = (key) => ({ p50: percentile(ok.map((x) => x[key]), 50), p95: percentile(ok.map((x) => x[key]), 95) });
+  const failed = {};
+  for (const x of entries) if (x.outcome !== "ok") failed[x.outcome] = (failed[x.outcome] ?? 0) + 1;
+  return { picks: entries.length, ok: ok.length, warmMs: spread("warmMs"), pickMs: spread("pickMs"), gatherPickMs: spread("totalMs"), failed };
+}
+
+const seconds = (value) => value === null || value === undefined ? "?" : `${(value / 1000).toFixed(1)} s`;
+
+export function pickTimingText(stats, { model, path } = {}) {
+  if (!stats.picks) return `${model ?? "Gather picker"}: no lane picks recorded on this Mac yet${path ? ` (${path})` : ""}.`;
+  const failed = Object.entries(stats.failed).map(([code, n]) => `${n} ${code}`).join(", ");
+  return [
+    `${model ?? "Gather picker"} · ${stats.picks} lane pick${stats.picks === 1 ? "" : "s"} on this Mac${path ? ` (${path})` : ""}`,
+    `  warm-up        p50 ${seconds(stats.warmMs.p50)}  p95 ${seconds(stats.warmMs.p95)}`,
+    `  first pick     p50 ${seconds(stats.pickMs.p50)}  p95 ${seconds(stats.pickMs.p95)}  (budget ${seconds(PICKER_FIRST_PICK_TIMEOUT_MS)} once warm)`,
+    `  warm-up + pick p50 ${seconds(stats.gatherPickMs.p50)}  p95 ${seconds(stats.gatherPickMs.p95)}`,
+    ...(failed ? [`  failed         ${failed}`] : []),
+  ].join("\n");
+}
+
+/** One line for a lane Gather's output: this pick, then this Mac's spread. */
+export function pickTimingLine(timing, stats) {
+  const spread = stats?.ok ? `; this Mac p50 ${seconds(stats.pickMs.p50)}, p95 ${seconds(stats.pickMs.p95)} over ${stats.ok} pick${stats.ok === 1 ? "" : "s"} (nodii-dev gather timings)` : "";
+  return `Picker ${timing.model}: warm-up ${seconds(timing.warmMs)}, pick ${seconds(timing.pickMs)} of its ${seconds(timing.budgetMs)} budget${spread}.`;
+}
+
 const LATENCY_PROBE = {
   objective: "Add a contacts list endpoint with cursor paging.",
   triggers: [

package/dist/hooks.js

@@ -254,9 +254,13 @@ export async function sessionStartContext(payload, { request = devRequest, confi
     },
     { request, config },
   );
+  // A Freeze written before it referenced the Clause map has no pointer to it.
+  const pointer = result.shown && !context.includes("lane gather show")
+    ? `\nFull Clause map: \`nodii-dev lane gather show ${result.lane.key}\`; one clause in full: \`nodii-dev rules show <ID>\`.`
+    : "";
   return result.shown
-    ? context.trimEnd()
-    : "Freeze re-grounding: no active Dev lane with initialized Freeze was available for this worktree; run `nodii-dev lane freeze show <key>` before continuing.";
+    ? `${context.trimEnd()}${pointer}`
+    : "Freeze re-grounding: no active Dev lane with initialized Freeze was available for this worktree; run `nodii-dev lane freeze show <key>` (and `nodii-dev lane gather show <key>` for its Clause map) before continuing.";
 }
 
 export function workflowSuggestion(payload) {

package/dist/lanes.js

@@ -4,7 +4,7 @@ import { promisify } from "node:util";
 import { CliError, encode, devRequest, query, readConfig, requireFlag } from "./core.js";
 import { launchRecovery } from "./runtime-launcher.js";
 import { recordReviewReceipt, reviewCommitContext } from "./safety.js";
-import { GATHER_TIMEOUT_MS, PICKER_MODEL, gatherText, pickDocuments, withPickLock } from "./gather.js";
+import { GATHER_TIMEOUT_MS, PICKER_FIRST_PICK_TIMEOUT_MS, PICKER_MODEL, agentFallbackReason, gatherDeadline, gatherText, pickDocuments, pickTimingLine, pickTimingStats, readPickTimings, recordPickTiming, warmPicker, withPickLock } from "./gather.js";
 import { storeGatherFreeze } from "./freeze.js";
 import { SWAP_BOUNDARIES, componentsForScope, guidelineLookup, laneFigmaScope, loadDsCatalog } from "./figma-scope.js";
 
@@ -207,7 +207,41 @@ async function currentGatherLane(request, config, gitContext) {
   return matches[0].key;
 }
 
-export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt, picker = pickDocuments, changedPaths = laneChangedPaths, gatherTimeoutMs = GATHER_TIMEOUT_MS, gatherSignal, storeFreeze = storeGatherFreeze, launch = launchRecovery, catalog = loadDsCatalog, pickLock = withPickLock } = {}) {
+const timedWarm = async (warm, signal) => {
+  const started = Date.now();
+  const status = await warm({ signal });
+  return { wallMs: Date.now() - started, loadMs: status?.latency?.loadMs ?? null };
+};
+
+/**
+ * The lane's local pick: wait for the warm-up begun at Gather start, then the
+ * first pick on its own budget. Every pick that reached the model is logged
+ * for this Mac's p50/p95, failures included.
+ */
+async function localPick(lane, warming, pick, { budgetMs, timings }) {
+  const started = Date.now();
+  const warmed = await warming;
+  const pickStarted = Date.now();
+  const entry = (outcome, picked) => ({
+    at: new Date().toISOString(), lane, model: picked?.model ?? PICKER_MODEL, outcome,
+    warmMs: pickStarted - started, warmLoadMs: warmed?.loadMs ?? null,
+    pickMs: picked?.latency?.wallMs ?? Date.now() - pickStarted, loadMs: picked?.latency?.loadMs ?? null,
+    totalMs: Date.now() - started, budgetMs,
+  });
+  let picked;
+  try {
+    picked = await pick();
+  } catch (error) {
+    if (error instanceof CliError && ["PICKER_TIMEOUT", "PICKER_RESPONSE_INVALID"].includes(error.code)) await timings.record(entry(error.code)).catch(() => {});
+    throw error;
+  }
+  const timing = entry("ok", picked);
+  await timings.record(timing).catch(() => {});
+  const stats = pickTimingStats(await timings.read({ model: timing.model }).catch(() => []));
+  return { ...picked, timing, stats };
+}
+
+export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt, picker = pickDocuments, warm = warmPicker, firstPickTimeoutMs = PICKER_FIRST_PICK_TIMEOUT_MS, timings = { record: recordPickTiming, read: readPickTimings }, changedPaths = laneChangedPaths, gatherTimeoutMs = GATHER_TIMEOUT_MS, deadline: outerDeadline, storeFreeze = storeGatherFreeze, launch = launchRecovery, catalog = loadDsCatalog, pickLock = withPickLock } = {}) {
   if (action === "list") {
     const c = flags.mine ? await config() : null;
     const payload = await request("GET", `/api/v1/lanes${query({ kind: flags.kind, status: flags.status, machine: flags.machine, agent: flags.mine ? c.agentId : flags.agent, "waiting-on": flags["waiting-on"], stuck: flags.stuck, cursor: flags.cursor, limit: flags.limit })}`);
@@ -231,6 +265,16 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     const payload = await request("POST", `/api/v1/lanes/${encode(key)}/start`, via);
     return { payload, human: (p) => `Started ${laneLine(p.data)}` };
   }
+  // The Freeze references the Clause map rather than holding it (hub-58).
+  if (action === "gather" && args[0] === "show") {
+    // A Gather flag here means a Gather was meant: never show silently instead.
+    const gatherFlags = ["picker", "shortlist", "documents", "delta", "objective", "done-check", "paths", "components", "limit", "section-limit-per-document"].filter((flag) => flags[flag] !== undefined);
+    if (gatherFlags.length)
+      throw new CliError("USAGE", `lane gather show takes only [<key>] [--gather ID]; --${gatherFlags.join(", --")} belong to lane gather.`, 2);
+    const key = need(args[1] ?? await currentGatherLane(request, config, gitContext), "lane gather show needs <key>");
+    const payload = await request("GET", `/api/v1/lanes/${encode(key)}/gather${query({ gatherId: flags.gather })}`);
+    return { payload, human: (p) => `Gather ${p.data.gatherId}\n${gatherText(p, p.data.objective ?? "")}` };
+  }
   const ref = need(args[0] ?? (action === "gather" ? await currentGatherLane(request, config, gitContext) : undefined), `lane ${action} needs <key>`);
   const id = ref;
   if (action === "show") {
@@ -238,11 +282,15 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     return { payload, human: (p) => detailText(p.data) };
   }
   if (action === "gather") {
-    const controller = gatherSignal ? null : new AbortController();
-    const deadline = controller ? setTimeout(() => controller.abort(), gatherTimeoutMs) : null;
-    const signal = gatherSignal ?? controller.signal;
+    const deadline = outerDeadline ?? gatherDeadline(gatherTimeoutMs);
+    const signal = deadline.signal;
+    // Stops a warm-up still loading when Gather fails before its pick.
+    const warmStop = new AbortController();
     try {
       const byAgent = agentPickerFlags(flags);
+      // Warm the local picker at Gather start, alongside Dev's requests (GATHER_TIMEOUT, 30 Oct).
+      const warming = byAgent ? null : timedWarm(warm, warmStop.signal);
+      warming?.catch(() => {});
       const lane = (await request("GET", `/api/v1/lanes/${encode(id)}`, undefined, { signal })).data;
       if (flags.objective !== undefined && (typeof flags.objective !== "string" || !flags.objective.trim()))
         throw new CliError("USAGE", "lane gather --objective needs non-empty text", 2);
@@ -343,7 +391,7 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
         return { payload: { data: { recorded: false, picker: "agent", shortlistId, objective, triggers } }, human: (p) => agentShortlistText(ref, p.data, flags) };
       // Only the local model pick takes the per-lane pick lock; an agent pick
       // records a choice already made (AGENT-HARNESS-19 + GATHER-NA).
-      const picked = byAgent ? { documents: byAgent.documents } : await pickLock(lane.id ?? id, () => picker({
+      const pickInput = {
         objective,
         files: paths,
         triggers: triggers.map((trigger) => ({
@@ -351,7 +399,19 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
           trigger: trigger.sentence,
           ...(trigger.forcedBy ? { forcedBy: trigger.forcedBy } : {}),
         })),
-      }, { signal }));
+      };
+      let picked = byAgent && { documents: byAgent.documents };
+      if (!picked) {
+        try {
+          // Dev's deadline stops while the pick runs on its own budgets.
+          picked = await deadline.hold(() => localPick(ref, warming, () => pickLock(lane.id ?? id, () => picker(pickInput, { signal, timeoutMs: firstPickTimeoutMs })), { budgetMs: firstPickTimeoutMs, timings }));
+        } catch (error) {
+          // No picker on this Mac: the agent picks from the same shortlist (hub-58).
+          const fallback = agentFallbackReason(error);
+          if (!fallback) throw error;
+          return { payload: { data: { recorded: false, picker: "agent", fallback, shortlistId, objective, triggers } }, human: (p) => `picker: agent (${p.data.fallback})\n${agentShortlistText(ref, p.data, flags)}` };
+        }
+      }
       const payload = await request("POST", `/api/v1/lanes/${encode(id)}/gather`, {
         objective,
         documentCodes: picked.documents,
@@ -391,13 +451,15 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
         ...(invalidScope ? [`Notice: the launch Figma scope is not published keys (${invalidScope.replace(/\.$/, "")}), so the Freeze was stored with no Figma scope and every Figma lock and write is refused. Set the published keys with ${SWAP_BOUNDARIES(id)}.`] : []),
       ].map((line) => `\n${line}`).join("");
       // The pick's model and latency ride along in --json (morning check records them).
-      const result = { ...payload, picker: { model: picked.model ?? null, latency: picked.latency ?? null } };
-      return { payload: result, human: (p) => `${gatherText(p, objective, reasons)}${scopeNotice}` };
+      const result = { ...payload, picker: { model: picked.model ?? null, latency: picked.latency ?? null, ...(picked.timing ? { timing: picked.timing, stats: picked.stats } : {}) } };
+      const timingLine = picked.timing ? `\n${pickTimingLine(picked.timing, picked.stats)}` : "";
+      return { payload: result, human: (p) => `${gatherText(p, objective, reasons)}${scopeNotice}${timingLine}` };
     } catch (error) {
-      if (signal.aborted) throw new CliError("GATHER_TIMEOUT", `Gather exceeded its ${Math.round(gatherTimeoutMs / 1000)}-second deadline; nothing was retried.`, 1);
+      if (signal.aborted) throw new CliError("GATHER_TIMEOUT", `Gather's Dev requests exceeded their ${Math.round(deadline.ms / 1000)}-second deadline (the local pick runs on its own budget); nothing was retried.`, 1);
       throw error;
     } finally {
-      if (deadline) clearTimeout(deadline);
+      warmStop.abort();
+      if (!outerDeadline) deadline.clear();
     }
   }
   if (action === "step") {