chainlesschain 0.166.6 → 0.166.9

package/src/lib/app-server/rollout-store.js

@@ -116,6 +116,36 @@ function buildRecord(input, previous, now) {
   return Object.freeze({ ...record, hash: recordHash(record) });
 }
 
+function assertExpectedHead(input, records) {
+  const previous = records.at(-1) || null;
+  if (
+    input.expectedRevision !== undefined &&
+    Number(input.expectedRevision) !== Number(previous?.event_seq || 0)
+  ) {
+    throw storeError(
+      "CC_ROLLOUT_HEAD_CONFLICT",
+      "rollout revision changed before append",
+      {
+        expectedRevision: Number(input.expectedRevision),
+        actualRevision: Number(previous?.event_seq || 0),
+      },
+    );
+  }
+  if (
+    input.expectedHeadHash !== undefined &&
+    input.expectedHeadHash !== (previous?.hash || null)
+  ) {
+    throw storeError(
+      "CC_ROLLOUT_HEAD_CONFLICT",
+      "rollout event head changed before append",
+      {
+        expectedHeadHash: input.expectedHeadHash,
+        actualHeadHash: previous?.hash || null,
+      },
+    );
+  }
+}
+
 function verifyRecords(records, expectedThreadId = null) {
   let previous = null;
   for (const record of records) {
@@ -309,6 +339,7 @@ export class JsonlRolloutStore {
             return clone(duplicate);
           }
         }
+        assertExpectedHead(input, records);
         const record = buildRecord(input, records.at(-1), this.now);
         fs.appendFileSync(file, `${JSON.stringify(record)}\n`, "utf8");
         return clone(record);
@@ -498,6 +529,7 @@ export class MemoryRolloutStore {
       }
       return clone(duplicate);
     }
+    assertExpectedHead(input, records);
     const record = buildRecord(input, records.at(-1), this.now);
     records.push(record);
     return clone(record);

package/src/lib/app-server/server.js

@@ -2,6 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { BoundedAsyncQueue, QueueOverloadedError } from "./bounded-queue.js";
 import { CliAgentKernelAdapter } from "./cli-agent-kernel-adapter.js";
 import { JsonlRolloutStore } from "./rollout-store.js";
+import { AppServerGraphRuntime } from "./graph-runtime.js";
+import { compileGraphDefinition } from "../graph-kernel/compiler.js";
 import {
   APP_SERVER_MIN_PROTOCOL_VERSION,
   APP_SERVER_PROTOCOL_VERSION,
@@ -110,6 +112,7 @@ export class CcAppServer {
     requestTimeoutMs = 120_000,
     interruptSettlementMs = 30_000,
     transport = "stdio",
+    graphRuntime = null,
   } = {}) {
     if (typeof send !== "function") {
       throw new TypeError("CcAppServer requires a send(message) function");
@@ -122,6 +125,18 @@ export class CcAppServer {
     this.requestTimeoutMs = requestTimeoutMs;
     this.interruptSettlementMs = interruptSettlementMs;
     this.transport = transport === "websocket" ? "websocket" : "stdio";
+    this.graphRuntime =
+      graphRuntime ||
+      new AppServerGraphRuntime({
+        rolloutStore: store,
+        now,
+        createId,
+        executeNode: (context) => this._executeGraphNode(context),
+        requestHumanTask: (context) => this._requestHumanTask(context),
+        onEvent: (event) => {
+          void this._notify("graph/event", event).catch(() => {});
+        },
+      });
     this.initialized = false;
     this.negotiated = null;
     this.client = null;
@@ -278,6 +293,12 @@ export class CcAppServer {
       "thread/archive": () => this._threadArchive(message.params),
       "turn/start": () => this._turnStart(message.params),
       "turn/interrupt": () => this._turnInterrupt(message.params),
+      "graph/compile": () => this._graphCompile(message.params),
+      "graph/run": () => this._graphRun(message.params),
+      "graph/status": () => this._graphStatus(message.params),
+      "graph/history": () => this._graphHistory(message.params),
+      "graph/cancel": () => this._graphCancel(message.params),
+      "graph/reconcile": () => this._graphReconcile(message.params),
     };
     const handler = handlers[method];
     if (!handler) {
@@ -324,6 +345,7 @@ export class CcAppServer {
       transports: [this.transport],
       websocket: { stability: "experimental" },
       limits: this.requestQueue.snapshot(),
+      graphRuntime: this.graphRuntime.runtimeClaims(),
       schema: {
         id: APP_SERVER_SCHEMA.$id,
         version: APP_SERVER_PROTOCOL_VERSION,
@@ -331,6 +353,146 @@ export class CcAppServer {
     });
   }
 
+  _graphCompile(rawParams) {
+    const params = requireObject(rawParams);
+    const compiled = compileGraphDefinition(
+      requireObject(params.definition, "definition"),
+    );
+    return {
+      definitionId: compiled.definitionId,
+      revision: compiled.revision,
+      revisionDigest: compiled.revisionDigest,
+      migratedFrom: compiled.migratedFrom,
+      definitionMigration: compiled.definitionMigration
+        ? {
+            schema: compiled.definitionMigration.schema,
+            fromVersion: compiled.definitionMigration.fromVersion,
+            toVersion: compiled.definitionMigration.toVersion,
+            revisionDigest: compiled.definitionMigration.revisionDigest,
+            rollbackDigest: compiled.definitionMigration.rollbackDigest,
+            backupAvailable: true,
+          }
+        : null,
+      topologicalOrder: [...compiled.topologicalOrder],
+    };
+  }
+
+  async _graphRun(rawParams) {
+    const params = requireObject(rawParams);
+    if (params.resume === true) {
+      return this.graphRuntime.resume(requiredString(params.runId, "runId"), {
+        waitForCompletion: params.waitForCompletion === true,
+      });
+    }
+    return this.graphRuntime.run({
+      definition: requireObject(params.definition, "definition"),
+      runId: params.runId || this.createId(),
+      inputs: params.inputs || {},
+      originSurface: params.originSurface || "desktop",
+      agentCapacity: params.agentCapacity,
+      authorityMode: params.authorityMode || "canonical",
+      waitForCompletion: params.waitForCompletion === true,
+    });
+  }
+
+  _graphStatus(rawParams) {
+    const params = requireObject(rawParams);
+    return this.graphRuntime.status(requiredString(params.runId, "runId"));
+  }
+
+  _graphHistory(rawParams) {
+    const params = requireObject(rawParams);
+    return this.graphRuntime.history(requiredString(params.runId, "runId"), {
+      afterSeq: params.afterSeq,
+      limit: params.limit,
+      snapshotLimit: params.snapshotLimit,
+    });
+  }
+
+  _graphCancel(rawParams) {
+    const params = requireObject(rawParams);
+    return this.graphRuntime.cancel(
+      requiredString(params.runId, "runId"),
+      params.reason || "cancelled by App Server client",
+    );
+  }
+
+  _graphReconcile(rawParams) {
+    const params = requireObject(rawParams);
+    return this.graphRuntime.reconcile(
+      requiredString(params.runId, "runId"),
+      requireObject(params.reconciliation, "reconciliation"),
+    );
+  }
+
+  async _executeGraphNode({ runId, nodeId, attempt, input, signal }) {
+    const threadId = `graph-agent:${runId}:${nodeId}`;
+    const turn = { id: attempt.id, threadId };
+    const onAbort = () => {
+      void this.kernel.interruptTurn?.(threadId, attempt.id);
+    };
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+    try {
+      const result = await this.kernel.startTurn({
+        threadId,
+        turnId: attempt.id,
+        input: requiredString(input?.prompt, `inputs.${nodeId}.prompt`),
+        options: input?.options || {},
+        emit: (event) =>
+          this._notify("graph/event", {
+            type: "graph/agent-event",
+            runId,
+            nodeId,
+            attemptId: attempt.id,
+            event,
+          }),
+        requestApproval: (event) => this._requestApproval(turn, event),
+      });
+      const failed = result?.is_error === true || result?.subtype === "error";
+      const output = typeof result?.result === "string" ? result.result : "";
+      const receiptThreadId = `graph-executor:${runId}`;
+      this.store.start({
+        threadId: receiptThreadId,
+        title: `Graph executor receipts for ${runId}`,
+        metadata: { kind: "graph_executor_receipts", graphRunId: runId },
+      });
+      const events = this.store.read(receiptThreadId);
+      const receiptEvent = this.store.append({
+        threadId: receiptThreadId,
+        turnId: attempt.id,
+        eventType: failed ? "executor.failed" : "executor.succeeded",
+        idempotencyKey: `graph-executor:${attempt.id}`,
+        payload: {
+          runId,
+          nodeId,
+          attemptId: attempt.id,
+          status: failed ? "failed" : "succeeded",
+          outputDigest: output ? digest(output) : null,
+          error: failed ? String(result?.error || "Agent turn failed") : null,
+        },
+        expectedRevision: events.at(-1)?.seq,
+        expectedHeadHash: events.at(-1)?.hash,
+      });
+      if (failed) {
+        return {
+          status: "failed",
+          outcomeKnown: true,
+          error: result?.error || "Agent turn failed",
+        };
+      }
+      return {
+        status: "succeeded",
+        terminalEvidence: {
+          eventDigest: receiptEvent.hash,
+          outputDigest: output ? digest(output) : null,
+        },
+        usage: result?.usage || {},
+      };
+    } finally {
+      signal?.removeEventListener?.("abort", onAbort);
+    }
+  }
+
   async _notify(method, params, rollout = null) {
     if (rollout) {
       this.store.append({
@@ -769,6 +931,44 @@ export class CcAppServer {
     return result;
   }
 
+  async _requestHumanTask({ task }) {
+    const result = await this._requestClient("humanTask/decide", { task });
+    const response = requireObject(result, "humanTask decision");
+    const validation = validateApprovalDecision(response.decision);
+    const bindings = [
+      ["humanTaskId", task.id],
+      ["runId", task.runId],
+      ["revisionDigest", task.revisionDigest],
+      ["operationDigest", task.operationDigest],
+      ["nonce", task.nonce],
+    ];
+    if (
+      !validation.ok ||
+      typeof response.actorId !== "string" ||
+      !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$/u.test(response.actorId) ||
+      Object.keys(response).some(
+        (field) =>
+          ![
+            "humanTaskId",
+            "runId",
+            "revisionDigest",
+            "operationDigest",
+            "nonce",
+            "actorId",
+            "decision",
+          ].includes(field),
+      ) ||
+      bindings.some(([field, expected]) => response[field] !== expected)
+    ) {
+      throw new JsonRpcError(
+        JSON_RPC_ERROR.INVALID_PARAMS,
+        "client returned an invalid or stale HumanTask decision",
+        { errors: validation.errors },
+      );
+    }
+    return response;
+  }
+
   async _completeTurn(turn, status, result) {
     if (TERMINAL_TURN_STATUSES.has(turn.status)) return;
     if (turn.assistantStarted) {

package/src/lib/approval-grant-ledger.js

@@ -46,6 +46,14 @@ function permissionKey(permission) {
   return `${permission.capability}\0${permission.scope}`;
 }
 
+function grantId(sessionId, lifetime, permission) {
+  return `grant_${createHash("sha256")
+    .update(
+      `${String(sessionId)}\0${String(lifetime)}\0${permissionKey(permission)}`,
+    )
+    .digest("hex")}`;
+}
+
 function livePermission(permission, now) {
   const validation = validateAppServerDefinition("PermissionGrant", permission);
   if (!validation.ok) return false;
@@ -102,6 +110,67 @@ export class ApprovalGrantLedger {
     return false;
   }
 
+  listGrants() {
+    const now = this.now();
+    const grants = [];
+    for (const [lifetime, entries] of [
+      ["turn", this.turnGrants],
+      ["session", this.sessionGrants],
+    ]) {
+      for (const [key, entry] of entries) {
+        if (!livePermission(entry.permission, now)) {
+          entries.delete(key);
+          continue;
+        }
+        grants.push(
+          Object.freeze({
+            grantId: grantId(this.sessionId, lifetime, entry.permission),
+            lifetime,
+            permission: Object.freeze({ ...entry.permission }),
+            binding: entry.binding,
+            grantedAt: entry.grantedAt,
+            ...(lifetime === "turn" ? { turnId: this.turnId } : {}),
+          }),
+        );
+      }
+    }
+    return Object.freeze(grants);
+  }
+
+  revoke(grantIdValue) {
+    const requestedId = String(grantIdValue || "");
+    for (const [lifetime, entries] of [
+      ["turn", this.turnGrants],
+      ["session", this.sessionGrants],
+    ]) {
+      for (const [key, entry] of entries) {
+        if (
+          grantId(this.sessionId, lifetime, entry.permission) !== requestedId
+        ) {
+          continue;
+        }
+        entries.delete(key);
+        if (lifetime === "session") this.revision += 1;
+        return Object.freeze({
+          revoked: true,
+          persistedScope: lifetime === "session",
+          grant: Object.freeze({
+            grantId: requestedId,
+            lifetime,
+            permission: Object.freeze({ ...entry.permission }),
+            binding: entry.binding,
+            grantedAt: entry.grantedAt,
+          }),
+        });
+      }
+    }
+    return Object.freeze({
+      revoked: false,
+      persistedScope: false,
+      grant: null,
+    });
+  }
+
   applyDecision(decision, requiredPermission, binding) {
     if (
       decision?.kind !== "acceptForTurn" &&

package/src/lib/autonomous-agent.js

@@ -9,6 +9,7 @@
 
 import { EventEmitter } from "events";
 import { firstBalancedJson } from "./json-schema-output.js";
+import { assertCLILegacyMutationAllowed } from "./legacy-runtime-authority.js";
 
 // Exported for test injection
 export const _deps = {
@@ -67,6 +68,7 @@ export class CLIAutonomousAgent extends EventEmitter {
     maxGoals,
     iterationBudget,
   } = {}) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent.initialize");
     this._llmChat = llmChat || null;
     this._toolExecutor = toolExecutor || null;
     this._hookManager = hookManager || null;
@@ -84,6 +86,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    * @returns {{ goalId: string }}
    */
   async submitGoal(description, { tokenBudget = 50000 } = {}) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent.submitGoal");
     if (!this._initialized) throw new Error("Agent not initialized");
     if (!description) throw new Error("Goal description required");
 
@@ -124,6 +127,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    * the cap rather than losing live work.
    */
   _pruneGoals() {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent._pruneGoals");
     if (this._goals.size <= this._maxGoals) return;
     for (const [id, g] of this._goals) {
       if (this._goals.size <= this._maxGoals) break;
@@ -141,6 +145,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    * Pause a running goal.
    */
   pauseGoal(goalId) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent.pauseGoal");
     const goal = this._goals.get(goalId);
     if (!goal) return { error: "Goal not found" };
     if (goal.status !== GoalStatus.RUNNING)
@@ -156,6 +161,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    * Resume a paused goal.
    */
   resumeGoal(goalId) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent.resumeGoal");
     const goal = this._goals.get(goalId);
     if (!goal) return { error: "Goal not found" };
     if (goal.status !== GoalStatus.PAUSED)
@@ -178,6 +184,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    * Cancel a goal.
    */
   cancelGoal(goalId) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent.cancelGoal");
     const goal = this._goals.get(goalId);
     if (!goal) return { error: "Goal not found" };
 
@@ -228,6 +235,7 @@ export class CLIAutonomousAgent extends EventEmitter {
   // ─── ReAct Loop ─────────────────────────────────────────────
 
   async _runReActLoop(goal) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent._runReActLoop");
     goal.status = GoalStatus.RUNNING;
     this.emit("goal:started", { goalId: goal.id });
 
@@ -342,6 +350,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    * Decompose a goal into executable steps using LLM.
    */
   async _decomposeGoal(goal) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent._decomposeGoal");
     if (!this._llmChat) {
       // No LLM — create a single step
       return [
@@ -406,6 +415,7 @@ Only return the JSON array, no other text.`;
    * Execute a single step using the tool executor.
    */
   async _executeStep(step) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent._executeStep");
     if (!step.tool || !this._toolExecutor) {
       // No tool specified or no executor — skip as informational
       return "No tool action required";
@@ -419,6 +429,7 @@ Only return the JSON array, no other text.`;
    * Returns true if a correction was applied.
    */
   async _selfCorrect(goal, error) {
+    assertCLILegacyMutationAllowed("CLIAutonomousAgent._selfCorrect");
     if (!this._llmChat) return false;
 
     try {

package/src/lib/codex-app-server-adapter.js

@@ -2,6 +2,11 @@ import { EventEmitter } from "node:events";
 
 export const CODEX_APP_SERVER_PROTOCOL = "codex-app-server-experimental-v1";
 export const CODEX_APP_SERVER_FEATURE_FLAG = "CC_EXPERIMENTAL_CODEX_APP_SERVER";
+export const CODEX_APP_SERVER_COMPATIBILITY_MATRIX = Object.freeze([
+  Object.freeze({ version: "0.149.0" }),
+  Object.freeze({ version: "0.150.0" }),
+  Object.freeze({ version: "0.150.1" }),
+]);
 
 function adapterError(code, message, details = {}) {
   const error = new Error(message);
@@ -12,30 +17,16 @@ function adapterError(code, message, details = {}) {
 }
 
 function parseVersion(value) {
-  const match = String(value || "").match(/(\d+)\.(\d+)\.(\d+)/u);
-  return match ? match.slice(1).map(Number) : null;
-}
-
-function compareVersion(left, right) {
-  for (let index = 0; index < 3; index += 1) {
-    if (left[index] !== right[index]) return left[index] - right[index];
-  }
-  return 0;
+  const match = String(value || "")
+    .trim()
+    .match(/^(?:codex(?:-cli)?\s+)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u);
+  return match ? match.slice(1).map(Number).join(".") : null;
 }
 
 export function isCodexAppServerVersionCompatible(version, matrix = []) {
   const parsed = parseVersion(version);
   if (!parsed || !Array.isArray(matrix) || matrix.length === 0) return false;
-  return matrix.some((range) => {
-    const minimum = parseVersion(range.min);
-    const maximum = parseVersion(range.maxExclusive);
-    return (
-      minimum &&
-      maximum &&
-      compareVersion(parsed, minimum) >= 0 &&
-      compareVersion(parsed, maximum) < 0
-    );
-  });
+  return matrix.some((entry) => parseVersion(entry?.version) === parsed);
 }
 
 function projectNotification(notification) {
@@ -103,7 +94,7 @@ export class CodexAppServerAdapter extends EventEmitter {
     client,
     fallback,
     upstreamVersion,
-    compatibilityMatrix = [],
+    compatibilityMatrix = CODEX_APP_SERVER_COMPATIBILITY_MATRIX,
     enabled = process.env[CODEX_APP_SERVER_FEATURE_FLAG] === "1",
     timeoutMs = 120_000,
   } = {}) {