chainlesschain 0.162.95 → 0.162.96

package/src/lib/git-integration.js

@@ -13,6 +13,34 @@ export function isGitRepo(dir) {
   return existsSync(join(dir, ".git"));
 }
 
+/**
+ * Reject a git ref (branch / base / tag) that could break out of a
+ * shell-interpolated `git` command. gitExec interpolates its args into a shell
+ * string, so a ref like `x$(rm -rf ~)`, a backtick, or `--upload-pack=evil`
+ * would otherwise execute or inject a flag (double-quoting does NOT stop `$()`
+ * / backticks). Legit refs are branch/tag names — alphanumerics plus `. _ / -`;
+ * `HEAD` and `origin/main` pass. Throws on anything else. Exported for reuse +
+ * tests; callers validate caller/agent-supplied refs before interpolation.
+ *
+ * @param {string} ref
+ * @param {string} [label="git ref"]
+ */
+export function assertSafeGitRef(ref, label = "git ref") {
+  if (typeof ref !== "string" || ref.length === 0) {
+    throw new Error(`Invalid ${label}: expected a non-empty string`);
+  }
+  if (
+    !/^[A-Za-z0-9._/-]+$/.test(ref) || // only ref-safe chars (no space/shell metachars)
+    ref.startsWith("-") || // block flag injection (e.g. --upload-pack=…)
+    ref.includes("..") || // forbidden in refnames; also blocks range tricks
+    ref.includes("//") ||
+    ref.endsWith("/") ||
+    ref.endsWith(".lock")
+  ) {
+    throw new Error(`Unsafe ${label}: ${JSON.stringify(ref)}`);
+  }
+}
+
 /**
  * Run a git command and return stdout.
  */

package/src/lib/goal-store.js

@@ -19,6 +19,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getHomeDir } from "./paths.js";
+import { withFileLock } from "./with-file-lock.js";
 
 /** Valid goal lifecycle states. `active` goals are the ones injected. */
 export const GOAL_STATUS = Object.freeze({
@@ -38,6 +39,28 @@ function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
+/**
+ * Write a goal file atomically: a crash mid-write must not truncate/corrupt an
+ * existing goal (an unparseable goal file is silently dropped by getGoal's catch
+ * → the user loses that goal). Temp sibling + rename (atomic within a
+ * filesystem). Temp names end in `.tmp` (never `.json`), so a hard-crash
+ * leftover is ignored by listGoals.
+ */
+function atomicWriteFileSync(filePath, data) {
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    fs.writeFileSync(tmp, data, "utf-8");
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {
+      /* best-effort temp cleanup */
+    }
+    throw err;
+  }
+}
+
 function newId(prefix) {
   // Date.now/random are fine here (plain CLI lib, not a resumable workflow).
   const rand = Math.random().toString(36).slice(2, 8);
@@ -98,7 +121,7 @@ export function createGoal(input = {}, opts = {}) {
     updatedAt: nowIso(),
   };
   ensureDir(root);
-  fs.writeFileSync(goalFile(root, id), JSON.stringify(goal, null, 2), "utf-8");
+  atomicWriteFileSync(goalFile(root, id), JSON.stringify(goal, null, 2));
   return goal;
 }
 
@@ -137,11 +160,7 @@ function saveGoal(goal, opts = {}) {
   const root = opts.root || defaultRoot();
   ensureDir(root);
   goal.updatedAt = nowIso();
-  fs.writeFileSync(
-    goalFile(root, goal.id),
-    JSON.stringify(goal, null, 2),
-    "utf-8",
-  );
+  atomicWriteFileSync(goalFile(root, goal.id), JSON.stringify(goal, null, 2));
   return goal;
 }
 
@@ -162,10 +181,17 @@ export function listGoals(opts = {}) {
 
 /** Mutate a goal via `fn(goal)`; throws if not found. */
 function mutate(id, fn, opts = {}) {
-  const goal = getGoal(id, opts);
-  if (!goal) throw new Error(`no such goal: ${id}`);
-  fn(goal);
-  return saveGoal(goal, opts);
+  // Serialize the read-modify-write across processes (cc+cc, or cc+desktop
+  // sharing the goals dir) so concurrent goal edits don't lose an update.
+  // Best-effort lock (with-file-lock): on contention timeout it proceeds anyway,
+  // so the CLI never hangs.
+  const root = opts.root || defaultRoot();
+  return withFileLock(goalFile(root, id), () => {
+    const goal = getGoal(id, opts);
+    if (!goal) throw new Error(`no such goal: ${id}`);
+    fn(goal);
+    return saveGoal(goal, opts);
+  });
 }
 
 /** Add a key result to a goal. */

package/src/lib/hierarchical-memory.js

@@ -1006,6 +1006,12 @@ export function startConsolidationTimer({
       }
     }
   }, intervalMs);
+  // Background maintenance must not by itself keep the CLI process alive (the
+  // process should exit once foreground work is done); matches the unref
+  // discipline used by downloader / PtyManager / background-task-manager.
+  if (_consolidationTimer && typeof _consolidationTimer.unref === "function") {
+    _consolidationTimer.unref();
+  }
   return _consolidationTimer;
 }
 

package/src/lib/llm-pricing.js

@@ -30,7 +30,19 @@ export const FREE_PROVIDERS = Object.freeze([
  */
 export const PRICE_TABLE = Object.freeze({
   anthropic: [
-    { match: "opus", in: 15, out: 75 },
+    // Current Anthropic list prices (USD per 1M tokens), verified 2026-06-21
+    // against the claude-api reference. The Opus tier dropped to $5/$25 with
+    // Opus 4.5 (Nov 2025) — the old $15/$75 applies only to the retired
+    // Opus 4 / 4.1. Longest-pattern-first matching (see matchRate) resolves
+    // dated ids to the specific rate; bare "opus" defaults to the current price.
+    { match: "fable-5", in: 10, out: 50 },
+    { match: "mythos-5", in: 10, out: 50 },
+    { match: "opus-4-8", in: 5, out: 25 },
+    { match: "opus-4-7", in: 5, out: 25 },
+    { match: "opus-4-6", in: 5, out: 25 },
+    { match: "opus-4-5", in: 5, out: 25 },
+    { match: "opus-4-1", in: 15, out: 75 },
+    { match: "opus", in: 5, out: 25 },
     { match: "sonnet", in: 3, out: 15 },
     { match: "haiku", in: 1, out: 5 },
   ],
@@ -155,11 +167,33 @@ export function lookupRate(provider, model, table = PRICE_TABLE) {
  * @returns {{ inputCost:number, outputCost:number, totalCost:number,
  *             currency:string, matched:boolean, free:boolean, rate:object|null }}
  */
+// Prompt-cache price multipliers relative to the input rate. A cache WRITE
+// (Anthropic 5-minute ephemeral breakpoint) bills at ~125%; only Anthropic
+// reports cache creation. Cache READ pricing differs per provider — Anthropic
+// ~10%, OpenAI ~50%, DeepSeek ~25% of the input rate — so the default below is
+// overridden per provider. Applied only when cache token counts are present, so
+// non-caching usage is priced exactly as before. Public list-price estimates
+// that drift; override the table via config.llm.pricing for the base rates.
+export const CACHE_READ_MULTIPLIER = 0.1;
+export const CACHE_WRITE_MULTIPLIER = 1.25;
+export const CACHE_READ_MULTIPLIER_BY_PROVIDER = Object.freeze({
+  anthropic: 0.1,
+  openai: 0.5,
+  deepseek: 0.25,
+});
+
+function cacheReadMultiplier(provider) {
+  const p = String(provider || "").toLowerCase();
+  return CACHE_READ_MULTIPLIER_BY_PROVIDER[p] ?? CACHE_READ_MULTIPLIER;
+}
+
 export function estimateCost({
   provider,
   model,
   inputTokens = 0,
   outputTokens = 0,
+  cacheReadTokens = 0,
+  cacheCreationTokens = 0,
   table,
 } = {}) {
   const rate = lookupRate(provider, model, table);
@@ -167,6 +201,8 @@ export function estimateCost({
     return {
       inputCost: 0,
       outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreationCost: 0,
       totalCost: 0,
       currency: "USD",
       matched: false,
@@ -176,10 +212,20 @@ export function estimateCost({
   }
   const inputCost = round((Number(inputTokens) / 1e6) * rate.in);
   const outputCost = round((Number(outputTokens) / 1e6) * rate.out);
+  const cacheReadCost = round(
+    (Number(cacheReadTokens) / 1e6) * rate.in * cacheReadMultiplier(provider),
+  );
+  const cacheCreationCost = round(
+    (Number(cacheCreationTokens) / 1e6) * rate.in * CACHE_WRITE_MULTIPLIER,
+  );
   return {
     inputCost,
     outputCost,
-    totalCost: round(inputCost + outputCost),
+    cacheReadCost,
+    cacheCreationCost,
+    totalCost: round(
+      inputCost + outputCost + cacheReadCost + cacheCreationCost,
+    ),
     currency: "USD",
     matched: true,
     free: rate.pattern === "free",
@@ -202,6 +248,8 @@ export function priceRollup(aggregate, { table } = {}) {
       model: row.model,
       inputTokens: row.inputTokens,
       outputTokens: row.outputTokens,
+      cacheReadTokens: row.cacheReadTokens,
+      cacheCreationTokens: row.cacheCreationTokens,
       table,
     });
     return {
@@ -209,6 +257,8 @@ export function priceRollup(aggregate, { table } = {}) {
       cost: est.totalCost,
       inputCost: est.inputCost,
       outputCost: est.outputCost,
+      cacheReadCost: est.cacheReadCost,
+      cacheCreationCost: est.cacheCreationCost,
       currency: est.currency,
       matched: est.matched,
       free: est.free,

package/src/lib/mcp-oauth.js

@@ -306,12 +306,46 @@ export function getStoredToken(serverUrl) {
   return loadTokenStore()[serverKey(serverUrl)] || null;
 }
 
+// The store holds OAuth access + refresh tokens, so it must not be world-
+// readable. writeFileSync's `mode` only applies when the file is created, so
+// also chmod (best-effort) to tighten a file an older version left at 0644.
+function _writeStoreSecure(file, store) {
+  _deps.fs.mkdirSync(pathDefault.dirname(file), { recursive: true, mode: 0o700 });
+  const data = JSON.stringify(store, null, 2) + "\n";
+  // Atomic temp+rename: the store holds live OAuth tokens, so a crash (or a
+  // concurrent `cc mcp login`) mid-write must not truncate it and lose auth for
+  // every server. The temp inherits the 0600 mode. Falls back to a direct write
+  // when the injected fs lacks renameSync (test mocks); the real fs always has
+  // it, so production is always atomic.
+  if (typeof _deps.fs.renameSync !== "function") {
+    _deps.fs.writeFileSync(file, data, { encoding: "utf-8", mode: 0o600 });
+  } else {
+    const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+    try {
+      _deps.fs.writeFileSync(tmp, data, { encoding: "utf-8", mode: 0o600 });
+      _deps.fs.renameSync(tmp, file);
+    } catch (err) {
+      try {
+        if (_deps.fs.existsSync && _deps.fs.existsSync(tmp) && _deps.fs.unlinkSync)
+          _deps.fs.unlinkSync(tmp);
+      } catch {
+        /* best-effort temp cleanup */
+      }
+      throw err;
+    }
+  }
+  try {
+    _deps.fs.chmodSync(file, 0o600);
+  } catch {
+    /* chmod unsupported on this platform/fs (e.g. Windows) — mode is advisory */
+  }
+}
+
 export function saveStoredToken(serverUrl, record) {
   const file = tokenStorePath();
   const store = loadTokenStore();
   store[serverKey(serverUrl)] = { server: serverKey(serverUrl), ...record };
-  _deps.fs.mkdirSync(pathDefault.dirname(file), { recursive: true });
-  _deps.fs.writeFileSync(file, JSON.stringify(store, null, 2) + "\n", "utf-8");
+  _writeStoreSecure(file, store);
   return store[serverKey(serverUrl)];
 }
 
@@ -322,11 +356,7 @@ export function deleteStoredToken(serverUrl) {
   if (!(key in store)) return false;
   delete store[key];
   try {
-    _deps.fs.writeFileSync(
-      file,
-      JSON.stringify(store, null, 2) + "\n",
-      "utf-8",
-    );
+    _writeStoreSecure(file, store);
   } catch {
     /* best-effort */
   }

package/src/lib/memory-manager.js

@@ -8,6 +8,27 @@
 import fs from "fs";
 import path from "path";
 
+/**
+ * Atomically write a UTF-8 file: a crash mid-write must not truncate MEMORY.md
+ * (the long-term knowledge file, re-read each session). Temp sibling + rename,
+ * which is atomic within a filesystem, so a reader/crash sees either the old
+ * file or the complete new one.
+ */
+function atomicWriteFileSync(filePath, data) {
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    fs.writeFileSync(tmp, data, "utf8");
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {
+      /* best-effort temp cleanup */
+    }
+    throw err;
+  }
+}
+
 /**
  * Ensure the memory directory structure exists
  */
@@ -146,7 +167,7 @@ export function appendDailyNote(memoryDir, content) {
     fs.appendFileSync(filePath, entry, "utf8");
   } else {
     const header = `# Daily Note: ${today}\n${entry}`;
-    fs.writeFileSync(filePath, header, "utf8");
+    atomicWriteFileSync(filePath, header);
   }
 
   return { date: today, path: filePath };
@@ -206,7 +227,7 @@ export function getMemoryFile(memoryDir) {
 export function updateMemoryFile(memoryDir, content) {
   ensureMemoryDirs(memoryDir);
   const filePath = path.join(memoryDir, "MEMORY.md");
-  fs.writeFileSync(filePath, content, "utf8");
+  atomicWriteFileSync(filePath, content);
   return { path: filePath };
 }
 

package/src/lib/model-deprecation.js

@@ -0,0 +1,249 @@
+/**
+ * Deprecated-model warning — Claude-Code 2.1.183 parity:
+ * "a warning when the requested model is deprecated or automatically updated
+ *  to a newer model".
+ *
+ * The "automatically updated to a newer model" half is already covered by the
+ * fallback-model machinery (a model-not-found error switches to the next model
+ * in the chain and surfaces an onFallback notice — see fallback-model.js +
+ * agent.js / agent-repl.js). This module covers the PROACTIVE half: warn once,
+ * up front, when the user's *configured / requested* model id is on a small,
+ * high-confidence list of provider-retired model snapshots — before the run
+ * fails with an opaque "model not found".
+ *
+ * The Anthropic entries below are kept in sync with the authoritative model
+ * deprecation table (platform.claude.com/docs/en/about-claude/model-deprecations,
+ * verified 2026-06-21). `state` distinguishes "retired" (requests now fail) from
+ * "deprecated" (still works, not recommended, has a retirement date).
+ *
+ * Design constraints (this project hates model-id churn noise):
+ *  - Only ids the provider has officially retired or deprecated. A false warning
+ *    on a live model is worse than a missing one.
+ *  - CRITICAL: the Claude 4 family has BOTH active and retired members that
+ *    differ only by date suffix (claude-opus-4-8 active vs claude-opus-4-20250514
+ *    retired), so those entries use EXACT dated ids and must never be turned into
+ *    bare prefixes. Older families (1 / 2 / 3 / 3.5 / 3.7) are fully retired, so a
+ *    family prefix is safe there.
+ *  - Pure + fail-open: a lookup never throws and is trivially unit-testable.
+ *  - The notice goes to stderr (keeps stdout clean for JSON/headless output),
+ *    fires at most once per model per process, and is silenced with
+ *    CC_MODEL_NOTICE=0.
+ */
+
+import chalk from "chalk";
+
+/**
+ * Retired / deprecated model snapshots, most-specific first. `id` is matched
+ * case-insensitively as an exact id OR a prefix (so `claude-2` covers
+ * `claude-2.0` / `claude-2.1`, and `claude-3-5-sonnet` covers both 3.5 Sonnet
+ * snapshots). Prefixes are only used for fully-retired families — never for the
+ * Claude 4 family, whose active and retired members share a prefix.
+ *
+ * @type {Array<{id: string, state: "retired"|"deprecated", reason: string, replacement: string}>}
+ */
+export const DEPRECATED_MODELS = [
+  // ── Anthropic — Claude 4 family (EXACT dated ids only; prefixes would hit
+  //    the active claude-opus-4-8 / -4-7 / -4-6 / -4-5-20251101 / sonnet-4-6 /
+  //    sonnet-4-5-20250929 / haiku-4-5-20251001 models) ──────────────────────
+  {
+    id: "claude-opus-4-1-20250805",
+    state: "deprecated",
+    reason: "Anthropic deprecated Claude Opus 4.1 (retires 2026-08-05)",
+    replacement: "claude-opus-4-8",
+  },
+  {
+    id: "claude-opus-4-20250514",
+    state: "retired",
+    reason: "Anthropic retired the original Claude Opus 4 snapshot",
+    replacement: "claude-opus-4-8",
+  },
+  {
+    id: "claude-sonnet-4-20250514",
+    state: "retired",
+    reason: "Anthropic retired the original Claude Sonnet 4 snapshot",
+    replacement: "claude-sonnet-4-6",
+  },
+  // ── Anthropic — fully-retired older families (family prefix is safe) ───────
+  {
+    id: "claude-3-7-sonnet",
+    state: "retired",
+    reason: "Anthropic retired Claude Sonnet 3.7",
+    replacement: "claude-sonnet-4-6",
+  },
+  {
+    id: "claude-3-5-sonnet",
+    state: "retired",
+    reason: "Anthropic retired the Claude 3.5 Sonnet snapshots",
+    replacement: "claude-sonnet-4-6",
+  },
+  {
+    id: "claude-3-5-haiku",
+    state: "retired",
+    reason: "Anthropic retired Claude Haiku 3.5",
+    replacement: "claude-haiku-4-5",
+  },
+  {
+    id: "claude-3-opus-20240229",
+    state: "retired",
+    reason: "Anthropic retired Claude 3 Opus",
+    replacement: "claude-opus-4-8",
+  },
+  {
+    id: "claude-3-sonnet-20240229",
+    state: "retired",
+    reason: "Anthropic retired Claude 3 Sonnet",
+    replacement: "claude-sonnet-4-6",
+  },
+  {
+    id: "claude-3-haiku-20240307",
+    state: "retired",
+    reason: "Anthropic retired Claude 3 Haiku",
+    replacement: "claude-haiku-4-5",
+  },
+  {
+    id: "claude-2",
+    state: "retired",
+    reason: "Anthropic retired the Claude 2 family",
+    replacement: "claude-sonnet-4-6 or claude-opus-4-8",
+  },
+  {
+    id: "claude-instant",
+    state: "retired",
+    reason: "Anthropic retired Claude Instant",
+    replacement: "claude-haiku-4-5",
+  },
+  {
+    id: "claude-1",
+    state: "retired",
+    reason: "Anthropic retired the Claude 1 family",
+    replacement: "claude-sonnet-4-6 or claude-opus-4-8",
+  },
+  // ── OpenAI (retired snapshots) ────────────────────────────────────────────
+  {
+    id: "gpt-4-vision-preview",
+    state: "retired",
+    reason: "OpenAI retired the gpt-4 vision preview",
+    replacement: "gpt-5 (natively multimodal)",
+  },
+  {
+    id: "gpt-4-1106-vision-preview",
+    state: "retired",
+    reason: "OpenAI retired the gpt-4 vision preview",
+    replacement: "gpt-5 (natively multimodal)",
+  },
+  {
+    id: "gpt-4-32k",
+    state: "retired",
+    reason: "OpenAI retired the gpt-4-32k snapshots",
+    replacement: "gpt-5 or gpt-4o",
+  },
+  {
+    id: "gpt-4-0314",
+    state: "retired",
+    reason: "OpenAI retired this gpt-4 snapshot",
+    replacement: "gpt-5 or gpt-4o",
+  },
+  {
+    id: "gpt-4-0613",
+    state: "retired",
+    reason: "OpenAI retired this gpt-4 snapshot",
+    replacement: "gpt-5 or gpt-4o",
+  },
+  {
+    id: "gpt-3.5-turbo-0301",
+    state: "retired",
+    reason: "OpenAI retired this gpt-3.5-turbo snapshot",
+    replacement: "gpt-4o-mini or gpt-5-mini",
+  },
+  {
+    id: "gpt-3.5-turbo-0613",
+    state: "retired",
+    reason: "OpenAI retired this gpt-3.5-turbo snapshot",
+    replacement: "gpt-4o-mini or gpt-5-mini",
+  },
+  {
+    id: "text-davinci-002",
+    state: "retired",
+    reason: "OpenAI retired the text-davinci completion models",
+    replacement: "gpt-4o-mini or gpt-5-mini",
+  },
+  {
+    id: "text-davinci-003",
+    state: "retired",
+    reason: "OpenAI retired the text-davinci completion models",
+    replacement: "gpt-4o-mini or gpt-5-mini",
+  },
+];
+
+/**
+ * Look up a model id against the retired list.
+ *
+ * @param {string} modelId
+ * @returns {{id: string, state: string, reason: string, replacement: string}|null}
+ *          the matched entry (with `id` = the configured model), or null.
+ */
+export function checkModelDeprecation(modelId) {
+  if (!modelId || typeof modelId !== "string") return null;
+  const norm = modelId.trim().toLowerCase();
+  if (!norm) return null;
+  for (const entry of DEPRECATED_MODELS) {
+    const pat = entry.id.toLowerCase();
+    if (norm === pat || norm.startsWith(pat)) {
+      return { ...entry, id: modelId };
+    }
+  }
+  return null;
+}
+
+/**
+ * Human-readable one-line warning for a matched deprecation.
+ *
+ * @param {{id: string, state?: string, reason: string, replacement: string}} info
+ * @returns {string}
+ */
+export function formatModelDeprecationWarning(info) {
+  const verb = info.state === "retired" ? "has been retired" : "is deprecated";
+  return (
+    `Warning: model "${info.id}" ${verb} — ${info.reason}. ` +
+    `Switch to ${info.replacement}. (CC_MODEL_NOTICE=0 to hide)`
+  );
+}
+
+/** Models already warned about in this process — one notice per id. */
+export const _warned = new Set();
+
+/**
+ * Entry-point hook: warn once on stderr if `model` is a retired snapshot.
+ * Cheap, fail-open, never throws.
+ *
+ * @param {object} opts
+ * @param {string}  opts.model            the resolved model id
+ * @param {object} [opts.env]             defaults to process.env
+ * @param {(line:string)=>void} [opts.print]  defaults to a yellow stderr writer
+ * @param {Set}    [opts.seen]            dedup set (defaults to module `_warned`)
+ * @returns {{ warned: boolean, info: object|null }}
+ */
+export function maybeWarnDeprecatedModel(opts = {}) {
+  const env = opts.env || process.env;
+  const seen = opts.seen || _warned;
+  const print =
+    opts.print || ((line) => process.stderr.write(chalk.yellow(line) + "\n"));
+  const out = { warned: false, info: null };
+  try {
+    if (env.CC_MODEL_NOTICE === "0") return out;
+    const info = checkModelDeprecation(opts.model);
+    if (!info) return out;
+    const key = String(opts.model).toLowerCase();
+    if (seen.has(key)) {
+      out.info = info;
+      return out;
+    }
+    seen.add(key);
+    print(formatModelDeprecationWarning(info));
+    out.warned = true;
+    out.info = info;
+  } catch {
+    /* fail-open: a deprecation notice must never affect the run */
+  }
+  return out;
+}