@h-rig/cli-surface-plugin 0.0.6-alpha.146

package/dist/src/commands/task.js

@@ -0,0 +1,555 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli-surface-plugin/src/commands/task.ts
+import {
+  applyFilters,
+  createTask,
+  getTask,
+  listTasks,
+  normalizeTaskId,
+  readTaskTitle,
+  resolveStartTask,
+  selectNextReadyTask,
+  taskArtifactDir,
+  taskArtifacts,
+  taskArtifactWrite,
+  taskDeps,
+  taskInfo,
+  taskLookup,
+  taskReady,
+  taskRecord,
+  taskReopen,
+  taskScope,
+  taskStatus,
+  taskValidate,
+  taskVerify
+} from "@rig/client";
+
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+function requireTask(taskId, usage) {
+  if (!taskId) {
+    throw new CliError(`Missing --task option.
+Usage: ${usage}`);
+  }
+  return taskId;
+}
+
+// packages/cli-surface-plugin/src/kernel-dispatch.ts
+async function dispatchThroughKernel(input, options) {
+  const { getProcessKernel } = await import("@rig/kernel/boot-default");
+  const kernel = getProcessKernel();
+  if (!kernel) {
+    throw new Error("Kernel not booted: cannot dispatch a run through the transport capability.");
+  }
+  const runId = await kernel.transport.dispatch(input, options);
+  return { runId };
+}
+
+// packages/cli-surface-plugin/src/commands/_cli-format.ts
+import pc from "picocolors";
+import { runStatusColorRole, runStatusText, statusColorRole } from "@rig/client";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function arrayField(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function rawObject(record) {
+  const value = record.raw;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : record;
+}
+function truncate(value, width) {
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function colorForRole(role) {
+  switch (role) {
+    case "success":
+      return pc.green;
+    case "action-yellow":
+      return pc.yellow;
+    case "active-cyan":
+      return pc.cyan;
+    case "failure":
+      return pc.red;
+    case "muted":
+    case "neutral":
+      return pc.dim;
+  }
+}
+function statusColor(status) {
+  return colorForRole(statusColorRole(status));
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function printFormattedOutput(message) {
+  console.log(message);
+}
+function formatSection(title, subtitle) {
+  return `${pc.bold(accent("\u25C6"))} ${pc.bold(title)}${subtitle ? dim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatSuccessCard(title, rows = []) {
+  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${faintBar} ${dim(key.padEnd(12))} ${value}`);
+  return [formatSection(title), ...body].join(`
+`);
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${accent("\u203A")} ${step}`)];
+}
+function formatTaskList(tasks, options = {}) {
+  if (tasks.length === 0) {
+    return [formatSection("Tasks", "empty"), dim("No tasks available."), "", ...formatNextSteps(["Refresh: `rig task list`", "Pick next: `rig task next`"])].join(`
+`);
+  }
+  if (options.raw) {
+    return JSON.stringify(tasks, null, 2);
+  }
+  const rows = tasks.map((task) => summarizeTaskRow(task));
+  const idWidth = Math.max(2, ...rows.map((row) => row.id.length));
+  const statusWidth = Math.max(6, ...rows.map((row) => row.status.length));
+  const body = rows.map((row) => {
+    const labels = row.labels.length > 0 ? dim(`  ${row.labels.slice(0, 4).map((label) => `#${label}`).join(" ")}`) : "";
+    const source = row.source ? dim(`  ${row.source}`) : "";
+    return [
+      pc.bold(pad(truncate(row.id, idWidth), idWidth)),
+      statusColor(row.status)(pad(truncate(row.status, statusWidth), statusWidth)),
+      `${row.title}${labels}${source}`
+    ].join("  ");
+  });
+  return [formatSection("Tasks", `${tasks.length}`), ...body].join(`
+`);
+}
+function summarizeTaskRow(task) {
+  const raw = rawObject(task);
+  return {
+    id: firstString(task, ["id", "taskId"], "(unknown-task)"),
+    title: firstString(task, ["title", "summary", "name"], "(untitled)"),
+    status: firstString(task, ["status"], "unknown"),
+    labels: arrayField(task, "labels").length > 0 ? arrayField(task, "labels") : arrayField(raw, "labels"),
+    source: firstString(task, ["source"], "")
+  };
+}
+function formatTaskCard(task, options = {}) {
+  const raw = rawObject(task);
+  const lines = [formatSection(options.title ?? (options.selected ? "Selected task" : "Task"))];
+  for (const [label, value] of [
+    ["id", firstString(task, ["id", "taskId"], "(unknown-task)")],
+    ["title", firstString(task, ["title", "summary", "name"], "(untitled)")],
+    ["status", firstString(task, ["status"], "unknown")],
+    ["source", firstString(task, ["source"], "")],
+    ["url", firstString(raw, ["url"], "")]
+  ]) {
+    if (value)
+      lines.push(`${faintBar} ${dim(label.padEnd(12))} ${value}`);
+  }
+  const labels = arrayField(task, "labels");
+  if (labels.length > 0)
+    lines.push(`${faintBar} ${dim("labels".padEnd(12))} ${labels.map((label) => `#${label}`).join(" ")}`);
+  return lines.join(`
+`);
+}
+function formatTaskDetails(task) {
+  return formatTaskCard(task, { title: "Task details" });
+}
+function formatSubmittedRun(input) {
+  return formatSuccessCard("Run submitted", [
+    ["run", input.runId],
+    ["task", input.taskId ?? undefined],
+    ["title", input.title ?? undefined],
+    ["queue", input.queuePosition ?? undefined]
+  ]);
+}
+
+// packages/cli-surface-plugin/src/commands/task.ts
+function parsePositiveLimit(value) {
+  if (value === undefined)
+    return;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0 || String(parsed) !== value.trim()) {
+    throw new CliError("--limit must be a positive integer.", 1, { hint: "Re-run with a positive number, e.g. `rig task list --limit 20`." });
+  }
+  return parsed;
+}
+function parseTaskFilters(args) {
+  let pending = args;
+  const assigneeResult = takeOption(pending, "--assignee");
+  pending = assigneeResult.rest;
+  const stateResult = takeOption(pending, "--state");
+  pending = stateResult.rest;
+  const limitResult = takeOption(pending, "--limit");
+  pending = limitResult.rest;
+  const searchResult = takeOption(pending, "--search");
+  pending = searchResult.rest;
+  const state = stateResult.value?.toLowerCase();
+  if (state !== undefined && state !== "open" && state !== "closed") {
+    throw new CliError(`Invalid --state value: ${stateResult.value}`, 1, { hint: "Use --state open or --state closed." });
+  }
+  const assignee = assigneeResult.value;
+  const limit = parsePositiveLimit(limitResult.value);
+  const search = searchResult.value?.trim();
+  return {
+    filters: {
+      ...assignee ? { assignee } : {},
+      ...state ? { state } : {},
+      ...limit !== undefined ? { limit } : {},
+      ...search ? { search } : {}
+    },
+    rest: pending
+  };
+}
+function parsePromptOverride(prompt, initialPrompt) {
+  const promptText = prompt?.trim();
+  const initialPromptText = initialPrompt?.trim();
+  if (promptText && initialPromptText) {
+    throw new CliError("Pass only one of --prompt or --initial-prompt.", 2, {
+      hint: "Use `--prompt <text>`; `--initial-prompt` is accepted as a compatibility alias."
+    });
+  }
+  return promptText || initialPromptText || null;
+}
+function printText(context, message) {
+  if (context.outputMode === "text")
+    printFormattedOutput(message);
+}
+async function captureOutputForJson(context, work) {
+  if (context.outputMode === "text")
+    return { result: await work(), output: null };
+  const originalLog = console.log;
+  const stdout = process.stdout;
+  const originalWrite = stdout.write;
+  let output = "";
+  console.log = (...args) => {
+    output += `${args.map(String).join(" ")}
+`;
+  };
+  stdout.write = (chunk, ...args) => {
+    output += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    const callback = args.find((arg) => typeof arg === "function");
+    callback?.();
+    return true;
+  };
+  try {
+    return { result: await work(), output };
+  } finally {
+    console.log = originalLog;
+    stdout.write = originalWrite;
+  }
+}
+async function listTasksForCommand(projectRoot, deps) {
+  if (deps.listTasks)
+    return deps.listTasks(projectRoot);
+  if (deps.loadTaskSource) {
+    const { kind, source } = await deps.loadTaskSource(projectRoot);
+    return (await source.list()).map((task) => ({ ...task, source: kind }));
+  }
+  return listTasks(projectRoot);
+}
+async function getTaskForCommand(projectRoot, taskId, deps) {
+  if (deps.getTask)
+    return deps.getTask(projectRoot, taskId);
+  if (deps.loadTaskSource) {
+    const { kind, source } = await deps.loadTaskSource(projectRoot);
+    const task = source.get ? await source.get(taskId) : (await source.list()).find((entry) => entry.id === taskId);
+    return task ? { ...task, source: kind } : null;
+  }
+  return getTask(projectRoot, taskId);
+}
+async function executeReportBug(context, args, deps) {
+  let pending = args;
+  const titleResult = takeOption(pending, "--title");
+  pending = titleResult.rest;
+  const bodyResult = takeOption(pending, "--body");
+  pending = bodyResult.rest;
+  requireNoExtraArgs(pending, "rig task report-bug --title <text> [--body <text>]");
+  const title = titleResult.value?.trim();
+  if (!title)
+    throw new CliError("rig task report-bug requires --title.", 1, { hint: 'Re-run with `rig task report-bug --title "Short bug title"`.' });
+  if (deps.loadTaskSource) {
+    const { kind, source } = await deps.loadTaskSource(context.projectRoot);
+    const creator = taskCreator(source);
+    if (!creator)
+      throw new CliError(`The configured ${kind} task source does not expose a create API.`, 1, { hint: "Create the bug in the configured task source directly, or install a task source that supports createTask/create." });
+    const created2 = await creator({ title, body: bodyResult.value ?? "Bug reported via `rig task report-bug`.", status: "open", labels: ["bug"], type: "bug" });
+    const taskId = typeof created2 === "string" ? created2 : created2 && typeof created2 === "object" && ("id" in created2) && typeof created2.id === "string" ? created2.id : undefined;
+    printText(context, taskId ? `Created bug task ${taskId}.` : "Created bug task.");
+    return { ok: true, group: "task", command: "report-bug", details: { taskId: taskId ?? null, source: kind } };
+  }
+  const created = await createTask(context.projectRoot, { title, body: bodyResult.value ?? "Bug reported via `rig task report-bug`.", status: "open", labels: ["bug"], type: "bug" });
+  printText(context, created.taskId ? `Created bug task ${created.taskId}.` : "Created bug task.");
+  return { ok: true, group: "task", command: "report-bug", details: { taskId: created.taskId, source: created.source } };
+}
+function taskCreator(source) {
+  const record = source;
+  if (typeof record.createTask === "function")
+    return record.createTask.bind(source);
+  if (typeof record.create === "function")
+    return record.create.bind(source);
+  return null;
+}
+async function resolveRunTask(context, rawTaskId, useNext, filters, deps) {
+  return resolveStartTask({
+    projectRoot: context.projectRoot,
+    taskId: rawTaskId,
+    next: useNext,
+    filters,
+    listTasks: (root) => listTasksForCommand(root, deps),
+    getTask: (root, taskId) => getTaskForCommand(root, taskId, deps)
+  });
+}
+async function executeTask(context, args, deps = {}) {
+  const [command = "help", ...rest] = args;
+  switch (command) {
+    case "help":
+      printText(context, "Usage: rig task <list|next|show|details|run|ready|validate|verify|reopen|artifacts|artifact-dir|artifact-write|report-bug|info|scope|deps|status|lookup|record>");
+      return { ok: true, group: "task", command: "help" };
+    case "list": {
+      const parsed = parseTaskFilters(rest);
+      requireNoExtraArgs(parsed.rest, "rig task list [--assignee <login|me|@me>] [--state open|closed] [--search <text>] [--limit <n>]");
+      const tasks = applyFilters(await listTasksForCommand(context.projectRoot, deps), parsed.filters);
+      printText(context, formatTaskList(tasks));
+      return { ok: true, group: "task", command, details: { tasks, count: tasks.length } };
+    }
+    case "next": {
+      const parsed = parseTaskFilters(rest);
+      requireNoExtraArgs(parsed.rest, "rig task next [--assignee <login|me|@me>] [--state open|closed] [--search <text>] [--limit <n>]");
+      const task = selectNextReadyTask(await listTasksForCommand(context.projectRoot, deps), parsed.filters);
+      if (!task) {
+        printText(context, formatTaskList([]));
+        return { ok: true, group: "task", command, details: { task: null } };
+      }
+      printText(context, formatTaskCard(task));
+      return { ok: true, group: "task", command, details: { task } };
+    }
+    case "show": {
+      let pending = rest;
+      const rawResult = takeFlag(pending, "--raw");
+      pending = rawResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const positional = pending[0]?.startsWith("-") ? undefined : pending[0];
+      requireNoExtraArgs(positional ? pending.slice(1) : pending, "rig task show <id>|--task <id> [--raw]");
+      const taskId = requireTask(normalizeTaskId(taskResult.value ?? positional), "rig task show <id>|--task <id>");
+      const task = await getTaskForCommand(context.projectRoot, taskId, deps);
+      if (!task)
+        throw new CliError(`Task not found: ${taskId}`, 1, { hint: "Run `rig task list` to see available task ids." });
+      printText(context, rawResult.value ? JSON.stringify(task, null, 2) : formatTaskCard(task));
+      return { ok: true, group: "task", command, details: task };
+    }
+    case "details": {
+      const taskResult = takeOption(rest, "--task");
+      requireNoExtraArgs(taskResult.rest, "rig task details --task <id>");
+      const taskId = requireTask(normalizeTaskId(taskResult.value), "rig task details --task <id>");
+      const task = await getTaskForCommand(context.projectRoot, taskId, deps);
+      if (!task)
+        throw new CliError(`Task not found: ${taskId}`, 1, { hint: "Run `rig task list` to see available task ids." });
+      printText(context, formatTaskDetails(task));
+      return { ok: true, group: "task", command, details: task };
+    }
+    case "run": {
+      let pending = rest;
+      const nextResult = takeFlag(pending, "--next");
+      pending = nextResult.rest;
+      const detachResult = takeFlag(pending, "--detach");
+      pending = detachResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const titleResult = takeOption(pending, "--title");
+      pending = titleResult.rest;
+      const modelResult = takeOption(pending, "--model");
+      pending = modelResult.rest;
+      const promptResult = takeOption(pending, "--prompt");
+      pending = promptResult.rest;
+      const initialPromptResult = takeOption(pending, "--initial-prompt");
+      pending = initialPromptResult.rest;
+      const parsed = parseTaskFilters(pending);
+      pending = parsed.rest;
+      const positional = pending[0]?.startsWith("-") ? undefined : pending[0];
+      requireNoExtraArgs(positional ? pending.slice(1) : pending, "rig task run [#<issue>|<task-id>|--next|--task <id>] [--title <t>] [--model <m>] [--prompt <p>] [--initial-prompt <p>] [--detach] [--search <text>]");
+      const model = modelResult.value?.trim() || null;
+      const prompt = parsePromptOverride(promptResult.value, initialPromptResult.value);
+      const { taskId, task } = await resolveRunTask(context, taskResult.value ?? positional, nextResult.value, parsed.filters, deps);
+      const title = titleResult.value ?? readTaskTitle(task);
+      const submitted = await (deps.dispatch ?? deps.spawnRun ?? dispatchThroughKernel)({ projectRoot: context.projectRoot, taskId, title, model, prompt });
+      const note = detachResult.value ? `
+
+Note: --detach is the default; the run was submitted detached.` : "";
+      printText(context, `${formatSubmittedRun({ runId: submitted.runId, taskId, title })}
+
+Next: rig run attach ${submitted.runId}${note}`);
+      return { ok: true, group: "task", command, details: { runId: submitted.runId, taskId, title: title ?? null, model, prompt, detached: true } };
+    }
+    case "ready":
+      requireNoExtraArgs(rest, "rig task ready");
+      const captured = await captureOutputForJson(context, () => (deps.taskReady ?? taskReady)(context.projectRoot));
+      return { ok: true, group: "task", command, details: { ...captured.output !== null ? { output: captured.output } : {} } };
+    case "validate":
+    case "verify": {
+      const taskResult = takeOption(rest, "--task");
+      requireNoExtraArgs(taskResult.rest, `rig task ${command} [--task <id>]`);
+      const taskId = normalizeTaskId(taskResult.value);
+      const captured2 = await captureOutputForJson(context, () => command === "validate" ? (deps.taskValidate ?? taskValidate)(context.projectRoot, taskId) : (deps.taskVerify ?? taskVerify)(context.projectRoot, taskId));
+      const passed = captured2.result;
+      if (passed === false)
+        throw new CliError(`rig task ${command} failed${taskId ? ` for task ${taskId}` : ""}.`, 1, { hint: command === "validate" ? "Fix validation failures, then re-run `rig task validate`." : "Fix verification failures, then re-run `rig task verify`." });
+      return { ok: true, group: "task", command, details: { taskId: taskId ?? null, passed: true, ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "reopen": {
+      let pending = rest;
+      const allResult = takeFlag(pending, "--all");
+      pending = allResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const reasonResult = takeOption(pending, "--reason");
+      pending = reasonResult.rest;
+      requireNoExtraArgs(pending, "rig task reopen [--task <id> | --all] [--reason <text>]");
+      const taskId = normalizeTaskId(taskResult.value);
+      if (allResult.value && taskId)
+        throw new CliError("Pass only one of --task or --all.", 1, { hint: "Use `rig task reopen --task <id>` or `rig task reopen --all`." });
+      const captured2 = await captureOutputForJson(context, () => (deps.taskReopen ?? taskReopen)(context.projectRoot, { all: allResult.value, dryRun: context.dryRun, ...taskId ? { taskId } : {} }));
+      const summary = captured2.result;
+      return { ok: true, group: "task", command, details: { ...summary, reason: reasonResult.value ?? null, ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "artifacts": {
+      const taskResult = takeOption(rest, "--task");
+      const positional = taskResult.rest[0]?.startsWith("-") ? undefined : taskResult.rest[0];
+      requireNoExtraArgs(positional ? taskResult.rest.slice(1) : taskResult.rest, "rig task artifacts [<id>|--task <id>]");
+      const taskId = normalizeTaskId(taskResult.value ?? positional);
+      const captured2 = await captureOutputForJson(context, () => (deps.taskArtifacts ?? taskArtifacts)(context.projectRoot, taskId));
+      return { ok: true, group: "task", command, details: { taskId: taskId ?? null, ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "artifact-dir": {
+      const taskResult = takeOption(rest, "--task");
+      requireNoExtraArgs(taskResult.rest, "rig task artifact-dir [--task <id>]");
+      const taskId = normalizeTaskId(taskResult.value);
+      const dir = (deps.taskArtifactDir ?? taskArtifactDir)(context.projectRoot, taskId);
+      printText(context, dir);
+      return { ok: true, group: "task", command, details: { taskId: taskId ?? null, dir } };
+    }
+    case "artifact-write": {
+      const taskResult = takeOption(rest, "--task");
+      const [filename, content, ...extra] = taskResult.rest;
+      requireNoExtraArgs(extra, "rig task artifact-write <filename> <content> [--task <id>]");
+      if (!filename || content === undefined)
+        throw new CliError("Missing artifact filename or content.", 1, { hint: "Use `rig task artifact-write <filename> <content> [--task <id>]`." });
+      const taskId = normalizeTaskId(taskResult.value);
+      const captured2 = await captureOutputForJson(context, () => (deps.taskArtifactWrite ?? taskArtifactWrite)(context.projectRoot, filename, content, taskId));
+      return { ok: true, group: "task", command, details: { taskId: taskId ?? null, filename, ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "report-bug":
+      return executeReportBug(context, rest, deps);
+    case "info": {
+      const taskResult = takeOption(rest, "--task");
+      const positional = taskResult.rest[0]?.startsWith("-") ? undefined : taskResult.rest[0];
+      requireNoExtraArgs(positional ? taskResult.rest.slice(1) : taskResult.rest, "rig task info [<id>|--task <id>]");
+      const taskId = normalizeTaskId(taskResult.value ?? positional);
+      const captured2 = await captureOutputForJson(context, () => (deps.taskInfo ?? taskInfo)(context.projectRoot, taskId));
+      return { ok: true, group: "task", command, details: { taskId: taskId ?? null, ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "scope": {
+      const filesFlag = takeFlag(rest, "--files");
+      const taskResult = takeOption(filesFlag.rest, "--task");
+      requireNoExtraArgs(taskResult.rest, "rig task scope [--files] [--task <id>]");
+      const captured2 = await captureOutputForJson(context, () => (deps.taskScope ?? taskScope)(context.projectRoot, Boolean(filesFlag.value), normalizeTaskId(taskResult.value)));
+      return { ok: true, group: "task", command, details: { ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "deps": {
+      const taskResult = takeOption(rest, "--task");
+      requireNoExtraArgs(taskResult.rest, "rig task deps [--task <id>]");
+      const captured2 = await captureOutputForJson(context, () => (deps.taskDeps ?? taskDeps)(context.projectRoot, normalizeTaskId(taskResult.value)));
+      return { ok: true, group: "task", command, details: { ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "status": {
+      requireNoExtraArgs(rest, "rig task status");
+      const captured2 = await captureOutputForJson(context, () => (deps.taskStatus ?? taskStatus)(context.projectRoot));
+      return { ok: true, group: "task", command, details: { ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    case "lookup": {
+      const [rawId, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig task lookup <id>");
+      const lookupId = requireTask(normalizeTaskId(rawId), "rig task lookup <id>");
+      const resolved = (deps.taskLookup ?? taskLookup)(context.projectRoot, lookupId);
+      printText(context, resolved);
+      return { ok: true, group: "task", command, details: { id: lookupId, resolved } };
+    }
+    case "record": {
+      const taskResult = takeOption(rest, "--task");
+      const [type, ...textParts] = taskResult.rest;
+      const text = textParts.join(" ").trim();
+      if (type !== "decision" && type !== "failure")
+        throw new CliError("rig task record requires a type: decision|failure.", 1, { hint: "rig task record <decision|failure> <text> [--task <id>]" });
+      if (!text)
+        throw new CliError("rig task record requires text.", 1, { hint: "rig task record <decision|failure> <text> [--task <id>]" });
+      const captured2 = await captureOutputForJson(context, () => taskRecord(context.projectRoot, type, text, normalizeTaskId(taskResult.value)));
+      return { ok: true, group: "task", command, details: { type, text, ...captured2.output !== null ? { output: captured2.output } : {} } };
+    }
+    default:
+      throw new CliError(`Unknown task command: ${command}`, 1, { hint: "Run `rig task --help`." });
+  }
+}
+export {
+  executeTask
+};

package/dist/src/commands/test.d.ts

@@ -0,0 +1,3 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+export declare function executeTest(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/commands/test.js

@@ -0,0 +1,46 @@
+// @bun
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/test.ts
+async function executeTest(context, args) {
+  const [command = "unit", ...rest] = args;
+  switch (command) {
+    case "unit":
+      requireNoExtraArgs(rest, "rig test unit");
+      await context.runCommand(["bun", "test", "tests/harness/", "--ignore", "tests/harness/e2e/**"]);
+      return { ok: true, group: "test", command };
+    case "e2e":
+      requireNoExtraArgs(rest, "rig test e2e");
+      await context.runCommand(["bun", "test", "tests/harness/e2e/"]);
+      return { ok: true, group: "test", command };
+    case "all":
+      requireNoExtraArgs(rest, "rig test all");
+      await context.runCommand(["bun", "test", "tests/harness/"]);
+      return { ok: true, group: "test", command };
+    default:
+      throw new CliError(`Unknown test command: ${command}`, 1, { hint: "Run `rig test --help` \u2014 commands are unit|e2e|all." });
+  }
+}
+export {
+  executeTest
+};

package/dist/src/commands/triage.d.ts

@@ -0,0 +1,11 @@
+import { type IssueAnalysisTriageRunResult, type RunIssueAnalysisTriageOptions } from "@rig/runtime/control-plane/github";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+import { type RunnerContext } from "../runner";
+type TriageCommandDeps = {
+    runTriage?: (options: RunIssueAnalysisTriageOptions) => Promise<IssueAnalysisTriageRunResult>;
+    spinner?: <T>(label: string, work: (update: (label: string) => void) => Promise<T>, options: {
+        outputMode: RunnerContext["outputMode"];
+    }) => Promise<T>;
+};
+export declare function executeTriage(context: RunnerContext, args: string[], deps?: TriageCommandDeps): Promise<CommandOutcome>;
+export {};