chainlesschain 0.165.3 → 0.165.5

package/src/commands/cowork.js

@@ -1009,15 +1009,24 @@ export function registerCoworkCommand(program, commandDeps = {}) {
   workflow
     .command("runtime-status <run-id>")
     .description("Read a durable workflow run without invoking a task provider")
+    .option("--cwd <path>", "Project root containing the durable run")
     .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(),
+          options.cwd || 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,12 +1040,65 @@ 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;
       }
     });
 
+  workflow
+    .command("runtime-recovery-plan")
+    .description(
+      "Dry-run the bounded startup/periodic recovery policy for this project",
+    )
+    .option("--cwd <path>", "Project root containing durable runs")
+    .option("-n, --limit <n>", "Maximum durable runs to inspect", "100")
+    .option("--json", "Machine-readable JSON output")
+    .action(async (options) => {
+      try {
+        const runtime = await import("../lib/dynamic-workflow-runtime.js");
+        const plan = runtime.buildDynamicWorkflowRecoveryPlan(
+          options.cwd || process.cwd(),
+          {
+            limit: Math.max(1, parseInt(options.limit) || 100),
+            ...(Object.hasOwn(commandDeps, "workflowCheckpointStore")
+              ? { checkpointStore: commandDeps.workflowCheckpointStore }
+              : {}),
+          },
+        );
+        if (options.json) {
+          console.log(JSON.stringify(plan, null, 2));
+          return;
+        }
+        logger.log(
+          `${plan.summary.attention}/${plan.summary.total} durable runs need attention; plan ${plan.planDigest}`,
+        );
+        for (const item of plan.items.filter(
+          (entry) => entry.risk !== "none",
+        )) {
+          logger.log(
+            `  ${item.runId}  ${item.risk}  action=${item.recommendedAction}  revision=${item.revision}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`WORKFLOW_RUNTIME_RECOVERY_PLAN_FAILED: ${err.message}`);
+        process.exitCode = 2;
+      }
+    });
+
   for (const action of ["pause", "stop", "resume"]) {
     workflow
       .command(`runtime-${action} <run-id>`)
@@ -1047,12 +1109,13 @@ export function registerCoworkCommand(program, commandDeps = {}) {
         "--expected-revision <n>",
         "Exact runtime revision shown by runtime-status",
       )
+      .option("--cwd <path>", "Project root containing the durable run")
       .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(),
+            options.cwd || process.cwd(),
             runId,
           );
           const operation =
@@ -1079,6 +1142,130 @@ 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("--cwd <path>", "Project root containing the durable run")
+    .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(
+          options.cwd || 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("--cwd <path>", "Project root containing the durable run")
+    .option("--json", "Machine-readable JSON output")
+    .action(async (runId, options) => {
+      try {
+        const runtime = await import("../lib/dynamic-workflow-runtime.js");
+        const statePath = runtime.dynamicWorkflowRunStatePath(
+          options.cwd || 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("--cwd <path>", "Project root containing the durable run")
+    .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(
+          options.cwd || 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(
@@ -1088,12 +1275,13 @@ export function registerCoworkCommand(program, commandDeps = {}) {
       "--expected-revision <n>",
       "Exact runtime revision shown by runtime-status",
     )
+    .option("--cwd <path>", "Project root containing the durable run")
     .option("--json", "Machine-readable JSON output")
     .action(async (runId, effectId, resultFile, options) => {
       try {
         const runtime = await import("../lib/dynamic-workflow-runtime.js");
         const statePath = runtime.dynamicWorkflowRunStatePath(
-          process.cwd(),
+          options.cwd || process.cwd(),
           runId,
         );
         const result = runtime.readDynamicWorkflowEffectResultFile(resultFile);
@@ -1519,7 +1707,14 @@ export function registerCoworkCommand(program, commandDeps = {}) {
                   runId: options.durableRunId,
                   execution,
                 },
-                { runTask: runCoworkTask },
+                {
+                  runTask: runCoworkTask,
+                  ...(Object.hasOwn(commandDeps, "workflowCheckpointStore")
+                    ? {
+                        checkpointStore: commandDeps.workflowCheckpointStore,
+                      }
+                    : {}),
+                },
               );
             },
           },

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;
+      }
+    });
+}