chainlesschain 0.166.6 → 0.166.7

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,17 @@ 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),
+        onEvent: (event) => {
+          void this._notify("graph/event", event).catch(() => {});
+        },
+      });
     this.initialized = false;
     this.negotiated = null;
     this.client = null;
@@ -278,6 +292,11 @@ 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/cancel": () => this._graphCancel(message.params),
+      "graph/reconcile": () => this._graphReconcile(message.params),
     };
     const handler = handlers[method];
     if (!handler) {
@@ -324,6 +343,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 +351,126 @@ 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,
+      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"));
+  }
+
+  _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({

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 {