chainlesschain 0.162.94 → 0.162.96

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;
+}

package/src/lib/pdh-feedback-ledger.js

@@ -0,0 +1,131 @@
+/**
+ * PDH feedback ledger (design module 101 §3.5.13) — durable, cross-session
+ * persistence of the self-learning feedback the personal-data chat collects.
+ *
+ * The Android 纠正卡 sends {type:feedback,turn_id,kind,comment} to the cc agent;
+ * headless-stream.js consumes it within the session (ack + correction turn /
+ * preference note). That is in-session only. This ledger appends every feedback
+ * to <home>/pdh-feedback.jsonl so future sessions can learn the user's standing
+ * preferences — the "越用越聪明" flywheel (§3.5.13/§8.2). Append-only and
+ * best-effort: a learning ledger must never break the live chat.
+ *
+ * Pure CLI, no Android dependency, fully unit-testable through `_deps`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { getHomeDir } from "./paths.js";
+
+const VALID_KINDS = new Set(["positive", "negative", "correction"]);
+
+export const _deps = {
+  homeDir: () => getHomeDir(),
+  appendFile: (p, s) => fs.appendFileSync(p, s, "utf-8"),
+  readFile: (p) => fs.readFileSync(p, "utf-8"),
+  exists: (p) => fs.existsSync(p),
+  mkdir: (d) => fs.mkdirSync(d, { recursive: true }),
+  now: () => Date.now(),
+};
+
+/** `<home>/pdh-feedback.jsonl`. */
+export function feedbackLedgerPath(deps = _deps) {
+  return path.join(deps.homeDir(), "pdh-feedback.jsonl");
+}
+
+/**
+ * Append one feedback entry. Best-effort: never throws (a learning ledger must
+ * not break the live chat). Returns the written record, or null on skip/failure.
+ * A `comment` is only kept for `correction` (thumbs carry no ground truth).
+ */
+export function appendFeedback(entry, deps = _deps) {
+  const kind = String(entry?.kind || "").toLowerCase();
+  if (!VALID_KINDS.has(kind)) return null;
+  const rec = {
+    ts: deps.now(),
+    sessionId: entry.sessionId != null ? String(entry.sessionId) : null,
+    turnId: entry.turnId != null ? String(entry.turnId) : null,
+    kind,
+    comment:
+      kind === "correction" &&
+      typeof entry.comment === "string" &&
+      entry.comment
+        ? entry.comment
+        : null,
+  };
+  try {
+    const file = feedbackLedgerPath(deps);
+    const dir = path.dirname(file);
+    if (!deps.exists(dir)) deps.mkdir(dir);
+    deps.appendFile(file, JSON.stringify(rec) + "\n");
+    return rec;
+  } catch {
+    return null; // persistence is best-effort; the live turn carries on
+  }
+}
+
+/** Read all ledger entries (oldest-first), skipping malformed/invalid lines. */
+export function readFeedback(deps = _deps) {
+  const file = feedbackLedgerPath(deps);
+  let raw;
+  try {
+    if (!deps.exists(file)) return [];
+    raw = deps.readFile(file);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const o = JSON.parse(t);
+      if (o && VALID_KINDS.has(o.kind)) out.push(o);
+    } catch {
+      /* skip malformed */
+    }
+  }
+  return out;
+}
+
+/**
+ * Summarize the ledger into the user's standing preferences:
+ *   { total, positive, negative, corrections:[newest-first], sentiment }
+ * Pure over a list (caller passes readFeedback()). Corrections are the most
+ * actionable ground truth, so the newest few are surfaced verbatim.
+ */
+export function summarizeFeedback(entries, { maxCorrections = 5 } = {}) {
+  const list = Array.isArray(entries) ? entries : [];
+  let positive = 0;
+  let negative = 0;
+  const corrections = [];
+  for (const e of list) {
+    if (e.kind === "positive") positive++;
+    else if (e.kind === "negative") negative++;
+    else if (e.kind === "correction" && e.comment) corrections.push(e.comment);
+  }
+  return {
+    total: list.length,
+    positive,
+    negative,
+    corrections: corrections.slice(-maxCorrections).reverse(),
+    sentiment: positive - negative,
+  };
+}
+
+/**
+ * A compact Chinese system-note from a summary, for re-injecting learned
+ * preferences into a new session's prompt. "" when nothing has been learned.
+ */
+export function feedbackSystemNote(summary) {
+  if (!summary || !summary.total) return "";
+  const parts = [];
+  if (summary.corrections.length) {
+    parts.push(
+      "用户过往纠正（请遵循）：" +
+        summary.corrections.map((c) => `「${c}」`).join("；"),
+    );
+  }
+  if (summary.sentiment > 0) parts.push("用户总体认可你的回复风格。");
+  else if (summary.sentiment < 0)
+    parts.push("用户对过往回复多有不满，请更严谨、更贴合需求。");
+  return parts.join(" ");
+}

package/src/lib/permanent-memory.js

@@ -17,6 +17,34 @@ export const _deps = {
   BM25Search,
 };
 
+/**
+ * Atomically rewrite a UTF-8 file via _deps.fs. MEMORY.md is the memory index
+ * (re-read every session); a crash mid-rewrite truncates it and loses the
+ * index. Temp sibling + rename (atomic within a filesystem). Graceful-degrade
+ * to a direct write when the injected fs has no renameSync (partial test mocks);
+ * the real fs always has it, so production is always atomic.
+ */
+function _atomicWriteFile(filePath, data) {
+  const fsx = _deps.fs;
+  if (typeof fsx.renameSync !== "function") {
+    fsx.writeFileSync(filePath, data, "utf-8");
+    return;
+  }
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    fsx.writeFileSync(tmp, data, "utf-8");
+    fsx.renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      if (fsx.existsSync && fsx.existsSync(tmp) && fsx.unlinkSync)
+        fsx.unlinkSync(tmp);
+    } catch {
+      /* best-effort temp cleanup */
+    }
+    throw err;
+  }
+}
+
 export class CLIPermanentMemory {
   /**
    * @param {object} options
@@ -148,13 +176,13 @@ export class CLIPermanentMemory {
           existing.slice(0, sectionIdx) +
           `${sectionHeader}\n\n${content}\n` +
           existing.slice(endIdx);
-        _deps.fs.writeFileSync(filePath, newContent, "utf-8");
+        _atomicWriteFile(filePath, newContent);
       } else {
         // Append new section
         const append = existing
           ? `\n${sectionHeader}\n\n${content}\n`
           : `# Memory\n\n${sectionHeader}\n\n${content}\n`;
-        _deps.fs.writeFileSync(filePath, existing + append, "utf-8");
+        _atomicWriteFile(filePath, existing + append);
       }
 
       this._loadMemoryFile();

package/src/lib/permission-rules.cjs

@@ -113,9 +113,17 @@ function globToRegExp(glob) {
     const c = s[i];
     if (c === "*") {
       if (s[i + 1] === "*") {
-        re += ".*";
-        i++;
-        if (s[i + 1] === "/") i++; // `**/` also matches zero segments
+        i++; // consume the second `*`
+        if (s[i + 1] === "/") {
+          i++; // consume the `/` too
+          // `**/` = zero or more WHOLE path segments. Must be boundary-aware:
+          // `.*` here would let `**/secret` match `notsecret` (no `/` before the
+          // suffix), over-matching permission patterns. `(?:.*/)?` requires the
+          // suffix to start a path segment (or sit at the root).
+          re += "(?:.*/)?";
+        } else {
+          re += ".*"; // bare `**` (no trailing slash) — matches across segments
+        }
       } else {
         re += "[^/]*";
       }

package/src/lib/personal-data-hub-aichat-wizard.js

@@ -15,12 +15,42 @@
  * Reference: docs/design/Personal_Data_Hub_Phase_10_3_AIChat_WebView_Wizard.md §2 §11
  */
 
-import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  renameSync,
+  existsSync,
+} from "node:fs";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 
 const _require = createRequire(import.meta.url);
 
+/**
+ * Atomically persist the accounts JSON at mode 0600. The store holds AI-chat
+ * vendor API keys, and `_readAll` swallows a parse error → returns {}, so a
+ * crash mid-write would silently drop every saved vendor. Temp sibling (created
+ * 0600 so the secret is never world-readable) + rename, atomic within a
+ * filesystem. (Mirrors the config / mcp-oauth / sync-credentials / PDH-account
+ * atomic-write fixes.) Exported as a test seam.
+ */
+export function _atomicWriteAccounts(filePath, data) {
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    writeFileSync(tmp, data, { mode: 0o600 });
+    renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      if (existsSync(tmp)) unlinkSync(tmp);
+    } catch {
+      /* best-effort temp cleanup */
+    }
+    throw err;
+  }
+}
+
 // Lazy-load `@chainlesschain/personal-data-hub/adapters/ai-chat-history` —
 // older nested copies of the hub package (e.g. PDH 0.2.0 left in
 // `packages/cli/node_modules/@chainlesschain/personal-data-hub/` by a stale
@@ -76,7 +106,7 @@ export function createAccountsStore({ hubDir }) {
       } catch (err) {
         if (!err || err.code !== "EEXIST") throw err;
       }
-      writeFileSync(filePath, JSON.stringify(all, null, 2), { mode: 0o600 });
+      _atomicWriteAccounts(filePath, JSON.stringify(all, null, 2));
     });
     return writeChain;
   }
@@ -93,7 +123,7 @@ export function createAccountsStore({ hubDir }) {
           /* missing is fine */
         }
       } else {
-        writeFileSync(filePath, JSON.stringify(all, null, 2), { mode: 0o600 });
+        _atomicWriteAccounts(filePath, JSON.stringify(all, null, 2));
       }
     });
     return writeChain;

package/src/lib/personal-data-hub-wiring.js

@@ -126,7 +126,13 @@ const {
   runAnalysisSkill,
   ANALYSIS_SKILL_NAMES,
 } = hub;
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  renameSync,
+  unlinkSync,
+} from "node:fs";
 import { getElectronUserDataDir } from "./paths.js";
 
 import {
@@ -1382,11 +1388,34 @@ function loadWechatAccounts(filePath) {
   }
 }
 
+/**
+ * Atomically persist a JSON state file at mode 0600. The PDH account stores hold
+ * login credentials (cookies/tokens), so a crash mid-write must not truncate the
+ * file — loadXAccounts swallows a parse error and returns [], silently dropping
+ * every saved account. Temp sibling (created 0600 so the secret is never world-
+ * readable) + rename, which is atomic within a filesystem. Exported as a test
+ * seam. (Mirrors the config / mcp-oauth / sync-credentials atomic-write fixes.)
+ */
+export function _atomicWriteJson600(filePath, obj) {
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(obj, null, 2), {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+    renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      if (existsSync(tmp)) unlinkSync(tmp);
+    } catch {
+      /* best-effort temp cleanup */
+    }
+    throw err;
+  }
+}
+
 function saveWechatAccounts(filePath, accounts) {
-  writeFileSync(filePath, JSON.stringify(accounts, null, 2), {
-    encoding: "utf-8",
-    mode: 0o600,
-  });
+  _atomicWriteJson600(filePath, accounts);
 }
 
 // ─── Email account persistence (Phase 5.6) ───────────────────────────────
@@ -1403,10 +1432,7 @@ function loadEmailAccounts(filePath) {
 }
 
 function saveEmailAccounts(filePath, accounts) {
-  writeFileSync(filePath, JSON.stringify(accounts, null, 2), {
-    encoding: "utf-8",
-    mode: 0o600,
-  });
+  _atomicWriteJson600(filePath, accounts);
 }
 
 // ─── Alipay account persistence (Phase 6) ───────────────────────────────
@@ -1423,10 +1449,7 @@ function loadAlipayAccounts(filePath) {
 }
 
 function saveAlipayAccounts(filePath, accounts) {
-  writeFileSync(filePath, JSON.stringify(accounts, null, 2), {
-    encoding: "utf-8",
-    mode: 0o600,
-  });
+  _atomicWriteJson600(filePath, accounts);
 }
 
 export async function getHub() {

package/src/lib/project-instructions.js

@@ -133,9 +133,11 @@ export function findInstructionFiles(opts = {}) {
   for (const d of chain) {
     push(firstExisting(fs, path, d, PROJECT_FILE_NAMES), "project");
     push(firstExisting(fs, path, d, LOCAL_FILE_NAMES), "local");
-    // Template-scaffolded project rules (`cc init -t` writes these) join the
-    // chain too, so scaffold-flow and memory-flow projects both feed the agent.
-    push(path.join(d, ".chainlesschain", "rules.md"), "rules");
+    // NOTE: `.chainlesschain/rules.md` is intentionally NOT loaded here — it is
+    // already injected by buildSystemPrompt() (as "## Project Rules"), which is
+    // the base of every composeSystemPrompt() call. Loading it here too sent it
+    // TWICE in the system prompt on every turn. Path-scoped `.claude/rules/*.md`
+    // below are NOT covered by buildSystemPrompt, so they stay.
     // Path-scoped rule files (`.claude/rules/*.md`, YAML frontmatter `paths:`
     // globs). Glob filtering happens at LOAD time where content is available.
     try {
@@ -211,7 +213,11 @@ export function ruleApplies(globs, relCwd) {
     const star = g.search(/[*?[]/);
     const prefix = (star === -1 ? g : g.slice(0, star)).replace(/\/+$/, "");
     if (!prefix) return true; // "**/*.js" — applies everywhere
-    if (cwd === prefix || cwd.startsWith(`${prefix}/`) || prefix.startsWith(`${cwd}/`)) {
+    if (
+      cwd === prefix ||
+      cwd.startsWith(`${prefix}/`) ||
+      prefix.startsWith(`${cwd}/`)
+    ) {
       return true;
     }
   }