chainlesschain 0.166.90 → 0.166.92

package/src/lib/formal-quality-eval-runtime.js

@@ -1,3 +1,4 @@
+import { isFormalQualityHermeticRuntime } from "@chainlesschain/session-core/host-storage-environment";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
@@ -23,20 +24,7 @@ export const FORMAL_QUALITY_FILE_TOOLS = Object.freeze([
  * headless boundary through a launcher-only environment marker. Keep the
  * check exact so inherited or malformed values never change normal CLI runs.
  */
-export function isFormalQualityHermeticRuntime(environment = process.env) {
-  if (environment?.[FORMAL_QUALITY_HERMETIC_ENV] !== "1") return false;
-  const configuredHome = String(environment?.CHAINLESSCHAIN_HOME || "").trim();
-  if (!configuredHome) return false;
-  const temporaryRoot = path.resolve(os.tmpdir());
-  const resolvedHome = path.resolve(configuredHome);
-  const relation = path.relative(temporaryRoot, resolvedHome);
-  return Boolean(
-    relation &&
-    relation !== ".." &&
-    !relation.startsWith(`..${path.sep}`) &&
-    !path.isAbsolute(relation),
-  );
-}
+export { isFormalQualityHermeticRuntime };
 
 function formalQualityIsolationRoot(environment) {
   if (!isFormalQualityHermeticRuntime(environment)) return null;

package/src/lib/goal-store.js

@@ -18,8 +18,15 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { getHomeDir } from "./paths.js";
 import { withFileLock } from "./with-file-lock.js";
+import {
+  createGoalRecord,
+  validateGoalRecord,
+  upgradeLegacyGoal,
+  goalError,
+} from "@chainlesschain/session-core/goal-contract";
 
 /** Valid goal lifecycle states. `active` goals are the ones injected. */
 export const GOAL_STATUS = Object.freeze({
@@ -35,6 +42,25 @@ function defaultRoot() {
   return path.join(getHomeDir(), "goals");
 }
 
+/** Store identity is path-bound metadata, not filesystem authorization. */
+export function goalFileStoreId(root = defaultRoot()) {
+  const resolved = path.resolve(root);
+  const canonical =
+    process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  return `cli-goals-${createHash("sha256").update(canonical).digest("hex")}`;
+}
+
+function fileRecord(value, root) {
+  const record = upgradeLegacyGoal(value, goalFileStoreId(root));
+  if (record.storeId !== goalFileStoreId(root))
+    throw goalError("GOAL_STORE_MISMATCH");
+  // Files are the legacy standalone CLI store. Project authority lives in the
+  // host database and must not be acquired by copying a record into this dir.
+  if (record.ownerRef !== null || record.projectRef !== null)
+    throw goalError("GOAL_PROJECT_STORE_REQUIRED");
+  return record;
+}
+
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
@@ -83,6 +109,7 @@ function isUnsafeGoalId(id) {
     id == null ||
     id === "" ||
     typeof id !== "string" ||
+    !/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u.test(id) ||
     id.includes("/") ||
     id.includes("\\") ||
     id.includes("..")
@@ -133,17 +160,15 @@ export function createGoal(input = {}, opts = {}) {
   }
   const keyResults = (input.keyResults || []).map((kr) => normalizeKr(kr));
   const goal = {
-    id,
-    title: String(input.title || objective).trim(),
-    objective,
-    keyResults,
-    status: GOAL_STATUS.ACTIVE,
+    ...createGoalRecord({
+      id,
+      storeId: goalFileStoreId(root),
+      title: String(input.title || objective).trim(),
+      objective,
+      keyResults,
+      createdAt: nowIso(),
+    }),
     progress: derivedProgress(keyResults) ?? 0,
-    linkedSessions: [],
-    notes: [],
-    drift: { lastProgressAt: null, flags: [] },
-    createdAt: nowIso(),
-    updatedAt: nowIso(),
   };
   ensureDir(root);
   const file = goalFile(root, id);
@@ -186,21 +211,42 @@ export function getGoal(id, opts = {}) {
   const file = goalFile(root, id);
   if (!fs.existsSync(file)) return null;
   try {
-    return JSON.parse(fs.readFileSync(file, "utf-8"));
+    const value = JSON.parse(fs.readFileSync(file, "utf-8"));
+    if (value?.id !== id) return null;
+    if (Object.hasOwn(value, "schema") || Object.hasOwn(value, "schemaVersion"))
+      fileRecord(value, root);
+    return value;
   } catch {
     return null;
   }
 }
 
-function saveGoal(goal, opts = {}) {
+function saveGoal(goal, opts = {}, before = null) {
   if (isUnsafeGoalId(goal && goal.id)) {
     throw new Error(`非法 goal id: ${String(goal && goal.id).slice(0, 60)}`);
   }
   const root = opts.root || defaultRoot();
   ensureDir(root);
-  goal.updatedAt = nowIso();
-  atomicWriteFileSync(goalFile(root, goal.id), JSON.stringify(goal, null, 2));
-  return goal;
+  const previous = before || fileRecord(goal, root);
+  const migrated = goal.schema ? goal : { ...fileRecord(goal, root) };
+  if (previous.completion !== null && migrated.status === "done")
+    throw goalError("GOAL_TERMINAL_REVISION_DENIED");
+  const controls = ["status", "objective", "keyResults"];
+  const changedControl = controls.some(
+    (key) => JSON.stringify(previous[key]) !== JSON.stringify(migrated[key]),
+  );
+  const saved = fileRecord(
+    {
+      ...migrated,
+      revision: previous.revision + 1,
+      controlGeneration: previous.controlGeneration + (changedControl ? 1 : 0),
+      completion: null,
+      updatedAt: nowIso(),
+    },
+    root,
+  );
+  atomicWriteFileSync(goalFile(root, goal.id), JSON.stringify(saved, null, 2));
+  return saved;
 }
 
 /** List goals, newest first. Optionally filter by status. */
@@ -233,8 +279,64 @@ function mutate(id, fn, opts = {}) {
     () => {
       const goal = getGoal(id, opts);
       if (!goal) throw new Error(`no such goal: ${id}`);
+      let before;
+      try {
+        before = fileRecord(goal, root);
+      } catch (error) {
+        // Older CLI records had unbounded notes/strings. Preserve their full
+        // history and existing controls if the bounded contract cannot accept
+        // them. This fallback is never available to a versioned record.
+        if (
+          Object.hasOwn(goal, "schema") ||
+          Object.hasOwn(goal, "schemaVersion") ||
+          ![
+            "GOAL_INVALID_ARRAY",
+            "GOAL_INVALID_TEXT",
+            "GOAL_INVALID_JSON",
+          ].includes(error.code)
+        )
+          throw error;
+        const revision = goal.revision ?? 1;
+        const generation = goal.controlGeneration ?? 0;
+        if (
+          !Number.isSafeInteger(revision) ||
+          revision < 1 ||
+          !Number.isSafeInteger(generation) ||
+          generation < 0 ||
+          !Number.isSafeInteger(revision + 1) ||
+          !Number.isSafeInteger(generation + 1)
+        )
+          throw goalError("GOAL_INVALID_REVISION");
+        if (
+          opts.expectedRevision !== undefined &&
+          opts.expectedRevision !== revision
+        )
+          throw goalError("GOAL_REVISION_CONFLICT");
+        const controls = JSON.stringify([
+          goal.status,
+          goal.objective,
+          goal.keyResults,
+        ]);
+        fn(goal);
+        goal.revision = revision + 1;
+        goal.controlGeneration =
+          generation +
+          (controls !==
+          JSON.stringify([goal.status, goal.objective, goal.keyResults])
+            ? 1
+            : 0);
+        goal.updatedAt = nowIso();
+        atomicWriteFileSync(goalFile(root, id), JSON.stringify(goal, null, 2));
+        return goal;
+      }
+      if (
+        opts.expectedRevision !== undefined &&
+        (!Number.isSafeInteger(opts.expectedRevision) ||
+          opts.expectedRevision !== before.revision)
+      )
+        throw goalError("GOAL_REVISION_CONFLICT");
       fn(goal);
-      return saveGoal(goal, opts);
+      return saveGoal(goal, opts, before);
     },
     { failIfUnavailable: true },
   );
@@ -385,6 +487,15 @@ export function deleteGoal(id, opts = {}) {
     file,
     () => {
       if (!fs.existsSync(file)) return false;
+      if (opts.expectedRevision !== undefined) {
+        const current = getGoal(id, { root });
+        if (
+          !current ||
+          !Number.isSafeInteger(opts.expectedRevision) ||
+          opts.expectedRevision !== (current.revision ?? 1)
+        )
+          throw goalError("GOAL_REVISION_CONFLICT");
+      }
       fs.rmSync(file);
       return true;
     },
@@ -419,3 +530,101 @@ export function resolveActiveGoal(sel = {}, opts = {}) {
   // Ambiguous (multiple active, none linked) — caller must pick explicitly.
   return null;
 }
+
+/** Injectable repository adapter using the same files/strict locks as cc goal.
+ * Reading a legacy file upgrades the returned view only; it never rewrites the
+ * file, binds an owner or enables scheduling. */
+export function createGoalFileAdapter(opts = {}) {
+  const root = opts.root || defaultRoot();
+  const storeId = goalFileStoreId(root);
+  function read(id) {
+    if (isUnsafeGoalId(id)) throw goalError("GOAL_INVALID_ID");
+    const file = goalFile(root, id);
+    if (!fs.existsSync(file)) return null;
+    let value;
+    try {
+      value = JSON.parse(fs.readFileSync(file, "utf8"));
+    } catch {
+      throw goalError("GOAL_RECORD_CORRUPT");
+    }
+    const record = fileRecord(value, root);
+    if (record.id !== id) throw goalError("GOAL_RECORD_CORRUPT");
+    return record;
+  }
+  return Object.freeze({
+    storeId,
+    get: read,
+    create(value) {
+      const record = fileRecord(value, root);
+      if (isUnsafeGoalId(record.id)) throw goalError("GOAL_INVALID_ID");
+      if (
+        record.revision !== 1 ||
+        record.controlGeneration !== 0 ||
+        record.status !== "active"
+      )
+        throw goalError("GOAL_INVALID_INITIAL_STATE");
+      ensureDir(root);
+      return withFileLock(
+        goalFile(root, record.id),
+        () => {
+          if (fs.existsSync(goalFile(root, record.id)))
+            throw goalError("GOAL_ALREADY_EXISTS");
+          atomicWriteFileSync(
+            goalFile(root, record.id),
+            JSON.stringify(record, null, 2),
+          );
+          return record;
+        },
+        { failIfUnavailable: true },
+      );
+    },
+    compareAndSwap(id, expectedRevision, transform) {
+      if (isUnsafeGoalId(id)) throw goalError("GOAL_INVALID_ID");
+      if (
+        !Number.isSafeInteger(expectedRevision) ||
+        expectedRevision < 1 ||
+        typeof transform !== "function"
+      )
+        throw goalError("GOAL_INVALID_REVISION");
+      if (!fs.existsSync(goalFile(root, id)))
+        throw goalError("GOAL_NOT_FOUND_OR_DENIED");
+      return withFileLock(
+        goalFile(root, id),
+        () => {
+          const current = read(id);
+          if (current === null) throw goalError("GOAL_NOT_FOUND_OR_DENIED");
+          if (current.revision !== expectedRevision)
+            throw goalError("GOAL_REVISION_CONFLICT");
+          const next = fileRecord(validateGoalRecord(transform(current)), root);
+          if (
+            next.id !== id ||
+            next.revision !== current.revision + 1 ||
+            next.controlGeneration < current.controlGeneration
+          )
+            throw goalError("GOAL_INVALID_REPLACEMENT");
+          atomicWriteFileSync(
+            goalFile(root, id),
+            JSON.stringify(next, null, 2),
+          );
+          return next;
+        },
+        { failIfUnavailable: true },
+      );
+    },
+    list({ status } = {}) {
+      if (status !== undefined && !STATUS_VALUES.has(status))
+        throw goalError("GOAL_INVALID_STATUS");
+      if (!fs.existsSync(root)) return [];
+      return fs
+        .readdirSync(root)
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => read(name.slice(0, -5)))
+        .filter(
+          (record) =>
+            record !== null &&
+            (status === undefined || record.status === status),
+        )
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    },
+  });
+}

package/src/lib/process-execution-broker/index.js

@@ -46,6 +46,7 @@ import {
   SANDBOX_BOUNDARIES,
 } from "./platform-sandbox.js";
 import { normalizeLinuxCgroupPolicy } from "./linux-cgroup-v2.js";
+import { consumeWindowsNativeEvaluatorPolicy } from "./windows-native-evaluator.js";
 import { acquireLinuxSubreaperHelper } from "./linux-subreaper-helper.js";
 import { spawnLinuxSubreaperChild } from "./linux-subreaper-process.js";
 import {
@@ -1625,7 +1626,49 @@ class ProcessExecutionBroker extends EventEmitter {
       requiredBoundaries,
       launch,
     );
-    return { profile, requiredBoundaries, linuxCgroup, executionContract };
+    const wallTimeMs = rawPolicy?.limits?.wallTimeMs;
+    if (wallTimeMs !== undefined) {
+      if (
+        !Number.isSafeInteger(wallTimeMs) ||
+        wallTimeMs < 1 ||
+        wallTimeMs > 3600000
+      ) {
+        throw this._sandboxBoundaryError(
+          "invalid_wall_time_limit",
+          "Native wall-time limit must be an integer from 1 to 3600000 milliseconds",
+        );
+      }
+      if (!requiredBoundaries.includes(SANDBOX_BOUNDARIES.RESOURCE_LIMITS)) {
+        requiredBoundaries.push(SANDBOX_BOUNDARIES.RESOURCE_LIMITS);
+      }
+    }
+    const windowsNativeEvaluator =
+      rawPolicy?.windowsNativeEvaluator === undefined
+        ? null
+        : consumeWindowsNativeEvaluatorPolicy(
+            rawPolicy.windowsNativeEvaluator,
+            launch,
+            options,
+          );
+    if (windowsNativeEvaluator) {
+      for (const boundary of [
+        SANDBOX_BOUNDARIES.FILESYSTEM,
+        SANDBOX_BOUNDARIES.NETWORK,
+        SANDBOX_BOUNDARIES.PROCESS_TREE,
+        SANDBOX_BOUNDARIES.RESOURCE_LIMITS,
+      ]) {
+        if (!requiredBoundaries.includes(boundary))
+          requiredBoundaries.push(boundary);
+      }
+    }
+    return {
+      profile,
+      requiredBoundaries,
+      linuxCgroup,
+      executionContract,
+      ...(windowsNativeEvaluator ? { windowsNativeEvaluator } : {}),
+      ...(wallTimeMs !== undefined ? { wallTimeMs } : {}),
+    };
   }
 
   _stripSandboxControlOptions(options) {
@@ -3660,6 +3703,12 @@ class ProcessExecutionBroker extends EventEmitter {
       ...(sandboxPolicy.executionContract
         ? { executionContract: sandboxPolicy.executionContract }
         : {}),
+      ...(sandboxPolicy.wallTimeMs !== undefined
+        ? { limits: Object.freeze({ wallTimeMs: sandboxPolicy.wallTimeMs }) }
+        : {}),
+      ...(sandboxPolicy.windowsNativeEvaluator
+        ? { windowsNativeEvaluator: sandboxPolicy.windowsNativeEvaluator }
+        : {}),
     });
     // Keep the legacy string profile in argument four. The built-in adapter
     // reserves argument five for runtime injection, so the typed request is
@@ -3667,6 +3716,12 @@ class ProcessExecutionBroker extends EventEmitter {
     const sandboxAdapter = this._sandboxAdapter;
     const applySandboxAdapter = sandboxAdapter.applySandbox;
     const builtInSandboxAdapter = applySandboxAdapter === _applySandbox;
+    if (sandboxPolicy.wallTimeMs !== undefined && !builtInSandboxAdapter) {
+      throw this._sandboxBoundaryError(
+        "native_wall_time_adapter_unattested",
+        "Native wall-time enforcement requires the built-in Windows supervisor",
+      );
+    }
     // Never dispatch the built-in through a mutable Function property or a
     // global reflective helper after consulting an injected adapter getter.
     // The lexical import is the identity we checked and the implementation we
@@ -3690,6 +3745,41 @@ class ProcessExecutionBroker extends EventEmitter {
         ]);
     let plan;
     try {
+      if (
+        sandboxPolicy.wallTimeMs !== undefined &&
+        (!rawPlan?.applied ||
+          rawPlan.platform !== "win32" ||
+          ![
+            "windows-job-restricted-token",
+            "windows-appcontainer-job-restricted-token",
+          ].includes(rawPlan.backend) ||
+          rawPlan.windowsWallTimeMs !== sandboxPolicy.wallTimeMs)
+      ) {
+        throw this._sandboxBoundaryError(
+          "native_wall_time_limit_unavailable",
+          `The requested native wall-time limit was not enforced: ${rawPlan?.reason || "unattested_plan"}`,
+          {
+            requiredBoundaries,
+            actualGuarantees: rawPlan?.guarantees || [],
+            sandboxBackend: rawPlan?.backend,
+            sandboxCandidateBackend: rawPlan?.candidateBackend,
+            sandboxRuntimeProbe: rawPlan?.runtimeProbe,
+            sandboxCandidateReason: rawPlan?.reason,
+          },
+        );
+      }
+      if (
+        sandboxPolicy.windowsNativeEvaluator &&
+        (rawPlan.backend !== "windows-appcontainer-job-restricted-token" ||
+          rawPlan.policyAttested !== true ||
+          rawPlan.windowsNativeEvaluatorDigest !==
+            sandboxPolicy.windowsNativeEvaluator.manifestDigest)
+      ) {
+        throw this._sandboxBoundaryError(
+          "native_evaluator_plan_unattested",
+          "The staged native evaluator policy was not enforced",
+        );
+      }
       plan = this._validateSandboxPlan(rawPlan, {
         command,
         args: Object.freeze([...(args || [])]),

package/src/lib/process-execution-broker/platform-sandbox.js

@@ -783,6 +783,8 @@ function normalizeSandboxRequest(profileOrRequest, explicitRequest) {
     profile,
     requiredBoundaries,
     sync: request.sync === true,
+    wallTimeMs: request.limits?.wallTimeMs,
+    windowsNativeEvaluator: request.windowsNativeEvaluator || null,
     pty: request.pty === true,
     linuxCgroup: normalizeLinuxCgroupPolicy(request.linuxCgroup),
     executionContract:
@@ -2106,6 +2108,12 @@ export function applyMacSandbox(
       reason: "platform_mismatch",
     });
   }
+  if (sandboxOpts.limits?.wallTimeMs !== undefined) {
+    return createSandboxPlan({
+      ...base,
+      reason: "native_wall_time_limit_unsupported",
+    });
+  }
 
   if (
     Array.isArray(sandboxOpts.requiredBoundaries) &&
@@ -4205,10 +4213,14 @@ function windowsAppContainerPolicyDigest({
       },
       job: {
         killOnClose: true,
+        wallTimeMs: launchSpec.wallTimeMs,
         activeProcessLimit: launchSpec.activeProcessLimit,
         cpuSeconds: launchSpec.cpuSeconds,
         processMemoryBytes: launchSpec.processMemoryBytes,
       },
+      ...(launchSpec.nativeEvaluator
+        ? { nativeEvaluator: launchSpec.nativeEvaluator }
+        : {}),
       execution: {
         contractKind: executionContract?.kind || null,
         contentSnapshot: snapshotLocks.length > 0,
@@ -4310,6 +4322,15 @@ export function applyWindowsSandbox(
   if (runtime.platform !== "win32") {
     return unavailablePlan("platform_mismatch");
   }
+  const wallTimeMs = sandboxOpts.limits?.wallTimeMs ?? 0;
+  if (
+    sandboxOpts.limits?.wallTimeMs !== undefined &&
+    (!Number.isSafeInteger(wallTimeMs) ||
+      wallTimeMs < 1 ||
+      wallTimeMs > 3600000)
+  ) {
+    return unavailablePlan("windows_wall_time_limit_invalid");
+  }
   let windowsDirectory;
   try {
     windowsDirectory = path.win32.resolve(runtime.windowsDir());
@@ -4499,6 +4520,7 @@ export function applyWindowsSandbox(
     }
   }
   const launchSpec = {
+    wallTimeMs,
     cpuSeconds: Number(limits.cpu || 0),
     processMemoryBytes: Number(
       limits.as || (profile === "strict" ? 256 * 1024 * 1024 : 0),
@@ -4516,6 +4538,9 @@ export function applyWindowsSandbox(
     windowsHide: invocation.options.windowsHide === true,
     workingDirectory: targetWorkingDirectory,
     environment: targetEnvironment,
+    ...(sandboxOpts.windowsNativeEvaluator
+      ? { nativeEvaluator: sandboxOpts.windowsNativeEvaluator }
+      : {}),
   };
   if (entrySnapshot.locks) {
     launchSpec.launchPathLocks = entrySnapshot.locks;
@@ -4917,6 +4942,9 @@ export function applyWindowsSandbox(
     policyAttested: requiresAppContainer ? true : null,
     policyDigest: appContainerPolicyDigest,
     adapterTempRootAttestation: adapterSource.tempRootAttestation,
+    windowsWallTimeMs: wallTimeMs || null,
+    windowsNativeEvaluatorDigest:
+      sandboxOpts.windowsNativeEvaluator?.manifestDigest || null,
     runtimeProbe: entrySnapshotRuntimeProbe,
     guarantees: [
       ...(requiresAppContainer
@@ -8896,6 +8924,13 @@ export function applyLinuxSandbox(
     });
   }
 
+  if (sandboxOpts.limits?.wallTimeMs !== undefined) {
+    return createSandboxPlan({
+      ...base,
+      reason: "native_wall_time_limit_unsupported",
+    });
+  }
+
   const { limits = {} } = sandboxOpts;
   const requiredBoundaries = Array.isArray(sandboxOpts.requiredBoundaries)
     ? sandboxOpts.requiredBoundaries
@@ -9984,7 +10019,14 @@ export function applySandbox(
     pty: sandboxRequest.pty,
     linuxCgroup: sandboxRequest.linuxCgroup,
     executionContract: sandboxRequest.executionContract,
+    windowsNativeEvaluator: sandboxRequest.windowsNativeEvaluator,
   };
+  if (sandboxRequest.wallTimeMs !== undefined) {
+    profile.limits = {
+      ...profile.limits,
+      wallTimeMs: sandboxRequest.wallTimeMs,
+    };
+  }
 
   const applyRequestedLinuxCgroup = (plan) =>
     applyLinuxCgroupV2ToPlan(plan, sandboxRequest.linuxCgroup, {