chainlesschain 0.165.1 → 0.165.3

package/src/lib/cowork-task-runner.js

@@ -58,6 +58,7 @@ export const _deps = {
 
 const DEFAULT_MAX_ITERATIONS = 50;
 const DEFAULT_TOKEN_BUDGET = 100_000;
+const WORKFLOW_EFFECT_ID_RE = /^sha256:[a-f0-9]{64}$/;
 const COWORK_MCP_CALL_LEDGER_UNSUPPORTED =
   "CC_COWORK_MCP_CALL_LEDGER_UNSUPPORTED";
 const COWORK_MCP_SESSION_UNVERIFIED = "CC_COWORK_MCP_SESSION_UNVERIFIED";
@@ -74,6 +75,44 @@ function coworkMcpAdmissionError(code, message, sessionId, cause = null) {
   return error;
 }
 
+function assertWorkflowEffectId(value) {
+  if (value == null) return;
+  if (typeof value !== "string" || !WORKFLOW_EFFECT_ID_RE.test(value)) {
+    const error = new TypeError(
+      "workflowEffectId must be a canonical sha256 identity",
+    );
+    error.code = "CC_COWORK_WORKFLOW_EFFECT_ID_INVALID";
+    throw error;
+  }
+}
+
+function workflowEffectEvidence(subAgent, workflowEffectId) {
+  if (!workflowEffectId) return {};
+  const attempts =
+    typeof subAgent?.providerRequestAttempts === "function"
+      ? subAgent.providerRequestAttempts()
+      : [];
+  const receipts =
+    typeof subAgent?.providerRequestReceipts === "function"
+      ? subAgent.providerRequestReceipts()
+      : [];
+  const nestedEffectAttempts =
+    typeof subAgent?.nestedEffectAttempts === "function"
+      ? subAgent.nestedEffectAttempts()
+      : [];
+  const nestedEffectSettlements =
+    typeof subAgent?.nestedEffectSettlements === "function"
+      ? subAgent.nestedEffectSettlements()
+      : [];
+  return {
+    workflowEffectId,
+    providerRequestAttempts: attempts,
+    providerRequestReceipts: receipts,
+    nestedEffectAttempts,
+    nestedEffectSettlements,
+  };
+}
+
 function assertCoworkMcpEventUsageAdmission(event, sessionId) {
   if (event?.type !== "session_start") return;
   const data =
@@ -477,6 +516,12 @@ export function prepareCoworkMcpRuntime(mcp, options = {}) {
  * @param {number} [options.maxIterations] - Override iteration limit
  * @param {number} [options.tokenBudget] - Override token budget
  * @param {string} [options.mcpSessionId] - Stable MCP ledger session for resume
+ * @param {string} [options.workflowEffectId] - Canonical durable workflow effect
+ * @param {boolean} [options.strictUsageTelemetry] - Require synchronous durable call observers
+ * @param {function} [options.onUsageBoundary] - Provider-call durable start observer
+ * @param {function} [options.onUsageSettlement] - Provider-call durable settlement observer
+ * @param {function} [options.onToolCallBoundary] - Tool-call durable start observer
+ * @param {function} [options.onToolCallSettlement] - Tool-call durable settlement observer
  * @param {(request: object) => boolean|Promise<boolean>} [options.approveMcpLocalCodeExecution]
  * @returns {Promise<{ taskId: string, status: string, result: object }>}
  */
@@ -493,12 +538,19 @@ export async function runCoworkTask(options = {}) {
     onProgress = null,
     signal = null,
     mcpSessionId = null,
+    workflowEffectId = null,
+    strictUsageTelemetry = false,
+    onUsageBoundary = null,
+    onUsageSettlement = null,
+    onToolCallBoundary = null,
+    onToolCallSettlement = null,
     approveMcpLocalCodeExecution = null,
   } = options;
 
   if (!userMessage || typeof userMessage !== "string") {
     throw new Error("userMessage is required");
   }
+  assertWorkflowEffectId(workflowEffectId);
 
   // An explicit canonical authority must be admitted before mounting local MCP
   // servers, constructing a child context, or making any provider call.
@@ -582,6 +634,16 @@ export async function runCoworkTask(options = {}) {
       cwd,
       onProgress,
       signal,
+      ...(workflowEffectId ? { workflowEffectId } : {}),
+      ...(strictUsageTelemetry
+        ? {
+            strictUsageTelemetry: true,
+            onUsageBoundary,
+            onUsageSettlement,
+            onToolCallBoundary,
+            onToolCallSettlement,
+          }
+        : {}),
       extraToolDefinitions: mcp.extraToolDefinitions,
       externalToolDescriptors: mcp.externalToolDescriptors,
       externalToolExecutors: mcp.externalToolExecutors,
@@ -632,17 +694,25 @@ export async function runCoworkTask(options = {}) {
         templateId: template.id,
         templateName: template.name,
         ...(mcpRuntime.sessionId ? { mcpSessionId: mcpRuntime.sessionId } : {}),
+        ...workflowEffectEvidence(subAgent, workflowEffectId),
         result,
       };
       _appendHistory(cwd, entry, userMessage);
       return entry;
     } catch (err) {
+      // A durable workflow already marked this outer effect as dispatched.
+      // Converting a child/provider exception into an ordinary failed result
+      // would authorize the step retry path even though the physical provider
+      // outcome may be unknown. Propagate so the runtime keeps it pending and
+      // requires reconciliation.
+      if (workflowEffectId) throw err;
       const entry = {
         taskId,
         status: "failed",
         templateId: template.id,
         templateName: template.name,
         ...(mcpRuntime.sessionId ? { mcpSessionId: mcpRuntime.sessionId } : {}),
+        ...workflowEffectEvidence(subAgent, workflowEffectId),
         result: {
           summary: `Task failed: ${err.message}`,
           artifacts: [],

package/src/lib/cowork-workflow.js

@@ -66,6 +66,8 @@ export const COWORK_WORKFLOW_RUN_ADMISSION_INVALID_CODE =
   "COWORK_WORKFLOW_RUN_ADMISSION_INVALID";
 export const COWORK_WORKFLOW_RUN_RESULT_INVALID_CODE =
   "COWORK_WORKFLOW_RUN_RESULT_INVALID";
+export const COWORK_WORKFLOW_CONTROL_SIGNAL_CODE =
+  "COWORK_WORKFLOW_CONTROL_SIGNAL";
 
 const DYNAMIC_WORKFLOW_RUN_ADMISSION_SCHEMA =
   "cc-dynamic-workflow-run-admission/v1";
@@ -484,7 +486,9 @@ function normalizeWorkflowRunAdmission(
     authority.definitionDigest !== definitionDigest ||
     value.executionLocation.authoritySchema !==
       EXECUTION_LOCATION_AUTHORITY_SCHEMA ||
-    value.executionLocation.authority !== "verified-session-start" ||
+    !["verified-session-start", "verified-session-location-handoff"].includes(
+      value.executionLocation.authority,
+    ) ||
     value.executionLocation.bindingSchema !==
       EXECUTION_LOCATION_BINDING_SCHEMA ||
     typeof value.executionLocation.location !== "string" ||
@@ -534,7 +538,7 @@ function normalizeWorkflowRunAdmission(
     }),
     executionLocation: Object.freeze({
       authoritySchema: EXECUTION_LOCATION_AUTHORITY_SCHEMA,
-      authority: "verified-session-start",
+      authority: value.executionLocation.authority,
       session: Object.freeze({
         sessionId: session.sessionId,
         headHash: session.headHash,
@@ -1307,6 +1311,7 @@ export async function runStepWithRetry({
   taskSemaphore,
   runTask = _deps.runTask,
   recordId = step.id,
+  iteration = 1,
   onTaskStart,
   admitted = false,
 }) {
@@ -1336,6 +1341,12 @@ export async function runStepWithRetry({
           files: step.files || [],
           cwd,
           llmOptions,
+          workflowEffect: Object.freeze({
+            stepId: recordId,
+            iteration,
+            attempt,
+            timeoutMs,
+          }),
           ...(abortController ? { signal: abortController.signal } : {}),
         }),
       );
@@ -1353,20 +1364,38 @@ export async function runStepWithRetry({
       lastErr = null;
     } catch (err) {
       if (release) release();
+      if (err?.code === COWORK_WORKFLOW_CONTROL_SIGNAL_CODE) throw err;
       if (err?.code === COWORK_WORKFLOW_RUN_RESULT_INVALID_CODE) throw err;
       if (admitted && err?.code === STEP_TIMEOUT_CODE && taskPromise != null) {
         abortController.abort(err);
         // A terminal admitted record must never be written while the physical
         // task can still produce side effects. Confirm settlement before a
         // retry or final failure; a runner that ignores abort safely blocks.
+        // A late completed result is authoritative and must not be replayed.
         try {
-          await taskPromise;
-        } catch {
-          // The timeout remains the attempt's externally visible failure.
+          const lateRawEntry = await taskPromise;
+          const lateEntry = normalizeAdmittedTaskEntry(lateRawEntry);
+          if (lateEntry.status === "completed") {
+            return { ok: true, entry: lateEntry, attempts: attempt };
+          }
+          lastEntry = lateEntry;
+          lastErr = null;
+        } catch (lateError) {
+          if (
+            lateError?.code === COWORK_WORKFLOW_CONTROL_SIGNAL_CODE ||
+            lateError?.code === COWORK_WORKFLOW_RUN_RESULT_INVALID_CODE
+          ) {
+            throw lateError;
+          }
+          // The timeout remains the attempt's externally visible failure when
+          // a non-authoritative runner error arrives after the deadline.
+          lastErr = err;
+          lastEntry = null;
         }
+      } else {
+        lastErr = err; // threw or timed out → retry-eligible
+        lastEntry = null;
       }
-      lastErr = err; // threw or timed out → retry-eligible
-      lastEntry = null;
     }
     if (attempt <= maxRetries) {
       const delay = retryDelayFor(step, attempt);
@@ -1503,6 +1532,7 @@ export async function runLoopStep({
       taskSemaphore,
       runTask,
       recordId,
+      iteration: iter,
       onTaskStart: (event) => {
         if (startAnnounced) return;
         startAnnounced = true;
@@ -1760,8 +1790,11 @@ export async function runPipeline({
           admitted,
         });
       } catch (err) {
-        if (err?.code === COWORK_WORKFLOW_RUN_RESULT_INVALID_CODE) {
-          fatalError = err;
+        if (
+          err?.code === COWORK_WORKFLOW_RUN_RESULT_INVALID_CODE ||
+          err?.code === COWORK_WORKFLOW_CONTROL_SIGNAL_CODE
+        ) {
+          fatalError ||= err;
           halted = true;
           active--;
           pump();

package/src/lib/doctor-checkup.js

@@ -462,7 +462,6 @@ async function pluginSection(opts, _deps2) {
   const checks = [];
   try {
     const { listInstalled } = await import("./plugin-runtime/install.js");
-    const { readPluginLock } = await import("./plugin-runtime/signature.js");
     const plugins = listInstalled({ cwd: opts.cwd || process.cwd() }) || [];
     if (plugins.length === 0) {
       checks.push(
@@ -475,22 +474,47 @@ async function pluginSection(opts, _deps2) {
       );
     } else {
       let unsigned = 0;
+      const runtimeBlocked = [];
+      const retainedRecovery = [];
       for (const p of plugins) {
-        try {
-          const lock = p.dir ? readPluginLock(p.dir) : null;
-          if (!lock || !lock.signature) unsigned++;
-        } catch {
-          unsigned++;
+        if (p.activePointer?.recoveryPath) {
+          retainedRecovery.push(`${p.name} (${p.activePointer.recoveryPath})`);
+        }
+        if (p.runtimeBlocked === true) {
+          runtimeBlocked.push(
+            `${p.name} (${p.activePointer?.status || "unknown pointer state"})`,
+          );
+          continue;
         }
+        if (p.integrity?.signature?.present !== true) unsigned++;
       }
       checks.push(
         check(
           "plugins",
           `Installed plugins: ${plugins.length}`,
-          unsigned > 0 ? CHECK_LEVELS.WARN : CHECK_LEVELS.OK,
-          unsigned > 0
-            ? `${unsigned} without a signature lock — they will be refused if plugins.requireSignedPlugins is enabled`
-            : "all have signature locks",
+          unsigned > 0 ||
+            runtimeBlocked.length > 0 ||
+            retainedRecovery.length > 0
+            ? CHECK_LEVELS.WARN
+            : CHECK_LEVELS.OK,
+          [
+            runtimeBlocked.length > 0
+              ? `runtime blocked: ${runtimeBlocked.join(", ")}`
+              : null,
+            retainedRecovery.length > 0
+              ? `retained install recovery: ${retainedRecovery.join(", ")}; remove the blocked plugin before another mutation`
+              : null,
+            unsigned > 0
+              ? `${unsigned} active without a signature lock — they will be refused if plugins.requireSignedPlugins is enabled`
+              : null,
+            runtimeBlocked.length === 0 &&
+            retainedRecovery.length === 0 &&
+            unsigned === 0
+              ? "all active plugins have signature locks"
+              : null,
+          ]
+            .filter(Boolean)
+            .join("; "),
         ),
       );
     }