chainlesschain 0.166.130 → 0.166.131

package/src/lib/cost-budget.js

@@ -75,6 +75,8 @@ export class CostBudget {
       cacheCreationTokens,
       cacheCreation5mTokens: pricingContext.cacheCreation5mTokens,
       cacheCreation1hTokens: pricingContext.cacheCreation1hTokens,
+      cacheCreation30mTokens: pricingContext.cacheCreation30mTokens,
+      cacheCreation12hTokens: pricingContext.cacheCreation12hTokens,
       cacheCreationInvalid: pricingContext.cacheCreationInvalid,
       pricingContextInvalid:
         pricingContext.pricingContextInvalid === true ||

package/src/lib/ephemeral-worktree-scope.js

@@ -0,0 +1,24 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+const scopes = new AsyncLocalStorage();
+
+/**
+ * An ephemeral checkout belongs to its awaited callback. This host scope is a
+ * capability restriction, not a process lease: tools that return before their
+ * consumers settle must refuse dispatch until they can transfer that ownership.
+ * Async descendants retain the restriction even after the callback returns.
+ */
+export function withEphemeralWorktreeScope(worktreePath, callback) {
+  return scopes.run(Object.freeze({ worktreePath }), callback);
+}
+
+export function ephemeralWorktreeConsumerRefusal(operation) {
+  const scope = scopes.getStore();
+  if (!scope) return null;
+  return {
+    error: `${operation} cannot outlive an ephemeral worktree. Run this work in the foreground, or launch it from a persistent checkout with its own lifecycle owner.`,
+    code: "CC_EPHEMERAL_WORKTREE_CONSUMER_UNOWNED",
+    worktreePath: scope.worktreePath,
+    policy: { decision: "deny", via: "ephemeral-worktree-lifetime" },
+  };
+}

package/src/lib/evolution/evolution-deployment-loader.js

@@ -8,10 +8,6 @@ import {
   assertEvolutionDeploymentRevisionFloor,
   readEvolutionDeploymentProfile,
 } from "./evolution-deployment-profile.js";
-import {
-  readEvolutionEnabled,
-  resolveEvolutionEnabled,
-} from "./evolution-enabled.js";
 
 export const EVOLUTION_DEPLOYMENT_DESCRIPTOR_SCHEMA =
   "chainlesschain.evolution-deployment-descriptor/v1";
@@ -1038,6 +1034,12 @@ export async function loadEvolutionDeploymentCommandDependencies(
   } = {},
 ) {
   if (!SUPPORTED_COMMANDS.has(commandName)) return null;
+  // Unsupported commands (including read-only session show) need no deployment
+  // configuration. Loading it eagerly also loads secret-store and the full
+  // process broker/platform sandbox graph before this early return.
+  const { readEvolutionEnabled, resolveEvolutionEnabled } = await import(
+    "./evolution-enabled.js"
+  );
   const localModelDependencies = () =>
     dependencies(
       {

package/src/lib/evolution/governed-skill-marketplace-abort.js

@@ -0,0 +1,14 @@
+import { raceWithAbort, throwIfAborted } from "../abort-utils.js";
+
+// Only race reads/preparation. Durable commits must retain their acknowledgement
+// and recovery path even when the caller interrupts after the append starts.
+export function awaitMarketplaceRead(operation, signal) {
+  throwIfAborted(signal);
+  return raceWithAbort(
+    Promise.resolve().then(() => {
+      throwIfAborted(signal);
+      return operation();
+    }),
+    signal,
+  );
+}

package/src/lib/evolution/governed-skill-marketplace-candidate.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { types as utilTypes } from "node:util";
+import { throwIfAborted } from "../abort-utils.js";
+import { awaitMarketplaceRead } from "./governed-skill-marketplace-abort.js";
 import {
   SkillCandidateRegistry,
   SKILL_CANDIDATE_MAX_ARTIFACT_BYTES,
@@ -250,7 +252,8 @@ export function createGovernedSkillMarketplaceCandidateInstaller({
   };
   const installer = Object.freeze({
     tenantId,
-    async materialize(inspected) {
+    async materialize(inspected, { signal } = {}) {
+      throwIfAborted(signal);
       const { manifest, adapted, target } = inspected;
       if (manifest.tenantId !== tenantId)
         throw new Error("marketplace candidate tenant mismatch");
@@ -262,7 +265,11 @@ export function createGovernedSkillMarketplaceCandidateInstaller({
         adaptedOutputDigest: adapted.outputDigest,
         sbomDigest: manifest.sbomDigest,
       });
-      const resolved = await Reflect.apply(resolve, artifacts, [request]);
+      const resolved = await awaitMarketplaceRead(
+        () => Reflect.apply(resolve, artifacts, [request, { signal }]),
+        signal,
+      );
+      throwIfAborted(signal);
       const sourceBytes = bytes(
         resolved?.packageBytes,
         request.packageDigest,
@@ -307,6 +314,7 @@ export function createGovernedSkillMarketplaceCandidateInstaller({
         ...core,
         bindingDigest: bindingDigest(core),
       });
+      throwIfAborted(signal);
       const result = create(candidateInput(candidate));
       if (result.candidate.candidateId !== candidate.candidateId)
         throw new Error(

package/src/lib/evolution/governed-skill-marketplace-cli-host.js

@@ -1,4 +1,6 @@
 import { types as utilTypes } from "node:util";
+import { throwIfAborted } from "../abort-utils.js";
+import { awaitMarketplaceRead } from "./governed-skill-marketplace-abort.js";
 import { GovernedSkillMarketplace } from "./governed-skill-marketplace.js";
 import { isGovernedSkillMarketplaceLedgerAdapter } from "./governed-skill-marketplace-ledger-adapter.js";
 import { isGovernedSkillMarketplaceCandidateInstaller } from "./governed-skill-marketplace-candidate.js";
@@ -105,12 +107,16 @@ export function createGovernedSkillMarketplaceCliHost({
       candidateInstaller.verify(state);
     return state;
   };
-  const resolveManifest = async (skillName, version) => {
+  const resolveManifest = async (skillName, version, { signal } = {}) => {
+    throwIfAborted(signal);
     id(skillName, "skillName");
     if (version !== null) id(version, "version");
-    const manifest = await resolve(
-      Object.freeze({ tenantId, skillName, version }),
+    const manifest = await awaitMarketplaceRead(
+      () =>
+        resolve(Object.freeze({ tenantId, skillName, version }), { signal }),
+      signal,
     );
+    throwIfAborted(signal);
     if (
       manifest?.tenantId !== tenantId ||
       manifest.skillName !== skillName ||
@@ -217,20 +223,30 @@ export function createGovernedSkillMarketplaceCliHost({
       });
     },
     state: ({ skillName } = {}) => stateFor(skillName),
-    async install({
-      skillName,
-      version = null,
-      manifestDigest,
-      expectedStateDigest = null,
-    } = {}) {
+    async install(
+      {
+        skillName,
+        version = null,
+        manifestDigest,
+        expectedStateDigest = null,
+      } = {},
+      { signal } = {},
+    ) {
+      throwIfAborted(signal);
       digest(manifestDigest, "manifestDigest");
       if (expectedStateDigest !== null)
         digest(expectedStateDigest, "expectedStateDigest");
-      const manifest = await resolveManifest(skillName, version);
+      const manifest = await resolveManifest(skillName, version, { signal });
       if (manifest.manifestDigest !== manifestDigest)
         throw new Error("marketplace catalog manifest changed; inspect again");
-      const inspected = await marketplace.inspect(manifest, target);
-      if (await isManifestRevoked({ skillName, manifestDigest }))
+      const inspected = await marketplace.inspect(manifest, target, { signal });
+      throwIfAborted(signal);
+      if (
+        await awaitMarketplaceRead(
+          () => isManifestRevoked({ skillName, manifestDigest }),
+          signal,
+        )
+      )
         throw new Error(
           "marketplace manifest was revoked and cannot be staged again",
         );
@@ -251,7 +267,12 @@ export function createGovernedSkillMarketplaceCliHost({
           state,
         });
       };
-      const current = await stateFor(skillName);
+      throwIfAborted(signal);
+      const current = await awaitMarketplaceRead(
+        () => stateFor(skillName),
+        signal,
+      );
+      throwIfAborted(signal);
       if (isReplay(current)) return result(current, true);
       if (
         current?.manifestDigest === manifestDigest &&
@@ -264,15 +285,21 @@ export function createGovernedSkillMarketplaceCliHost({
         );
       if ((current?.stateDigest ?? null) !== expectedStateDigest)
         throw new Error("marketplace install baseline changed");
-      const candidateBinding = await candidateInstaller.materialize(inspected);
+      const candidateBinding = await candidateInstaller.materialize(inspected, {
+        signal,
+      });
+      throwIfAborted(signal);
       try {
         return result(
-          await marketplace.stage({
-            manifest,
-            target,
-            expectedStateDigest,
-            candidateBinding,
-          }),
+          await marketplace.stage(
+            {
+              manifest,
+              target,
+              expectedStateDigest,
+              candidateBinding,
+            },
+            { signal },
+          ),
           false,
         );
       } catch (error) {

package/src/lib/evolution/governed-skill-marketplace.js

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 import { types as utilTypes } from "node:util";
+import { throwIfAborted } from "../abort-utils.js";
+import { awaitMarketplaceRead } from "./governed-skill-marketplace-abort.js";
 import { verifyGovernedSkillMarketplaceCandidateBinding } from "./governed-skill-marketplace-candidate.js";
 
 import {
@@ -322,23 +324,33 @@ export class GovernedSkillMarketplace {
     this._verifyRevocation = capture(ports, "verifyRevocation");
   }
 
-  async verifyListing(input, target) {
+  async verifyListing(input, target, { signal } = {}) {
+    throwIfAborted(signal);
     const manifest = normalizeManifest(input, this.tenantId);
-    if ((await this._verifySignature({ manifest })) !== true)
+    if (
+      (await awaitMarketplaceRead(
+        () => this._verifySignature({ manifest }, { signal }),
+        signal,
+      )) !== true
+    )
       throw new Error("marketplace manifest signature is invalid");
+    throwIfAborted(signal);
     const cell = targetCell(manifest, target);
     if (cell.safetyPassed !== true)
       throw new Error("marketplace target safety gate failed");
     return freeze({ manifest, target: clone(target), cell });
   }
 
-  async inspect(input, target) {
-    const { manifest, cell } = await this.verifyListing(input, target);
-    const adapted = await this._adapt({
-      manifest,
-      target: clone(target),
-      cell,
+  async inspect(input, target, { signal } = {}) {
+    const { manifest, cell } = await this.verifyListing(input, target, {
+      signal,
     });
+    throwIfAborted(signal);
+    const adapted = await awaitMarketplaceRead(
+      () => this._adapt({ manifest, target: clone(target), cell }, { signal }),
+      signal,
+    );
+    throwIfAborted(signal);
     if (
       adapted?.authenticated !== true ||
       adapted.manifestDigest !== manifest.manifestDigest ||
@@ -357,16 +369,22 @@ export class GovernedSkillMarketplace {
     });
   }
 
-  async stage({
-    manifest: input,
-    target,
-    expectedStateDigest = null,
-    candidateBinding = null,
-  } = {}) {
-    const inspected = await this.inspect(input, target);
-    const current = await this._load({
-      skillName: inspected.manifest.skillName,
-    });
+  async stage(
+    {
+      manifest: input,
+      target,
+      expectedStateDigest = null,
+      candidateBinding = null,
+    } = {},
+    { signal } = {},
+  ) {
+    const inspected = await this.inspect(input, target, { signal });
+    throwIfAborted(signal);
+    const current = await awaitMarketplaceRead(
+      () => this._load({ skillName: inspected.manifest.skillName }),
+      signal,
+    );
+    throwIfAborted(signal);
     if ((current?.stateDigest || null) !== expectedStateDigest)
       throw new Error("marketplace install baseline changed");
     const state = {
@@ -400,6 +418,9 @@ export class GovernedSkillMarketplace {
         );
       state.candidateBinding = binding;
     }
+    // Once the durable append starts, await its acknowledgement/recovery. An
+    // abort cannot truthfully turn a committed state into a cancelled install.
+    throwIfAborted(signal);
     return this._persist(state, expectedStateDigest, "marketplace.staged");
   }
 
@@ -629,12 +650,14 @@ export class GovernedSkillMarketplace {
     }
     let current = await this._verifiedState(request.skillName);
     const expectedStateDigest = request.dependency.digest;
-    if (!(
-      current.revoked === true &&
-      current.stage === "rolled-back" &&
-      current.revocationBaselineStateDigest === expectedStateDigest &&
-      current.revocationPropagationRequestDigest === request.requestDigest
-    )) {
+    if (
+      !(
+        current.revoked === true &&
+        current.stage === "rolled-back" &&
+        current.revocationBaselineStateDigest === expectedStateDigest &&
+        current.revocationPropagationRequestDigest === request.requestDigest
+      )
+    ) {
       if (current.stateDigest !== expectedStateDigest) {
         throw new Error("marketplace revocation dependency baseline changed");
       }

package/src/lib/goal-condition-engine.js

@@ -81,6 +81,7 @@ export function normalizeGoalBudget(input = {}) {
  *   file-exists:dist/app.js   → met iff the path exists
  *   contains:ALL GREEN        → met iff the last output contains the text
  *   regex:^BUILD OK$          → met iff the last output matches
+ *   verify:acceptance.json    → all frozen host acceptance commands must pass
  *   model:the tests pass      → a model judges the transcript
  *   the tests pass            → (bare) model-judged
  */
@@ -99,6 +100,9 @@ export function parseGoalCondition(spec) {
     case "file":
       if (!rest) throw new Error("file-exists condition needs a path");
       return { kind: "file-exists", path: rest, source: raw };
+    case "verify":
+      if (!rest) throw new Error("verify condition needs a manifest path");
+      return { kind: "verify", path: rest, source: raw };
     case "contains":
       if (!rest) throw new Error("contains condition needs text");
       return { kind: "contains", text: rest, source: raw };
@@ -387,9 +391,22 @@ export class GoalConditionEngine {
     const state = snap?.state;
     if (
       !snap?.condition ||
-      !["model", "exit-zero", "file-exists", "contains", "regex"].includes(
-        snap.condition.kind,
-      ) ||
+      ![
+        "model",
+        "exit-zero",
+        "file-exists",
+        "contains",
+        "regex",
+        "verify",
+      ].includes(snap.condition.kind) ||
+      (snap.condition.kind === "verify" &&
+        (typeof snap.condition.path !== "string" ||
+          !snap.condition.path.trim() ||
+          snap.condition.verification?.schema !==
+            "chainlesschain.prepared-goal-verification/v1" ||
+          !/^sha256:[a-f0-9]{64}$/u.test(
+            snap.condition.verification?.digest || "",
+          ))) ||
       !state ||
       !Number.isSafeInteger(state.outerTurns) ||
       state.outerTurns < 0 ||

package/src/lib/goal-verification-command.js

@@ -0,0 +1,221 @@
+import { createHash, randomUUID } from "node:crypto";
+import executionBroker from "./process-execution-broker/index.js";
+import { terminateOwnedProcessTree } from "./process-tree-termination.js";
+import { redactSecrets } from "./secret-scan.js";
+
+const MAX_OUTPUT_BYTES = 128 * 1024;
+const RESULT_PREFIX = "CC_GOAL_CHECK_RESULT ";
+export const GOAL_CHECK_RESULT_SCHEMA = "chainlesschain.goal-check-result/v1";
+
+function checkReceipt(stdout, check, invocationId) {
+  const lines = stdout
+    .toString("utf8")
+    .split(/\r?\n/u)
+    .filter((line) => line.startsWith(RESULT_PREFIX));
+  if (lines.length !== 1 || lines[0].length > 16 * 1024) return null;
+  try {
+    const receipt = JSON.parse(lines[0].slice(RESULT_PREFIX.length));
+    if (
+      !receipt ||
+      typeof receipt !== "object" ||
+      Array.isArray(receipt) ||
+      Object.keys(receipt).some(
+        (key) =>
+          !["schema", "checkId", "invocationId", "requirements"].includes(key),
+      ) ||
+      receipt.schema !== GOAL_CHECK_RESULT_SCHEMA ||
+      receipt.checkId !== check.id ||
+      receipt.invocationId !== invocationId ||
+      !Array.isArray(receipt.requirements) ||
+      receipt.requirements.length !== check.requirements.length
+    )
+      return null;
+    const ids = new Set();
+    for (const entry of receipt.requirements) {
+      if (
+        !entry ||
+        typeof entry !== "object" ||
+        Array.isArray(entry) ||
+        Object.keys(entry).some((key) => !["id", "passed"].includes(key)) ||
+        !check.requirements.includes(entry.id) ||
+        ids.has(entry.id) ||
+        entry.passed !== true
+      )
+        return null;
+      ids.add(entry.id);
+    }
+    return receipt;
+  } catch {
+    return null;
+  }
+}
+export function goalVerificationError(message, reason = "error") {
+  return Object.assign(new Error(message), {
+    code: "CC_GOAL_VERIFICATION_FAILED",
+    goalVerificationFailure: true,
+    subtype: "error_goal_verification",
+    endReason: reason,
+  });
+}
+
+export function checkGoalVerificationCancellation(signal) {
+  if (signal?.aborted)
+    throw goalVerificationError("Goal verification was cancelled", "cancelled");
+}
+
+function outputEvidence(bytes, truncated) {
+  const text = bytes.toString("utf8");
+  const preview =
+    text.length <= 4000
+      ? text
+      : `${text.slice(0, 1980)}\n[... truncated ...]\n${text.slice(-1980)}`;
+  return {
+    bytes: bytes.length,
+    digest: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+    truncated,
+    preview: redactSecrets(preview),
+  };
+}
+
+/** Execute a user-selected, frozen acceptance command, never model tool text.
+ * Use argv without a shell and wait for the actual close / cleanup fence.
+ */
+export async function runGoalVerificationCommand(
+  check,
+  { cwd, signal, timeoutMs } = {},
+) {
+  checkGoalVerificationCancellation(signal);
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const invocationId = randomUUID();
+    let child, timer, stopping, stopReason, spawnError;
+    let closed = false,
+      settled = false,
+      exitCode = null,
+      exitSignal = null;
+    const streams = {
+      stdout: { chunks: [], size: 0, truncated: false },
+      stderr: { chunks: [], size: 0, truncated: false },
+    };
+    const finish = (cleanup) => {
+      if (settled || (stopping && cleanup === undefined)) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      if (cleanup && !cleanup.confirmed) {
+        const error = goalVerificationError(
+          "Goal checker process cleanup is unconfirmed; reconcile it before continuing",
+        );
+        error.cleanup = cleanup;
+        error.verification = {
+          checkId: check.id,
+          status: "cleanup-unconfirmed",
+          manualReviewRequired: true,
+          cleanup,
+        };
+        reject(error);
+        return;
+      }
+      if (signal?.aborted || stopReason === "cancelled") {
+        reject(
+          goalVerificationError("Goal verification was cancelled", "cancelled"),
+        );
+        return;
+      }
+      const stdout = Buffer.concat(streams.stdout.chunks);
+      const receipt = checkReceipt(stdout, check, invocationId);
+      resolve({
+        id: check.id,
+        invocationId,
+        command: { executable: check.executable, args: check.args },
+        exitCode: closed && !spawnError ? exitCode : null,
+        signal: exitSignal,
+        status:
+          stopReason ||
+          (spawnError
+            ? "spawn-failed"
+            : exitCode === 0 && !exitSignal
+              ? receipt
+                ? "passed"
+                : "receipt-invalid"
+              : "failed"),
+        receipt,
+        durationMs: Date.now() - startedAt,
+        stdout: outputEvidence(stdout, streams.stdout.truncated),
+        stderr: outputEvidence(
+          Buffer.concat(streams.stderr.chunks),
+          streams.stderr.truncated,
+        ),
+        ...(cleanup ? { cleanup } : {}),
+      });
+    };
+    const stop = (reason) => {
+      if (settled || stopping) return;
+      stopReason = reason;
+      stopping = Promise.resolve().then(() =>
+        terminateOwnedProcessTree(child, { alreadyClosed: closed }),
+      );
+      stopping.then(finish, () => finish({ confirmed: false }));
+    };
+    const onAbort = () => stop("cancelled");
+    try {
+      // Acceptance programs do not inherit provider credentials or Node preload
+      // hooks. They can read the explicitly selected workspace as ordinary tests.
+      const env = Object.fromEntries(
+        Object.entries(process.env).filter(([key]) =>
+          /^(path|systemroot|windir|temp|tmp|home|userprofile|lang|lc_all)$/i.test(
+            key,
+          ),
+        ),
+      );
+      env.CC_GOAL_CHECK_ID = check.id;
+      env.CC_GOAL_CHECK_INVOCATION = invocationId;
+      child = executionBroker.spawn(
+        check.executable === "node" ? process.execPath : check.executable,
+        check.args,
+        {
+          cwd,
+          env,
+          shell: false,
+          windowsHide: true,
+          detached: process.platform !== "win32",
+          stdio: ["ignore", "pipe", "pipe"],
+          origin: "headless-goal:verification",
+          scope: "headless-goal",
+          policy: "allow",
+        },
+      );
+      for (const name of ["stdout", "stderr"])
+        child[name]?.on("data", (chunk) => {
+          const bytes = Buffer.from(chunk),
+            stream = streams[name];
+          const remaining = MAX_OUTPUT_BYTES - stream.size;
+          if (remaining > 0) {
+            const kept = bytes.subarray(0, remaining);
+            stream.chunks.push(kept);
+            stream.size += kept.length;
+          }
+          if (bytes.length > remaining) {
+            stream.truncated = true;
+            stop("output-limit");
+          }
+        });
+      child.once("error", (error) => {
+        spawnError = error;
+      });
+      child.once("close", (code, childSignal) => {
+        closed = true;
+        exitCode = code;
+        exitSignal = childSignal;
+        finish();
+      });
+      timer = setTimeout(() => stop("timed-out"), timeoutMs);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      if (signal?.aborted) onAbort();
+    } catch (error) {
+      spawnError = error;
+      if (child?.pid) stop("spawn-failed");
+      else finish();
+    }
+  });
+}