chainlesschain 0.166.6 → 0.166.9

package/src/lib/cowork-graph-authority-adapter.js

@@ -0,0 +1,455 @@
+import { randomUUID } from "node:crypto";
+import {
+  compileGraphDefinition,
+  graphDigest,
+} from "./graph-kernel/compiler.js";
+import { createGraphAuthorityBinding } from "./graph-kernel/authority.js";
+import { createRuntimeGraphCutoverAuthorityResolver } from "./graph-kernel/cutover-authority-resolver.js";
+import { GraphEventStore } from "./graph-kernel/event-store.js";
+import { GraphKernel } from "./graph-kernel/runtime.js";
+
+function adapterError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "CoworkGraphAuthorityError";
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+}
+
+export function coworkGraphAuthorityMode(env = process.env) {
+  const value = String(env.CHAINLESSCHAIN_GRAPH_COWORK || "legacy")
+    .trim()
+    .toLowerCase();
+  if (!["legacy", "shadow", "canonical"].includes(value)) {
+    throw adapterError(
+      "CC_GRAPH_AUTHORITY_MODE_INVALID",
+      "CHAINLESSCHAIN_GRAPH_COWORK must be legacy, shadow, or canonical",
+    );
+  }
+  return value;
+}
+
+function graphDefinition(workflow, admission) {
+  return compileGraphDefinition({
+    schemaVersion: 1,
+    id: `cowork:${String(workflow.id || workflow.name || "workflow").replace(
+      /[^A-Za-z0-9._:/-]/gu,
+      "-",
+    )}`,
+    revision: 1,
+    nodes: [
+      {
+        id: "dynamic-workflow",
+        kind: "task",
+        dependsOn: [],
+        inputs: [],
+        outputs: [],
+        effectClass: "external",
+        idempotencyKey: `cowork:${admission.admissionDigest}`,
+        retryLimit: 0,
+      },
+    ],
+    edges: [],
+    loops: [],
+    subgraphCalls: [],
+    budget: { turns: 1 },
+    allowedCapabilities: [],
+    metadata: {
+      originSurface: "cowork",
+      definitionDigest: admission.definitionDigest,
+      admissionDigest: admission.admissionDigest,
+      delegatedRuntime: "dynamic_workflow_runtime",
+    },
+  });
+}
+
+export class CoworkGraphAuthorityAdapter {
+  constructor({
+    mode = undefined,
+    authorityResolver = undefined,
+    optIn = false,
+    eventStore = new GraphEventStore(),
+    now = Date.now,
+    createId = randomUUID,
+    writerLeaseTtlMs = 24 * 60 * 60 * 1000,
+  } = {}) {
+    this.mode = mode === undefined ? coworkGraphAuthorityMode() : mode;
+    if (!["legacy", "shadow", "canonical"].includes(this.mode)) {
+      throw adapterError(
+        "CC_GRAPH_AUTHORITY_MODE_INVALID",
+        "Cowork Graph authority mode is invalid",
+      );
+    }
+    this.authorityResolver =
+      authorityResolver ||
+      createRuntimeGraphCutoverAuthorityResolver({
+        surface: "cowork",
+        entryId: "cli-cowork",
+        fallbackMode: this.mode,
+      });
+    this.optIn = optIn === true;
+    this.eventStore = eventStore;
+    this.resultStore = eventStore.rolloutStore;
+    this.now = now;
+    this.createId = createId;
+    this.writerLeaseTtlMs = writerLeaseTtlMs;
+    this.active = new Map();
+  }
+
+  _modeFor(runKey) {
+    const resolved =
+      typeof this.authorityResolver === "function"
+        ? this.authorityResolver({ runKey, optIn: this.optIn })
+        : this.authorityResolver.resolve({ runKey, optIn: this.optIn });
+    const mode = typeof resolved === "string" ? resolved : resolved?.mode;
+    if (!["legacy", "shadow", "canonical"].includes(mode)) {
+      throw adapterError(
+        "CC_GRAPH_AUTHORITY_MODE_INVALID",
+        "Cowork Graph authority resolver returned an invalid mode",
+      );
+    }
+    return mode;
+  }
+
+  runtimeClaims() {
+    return Object.freeze({
+      originSurface: "cowork",
+      surface: "cowork",
+      execution: "real",
+      persistence: "durable",
+      isolated: true,
+      terminalEvidence: true,
+      authorityModes: Object.freeze(["shadow", "canonical"]),
+      featureGated: true,
+    });
+  }
+
+  _resultThread(runId) {
+    return `cowork-result:${runId}`;
+  }
+
+  _resultReceipt(runId, { allowMissing = false } = {}) {
+    let events;
+    try {
+      events = this.resultStore.read(this._resultThread(runId));
+    } catch (error) {
+      if (allowMissing && error?.code === "CC_ROLLOUT_THREAD_NOT_FOUND") {
+        return null;
+      }
+      throw adapterError(
+        "CC_COWORK_GRAPH_RECEIPT_MISSING",
+        "canonical Cowork result receipt is missing",
+        { cause: error },
+      );
+    }
+    const receipt = [...events]
+      .reverse()
+      .find((event) => event.event_type === "cowork.result.committed");
+    if (
+      !receipt ||
+      graphDigest(receipt.payload?.record, "cc.cowork.workflow-result/v1") !==
+        receipt.payload?.outputDigest
+    ) {
+      throw adapterError(
+        "CC_COWORK_GRAPH_RECEIPT_FORGED",
+        "canonical Cowork result receipt does not match terminal evidence",
+      );
+    }
+    return Object.freeze({
+      outputDigest: receipt.payload.outputDigest,
+      receiptDigest: receipt.hash,
+      record: receipt.payload.record,
+    });
+  }
+
+  _readResult(runId, expectedDigest) {
+    const receipt = this._resultReceipt(runId);
+    if (receipt.outputDigest !== expectedDigest) {
+      throw adapterError(
+        "CC_COWORK_GRAPH_RECEIPT_FORGED",
+        "canonical Cowork result receipt does not match terminal evidence",
+      );
+    }
+    return receipt.record;
+  }
+
+  begin({ workflow, admission }) {
+    const runId = `cowork:${admission.admissionDigest.slice(7, 55)}`;
+    const compiled = graphDefinition(workflow, admission);
+    let events = [];
+    try {
+      events = this.eventStore.read(runId);
+    } catch (error) {
+      if (error?.code !== "CC_ROLLOUT_THREAD_NOT_FOUND") throw error;
+    }
+    const previous = [...events]
+      .reverse()
+      .find((event) => event.payload?.state?.authority)?.payload
+      .state.authority;
+    const mode = previous?.authorityMode || this._modeFor(runId);
+    if (mode === "legacy") return null;
+    const generation = previous ? Number(previous.authorityGeneration) + 1 : 1;
+    const authoritySource =
+      mode === "shadow" ? "graph_kernel_shadow" : "graph_kernel";
+    const writerId = `cowork-writer:${process.pid}:${generation}`;
+    const writerLeaseId = `cowork-lease:${this.createId()}`;
+    const kernel = new GraphKernel({
+      eventStore: this.eventStore,
+      now: this.now,
+      writerId,
+      writerLeaseId,
+      authoritySource,
+      authorityGeneration: generation,
+      writerLeaseTtlMs: this.writerLeaseTtlMs,
+    });
+    let projection;
+    if (!events.length) {
+      projection = kernel.startRun(compiled, {
+        runId,
+        originSurface: "cowork",
+      });
+    } else {
+      const latest = events.at(-1);
+      projection = kernel.recoverRun(runId, {
+        authority: createGraphAuthorityBinding({
+          ...previous,
+          authorityGeneration: generation,
+          writerId,
+          writerLeaseId,
+          writerLeaseExpiresAt: new Date(
+            this.now() + this.writerLeaseTtlMs,
+          ).toISOString(),
+          eventHead: latest.hash,
+        }),
+      });
+      if (projection.revisionDigest !== compiled.revisionDigest) {
+        throw adapterError(
+          "CC_COWORK_GRAPH_REVISION_CONFLICT",
+          "Cowork Graph revision changed during recovery",
+        );
+      }
+    }
+    if (projection.status === "succeeded") {
+      const accepted = projection.attempts.find(
+        (attempt) => attempt.status === "accepted",
+      );
+      const outputDigest = accepted?.terminalEvidence?.outputDigest;
+      if (!outputDigest) {
+        throw adapterError(
+          "CC_COWORK_GRAPH_RECEIPT_MISSING",
+          "successful Cowork Graph has no output digest",
+        );
+      }
+      const record = this._readResult(runId, outputDigest);
+      return Object.freeze({
+        runId,
+        authorityMode: mode,
+        alreadySettled: mode === "canonical",
+        compareOnly: mode === "shadow",
+        outputDigest,
+        projection,
+        record,
+      });
+    }
+    if (projection.status === "reconciliation_required") {
+      const durableResult = this._resultReceipt(runId, { allowMissing: true });
+      if (!durableResult || projection.reconciliationEffectIds.length !== 1) {
+        throw adapterError(
+          "CC_GRAPH_RECONCILIATION_REQUIRED",
+          "Cowork workflow effect outcome requires reconciliation",
+          { graphRunId: runId },
+        );
+      }
+      kernel.reconcileEffect(runId, {
+        effectId: projection.reconciliationEffectIds[0],
+        decision: "committed",
+        receipt: { receiptDigest: durableResult.receiptDigest },
+        auditDecisionId: `cowork-result-receipt:${durableResult.outputDigest.slice(
+          7,
+          39,
+        )}`,
+      });
+      projection = kernel.getRun(runId);
+    }
+    const durableResult = this._resultReceipt(runId, { allowMissing: true });
+    const recoverableAttempt = projection.attempts.find(
+      (attempt) =>
+        attempt.nodeId === "dynamic-workflow" && attempt.status === "active",
+    );
+    if (durableResult && recoverableAttempt) {
+      const settlementAttempt =
+        recoverableAttempt.authorityGeneration ===
+          projection.authorityGeneration &&
+        recoverableAttempt.writerId === projection.writerId
+          ? recoverableAttempt
+          : kernel.resumeAttempt(runId, recoverableAttempt.id, {
+              resumedAttemptId: `cowork-recovery-attempt:${this.createId()}`,
+              leaseId: `cowork-recovery-lease:${this.createId()}`,
+              ttlMs: this.writerLeaseTtlMs,
+              reason: "durable Cowork result recovered after writer takeover",
+            });
+      kernel.settleAttempt(runId, {
+        attemptId: settlementAttempt.id,
+        leaseId: settlementAttempt.leaseId,
+        fence: settlementAttempt.fence,
+        outcome: "succeeded",
+        evidence: { outputDigest: durableResult.outputDigest },
+        usage: { turns: 1 },
+      });
+      projection = kernel.getRun(runId);
+      return Object.freeze({
+        runId,
+        authorityMode: mode,
+        alreadySettled: mode === "canonical",
+        compareOnly: mode === "shadow",
+        outputDigest: durableResult.outputDigest,
+        projection,
+        record: durableResult.record,
+      });
+    }
+    if (projection.phase === "open") {
+      kernel.registerAgent(runId, {
+        agentId: "cowork-runtime",
+        capacity: 1,
+        resident: true,
+      });
+      kernel.sealRun(runId);
+    }
+    const attempt = kernel.assignNode(
+      runId,
+      "dynamic-workflow",
+      "cowork-runtime",
+      {
+        ttlMs: this.writerLeaseTtlMs,
+        leaseId: `cowork-attempt:${this.createId()}`,
+        grant: {
+          definitionDigest: admission.definitionDigest,
+          admissionDigest: admission.admissionDigest,
+        },
+      },
+    );
+    const effect = kernel.beginEffect(runId, {
+      effectId: `cowork-effect:${attempt.id}`,
+      attemptId: attempt.id,
+      leaseId: attempt.leaseId,
+      fence: attempt.fence,
+      idempotencyKey: attempt.effectIdempotencyKey,
+      operationDigest: graphDigest(
+        {
+          definitionDigest: admission.definitionDigest,
+          admissionDigest: admission.admissionDigest,
+        },
+        "cc.cowork.workflow-operation/v1",
+      ),
+    });
+    this.active.set(runId, {
+      runId,
+      authorityMode: mode,
+      kernel,
+      attempt,
+      effect,
+    });
+    if (durableResult) {
+      const settled = this.settleSuccess(
+        { runId, authorityMode: mode, alreadySettled: false, projection },
+        durableResult.record,
+      );
+      return Object.freeze({
+        runId,
+        authorityMode: mode,
+        alreadySettled: mode === "canonical",
+        compareOnly: mode === "shadow",
+        outputDigest: durableResult.outputDigest,
+        projection: settled,
+        record: durableResult.record,
+      });
+    }
+    return Object.freeze({
+      runId,
+      authorityMode: mode,
+      alreadySettled: false,
+      projection,
+    });
+  }
+
+  settleSuccess(claim, record) {
+    if (!claim || claim.authorityMode === "legacy") return null;
+    const outputDigest = graphDigest(record, "cc.cowork.workflow-result/v1");
+    if (claim.compareOnly === true) {
+      if (outputDigest !== claim.outputDigest) {
+        throw adapterError(
+          "CC_COWORK_GRAPH_SHADOW_DIVERGENCE",
+          "Cowork shadow result diverged from persisted Graph evidence",
+          { expectedDigest: claim.outputDigest, actualDigest: outputDigest },
+        );
+      }
+      return claim.projection;
+    }
+    const active = this.active.get(claim.runId);
+    if (!active) {
+      throw adapterError(
+        "CC_COWORK_GRAPH_ATTEMPT_MISSING",
+        "Cowork Graph attempt is not active",
+      );
+    }
+    const threadId = this._resultThread(claim.runId);
+    this.resultStore.start({
+      threadId,
+      title: `Cowork Graph result ${claim.runId}`,
+      metadata: { kind: "cowork_graph_result", graphRunId: claim.runId },
+    });
+    const events = this.resultStore.read(threadId);
+    const receipt = this.resultStore.append({
+      threadId,
+      eventType: "cowork.result.committed",
+      idempotencyKey: `cowork-result:${claim.runId}`,
+      payload: { outputDigest, record },
+      expectedRevision: events.at(-1)?.event_seq,
+      expectedHeadHash: events.at(-1)?.hash,
+    });
+    active.kernel.settleEffect(claim.runId, {
+      effectId: active.effect.id,
+      attemptId: active.attempt.id,
+      leaseId: active.attempt.leaseId,
+      fence: active.attempt.fence,
+      outcome: "committed",
+      receipt: { receiptDigest: receipt.hash },
+    });
+    active.kernel.settleAttempt(claim.runId, {
+      attemptId: active.attempt.id,
+      leaseId: active.attempt.leaseId,
+      fence: active.attempt.fence,
+      outcome: "succeeded",
+      evidence: { outputDigest },
+      usage: { turns: 1 },
+    });
+    this.active.delete(claim.runId);
+    return active.kernel.getRun(claim.runId);
+  }
+
+  settleFailure(claim, error) {
+    if (!claim || claim.authorityMode === "legacy") return null;
+    const active = this.active.get(claim.runId);
+    if (!active) return null;
+    const outcomeKnown = error?.outcomeKnown === true;
+    active.kernel.settleEffect(claim.runId, {
+      effectId: active.effect.id,
+      attemptId: active.attempt.id,
+      leaseId: active.attempt.leaseId,
+      fence: active.attempt.fence,
+      outcome: outcomeKnown ? "failed" : "unknown",
+    });
+    if (outcomeKnown) {
+      active.kernel.settleAttempt(claim.runId, {
+        attemptId: active.attempt.id,
+        leaseId: active.attempt.leaseId,
+        fence: active.attempt.fence,
+        outcome: "failed",
+        error: error?.message || String(error),
+        usage: { turns: 1 },
+      });
+    }
+    this.active.delete(claim.runId);
+    return active.kernel.getRun(claim.runId);
+  }
+}

package/src/lib/dynamic-workflow-facade.js

@@ -24,6 +24,7 @@ import {
   normalizeWorkflowDefinitionDigest,
 } from "./workflow-definition-contract.js";
 import { canonicalJson } from "./scheduler-kernel/contract.js";
+import { CoworkGraphAuthorityAdapter } from "./cowork-graph-authority-adapter.js";
 
 export const DYNAMIC_WORKFLOW_DEFINITION_SCHEMA = WORKFLOW_DEFINITION_SCHEMA;
 export const DYNAMIC_WORKFLOW_PREFLIGHT_SCHEMA =
@@ -100,7 +101,11 @@ const RUN_INPUT_FIELDS = new Set([
   "execution",
   "onAdmitted",
 ]);
-const RUN_DEPENDENCY_FIELDS = new Set(["executeWorkflow", "verifyAuthorities"]);
+const RUN_DEPENDENCY_FIELDS = new Set([
+  "executeWorkflow",
+  "graphAuthorityAdapter",
+  "verifyAuthorities",
+]);
 const VERIFIED_AUTHORITIES_FIELDS = new Set([
   "definitionAuthority",
   "executionLocationAuthority",
@@ -1003,6 +1008,19 @@ function normalizeRunDependencies(deps) {
       "executeWorkflow dependency must be a function",
     );
   }
+  if (
+    Object.hasOwn(snapshot, "graphAuthorityAdapter") &&
+    (!snapshot.graphAuthorityAdapter ||
+      typeof snapshot.graphAuthorityAdapter.begin !== "function" ||
+      typeof snapshot.graphAuthorityAdapter.settleSuccess !== "function" ||
+      typeof snapshot.graphAuthorityAdapter.settleFailure !== "function" ||
+      utilTypes.isProxy(snapshot.graphAuthorityAdapter))
+  ) {
+    throw admissionError(
+      DYNAMIC_WORKFLOW_EXECUTION_OPTIONS_INVALID_CODE,
+      "graphAuthorityAdapter dependency is invalid",
+    );
+  }
   return snapshot;
 }
 
@@ -1480,28 +1498,77 @@ export async function executeDynamicWorkflowWithAdmission(
       prepared.outcome.preflight,
     );
   }
-  const policy = prepared.outcome.admission.executionPolicy;
-  const record = await executor({
-    cwd: policy.cwd,
-    continueOnError: policy.continueOnError,
-    pipeline: policy.pipeline,
-    llmOptions: Object.freeze({
-      provider: policy.provider,
-      model: policy.model,
-    }),
-    onStepStart: execution.onStepStart,
-    onStepComplete: execution.onStepComplete,
+  const graphAuthorityAdapter = Object.hasOwn(
+    dependencies,
+    "graphAuthorityAdapter",
+  )
+    ? dependencies.graphAuthorityAdapter
+    : new CoworkGraphAuthorityAdapter();
+  const graphClaim = graphAuthorityAdapter.begin({
     workflow: prepared.workflow,
-    definitionDigest: prepared.outcome.admission.definitionDigest,
-    maxParallel: prepared.outcome.admission.maxParallel,
-    runAdmission: prepared.outcome.admission,
+    admission: prepared.outcome.admission,
   });
-  const normalizedRecord = normalizeExecutionRecord(record, prepared);
+  const graphAuthorityMode = graphClaim?.authorityMode || "legacy";
+  if (graphClaim?.alreadySettled === true) {
+    const normalizedRecord = normalizeExecutionRecord(
+      graphClaim.record,
+      prepared,
+    );
+    return Object.freeze({
+      ...prepared.outcome,
+      record: normalizedRecord,
+      executionStarted: false,
+      graphAuthority: graphClaim.projection,
+      graphAuthorityMode,
+      graphRecovered: true,
+    });
+  }
+  const policy = prepared.outcome.admission.executionPolicy;
+  let normalizedRecord;
+  let graphProjection = graphClaim?.projection ?? null;
+  try {
+    const record = await executor({
+      cwd: policy.cwd,
+      continueOnError: policy.continueOnError,
+      pipeline: policy.pipeline,
+      llmOptions: Object.freeze({
+        provider: policy.provider,
+        model: policy.model,
+      }),
+      onStepStart: execution.onStepStart,
+      onStepComplete: execution.onStepComplete,
+      workflow: prepared.workflow,
+      definitionDigest: prepared.outcome.admission.definitionDigest,
+      maxParallel: prepared.outcome.admission.maxParallel,
+      runAdmission: prepared.outcome.admission,
+    });
+    normalizedRecord = normalizeExecutionRecord(record, prepared);
+    graphProjection =
+      graphAuthorityAdapter.settleSuccess(graphClaim, normalizedRecord) ??
+      graphProjection;
+  } catch (error) {
+    const failureProjection = graphAuthorityAdapter.settleFailure(
+      graphClaim,
+      error,
+    );
+    if (
+      graphAuthorityMode === "canonical" &&
+      failureProjection?.status === "reconciliation_required"
+    ) {
+      error.graphRunId = graphClaim?.runId;
+      error.graphAuthority = failureProjection;
+      error.reconciliationRequired = true;
+    }
+    throw error;
+  }
 
   return Object.freeze({
     ...prepared.outcome,
     record: normalizedRecord,
     executionStarted: true,
+    graphAuthority: graphProjection,
+    graphAuthorityMode,
+    graphRecovered: false,
   });
 }