chainlesschain 0.162.188 → 0.162.193

package/src/lib/artifact-store.js

@@ -60,6 +60,8 @@ export function publicArtifactMetadata(entry) {
     sessionId,
     createdAt,
     expiresAt,
+    immutable,
+    recordDigest,
   } = entry;
   return {
     id,
@@ -72,6 +74,8 @@ export function publicArtifactMetadata(entry) {
     sessionId,
     createdAt,
     expiresAt,
+    immutable: immutable === true,
+    recordDigest: recordDigest || null,
   };
 }
 
@@ -158,8 +162,70 @@ export class ArtifactStore {
       );
     }
     const body = fs.readFileSync(abs);
+    return this._publishData(body, {
+      fileName: path.basename(abs),
+      title,
+      kind,
+      sessionId,
+      ttlDays,
+      sourcePath: abs,
+    });
+  }
+
+  /**
+   * Publish generated bytes without an intermediate temp file. This is used by
+   * versioned evidence records so the exact digested JSON bytes are the bytes
+   * stored in the artifact directory.
+   */
+  publishData({
+    data,
+    fileName = "artifact.bin",
+    title,
+    kind,
+    mime,
+    sessionId = null,
+    ttlDays,
+    immutable = false,
+    recordDigest = null,
+  } = {}) {
+    if (typeof data !== "string" && !Buffer.isBuffer(data)) {
+      throw new Error("publishData requires string or Buffer data");
+    }
+    return this._publishData(Buffer.from(data), {
+      fileName,
+      title,
+      kind,
+      mime,
+      sessionId,
+      ttlDays,
+      immutable,
+      recordDigest,
+      sourcePath: null,
+    });
+  }
+
+  _publishData(
+    body,
+    {
+      fileName,
+      title,
+      kind,
+      mime,
+      sessionId,
+      ttlDays,
+      immutable = false,
+      recordDigest = null,
+      sourcePath = null,
+    },
+  ) {
+    if (body.length > MAX_ARTIFACT_BYTES) {
+      throw new Error(
+        `artifact too large (${body.length} bytes > ${MAX_ARTIFACT_BYTES}); artifacts are deliverables, not build output`,
+      );
+    }
+    const safeFileName = path.basename(String(fileName || "artifact.bin"));
     const sha256 = crypto.createHash("sha256").update(body).digest("hex");
-    const ext = path.extname(abs);
+    const ext = path.extname(safeFileName);
     const id = `art_${this._now().toString(36)}_${crypto
       .randomBytes(4)
       .toString("hex")}`;
@@ -169,19 +235,30 @@ export class ArtifactStore {
     const createdAt = this._now();
     const entry = {
       id,
-      title: String(title || path.basename(abs)),
+      title: String(title || safeFileName),
       kind: normalizeKind(kind),
-      mime: mimeForExt(ext),
-      size: stat.size,
+      mime: mime ? String(mime) : mimeForExt(ext),
+      size: body.length,
       sha256,
-      sourcePath: abs,
+      sourcePath,
       file: `${id}${ext}`,
       sessionId: sessionId ? String(sessionId) : null,
       createdAt: new Date(createdAt).toISOString(),
       expiresAt: new Date(createdAt + days * 24 * 60 * 60 * 1000).toISOString(),
+      immutable: immutable === true,
+      recordDigest: recordDigest ? String(recordDigest) : null,
     };
     this._ensureDirs();
-    fs.writeFileSync(path.join(this._filesDir(), entry.file), body);
+    const storedPath = path.join(this._filesDir(), entry.file);
+    fs.writeFileSync(storedPath, body, { flag: "wx" });
+    if (entry.immutable) {
+      try {
+        fs.chmodSync(storedPath, 0o444);
+      } catch {
+        // The content hash still detects mutation on filesystems without mode
+        // support; immutable here means append-only/no update API, not WORM.
+      }
+    }
     fs.appendFileSync(this._indexFile(), JSON.stringify(entry) + "\n", "utf-8");
     return entry;
   }
@@ -223,13 +300,59 @@ export class ArtifactStore {
     return path.join(this._filesDir(), entry.file);
   }
 
+  /** Recompute the stored copy's digest; unknown/missing bytes fail closed. */
+  verifyIntegrity(idOrEntry) {
+    const entry =
+      typeof idOrEntry === "object" && idOrEntry
+        ? idOrEntry
+        : this.get(idOrEntry);
+    if (!entry) {
+      return {
+        ok: false,
+        reason: "artifact-not-found",
+        expectedSha256: null,
+        actualSha256: null,
+      };
+    }
+    let body;
+    try {
+      body = fs.readFileSync(this.storedPath(entry));
+    } catch {
+      return {
+        ok: false,
+        reason: "artifact-bytes-unavailable",
+        expectedSha256: entry.sha256 || null,
+        actualSha256: null,
+      };
+    }
+    const actualSha256 = crypto.createHash("sha256").update(body).digest("hex");
+    return {
+      ok: actualSha256 === entry.sha256,
+      reason: actualSha256 === entry.sha256 ? "ok" : "artifact-digest-mismatch",
+      expectedSha256: entry.sha256 || null,
+      actualSha256,
+    };
+  }
+
+  _deleteStoredFile(entry) {
+    const storedPath = this.storedPath(entry);
+    if (entry?.immutable) {
+      try {
+        fs.chmodSync(storedPath, 0o666);
+      } catch {
+        // Explicit deletion remains best-effort on filesystems without modes.
+      }
+    }
+    fs.rmSync(storedPath, { force: true });
+  }
+
   /** Remove one artifact (file + index row). @returns {boolean} found */
   remove(id) {
     const entries = this.list();
     const target = entries.find((e) => e.id === id);
     if (!target) return false;
     try {
-      fs.rmSync(this.storedPath(target), { force: true });
+      this._deleteStoredFile(target);
     } catch {
       /* best-effort — the index row is the source of truth */
     }
@@ -250,7 +373,7 @@ export class ArtifactStore {
       const exp = Date.parse(e.expiresAt || "");
       if (Number.isFinite(exp) && exp <= now) {
         try {
-          fs.rmSync(this.storedPath(e), { force: true });
+          this._deleteStoredFile(e);
         } catch {
           /* best-effort */
         }

package/src/lib/background-agent-supervisor.js

@@ -22,6 +22,16 @@ import {
 } from "./agent-worktree.js";
 import { rejectPendingBackgroundInteractions } from "./background-interaction-journal.js";
 import executionBroker from "./process-execution-broker/index.js";
+import {
+  assessBackgroundLaunchProfileCompatibility,
+  buildArgvFromBackgroundLaunchProfile,
+  captureBackgroundLaunchProfile,
+  fingerprintBackgroundLaunchProfile,
+  normalizeBackgroundLaunchProfile,
+  refreshBackgroundLaunchProfileSources,
+  stripBackgroundLaunchSecrets,
+  verifyBackgroundLaunchProfileSources,
+} from "./background-launch-profile.js";
 
 export const DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
 export const DEFAULT_HEARTBEAT_STALE_MS = 120000;
@@ -364,10 +374,40 @@ export function writeBackgroundAgentState(state) {
         branch: current.branch,
       };
     }
+    // The launch profile is immutable same-id identity. A heartbeat/finalize
+    // writer holding an older snapshot must never drop it and silently turn a
+    // profile-aware record back into legacy minimal-resume semantics.
+    if (current.launchProfile) {
+      next = {
+        ...next,
+        launchProfile: current.launchProfile,
+        configFingerprint: current.configFingerprint,
+      };
+    }
   }
-  const tmp = `${target}.${process.pid}.tmp`;
+  // Multiple async state writers can run in one process; a pid-only temporary
+  // name lets them overwrite each other's staging file. A unique suffix keeps
+  // each atomic replacement independent. Windows scanners/readers can also
+  // hold the destination for a few milliseconds, so retry only that bounded
+  // transient class rather than surfacing a spurious EPERM background failure.
+  const tmp = `${target}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
   writeFileSync(tmp, JSON.stringify(next, null, 2), { mode: 0o600 });
-  renameSync(tmp, target);
+  for (let attempt = 0; ; attempt++) {
+    try {
+      renameSync(tmp, target);
+      break;
+    } catch (error) {
+      if (
+        process.platform !== "win32" ||
+        !new Set(["EPERM", "EACCES", "EBUSY"]).has(error?.code) ||
+        attempt >= 5
+      ) {
+        rmSync(tmp, { force: true });
+        throw error;
+      }
+      sleepSyncMs(5 * (attempt + 1));
+    }
+  }
   return next;
 }
 
@@ -860,13 +900,23 @@ function persistedWorktree(state) {
 }
 
 /**
- * Continue a finished/crashed background session as a NEW background session
- * on the same conversation (`cc daemon resume <id> <prompt>`). The original
- * launch argv is intentionally NOT persisted (it may carry secrets), so the
- * resume runs a minimal `agent --session <sid> -p <prompt>` — model/provider
- * come from config defaults, and the headless runner replays the JSONL
- * transcript for the session id.
+ * Continue a finished/crashed run as a NEW background agent on the same
+ * conversation. Versioned records rebuild their secret-free launch profile;
+ * legacy records retain the old minimal argv behavior. Callers must explicitly
+ * opt in before an incompatible profile override can change the run envelope.
  */
+function incompatibleLaunchProfileError(id, reasons) {
+  const normalized = Array.isArray(reasons) ? reasons.filter(Boolean) : [];
+  const error = new Error(
+    `Background agent ${id} launch profile is incompatible: ${
+      normalized.join(", ") || "unknown profile mismatch"
+    }. Refusing to resume without an explicit compatibility override.`,
+  );
+  error.code = "BACKGROUND_LAUNCH_PROFILE_INCOMPATIBLE";
+  error.reasons = normalized;
+  return error;
+}
+
 export function resumeBackgroundAgent(id, prompt, options = {}) {
   const state = effectiveBackgroundAgentState(readBackgroundAgentState(id), {
     now: options.now,
@@ -893,7 +943,88 @@ export function resumeBackgroundAgent(id, prompt, options = {}) {
       `Background agent ${id} is bound to worktree "${worktree.worktreePath}" and cannot resume in a different cwd`,
     );
   }
-  const argv = ["agent", "--session", state.sessionId, "-p", text];
+  let launchProfile = null;
+  if (state.launchProfile) {
+    let persisted;
+    try {
+      persisted = normalizeBackgroundLaunchProfile(state.launchProfile);
+    } catch (error) {
+      throw incompatibleLaunchProfileError(id, [
+        `invalid-profile:${error.message}`,
+      ]);
+    }
+    const actualFingerprint = fingerprintBackgroundLaunchProfile(persisted);
+    const storedFingerprint =
+      state.configFingerprint || state.launchProfileFingerprint || null;
+    const explicitReplacement =
+      options.launchProfileOverride &&
+      options.allowIncompatibleProfile === true;
+    if (storedFingerprint !== actualFingerprint && !explicitReplacement) {
+      throw incompatibleLaunchProfileError(id, [
+        storedFingerprint
+          ? "profile-fingerprint-mismatch"
+          : "profile-fingerprint-missing",
+      ]);
+    }
+
+    if (options.launchProfileOverride) {
+      let proposed;
+      try {
+        proposed = normalizeBackgroundLaunchProfile(
+          options.launchProfileOverride,
+        );
+      } catch (error) {
+        throw incompatibleLaunchProfileError(id, [
+          `invalid-profile-override:${error.message}`,
+        ]);
+      }
+      const compatibility = assessBackgroundLaunchProfileCompatibility(
+        persisted,
+        proposed,
+      );
+      if (
+        !compatibility.compatible &&
+        options.allowIncompatibleProfile !== true
+      ) {
+        throw incompatibleLaunchProfileError(id, compatibility.reasons);
+      }
+      launchProfile = proposed;
+    } else {
+      launchProfile = persisted;
+    }
+
+    const sourceCheck = verifyBackgroundLaunchProfileSources(launchProfile);
+    if (!sourceCheck.valid && options.allowIncompatibleProfile !== true) {
+      throw incompatibleLaunchProfileError(id, sourceCheck.issues);
+    }
+    if (!sourceCheck.valid) {
+      launchProfile = refreshBackgroundLaunchProfileSources(launchProfile);
+    }
+    if (
+      launchProfile.credentials.apiKey === "external" &&
+      !options.apiKey &&
+      !process.env.CC_API_KEY
+    ) {
+      throw incompatibleLaunchProfileError(id, [
+        "external-api-key-unavailable",
+      ]);
+    }
+  } else if (options.launchProfileOverride) {
+    // Explicit profiles can migrate legacy records, which have no prior
+    // launch envelope to compare against.
+    launchProfile = normalizeBackgroundLaunchProfile(
+      options.launchProfileOverride,
+    );
+  }
+
+  const followUpArgv = launchProfile
+    ? [
+        ...buildArgvFromBackgroundLaunchProfile(launchProfile),
+        "--session",
+        state.sessionId,
+      ]
+    : ["agent", "--session", state.sessionId];
+  const argv = [...followUpArgv, "-p", text];
   return launchBackgroundAgent({
     argv,
     // Worktree sessions fail closed: never fall back to process.cwd(), which
@@ -902,9 +1033,19 @@ export function resumeBackgroundAgent(id, prompt, options = {}) {
     sessionId: state.sessionId,
     title: options.title || state.title || text.slice(0, 100),
     cliEntry: options.cliEntry,
-    followUpArgv: ["agent", "--session", state.sessionId],
+    followUpArgv,
     worktree,
-    governance: state.governance,
+    governance: launchProfile
+      ? {
+          permissionMode: launchProfile.permission.mode,
+          resourceBudget: {
+            maxTurns: launchProfile.budget.maxTurns,
+            maxCostUsd: launchProfile.budget.maxCostUsd,
+          },
+        }
+      : state.governance,
+    launchProfile,
+    apiKey: options.apiKey,
   });
 }
 
@@ -944,6 +1085,8 @@ export function launchBackgroundAgent({
   followUpArgv,
   worktree,
   governance,
+  launchProfile,
+  apiKey,
 }) {
   assertUsableCwd(cwd);
   const worktreeState = normalizeBackgroundWorktree(worktree, cwd);
@@ -952,6 +1095,28 @@ export function launchBackgroundAgent({
     id,
     sessionId,
   });
+  const initialSecrets = stripBackgroundLaunchSecrets(argv);
+  const followUpSecrets = stripBackgroundLaunchSecrets(followUpArgv);
+  const forwardedApiKey =
+    apiKey || initialSecrets.apiKey || followUpSecrets.apiKey || null;
+  const runtimeApiKey = forwardedApiKey || process.env.CC_API_KEY || null;
+  let launchProfileState = launchProfile
+    ? normalizeBackgroundLaunchProfile(launchProfile)
+    : captureBackgroundLaunchProfile({
+        argv,
+        cwd,
+        worktree: worktreeState,
+        governance: governanceState,
+      });
+  if (runtimeApiKey && launchProfileState.credentials.apiKey !== "external") {
+    launchProfileState = normalizeBackgroundLaunchProfile({
+      ...launchProfileState,
+      credentials: { apiKey: "external" },
+      omitted: [...launchProfileState.omitted, "apiKey"],
+    });
+  }
+  const configFingerprint =
+    fingerprintBackgroundLaunchProfile(launchProfileState);
   const dir = backgroundAgentsDir();
   const jobFile = join(dir, `${id}.job.${process.pid}.json`);
   const worker = fileURLToPath(
@@ -959,7 +1124,7 @@ export function launchBackgroundAgent({
   );
   const job = {
     id,
-    argv,
+    argv: initialSecrets.argv,
     cwd,
     sessionId,
     title: title || "Background agent",
@@ -969,7 +1134,9 @@ export function launchBackgroundAgent({
     governance: governanceState,
     // Present = interactive attach can start follow-up turns; absent = the
     // transport rejects prompts (log-only session).
-    ...(Array.isArray(followUpArgv) ? { followUpArgv } : {}),
+    ...(Array.isArray(followUpArgv)
+      ? { followUpArgv: followUpSecrets.argv }
+      : {}),
   };
   writeFileSync(jobFile, JSON.stringify(job), { mode: 0o600 });
   // Write the initial state BEFORE spawning so the worker's own merges (the
@@ -992,6 +1159,8 @@ export function launchBackgroundAgent({
     logFile: job.logFile,
     ...(worktreeState || {}),
     governance: governanceState,
+    launchProfile: launchProfileState,
+    configFingerprint,
   };
   writeBackgroundAgentState(state);
   let child;
@@ -1007,6 +1176,9 @@ export function launchBackgroundAgent({
       detached: true,
       stdio: ["ignore", workerLogFd, workerLogFd],
       windowsHide: true,
+      ...(forwardedApiKey
+        ? { env: { ...process.env, CC_API_KEY: forwardedApiKey } }
+        : {}),
       origin: "background-agent:worker",
       policy: "allow",
       scope: "background-agent",

package/src/lib/background-interaction-journal.js

@@ -11,6 +11,7 @@ import { createHash } from "node:crypto";
 import {
   appendEvent as storeAppendEvent,
   readEvents as storeReadEvents,
+  findLatestEvent as storeFindLatestEvent,
 } from "../harness/jsonl-session-store.js";
 import {
   normalizeInteractionBinding,
@@ -27,8 +28,41 @@ const TERMINAL_STATUSES = new Set(["resolved", "rejected", "cancelled"]);
 export const _deps = {
   appendEvent: storeAppendEvent,
   readEvents: storeReadEvents,
+  findLatestEvent: storeFindLatestEvent,
 };
 
+function findLatestJournalEvent(sessionId, backgroundAgentId) {
+  const valid = (event) => event?.data?.backgroundAgentId === backgroundAgentId;
+  if (
+    typeof _deps.findLatestEvent === "function" &&
+    _deps.findLatestEvent !== storeFindLatestEvent
+  ) {
+    return _deps.findLatestEvent(
+      sessionId,
+      BACKGROUND_INTERACTION_JOURNAL_EVENT,
+      valid,
+    );
+  }
+  if (_deps.readEvents !== storeReadEvents) {
+    const events = _deps.readEvents(sessionId) || [];
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (
+        event?.type === BACKGROUND_INTERACTION_JOURNAL_EVENT &&
+        valid(event)
+      ) {
+        return event;
+      }
+    }
+    return null;
+  }
+  return storeFindLatestEvent(
+    sessionId,
+    BACKGROUND_INTERACTION_JOURNAL_EVENT,
+    valid,
+  );
+}
+
 function journalError(message, code, details = {}) {
   const error = new Error(message);
   error.code = code;
@@ -316,15 +350,9 @@ export function loadBackgroundInteractionJournal(
     if (!sessionId || !backgroundAgentId) {
       throw new TypeError("sessionId and backgroundAgentId are required");
     }
-    const events = _deps.readEvents(sessionId) || [];
-    for (let index = events.length - 1; index >= 0; index--) {
-      const event = events[index];
-      if (
-        event?.type === BACKGROUND_INTERACTION_JOURNAL_EVENT &&
-        event.data?.backgroundAgentId === backgroundAgentId
-      ) {
-        return BackgroundInteractionJournal.fromJSON(event.data, options);
-      }
+    const event = findLatestJournalEvent(sessionId, backgroundAgentId);
+    if (event) {
+      return BackgroundInteractionJournal.fromJSON(event.data, options);
     }
     return new BackgroundInteractionJournal({
       backgroundAgentId,