chainlesschain 0.165.2 → 0.165.4

package/src/commands/cowork.js

@@ -75,8 +75,9 @@ function renderWorkflowPreflight(preflight) {
 }
 
 async function loadCoworkWorkflowRecord(cwd, id, definitionDigest) {
-  const { getWorkflowRecord, getWorkflowVersion } =
-    await import("../lib/cowork-workflow.js");
+  const { getWorkflowRecord, getWorkflowVersion } = await import(
+    "../lib/cowork-workflow.js"
+  );
   return definitionDigest
     ? getWorkflowVersion(cwd, id, definitionDigest)
     : getWorkflowRecord(cwd, id);
@@ -134,8 +135,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .option("--model <name>", "LLM model to use")
     .option("--json", "Output as JSON")
     .action(async (target, options) => {
-      const { startDebate, DEFAULT_PERSPECTIVES } =
-        await import("../lib/cowork/debate-review-cli.js");
+      const { startDebate, DEFAULT_PERSPECTIVES } = await import(
+        "../lib/cowork/debate-review-cli.js"
+      );
 
       const perspectives = options.perspectives
         .split(",")
@@ -344,8 +346,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
         let result;
 
         if (options.type === "style") {
-          const { analyzeProjectStyle } =
-            await import("../lib/cowork/project-style-analyzer-cli.js");
+          const { analyzeProjectStyle } = await import(
+            "../lib/cowork/project-style-analyzer-cli.js"
+          );
           const llmOptions = {};
           if (options.provider) llmOptions.provider = options.provider;
           if (options.model) llmOptions.model = options.model;
@@ -354,12 +357,14 @@ export function registerCoworkCommand(program, commandDeps = {}) {
             llmOptions,
           });
         } else if (options.type === "knowledge-graph") {
-          const { buildKnowledgeGraph } =
-            await import("../lib/cowork/code-knowledge-graph-cli.js");
+          const { buildKnowledgeGraph } = await import(
+            "../lib/cowork/code-knowledge-graph-cli.js"
+          );
           result = await buildKnowledgeGraph({ targetPath: resolved });
         } else if (options.type === "decisions") {
-          const { extractDecisions } =
-            await import("../lib/cowork/decision-kb-cli.js");
+          const { extractDecisions } = await import(
+            "../lib/cowork/decision-kb-cli.js"
+          );
           const llmOptions = {};
           if (options.provider) llmOptions.provider = options.provider;
           if (options.model) llmOptions.model = options.model;
@@ -408,8 +413,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .option("--limit <n>", "Max results", "20")
     .option("--json", "Output as JSON")
     .action(async (query, options) => {
-      const { searchTemplatesInHub } =
-        await import("../lib/cowork-evomap-adapter.js");
+      const { searchTemplatesInHub } = await import(
+        "../lib/cowork-evomap-adapter.js"
+      );
       try {
         const results = await searchTemplatesInHub(query || "", {
           hubUrl: options.hub,
@@ -455,8 +461,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
       (value, prev) => (prev ? [...prev, value] : [value]),
     )
     .action(async (geneId, options) => {
-      const { installTemplateFromHub } =
-        await import("../lib/cowork-evomap-adapter.js");
+      const { installTemplateFromHub } = await import(
+        "../lib/cowork-evomap-adapter.js"
+      );
       try {
         const template = await installTemplateFromHub(process.cwd(), geneId, {
           hubUrl: options.hub,
@@ -479,8 +486,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .description("List locally installed Cowork templates")
     .option("--json", "Output as JSON")
     .action(async (options) => {
-      const { listUserTemplates } =
-        await import("../lib/cowork-template-marketplace.js");
+      const { listUserTemplates } = await import(
+        "../lib/cowork-template-marketplace.js"
+      );
       const templates = listUserTemplates(process.cwd());
       if (options.json) {
         console.log(JSON.stringify(templates, null, 2));
@@ -503,8 +511,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .command("remove <id>")
     .description("Remove an installed Cowork template")
     .action(async (id) => {
-      const { removeUserTemplate } =
-        await import("../lib/cowork-template-marketplace.js");
+      const { removeUserTemplate } = await import(
+        "../lib/cowork-template-marketplace.js"
+      );
       if (removeUserTemplate(process.cwd(), id)) {
         logger.log(chalk.green(`✓ Removed '${id}'`));
       } else {
@@ -928,8 +937,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
               : {}),
           });
         }
-        const { generateDynamicWorkflowDraft } =
-          await import("../lib/dynamic-workflow-draft.js");
+        const { generateDynamicWorkflowDraft } = await import(
+          "../lib/dynamic-workflow-draft.js"
+        );
         const draft = await generateDynamicWorkflowDraft(
           { prompt, provider, model },
           { chat },
@@ -1017,7 +1027,15 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           process.cwd(),
           runId,
         );
-        const projection = runtime.projectDynamicWorkflowRuntime(statePath);
+        const projection = runtime.projectDynamicWorkflowRuntime(statePath, {
+          currentStoreReadback: true,
+          ...(Object.hasOwn(commandDeps, "workflowArtifactStore")
+            ? { artifactStore: commandDeps.workflowArtifactStore }
+            : {}),
+          ...(Object.hasOwn(commandDeps, "workflowCheckpointStore")
+            ? { checkpointStore: commandDeps.workflowCheckpointStore }
+            : {}),
+        });
         if (options.json) {
           console.log(JSON.stringify(projection, null, 2));
           return;
@@ -1031,6 +1049,19 @@ export function registerCoworkCommand(program, commandDeps = {}) {
         for (const effect of projection.pendingEffects) {
           logger.log(`  pending: ${effect.id} (${effect.key})`);
         }
+        for (const request of projection.pendingInputRequests) {
+          logger.log(
+            `  needs input: ${request.id} step=${request.stepId} ${request.prompt}`,
+          );
+        }
+        if (projection.currentStoreReadbacks.eligibleCalls > 0) {
+          logger.log(
+            `  current stores: ${projection.currentStoreReadbacks.verifiedCalls}/${projection.currentStoreReadbacks.eligibleCalls} verified`,
+          );
+          for (const gap of projection.currentStoreReadbacks.gaps) {
+            logger.log(`  current store gap: ${gap}`);
+          }
+        }
       } catch (err) {
         logger.error(`WORKFLOW_RUNTIME_STATUS_FAILED: ${err.message}`);
         process.exitCode = 2;
@@ -1079,6 +1110,127 @@ export function registerCoworkCommand(program, commandDeps = {}) {
       });
   }
 
+  workflow
+    .command("runtime-recover-checkpoint <run-id> <call-record-id>")
+    .description(
+      "Settle one crash-visible tool call from its bound terminal checkpoint store record",
+    )
+    .requiredOption(
+      "--expected-revision <n>",
+      "Exact runtime revision shown by runtime-status",
+    )
+    .option("--json", "Machine-readable JSON output")
+    .action(async (runId, callRecordId, options) => {
+      try {
+        const runtime = await import("../lib/dynamic-workflow-runtime.js");
+        const statePath = runtime.dynamicWorkflowRunStatePath(
+          process.cwd(),
+          runId,
+        );
+        const state = runtime.recoverDurableWorkflowCheckpointCall(
+          statePath,
+          {
+            expectedRevision: options.expectedRevision,
+            callRecordId,
+          },
+          Object.hasOwn(commandDeps, "workflowCheckpointStore")
+            ? { checkpointStore: commandDeps.workflowCheckpointStore }
+            : {},
+        );
+        const projection = runtime.projectDynamicWorkflowRuntime(state);
+        if (options.json) {
+          console.log(JSON.stringify(projection, null, 2));
+        } else {
+          logger.log(
+            `${projection.runId}  ${projection.status}  revision=${projection.revision}`,
+          );
+        }
+      } catch (err) {
+        logger.error(
+          `WORKFLOW_RUNTIME_RECOVER_CHECKPOINT_FAILED: ${err.message}`,
+        );
+        process.exitCode = 2;
+      }
+    });
+
+  workflow
+    .command("runtime-recover-checkpoints <run-id>")
+    .description(
+      "Atomically settle every crash-visible child call with a bound terminal checkpoint store record",
+    )
+    .requiredOption(
+      "--expected-revision <n>",
+      "Exact runtime revision shown by runtime-status",
+    )
+    .option("--json", "Machine-readable JSON output")
+    .action(async (runId, options) => {
+      try {
+        const runtime = await import("../lib/dynamic-workflow-runtime.js");
+        const statePath = runtime.dynamicWorkflowRunStatePath(
+          process.cwd(),
+          runId,
+        );
+        const state = runtime.recoverDurableWorkflowCheckpointCalls(
+          statePath,
+          { expectedRevision: options.expectedRevision },
+          Object.hasOwn(commandDeps, "workflowCheckpointStore")
+            ? { checkpointStore: commandDeps.workflowCheckpointStore }
+            : {},
+        );
+        const projection = runtime.projectDynamicWorkflowRuntime(state);
+        if (options.json) {
+          console.log(JSON.stringify(projection, null, 2));
+        } else {
+          logger.log(
+            `${projection.runId}  ${projection.status}  revision=${projection.revision}`,
+          );
+        }
+      } catch (err) {
+        logger.error(
+          `WORKFLOW_RUNTIME_RECOVER_CHECKPOINTS_FAILED: ${err.message}`,
+        );
+        process.exitCode = 2;
+      }
+    });
+
+  workflow
+    .command("runtime-reply <run-id> <request-id> <response-file>")
+    .description(
+      "Answer one revision-bound durable stage input request from a bounded JSON file",
+    )
+    .requiredOption(
+      "--expected-revision <n>",
+      "Exact runtime revision shown by runtime-status",
+    )
+    .option("--json", "Machine-readable JSON output")
+    .action(async (runId, requestId, responseFile, options) => {
+      try {
+        const runtime = await import("../lib/dynamic-workflow-runtime.js");
+        const statePath = runtime.dynamicWorkflowRunStatePath(
+          process.cwd(),
+          runId,
+        );
+        const answer =
+          runtime.readDynamicWorkflowInputResponseFile(responseFile);
+        const state = runtime.submitDurableWorkflowInput(statePath, {
+          expectedRevision: options.expectedRevision,
+          requestId,
+          answer,
+        });
+        const projection = runtime.projectDynamicWorkflowRuntime(state);
+        if (options.json) {
+          console.log(JSON.stringify(projection, null, 2));
+        } else {
+          logger.log(
+            `${projection.runId}  ${projection.status}  revision=${projection.revision}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`WORKFLOW_RUNTIME_REPLY_FAILED: ${err.message}`);
+        process.exitCode = 2;
+      }
+    });
+
   workflow
     .command("runtime-reconcile <run-id> <effect-id> <result-file>")
     .description(
@@ -1159,8 +1311,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .option("--json", "Machine-readable JSON output")
     .action(async (id, options) => {
       try {
-        const { listWorkflowVersions } =
-          await import("../lib/cowork-workflow.js");
+        const { listWorkflowVersions } = await import(
+          "../lib/cowork-workflow.js"
+        );
         const versions = listWorkflowVersions(process.cwd(), id);
         if (options.json) {
           console.log(JSON.stringify(versions, null, 2));
@@ -1405,8 +1558,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
             getVerifiedSessionExecutionLocationAuthority: descriptor.value,
           });
         } else {
-          workflowExecutionAuthorityModule =
-            import("../harness/jsonl-session-store.js");
+          workflowExecutionAuthorityModule = import(
+            "../harness/jsonl-session-store.js"
+          );
         }
         let workflowRunTaskModule;
         if (Object.hasOwn(commandDeps, "workflowRunTask")) {
@@ -1508,8 +1662,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
                   runTask: runCoworkTask,
                 });
               }
-              const runtime =
-                await import("../lib/dynamic-workflow-runtime.js");
+              const runtime = await import(
+                "../lib/dynamic-workflow-runtime.js"
+              );
               return runtime.executeDurableDynamicWorkflow(
                 {
                   statePath: runtime.dynamicWorkflowRunStatePath(
@@ -1519,7 +1674,14 @@ export function registerCoworkCommand(program, commandDeps = {}) {
                   runId: options.durableRunId,
                   execution,
                 },
-                { runTask: runCoworkTask },
+                {
+                  runTask: runCoworkTask,
+                  ...(Object.hasOwn(commandDeps, "workflowCheckpointStore")
+                    ? {
+                        checkpointStore: commandDeps.workflowCheckpointStore,
+                      }
+                    : {}),
+                },
               );
             },
           },
@@ -1667,8 +1829,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .description("Per-template aggregate stats across all runs")
     .option("--json", "Output as JSON")
     .action(async (options) => {
-      const { loadHistory, computeTemplateStats } =
-        await import("../lib/cowork-learning.js");
+      const { loadHistory, computeTemplateStats } = await import(
+        "../lib/cowork-learning.js"
+      );
       const stats = computeTemplateStats(loadHistory(process.cwd()));
       if (options.json) {
         console.log(JSON.stringify(stats, null, 2));
@@ -1701,8 +1864,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .option("--min-runs <n>", "Only consider templates with ≥N past runs", "1")
     .option("--json", "Output as JSON")
     .action(async (messageParts, options) => {
-      const { loadHistory, recommendTemplate } =
-        await import("../lib/cowork-learning.js");
+      const { loadHistory, recommendTemplate } = await import(
+        "../lib/cowork-learning.js"
+      );
       const message = messageParts.join(" ");
       const rec = recommendTemplate(message, loadHistory(process.cwd()), {
         minRuns: parseInt(options.minRuns, 10) || 1,
@@ -1731,8 +1895,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .option("--limit <n>", "Max examples per template", "3")
     .option("--json", "Output as JSON")
     .action(async (options) => {
-      const { loadHistory, summarizeFailures } =
-        await import("../lib/cowork-learning.js");
+      const { loadHistory, summarizeFailures } = await import(
+        "../lib/cowork-learning.js"
+      );
       const out = summarizeFailures(loadHistory(process.cwd()), {
         limit: parseInt(options.limit, 10) || 3,
       });
@@ -1759,8 +1924,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .description("Suggest systemPromptExtension patches from failure history")
     .option("--json", "Output as JSON")
     .action(async (options) => {
-      const { loadHistory, suggestPromptPatch } =
-        await import("../lib/cowork-learning.js");
+      const { loadHistory, suggestPromptPatch } = await import(
+        "../lib/cowork-learning.js"
+      );
       const patches = suggestPromptPatch(loadHistory(process.cwd()));
       if (options.json) {
         console.log(JSON.stringify(patches, null, 2));

package/src/commands/session-budget.js

@@ -0,0 +1,155 @@
+import {
+  adjudicateProductionSessionBudgetRecovery,
+  readProductionSessionBudget,
+  readProductionSessionBudgetRecoveryReceipts,
+} from "../lib/session-budget-production-root.js";
+
+function writeJson(value, write = console.log) {
+  write(JSON.stringify(value, null, 2));
+}
+
+function collect(value, previous) {
+  return [...previous, value];
+}
+
+function parseSettlement(value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid --settlement JSON: ${error.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Invalid --settlement JSON: expected one object");
+  }
+  return parsed;
+}
+
+export function renderSessionBudgetStatus(status) {
+  if (!status) return ["No durable session budget authority was found."];
+  const lines = [
+    `Session budget ${status.sessionId} (revision ${status.revision})`,
+    `turns ${status.totals.turns}/${status.limits.maxTurns ?? "unlimited"}; tokens ${status.totals.tokens}/${status.limits.maxTokens ?? "unlimited"}; USD ${status.totals.spentUsd}/${status.limits.maxUsd ?? "unlimited"}`,
+    `tool time ${status.totals.toolMs}/${status.limits.maxToolMs ?? "unlimited"} ms; active wall ${status.totals.elapsedMs}/${status.limits.maxWallMs ?? "unlimited"} ms`,
+    `recovery ${status.recoveryRequired ? `required (${status.pendingRecovery.length})` : "not required"}`,
+  ];
+  const adjudication = status.state?.recoveryAdjudication;
+  if (adjudication) {
+    lines.push(
+      `recovery adjudication ${adjudication.headDigest} (sequence ${adjudication.count})`,
+    );
+  }
+  for (const pending of status.pendingRecovery) {
+    lines.push(
+      `  ${pending.authorityId} ${pending.resourceType}/${pending.kind}`,
+    );
+  }
+  return lines;
+}
+
+export function renderSessionBudgetReceipts(receipts) {
+  if (!receipts) {
+    return ["No durable session budget authority was found."];
+  }
+  const retained = receipts.entries.length;
+  const lines = [
+    `Session budget recovery receipts ${receipts.sessionId} (revision ${receipts.revision})`,
+    `history ${receipts.complete ? "complete" : "partial"}; retained ${retained}/${receipts.count}; head ${receipts.headDigest || "none"}`,
+  ];
+  if (!receipts.complete && receipts.baseDigest) {
+    lines.push(
+      `  legacy prefix through sequence ${receipts.baseSequence}: ${receipts.baseDigest}`,
+    );
+  }
+  for (const receipt of receipts.entries) {
+    lines.push(
+      `  sequence ${receipt.sequence}: ${receipt.digest}; settled ${receipt.settled.length}; abandoned ${receipt.abandoned.length}; tokens ${receipt.totalsBefore.tokens}->${receipt.totalsAfter.tokens}; USD ${receipt.totalsBefore.spentUsd}->${receipt.totalsAfter.spentUsd}`,
+    );
+  }
+  return lines;
+}
+
+export function registerSessionBudgetCommands(session, dependencies = {}) {
+  const readBudget =
+    dependencies.readProductionSessionBudget || readProductionSessionBudget;
+  const readReceipts =
+    dependencies.readProductionSessionBudgetRecoveryReceipts ||
+    readProductionSessionBudgetRecoveryReceipts;
+  const adjudicate =
+    dependencies.adjudicateProductionSessionBudgetRecovery ||
+    adjudicateProductionSessionBudgetRecovery;
+  const write = dependencies.write || console.log;
+  const writeError = dependencies.writeError || console.error;
+
+  const budget = session
+    .command("budget")
+    .description("Inspect or adjudicate a durable session budget authority");
+
+  budget
+    .command("status <session-id>", { isDefault: true })
+    .description("Read the current durable session budget status")
+    .option("--json", "Output JSON")
+    .action((sessionId, options) => {
+      try {
+        const status = readBudget(sessionId);
+        if (options.json) writeJson(status, write);
+        else for (const line of renderSessionBudgetStatus(status)) write(line);
+      } catch (error) {
+        writeError(`Session budget status failed: ${error.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  budget
+    .command("recover <session-id>")
+    .description(
+      "Adjudicate every exact crash-pending authority as verified usage or abandoned",
+    )
+    .option(
+      "--abandon <authority-id...>",
+      "Exact opaque authority ids shown by session budget status",
+    )
+    .option(
+      "--settlement <json>",
+      "Repeatable verified usage JSON with authorityId, provider, model, and usage",
+      collect,
+      [],
+    )
+    .option("--json", "Output JSON")
+    .action((sessionId, options) => {
+      try {
+        const result = adjudicate(sessionId, {
+          abandoned: options.abandon || [],
+          settled: options.settlement.map(parseSettlement),
+        });
+        if (options.json) writeJson(result, write);
+        else {
+          write(
+            `Recovered session budget ${sessionId}; recorded ${result.settled.length} verified usage settlement(s), abandoned ${result.abandoned.length} exact authority id(s); adjudication ${result.adjudication.digest}.`,
+          );
+        }
+      } catch (error) {
+        writeError(`Session budget recovery failed: ${error.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  budget
+    .command("receipts <session-id>")
+    .description(
+      "Read canonical content-free recovery receipts retained by the durable budget",
+    )
+    .option("--json", "Output JSON")
+    .action((sessionId, options) => {
+      try {
+        const receipts = readReceipts(sessionId);
+        if (options.json) writeJson(receipts, write);
+        else {
+          for (const line of renderSessionBudgetReceipts(receipts)) write(line);
+        }
+      } catch (error) {
+        writeError(`Session budget receipts failed: ${error.message}`);
+        process.exitCode = 1;
+      }
+    });
+}