@h-rig/cli 0.0.6-alpha.13 → 0.0.6-alpha.14

package/dist/src/commands/task.js

@@ -1,8 +1,8 @@
 // @bun
 // packages/cli/src/commands/task.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { spawnSync as spawnSync2 } from "child_process";
-import { createInterface as createInterface3 } from "readline/promises";
+import { spawnSync } from "child_process";
+import { createInterface as createInterface2 } from "readline/promises";
 import { resolve as resolve4 } from "path";
 
 // packages/cli/src/runner.ts
@@ -188,11 +188,10 @@ function resolveSelectedConnection(projectRoot, options = {}) {
 }
 
 // packages/cli/src/commands/_server-client.ts
-import { spawnSync } from "child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
-var cachedGitHubBearerToken;
+var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
@@ -209,25 +208,13 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  if (cachedGitHubBearerToken !== undefined)
-    return cachedGitHubBearerToken;
+  const scopedKey = resolve2(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession) {
-    cachedGitHubBearerToken = privateSession;
-    return cachedGitHubBearerToken;
-  }
-  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
-  if (envToken) {
-    cachedGitHubBearerToken = envToken;
-    return cachedGitHubBearerToken;
-  }
-  const result = spawnSync("gh", ["auth", "token"], {
-    encoding: "utf8",
-    timeout: 5000,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
-  return cachedGitHubBearerToken;
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 async function ensureServerForCli(projectRoot) {
   try {
@@ -347,6 +334,15 @@ async function getRunLogsViaServer(context, runId, options = {}) {
   const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
 }
+async function getRunTimelineViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/timeline`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
 async function stopRunViaServer(context, runId) {
   const payload = await requestServerJson(context, "/api/runs/stop", {
     method: "POST",
@@ -522,6 +518,9 @@ function permissionAllowsPr(payload) {
   }
   return null;
 }
+function isNotFoundError(error) {
+  return /\b(404|not found)\b/i.test(message(error));
+}
 function projectCheckoutReady(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
     return null;
@@ -554,19 +553,33 @@ async function runFastTaskRunPreflight(context, options = {}) {
   const checks = [];
   const request = options.requestJson ?? ((pathname, init) => requestServerJson(context, pathname, init));
   const taskId = options.taskId?.trim() || null;
+  const requiresCurrentRunApi = Boolean(taskId);
+  const selectedServer = options.requestJson ? null : await ensureServerForCli(context.projectRoot).catch(() => null);
+  const allowLocalLegacyTaskRunCompatibility = selectedServer?.connectionKind === "local";
+  let legacyServerCompatibility = false;
   try {
     await request("/api/server/status");
     checks.push(preflightCheck("server", "Rig server reachable", "pass"));
   } catch (error) {
-    checks.push(preflightCheck("server", "Rig server reachable", "fail", message(error), "Start or select a reachable Rig server."));
+    if (isNotFoundError(error)) {
+      try {
+        await request("/health");
+        legacyServerCompatibility = !requiresCurrentRunApi || allowLocalLegacyTaskRunCompatibility;
+        checks.push(requiresCurrentRunApi && !allowLocalLegacyTaskRunCompatibility ? preflightCheck("server", "Rig server reachable", "fail", "legacy /health endpoint only; current task-run APIs are required", "Upgrade/select the Rig server before launching a task run.") : preflightCheck("server", "Rig server reachable", "pass", allowLocalLegacyTaskRunCompatibility ? "local legacy /health endpoint; submit endpoint will be authoritative" : "legacy /health endpoint"));
+      } catch (healthError) {
+        checks.push(preflightCheck("server", "Rig server reachable", "fail", message(healthError), "Start or select a reachable Rig server."));
+      }
+    } else {
+      checks.push(preflightCheck("server", "Rig server reachable", "fail", message(error), "Start or select a reachable Rig server."));
+    }
   }
   const repo = readRepoConnection(context.projectRoot);
-  checks.push(repo ? preflightCheck("project-link", "project linked to Rig connection", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig connection", "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig connect use <alias|local>`."));
+  checks.push(repo ? preflightCheck("project-link", "project linked to Rig connection", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig connection", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig connect use <alias|local>`."));
   try {
     const auth = await request("/api/github/auth/status");
-    checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
+    checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
   } catch (error) {
-    checks.push(preflightCheck("github-auth", "GitHub auth valid", "fail", message(error), "Fix GitHub auth on the selected Rig server."));
+    checks.push(preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix GitHub auth on the selected Rig server."));
   }
   try {
     const projection = await request("/api/workspace/task-projection");
@@ -594,9 +607,9 @@ async function runFastTaskRunPreflight(context, options = {}) {
     try {
       const tasks = await request(`/api/workspace/tasks?limit=200&refresh=1`);
       const found = Array.isArray(tasks) && tasks.some((task) => taskMatchesId(task, taskId));
-      checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
+      checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
     } catch (error) {
-      checks.push(preflightCheck("issue", "task/issue accessible", "fail", message(error), "Fix the task source before launching a run."));
+      checks.push(preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix the task source before launching a run."));
     }
     try {
       const runs = await request("/api/runs?limit=200");
@@ -705,8 +718,135 @@ function withMutedConsole(mute, fn) {
   }
 }
 
-// packages/cli/src/commands/_task-picker.ts
-import { createInterface } from "readline/promises";
+// packages/cli/src/commands/_operator-surface.ts
+import { createInterface } from "readline";
+import { createInterface as createPromptInterface } from "readline/promises";
+var CANONICAL_STAGES = [
+  "Connect",
+  "GitHub/task sync",
+  "Prepare workspace",
+  "Launch Pi",
+  "Plan",
+  "Implement",
+  "Validate",
+  "Commit",
+  "Open PR",
+  "Review/CI",
+  "Merge",
+  "Complete"
+];
+function logDetail(log) {
+  return typeof log.detail === "string" ? log.detail.trim() : "";
+}
+function entryId(entry, fallback) {
+  return typeof entry.id === "string" && entry.id.trim() ? entry.id : fallback;
+}
+function renderOperatorSnapshot(snapshot) {
+  const run = snapshot.run.run && typeof snapshot.run.run === "object" ? snapshot.run.run : snapshot.run;
+  const runId = String(run.runId ?? run.id ?? "run");
+  const status = String(run.status ?? "unknown");
+  const logs = snapshot.logs ?? [];
+  const latestByStage = new Map;
+  for (const log of logs) {
+    const title = String(log.title ?? "").toLowerCase();
+    const stageName = String(log.stage ?? "").toLowerCase();
+    const stage = CANONICAL_STAGES.find((candidate) => candidate.toLowerCase() === title || candidate.toLowerCase() === stageName);
+    if (stage)
+      latestByStage.set(stage, log);
+  }
+  const stageLines = CANONICAL_STAGES.flatMap((stage) => {
+    const match = latestByStage.get(stage);
+    return match ? [`${stage}: ${String(match.status ?? status)}${logDetail(match) ? ` \u2014 ${logDetail(match)}` : ""}`] : [];
+  });
+  return [`Rig run ${runId}: ${status}`, ...stageLines].join(`
+`);
+}
+function createPiRunStreamRenderer(output = process.stdout) {
+  let lastSnapshot = "";
+  const assistantTextById = new Map;
+  const seenTimeline = new Set;
+  const seenLogs = new Set;
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    renderSnapshot(snapshot) {
+      const rendered = renderOperatorSnapshot(snapshot);
+      if (rendered && rendered !== lastSnapshot) {
+        writeLine(rendered);
+        lastSnapshot = rendered;
+      }
+    },
+    renderTimeline(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `timeline:${index}:${String(entry.cursor ?? "")}`);
+        if (entry.type === "assistant_message" && typeof entry.text === "string") {
+          const text = entry.text;
+          const previousText = assistantTextById.get(id) ?? "";
+          if (text.startsWith(previousText)) {
+            const delta = text.slice(previousText.length);
+            if (delta)
+              output.write(delta);
+          } else if (text.trim() && text !== previousText) {
+            writeLine(`
+[Pi assistant]`);
+            output.write(text);
+          }
+          assistantTextById.set(id, text);
+          continue;
+        }
+        if (seenTimeline.has(id))
+          continue;
+        seenTimeline.add(id);
+        if (entry.type === "tool_execution_start" || entry.type === "tool_execution_update" || entry.type === "tool_execution_end" || entry.type === "mcp_tool_call") {
+          writeLine(`[Pi tool] ${String(entry.toolName ?? entry.name ?? entry.title ?? entry.type)} ${String(entry.status ?? entry.state ?? "")}`.trim());
+          continue;
+        }
+        if (entry.type === "timeline_warning") {
+          writeLine(`[Rig timeline] ${String(entry.detail ?? entry.message ?? "timeline unavailable")}`);
+        }
+      }
+    },
+    renderLogs(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `log:${index}:${String(entry.createdAt ?? "")}:${String(entry.title ?? "")}`);
+        if (seenLogs.has(id))
+          continue;
+        seenLogs.add(id);
+        const title = String(entry.title ?? "");
+        if (CANONICAL_STAGES.some((stage) => stage.toLowerCase() === title.toLowerCase()))
+          continue;
+        const detail = logDetail(entry);
+        if (!detail)
+          continue;
+        writeLine(`[${title || "Rig log"}] ${detail}`);
+      }
+    }
+  };
+}
+function createOperatorSurface(options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const errorOutput = options.errorOutput ?? process.stderr;
+  const renderer = createPiRunStreamRenderer(output);
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    mode: "pi-compatible-text",
+    ...renderer,
+    info: writeLine,
+    error: (message2) => errorOutput.write(`${message2}
+`),
+    attachCommandInput(handler) {
+      if (options.interactive === false || !input.isTTY)
+        return null;
+      const rl = createInterface({ input, output: process.stdout, terminal: false });
+      rl.on("line", (line) => {
+        Promise.resolve(handler(line)).catch((error) => writeLine(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      });
+      return { close: () => rl.close() };
+    }
+  };
+}
 function taskId(task) {
   return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
 }
@@ -719,6 +859,19 @@ function taskStatus(task) {
 function renderTaskPickerRows(tasks) {
   return tasks.map((task, index) => `${index + 1}. ${taskId(task)} \xB7 ${taskStatus(task)} \xB7 ${taskTitle(task)}`);
 }
+async function promptForTaskSelection(question) {
+  const rl = createPromptInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+
+// packages/cli/src/commands/_task-picker.ts
+function taskId2(task) {
+  return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
+}
 async function selectTaskWithTextPicker(tasks, io = {}) {
   if (tasks.length === 0)
     return null;
@@ -728,17 +881,12 @@ async function selectTaskWithTextPicker(tasks, io = {}) {
   if (!isTty) {
     throw new Error("task run requires an interactive terminal to pick a task; pass --task <id>, --next, or --detach with a task id.");
   }
-  const prompt = io.prompt ?? (async (question) => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-      return await rl.question(question);
-    } finally {
-      rl.close();
-    }
-  });
-  console.log("Select Rig task:");
+  const prompt = io.prompt ?? promptForTaskSelection;
+  const renderer = io.renderer ?? { writeLine: (line) => process.stdout.write(`${line}
+`) };
+  renderer.writeLine("Select Rig task:");
   for (const row of renderTaskPickerRows(tasks))
-    console.log(`  ${row}`);
+    renderer.writeLine(`  ${row}`);
   const answer = (await prompt(`Task [1-${tasks.length}] or id: `)).trim();
   if (!answer)
     return null;
@@ -746,38 +894,11 @@ async function selectTaskWithTextPicker(tasks, io = {}) {
     const index = Number.parseInt(answer, 10) - 1;
     return tasks[index] ?? null;
   }
-  return tasks.find((task) => taskId(task) === answer) ?? null;
+  return tasks.find((task) => taskId2(task) === answer) ?? null;
 }
 
 // packages/cli/src/commands/_operator-view.ts
-import { createInterface as createInterface2 } from "readline";
 var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
-var CANONICAL_STAGES = [
-  "Connect",
-  "GitHub/task sync",
-  "Prepare workspace",
-  "Launch Pi",
-  "Plan",
-  "Implement",
-  "Validate",
-  "Commit",
-  "Open PR",
-  "Review/CI",
-  "Merge",
-  "Complete"
-];
-function renderOperatorSnapshot(snapshot) {
-  const run = snapshot.run.run && typeof snapshot.run.run === "object" ? snapshot.run.run : snapshot.run;
-  const runId = String(run.runId ?? run.id ?? "run");
-  const status = String(run.status ?? "unknown");
-  const logs = snapshot.logs ?? [];
-  const stageLines = CANONICAL_STAGES.flatMap((stage) => {
-    const match = logs.find((log) => String(log.title ?? "").toLowerCase() === stage.toLowerCase() || String(log.stage ?? "").toLowerCase() === stage.toLowerCase());
-    return match ? [`${stage}: ${String(match.status ?? status)}`] : [];
-  });
-  return [`Rig run ${runId}: ${status}`, ...stageLines].join(`
-`);
-}
 function runStatusFromPayload(payload) {
   const run = payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
   return String(run.status ?? "unknown").toLowerCase();
@@ -799,11 +920,22 @@ async function applyOperatorCommand(context, input, deps = {}) {
   await (deps.steer ?? steerRunViaServer)(context, input.runId, userMessage);
   return { action: "continue", message: "Steering message queued." };
 }
-async function readOperatorSnapshot(context, runId) {
+async function readOperatorSnapshot(context, runId, options = {}) {
   const run = await getRunDetailsViaServer(context, runId);
   const logsPage = await getRunLogsViaServer(context, runId, { limit: 100 });
-  const entries = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-  return { run, logs: entries, rendered: renderOperatorSnapshot({ run, logs: entries }) };
+  const timelinePage = await getRunTimelineViaServer(context, runId, { limit: 200, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} }).catch((error) => ({
+    entries: [{
+      id: `timeline-unavailable:${runId}`,
+      type: "timeline_warning",
+      detail: `Selected Rig server did not provide run timeline events: ${error instanceof Error ? error.message : String(error)}`,
+      createdAt: new Date().toISOString()
+    }],
+    nextCursor: options.timelineCursor ?? null
+  }));
+  const logs = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).toReversed() : [];
+  const timeline = Array.isArray(timelinePage.entries) ? timelinePage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  const timelineCursor = typeof timelinePage.nextCursor === "string" ? timelinePage.nextCursor : options.timelineCursor ?? null;
+  return { run, logs, timeline, timelineCursor, rendered: renderOperatorSnapshot({ run, logs, timeline }) };
 }
 async function attachRunOperatorView(context, input) {
   let steered = false;
@@ -811,40 +943,41 @@ async function attachRunOperatorView(context, input) {
     await steerRunViaServer(context, input.runId, input.message.trim());
     steered = true;
   }
+  const surface = createOperatorSurface({ interactive: input.interactive !== false });
   let snapshot = await readOperatorSnapshot(context, input.runId);
   if (context.outputMode === "text") {
-    console.log(snapshot.rendered);
+    surface.renderSnapshot(snapshot);
+    surface.renderTimeline(snapshot.timeline);
+    surface.renderLogs(snapshot.logs);
     if (steered)
-      console.log("Steering message queued.");
+      surface.info("Steering message queued.");
   }
   let detached = false;
-  let rl = null;
+  let commandInput = null;
   if (input.follow && !input.once && context.outputMode === "text") {
     if (input.interactive !== false && process.stdin.isTTY) {
-      console.log("Controls: /user <message>, /stop, /detach");
-      rl = createInterface2({ input: process.stdin, output: process.stdout, terminal: false });
-      rl.on("line", (line) => {
-        applyOperatorCommand(context, { runId: input.runId, line }).then((result) => {
-          if (result.message)
-            console.log(result.message);
-          if (result.action === "detach" || result.action === "stopped") {
-            detached = true;
-            rl?.close();
-          }
-        }).catch((error) => console.log(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      surface.info("Controls: /user <message>, /stop, /detach");
+      commandInput = surface.attachCommandInput(async (line) => {
+        const result = await applyOperatorCommand(context, { runId: input.runId, line });
+        if (result.message)
+          surface.info(result.message);
+        if (result.action === "detach" || result.action === "stopped") {
+          detached = true;
+          commandInput?.close();
+        }
       });
     }
-    let lastRendered = snapshot.rendered;
     const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
+    let timelineCursor = snapshot.timelineCursor;
     while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
       await Bun.sleep(pollMs);
-      snapshot = await readOperatorSnapshot(context, input.runId);
-      if (snapshot.rendered !== lastRendered) {
-        console.log(snapshot.rendered);
-        lastRendered = snapshot.rendered;
-      }
+      snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
+      timelineCursor = snapshot.timelineCursor;
+      surface.renderSnapshot(snapshot);
+      surface.renderTimeline(snapshot.timeline);
+      surface.renderLogs(snapshot.logs);
     }
-    rl?.close();
+    commandInput?.close();
   }
   return { ...snapshot, steered, detached };
 }
@@ -924,7 +1057,7 @@ function normalizePrMode(value) {
   throw new CliError2("--pr must be auto, ask, or off.", 2);
 }
 function detectLocalDirtyState(projectRoot) {
-  const result = spawnSync2("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5000 });
+  const result = spawnSync("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5000 });
   if (result.status !== 0)
     return { dirty: false, modified: 0, untracked: 0, lines: [] };
   const lines = result.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
@@ -958,7 +1091,7 @@ async function resolveDirtyBaselineForTaskRun(context, explicit) {
   if (explicit)
     return { mode: explicit, state };
   if (context.outputMode === "text" && process.stdin.isTTY && process.stdout.isTTY) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     try {
       const answer = (await rl.question("Include current uncommitted changes in run baseline? [y/N] ")).trim().toLowerCase();
       return { mode: answer === "y" || answer === "yes" ? "dirty-snapshot" : "head", state };
@@ -1043,12 +1176,12 @@ async function executeTask(context, args, options) {
       const positional = taskOption.rest.length > 0 && taskOption.rest[0] && !taskOption.rest[0].startsWith("-") ? taskOption.rest[0] : undefined;
       const remaining = positional ? taskOption.rest.slice(1) : taskOption.rest;
       requireNoExtraArgs(remaining, "bun run rig task show <id>|--task <id>");
-      const taskId2 = normalizeTaskRunTaskId(taskOption.value ?? positional);
-      if (!taskId2)
+      const taskId3 = normalizeTaskRunTaskId(taskOption.value ?? positional);
+      if (!taskId3)
         throw new CliError2("task show requires a task id.", 2);
-      const task = await getWorkspaceTaskViaServer(context, taskId2);
+      const task = await getWorkspaceTaskViaServer(context, taskId3);
       if (!task)
-        throw new CliError2(`Task not found: ${taskId2}`, 3);
+        throw new CliError2(`Task not found: ${taskId3}`, 3);
       const summary = summarizeTask(task, { raw: true });
       if (context.outputMode === "text")
         console.log(JSON.stringify(summary, null, 2));