blun-king-cli 9.1.567 → 9.1.569

package/agent-spine-plugin/src/cli-agent.js

@@ -0,0 +1,296 @@
+import { checkDelegation, createTask, deleteTask, grantDelegation, loadDelegationPolicy, revokeDelegation, taskContext, updateTask } from "./lib/coordination.js";
+import { cancelJob, deleteJob, grantExecution, loadExecutionPolicy, registerJob, revokeExecution, selfstarterContext } from "./lib/selfstarter.js";
+import { channelRuntimeContext, grantChannelBinding, loadChannelPolicy, revokeChannelBinding } from "./lib/channel-runtime.js";
+import { personaContext, syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
+import { assignGoal, gatewayContext, resolveGoalKnowledgeGap, setGatewayControl } from "./lib/gateway-runtime.js";
+import {
+  currentHostTranscriptReceipt, enrollPrivateSessionTimeline, LOCAL_TIMELINE_ENROLLMENT_CONFIRMATION,
+  LOCAL_TIMELINE_ENROLLMENT_RECOVERY_CONFIRMATION, resetPrivateSessionTimelineEnrollment
+} from "./lib/session-timeline-enrollment.js";
+import { bootstrapSessionTimelineEnrollment } from "./lib/session-timeline.js";
+import { booleanFlag, goalPlanFlag, output } from "./cli-common.js";
+
+export const agentCommands = new Set([
+  "delegation-grant",
+  "delegation-revoke",
+  "delegation-check",
+  "delegation-policy",
+  "task-create",
+  "task-update",
+  "tasks",
+  "task-delete",
+  "execution-grant",
+  "execution-revoke",
+  "execution-policy",
+  "job-register",
+  "jobs",
+  "job-cancel",
+  "job-delete",
+  "channel-bind",
+  "channel-revoke",
+  "channel-policy",
+  "channel-events",
+  "persona-sync",
+  "personas",
+  "goal-assign",
+  "goal-clarify",
+  "gateway-control",
+  "gateway-status",
+  "timeline-receipt",
+  "timeline-enroll",
+  "timeline-enrollment-recover"
+]);
+
+function timelineFlagValue(flags, name) {
+  const value = flags[name];
+  if (typeof value !== "string" || !value) throw new Error(`timeline command requires --${name}`);
+  return value;
+}
+
+function onlyTimelineFlags(flags, allowed, command) {
+  const unexpected = Object.keys(flags).filter((name) => !allowed.has(name));
+  if (unexpected.length) {
+    throw new Error(`${command} accepts only ${[...allowed].filter((name) => name !== "json").map((name) => `--${name}`).join(", ")}`);
+  }
+}
+
+export async function runAgentCommand({ command, flags, positional, json }) {
+  if (command === "timeline-receipt") {
+    if (positional.length) throw new Error("timeline receipt accepts no positional arguments; pass --root explicitly");
+    onlyTimelineFlags(flags, new Set(["root", "json"]), "timeline receipt");
+    return output(await currentHostTranscriptReceipt({ root: timelineFlagValue(flags, "root") }), json);
+  }
+
+  if (command === "timeline-enroll") {
+    if (positional.length) throw new Error("timeline enrollment accepts no positional arguments; pass --root explicitly");
+    onlyTimelineFlags(flags, new Set(["root", "receipt", "confirm-local-timeline", "json"]), "timeline enrollment");
+    if (!booleanFlag(flags["confirm-local-timeline"])) {
+      throw new Error("timeline enrollment requires --confirm-local-timeline");
+    }
+    const enrollment = await enrollPrivateSessionTimeline({
+      root: timelineFlagValue(flags, "root"), hostReceipt: timelineFlagValue(flags, "receipt"),
+      confirmation: LOCAL_TIMELINE_ENROLLMENT_CONFIRMATION
+    });
+    if (enrollment.status !== "enrolled") return output(enrollment, json);
+    const bootstrap = await bootstrapSessionTimelineEnrollment({
+      root: timelineFlagValue(flags, "root"), enrollmentDigest: enrollment.enrollmentDigest
+    });
+    return output({ ...enrollment, stateBootstrap: { status: bootstrap.status, reason: bootstrap.reason ?? null } }, json);
+  }
+
+  if (command === "timeline-enrollment-recover") {
+    if (positional.length) throw new Error("timeline enrollment recovery accepts no positional arguments; pass --root explicitly");
+    onlyTimelineFlags(flags, new Set(["root", "confirm-local-timeline-recovery", "json"]), "timeline enrollment recovery");
+    if (!booleanFlag(flags["confirm-local-timeline-recovery"])) {
+      throw new Error("timeline enrollment recovery requires --confirm-local-timeline-recovery");
+    }
+    const recovered = await resetPrivateSessionTimelineEnrollment({
+      root: timelineFlagValue(flags, "root"), confirmation: LOCAL_TIMELINE_ENROLLMENT_RECOVERY_CONFIRMATION
+    });
+    return output({ status: recovered ? "recovered" : "unavailable",
+      reason: recovered ? null : "timeline-enrollment-recovery-unavailable", authority: "context-only" }, json);
+  }
+
+  if (command === "delegation-grant") {
+    return output(await grantDelegation({
+      root: flags.root || process.cwd(), actorId: positional[0],
+      id: flags.id, actions: String(flags.actions || "").split(",").filter(Boolean),
+      targetIds: String(flags.targets || "*").split(",").filter(Boolean), reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-policy"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "delegation-revoke") {
+    return output(await revokeDelegation({
+      root: flags.root || process.cwd(), id: positional[0], reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-policy"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "delegation-check") {
+    return output(await checkDelegation({
+      root: flags.root || process.cwd(), actorId: positional[0], action: flags.action,
+      targetId: flags.target || null
+    }), json);
+  }
+
+  if (command === "delegation-policy") {
+    return output((await loadDelegationPolicy(positional[0] || process.cwd())).policy, json);
+  }
+
+  if (command === "task-create") {
+    return output(await createTask({
+      root: flags.root || process.cwd(), id: positional[0], actorId: flags.actor,
+      assigneeId: flags.assignee || null, kind: flags.kind || "task", title: flags.title,
+      summary: flags.summary || null, projectId: flags.project || null,
+      privacy: flags.privacy || "private", groupId: flags.group || null,
+      priority: Number(flags.priority ?? 50), dueAt: flags.due || null
+    }), json);
+  }
+
+  if (command === "task-update") {
+    const patch = {};
+    if (flags.status !== undefined) patch.status = flags.status;
+    if (flags.assignee !== undefined) patch.assigneeId = flags.assignee;
+    if (flags.unassign !== undefined) patch.assigneeId = null;
+    if (flags.title !== undefined) patch.title = flags.title;
+    if (flags.summary !== undefined) patch.summary = flags.summary;
+    if (flags.priority !== undefined) patch.priority = Number(flags.priority);
+    if (flags.due !== undefined) patch.dueAt = flags.due;
+    if (flags["clear-due"] !== undefined) patch.dueAt = null;
+    if (flags.note !== undefined) patch.note = flags.note;
+    return output(await updateTask({
+      root: flags.root || process.cwd(), id: positional[0], actorId: flags.actor, patch
+    }), json);
+  }
+
+  if (command === "tasks") {
+    return output(await taskContext({
+      root: positional[0] || process.cwd(), includePrivate: booleanFlag(flags["include-private"]),
+      groupId: flags.group || null, actorId: flags.actor || null, assigneeId: flags.assignee || null,
+      projectId: flags.project || null, includeClosed: booleanFlag(flags.closed),
+      maxItems: Number(flags["max-items"] ?? 20)
+    }), json);
+  }
+
+  if (command === "task-delete") {
+    return output(await deleteTask({
+      root: flags.root || process.cwd(), id: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-policy"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "execution-grant") {
+    return output(await grantExecution({
+      root: flags.root || process.cwd(), id: flags.id, jobId: positional[0], actorId: flags.actor,
+      taskId: flags.task, targetId: flags.target, projectId: flags.project, groupId: flags.group || null,
+      host: flags.host, capabilities: String(flags.capabilities || "").split(",").filter(Boolean),
+      reason: flags.reason, expiresAt: flags.expires || null,
+      confirmation: booleanFlag(flags["confirm-local-execution"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "execution-revoke") {
+    return output(await revokeExecution({
+      root: flags.root || process.cwd(), id: positional[0], reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-execution"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "execution-policy") {
+    return output((await loadExecutionPolicy(positional[0] || process.cwd())).policy, json);
+  }
+
+  if (command === "job-register") {
+    return output(await registerJob({
+      root: flags.root || process.cwd(), id: positional[0], grantId: flags.grant,
+      maxRetries: Number(flags["max-retries"] ?? 3), leaseSeconds: Number(flags["lease-seconds"] ?? 120),
+      baseRetrySeconds: Number(flags["retry-seconds"] ?? 5),
+      confirmation: booleanFlag(flags["confirm-local-execution"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "jobs") {
+    return output(await selfstarterContext({
+      root: positional[0] || process.cwd(), actorId: flags.actor || null,
+      projectId: flags.project || null, taskId: flags.task || null,
+      includeTerminal: booleanFlag(flags["include-terminal"])
+    }), json);
+  }
+
+  if (command === "job-cancel") {
+    return output(await cancelJob({
+      root: flags.root || process.cwd(), id: positional[0], reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-execution"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "job-delete") {
+    return output(await deleteJob({
+      root: flags.root || process.cwd(), id: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-execution"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "channel-bind") {
+    return output(await grantChannelBinding({
+      root: flags.root || process.cwd(), id: positional[0], provider: flags.provider,
+      tenantId: flags.tenant, accountId: flags.account, chatId: flags.chat,
+      threadId: flags.thread || null,
+      senderIds: String(flags.senders || "").split(",").filter(Boolean),
+      agentId: flags.agent, projectId: flags.project, groupId: flags.group || null,
+      sessionKey: flags.session, secretEnv: flags["secret-env"], outboundSecretEnv: flags["outbound-secret-env"] || null,
+      capabilities: String(flags.capabilities || "receive,reply").split(",").filter(Boolean),
+      confirmation: booleanFlag(flags["confirm-local-channel"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "channel-revoke") {
+    return output(await revokeChannelBinding({
+      root: flags.root || process.cwd(), id: positional[0], reason: flags.reason,
+      confirmation: booleanFlag(flags["confirm-local-channel"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "channel-policy") {
+    return output((await loadChannelPolicy(positional[0] || process.cwd())).policy, json);
+  }
+
+  if (command === "channel-events") {
+    return output(await channelRuntimeContext({
+      root: positional[0] || process.cwd(), agentId: flags.agent || null,
+      projectId: flags.project || null,
+      ...(flags.group !== undefined ? { groupId: flags.group || null } : {}),
+      provider: flags.provider || null,
+      includeTerminal: booleanFlag(flags["include-terminal"]),
+      maxItems: Number(flags["max-items"] ?? 20)
+    }), json);
+  }
+
+  if (command === "persona-sync") {
+    if (!booleanFlag(flags["confirm-local-persona"])) throw new Error("persona synchronization requires --confirm-local-persona");
+    return output(await syncPersonaRosterFromEnvironment({
+      root: positional[0] || process.cwd(), env: { ...process.env, AGENTSPINE_PERSONA_ROSTER_FILE: flags.roster }
+    }), json);
+  }
+
+  if (command === "personas") {
+    return output(await personaContext({
+      root: positional[0] || process.cwd(), personaId: flags.persona || null,
+      ...(flags.group !== undefined ? { groupId: flags.group || null } : {}),
+      includeInactive: booleanFlag(flags["include-inactive"])
+    }), json);
+  }
+
+  if (command === "goal-assign") {
+    return output(await assignGoal({
+      root: flags.root || process.cwd(), goalId: positional[0], agentId: flags.agent,
+      ownerSubjectId: flags.owner, projectId: flags.project, groupId: flags.group || null,
+      priority: Number(flags.priority ?? 70), successCriterion: flags.success,
+      nextSafeStep: flags["next-step"] || null, steps: await goalPlanFlag(flags.plan), deadline: flags.deadline || null,
+      confirmation: booleanFlag(flags["confirm-local-goal"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "goal-clarify") {
+    return output(await resolveGoalKnowledgeGap({
+      root: flags.root || process.cwd(), goalId: positional[0], gapId: flags.gap,
+      answer: flags.answer, answerSource: flags.source || "owner-input",
+      sourceDigest: flags["source-digest"] || null,
+      confirmation: booleanFlag(flags["confirm-local-goal"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "gateway-control") {
+    return output(await setGatewayControl({
+      root: positional[0] || process.cwd(),
+      ...(flags.enabled !== undefined ? { enabled: booleanFlag(flags.enabled) } : {}),
+      ...(flags["kill-switch"] !== undefined ? { killSwitch: booleanFlag(flags["kill-switch"]) } : {}),
+      confirmation: booleanFlag(flags["confirm-local-gateway"]) ? "local-owner-confirmed" : null
+    }), json);
+  }
+
+  if (command === "gateway-status") {
+    return output(await gatewayContext({ root: positional[0] || process.cwd(), agentId: flags.agent || null }), json);
+  }
+}

package/agent-spine-plugin/src/cli-attention.js

@@ -0,0 +1,95 @@
+import { attentionContext, configureAttention, deleteAttention, loadAttention, recordActivity, resolveAttention, upsertAttention } from "./lib/attention.js";
+import { booleanFlag, output } from "./cli-common.js";
+
+export const attentionCommands = new Set([
+  "attention",
+  "attention-events",
+  "attention-add",
+  "attention-resolve",
+  "attention-touch",
+  "attention-delete",
+  "attention-event-delete",
+  "attention-purge",
+  "attention-config"
+]);
+
+export async function runAttentionCommand({ command, flags, positional, json }) {
+  if (command === "attention") {
+    return output(await attentionContext({
+      root: positional[0] || process.cwd(),
+      includePrivate: booleanFlag(flags["include-private"]),
+      focusActive: booleanFlag(flags["focus-active"]),
+      markPresented: booleanFlag(flags["mark-presented"]),
+      entityId: flags.entity || null,
+      groupId: flags.group || null,
+      projectId: flags.project || null,
+      currentTaskId: flags.task || null,
+      maxItems: flags["max-items"] === undefined ? null : Number(flags["max-items"])
+    }), json);
+  }
+
+  if (command === "attention-events") {
+    const { attention, attentionPath } = await loadAttention(positional[0] || process.cwd());
+    return output({
+      schema: "agentspine.attention-events/v1", attentionPath,
+      events: attention.events,
+      receipts: attention.receipts,
+      history: booleanFlag(flags["include-history"]) ? attention.history.filter((item) => item.kind === "attention-event") : [],
+      authority: "context-only"
+    }, json);
+  }
+
+  if (command === "attention-add") {
+    return output(await upsertAttention({
+      root: flags.root || process.cwd(), id: positional[0], kind: flags.kind,
+      summary: flags.summary, entityId: flags.entity || null, dueAt: flags.due || null,
+      priority: Number(flags.priority ?? 50), privacy: flags.privacy || "private",
+      groupId: flags.group || null,
+      sourceDocument: flags.source || null, confidence: Number(flags.confidence ?? 0.5)
+    }), json);
+  }
+
+  if (command === "attention-resolve") {
+    return output(await resolveAttention({
+      root: flags.root || process.cwd(), id: positional[0], status: flags.status || "completed"
+    }), json);
+  }
+
+  if (command === "attention-touch") {
+    return output(await recordActivity({
+      root: flags.root || process.cwd(), entityId: positional[0], kind: flags.kind || "interaction",
+      at: flags.at || new Date(), privacy: flags.privacy || "private", groupId: flags.group || null
+    }), json);
+  }
+
+  if (command === "attention-delete") {
+    return output(await deleteAttention({ root: flags.root || process.cwd(), signalId: positional[0] }), json);
+  }
+
+  if (command === "attention-event-delete") {
+    return output(await deleteAttention({ root: flags.root || process.cwd(), eventId: positional[0] }), json);
+  }
+
+  if (command === "attention-purge") {
+    return output(await deleteAttention({ root: flags.root || process.cwd(), entityId: positional[0] }), json);
+  }
+
+  if (command === "attention-config") {
+    const root = positional[0] || process.cwd();
+    const config = {};
+    if (flags.enabled !== undefined) config.enabled = booleanFlag(flags.enabled);
+    if (flags["min-interval-hours"] !== undefined) config.minIntervalHours = Number(flags["min-interval-hours"]);
+    if (flags["silence-days"] !== undefined) config.entitySilenceDays = Number(flags["silence-days"]);
+    if (flags["heartbeat-stale-minutes"] !== undefined) config.heartbeatStaleMinutes = Number(flags["heartbeat-stale-minutes"]);
+    if (flags["max-items"] !== undefined) config.maxItems = Number(flags["max-items"]);
+    if (flags["quiet-off"] !== undefined) config.quietHours = null;
+    else if (flags["quiet-start"] !== undefined || flags["quiet-end"] !== undefined) {
+      config.quietHours = {
+        start: Number(flags["quiet-start"]), end: Number(flags["quiet-end"]),
+        utcOffsetMinutes: Number(flags["utc-offset"] ?? 0)
+      };
+    }
+    if (!Object.keys(config).length) return output((await loadAttention(root)).attention.config, json);
+    return output(await configureAttention({ root, config }), json);
+  }
+}

package/agent-spine-plugin/src/cli-autonomy.js

@@ -0,0 +1,36 @@
+import {
+  autonomyStatus, configureAutonomyProject, evaluateAutonomyAction,
+  projectPortfolioContext, recordProjectObservation, revokeAutonomyProject, scanProjectPortfolio
+} from "./lib/autonomy.js";
+import { booleanFlag, output } from "./cli-common.js";
+
+export const autonomyCommands = new Set([
+  "autonomy-project-set", "autonomy-project-revoke", "autonomy-scan",
+  "autonomy-observe", "autonomy-status", "autonomy-check", "portfolio"
+]);
+
+function capabilities(value) { return String(value || "").split(",").filter(Boolean); }
+
+export async function runAutonomyCommand({ command, flags, positional, json }) {
+  const root = flags.root || process.cwd();
+  if (command === "autonomy-project-set") return output(await configureAutonomyProject({
+    root, id: positional[0], projectId: flags.project, tenantId: flags.tenant, groupId: flags.group || null,
+    localRoot: flags["local-root"] || null, publicUrl: flags["public-url"] || null,
+    mode: flags.mode || "observe", capabilities: capabilities(flags.capabilities), goal: flags.goal,
+    confirmation: flags["confirm-local-autonomy"] ? "local-owner-confirmed" : null,
+    publishConfirmation: flags["confirm-local-publish"] ? "local-owner-publish-confirmed" : null
+  }), json);
+  if (command === "autonomy-project-revoke") return output(await revokeAutonomyProject({ root, id: positional[0],
+    reason: flags.reason, confirmation: flags["confirm-local-autonomy"] ? "local-owner-confirmed" : null }), json);
+  if (command === "autonomy-scan") return output(await scanProjectPortfolio({ root, tenantId: flags.tenant, groupId: flags.group || null }), json);
+  if (command === "autonomy-observe") return output(await recordProjectObservation({ root, registrationId: positional[0],
+    tenantId: flags.tenant, groupId: flags.group || null, kind: flags.kind, status: flags.status || "open",
+    evidenceClass: flags.evidence, summary: flags.summary, sourceDigest: flags["source-digest"], expiresAt: flags.expires || null }), json);
+  if (command === "autonomy-status") return output(await autonomyStatus({ root, tenantId: flags.tenant || null, groupId: flags.group || null }), json);
+  if (command === "autonomy-check") return output(await evaluateAutonomyAction({ root, registrationId: positional[0],
+    tenantId: flags.tenant, groupId: flags.group || null, action: flags.action, capability: flags.capability || null,
+    actorId: flags.actor || null, jobId: flags.job || null, taskId: flags.task || null, targetId: flags.target || null,
+    projectId: flags.project || null, host: flags.host || null }), json);
+  if (command === "portfolio") return output(await projectPortfolioContext({ root, tenantId: flags.tenant,
+    groupId: flags.group || null, markPresented: booleanFlag(flags["mark-presented"]) }), json);
+}

package/agent-spine-plugin/src/cli-common.js

@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+
+export function parseCli(argv) {
+  const [command = "help", ...rest] = argv;
+  const flags = {};
+  const positional = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const [name, inline] = token.slice(2).split("=", 2);
+    if (inline !== undefined) flags[name] = inline;
+    else if (rest[index + 1] && !rest[index + 1].startsWith("--")) flags[name] = rest[++index];
+    else flags[name] = true;
+  }
+  return { command, flags, positional };
+}
+
+export function outputCli(value, json = false) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    return;
+  }
+  if (typeof value === "string") process.stdout.write(`${value}\n`);
+  else process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function booleanFlag(value, fallback = false) {
+  if (value === undefined) return fallback;
+  if (value === true || value === "true" || value === "1") return true;
+  if (value === false || value === "false" || value === "0") return false;
+  throw new Error(`expected boolean flag, received: ${value}`);
+}
+
+export async function goalPlanFlag(path) {
+  if (!path) return null;
+  const content = await readFile(path, "utf8");
+  if (Buffer.byteLength(content) > 64 * 1024) throw new Error("goal plan exceeds 64 KiB");
+  const parsed = JSON.parse(content);
+  const steps = Array.isArray(parsed) ? parsed : parsed?.steps;
+  if (!Array.isArray(steps)) throw new Error("goal plan must be a JSON array or an object with a steps array");
+  return steps;
+}
+
+export function learningScope(flags) {
+  return {
+    personaId: flags.persona || null,
+    userId: flags.user || null,
+    tenantId: flags.tenant || null,
+    projectId: flags.project || null,
+    groupId: flags.group || null,
+    taskId: flags.task || null
+  };
+}
+
+export function hasLearningScope(flags) {
+  return ["persona", "user", "tenant", "project", "group", "task"]
+    .some((name) => flags[name] !== undefined);
+}
+
+export function evaluatorRootsFlag(value) {
+  return String(value || "").split(",").filter(Boolean).map((entry) => {
+    const separator = entry.lastIndexOf("=");
+    if (separator <= 0) throw new Error("evaluator roots must use evaluator-id=sha256 entries");
+    return { evaluatorId: entry.slice(0, separator), principalDigest: entry.slice(separator + 1) };
+  });
+}
+
+export { outputCli as output, parseCli as parse };

package/agent-spine-plugin/src/cli-continuity.js

@@ -0,0 +1,116 @@
+import { readFile } from "node:fs/promises";
+import { configureContinuity, loadContinuity, purgeContinuity } from "./lib/continuity.js";
+import { configurePreflightPolicy, confirmMustRemember, preflightStatus, proposeMustRemember, purgeMustRemember, rollbackMustRemember } from "./lib/preflight.js";
+import { bindSourceRoot, inspectSourceRegistry, purgeSourceBinding, resolveHostSourceCatalog, rollbackSourceBinding } from "./lib/source-roots.js";
+import { booleanFlag, output } from "./cli-common.js";
+
+export const continuityCommands = new Set([
+  "continuity-config",
+  "continuity-status",
+  "continuity-purge",
+  "preflight-policy",
+  "preflight-status",
+  "remember-propose",
+  "remember-confirm",
+  "remember-rollback",
+  "remember-purge",
+  "source-status",
+  "source-bind",
+  "source-rollback",
+  "source-purge"
+]);
+
+export async function runContinuityCommand({ command, flags, positional, json }) {
+  if (command === "continuity-config") {
+    const root = positional[0] || process.cwd();
+    const config = {};
+    if (flags.enabled !== undefined) config.enabled = booleanFlag(flags.enabled);
+    if (flags.entity !== undefined) config.defaultEntityId = flags.entity === "none" ? null : flags.entity;
+    if (flags.project !== undefined) config.defaultProjectId = flags.project === "none" ? null : flags.project;
+    if (flags["min-confidence"] !== undefined) config.minConfidence = Number(flags["min-confidence"]);
+    if (flags["min-directness"] !== undefined) config.minDirectness = Number(flags["min-directness"]);
+    if (flags["min-evidence"] !== undefined) config.minEvidence = Number(flags["min-evidence"]);
+    if (flags["max-prompt-bytes"] !== undefined) config.maxPromptBytes = Number(flags["max-prompt-bytes"]);
+    if (flags["max-briefing-bytes"] !== undefined) config.maxBriefingBytes = Number(flags["max-briefing-bytes"]);
+    if (!Object.keys(config).length) return output((await loadContinuity(root)).continuity.config, json);
+    return output(await configureContinuity({
+      root, config,
+      confirmation: booleanFlag(flags["confirm-local-opt-in"]) ? "local-user-opt-in" : null
+    }), json);
+  }
+
+  if (command === "continuity-status") {
+    const { continuity, continuityPath } = await loadContinuity(positional[0] || process.cwd());
+    return output({
+      schema: continuity.schema, config: continuity.config,
+      signals: continuity.signals.length, history: continuity.history.length,
+      continuityPath, authority: "context-only"
+    }, json);
+  }
+
+  if (command === "continuity-purge") {
+    return output(await purgeContinuity({
+      root: flags.root || process.cwd(), subjectId: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-purge"]) ? "local-user-confirmed" : null
+    }), json);
+  }
+
+  if (command === "preflight-policy") {
+    if (!positional[0]) throw new Error("preflight-policy requires one local JSON policy file");
+    const profile = JSON.parse(await readFile(positional[0], "utf8"));
+    return output(await configurePreflightPolicy({ profile,
+      confirmation: booleanFlag(flags["confirm-local-policy"]) ? "local-owner-confirmed" : null }), json);
+  }
+
+  if (command === "preflight-status") return output(await preflightStatus(), json);
+
+  if (command === "remember-propose") {
+    return output(await proposeMustRemember({ claim: flags.claim, kind: flags.kind || "critical",
+      userId: flags.user, tenantId: flags.tenant, projectId: flags.project || null,
+      groupId: flags.group || null, taskId: flags.task || null, sourceDigest: flags["source-digest"] || null }), json);
+  }
+
+  if (command === "remember-confirm") {
+    return output(await confirmMustRemember({ candidateId: positional[0], supersedes: flags.supersedes || null,
+      confirmation: booleanFlag(flags["confirm-local-user"]) ? "local-user-confirmed" : null }), json);
+  }
+
+  if (command === "remember-rollback") {
+    return output(await rollbackMustRemember({ id: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-user"]) ? "local-user-confirmed" : null }), json);
+  }
+
+  if (command === "remember-purge") {
+    return output(await purgeMustRemember({ id: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-purge"]) ? "local-user-purge-confirmed" : null }), json);
+  }
+
+  if (command === "source-status") {
+    const host = flags.host || process.env.AGENTSPINE_HOST;
+    if (!["claude", "codex"].includes(host)) throw new Error("source-status requires --host claude or --host codex");
+    const resolved = await resolveHostSourceCatalog({ host, cwd: flags.cwd || process.cwd() });
+    const registry = await inspectSourceRegistry();
+    return output({ diagnostics: resolved.diagnostics, sources: resolved.catalog.documents.map((item) => ({
+      id: item.relativePath, scope: item.sourceScope, binding: item.sourceBinding, sha256: item.sha256,
+      bytes: item.bytes, authority: item.authority
+    })), bindings: registry.registry.bindings, authority: "context-only" }, json);
+  }
+
+  if (command === "source-bind") {
+    return output(await bindSourceRoot({
+      host: flags.host, hostHome: flags["host-home"] || process.env.CLAUDE_CONFIG_DIR || process.env.CODEX_HOME || process.cwd(),
+      projectRoot: flags.project || process.cwd(), sourceRoot: positional[0], scope: flags.scope || "state-user",
+      confirmation: booleanFlag(flags["confirm-local-binding"]) ? "local-user-confirmed" : null
+    }), json);
+  }
+
+  if (command === "source-rollback") {
+    return output(await rollbackSourceBinding({ id: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-binding"]) ? "local-user-confirmed" : null }), json);
+  }
+
+  if (command === "source-purge") {
+    return output(await purgeSourceBinding({ id: positional[0],
+      confirmation: booleanFlag(flags["confirm-local-binding"]) ? "local-user-confirmed" : null }), json);
+  }
+}