chainlesschain 0.166.91 → 0.166.93

package/src/data/changelog.json

@@ -1,6 +1,58 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.93",
+      "cliVersions": ["0.166.93"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.93: bounded investigations and release evidence",
+          "body": "- Bound repeated IDE evidence inspections and all phases of authenticated\n  artifact byte reads, including directory, index, identity, and history checks.\n- Publish Session Core `0.3.18` and Context Memory Kernel `0.1.8` before CLI\n  `0.166.93`, with exact dependency\n  pins and registry-only readback of the published child package.\n- Include organization goal acceptance, periodic monitoring, memory, risk\n  review, transfer, workflow, and notification services in Session Core.\n- Register the organization goal memory adapter as a Kernel capability client,\n  preserving the single canonical memory writer in the published inventory.\n- Support immediate transactions and nested savepoints in desktop SQLite\n  compatibility adapters, and verify notification reads after login and denial\n  after logout with a real Electron session.\n- Correct browser timer and synchronous subscription types in goal memory\n  panels and retain their disposal behavior.\n- Install exact-checkout dependencies in the accessibility/performance\n  aggregate job before verifying Linux, Windows, and macOS evidence.\n- Pair VS Code `0.37.138` and JetBrains `0.4.156` after CLI publication;\n  release desktop/mobile `v5.0.3.140` after both IDE release stages."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.92",
+      "cliVersions": ["0.166.92"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.92: private storage and release regression repairs",
+          "body": "- Publish Session Core `0.3.17` and Context Memory Kernel `0.1.7` before CLI\n  `0.166.92`, with exact CLI dependency pins and public package readback.\n- Stage the actual Session Core package in isolated CLI and desktop fixtures;\n  missing private-storage code fails the fixture checks. Extract the complete\n  packed library when validating new transitive authorization dependencies.\n- Compare temporary fixture paths by their physical identity on Windows and\n  macOS while retaining production symlink and path-admission checks.\n- Preserve full 64-bit RRSI directory and marker identities on Windows so\n  distinct objects cannot collide after numeric rounding. Existing identity\n  mismatches still hold the store without rewriting authenticated records.\n- Create SQLite WAL/SHM files before applying final private-storage protection,\n  including owner-only Windows ACLs when goal schedulers reopen their stores.\n- Exclude validated browser digest metadata from Record & Replay content scans;\n  malformed metadata and sensitive values in user content still fail review.\n- Avoid repeating the same authenticated journal read for each signed sibling\n  in the cohort enrollment regression test; keep every admission assertion.\n- Stop canceled execution-location workflows from reporting missing producer\n  artifacts as a new aggregate failure; failed producers still fail the gate.\n- Await main-process logout in desktop tests and preserve the UI session until\n  revocation succeeds. Failed or unavailable revocation still rejects logout.\n- Require the parent to acknowledge RRSI process-test results before workers\n  disconnect, retaining both the competing-process assertions and exit checks.\n- Pair VS Code `0.37.137` and JetBrains `0.4.155` with CLI `0.166.92`. Disable\n  development plugin hot reload in the JetBrains test host so restart validation\n  retains both the packaged plugin and its UI driver.\n- Require the authorized CLI and downloadable OIDC-published child packages\n  before desktop and mobile builds; remove the product workflow's npm token\n  fallback so dependency failures cannot trigger a separate npm publication."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.92",
+      "cliVersions": ["0.166.92"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - CLI 0.166.92: organization workflows and authenticated registry reads",
+          "body": "- Carry the committed organization project workbench into the desktop product\n  candidate, with project setup, saved proposals and governed task actions.\n  Session Core `0.3.17` includes the proposal store used by those host services.\n- Bind RRSI Registry read-only construction to authenticated backend evidence.\n  Read-only queries require that construction authority and retain checks for\n  replacement and mutation instead of creating a fresh writable registry."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.92",
+      "cliVersions": ["0.166.92"],
+      "date": "2026-10-07",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Upgrade - CLI 0.166.92 and product v5.0.3.139 candidates (2026-10-07)",
+          "body": "- These versions are release candidates until the final versioned commit passes\n  its complete GitHub Actions gates and public release verification.\n- After CLI publication, run `npm install -g chainlesschain@0.166.92`, then\n  `chainlesschain --version`. `cc changelog` includes these bundled release notes.\n  Keep the existing configuration and data directories when replacing binaries.\n- Upgrade IDE plugins after the CLI: VS Code `0.37.137` and JetBrains `0.4.155`.\n  Restart the editor and verify its CLI path. If `cc` resolves to a C compiler,\n  configure the full path to the installed ChainlessChain executable.\n- The final product stage uses desktop `5.0.3-alpha.139`, Android\n  `5.0.3.139` / code `503139`, and iOS `5.0.3` / build `139`. Install the\n  matching platform artifact after the CLI and IDE release stages finish.\n- Back up existing application data before upgrading persistent stores. Close\n  desktop clients before copying SQLite stores, and retain their WAL/SHM files\n  when present so the backup includes committed data."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.91",

package/src/lib/artifact-store.js

@@ -24,7 +24,9 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import crypto from "crypto";
+import { types as utilTypes } from "node:util";
 import { withFileLock } from "./with-file-lock.js";
+import { readBoundedArtifactFile } from "./bounded-artifact-file-read.js";
 
 export const ARTIFACT_KINDS = Object.freeze([
   "report",
@@ -144,6 +146,39 @@ function normalizeLineage(lineage) {
   return normalized;
 }
 
+function integrityReadBounds(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    utilTypes.isProxy(value) ||
+    Object.getPrototypeOf(value) !== Object.prototype ||
+    Reflect.ownKeys(value).length !== 2
+  )
+    throw new TypeError(
+      "artifact integrity bounds require exact own data fields",
+    );
+  const values = Object.fromEntries(
+    ["expectedSize", "maximumBytes"].map((name) => {
+      const field = Object.getOwnPropertyDescriptor(value, name);
+      if (!field?.enumerable || !("value" in field))
+        throw new TypeError("artifact integrity bounds cannot use accessors");
+      return [name, field.value];
+    }),
+  );
+  if (
+    !Number.isSafeInteger(values.expectedSize) ||
+    !Number.isSafeInteger(values.maximumBytes) ||
+    values.expectedSize < 0 ||
+    values.maximumBytes < 1 ||
+    values.expectedSize > values.maximumBytes ||
+    values.maximumBytes > MAX_ARTIFACT_BYTES
+  )
+    throw new TypeError(
+      "artifact integrity bounds exceed finite deliverable limits",
+    );
+  return Object.freeze(values);
+}
+
 export class ArtifactStore {
   constructor({
     dir = null,
@@ -449,8 +484,14 @@ export class ArtifactStore {
     return path.join(this._filesDir(), entry.file);
   }
 
-  /** Recompute the stored copy's digest; unknown/missing bytes fail closed. */
-  verifyIntegrity(idOrEntry) {
+  /** Explicit bounds constrain artifact bytes only; id lookup may still read the index. */
+  verifyIntegrity(idOrEntry, bounds) {
+    if (arguments.length > 2)
+      throw new TypeError(
+        "artifact integrity accepts at most one bounds object",
+      );
+    // An explicitly supplied invalid value must never select the legacy raw read.
+    const bounded = arguments.length > 1 ? integrityReadBounds(bounds) : null;
     const entry =
       typeof idOrEntry === "object" && idOrEntry
         ? idOrEntry
@@ -465,7 +506,14 @@ export class ArtifactStore {
     }
     let body;
     try {
-      body = fs.readFileSync(this.storedPath(entry));
+      const target = this.storedPath(entry);
+      body = bounded
+        ? readBoundedArtifactFile(
+            path.resolve(target),
+            bounded.expectedSize,
+            bounded.maximumBytes,
+          )
+        : fs.readFileSync(target);
     } catch {
       return {
         ok: false,

package/src/lib/bounded-artifact-file-read.js

@@ -0,0 +1,131 @@
+/** A bounded canonical-path read, not a persistent identity or authority grant. */
+import fs from "node:fs";
+import path from "node:path";
+import { readBoundedDescriptor } from "./evolution/bounded-descriptor-read.js";
+import { withEvolutionFileIdentity } from "./evolution/evolution-file-identity.js";
+import { artifactPhysicalIdentity } from "./evolution/evolution-artifact-identity.js";
+
+export const ARTIFACT_BOUNDED_READ_FAILED_CODE =
+  "CC_ARTIFACT_BOUNDED_READ_FAILED";
+const FIELDS = Object.freeze([
+  "dev",
+  "ino",
+  "mode",
+  "uid",
+  "gid",
+  "nlink",
+  "size",
+  "mtimeNs",
+  "ctimeNs",
+]);
+const MUTATION_FIELDS = Object.freeze(
+  FIELDS.filter((name) => name !== "dev" && name !== "ino"),
+);
+const DIRECTORY_FS = Object.freeze({
+  constants: fs.constants,
+  realpathSync: fs.realpathSync,
+  lstatSync: (...args) => fs.lstatSync(...args),
+  fstatSync: (...args) => fs.fstatSync(...args),
+  closeSync: (...args) => fs.closeSync(...args),
+  openSync: (target, flags) =>
+    fs.openSync(
+      target,
+      flags | (fs.constants.O_NONBLOCK || 0) | (fs.constants.O_DIRECTORY || 0),
+    ),
+});
+const canonical = (value) =>
+  process.platform === "win32" ? value.toLowerCase() : value;
+function fail(message, cause) {
+  const error = new Error(message, cause ? { cause } : undefined);
+  error.code = ARTIFACT_BOUNDED_READ_FAILED_CODE;
+  throw error;
+}
+function safeStat(stat, expectedSize, maximumBytes, label) {
+  if (FIELDS.some((name) => typeof stat?.[name] !== "bigint"))
+    fail(`${label} requires full-precision stat fields`);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n)
+    fail(`${label} must be a regular, non-symlink, single-link file`);
+  if (
+    stat.size < 0n ||
+    stat.size > BigInt(maximumBytes) ||
+    stat.size !== BigInt(expectedSize)
+  )
+    fail(`${label} differs from its bounded expected size`);
+}
+function sameMetadata(left, right) {
+  return (
+    MUTATION_FIELDS.every((name) => left[name] === right[name]) &&
+    artifactPhysicalIdentity(left).birthtimeMs ===
+      artifactPhysicalIdentity(right).birthtimeMs
+  );
+}
+function sameStat(left, right) {
+  return (
+    left.dev === right.dev &&
+    left.ino === right.ino &&
+    sameMetadata(left, right)
+  );
+}
+
+/** Read one stable window only. Callers retain hash/signature and root checks. */
+export function readBoundedArtifactFile(target, expectedSize, maximumBytes) {
+  if (
+    arguments.length !== 3 ||
+    typeof target !== "string" ||
+    !path.isAbsolute(target) ||
+    path.resolve(target) !== target ||
+    !Number.isSafeInteger(expectedSize) ||
+    !Number.isSafeInteger(maximumBytes) ||
+    expectedSize < 0 ||
+    maximumBytes < 1 ||
+    expectedSize > maximumBytes
+  )
+    throw new TypeError(
+      "bounded artifact read requires a canonical path and finite size bounds",
+    );
+  try {
+    return withEvolutionFileIdentity(DIRECTORY_FS, target, (samePathHandle) => {
+      const before = fs.lstatSync(target, { bigint: true });
+      safeStat(before, expectedSize, maximumBytes, "artifact path");
+      if (canonical(fs.realpathSync.native(target)) !== canonical(target))
+        fail("artifact path is not physically canonical");
+      const fd = fs.openSync(
+        target,
+        fs.constants.O_RDONLY |
+          (fs.constants.O_NOFOLLOW || 0) |
+          (fs.constants.O_NONBLOCK || 0),
+      );
+      try {
+        const opened = fs.fstatSync(fd, { bigint: true });
+        safeStat(opened, expectedSize, maximumBytes, "artifact descriptor");
+        if (!samePathHandle(before, opened) || !sameMetadata(before, opened))
+          fail("artifact path and descriptor identities differ");
+        const bytes = readBoundedDescriptor(
+          fs,
+          fd,
+          Number(opened.size),
+          maximumBytes,
+        );
+        const closed = fs.fstatSync(fd, { bigint: true });
+        const after = fs.lstatSync(target, { bigint: true });
+        safeStat(closed, expectedSize, maximumBytes, "artifact descriptor");
+        safeStat(after, expectedSize, maximumBytes, "artifact path");
+        if (!sameStat(opened, closed))
+          fail("artifact descriptor changed during bounded read");
+        if (
+          !sameStat(before, after) ||
+          !samePathHandle(after, closed) ||
+          !sameMetadata(after, closed) ||
+          canonical(fs.realpathSync.native(target)) !== canonical(target)
+        )
+          fail("artifact pathname changed during bounded read");
+        return bytes;
+      } finally {
+        fs.closeSync(fd);
+      }
+    });
+  } catch (cause) {
+    if (cause?.code === ARTIFACT_BOUNDED_READ_FAILED_CODE) throw cause;
+    fail("artifact bounded descriptor read failed", cause);
+  }
+}