jules-orchestrator-kit 0.29.1 → 0.32.0

package/src/ops/ide-scaffold.mjs

@@ -0,0 +1,139 @@
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveRoot } from "../config.mjs";
+
+export class IdeScaffoldError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IdeScaffoldError";
+  }
+}
+
+/**
+ * Scaffolds IDE integration configuration files for Cursor, VS Code, and Claude Desktop.
+ * @param {string} target - 'cursor' | 'vscode' | 'claude' | 'all'
+ * @param {object} [options]
+ * @returns {object} Summary of scaffolded files
+ */
+export function scaffoldIdeConfig(target = "all", options = {}) {
+  const root = options.root || resolveRoot();
+  const validTargets = new Set(["cursor", "vscode", "claude", "all"]);
+
+  const normTarget = (target || "all").toLowerCase();
+  if (!validTargets.has(normTarget)) {
+    throw new IdeScaffoldError(`Invalid target '${target}'. Allowed targets: cursor, vscode, claude, all`);
+  }
+
+  const results = [];
+
+  // Target: Cursor (.cursor/mcp.json)
+  if (normTarget === "cursor" || normTarget === "all") {
+    const cursorDir = join(root, ".cursor");
+    try {
+      mkdirSync(cursorDir, { recursive: true });
+    } catch (_) {}
+
+    const cursorConfigPath = join(cursorDir, "mcp.json");
+    let existingConfig = {};
+    if (existsSync(cursorConfigPath)) {
+      try {
+        existingConfig = JSON.parse(readFileSync(cursorConfigPath, "utf-8"));
+      } catch (_) {}
+    }
+
+    const updatedCursorConfig = {
+      ...existingConfig,
+      mcpServers: {
+        ...(existingConfig.mcpServers || {}),
+        "jules-orchestrator-kit": {
+          command: "npx",
+          args: ["-y", "jules-orchestrator-kit@latest", "mcp"],
+        },
+      },
+    };
+
+    writeFileSync(cursorConfigPath, JSON.stringify(updatedCursorConfig, null, 2), "utf-8");
+    results.push({ target: "cursor", file: ".cursor/mcp.json", ok: true });
+  }
+
+  // Target: VS Code (.vscode/tasks.json)
+  if (normTarget === "vscode" || normTarget === "all") {
+    const vscodeDir = join(root, ".vscode");
+    try {
+      mkdirSync(vscodeDir, { recursive: true });
+    } catch (_) {}
+
+    const vscodeTasksPath = join(vscodeDir, "tasks.json");
+    let existingConfig = { version: "2.0.0", tasks: [] };
+    if (existsSync(vscodeTasksPath)) {
+      try {
+        existingConfig = JSON.parse(readFileSync(vscodeTasksPath, "utf-8"));
+      } catch (_) {}
+    }
+
+    const defaultTasks = [
+      {
+        label: "Jules: Run System Doctor",
+        type: "shell",
+        command: "npx agentctl doctor",
+        group: "test",
+        problemMatcher: [],
+      },
+      {
+        label: "Jules: Create Task Envelope",
+        type: "shell",
+        command: "npx agentctl task create",
+        group: "build",
+        problemMatcher: [],
+      },
+      {
+        label: "Jules: 1-Click Rollback Checkpoint",
+        type: "shell",
+        command: "npx agentctl rollback --latest",
+        group: "none",
+        problemMatcher: [],
+      },
+    ];
+
+    const currentTasks = existingConfig.tasks || [];
+    const updatedTasks = [...currentTasks];
+
+    for (const newTask of defaultTasks) {
+      if (!updatedTasks.some((t) => t.label === newTask.label)) {
+        updatedTasks.push(newTask);
+      }
+    }
+
+    const updatedVsCodeConfig = {
+      ...existingConfig,
+      version: existingConfig.version || "2.0.0",
+      tasks: updatedTasks,
+    };
+
+    writeFileSync(vscodeTasksPath, JSON.stringify(updatedVsCodeConfig, null, 2), "utf-8");
+    results.push({ target: "vscode", file: ".vscode/tasks.json", ok: true });
+  }
+
+  // Target: Claude Desktop (claude_desktop_config.json snippet helper)
+  if (normTarget === "claude" || normTarget === "all") {
+    const agentDir = join(root, ".agent");
+    try {
+      mkdirSync(agentDir, { recursive: true });
+    } catch (_) {}
+
+    const snippetPath = join(agentDir, "claude_desktop_config.snippet.json");
+    const claudeSnippet = {
+      mcpServers: {
+        "jules-orchestrator-kit": {
+          command: "npx",
+          args: ["-y", "jules-orchestrator-kit@latest", "mcp"],
+        },
+      },
+    };
+
+    writeFileSync(snippetPath, JSON.stringify(claudeSnippet, null, 2), "utf-8");
+    results.push({ target: "claude", file: ".agent/claude_desktop_config.snippet.json", ok: true });
+  }
+
+  return { ok: true, target: normTarget, results };
+}

package/src/ops/receipts.mjs

@@ -0,0 +1,171 @@
+import {
+  readFileSync,
+  mkdirSync,
+  existsSync,
+  openSync,
+  writeSync,
+  fsyncSync,
+  closeSync,
+  renameSync,
+  unlinkSync,
+} from "node:fs";
+import { join, resolve, relative, isAbsolute } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { redactSecrets } from "../security.mjs";
+
+/**
+ * @typedef {Object} OperationReceipt
+ * @property {"agentctl/operation-receipt-v1"} schema
+ * @property {string} receiptId
+ * @property {string} actionPlanId
+ * @property {string} kind
+ * @property {string} title
+ * @property {string} repository
+ * @property {string} appliedAt
+ * @property {"success" | "rolled-back" | "failed"} status
+ * @property {number} durationMs
+ * @property {Array<{ path: string, operation: string, hashBefore?: string, hashAfter?: string }>} mutationsApplied
+ * @property {Array<{ executable: string, args: string[], exitCode: number }>} effectsExecuted
+ * @property {string} receiptHash
+ */
+
+/**
+ * Compute SHA-256 hash of operation receipt metadata.
+ * @param {Omit<OperationReceipt, "receiptHash">} receipt
+ * @returns {string}
+ */
+export function computeReceiptHash(receipt) {
+  const payload = JSON.stringify({
+    schema: receipt.schema,
+    receiptId: receipt.receiptId,
+    actionPlanId: receipt.actionPlanId,
+    kind: receipt.kind,
+    title: receipt.title,
+    repository: receipt.repository,
+    status: receipt.status,
+    appliedAt: receipt.appliedAt,
+    durationMs: receipt.durationMs,
+    mutationsApplied: receipt.mutationsApplied,
+    effectsExecuted: receipt.effectsExecuted,
+  });
+  return "sha256:" + createHash("sha256").update(payload).digest("hex");
+}
+
+function redactReceiptValue(value) {
+  if (typeof value === "string") return redactSecrets(value);
+  if (Array.isArray(value)) return value.map(redactReceiptValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, redactReceiptValue(child)]));
+  }
+  return value;
+}
+
+function assertReceiptId(receiptId) {
+  if (typeof receiptId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(receiptId)) {
+    throw new Error("Invalid operation receipt id");
+  }
+}
+
+function writeFileAtomically(filePath, content) {
+  const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+  let fd;
+  try {
+    fd = openSync(tmpPath, "wx", 0o600);
+    writeSync(fd, content, "utf-8");
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(tmpPath, filePath);
+  } catch (err) {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch (_) {}
+    }
+    try { unlinkSync(tmpPath); } catch (_) {}
+    throw err;
+  }
+}
+
+/**
+ * Create and persist an OperationReceipt atomically.
+ * @param {string} root
+ * @param {Omit<OperationReceipt, "schema" | "receiptId" | "appliedAt" | "receiptHash"> & { receiptId?: string }} data
+ * @returns {OperationReceipt}
+ */
+export function createOperationReceipt(root, data) {
+  const receiptsDir = join(root, ".agent", "receipts");
+  if (!existsSync(receiptsDir)) {
+    mkdirSync(receiptsDir, { recursive: true });
+  }
+
+  const receiptId = data.receiptId || `REC-${Date.now()}-${randomUUID().slice(0, 8)}`;
+  assertReceiptId(receiptId);
+  const appliedAt = new Date().toISOString();
+
+  const baseReceipt = redactReceiptValue({
+    schema: /** @type {const} */ ("agentctl/operation-receipt-v1"),
+    receiptId,
+    actionPlanId: data.actionPlanId,
+    kind: data.kind,
+    title: data.title,
+    repository: data.repository || "local",
+    appliedAt,
+    status: data.status,
+    durationMs: data.durationMs || 0,
+    mutationsApplied: data.mutationsApplied || [],
+    effectsExecuted: data.effectsExecuted || [],
+  });
+
+  const receiptHash = computeReceiptHash(baseReceipt);
+  /** @type {OperationReceipt} */
+  const fullReceipt = {
+    ...baseReceipt,
+    receiptHash,
+  };
+
+  const targetPath = join(receiptsDir, `${receiptId}.json`);
+  writeFileAtomically(targetPath, JSON.stringify(fullReceipt, null, 2));
+
+  return fullReceipt;
+}
+
+/**
+ * Load and validate an OperationReceipt from disk.
+ * @param {string} root
+ * @param {string} receiptIdOrPath
+ * @returns {OperationReceipt}
+ */
+export function loadOperationReceipt(root, receiptIdOrPath) {
+  const receiptsDir = resolve(root, ".agent", "receipts");
+  let targetPath;
+  if (typeof receiptIdOrPath !== "string" || !receiptIdOrPath) {
+    throw new Error("Operation receipt id or path is required");
+  }
+
+  if (!receiptIdOrPath.endsWith(".json")) {
+    assertReceiptId(receiptIdOrPath);
+    targetPath = join(receiptsDir, `${receiptIdOrPath}.json`);
+  } else {
+    targetPath = isAbsolute(receiptIdOrPath) ? resolve(receiptIdOrPath) : resolve(root, receiptIdOrPath);
+    const rel = relative(receiptsDir, targetPath);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      throw new Error("Operation receipt path escapes the receipts directory");
+    }
+  }
+
+  if (!existsSync(targetPath)) {
+    throw new Error(`Operation receipt not found: ${targetPath}`);
+  }
+
+  const content = readFileSync(targetPath, "utf-8");
+  /** @type {OperationReceipt} */
+  const receipt = JSON.parse(content);
+
+  if (receipt.schema !== "agentctl/operation-receipt-v1") {
+    throw new Error(`Invalid receipt schema version: ${receipt.schema}`);
+  }
+  if (receipt.receiptHash !== computeReceiptHash(receipt)) {
+    throw new Error(`Invalid operation receipt hash: ${targetPath}`);
+  }
+
+  return receipt;
+}

package/src/ops/swarm-actions.mjs

@@ -0,0 +1,156 @@
+import { createHash, randomUUID } from "node:crypto";
+
+/**
+ * @typedef {import("../ux/capabilities.mjs").ActionPlan} ActionPlan
+ * @typedef {import("../ux/swarm-model.mjs").SwarmSlot} SwarmSlot
+ */
+
+/**
+ * Plan swarm concurrency action into an immutable ActionPlan.
+ * @param {{ slots: SwarmSlot[], revision: string }} snapshot
+ * @param {Object} intent
+ * @param {string} intent.kind
+ * @param {string} [intent.slotId]
+ * @param {string} [intent.taskId]
+ * @param {Record<string, any>} [intent.answers]
+ * @returns {Promise<ActionPlan>}
+ */
+export async function planSwarmAction(snapshot, intent) {
+  const planId = `PLAN-SWARM-${Date.now()}-${randomUUID().slice(0, 8)}`;
+
+  if (intent.kind === "pause-scheduler" || intent.kind === "resume-scheduler") {
+    const isPause = intent.kind === "pause-scheduler";
+    const schedulerRelPath = ".agent/state/swarm/scheduler.json";
+    const newContent = JSON.stringify(
+      {
+        schema: "agentctl/swarm-scheduler-v1",
+        paused: isPause,
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    );
+
+    return {
+      schema: "agentctl/action-plan-v1",
+      id: planId,
+      kind: intent.kind,
+      title: `${isPause ? "Pause" : "Resume"} Swarm Scheduler`,
+      summary: `${isPause ? "Halt dispatching new tasks to swarm slots" : "Resume task dispatching to available slots"}`,
+      risk: "moderate",
+      repository: "local",
+      createdAt: new Date().toISOString(),
+      preconditions: [],
+      fileMutations: [
+        {
+          operation: "replace",
+          path: schedulerRelPath,
+          newContent,
+        },
+      ],
+      commandEffects: [],
+      stateTransitions: [],
+      preview: {
+        unifiedDiff: `--- a/${schedulerRelPath}\n+++ b/${schedulerRelPath}\n@@ -paused @@\n- paused: ${!isPause}\n+ paused: ${isPause}\n`,
+        warnings: isPause ? ["Running tasks will complete, but no new tasks will be scheduled."] : [],
+        estimatedImpact: [`Swarm scheduler state set to ${isPause ? "PAUSED" : "RUNNING"}`],
+      },
+      confirmation: {
+        mode: "keypress",
+        prompt: `Confirm ${isPause ? "pause" : "resume"} of swarm scheduler?`,
+      },
+      planHash: "sha256:" + createHash("sha256").update(planId).digest("hex"),
+    };
+  }
+
+  if (intent.kind === "cancel-slot-task") {
+    const slotId = intent.slotId;
+    const slot = (snapshot.slots || []).find((s) => s.id === slotId || s.taskId === intent.taskId);
+    if (!slot) {
+      throw new Error(`Target slot ${slotId || intent.taskId} not found.`);
+    }
+
+    const slotRelPath = `.agent/state/swarm/${slot.id}.json`;
+    const newContent = JSON.stringify(
+      {
+        id: slot.id,
+        state: "draining",
+        taskId: slot.taskId,
+        cancelledAt: new Date().toISOString(),
+      },
+      null,
+      2
+    );
+
+    return {
+      schema: "agentctl/action-plan-v1",
+      id: planId,
+      kind: "swarm.cancel-slot-task",
+      title: `Cancel active slot task ${slot.taskId || slot.id}`,
+      summary: `Send cancellation signal to slot ${slot.id} (Task ${slot.taskId || "N/A"})`,
+      risk: "high",
+      repository: "local",
+      createdAt: new Date().toISOString(),
+      preconditions: [],
+      fileMutations: [
+        {
+          operation: "replace",
+          path: slotRelPath,
+          newContent,
+        },
+      ],
+      commandEffects: [],
+      stateTransitions: [{ taskId: slot.taskId, from: slot.state, to: "cancelled" }],
+      preview: {
+        unifiedDiff: `--- a/${slotRelPath}\n+++ b/${slotRelPath}\n@@ -state @@\n- state: ${slot.state}\n+ state: draining\n`,
+        warnings: ["Cancelling a running worker process will terminate its active attempt."],
+        estimatedImpact: [`Cancels execution in slot ${slot.id}`],
+      },
+      confirmation: {
+        mode: "typed-task-id",
+        prompt: `Type '${slot.taskId || slot.id}' to confirm cancellation:`,
+        expected: slot.taskId || slot.id,
+      },
+      planHash: "sha256:" + createHash("sha256").update(planId).digest("hex"),
+    };
+  }
+
+  if (intent.kind === "prune-stale-slots") {
+    const staleSlots = (snapshot.slots || []).filter((s) => s.state === "stale");
+    if (staleSlots.length === 0) {
+      throw new Error("No stale slots found to prune.");
+    }
+
+    const fileMutations = staleSlots.map((s) => ({
+      operation: /** @type {const} */ ("delete"),
+      path: `.agent/state/swarm/${s.id}.json`,
+    }));
+
+    return {
+      schema: "agentctl/action-plan-v1",
+      id: planId,
+      kind: "swarm.prune-stale-slots",
+      title: `Prune ${staleSlots.length} stale swarm slot(s)`,
+      summary: `Remove stale slot state files for dead worker process PIDs`,
+      risk: "low",
+      repository: "local",
+      createdAt: new Date().toISOString(),
+      preconditions: [],
+      fileMutations,
+      commandEffects: [],
+      stateTransitions: [],
+      preview: {
+        unifiedDiff: staleSlots.map((s) => `--- a/.agent/state/swarm/${s.id}.json\n+++ /dev/null\n`).join("\n"),
+        warnings: [],
+        estimatedImpact: [`Prunes ${staleSlots.length} stale slot file(s)`],
+      },
+      confirmation: {
+        mode: "keypress",
+        prompt: `Prune ${staleSlots.length} stale slot(s)?`,
+      },
+      planHash: "sha256:" + createHash("sha256").update(planId).digest("hex"),
+    };
+  }
+
+  throw new Error(`Unsupported swarm action intent: ${intent.kind}`);
+}

package/src/ops/task-actions.mjs

@@ -0,0 +1,214 @@
+import { createHash, randomUUID } from "node:crypto";
+import { redactSecrets } from "../security.mjs";
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
+function finalizePlan(plan) {
+  const { planHash: _oldHash, ...unsigned } = plan;
+  const planHash = "sha256:" + createHash("sha256").update(JSON.stringify(unsigned)).digest("hex");
+  return deepFreeze({ ...unsigned, planHash });
+}
+
+/**
+ * @typedef {import("../ux/capabilities.mjs").ActionPlan} ActionPlan
+ * @typedef {import("../ux/queue-model.mjs").QueueSnapshot} QueueSnapshot
+ */
+
+/**
+ * Plan task lifecycle action into an immutable ActionPlan.
+ * @param {QueueSnapshot} snapshot
+ * @param {Object} intent
+ * @param {string} intent.kind
+ * @param {string} intent.taskId
+ * @param {Record<string, any>} [intent.answers]
+ * @returns {Promise<ActionPlan>}
+ */
+export async function planTaskAction(snapshot, intent = {}) {
+  const taskId = typeof intent.taskId === "string" ? intent.taskId : "";
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(taskId)) {
+    throw new Error("Task id must be a safe queue identifier.");
+  }
+  const task = (snapshot?.tasks || []).find((t) => t.id === taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found in queue snapshot.`);
+  }
+
+  const root = snapshot.repository;
+  const planId = `PLAN-TASK-${Date.now()}-${randomUUID().slice(0, 8)}`;
+  const sidecarRelPath = `.agent/jules-queue/${taskId}.state.json`;
+
+  if (intent.kind === "retry") {
+    const allowedStates = ["failed", "deferred", "quarantined", "cancelled"];
+    if (!allowedStates.includes(task.state)) {
+      throw new Error(`Task ${taskId} in state '${task.state}' cannot be retried.`);
+    }
+
+    const nextAttempt = (Number.isFinite(task.attempt) ? task.attempt : 0) + 1;
+    const sidecarContent = JSON.stringify(
+      {
+        schema: "agentctl/task-state-v1",
+        taskId,
+        revision: (Number.isFinite(task.stateRevision) ? task.stateRevision : 0) + 1,
+        state: "pending",
+        attempt: nextAttempt,
+        maxAttempts: task.maxAttempts,
+        createdAt: task.createdAt,
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    );
+
+    return finalizePlan({
+      schema: "agentctl/action-plan-v1",
+      id: planId,
+      kind: "task.retry",
+      title: `Retry task ${taskId}`,
+      summary: `Reset state to pending and increment attempt count to ${nextAttempt}`,
+      risk: "moderate",
+      repository: root,
+      createdAt: new Date().toISOString(),
+      preconditions: [
+        {
+          kind: "file-hash",
+          target: sidecarRelPath,
+          expected: task.stateHash, // Checked prior state hash if sidecar exists
+        },
+      ],
+      fileMutations: [
+        {
+          operation: "replace",
+          path: sidecarRelPath,
+          newContent: sidecarContent,
+        },
+      ],
+      commandEffects: [],
+      stateTransitions: [{ taskId, from: task.state, to: "pending" }],
+      preview: {
+        unifiedDiff: `--- a/${sidecarRelPath}\n+++ b/${sidecarRelPath}\n@@ -state @@\n- state: ${task.state}\n+ state: pending\n- attempt: ${task.attempt}\n+ attempt: ${nextAttempt}\n`,
+        warnings: [],
+        estimatedImpact: [`Resets ${taskId} to pending state (Attempt ${nextAttempt})`],
+      },
+      confirmation: {
+        mode: "keypress",
+        prompt: `Confirm retry of ${taskId} (Attempt ${nextAttempt})?`,
+      },
+      planHash: "sha256:" + createHash("sha256").update(planId).digest("hex"),
+    });
+  }
+
+  if (intent.kind === "quarantine-override") {
+    if (task.state !== "quarantined") {
+      throw new Error(`Task ${taskId} is not in quarantined state.`);
+    }
+
+    const reason = redactSecrets(String(intent.answers?.reason || "").trim());
+    if (!reason) {
+      throw new Error("Quarantine override requires a non-empty reason.");
+    }
+
+    const sidecarContent = JSON.stringify(
+      {
+        schema: "agentctl/task-state-v1",
+        taskId,
+        revision: (Number.isFinite(task.stateRevision) ? task.stateRevision : 0) + 1,
+        state: "pending",
+        attempt: task.attempt,
+        maxAttempts: task.maxAttempts,
+        quarantineOverrideReason: reason,
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    );
+
+    return finalizePlan({
+      schema: "agentctl/action-plan-v1",
+      id: planId,
+      kind: "task.quarantine-override",
+      title: `Override quarantine for ${taskId}`,
+      summary: `Bypass quarantine with reason: "${reason}"`,
+      risk: "high",
+      repository: root,
+      createdAt: new Date().toISOString(),
+      preconditions: [
+        {
+          kind: "file-hash",
+          target: sidecarRelPath,
+          expected: task.stateHash,
+        },
+      ],
+      fileMutations: [
+        {
+          operation: "replace",
+          path: sidecarRelPath,
+          newContent: sidecarContent,
+        },
+      ],
+      commandEffects: [],
+      stateTransitions: [{ taskId, from: "quarantined", to: "pending" }],
+      preview: {
+        unifiedDiff: `--- a/${sidecarRelPath}\n+++ b/${sidecarRelPath}\n@@ -state @@\n- state: quarantined\n+ state: pending\n+ overrideReason: "${reason}"\n`,
+        warnings: ["Bypassing quarantine filter requires verified operator review."],
+        estimatedImpact: [`Re-enables ${taskId} for dispatch`],
+      },
+      confirmation: {
+        mode: "typed-task-id",
+        prompt: `Type '${taskId}' to confirm quarantine override:`,
+        expected: taskId,
+        requireReason: true,
+      },
+      planHash: "sha256:" + createHash("sha256").update(planId).digest("hex"),
+    });
+  }
+
+  if (intent.kind === "delete-task") {
+    if (task.state === "running" || task.state === "verifying") {
+      throw new Error(`Task ${taskId} is currently active (${task.state}) and cannot be deleted.`);
+    }
+
+    const trashRelPath = `.agent/jules-queue/.trash/${taskId}.md`;
+    return finalizePlan({
+      schema: "agentctl/action-plan-v1",
+      id: planId,
+      kind: "task.delete",
+      title: `Delete task ${taskId}`,
+      summary: `Move task file ${task.taskFile} to trash directory`,
+      risk: "moderate",
+      repository: root,
+      createdAt: new Date().toISOString(),
+      preconditions: [
+        {
+          kind: "file-hash",
+          target: task.taskFile,
+          expected: task.envelopeHash,
+        },
+      ],
+      fileMutations: [
+        {
+          operation: "move",
+          path: trashRelPath,
+          fromPath: task.taskFile,
+        },
+      ],
+      commandEffects: [],
+      stateTransitions: [{ taskId, from: task.state, to: "cancelled" }],
+      preview: {
+        unifiedDiff: `--- a/${task.taskFile}\n+++ /dev/null\n`,
+        warnings: [],
+        estimatedImpact: [`Moves ${taskId} to trash`],
+      },
+      confirmation: {
+        mode: "keypress",
+        prompt: `Delete task ${taskId}?`,
+      },
+      planHash: "sha256:" + createHash("sha256").update(planId).digest("hex"),
+    });
+  }
+
+  throw new Error(`Unsupported task action intent: ${intent.kind}`);
+}