cc-viewer 1.8.13 → 1.8.15

package/server/lib/interceptor-core.js

@@ -399,6 +399,150 @@ export function replaceTopLevelModel(jsonStr, oldModel, newModel) {
   return jsonStr.slice(0, idx) + replaced + jsonStr.slice(idx + needle.length);
 }
 
+// ─── replaceTopLevelSystem ────────────────────────────────────────────────────
+// system 文本随主模型热切换（system-prompt-live.js）的 wire 层原语：在原始 JSON
+// 字符串上定向替换顶层 "system" 成员的值，避免对巨型 wire body（-c checkpoint
+// 可达数十 MB）做二次 JSON.parse + 全量 re-stringify。
+//
+// 与 replaceTopLevelModel 的三点差异：
+// 1. needle 只有 key（值可能极大且未知），嵌套的同名成员（如工具 input_schema
+//    里名为 "system" 的属性）会产生多候选 → 要求顶层候选唯一，否则返回 null
+//    由调用方回退 parse/stringify。
+// 2. 值的结束位置用「字符串/转义感知的有界扫描」定位（string 处理 \" 与 \\；
+//    array/object 做深度计数，跳过字符串内部）。扫描结束后校验下一个非空白字符
+//    必须是 `,` 或 `}`（顶层对象内的合法后继），否则视为定位失败返回 null。
+// 3. body 没有顶层 "system" 成员时（罕见，如某些 utility 调用），opts.allowPrepend
+//    为 true 才前插；否则返回 null。前插的重复键风险与 injectOutputConfigEffort
+//    同理——调用方必须先在解析后的 body 上确认 system 不存在。
+//
+// newSystemJson 是完整的新值 JSON（字符串或数组的序列化形态，调用方负责 JSON.stringify）。
+// 返回替换后的字符串；无法唯一定位 / 入参非法 → null（调用方回退）。
+
+// 从 jsonStr[i]（值首字符，必须为 " [ { 或字面量）扫描到值结束，返回结束下标（exclusive），
+// 无法定位 → -1。字符串处理 \" 与 \\ 转义；数组/对象做深度计数并跳过字符串内容；
+// 字面量（true/false/null/number）直接扫到分隔符。system 值在真实 wire 上只会是
+// string 或 array，其余形态防御性支持。
+function _scanJsonValueEnd(jsonStr, i) {
+  const open = jsonStr[i];
+  if (open === '"') {
+    let p = i + 1;
+    while (p < jsonStr.length) {
+      const c = jsonStr[p];
+      if (c === '\\') { p += 2; continue; }
+      if (c === '"') return p + 1;
+      p++;
+    }
+    return -1;
+  }
+  if (open === '[' || open === '{') {
+    let depth = 0;
+    let p = i;
+    while (p < jsonStr.length) {
+      const c = jsonStr[p];
+      if (c === '"') {
+        const end = _scanJsonValueEnd(jsonStr, p);
+        if (end === -1) return -1;
+        p = end;
+        continue;
+      }
+      if (c === '[' || c === '{') depth++;
+      else if (c === ']' || c === '}') {
+        depth--;
+        if (depth === 0) return p + 1;
+        if (depth < 0) return -1;
+      }
+      p++;
+    }
+    return -1;
+  }
+  // literal: true / false / null / number → 扫到 , } ] 或空白
+  const m = /^-?\d+(\.\d+)?([eE][+-]?\d+)?|^true|^false|^null/.exec(jsonStr.slice(i, i + 32));
+  return m ? i + m[0].length : -1;
+}
+
+export function replaceTopLevelSystem(jsonStr, newSystemJson, opts = {}) {
+  if (typeof jsonStr !== 'string' || !jsonStr ||
+      typeof newSystemJson !== 'string' || !newSystemJson) return null;
+  // 防御：newSystemJson 必须是合法 JSON 值（调用方 Bug 直接把垃圾写上 wire 不可接受）。
+  try { JSON.parse(newSystemJson); } catch { return null; }
+
+  const needles = ['"system":', '"system" :'];
+  // 顶层必须是对象：顶层数组（如 [{...}]）里的成员也可能通过 { 边界校验，
+  // 但那不是顶层 "system" —— 整体拒绝（调用方回退）。
+  const openIdx = jsonStr.search(/\S/);
+  if (openIdx === -1 || jsonStr[openIdx] !== '{') return null;
+  // 深度感知候选扫描（review 第二轮 P1-4）：成员边界校验（前一非空白字符是 { 或 ,）
+  // 不足以区分「顶层 system」与「嵌套同名成员」—— tools[i].input_schema.properties.system
+  // 前面同样是 {。必须跟踪 JSON 容器深度，只接受 depth===1（顶层对象内）的候选，
+  // 否则前插/替换会把 persona 写进工具 schema（顶层 system 根本没设置）。
+  //
+  // 性能（review 第二轮二次验证 P1）：逐字符深度扫描是 O(body)，对巨型 -c checkpoint
+  // （可达数十 MB）比「回退 parse+stringify」还贵 —— 而绝大多数请求（无 system 的旁路
+  // 调用、或 system 在后的大 body）根本不需要全文扫描。先用 indexOf 预筛：body 完全
+  // 不含 "system" 字样（含字符串值内）时 candidates 恒为空，直接跳过扫描（O(needle)
+  // 原生加速）；只有确实含 needle 才付出深度扫描成本。预筛命中不等于有候选（可能在
+  // 字符串值内），仍需扫描确认 —— 预筛只在「确定无 needle」时短路，语义不变。
+  const candidates = [];
+  const _hasNeedle = jsonStr.indexOf('"system"') !== -1; // 覆盖 "system": 与 "system" : 两 needle 的公共前缀
+  if (_hasNeedle) {
+    let depth = 0;
+    let p = openIdx;
+    while (p < jsonStr.length) {
+      const c = jsonStr[p];
+      if (c === '"') {
+        // 字符串内容整体跳过（含转义）—— 但先检查它是否是 depth===1 的 "system" 键
+        if (depth === 1) {
+          for (const needle of needles) {
+            if (jsonStr.startsWith(needle, p)) {
+              // 键边界：前一个非空白字符必须是 { 或 ,（顶层对象成员位置）
+              let q = p - 1;
+              while (q >= 0 && (jsonStr[q] === ' ' || jsonStr[q] === '\t' || jsonStr[q] === '\n' || jsonStr[q] === '\r')) q--;
+              if (q >= 0 && (jsonStr[q] === '{' || jsonStr[q] === ',')) {
+                candidates.push({ idx: p, needle });
+              }
+              break;
+            }
+          }
+        }
+        const end = _scanJsonValueEnd(jsonStr, p);
+        if (end === -1) return null;
+        p = end;
+        continue;
+      }
+      if (c === '{' || c === '[') depth++;
+      else if (c === '}' || c === ']') depth--;
+      p++;
+    }
+  }
+  if (candidates.length > 1) return null; // 嵌套同名成员 → 回退 parse/stringify
+
+  if (candidates.length === 0) {
+    // 无顶层 system 成员：只有显式允许才前插（utility 端点绝不能发明 system）。
+    if (opts.allowPrepend !== true) return null;
+    const i = jsonStr.indexOf('{');
+    if (i === -1) return null;
+    if (/\S/.test(jsonStr.slice(0, i))) return null; // 顶层必须是对象
+    const after = jsonStr.slice(i + 1);
+    const m = after.match(/^\s*(\S)/);
+    const needsComma = !!(m && m[1] !== '}');
+    const insert = `"system":${newSystemJson}` + (needsComma ? ',' : '');
+    return jsonStr.slice(0, i + 1) + insert + jsonStr.slice(i + 1);
+  }
+
+  const { idx, needle } = candidates[0];
+  // 值起始：跳过冒号后的空白
+  let vStart = idx + needle.length;
+  while (vStart < jsonStr.length && (jsonStr[vStart] === ' ' || jsonStr[vStart] === '\t' || jsonStr[vStart] === '\n' || jsonStr[vStart] === '\r')) vStart++;
+  if (vStart >= jsonStr.length) return null;
+  const vEnd = _scanJsonValueEnd(jsonStr, vStart);
+  if (vEnd === -1) return null;
+  // 值后边界：下一个非空白字符必须是 , 或 }（顶层对象内的合法后继）
+  let p = vEnd;
+  while (p < jsonStr.length && (jsonStr[p] === ' ' || jsonStr[p] === '\t' || jsonStr[p] === '\n' || jsonStr[p] === '\r')) p++;
+  if (p >= jsonStr.length || (jsonStr[p] !== ',' && jsonStr[p] !== '}')) return null;
+  return jsonStr.slice(0, vStart) + newSystemJson + jsonStr.slice(vEnd);
+}
+
 // proxy profile hot-switch 模型解析：按 request body 里 model 的家族名映射到 profile 的对应字段。
 // 家族用**大小写不敏感子串**匹配（/opus/i 等），只认这几个已知家族单词——
 // 因此 claude-opus-4-8、未来的 claude-opus-5 等任何版本都命中同一家族，版本升级无需重配。

package/server/lib/launch-config.js

@@ -21,13 +21,15 @@ import { randomBytes } from 'node:crypto';
 import { LOG_DIR } from '../../findcc.js';
 import { reportSwallowed } from '@ccv/core/error-report';
 import {
-  buildSystemPromptFileArgs, hasArg, isNonEmptyFile,
+  buildSystemPromptFileArgs, hasArg, argValue, isNonEmptyFile,
   SYSTEM_PROMPT_FILE, APPEND_SYSTEM_PROMPT_FILE,
 } from './system-prompt-files.js';
 import { renderSystemPromptFileArgs, renderedPromptDir } from './system-prompt-render.js';
+import { createSystemPromptVariables } from './create_system_prompt.js';
 import { appendPending, readSnapshot, resolveContinueTargetUuid } from './system-prompt-snapshots.js';
 import { MODEL_PROMPT_DIR, listModelPrompts } from './model-system-prompts.js';
 import { resolveSpawnModel } from './spawn-model-resolver.js';
+import { setLaunchSystemPromptInfo } from './system-prompt-live.js';
 
 // Opus 4.7 默认不再返回 thinking；为所有非显式覆写的调用加上 summarized。
 // 纯函数：仅根据 args 决定是否注入；用户已显式传入 `--thinking-display` 时原样返回。
@@ -210,7 +212,17 @@ export function resolveLaunchSystemPrompt(p) {
     resolvedModelId: null,
     diagnostic: null,
   };
-  if (!spawnDir) return out;
+  // The variable set collected while rendering this launch's injected files (if any).
+  // Captured via the render seam below and published to the live layer so a later hot
+  // model switch re-renders with THIS launch's variables — never by spawning git in
+  // the fetch hook. Stays null when nothing was injected or no file had `${...}`.
+  let collectedVariables = null;
+  if (!spawnDir) {
+    // 复位 live 启动判定：早退不得把上一次 launch 的注入状态泄漏给这次
+    // （什么都没注入的 launch 必须关闭 live 改写门）。
+    try { setLaunchSystemPromptInfo(null); } catch (err) { reportSwallowed('launch-config.publishLiveInfo', err); }
+    return out;
+  }
 
   // Continuation launches (-c/--continue/-r/--resume): pin the resumed conversation's
   // original injection — never re-render variables. IM workers (insideLogDir) skip the
@@ -245,6 +257,12 @@ export function resolveLaunchSystemPrompt(p) {
 
   if (pinned) {
     out.sysPrompt = pinned;
+    // resolvedModelId 仅在 fresh 分支产出（modelReader 的真模型 id）。pinned 分支的
+    // snap.model 是「条目名」（OPUS/KIMI-K3 大写 stem；sentinel 为 null），不是 wire
+    // 模型 id —— 置 null，live seed 由 pinned:true 走「无条件 seed 自 pin 字节」，
+    // 保证 resume pin 不被强行覆盖（snap.model 与 _targetModel 用 === 永不命中，
+    // 误当模型 id 会让 seed 死掉、第 2 请求被重选覆盖 pin）。
+    out.resolvedModelId = null;
   } else {
     // launchSettings is this launch's own live configuration — launchers like cfuse
     // deliver ANTHROPIC_MODEL exclusively inside it, so it must participate in model
@@ -274,14 +292,38 @@ export function resolveLaunchSystemPrompt(p) {
     }
     // Resolve `${...}` template variables in the injected files. Skipped entirely when
     // suppression zeroed the args (a rejected binary never pays the render cost).
+    // The collected variable set is captured (below) and published to the live layer
+    // so a later hot model switch re-renders with THIS launch's variables — never by
+    // spawning git inside the fetch hook.
     if (sysPrompt.args.length > 0) {
-      sysPrompt = renderSystemPromptFileArgs(sysPrompt, { cwd: spawnDir, modelId: resolvedModelId });
+      sysPrompt = renderSystemPromptFileArgs(sysPrompt, {
+        cwd: spawnDir,
+        modelId: resolvedModelId,
+        variablesFactory: (overrides, opts) => {
+          const variables = createSystemPromptVariables(overrides, opts);
+          collectedVariables = variables;
+          return variables;
+        },
+      });
     } else {
       sysPrompt = { ...sysPrompt, entries: [] };
     }
     out.sysPrompt = sysPrompt;
   }
 
+  // The render seam above is lazy: it only fires when some injected file actually
+  // contains `${...}`, so a no-template launch collects nothing and the snapshot would
+  // stay null — in which case the live layer falls back to an empty variable skeleton
+  // and hot-switch re-renders of a built-in preset produce EMPTY `${memory.dir}` /
+  // `${os.*}` / `${environment.lang}` texts (a model told to write into a `` path).
+  // Collect unconditionally for live-eligible launches: this runs on the spawn path
+  // (git subprocess at launch is fine — the hook path is what must never spawn).
+  if (!collectedVariables && !insideLogDir && !suppressInjection && !(pinned && pinned.noRecord === true)) {
+    try {
+      collectedVariables = createSystemPromptVariables({ model: { name: out.resolvedModelId || '' } }, { cwd: spawnDir });
+    } catch (err) { reportSwallowed('launch-config.collectVariables', err); }
+  }
+
   // Unified suppression (pin and fresh alike): nothing was injected → nothing can be bound.
   if (suppressInjection) {
     out.sysPrompt = { args: [], loaded: [], model: null, entries: [] };
@@ -299,6 +341,44 @@ export function resolveLaunchSystemPrompt(p) {
     try { appendPending(spawnDir, rec, logDir); } catch (err) { reportSwallowed('launch-config.appendPending', err); }
   }
   out.pendingRec = rec;
+
+  // 发布启动判定给 live 层（system-prompt-live.js）。强行覆盖模式：以热切换选中的
+  // 模型为准，只要该模型有对应 system 文本就注入/替换（含启动未注入的情况）。
+  // manualSystemPrompt：用户手动传了 --system-prompt（任意文本）或 --system-prompt-file
+  // 且其值不是 ccv 本次注入的路径 —— 此类会话绝不被热切换覆盖（手动优先；用户说的
+  // 手动是字面 flag，不含 ccv 启动阶段写入的那份）。
+  const _injectedSysPath = argValue(out.sysPrompt.args, '--system-prompt-file');
+  // ccv 本次注入的 --append-system-prompt-file 路径（同款识别，排除「手动 vs 注入」误判）
+  const _injectedAppendPath = argValue(out.sysPrompt.args, '--append-system-prompt-file');
+  const _manualSys =
+    hasArg(extraArgs, '--system-prompt') ||
+    (() => { const v = argValue(extraArgs, '--system-prompt-file'); return v !== null && v !== _injectedSysPath; })();
+  // 手动优先同样覆盖 append 两族：用户手传 --append-system-prompt[-file] 时启动期按
+  // 「手动优先」跳过 ccv 注入（buildSystemPromptFileArgs:148），live 层不得在请求时回补
+  // —— 同一条规则启动期生效、live 层绕过是不一致的。任一手动 flag → 关闭 live 门。
+  const _manualAppendSys =
+    hasArg(extraArgs, '--append-system-prompt') ||
+    (() => { const v = argValue(extraArgs, '--append-system-prompt-file'); return v !== null && v !== _injectedAppendPath; })();
+  try {
+    setLaunchSystemPromptInfo({
+      workspaceDir: spawnDir,
+      resolvedModelId: out.resolvedModelId,
+      entries: effectiveEntries,
+      pinned: !!pinned,
+      // suppressInjection（二进制拒绝 flag 自愈 / IM 去注入重启）必须有对应 suppressed，
+      // 否则 live 门会被击穿、把启动期明确不要的注入在请求时回补。
+      suppressed: suppressInjection ? 'suppressInjection' : (out.sysPrompt.suppressed ?? null),
+      manualSystemPrompt: _manualSys || _manualAppendSys,
+      // IM worker（spawnDir 在 LOG_DIR 内）persona 绝不被全局模型条目替换 → 拒绝 live 覆盖。
+      // F2 resume（pinned.noRecord：目标已识别但无快照）语义是「本次启动不注入任何东西，
+      // 绝不改动既有上下文的 system」→ 同样拒绝 live 覆盖（否则 resume 会话被强行注入）。
+      allowLive: !insideLogDir && !(pinned && pinned.noRecord === true),
+      // 本次启动收集到的变量集（含 git/os/env/memory…；live 层只缓存其快照部分）。
+      // 热切换渲染复用它,绝不在 fetch hook 同步段跑 git。无注入时由上方兜底收集
+      // （否则 preset 的 ${memory.dir}/${os.*} 会渲染成空串）。
+      variableSnapshot: collectedVariables,
+    });
+  } catch (err) { reportSwallowed('launch-config.publishLiveInfo', err); }
   return out;
 }
 

package/server/lib/model-system-prompts.js

@@ -253,12 +253,17 @@ export function deleteModelPrompt(dir, name) {
 // resolved id IS the bare shorthand — no accidental widening.
 const MODEL_ID_ALIASES = {
   k3: ['k3', 'kimi-k3', 'kimi'],
+  // deepseek 简写同理：代理/CLI 常把 `deepseek-v4-flash` 简写成 `deepseek-flash`。
+  // DeepSeek shorthand: proxies/CLIs often shorten `deepseek-v4-flash` to `deepseek-flash`.
+  'deepseek-flash': ['deepseek-flash', 'deepseek-v4-flash'],
 };
 
 // 展开模型 id 的全部等价小写拼写（无别名时就是单元素数组）。
+// 用 hasOwn 查表：普通对象下 `MODEL_ID_ALIASES['constructor']` 会取到 Object 构造器，
+// 让 .some 调用炸掉（模型 id 来自外部输入，不能信任）。
 // Expand a model id into every equivalent lowercase spelling.
 function modelIdVariants(id) {
-  return MODEL_ID_ALIASES[id] || [id];
+  return Object.hasOwn(MODEL_ID_ALIASES, id) ? MODEL_ID_ALIASES[id] : [id];
 }
 
 // 供内置预设匹配复用的导出包装：入参任意大小写，先剥 `[1m]` 类方括号后缀

package/server/lib/proxy/proxy-retry.js

@@ -15,9 +15,11 @@
 //   - Streaming responses: only read status + headers to decide whether to retry; never retry after the body has
 //     started being sent (retry-before-first-byte strategy).
 //   - race/stagger use AbortController; cancelled requests must be released correctly.
-import { resolveProfileModel } from '../interceptor-core.js';
+import { resolveProfileModel, replaceTopLevelSystem } from '../interceptor-core.js';
 import { readFileSync, existsSync } from 'node:fs';
 import { reportSwallowed } from '@ccv/core/error-report';
+import { liveSystemPromptEnabled, getLiveEntry, applyLiveSystem, knownInjectedTexts } from '../system-prompt-live.js';
+import { parseUserId } from '../session-id.js';
 
 // ── Configuration ─────────────────────────────────────────────────
 
@@ -458,6 +460,55 @@ function discardBody(response) {
 
 // ── executeRequest ────────────────────────────────────────────────
 
+/**
+ * Live system 应用（proxy 路径）：模型替换之后执行。幂等 —— interceptor hook 对 trace
+ * 请求会再跑一次 applyLiveSystem，此时 body.system 已是目标形态，剥离已知注入后重组
+ * 得到相同值 → null（无变化），与 resolveProfileModel 的双跑幂等同理。
+ * 门：liveSystemPromptEnabled + role 为 main/未分类 + 非 utility + sessionId 可解析 +
+ * 缓存已有该 (session, model) 条目（proxy 同步段绝不新生成 —— 启动模型 seed 由 hook
+ * 先行，非启动模型的异步旁路生成也由 hook 负责；这里只消费既有缓存）。
+ */
+function applyLiveSystemPrompt(body, ctx) {
+  try {
+    if (!body || !ctx || ctx.isUtility === true) return body;
+    if (ctx.role && ctx.role !== 'main') return body;
+    if (!liveSystemPromptEnabled()) return body;
+    const projectKey = ctx.projectKey;
+    if (!projectKey) return body;
+    const s = typeof body === 'string' ? body : body.toString('utf-8');
+    const obj = JSON.parse(s);
+    if (!obj || typeof obj !== 'object') return body;
+    const sid = parseUserId(obj.metadata?.user_id)?.sessionId ?? null;
+    if (!sid) return body;
+    const model = typeof obj.model === 'string' ? obj.model : ''; // 模型替换已先行 → 生效模型
+    if (!model) return body;
+    const entry = getLiveEntry(projectKey, sid, model);
+    if (!entry) return body; // 缓存未就绪 → 放行（同进程 hook 的同步生成会补上；proxy 只消费不生成）
+    // role 门（对齐 hook，review P0-1/P1-4）：已删除 isMainAgentRequest 死门 —— 它要求
+    // system 含 "You are Claude Code" 官方文案，而 override 主场景（--system-prompt-file
+    // 整段替换）的 base 是自定义 persona，永远判 false → proxy-only 路径（CCV_WORKSPACE_MODE /
+    // Electron）live 特性整体失效；且与下方「无 system 时合成目标形态」分支自相矛盾
+    // （isMainAgentRequest 要求 body.system 存在，该分支正为「无 system」而设）。
+    // 门由 ctx.role（proxy.js 在 live 启用时分类填入，未分类 → undefined → main 语义）
+    // + ctx.isUtility 承担。结构门：tools 非空 —— 无 tools 的旁路调用（标题生成/压缩探针，
+    // 本机语料 1323 条 tools=[]）与 main 同形但绝不改写 system（旧 mainAgent 门隐式覆盖）。
+    if (!Array.isArray(obj.tools) || obj.tools.length === 0) return body;
+    // 强行覆盖：body 无 system（启动未注入）时用空字符串合成目标形态（前插由 allowPrepend 承担）。
+    const hasSystem = 'system' in obj && obj.system != null;
+    const newSystem = applyLiveSystem(hasSystem ? obj.system : '', entry, knownInjectedTexts(projectKey, sid));
+    if (newSystem === null) return body;
+    // 字节级替换（与 hook 同一原语）：巨型 -c checkpoint 只改 system 成员、不整体重建，
+    // 且与 hook 输出字节一致（hook 二次 pass 必为 no-op）。needle 定位失败才回退对象级重建。
+    const replaced = replaceTopLevelSystem(s, JSON.stringify(newSystem), { allowPrepend: !hasSystem });
+    if (replaced !== null) return replaced;
+    obj.system = newSystem;
+    return JSON.stringify(obj);
+  } catch (err) {
+    reportSwallowed('proxyRetry.live-system', err);
+    return body;
+  }
+}
+
 /**
  * Executes a request with retries. Returns { response, attempts, retryCodes, durationMs, finalStatus, upstreamStatus, succeeded }.
  *
@@ -465,7 +516,7 @@ function discardBody(response) {
  * @param {string} params.url full upstream URL
  * @param {object} params.fetchOptions { method, headers, body }
  * @param {object} params.retryConfig retry config
- * @param {object} params.ctx { dispatcher, profile } network proxy dispatcher + model replacement profile
+ * @param {object} params.ctx { dispatcher, profile, role, isUtility, projectKey, launchInfo } network proxy dispatcher + model replacement profile + live system context
  * @returns {Promise<object>}
  */
 export async function executeRequest({ url, fetchOptions, retryConfig, ctx }) {
@@ -483,6 +534,10 @@ export async function executeRequest({ url, fetchOptions, retryConfig, ctx }) {
   if (finalBody && profile) {
     finalBody = applyModelReplacement(finalBody, profile);
   }
+  // Live system 改写（模型替换之后；幂等，hook 会再跑一次）
+  if (finalBody) {
+    finalBody = applyLiveSystemPrompt(finalBody, ctx);
+  }
   const finalFetchOptions = { ...fetchOptions, body: finalBody };
 
   const startTime = Date.now();

package/server/lib/resume-watchdog.js

@@ -0,0 +1,108 @@
+// Resume watchdog (L2): detect a `-c`/`-r` continuation that BYPASSED ccv (shell hook
+// missing or claude invoked directly), so the panel can warn that the system-prompt
+// injection was lost and the prompt-prefix cache will be fully rewritten.
+//
+// 裸续接检测(L2):发现「transcript 在写、但 ccv 没观测到对应 wire 流量」的会话,
+// 经 SSE 提示用户(一次性,可关闭)。判定三重门,缺一不报:
+//   1. 该会话 uuid 有 snapshot 记录(曾注入过 —— 从未注入的会话裸奔无损,不报);
+//   2. 当前工作区仍配置着注入(injectionConfigured —— 用户已删掉注入配置则不报);
+//   3. transcript 在快照写入之后又有可观增长,且 ccv 的 v2 会话目录里没有对应活动
+//      (有 = 请求经过了 ccv,不是裸奔)。
+// Failure philosophy: every error degrades to "no report" — never throws, never
+// affects the request or spawn paths.
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { reportSwallowed } from '@ccv/core/error-report';
+import { LOG_DIR } from '../../findcc.js';
+import { injectionConfigured } from './launch-config.js';
+import { readSnapshotByKey, transcriptDirForCwd, projectKeyForCwd } from './system-prompt-snapshots.js';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// transcript 必须比快照记录新这么多才算「发生了新的续接」——文件系统 mtime 粒度 +
+// 快照写入与 transcript flush 的既有竞态窗口内不误报。
+const RESUME_MIN_GAP_MS = 5 * 1000;
+
+/**
+ * 检测当前工作区最近被续接、但未经 ccv 的会话。
+ * Detect recently-resumed sessions of this workspace that bypassed ccv.
+ *
+ * @param {object} p
+ * @param {string} p.cwd 当前工作区目录
+ * @param {string} [p.logDir]
+ * @param {(uuid: string) => boolean} p.hasWireActivity 该 uuid 是否已有 ccv wire 观测
+ *   (由调用方提供 —— v2 sessions 目录存在该 uuid 的目录/journal;测试直接注入)
+ * @param {number} [p.now]
+ * @returns {{ uuid: string, transcriptPath: string }|null}
+ */
+export function detectBypassedResume({ cwd, logDir = LOG_DIR, hasWireActivity, now = Date.now() }) {
+  try {
+    if (!cwd || typeof hasWireActivity !== 'function') return null;
+    const projectKey = projectKeyForCwd(cwd);
+    if (!projectKey) return null;
+    // Gate 2: injection still configured (user removed the config → nothing lost).
+    if (!injectionConfigured(cwd, logDir)) return null;
+    const tDir = transcriptDirForCwd(cwd);
+    if (!tDir || !existsSync(tDir)) return null;
+    let latest = null;
+    for (const f of readdirSync(tDir)) {
+      if (!f.endsWith('.jsonl')) continue;
+      const uuid = f.slice(0, -'.jsonl'.length);
+      if (!UUID_RE.test(uuid)) continue;
+      // Gate 1: only sessions that ever had an injection (a snapshot record).
+      const snap = readSnapshotByKey(projectKey, uuid, logDir);
+      if (!snap) continue;
+      const full = join(tDir, uuid + '.jsonl');
+      let mtime;
+      try { mtime = statSync(full).mtimeMs; } catch { continue; }
+      // Gate 3a: transcript grew meaningfully AFTER the snapshot was recorded.
+      if (mtime - snap.createdAt < RESUME_MIN_GAP_MS) continue;
+      // Gate 3b: ccv observed no wire traffic for this uuid (a ccv-routed resume
+      // would have produced a v2 session dir).
+      if (hasWireActivity(uuid)) continue;
+      if (!latest || mtime > latest.mtime) latest = { uuid, transcriptPath: full, mtime };
+    }
+    return latest ? { uuid: latest.uuid, transcriptPath: latest.transcriptPath } : null;
+  } catch (err) {
+    reportSwallowed('resume-watchdog.detect', err);
+    return null;
+  }
+}
+
+/** 当前工作区 v2 sessions 目录里是否存在该 uuid 的活动目录。 */
+export function v2HasWireActivity(projectKey, uuid, logDir = LOG_DIR) {
+  try {
+    const sessDir = join(logDir, projectKey, 'sessions');
+    if (!existsSync(sessDir)) return false;
+    for (const d of readdirSync(sessDir)) {
+      if (d.includes(uuid)) return true;
+    }
+    return false;
+  } catch {
+    return true; // 读失败按「有活动」处理 —— 宁可不报,不可误报
+  }
+}
+
+/**
+ * 启动周期检测(默认 60s,仅当前工作区;命中后按 uuid 去重,每个 uuid 只报一次)。
+ * Start the periodic watcher. onHit({uuid, transcriptPath}) fires at most once per uuid.
+ * @returns {{ stop: () => void }}
+ */
+export function startResumeWatchdog({ cwd, onHit, intervalMs = 60_000, logDir = LOG_DIR } = {}) {
+  const reported = new Set();
+  const projectKey = projectKeyForCwd(cwd);
+  const tick = () => {
+    try {
+      const hit = detectBypassedResume({
+        cwd, logDir,
+        hasWireActivity: (uuid) => v2HasWireActivity(projectKey, uuid, logDir),
+      });
+      if (hit && !reported.has(hit.uuid)) {
+        reported.add(hit.uuid);
+        onHit?.(hit);
+      }
+    } catch (err) { reportSwallowed('resume-watchdog.tick', err); }
+  };
+  const timer = setInterval(tick, intervalMs);
+  timer.unref?.();
+  return { stop: () => clearInterval(timer), _reported: reported };
+}

package/server/lib/session-id.js

@@ -0,0 +1,33 @@
+// Shared leaf: parse session_id out of body.metadata.user_id.
+//
+// Lifted from v2/identity.js so lib-root and lib/proxy modules can use it without
+// an R3 cross-subsystem edge into v2/ (house pattern: isNonEmptyFile → file-api.js
+// re-export shell). v2/identity.js re-exports from here; do not duplicate the logic.
+//
+// Encodings (WIRE_FORMAT_V2 spec §8):
+//  - 'json':      '{"device_id":…,"account_uuid":…,"session_id":"<uuid>"}'
+//  - 'delimited': 'user_<hash>_account_<acct?>_session_<uuid>'
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Parse a raw metadata.user_id string into { sessionId, encoding } or null.
+ * @param {unknown} userIdRaw
+ * @returns {{ sessionId: string, encoding: 'json'|'delimited' } | null}
+ */
+export function parseUserId(userIdRaw) {
+  if (typeof userIdRaw !== 'string' || userIdRaw === '') return null;
+  try {
+    const obj = JSON.parse(userIdRaw);
+    if (obj && typeof obj.session_id === 'string' && obj.session_id !== '') {
+      return { sessionId: obj.session_id, encoding: 'json' };
+    }
+    return null; // valid JSON but no session_id — treat as unparseable
+  } catch { /* not JSON → try the delimited form */ }
+  const idx = userIdRaw.lastIndexOf('_session_');
+  if (idx >= 0) {
+    const tail = userIdRaw.slice(idx + '_session_'.length);
+    if (UUID_RE.test(tail)) return { sessionId: tail, encoding: 'delimited' };
+  }
+  return null;
+}

package/server/lib/shell-hook-inspect.js

@@ -0,0 +1,48 @@
+// Shell-hook 状态只读探针(L1):cli.js 与 server 共用,避免 server 反向 import cli.js
+// (cli.js 是 side-effectful 入口,import 即执行 dispatch)。
+// Shell-hook read-only inspector, shared by cli.js and the server (which must never
+// import the side-effectful cli.js entry).
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+
+export const SHELL_HOOK_START = '# >>> CC-Viewer Auto-Inject >>>';
+export const SHELL_HOOK_END = '# <<< CC-Viewer Auto-Inject <<<';
+
+// 候选 rc 文件全集(removeShellHook 原有清单)。install 只写 getShellConfigPath()
+// 选中的那一个,inspect 扫全集 —— 用户可能换过 shell,旧 rc 里的 hook 同样算「已装」。
+const RC_CANDIDATES = ['.zshrc', '.zprofile', '.bashrc', '.bash_profile', '.profile'];
+
+/**
+ * 检查 shell hook 安装状态(只读,绝不写 rc —— 「用户删掉 = 不想装」必须被尊重)。
+ * Inspect shell-hook installation state. Read-only by contract.
+ *
+ * @param {(isNative: boolean) => string} buildShellHook 期望内容的构造器(cli.js 注入,
+ *   使「stale」判定与 install 用同一份模板;server 侧无模板时可传 null 跳过 stale 判定)
+ * @returns {{ installed: boolean, stale: boolean, path: string|null, corrupt: string|null }}
+ *   - installed: 任一候选 rc 含 START 标记
+ *   - stale: 标记块存在但与当前模板不一致(upgrade 后旧版 hook 残留)
+ *   - corrupt: 含 START 但块不完整(END 损坏)的文件路径
+ */
+export function inspectShellHook(buildShellHook = null) {
+  const home = homedir();
+  let found = null;
+  let stale = false;
+  let corrupt = null;
+  for (const f of RC_CANDIDATES) {
+    const p = resolve(home, f);
+    try {
+      if (!existsSync(p)) continue;
+      const content = readFileSync(p, 'utf-8');
+      if (!content.includes(SHELL_HOOK_START)) continue;
+      const m = content.match(new RegExp(`${SHELL_HOOK_START}[\\s\\S]*?${SHELL_HOOK_END}`));
+      if (!m) { corrupt = p; continue; }
+      if (!found) found = p;
+      if (buildShellHook) {
+        // 两种模式(npm/native)任一匹配即不算 stale —— install 按部署形态二选一。
+        if (m[0] !== buildShellHook(false) && m[0] !== buildShellHook(true)) stale = true;
+      }
+    } catch { /* 读失败的 rc 不参与判定 */ }
+  }
+  return { installed: found !== null, stale, path: found, corrupt };
+}

package/server/lib/system-prompt-files.js

@@ -34,6 +34,20 @@ export function hasArg(args, ...names) {
   );
 }
 
+// 取出 args 里某个 flag 的值（`--x <v>` 取下一个 token；`--x=<v>` 取等号后）。无 → null。
+// live 层用：判断「用户手动传了 --system-prompt-file」时要排除 ccv 启动阶段注入的那份
+// （用户说的手动是字面 flag，不含 ccv 注入），需比对值。
+export function argValue(args, name) {
+  if (!Array.isArray(args)) return null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (typeof a !== 'string') continue;
+    if (a.startsWith(name + '=')) return a.slice(name.length + 1);
+    if (a === name && i + 1 < args.length && typeof args[i + 1] === 'string') return args[i + 1];
+  }
+  return null;
+}
+
 /**
  * 启动 claude 前，按「启动目录」里的 sentinel 文件决定是否注入 system prompt 文件参数。
  *