@geminix/gxpm 0.1.0

package/scripts/cleanup.ts

@@ -0,0 +1,142 @@
+import { mkdirSync, copyFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readArtifact } from "../core/artifacts";
+import { appendIssueEvent, getIssuePaths, readIssueState } from "../core/state";
+
+export function runCleanupLandCommand(argv: string[], issueId: string): void {
+  const root = process.cwd();
+  const execute = argv.includes("--execute");
+  const force = argv.includes("--force");
+
+  // 1. Read issue state and verify phase
+  const state = readIssueState({ root, issueId });
+  if (state.currentPhase !== "land") {
+    throw new Error("cleanup only applies to landed issues");
+  }
+
+  // 2. Resolve cleanup target from dispatch-handoff artifact
+  let handoffPayload: Record<string, unknown>;
+  try {
+    const artifact = readArtifact({ root, issueId, type: "dispatch-handoff" });
+    handoffPayload = artifact.payload as Record<string, unknown>;
+  } catch {
+    throw new Error("cleanup requires dispatch-handoff artifact");
+  }
+
+  // Prefer newer fields (worktree / branch), then current handoff workspace,
+  // and finally legacy worktreePath / targetBranch.
+  const worktree = (handoffPayload.worktree ?? handoffPayload.workspace ?? handoffPayload.worktreePath) as
+    | string
+    | undefined;
+  const branch = (handoffPayload.branch ?? handoffPayload.targetBranch) as string | undefined;
+
+  if (!worktree) {
+    throw new Error(
+      "cleanup requires one of dispatch-handoff.payload.worktree, dispatch-handoff.payload.workspace, or dispatch-handoff.payload.worktreePath",
+    );
+  }
+  if (!branch) {
+    throw new Error("cleanup requires dispatch-handoff.payload.branch");
+  }
+
+  // 3. Reject dangerous targets
+  const resolvedWorktree = resolve(worktree);
+  const resolvedRoot = resolve(root);
+  if (resolvedWorktree === resolvedRoot || branch === "main") {
+    throw new Error("refusing to clean main worktree/branch");
+  }
+
+  // 4. Dry-run (default)
+  if (!execute) {
+    console.log(`WOULD REMOVE worktree: ${worktree}`);
+    console.log(`WOULD DELETE branch: ${branch}`);
+    return;
+  }
+
+  // 5. Execute mode: assert clean worktree
+  const statusResult = Bun.spawnSync({
+    cmd: ["git", "status", "--short"],
+    cwd: worktree,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (statusResult.exitCode !== 0) {
+    throw new Error(`worktree dirty, refusing to remove; commit or stash first`);
+  }
+  const statusOutput = statusResult.stdout.toString().trim();
+  if (statusOutput.length > 0) {
+    throw new Error(`worktree dirty, refusing to remove; commit or stash first`);
+  }
+
+  // 6. Assert current cwd is not inside target worktree
+  const cwdResolved = resolve(process.cwd());
+  if (cwdResolved === resolvedWorktree || cwdResolved.startsWith(resolvedWorktree + "/")) {
+    throw new Error("currently inside target worktree; cd out first");
+  }
+
+  // 7. Remove worktree
+  const removeResult = Bun.spawnSync({
+    cmd: ["git", "worktree", "remove", worktree],
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (removeResult.exitCode !== 0) {
+    throw new Error(`git worktree remove failed: ${removeResult.stderr.toString().trim()}`);
+  }
+
+  // 8. Delete branch
+  const branchFlag = force ? "-D" : "-d";
+  const branchResult = Bun.spawnSync({
+    cmd: ["git", "branch", branchFlag, branch],
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (branchResult.exitCode !== 0) {
+    const stderr = branchResult.stderr.toString().trim();
+    if (!force) {
+      throw new Error(`${stderr}\nrerun with --force to delete unmerged branch`);
+    }
+    throw new Error(`git branch -D failed: ${stderr}`);
+  }
+
+  // 9. Append cleanup.executed event on success only
+  const paths = getIssuePaths(root, issueId);
+  appendIssueEvent({
+    issueDir: paths.issueDir,
+    event: {
+      schemaVersion: 1,
+      type: "cleanup.executed",
+      issueId,
+      timestamp: new Date().toISOString(),
+      payload: { worktree, branch, forced: force, dryRun: false },
+    },
+  });
+
+  // 10. Archive issue directory to .gxpm/archive/
+  const archiveDir = join(root, ".gxpm", "archive", `${new Date().toISOString().split("T")[0]}-${issueId}`);
+  try {
+    copyDirRecursive(paths.issueDir, archiveDir);
+    console.log(`archived issue: ${archiveDir}`);
+  } catch (err) {
+    console.warn(`archive failed (non-blocking): ${err instanceof Error ? err.message : String(err)}`);
+  }
+
+  console.log(`removed worktree: ${worktree}`);
+  console.log(`deleted branch: ${branch}`);
+}
+
+function copyDirRecursive(src: string, dest: string): void {
+  mkdirSync(dest, { recursive: true });
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}

package/scripts/commands/artifact.ts

@@ -0,0 +1,115 @@
+import { mkdtempSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { hasArtifact, listArtifacts, readArtifact, writeArtifact } from "../../core/artifacts";
+import { probeArtifactPayloadCommands } from "../../core/command-probe";
+import { readJsonPayloadFromArgs } from "./helpers";
+import { validateArtifact, formatValidationResult } from "../../core/artifact-validator";
+
+export function runArtifactCommand(argv: string[], subcommand: string | undefined, issueId: string | undefined, type: string | undefined) {
+  if (subcommand === "list") {
+    if (!issueId) throw new Error("Usage: gxpm artifact list <issue-id>");
+    const artifacts = listArtifacts({ issueId });
+    if (artifacts.length === 0) {
+      console.log("no artifacts");
+      return;
+    }
+    for (const artifact of artifacts) {
+      console.log(`${artifact.type}\t${artifact.path}\t${artifact.writtenAt}`);
+    }
+    return;
+  }
+
+  if (subcommand === "read") {
+    if (!issueId || !type) throw new Error("Usage: gxpm artifact read <issue-id> <type>");
+    console.log(JSON.stringify(readArtifact({ issueId, type }), null, 2));
+    return;
+  }
+
+  if (subcommand === "write") {
+    if (!issueId || !type) {
+      throw new Error("Usage: gxpm artifact write <issue-id> <type> [--probe-cli] --json <json> | --from <file> | --stdin");
+    }
+    runArtifactWrite(argv, issueId, type);
+    return;
+  }
+
+  if (subcommand === "edit") {
+    if (!issueId || !type) throw new Error("Usage: gxpm artifact edit <issue-id> <type>");
+    runArtifactEdit(issueId, type);
+    return;
+  }
+
+  throw new Error(`Unknown command: ${["artifact", subcommand].filter(Boolean).join(" ")}`);
+}
+
+function runArtifactEdit(issueId: string, type: string) {
+  const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+
+  let initial = "{}\n";
+  if (hasArtifact({ issueId, type })) {
+    const stored = readArtifact({ issueId, type });
+    initial = `${JSON.stringify(stored.payload, null, 2)}\n`;
+  }
+
+  const tmpFile = join(
+    mkdtempSync(join(tmpdir(), `gxpm-edit-${issueId}-${type}-`)),
+    `${type}.json`,
+  );
+  writeFileSync(tmpFile, initial);
+
+  const editorResult = Bun.spawnSync({
+    cmd: [editor, tmpFile],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  if (editorResult.exitCode !== 0) {
+    console.error(`editor "${editor}" exited with code ${editorResult.exitCode}; tempfile preserved at ${tmpFile}`);
+    process.exit(1);
+  }
+
+  const after = readFileSync(tmpFile, "utf8");
+  let payload: unknown;
+  try {
+    payload = JSON.parse(after);
+  } catch (error) {
+    console.error(
+      `gxpm artifact edit: invalid JSON saved by editor — ${error instanceof Error ? error.message : String(error)}`,
+    );
+    console.error(`Your edit is preserved at: ${tmpFile}`);
+    process.exit(1);
+  }
+
+  writeArtifact({ issueId, type, payload });
+  // best-effort cleanup
+  try {
+    unlinkSync(tmpFile);
+  } catch {}
+  console.log(`updated ${type} for ${issueId}`);
+}
+
+function runArtifactWrite(argv: string[], issueId: string, type: string) {
+  const payload = readJsonPayloadFromArgs(argv, "gxpm artifact write");
+  if (argv.includes("--probe-cli")) {
+    const findings = probeArtifactPayloadCommands(payload);
+    if (findings.length > 0) {
+      const detail = findings.map((finding) => `${finding.command} (${finding.reason})`).join("\n");
+      throw new Error(`gxpm artifact write: invalid command references\n${detail}`);
+    }
+  }
+  const result = validateArtifact(type, asPayloadRecord(payload));
+  if (!result.valid) {
+    throw new Error(`gxpm artifact write: ${formatValidationResult(result)}`);
+  }
+  const record = writeArtifact({ issueId, type, payload });
+  console.log(`wrote ${record.type} for ${issueId} at ${record.path}`);
+}
+
+function asPayloadRecord(payload: unknown): Record<string, unknown> {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return {};
+  }
+  return payload as Record<string, unknown>;
+}

package/scripts/commands/autopilot.ts

@@ -0,0 +1,143 @@
+import { createIssueState } from "../../core/state";
+import { getNextAvailableIssueId } from "../../core/issues";
+import {
+  assertAutopilotProfile,
+  formatAutopilotGrantContext,
+  listActiveAutopilotGrants,
+  readAutopilotGrant,
+  startAutopilotGrant,
+  stopAutopilotGrant,
+  type AutopilotGrant,
+  type AutopilotProfile,
+} from "../../core/autopilot";
+import { optionRequiredValue, optionValue, parsePositiveIntegerOption } from "./helpers";
+
+const USAGE = [
+  "Usage:",
+  "  gxpm autopilot start <issue-id>|--auto-id [--profile full-delivery] [--prompt <text>] [--ttl-minutes N] [--json]",
+  "  gxpm autopilot status <issue-id> [--json]",
+  "  gxpm autopilot list [--json]",
+  "  gxpm autopilot stop <issue-id> [--reason <text>] [--json]",
+].join("\n");
+
+export function runAutopilotCommand(argv: string[], subcommand: string | undefined, issueId: string | undefined) {
+  if (subcommand === "start") {
+    runAutopilotStart(argv, issueId);
+    return;
+  }
+
+  if (subcommand === "status") {
+    runAutopilotStatus(argv, issueId);
+    return;
+  }
+
+  if (subcommand === "list") {
+    runAutopilotList(argv);
+    return;
+  }
+
+  if (subcommand === "stop") {
+    runAutopilotStop(argv, issueId);
+    return;
+  }
+
+  throw new Error(USAGE);
+}
+
+function runAutopilotStart(argv: string[], issueId: string | undefined) {
+  const json = argv.includes("--json");
+  const autoId = argv.includes("--auto-id");
+  if (autoId && issueId && !issueId.startsWith("-")) {
+    throw new Error("Usage: choose either `gxpm autopilot start <issue-id>` or `gxpm autopilot start --auto-id`");
+  }
+  const targetIssueId = autoId ? getNextAvailableIssueId() : issueId;
+  if (!targetIssueId || targetIssueId.startsWith("-")) {
+    throw new Error(USAGE);
+  }
+
+  const profile = parseProfile(argv);
+  const ttlMinutes = parsePositiveIntegerOption(argv, "--ttl-minutes");
+  const prompt = optionValue(argv, "--prompt") ?? undefined;
+  let createdIssue = false;
+  if (autoId) {
+    createIssueState({ issueId: targetIssueId });
+    createdIssue = true;
+  }
+
+  const grant = startAutopilotGrant({
+    issueId: targetIssueId,
+    profile,
+    prompt,
+    ttlMinutes,
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ issueId: targetIssueId, createdIssue, grant }, null, 2));
+    return;
+  }
+
+  console.log(`autopilot grant active for ${targetIssueId}`);
+  if (createdIssue) console.log("createdIssue: true");
+  printGrantSummary(grant);
+  console.log("");
+  console.log(`Next: gxpm issue status ${targetIssueId} && gxpm issue next ${targetIssueId}`);
+}
+
+function runAutopilotStatus(argv: string[], issueId: string | undefined) {
+  if (!issueId || issueId.startsWith("-")) {
+    throw new Error(USAGE);
+  }
+  const grant = readAutopilotGrant({ issueId });
+  if (!grant) {
+    throw new Error(`Autopilot grant not found for ${issueId}`);
+  }
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(grant, null, 2));
+    return;
+  }
+  printGrantSummary(grant);
+}
+
+function runAutopilotList(argv: string[]) {
+  const active = listActiveAutopilotGrants();
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(active, null, 2));
+    return;
+  }
+  if (active.length === 0) {
+    console.log("no active autopilot grants");
+    return;
+  }
+  console.log(formatAutopilotGrantContext(active));
+}
+
+function runAutopilotStop(argv: string[], issueId: string | undefined) {
+  if (!issueId || issueId.startsWith("-")) {
+    throw new Error(USAGE);
+  }
+  const reason = argv.includes("--reason") ? optionRequiredValue(argv, "--reason") : undefined;
+  const grant = stopAutopilotGrant({ issueId, reason });
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(grant, null, 2));
+    return;
+  }
+  console.log(`autopilot grant stopped for ${issueId}`);
+  printGrantSummary(grant);
+}
+
+function parseProfile(argv: string[]): AutopilotProfile {
+  const raw = optionValue(argv, "--profile") ?? "full-delivery";
+  assertAutopilotProfile(raw);
+  return raw;
+}
+
+function printGrantSummary(grant: AutopilotGrant) {
+  console.log(`profile: ${grant.profile}`);
+  console.log(`status: ${grant.status}`);
+  console.log(`runId: ${grant.runId}`);
+  console.log(`startedAt: ${grant.startedAt}`);
+  if (grant.expiresAt) console.log(`expiresAt: ${grant.expiresAt}`);
+  if (grant.stopReason) console.log(`stopReason: ${grant.stopReason}`);
+  console.log(`allowedActions: ${grant.allowedActions.join(", ")}`);
+  console.log(`hardStops: ${grant.hardStops.join(", ")}`);
+}

package/scripts/commands/capability.ts

@@ -0,0 +1,57 @@
+import { listCapabilities, requireCapability } from "../../core/capabilities";
+
+export function runCapabilityCommand(
+  argv: string[],
+  subcommand: string | undefined,
+  capabilityId: string | undefined,
+) {
+  if (subcommand === "list") {
+    const capabilities = listCapabilities();
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(capabilities, null, 2));
+      return;
+    }
+    const idWidth = Math.max("ID".length, ...capabilities.map((capability) => capability.id.length));
+    const runtimeWidth = Math.max(
+      "RUNTIME".length,
+      ...capabilities.map((capability) => capability.runtime.length),
+    );
+    console.log(`${"ID".padEnd(idWidth)}  ${"RUNTIME".padEnd(runtimeWidth)}  STATUS   MUTATION`);
+    for (const capability of capabilities) {
+      console.log(
+        `${capability.id.padEnd(idWidth)}  ${capability.runtime.padEnd(runtimeWidth)}  ${capability.status.padEnd(7)}  ${capability.mutationPolicy.scope}`,
+      );
+    }
+    return;
+  }
+
+  if (subcommand === "show") {
+    if (!capabilityId || capabilityId.startsWith("--")) {
+      throw new Error("Usage: gxpm capability show <capability-id> [--json]");
+    }
+    const capability = requireCapability(capabilityId);
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(capability, null, 2));
+      return;
+    }
+    console.log(`id: ${capability.id}`);
+    console.log(`title: ${capability.title}`);
+    console.log(`runtime: ${capability.runtime}`);
+    console.log(`status: ${capability.status}`);
+    console.log(`mutation: ${capability.mutationPolicy.scope}`);
+    console.log(`input: ${capability.inputContract}`);
+    console.log(`output: ${capability.outputContract.description}`);
+    console.log(`idempotency: ${capability.idempotency}`);
+    console.log("failureModes:");
+    for (const mode of capability.failureModes) {
+      console.log(`- ${mode}`);
+    }
+    console.log("commands:");
+    for (const command of capability.commands) {
+      console.log(`- ${command}`);
+    }
+    return;
+  }
+
+  throw new Error("Usage: gxpm capability list [--json]\n       gxpm capability show <capability-id> [--json]");
+}

package/scripts/commands/config.ts

@@ -0,0 +1,69 @@
+import { getConfigValue, getResolvedConfigValue, listConfigEntries, resolveWorktreePolicy, setConfigValue } from "../../core/config";
+import { readSyncState, resolveSyncProvider } from "../../core/issue-sync";
+
+export function runWorktreePolicyCommand(argv: string[], subcommand: string | undefined) {
+  if (subcommand !== "policy") {
+    throw new Error(`Unknown command: ${["worktree", subcommand].filter(Boolean).join(" ")}`);
+  }
+  const policy = resolveWorktreePolicy();
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(policy, null, 2));
+    return;
+  }
+  console.log(`worktree.enforcement: ${policy.enforcement}`);
+  console.log(`worktree.default:     ${policy.default}`);
+  console.log(`source:               ${policy.source}`);
+}
+
+export function runConfigCommand(
+  argv: string[],
+  subcommand: string | undefined,
+  thirdArg: string | undefined,
+  fourthArg: string | undefined,
+) {
+  if (subcommand === "get") {
+    if (!thirdArg) throw new Error("Usage: gxpm config get <key>");
+    const result = getResolvedConfigValue({ key: thirdArg });
+    if (argv.includes("--raw")) {
+      console.log(String(result.value));
+    } else {
+      console.log(`${thirdArg}: ${JSON.stringify(result.value)}`);
+      console.log(`source:  ${result.source}`);
+    }
+    return;
+  }
+
+  if (subcommand === "set") {
+    if (!thirdArg || fourthArg === undefined) {
+      throw new Error("Usage: gxpm config set <key> <value> [--global]");
+    }
+    const scope = argv.includes("--global") ? "global" : "repo";
+    const path = setConfigValue({
+      scope,
+      key: thirdArg,
+      value: parseConfigValueLiteral(fourthArg),
+    });
+    console.log(`set ${thirdArg} = ${fourthArg} (${scope}); wrote ${path}`);
+    return;
+  }
+
+  if (subcommand === "list" || !subcommand) {
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(listConfigEntries(), null, 2));
+      return;
+    }
+    for (const entry of listConfigEntries()) {
+      console.log(`${entry.key}: ${JSON.stringify(entry.value)} (${entry.source})`);
+    }
+    return;
+  }
+
+  throw new Error(`Unknown config subcommand: ${subcommand}`);
+}
+
+function parseConfigValueLiteral(raw: string): unknown {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^-?\d+$/.test(raw)) return Number(raw);
+  return raw;
+}

package/scripts/commands/dag.ts

@@ -0,0 +1,126 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseWorkflow } from "../../core/dag-loader";
+import { executeDag } from "../../core/dag-executor";
+import type { DagNode, NodeOutput } from "../../core/dag-schemas";
+
+export function runDagCommand(argv: string[]) {
+  const subcommand = argv[1];
+  const filePath = argv[2];
+
+  if (!subcommand) {
+    console.log("Usage: gxpm dag <validate|run> <workflow-file>");
+    return;
+  }
+
+  if (subcommand === "validate") {
+    if (!filePath) {
+      throw new Error("Usage: gxpm dag validate <workflow-file>");
+    }
+    const fullPath = resolve(filePath);
+    const content = readFileSync(fullPath, "utf8");
+    const raw = JSON.parse(content);
+    const result = parseWorkflow(raw, filePath);
+
+    if (result.error) {
+      console.error(`Validation failed: ${result.error.error}`);
+      process.exit(1);
+    } else {
+      console.log(`Workflow '${result.workflow!.name}' is valid.`);
+      console.log(`Nodes: ${result.workflow!.nodes.length}`);
+      for (const node of result.workflow!.nodes) {
+        const deps = node.depends_on?.length ? ` (depends_on: ${node.depends_on.join(", ")})` : "";
+        console.log(`  - ${node.id}: ${node.type}${deps}`);
+      }
+    }
+    return;
+  }
+
+  if (subcommand === "run") {
+    if (!filePath) {
+      throw new Error("Usage: gxpm dag run <workflow-file>");
+    }
+    const fullPath = resolve(filePath);
+    const content = readFileSync(fullPath, "utf8");
+    const raw = JSON.parse(content);
+    const result = parseWorkflow(raw, filePath);
+
+    if (result.error) {
+      throw new Error(`Validation failed: ${result.error.error}`);
+    }
+
+    const workflow = result.workflow!;
+    const startTime = Date.now();
+
+    // Simple echo executor for CLI demo
+    const executor = async (node: DagNode): Promise<NodeOutput> => {
+      console.log(`[${node.id}] Running ${node.type} node...`);
+      if ("bash" in node && node.bash) {
+        const proc = Bun.spawn(["bash", "-c", node.bash], {
+          cwd: process.cwd(),
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = proc.exitCode ?? 1;
+        if (exitCode !== 0) {
+          return { state: "failed", output: stdout, error: stderr || `exit code ${exitCode}` };
+        }
+        return { state: "completed", output: stdout.trim() };
+      }
+      if ("script" in node && node.script) {
+        const proc = Bun.spawn(["bash", node.script], {
+          cwd: process.cwd(),
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = proc.exitCode ?? 1;
+        if (exitCode !== 0) {
+          return { state: "failed", output: stdout, error: stderr || `exit code ${exitCode}` };
+        }
+        return { state: "completed", output: stdout.trim() };
+      }
+      if ("prompt" in node && node.prompt) {
+        return { state: "completed", output: node.prompt };
+      }
+      if ("phase" in node && node.phase) {
+        return { state: "completed", output: node.phase };
+      }
+      if (node.type === "approval") {
+        return { state: "completed", output: "approved" };
+      }
+      if (node.type === "cancel") {
+        return { state: "completed", output: "cancelled" };
+      }
+      return { state: "completed", output: "" };
+    };
+
+    executeDag(workflow.nodes, executor, {
+      workflowName: workflow.name,
+      onNodeStart: (id) => console.log(`[${id}] START`),
+      onNodeComplete: (id, output) =>
+        console.log(`[${id}] ${output.state.toUpperCase()}${output.error ? `: ${output.error}` : ""}`),
+    })
+      .then((result) => {
+        const duration = Date.now() - startTime;
+        console.log(`\nWorkflow ${result.success ? "succeeded" : "failed"} in ${duration}ms`);
+        if (!result.success && result.error) {
+          console.error(`Error: ${result.error}`);
+        }
+        for (const [id, output] of result.nodeOutputs) {
+          console.log(`  ${id}: ${output.state}${output.output ? ` → ${output.output.slice(0, 80)}` : ""}`);
+        }
+        process.exit(result.success ? 0 : 1);
+      })
+      .catch((err) => {
+        console.error(`Execution error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      });
+    return;
+  }
+
+  throw new Error(`Unknown dag subcommand: ${subcommand}`);
+}