@kal-elsam/kairo-runtime 0.15.0 → 0.17.0

package/src/global/control-plane/review-status.js

@@ -0,0 +1,115 @@
+/**
+ * Official Gentle review status v2/v3 only. Never read authority inventory.
+ */
+import { isAbsolute } from "node:path";
+import { SUPPORTED_CONTRACT } from "../observability/gentle-probe.js";
+
+export const REVIEW_STATUS_SCHEMAS = Object.freeze([
+  "gentle-ai.review-integration.status/v2",
+  "gentle-ai.review-integration.status/v3"
+]);
+
+const INVENTORY_SCHEMA = "gentle-ai.review-authority-status/v1";
+const UNSAFE_TOKEN = /[|;&$`\n\r]/;
+const PLACEHOLDER = /^<[^>]+>$/;
+
+export const GENTLE_224_BOOTSTRAP =
+  "gentle-ai review status --cwd <repo> --contract gentle-ai.review-integration/v2 --next-transition";
+export const GENTLE_230_BOOTSTRAP =
+  "gentle-ai review status --cwd <repo> --contract gentle-ai.review-integration/v2 --agent claude-code --next-transition";
+
+const failArgv = () => ({ ok: false, error: "gentle_incompatible", binary: null, argv: null });
+
+export function bootstrapCommandFromProbe(probe) {
+  return probe?.evidence?.find((row) => row?.kind === "bootstrap" && row.command)?.command ?? null;
+}
+
+export function argvFromBootstrap(command, { repo, binaryPath }) {
+  if (typeof command !== "string" || !command.trim() || UNSAFE_TOKEN.test(command)) return failArgv();
+  if (typeof binaryPath !== "string" || !isAbsolute(binaryPath)) return failArgv();
+  if (typeof repo !== "string" || !repo) return failArgv();
+  const tokens = command.trim().split(/\s+/);
+  if (tokens[0] !== "gentle-ai") return failArgv();
+  const args = [];
+  const rest = tokens.slice(1);
+  for (let i = 0; i < rest.length; i += 1) {
+    const tok = rest[i];
+    if (UNSAFE_TOKEN.test(tok)) return failArgv();
+    if (tok === "--cwd") {
+      const next = rest[i + 1];
+      const needsRepo = next === "<repo>" || next == null || next.startsWith("-");
+      args.push("--cwd", needsRepo ? repo : next);
+      if (!needsRepo || next === "<repo>") i += 1;
+      continue;
+    }
+    if (PLACEHOLDER.test(tok)) return failArgv();
+    args.push(tok);
+  }
+  if (args[0] !== "review" || args[1] !== "status") return failArgv();
+  return { ok: true, error: null, binary: binaryPath, argv: args };
+}
+
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function publishedReceipt(receiptField) {
+  if (typeof receiptField === "string" && receiptField) return receiptField;
+  if (!isObject(receiptField)) return null;
+  if (typeof receiptField.id === "string" && receiptField.id) return receiptField.id;
+  if (typeof receiptField.digest === "string" && receiptField.digest) return receiptField.digest;
+  return null;
+}
+
+function publishedGate(payload) {
+  if (typeof payload.gate === "string" && payload.gate) return payload.gate;
+  if (isObject(payload.receipt) && typeof payload.receipt.gate === "string" && payload.receipt.gate) {
+    return payload.receipt.gate;
+  }
+  return null;
+}
+
+/**
+ * Fail closed unless schema/contract are official. Pass next_transition through unaltered.
+ */
+export function mapOfficialReviewStatus(payload) {
+  if (!isObject(payload)) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+  if (
+    payload.schema === INVENTORY_SCHEMA
+    || payload.authoritative === true
+    || Array.isArray(payload.entries)
+  ) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+  if (!REVIEW_STATUS_SCHEMAS.includes(payload.schema)) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+  if (payload.contract != null && payload.contract !== SUPPORTED_CONTRACT) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+
+  const nextTransition = Object.prototype.hasOwnProperty.call(payload, "next_transition")
+    ? payload.next_transition
+    : null;
+  const receipt = publishedReceipt(payload.receipt);
+  const gate = publishedGate(payload);
+  const applicability = typeof payload.applicability === "string" ? payload.applicability : null;
+  const action = typeof payload.action === "string" ? payload.action : null;
+  const receiptStatus = isObject(payload.receipt) && typeof payload.receipt.status === "string"
+    ? payload.receipt.status
+    : null;
+
+  const review = (receipt || gate || applicability || action)
+    ? {
+        lineageId: null,
+        state: applicability ?? action,
+        status: receiptStatus,
+        receipt,
+        gate
+      }
+    : null;
+
+  return { ok: true, error: null, review, nextTransition };
+}

package/src/global/control-plane/sdd-status.js

@@ -0,0 +1,49 @@
+/**
+ * Official `sdd-status --json` projection. No inferred phase/route/next.
+ */
+import { NO_ACTIVE_WORKFLOW, WORKFLOW_KIND } from "./constants.js";
+
+export const SDD_STATUS_SCHEMA_PREFIX = "gentle-ai.sdd-status";
+export const SDD_STATUS_ARGS = Object.freeze(["sdd-status", "--json"]);
+
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function mapOfficialSddStatus(payload) {
+  if (!isObject(payload)) {
+    return { ok: false, error: "gentle_incompatible", projection: null };
+  }
+  const schemaName = typeof payload.schemaName === "string"
+    ? payload.schemaName
+    : (typeof payload.schema === "string" ? payload.schema : null);
+  if (!schemaName || !schemaName.startsWith(SDD_STATUS_SCHEMA_PREFIX)) {
+    return { ok: false, error: "gentle_incompatible", projection: null };
+  }
+  const changeName = typeof payload.changeName === "string" && payload.changeName
+    ? payload.changeName
+    : null;
+  const nextRecommended = typeof payload.nextRecommended === "string" && payload.nextRecommended
+    ? payload.nextRecommended
+    : null;
+  return {
+    ok: true,
+    error: null,
+    projection: { schemaName, changeName, nextRecommended }
+  };
+}
+
+export function applySddProjection(workflow, projection) {
+  workflow.sdd = projection;
+  workflow.changeName = projection.changeName;
+  workflow.phase = null;
+  if (projection.changeName) {
+    workflow.kind = WORKFLOW_KIND.SDD;
+    workflow.active = true;
+    workflow.label = "SDD";
+  } else if (workflow.kind !== WORKFLOW_KIND.REVIEW) {
+    workflow.kind = WORKFLOW_KIND.NONE;
+    workflow.active = false;
+    workflow.label = NO_ACTIVE_WORKFLOW;
+  }
+}

package/src/global/control-plane/team.js

@@ -0,0 +1,63 @@
+/**
+ * Normalize declared fleets into honest control-plane team nodes.
+ * Live requires OpenCode active-agent evidence — never idle sessions.
+ */
+import { HONESTY } from "./constants.js";
+
+function honestyForNode(node, { platform, hasLiveActivity }) {
+  if (node?.opaque === true) return HONESTY.OPAQUE;
+  if (platform === "opencode" && hasLiveActivity) return HONESTY.LIVE;
+  return HONESTY.DECLARED;
+}
+
+export function normalizeTeam(connectionsReport = {}) {
+  const fleets = Array.isArray(connectionsReport.fleets) ? connectionsReport.fleets : [];
+  const activity = connectionsReport.activity ?? null;
+  const hasLiveActivity = Boolean(
+    activity
+    && (
+      (Array.isArray(activity.agents) && activity.agents.some((a) => a?.state === "active"))
+      || (typeof activity.activeCount === "number" && activity.activeCount > 0)
+      || activity.active === true
+    )
+  );
+
+  // Cursor configured agents are declared topology (not live); only opaque nodes stay opaque.
+  const platforms = fleets.map((fleet) => {
+    const platform = fleet?.platform ?? "unknown";
+    const orch = fleet?.orchestrator ?? null;
+    return {
+      platform,
+      honesty: honestyForNode(fleet, { platform, hasLiveActivity }),
+      source: fleet?.source ?? null,
+      orchestrator: orch
+        ? {
+            id: orch.id ?? null,
+            model: orch.modelShort ?? orch.model ?? null,
+            honesty: honestyForNode(orch, { platform, hasLiveActivity }),
+            role: orch.mode ?? "orchestrator"
+          }
+        : null,
+      agents: (Array.isArray(fleet?.minions) ? fleet.minions : []).map((m) => ({
+        id: m.id,
+        model: m.modelShort ?? m.model ?? null,
+        role: m.role ?? null,
+        honesty: m?.opaque === true && platform === "cursor"
+          ? HONESTY.DECLARED
+          : honestyForNode(m, { platform, hasLiveActivity: false })
+      }))
+    };
+  });
+
+  return {
+    platforms,
+    // Only surface activity when there is live evidence (active workers).
+    activity: hasLiveActivity ? activity : null,
+    fleetNote: connectionsReport.fleetNote
+      ?? "Declared config topology — not live token usage.",
+    orchestratorAuthority: connectionsReport.orchestratorAuthority ?? null,
+    connections: Array.isArray(connectionsReport.connections)
+      ? connectionsReport.connections
+      : []
+  };
+}

package/src/global/conversation/bootstrap-analyzer-adapters.js

@@ -0,0 +1,251 @@
+// A neutral contract for Bootstrap Analysis, so conversation/service.js's
+// runBootstrapAnalysis doesn't special-case providers inline — each real
+// provider gets its own adapter, and adding a new one (Cursor, a future
+// verified Claude boundary, etc.) means adding a factory here, not
+// branching inside runBootstrapAnalysis.
+//
+// Every adapter exposes:
+//   adapterId, modelId
+//   checkEligibility(): Promise<{ eligible, reason?, isolation, canaryTested }>
+//     isolation and canaryTested are separate axes — WHO enforces the
+//     boundary is not the same question as WHETHER it's been proven:
+//       isolation: "verified" | "restricted" | "unverified" — WHO enforces
+//         it. "verified" = an OS/kernel-enforced boundary (Codex's
+//         sandbox-exec, see codex-sandbox.js) that holds even if the CLI's
+//         own logic has a bug. "restricted" = an application-enforced
+//         boundary — the provider's own CLI/tool-permission logic (Claude's
+//         --restricted). "unverified" = no real boundary available.
+//       canaryTested: boolean — WHETHER that boundary has actually been
+//         empirically proven (a real canary read outside it was attempted
+//         and denied), as opposed to merely documented/assumed from
+//         --help text or a vendor's own claim. Both Codex's and Claude's
+//         adapters are canaryTested: true today; a provider could in
+//         principle be "restricted" but NOT canaryTested if its isolation
+//         claim were never independently checked — never conflate the two.
+//   analyze({ question, snapshotRoot, timeoutMs }): Promise<{status, answer, error}>
+//     same response shape intelligence/quick-ask.js's askProvider already
+//     returns, so callers don't need to branch on adapter type downstream.
+//
+// This module only wires the providers that already have a real
+// implementation (Codex, Claude). Requesting an adapterId with no real
+// implementation yet returns an honest "not implemented" ineligible
+// adapter — never a silent fallback to a provider the caller didn't ask
+// for.
+
+import { askProvider as defaultAskProvider } from "../intelligence/quick-ask.js";
+import {
+  getCodexIsolationStatus as defaultGetCodexIsolationStatus,
+  runCodexSandboxedBootstrap as defaultRunCodexSandboxedBootstrap
+} from "./codex-sandbox.js";
+import { verifyClaudeSubscriptionAuth as defaultVerifyClaudeSubscriptionAuth } from "../runtime/execution-adapters/claude.js";
+import { readClaudeModels as defaultReadClaudeModels } from "../observability/claude-models.js";
+import { readCursorModels as defaultReadCursorModels } from "../observability/cursor-models.js";
+import { probeCursorAuth as defaultProbeCursorAuth } from "../observability/cursor-auth.js";
+import {
+  getCursorIsolationStatus as defaultGetCursorIsolationStatus,
+  runCursorSandboxedBootstrap as defaultRunCursorSandboxedBootstrap
+} from "./cursor-sandbox.js";
+
+export function createCodexBootstrapAnalyzerAdapter({ modelId, deps = {} } = {}) {
+  const runSandboxed = deps.runCodexSandboxedBootstrap ?? defaultRunCodexSandboxedBootstrap;
+  const getIsolation = deps.getCodexIsolationStatus ?? defaultGetCodexIsolationStatus;
+  return {
+    adapterId: "codex",
+    modelId,
+    async checkEligibility() {
+      const isolation = await getIsolation(deps.isolationDeps ?? {});
+      return {
+        eligible: isolation.available,
+        reason: isolation.available ? undefined : isolation.reason,
+        isolation: isolation.available ? "verified" : "unverified",
+        // The sandbox-exec mechanism itself was empirically canary-tested
+        // (a real absolute-path read outside the confined root was denied,
+        // see codex-sandbox.js's own header) — `available` reflects that
+        // the same proven mechanism is usable here (platform + binary
+        // present), not a fresh proof on every call.
+        canaryTested: isolation.available
+      };
+    },
+    async analyze({ question, snapshotRoot, timeoutMs }) {
+      return runSandboxed({ question, model: modelId, snapshotRoot, timeoutMs, deps: deps.isolationDeps ?? {} });
+    }
+  };
+}
+
+export function createClaudeBootstrapAnalyzerAdapter({ modelId, deps = {} } = {}) {
+  const ask = deps.askProvider ?? defaultAskProvider;
+  const verifyAuth = deps.verifyClaudeSubscriptionAuth ?? defaultVerifyClaudeSubscriptionAuth;
+  const listModels = deps.readClaudeModels ?? defaultReadClaudeModels;
+  return {
+    adapterId: "claude",
+    modelId,
+    // Real, integral eligibility — not a hardcoded claim:
+    //  1. CLI + authentication: reuses execution-adapters/claude.js's own
+    //     `claude auth status` check (the same real one gating a Claude
+    //     execution run) — an unauthenticated or missing CLI fails here,
+    //     never silently reported eligible.
+    //  2. Model availability: checked against Claude's documented model
+    //     catalog (observability/claude-models.js). Claude's CLI has no
+    //     live model-discovery command (verified via its own --help, see
+    //     that module's own header) — this catches an unknown/typo'd
+    //     modelId, though it can't prove live per-account entitlement the
+    //     way Codex/OpenCode's live catalogs can.
+    //  3. isolation: "restricted" (application-enforced, by the claude
+    //     CLI's own in-process tool-permission logic — not an OS kernel
+    //     sandbox like Codex's sandbox-exec, so a bug in that logic could
+    //     theoretically be bypassed, unlike a kernel boundary).
+    //     canaryTested: true — --restricted's actual confinement was
+    //     empirically canary-tested (not assumed): a real absolute-path
+    //     read outside cwd came back in the JSON output's own
+    //     `permission_denials` array (Claude's Read tool itself refused
+    //     it), while an in-bounds read succeeded with an empty
+    //     `permission_denials`. That proof is WHETHER it was tested, not
+    //     WHO enforces it — it does not make this "verified"; only a
+    //     kernel-enforced boundary earns that label.
+    async checkEligibility() {
+      try {
+        await verifyAuth({});
+      } catch (error) {
+        return { eligible: false, reason: error?.message ?? String(error), isolation: "unverified", canaryTested: false };
+      }
+      if (modelId) {
+        const catalog = listModels();
+        const known = catalog.models.some((m) => m.id === modelId);
+        if (!known) {
+          return { eligible: false, reason: `"${modelId}" is not in Claude's documented model catalog.`, isolation: "unverified", canaryTested: false };
+        }
+      }
+      return { eligible: true, isolation: "restricted", canaryTested: true };
+    },
+    async analyze({ question, snapshotRoot, timeoutMs }) {
+      return ask({ provider: "claude", question, model: modelId, cwd: snapshotRoot, timeoutMs });
+    }
+  };
+}
+
+const CURSOR_AUTO_IDS = new Set(["auto", "cursor:auto", "cursor-auto"]);
+const CURSOR_AUTO_CANONICAL = "cursor:auto";
+const CURSOR_ANALYZE_TIMEOUT_MS = 180_000;
+
+export function createCursorBootstrapAnalyzerAdapter({ modelId, deps = {} } = {}) {
+  const listModels = deps.readCursorModels ?? defaultReadCursorModels;
+  const probeAuth = deps.probeCursorAuth ?? defaultProbeCursorAuth;
+  const getIsolation = deps.getCursorIsolationStatus ?? defaultGetCursorIsolationStatus;
+  const runSandboxed = deps.runCursorSandboxedBootstrap ?? defaultRunCursorSandboxedBootstrap;
+  const isAuto = modelId != null && CURSOR_AUTO_IDS.has(String(modelId).toLowerCase());
+  // Cursor Auto is a distinct, real candidate identity, never an implicit
+  // default for a missing selection — its own outcomes are ALWAYS
+  // attributed to this canonical "cursor:auto" id, never to a guessed
+  // inner model (Cursor never discloses which model actually answered in
+  // Auto mode). A caller must explicitly choose it.
+  const normalizedModelId = isAuto ? CURSOR_AUTO_CANONICAL : modelId;
+  return {
+    adapterId: "cursor",
+    modelId: normalizedModelId,
+    // Real eligibility — currently, honestly, negative. Real gates, none
+    // skipped or assumed:
+    //  1. A modelId must actually be provided — either a real explicit
+    //     model or the canonical "cursor:auto" opaque-router candidate;
+    //     an absent selection is never silently defaulted to either.
+    //  2. For an EXPLICIT model: checked against the real per-account
+    //     catalog (observability/cursor-models.js's readCursorModels — a
+    //     real `cursor-agent models` call, exit-status-checked). Cursor
+    //     Auto is exempt from this specific check (it's a routing mode,
+    //     not a listed catalog model) — but exempting the catalog check
+    //     must never also exempt authentication: `cursor-agent status`/
+    //     `whoami` do NOT reliably reflect whether a real invocation will
+    //     work (verified empirically — status can report "Logged in"
+    //     while a real -p call still fails with "Authentication
+    //     required"), so Auto is separately gated on
+    //     observability/cursor-auth.js's probeCursorAuth, a real
+    //     invocation-based probe, not the unreliable status/whoami claim.
+    //  3. Isolation proof, for BOTH explicit models and Cursor Auto alike:
+    //     Cursor's OWN --sandbox enabled does NOT confine reads (verified
+    //     empirically — a real out-of-bounds absolute-path read under
+    //     --sandbox enabled alone succeeded and disclosed real content).
+    //     The real boundary is cursor-sandbox.js's external macOS
+    //     sandbox-exec wrapper (mirroring codex-sandbox.js), independently
+    //     canary-tested and proven to hold: an in-bounds read succeeds, an
+    //     out-of-bounds one is denied ("Permission denied"). isolation:
+    //     "verified" + canaryTested: true only when that mechanism is
+    //     actually available (macOS + sandbox-exec present) — never on
+    //     any other platform, and never via Cursor's own --sandbox flag.
+    async checkEligibility() {
+      if (!modelId) {
+        return {
+          eligible: false,
+          reason: "No Cursor model selection was provided — pass an explicit model or \"cursor:auto\".",
+          isolation: "unverified", canaryTested: false
+        };
+      }
+      if (!isAuto) {
+        const catalog = await listModels();
+        if (catalog.status !== "measured") {
+          return {
+            eligible: false, reason: `Could not read Cursor's real model catalog: ${catalog.error ?? catalog.status}`,
+            isolation: "unverified", canaryTested: false
+          };
+        }
+        if (catalog.models.length === 0) {
+          return { eligible: false, reason: "No models are enabled for this Cursor account.", isolation: "unverified", canaryTested: false };
+        }
+        if (!catalog.models.some((m) => m.id === modelId)) {
+          return {
+            eligible: false, reason: `"${modelId}" is not in this account's real Cursor model catalog.`,
+            isolation: "unverified", canaryTested: false
+          };
+        }
+      } else {
+        const auth = await probeAuth();
+        if (auth.status !== "measured") {
+          return {
+            eligible: false, reason: `Could not determine whether Cursor Auto can actually be invoked: ${auth.reason ?? auth.status}`,
+            isolation: "unverified", canaryTested: false
+          };
+        }
+        if (!auth.authenticated) {
+          return { eligible: false, reason: auth.reason, isolation: "unverified", canaryTested: false };
+        }
+      }
+      const isolation = await getIsolation(deps.isolationDeps ?? {});
+      if (!isolation.available) {
+        return { eligible: false, reason: isolation.reason, isolation: "unverified", canaryTested: false };
+      }
+      return { eligible: true, isolation: "verified", canaryTested: true };
+    },
+    // Routed through cursor-sandbox.js's external sandbox-exec wrapper —
+    // never a bare `cursor-agent` spawn, since Cursor's own --sandbox
+    // enabled does not confine reads (see that module's header for the
+    // full empirical finding). Cursor Auto omits a model id; the wrapper
+    // itself omits --model entirely for that case.
+    async analyze({ question, snapshotRoot, timeoutMs = CURSOR_ANALYZE_TIMEOUT_MS }) {
+      return runSandboxed({
+        question, model: isAuto ? null : modelId, snapshotRoot, timeoutMs, deps: deps.isolationDeps ?? {}
+      });
+    }
+  };
+}
+
+const ADAPTER_FACTORIES = Object.freeze({
+  codex: createCodexBootstrapAnalyzerAdapter,
+  claude: createClaudeBootstrapAnalyzerAdapter,
+  cursor: createCursorBootstrapAnalyzerAdapter
+});
+
+/**
+ * @param {string} adapterId
+ * @param {{modelId: string, deps?: object}} [options]
+ * @returns {{adapterId: string, modelId: string, checkEligibility: Function, analyze: Function}}
+ */
+export function createBootstrapAnalyzerAdapter(adapterId, { modelId, deps = {} } = {}) {
+  const factory = ADAPTER_FACTORIES[adapterId];
+  if (!factory) {
+    const reason = `No Bootstrap Analyzer adapter implemented for "${adapterId}" yet.`;
+    return {
+      adapterId, modelId,
+      checkEligibility() { return { eligible: false, reason, isolation: "unverified", canaryTested: false }; },
+      async analyze() { throw new Error(reason); }
+    };
+  }
+  return factory({ modelId, deps });
+}

package/src/global/conversation/cli.js

@@ -0,0 +1,53 @@
+import { createConversationService } from "./service.js";
+import { printJson } from "../json-output.js";
+
+/**
+ * The scripted CLI's own preview/confirm contract, mirroring the cockpit
+ * and browser local UI exactly: no `--confirm` is always a read-only
+ * preview (service.planExecution — never reserves quota or starts a run);
+ * `--confirm` re-fetches that same preview fresh, right before executing,
+ * and executes exactly what it shows. PROJECT TEAM is the sole authority
+ * for execution — `--role` is required (never inferred from task text),
+ * and there is no `--model`/`--agent` override left to bypass it; only a
+ * confirmed `confirmationTarget` from the fresh preview ever reaches
+ * executePlan.
+ * @param {ReturnType<typeof createConversationService>} service
+ * @param {object} options
+ */
+async function runExecuteAction(service, options) {
+  if (!options.role) {
+    throw new Error(`Missing --role. PROJECT TEAM is the sole authority for execution — pick the real role this task is for (see /project or 'conversation snapshot' for the active team's roles).`);
+  }
+  const preview = await service.planExecution({ cwd: options.cwd, taskId: options.taskId, role: options.role });
+  if (!options.confirm) return preview;
+
+  if (!preview.confirmationTarget) {
+    throw new Error(`Cannot execute "${options.taskId}": ${preview.why}`);
+  }
+  return service.executePlan({ cwd: options.cwd, taskId: options.taskId, confirmationTarget: preview.confirmationTarget });
+}
+
+export async function runConversationCli(options, deps = {}) {
+  const service = deps.service ?? createConversationService(deps);
+  const action = options.conversationAction ?? "snapshot";
+  let result;
+  if (action === "snapshot") result = await service.snapshot({ cwd: options.cwd });
+  else if (action === "architect") {
+    result = await service.submitArchitecture({ cwd: options.cwd, task: options.task, model: options.model });
+  } else if (action === "show") {
+    result = await service.showPlan({ cwd: options.cwd, taskId: options.taskId });
+  } else if (action === "approve" || action === "reject") {
+    result = await service.decidePlan({
+      cwd: options.cwd,
+      taskId: options.taskId,
+      decision: action === "approve" ? "approved" : "rejected"
+    });
+  } else if (action === "execute") {
+    result = await runExecuteAction(service, options);
+  } else if (action === "cancel") {
+    result = await service.cancelExecution({ cwd: options.cwd, taskId: options.taskId });
+  } else throw new Error(`Unknown conversation action "${action}".`);
+  if (options.json) printJson(result);
+  else console.log(JSON.stringify(result, null, 2));
+  return result;
+}