@chrisjowen/wheelhouse 0.2.0 → 0.2.1

package/build/server/chunks/chunks/chat.svelte.js-b0uQXOge.js

@@ -0,0 +1,545 @@
+import { _ as derived } from './index.js-B0NFhRTN.js';
+import { S as SESSION_HEADER } from './messages.js-CFyGKoqq.js';
+import { w as watchedStream } from './live.svelte.js-DavJCZVs.js';
+
+const QUIET_REPLY = /^(captain[,.!]?\s*)?(shipshape|all (is )?well|all quiet|nothing (new )?to report)[.!]?$/i;
+const INTERRUPTED = /^\[Request interrupted by user/;
+const ANSI = /\u001b\[[0-9;?]*[A-Za-z]/g;
+const base = (p) => String(p ?? "").split("/").filter(Boolean).pop() ?? "";
+const firstLine = (s) => String(s ?? "").split("\n")[0].trim();
+const host = (u) => {
+  try {
+    return new URL(String(u)).host;
+  } catch {
+    return String(u ?? "");
+  }
+};
+function describeTool(name, input) {
+  switch (name) {
+    case "Bash":
+      return {
+        verb: "Ran",
+        summary: input.description || firstLine(input.command),
+        noun: ["command", "commands"]
+      };
+    case "Read":
+      return { verb: "Read", summary: base(input.file_path), noun: ["file read", "files read"] };
+    case "Edit":
+    case "MultiEdit":
+      return { verb: "Edited", summary: base(input.file_path), noun: ["edit", "edits"] };
+    case "Write":
+      return {
+        verb: "Wrote",
+        summary: base(input.file_path),
+        noun: ["file written", "files written"]
+      };
+    case "Grep":
+      return {
+        verb: "Searched code for",
+        summary: String(input.pattern ?? ""),
+        noun: ["code search", "code searches"]
+      };
+    case "Glob":
+      return {
+        verb: "Listed files",
+        summary: String(input.pattern ?? ""),
+        noun: ["file listing", "file listings"]
+      };
+    case "WebSearch":
+      return {
+        verb: "Searched the web for",
+        summary: String(input.query ?? ""),
+        noun: ["web search", "web searches"]
+      };
+    case "WebFetch":
+      return { verb: "Read page", summary: host(input.url), noun: ["page read", "pages read"] };
+    case "Skill":
+      return { verb: "Used skill", summary: String(input.skill ?? ""), noun: ["skill", "skills"] };
+    case "ToolSearch":
+      return {
+        verb: "Loaded tools",
+        summary: firstLine(input.query),
+        noun: ["tool lookup", "tool lookups"]
+      };
+    case "Agent":
+    case "Task":
+      return {
+        verb: "Asked a helper",
+        summary: input.description || firstLine(input.prompt),
+        noun: ["helper", "helpers"]
+      };
+    case "TodoWrite":
+      return { verb: "Updated the plan", summary: "", noun: ["plan update", "plan updates"] };
+    case "SendMessage":
+      return { verb: "Messaged", summary: String(input.to ?? ""), noun: ["message", "messages"] };
+    default: {
+      const m = name.match(/^mcp__(.+?)__(.+)$/);
+      if (m) {
+        return {
+          verb: "Used",
+          summary: `${m[2].replace(/_/g, " ")} (${m[1]})`,
+          noun: ["tool call", "tool calls"]
+        };
+      }
+      return { verb: "Used", summary: name, noun: ["tool call", "tool calls"] };
+    }
+  }
+}
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map(
+      (c) => c?.type === "text" ? String(c.text ?? "") : c?.type === "image" ? "[image]" : c?.type === "tool_reference" ? `[tool: ${c.tool_name ?? ""}]` : `[${c?.type ?? "item"}]`
+    ).join("\n");
+  }
+  return "";
+}
+const captainText = (s) => s.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<\/?pasted_content(?:\s+id="[^"]*")?\s*>\n?/g, "").trim();
+const MID_TURN = /<system-reminder>\s*The user sent a new message while you were working:\n([\s\S]*?)(?:\n\nThis is how Claude Code (?:(?!\n\n)[\s\S])*)?\s*<\/system-reminder>/;
+const midTurn = (s) => {
+  const m = s.match(MID_TURN);
+  return m ? captainText(m[1]) || null : null;
+};
+function tag(s, name) {
+  const m = s.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
+  return m ? m[1].trim() : null;
+}
+function commandText(s) {
+  const name = tag(s, "command-name");
+  if (!name) return null;
+  const args = tag(s, "command-args");
+  return args ? `${name} ${args}` : name;
+}
+function questions(input) {
+  const qs = Array.isArray(input?.questions) ? input.questions : [];
+  return qs.map((q) => ({
+    header: String(q?.header ?? ""),
+    question: String(q?.question ?? ""),
+    multiSelect: q?.multiSelect === true,
+    options: (Array.isArray(q?.options) ? q.options : []).map((o) => ({
+      label: String(o?.label ?? ""),
+      description: String(o?.description ?? "")
+    }))
+  }));
+}
+function answersOf(r, text) {
+  const structured = r.toolUseResult?.answers;
+  if (structured && typeof structured === "object") {
+    return Object.fromEntries(Object.entries(structured).map(([k, v]) => [k, String(v)]));
+  }
+  const out = {};
+  for (const m of text.matchAll(/"([^"]+)"="([^"]*)"/g)) out[m[1]] = m[2];
+  return out;
+}
+function fold(records) {
+  const items = [];
+  const tools = /* @__PURE__ */ new Map();
+  const asks = /* @__PURE__ */ new Map();
+  let title = null;
+  let turn = null;
+  let lastTurn = null;
+  let prevAt = null;
+  let wake = false;
+  const closeTurn = () => {
+    turn = null;
+  };
+  const ensureTurn = (r) => {
+    if (!turn) {
+      turn = {
+        kind: "turn",
+        id: r.uuid,
+        parts: [],
+        at: r.timestamp,
+        durationMs: null,
+        done: false,
+        interrupted: false,
+        trigger: wake ? "background" : "captain"
+      };
+      wake = false;
+      items.push(turn);
+      lastTurn = turn;
+    }
+    return turn;
+  };
+  const activity = (r) => {
+    const t = ensureTurn(r);
+    const last = t.parts[t.parts.length - 1];
+    if (last?.kind === "activity") return last;
+    const a = { kind: "activity", id: `${r.uuid}-a`, steps: [] };
+    t.parts.push(a);
+    return a;
+  };
+  const user = (r, text, opts = {}) => {
+    closeTurn();
+    wake = false;
+    items.push({
+      kind: "user",
+      id: r.uuid,
+      text,
+      at: r.timestamp,
+      queued: !!opts.queued,
+      command: !!opts.command
+    });
+  };
+  const context = (r, label, detail, id = r.uuid) => {
+    if (turn) activity(r).steps.push({ kind: "context", id, label, detail });
+  };
+  for (const r of records) {
+    if (!r || typeof r !== "object" || r.isSidechain) continue;
+    const at2 = r.timestamp ?? null;
+    switch (r.type) {
+      case "ai-title":
+        title = r.aiTitle ?? title;
+        break;
+      case "user": {
+        const c = r.message?.content;
+        if (typeof c === "string") {
+          if (r.origin?.kind === "task-notification" || c.trimStart().startsWith("<task-notification>")) {
+            closeTurn();
+            wake = true;
+          } else if (r.isMeta) {
+            const mid = midTurn(c);
+            if (mid) user(r, mid, { queued: true });
+            else context(r, "Context added", c);
+          } else if (INTERRUPTED.test(c.trim())) {
+            if (lastTurn) lastTurn.interrupted = true;
+          } else {
+            const cmd = commandText(c);
+            if (cmd) user(r, cmd, { command: true });
+            else if (!c.includes("<local-command-stdout>")) {
+              const t = captainText(c);
+              if (t) user(r, t);
+            }
+          }
+        } else if (Array.isArray(c)) {
+          for (const b of c) {
+            if (b?.type === "tool_result") {
+              const text = resultText(b.content);
+              const step = tools.get(b.tool_use_id);
+              if (step) {
+                step.result = text;
+                step.isError = !!b.is_error;
+              }
+              const ask = asks.get(b.tool_use_id);
+              if (ask) ask.answers = b.is_error ? {} : answersOf(r, text);
+            } else if (b?.type === "text") {
+              const text = String(b.text ?? "");
+              const mid = midTurn(text);
+              if (INTERRUPTED.test(text.trim())) {
+                if (lastTurn) lastTurn.interrupted = true;
+              } else if (mid) {
+                user(r, mid, { queued: true });
+              } else if (r.isMeta || r.sourceToolUseID) {
+                const label = text.startsWith("Base directory for this skill") ? "Skill instructions loaded" : "Context added";
+                context(r, label, text, `${r.uuid}-${label}`);
+              } else {
+                const t = captainText(text);
+                if (t) user(r, t);
+              }
+            } else if (b?.type === "image") {
+              user(r, "[image]");
+            }
+          }
+        }
+        break;
+      }
+      case "assistant": {
+        for (const b of r.message?.content ?? []) {
+          if (b?.type === "thinking" || b?.type === "redacted_thinking") {
+            const ms = prevAt && at2 ? Date.parse(at2) - Date.parse(prevAt) : null;
+            activity(r).steps.push({ kind: "thinking", id: `${r.uuid}-th`, ms });
+          } else if (b?.type === "tool_use" && b.name === "AskUserQuestion") {
+            const part = {
+              kind: "question",
+              id: b.id,
+              questions: questions(b.input),
+              answers: null
+            };
+            asks.set(b.id, part);
+            ensureTurn(r).parts.push(part);
+          } else if (b?.type === "tool_use") {
+            const d = describeTool(String(b.name), b.input ?? {});
+            const step = {
+              kind: "tool",
+              id: b.id,
+              name: String(b.name),
+              ...d,
+              input: b.input,
+              result: null,
+              isError: false
+            };
+            tools.set(b.id, step);
+            activity(r).steps.push(step);
+          } else if (b?.type === "text") {
+            if (!String(b.text ?? "").trim()) continue;
+            ensureTurn(r).parts.push({ kind: "text", id: `${r.uuid}-t`, text: b.text });
+          }
+        }
+        break;
+      }
+      case "attachment": {
+        const a = r.attachment ?? {};
+        if (a.type === "queued_command" && typeof a.prompt === "string" && (a.commandMode ?? "prompt") === "prompt") {
+          const t = captainText(a.prompt);
+          if (t) user(r, t, { queued: true });
+        } else if (a.type === "hook_additional_context") {
+          const detail = Array.isArray(a.content) ? a.content.join("\n") : String(a.content ?? "");
+          context(r, `Hook added context${a.hookEvent ? ` (${a.hookEvent})` : ""}`, detail);
+        }
+        break;
+      }
+      case "system": {
+        if (r.subtype === "turn_duration") {
+          if (lastTurn) {
+            lastTurn.durationMs = r.durationMs ?? null;
+            lastTurn.done = true;
+          }
+          closeTurn();
+        } else if (r.subtype === "away_summary") {
+          closeTurn();
+          items.push({
+            kind: "notice",
+            id: r.uuid,
+            title: "While you were away",
+            detail: String(r.content ?? ""),
+            at: r.timestamp
+          });
+        } else if (r.subtype === "local_command") {
+          const c = String(r.content ?? "");
+          const out = tag(c, "local-command-stdout") ?? tag(c, "local-command-stderr");
+          const cmd = commandText(c);
+          if (cmd) user(r, cmd, { command: true });
+          else if (out !== null) {
+            const text = out.replace(ANSI, "").trim();
+            if (text) items.push({ kind: "output", id: r.uuid, text, at: r.timestamp });
+          }
+        }
+        break;
+      }
+    }
+    if (at2) prevAt = at2;
+  }
+  const checks = [];
+  const visible = items.filter((it, i) => {
+    if (it.kind !== "turn" || it.trigger !== "background") return true;
+    const reply = it.parts.filter((p) => p.kind === "text").map((p) => p.text).join("\n").trim();
+    const asks2 = it.parts.some((p) => p.kind === "question");
+    const quiet = !asks2 && (!reply || QUIET_REPLY.test(reply));
+    checks.push({
+      id: it.id,
+      at: it.at,
+      durationMs: it.durationMs,
+      // A later item means the turn ended even without a turn_duration record.
+      done: it.done || i < items.length - 1,
+      outcome: quiet ? "quiet" : "reported"
+    });
+    return !quiet;
+  });
+  return { items: visible, title, checks };
+}
+function activitySummary(steps) {
+  const counts = /* @__PURE__ */ new Map();
+  let thought = false;
+  let thinkMs = 0;
+  for (const s of steps) {
+    if (s.kind === "thinking") {
+      thought = true;
+      thinkMs += s.ms ?? 0;
+    }
+    if (s.kind !== "tool") continue;
+    const c = counts.get(s.noun[0]) ?? { n: 0, noun: s.noun };
+    c.n++;
+    counts.set(s.noun[0], c);
+  }
+  const parts = [...counts.values()].map((c) => `${c.n} ${c.n === 1 ? c.noun[0] : c.noun[1]}`);
+  if (!parts.length) {
+    if (!thought) return "Read some context";
+    return thinkMs >= 1e3 ? `Thought for ${duration(thinkMs)}` : "Thought briefly";
+  }
+  return parts.join(", ");
+}
+function duration(ms) {
+  if (ms == null || ms < 0) return "";
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+const IDLE_FALLBACK = 2;
+const norm = (s) => ` ${s.replace(/\s+/g, " ").trim()} `;
+const lastId = (items) => items[items.length - 1]?.id ?? null;
+const at = (items, after) => after === null ? -1 : items.findIndex((it) => it.id === after);
+const isTurn = (i) => i?.kind === "turn";
+function unconfirmed(pending, items) {
+  const claimed = /* @__PURE__ */ new Map();
+  return pending.filter((p) => {
+    if (p.state === "sending" || p.state === "failed") return true;
+    const pos = at(items, p.after);
+    const newer = items.slice(pos + 1);
+    if (p.via === "inbox") return !newer.some(isTurn);
+    const t = norm(p.text);
+    const used = claimed.get(t) ?? 0;
+    const echoes = newer.filter((i) => i.kind === "user" && norm(i.text).includes(t)).length;
+    if (echoes > used) {
+      claimed.set(t, used + 1);
+      return false;
+    }
+    return newer.filter((i) => isTurn(i) && i.done).length < IDLE_FALLBACK;
+  });
+}
+function pendingLabel(p) {
+  switch (p.state) {
+    case "sending":
+      return "Sending…";
+    case "queued":
+      return "Queued · Firstmate is busy and will read it next";
+    case "failed":
+      return p.error ? `Not sent · ${p.error}` : "Not sent";
+    default:
+      return p.via === "inbox" ? "In Firstmate’s inbox" : "Delivered · waiting for Firstmate";
+  }
+}
+const MAX_RECORDS = 6e3;
+class FirstmateChat {
+  session = null;
+  source = null;
+  records = [];
+  /** Our own connection to the Wheelhouse server. */
+  connection = "connecting";
+  /** Bumps when the transcript starts over (a new file), so the page can jump to the end. */
+  resets = 0;
+  commands = [];
+  #chat = derived(() => fold(this.records));
+  get chat() {
+    return this.#chat();
+  }
+  set chat($$value) {
+    return this.#chat($$value);
+  }
+  outbox = [];
+  #pending = derived(() => unconfirmed(this.outbox, this.chat.items));
+  get pending() {
+    return this.#pending();
+  }
+  set pending($$value) {
+    return this.#pending($$value);
+  }
+  close = null;
+  connect() {
+    if (this.close) return () => {
+    };
+    const listen = (es) => {
+      es.addEventListener("session", (e) => {
+        this.session = JSON.parse(e.data);
+        this.connection = "open";
+      });
+      es.addEventListener("reset", (e) => {
+        this.source = JSON.parse(e.data);
+        this.records = [];
+        this.resets++;
+      });
+      es.addEventListener("records", (e) => {
+        const next = [...this.records, ...JSON.parse(e.data)];
+        this.records = next.length > MAX_RECORDS ? next.slice(-MAX_RECORDS) : next;
+      });
+    };
+    this.close = watchedStream("/api/firstmate/chat", listen, (s) => this.connection = s);
+    void this.loadCommands();
+    return () => {
+      this.close?.();
+      this.close = null;
+    };
+  }
+  /**
+   * Send a message, showing it at once as a pending bubble. `busy`: Firstmate is
+   * mid-turn, so Claude Code queues it until the turn ends.
+   */
+  async send(text, via, token, busy) {
+    this.prune();
+    this.outbox.push({
+      id: crypto.randomUUID(),
+      text,
+      via,
+      state: "sending",
+      error: null,
+      after: lastId(this.chat.items)
+    });
+    return this.deliver(this.outbox[this.outbox.length - 1], token, busy);
+  }
+  /** Try a failed message again. */
+  retry(id, token, busy) {
+    const p = this.outbox.find((m) => m.id === id);
+    if (!p || p.state !== "failed") return;
+    p.after = lastId(this.chat.items);
+    void this.deliver(p, token, busy);
+  }
+  dismiss(id) {
+    this.outbox = this.outbox.filter((m) => m.id !== id);
+  }
+  async deliver(p, token, busy) {
+    p.state = "sending";
+    p.error = null;
+    const r = p.via === "inbox" ? await sendToInbox(p.text, token) : await act("/api/firstmate/input", token, { text: p.text });
+    if (r.ok) p.state = busy && p.via === "session" ? "queued" : "delivered";
+    else {
+      p.state = "failed";
+      p.error = r.error;
+    }
+    return r;
+  }
+  /** Forget messages the transcript has since shown. */
+  prune() {
+    const shown = new Set(this.pending.map((m) => m.id));
+    this.outbox = this.outbox.filter((m) => shown.has(m.id));
+  }
+  async loadCommands() {
+    try {
+      const res = await fetch("/api/firstmate/commands");
+      if (res.ok) this.commands = (await res.json()).commands;
+    } catch {
+    }
+  }
+}
+const firstmateChat = new FirstmateChat();
+async function act(path, token, body) {
+  try {
+    const res = await fetch(path, {
+      method: "POST",
+      headers: { "content-type": "application/json", [SESSION_HEADER]: token },
+      body: JSON.stringify(body ?? {})
+    });
+    if (res.ok) return { ok: true };
+    const data = await res.json().catch(() => null);
+    return {
+      ok: false,
+      error: data?.message ?? `Wheelhouse answered ${res.status}.`
+    };
+  } catch {
+    return { ok: false, error: "Could not reach the Wheelhouse server." };
+  }
+}
+async function sendToInbox(text, token, taskId = null, requestId = `wh-${crypto.randomUUID()}`) {
+  try {
+    const res = await fetch("/api/firstmate/messages", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "idempotency-key": requestId,
+        [SESSION_HEADER]: token
+      },
+      body: JSON.stringify({ text, taskId })
+    });
+    if (res.ok) return { ok: true, pending: res.status === 202 };
+    const data = await res.json().catch(() => null);
+    return {
+      ok: false,
+      error: data?.message ?? `Wheelhouse answered ${res.status}.`
+    };
+  } catch {
+    return { ok: false, error: "Could not reach the Wheelhouse server." };
+  }
+}
+
+export { activitySummary as a, duration as d, firstmateChat as f, pendingLabel as p, sendToInbox as s };
+//# sourceMappingURL=chat.svelte.js-b0uQXOge.js.map

package/build/server/chunks/chunks/detail.js-9VHqIqfd.js

@@ -0,0 +1,121 @@
+import { g as getRuntime, E as GAPS } from './runtime.js-4msnOWzY.js';
+import { c as checksLine } from './checks.js-DR3fVVpO.js';
+
+async function taskDetail(id) {
+  const runtime = await getRuntime();
+  if (!runtime.configured) return { ok: false, status: 503, message: runtime.error };
+  const task = runtime.collector.getFleet().tasks.find((t) => t.id === id);
+  if (!task) return { ok: false, status: 404, message: `There is no task called ${id}.` };
+  const row = runtime.collector.row(task.id);
+  const ledger = runtime.collector.ledgerTask(task.id);
+  const ledgerState = runtime.collector.ledgerState();
+  const evidence = await runtime.evidence.evidence(task, row, ledger?.runIds ?? []);
+  const at = (ts) => new Date(ts * 1e3).toISOString();
+  let timeline;
+  if (ledger) {
+    const entries = [];
+    if (ledger.dispatched) {
+      entries.push({
+        at: at(ledger.dispatched.ts),
+        kind: "dispatched",
+        state: null,
+        text: "Dispatched"
+      });
+    }
+    for (const s of ledger.statuses) {
+      entries.push({ at: at(s.ts), kind: "status", state: s.state, text: s.text });
+    }
+    if (ledger.prReady) {
+      entries.push({
+        at: at(ledger.prReady.ts),
+        kind: "pr-ready",
+        state: null,
+        text: ledger.prReady.pr
+      });
+    }
+    if (ledger.merged) {
+      entries.push({
+        at: at(ledger.merged.ts),
+        kind: "merged",
+        state: null,
+        text: ledger.merged.via === "local" ? "Landed locally" : ledger.merged.pr ?? "Merged"
+      });
+    }
+    if (ledger.cleanedUpAt !== null) {
+      entries.push({
+        at: at(ledger.cleanedUpAt),
+        kind: "cleaned-up",
+        state: null,
+        text: "Cleaned up"
+      });
+    }
+    entries.sort((a, b) => a.at.localeCompare(b.at));
+    timeline = {
+      available: true,
+      source: "Firstmate’s fleet activity ledger (history, not current state)",
+      observedAt: null,
+      value: entries.slice(-120)
+    };
+  } else {
+    timeline = {
+      available: false,
+      reason: ledgerState.available ? "The fleet ledger has no history for this task (it may predate the ledger)." : ledgerState.reason ?? "Firstmate’s fleet activity ledger is not available."
+    };
+  }
+  const gaps = [GAPS.decisionOptions];
+  if (task.passage.live === null) gaps.unshift(GAPS.deployment);
+  if (!task.preview) gaps.push(GAPS.preview);
+  if (!row && task.status === "landed") gaps.push(GAPS.landedHistory);
+  if (task.worker && !task.worker.model) gaps.push(GAPS.modelDefault);
+  const decided = runtime.insights.decisions(task.id);
+  const build = await runtime.build.insight(buildContext(runtime, task, evidence.files, decided));
+  const worktree = row?.worktree.present ? row.worktree.path : null;
+  const ids = [.../* @__PURE__ */ new Set([...runtime.insights.runsFor(task.id), ...ledger?.runIds ?? []])];
+  const validations = (await Promise.all(
+    ids.map(
+      (id2) => runtime.evidence.pipeline(id2, worktree).then(
+        (p) => p ? { id: id2, startedAt: p.startedAt, outcome: p.outcome, text: checksLine(p, null) } : null
+      ).catch(() => null)
+    )
+  )).filter((v) => v !== null).sort((a, b) => (a.startedAt ?? "").localeCompare(b.startedAt ?? ""));
+  const detail = {
+    schema: "wheelhouse-task.v1",
+    task,
+    evidence,
+    timeline,
+    gaps,
+    time: runtime.insights.split(task.id),
+    decided,
+    build,
+    validations
+  };
+  return { ok: true, detail };
+}
+function buildContext(runtime, task, files, decided) {
+  const row = runtime.collector.row(task.id);
+  const project = runtime.collector.getFleet().projects.find((p) => p.id === task.projectId);
+  return {
+    task,
+    ledger: runtime.collector.ledgerTask(task.id),
+    worktree: row?.worktree.present ? row.worktree.path : null,
+    projectDir: row?.project ?? project?.path ?? null,
+    runs: runtime.insights.runsFor(task.id),
+    decided,
+    rounds: runtime.insights.questionRounds(task.id),
+    captain: (runtime.messenger?.view().messages ?? []).filter((m) => m.taskId === task.id),
+    files
+  };
+}
+async function taskDoc(id, file) {
+  const runtime = await getRuntime();
+  if (!runtime.configured) return { ok: false, status: 503, message: runtime.error };
+  const task = runtime.collector.getFleet().tasks.find((t) => t.id === id);
+  if (!task) return { ok: false, status: 404, message: `There is no task called ${id}.` };
+  const row = runtime.collector.row(task.id);
+  const files = row?.worktree.present ? await runtime.evidence.diff(row.worktree.path) : { available: false, reason: "The task’s worktree is no longer there." };
+  const ctx = buildContext(runtime, task, files, runtime.insights.decisions(task.id));
+  return { ok: true, task, doc: await runtime.build.doc(ctx, file) };
+}
+
+export { taskDoc as a, taskDetail as t };
+//# sourceMappingURL=detail.js-9VHqIqfd.js.map