chainlesschain 0.162.164 → 0.162.166

package/src/lib/packer/smoke-runner.js

@@ -85,6 +85,15 @@ export async function smokeTestExe(ctx) {
     stdio: ["ignore", "pipe", "pipe"],
     windowsHide: true,
     shell: needsShell,
+    // POSIX: own process group so teardown can signal the WHOLE tree via the
+    // negative pid. Critical when shell:true wraps the launch in `/bin/sh -c`
+    // (the `.sh` test shim, and any real exe that re-execs): a plain
+    // child.kill() then hits only the wrapper shell and orphans the real
+    // `node` server grandchild (ppid→1), which kept serving AND — via the
+    // stdio pipe fds it inherited from the worker — pinned the vitest forks
+    // pool past its terminate deadline ("Worker exited unexpectedly" flake).
+    // No-op on Windows, where killChild uses taskkill /T to walk the tree.
+    detached: process.platform !== "win32",
   });
 
   let stdoutBuf = "";
@@ -104,9 +113,26 @@ export async function smokeTestExe(ctx) {
         // is enough in practice, but /T protects us if that ever changes.
         spawn("taskkill", ["/F", "/T", "/PID", String(child.pid)], {
           stdio: "ignore",
-        });
+        }).unref();
+      } else if (child.pid) {
+        // Negative pid → the whole process group from the detached spawn above,
+        // so a shell:true wrapper's exec'd/forked `node` grandchild dies too
+        // (a plain child.kill would signal only the wrapper and orphan the
+        // server). SIGKILL, not SIGTERM: a smoke teardown has no reason to wait
+        // for a graceful close and not every packed/fake server installs a
+        // SIGTERM handler. Fall back to a direct kill if the group is already
+        // gone (ESRCH).
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+            /* already gone */
+          }
+        }
       } else {
-        child.kill("SIGTERM");
+        child.kill("SIGKILL");
       }
     } catch {
       /* best effort */
@@ -115,9 +141,10 @@ export async function smokeTestExe(ctx) {
 
   // Early-death watchdog: if the child exits before we see a listening
   // port, report the stdout/stderr so the user sees the real failure
-  // instead of a generic timeout.
+  // instead of a generic timeout. Named so cleanup() can detach it.
+  let onExit;
   const deathPromise = new Promise((_, reject) => {
-    child.on("exit", (code, signal) => {
+    onExit = (code, signal) => {
       reject(
         new PackError(
           `Smoke-test process exited (code=${code}, signal=${signal}) before ports came up.\n` +
@@ -126,16 +153,52 @@ export async function smokeTestExe(ctx) {
           EXIT.SMOKE,
         ),
       );
-    });
+    };
+    child.on("exit", onExit);
   });
 
+  // Full teardown: killing the child is not enough — the parent still holds
+  // the child's stdout/stderr PIPE handles and the ChildProcess object, all of
+  // which keep the event loop alive (killed-but-unreaped on Windows, or
+  // still-open pipes on POSIX). Left dangling across the ~8 smokeTestExe calls
+  // this test makes, they pinned the vitest forks-pool worker so it could not
+  // terminate → the "Worker exited unexpectedly" / "Timeout terminating forks
+  // worker" flake blamed on whatever file ran next on the reused worker. Detach
+  // the exit watcher, destroy the pipes, kill, and unref so nothing survives.
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    try {
+      child.removeListener("exit", onExit);
+    } catch {
+      /* noop */
+    }
+    killChild();
+    try {
+      child.stdout?.destroy();
+    } catch {
+      /* noop */
+    }
+    try {
+      child.stderr?.destroy();
+    } catch {
+      /* noop */
+    }
+    try {
+      child.unref();
+    } catch {
+      /* noop */
+    }
+  };
+
   try {
     await Promise.race([
       waitForPorts({ uiPort, wsPort, timeoutMs: bootTimeoutMs }),
       deathPromise,
     ]);
   } catch (e) {
-    killChild();
+    cleanup();
     throw e;
   }
 
@@ -148,7 +211,7 @@ export async function smokeTestExe(ctx) {
       timeoutMs: probeTimeoutMs,
     });
   } catch (e) {
-    killChild();
+    cleanup();
     throw new PackError(
       `Smoke-test HTTP probe failed: ${e.message}`,
       EXIT.SMOKE,
@@ -156,7 +219,7 @@ export async function smokeTestExe(ctx) {
   }
 
   if (uiStatus < 200 || uiStatus >= 300) {
-    killChild();
+    cleanup();
     throw new PackError(
       `Smoke-test HTTP probe: http://127.0.0.1:${uiPort}/ returned ${uiStatus} (expected 2xx)`,
       EXIT.SMOKE,
@@ -191,7 +254,7 @@ export async function smokeTestExe(ctx) {
           `        skills check: /api/skills returned 404 — skipping (older pack predating Phase 2b)`,
         );
         skillsCheck = { ok: true, skipped: "endpoint-404" };
-        killChild();
+        cleanup();
         return {
           ok: true,
           uiStatus,
@@ -200,7 +263,7 @@ export async function smokeTestExe(ctx) {
           skillsCheck,
         };
       }
-      killChild();
+      cleanup();
       throw new PackError(
         `Smoke-test /api/skills probe failed: ${e.message}`,
         EXIT.SMOKE,
@@ -216,7 +279,7 @@ export async function smokeTestExe(ctx) {
     );
     const missing = bundledSkillNames.filter((n) => !registeredNames.has(n));
     if (missing.length > 0) {
-      killChild();
+      cleanup();
       throw new PackError(
         `Smoke-test skills check: bundled skill(s) not registered: ${missing.join(", ")}`,
         EXIT.SMOKE,
@@ -228,7 +291,7 @@ export async function smokeTestExe(ctx) {
     skillsCheck = { ok: true, checked: bundledSkillNames.length };
   }
 
-  killChild();
+  cleanup();
 
   return {
     ok: true,
@@ -280,12 +343,17 @@ function tryConnect(host, port, timeoutMs) {
 function probeHttp({ host, port, path: urlPath, timeoutMs }) {
   return new Promise((resolve, reject) => {
     const req = http.get(
-      { host, port, path: urlPath, timeout: timeoutMs },
+      // agent:false → a one-off connection that closes after the response
+      // instead of lingering in the global keep-alive pool (leak-free probe).
+      { host, port, path: urlPath, timeout: timeoutMs, agent: false },
       (res) => {
         const status = res.statusCode || 0;
         // Drain body so the socket can close cleanly.
         res.on("data", () => {});
-        res.on("end", () => resolve(status));
+        res.on("end", () => {
+          req.destroy(); // release the socket now, don't wait for GC
+          resolve(status);
+        });
         res.on("error", reject);
       },
     );
@@ -299,10 +367,11 @@ function probeHttp({ host, port, path: urlPath, timeoutMs }) {
 function probeHttpJson({ host, port, path: urlPath, timeoutMs }) {
   return new Promise((resolve, reject) => {
     const req = http.get(
-      { host, port, path: urlPath, timeout: timeoutMs },
+      { host, port, path: urlPath, timeout: timeoutMs, agent: false },
       (res) => {
         if (res.statusCode < 200 || res.statusCode >= 300) {
           res.resume();
+          req.destroy();
           reject(new Error(`HTTP ${res.statusCode} from ${urlPath}`));
           return;
         }
@@ -311,6 +380,7 @@ function probeHttpJson({ host, port, path: urlPath, timeoutMs }) {
           body += d.toString("utf8");
         });
         res.on("end", () => {
+          req.destroy(); // release the socket now, don't wait for GC
           try {
             resolve(JSON.parse(body));
           } catch (e) {

package/src/lib/project-instructions.js

@@ -178,6 +178,12 @@ export function findInstructionFiles(opts = {}) {
   const cwd = path.resolve(opts.cwd || process.cwd());
   const home = opts.home || os.homedir() || "";
   const excludes = normalizeInstructionExcludes(opts.instructionExcludes);
+  // Lean / entry-only mode (`CC_PROJECT_MEMORY=lean`, IDE chat default): keep the
+  // primary instruction ENTRY files (user + project cc.md/CLAUDE.md/AGENTS.md
+  // hierarchy) but skip the heavy companions — local (cc.local.md/CLAUDE.local.md,
+  // gitignored personal status) and path-scoped `.claude/rules/*.md`. The agent
+  // can still read those with its tools when a task actually needs them.
+  const entryOnly = opts.entryOnly === true;
 
   const seen = new Set();
   const out = [];
@@ -217,7 +223,7 @@ 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");
+    if (!entryOnly) push(firstExisting(fs, path, d, LOCAL_FILE_NAMES), "local");
     // 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
@@ -225,6 +231,8 @@ export function findInstructionFiles(opts = {}) {
     // 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.
+    // Skipped in entry-only mode (they are the bulk of the token weight).
+    if (entryOnly) continue;
     try {
       const rulesDir = path.join(d, ".claude", "rules");
       for (const f of fs

package/src/lib/protocol-replay.js

@@ -0,0 +1,153 @@
+/**
+ * Offline protocol replay — the last open pure item of P1-9 ("离线协议回放") in
+ * docs/CLAUDE_CODE_IDE_INCREMENTAL_GAP_ANALYSIS_2026-07-13.md.
+ *
+ * [[event-seq-replay.js]] replays for TRANSPORT reliability (re-send a gap over a
+ * lossy socket). This module replays for PROTOCOL COMPAT: take a recorded
+ * stream-json session and a negotiation context (server offer × client offer) and
+ * answer two offline questions no live peer is needed for —
+ *
+ *   1. REPLAY: what would these frames look like on the wire under THIS
+ *      negotiation? (fields whose feature did not survive negotiation are
+ *      stripped, exactly as the live emitter's field-gate would strip them.)
+ *   2. AUDIT: does a recorded session OBEY a claimed negotiation, i.e. does any
+ *      frame carry a negotiable wire field the negotiation gated OFF? A vN-only
+ *      client must never receive a vN+1 field; a recording that violates that is
+ *      a compat bug this catches deterministically, offline, in CI.
+ *
+ * The set of gateable wire fields ({seq, trace_id, tool_use_id}) is projected
+ * from the ONE canonical [[capability-manifest.js]] via `toFieldGate()` — it can
+ * NOT drift from the negotiated feature list. All non-negotiable frame fields
+ * (type, content, tool name, …) always pass through untouched.
+ *
+ * PURE + deterministic: no fs / process / clock / RNG. The `digest` lets a golden
+ * recording be pinned so any change to negotiation/gating that alters wire output
+ * fails a byte/hash compare (same anti-drift philosophy as the capability doc).
+ */
+
+import { createHash } from "node:crypto";
+import {
+  negotiateProtocol,
+  applyNegotiationToGate,
+} from "./capability-negotiation.js";
+import { toFieldGate } from "./capability-manifest.js";
+
+/** Negotiable wire field names ({seq, trace_id, tool_use_id}), single-sourced. */
+export const GATEABLE_FIELDS = Object.freeze(
+  [...new Set(Object.values(toFieldGate()))].sort(),
+);
+
+/**
+ * Run negotiation and fold it into a per-field gate the replay/audit read.
+ * On an incompatible (ok:false) negotiation the gate stays empty → every gateable
+ * field is treated as OFF (fail-closed safe baseline).
+ *
+ * @param {object} params
+ * @param {object} params.server  server offer {protocolVersion,minProtocolVersion,features}
+ * @param {object|null} [params.client]  client offer, or null/undefined = legacy peer
+ * @returns {{negotiation:object, gate:object, enabledFields:string[], gatedFields:string[]}}
+ */
+export function gateFromNegotiation({ server = {}, client = null } = {}) {
+  const negotiation = negotiateProtocol(server, client ?? null);
+  const gate = applyNegotiationToGate(negotiation, {});
+  const enabledFields = GATEABLE_FIELDS.filter((f) => gate[f] === true);
+  const gatedFields = GATEABLE_FIELDS.filter((f) => gate[f] !== true);
+  return { negotiation, gate, enabledFields, gatedFields };
+}
+
+/**
+ * Strip from a single frame every gateable wire field the gate has OFF, exactly
+ * as the live emitter would; all other fields pass through in original order.
+ * Returns a shallow copy — the input frame is never mutated.
+ *
+ * @param {object} frame
+ * @param {object} gate  {seq?:boolean, trace_id?:boolean, tool_use_id?:boolean}
+ * @returns {object}
+ */
+export function replayFrame(frame, gate = {}) {
+  if (!frame || typeof frame !== "object") return frame;
+  const out = {};
+  for (const [k, v] of Object.entries(frame)) {
+    if (GATEABLE_FIELDS.includes(k) && gate[k] !== true) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * Replay a recorded session under a negotiation → the frames as they'd appear on
+ * the wire (gated-off fields stripped) plus a deterministic digest.
+ *
+ * @param {object[]} frames  recorded stream-json frames
+ * @param {{server:object, client?:object|null}} ctx  negotiation context
+ * @returns {{negotiation:object, gate:object, enabledFields:string[],
+ *            gatedFields:string[], frames:object[], digest:string}}
+ */
+export function replaySession(frames, ctx = {}) {
+  const { negotiation, gate, enabledFields, gatedFields } =
+    gateFromNegotiation(ctx);
+  const emitted = (Array.isArray(frames) ? frames : []).map((f) =>
+    replayFrame(f, gate),
+  );
+  return {
+    negotiation,
+    gate,
+    enabledFields,
+    gatedFields,
+    frames: emitted,
+    digest: sessionDigest(emitted),
+  };
+}
+
+/**
+ * Audit a recorded session against a claimed negotiation WITHOUT stripping:
+ * report every frame that carries a gateable wire field the negotiation gated
+ * OFF (a forward-compat violation — a field a peer at the agreed version must not
+ * have received). Fail-closed: `ok` is true only when there are zero violations.
+ *
+ * @param {object[]} frames
+ * @param {{server:object, client?:object|null}} ctx
+ * @returns {{ok:boolean, violations:Array<{index:number, field:string, type:(string|null)}>, gate:object, gatedFields:string[]}}
+ */
+export function auditRecordedSession(frames, ctx = {}) {
+  const { gate, gatedFields } = gateFromNegotiation(ctx);
+  const violations = [];
+  (Array.isArray(frames) ? frames : []).forEach((frame, index) => {
+    if (!frame || typeof frame !== "object") return;
+    for (const field of GATEABLE_FIELDS) {
+      if (
+        gate[field] !== true &&
+        Object.prototype.hasOwnProperty.call(frame, field)
+      ) {
+        violations.push({
+          index,
+          field,
+          type: typeof frame.type === "string" ? frame.type : null,
+        });
+      }
+    }
+  });
+  return { ok: violations.length === 0, violations, gate, gatedFields };
+}
+
+/** Recursively key-sort a value so JSON.stringify is order-independent. */
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value).sort()) out[k] = canonical(value[k]);
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Deterministic sha256 over a frame sequence (key-order independent) so a golden
+ * recording can be pinned and diffed. Pure.
+ * @param {object[]} frames
+ * @returns {string} 64-hex digest
+ */
+export function sessionDigest(frames) {
+  const body = (Array.isArray(frames) ? frames : []).map(canonical);
+  return createHash("sha256").update(JSON.stringify(body)).digest("hex");
+}

package/src/repl/agent-repl.js

@@ -1038,11 +1038,22 @@ export async function startAgentRepl(options = {}) {
   // output-style persona can be swapped in/out at runtime via /output-style.
   // `let` (not const): /add-dir rebuilds this mid-session to re-advertise the
   // updated working roots; output-style swaps also read it live.
+  // --no-project-memory (options.projectMemory === false): lean prompt — skip
+  // rules.md (in buildSystemPrompt) + the cc.md/CLAUDE.md block (in
+  // composeSystemPrompt). Map only an explicit `false` to a suppressing value;
+  // anything else (Commander defaults an absent `--no-` flag to `true`) stays
+  // `undefined` so the runtime default-on path — and CC_PROJECT_MEMORY=0 — keep
+  // their existing behaviour byte-identically.
+  const _leanNoProjectMemory = options.projectMemory === false;
   let _replBaseSystem = composeSystemPrompt(
-    buildSystemPrompt(process.cwd(), { additionalDirectories }),
+    buildSystemPrompt(process.cwd(), {
+      additionalDirectories,
+      projectMemory: options.projectMemory,
+    }),
     {
       systemPrompt: options.systemPrompt,
       appendSystemPrompt: options.appendSystemPrompt,
+      projectMemory: _leanNoProjectMemory ? false : undefined,
     },
   );
   let _activeOutputStyle = null; // { name, body }
@@ -2393,10 +2404,14 @@ export async function startAgentRepl(options = {}) {
             // Re-advertise the updated roots in the system prompt; keep the
             // active output-style body layered on top (same as /output-style).
             _replBaseSystem = composeSystemPrompt(
-              buildSystemPrompt(process.cwd(), { additionalDirectories }),
+              buildSystemPrompt(process.cwd(), {
+                additionalDirectories,
+                projectMemory: options.projectMemory,
+              }),
               {
                 systemPrompt: options.systemPrompt,
                 appendSystemPrompt: options.appendSystemPrompt,
+                projectMemory: _leanNoProjectMemory ? false : undefined,
               },
             );
             messages[0].content = _activeOutputStyle

package/src/runtime/agent-core.js

@@ -184,6 +184,35 @@ export function listBackgroundShellTasks() {
 // spawned detached (its own process group), so signal the group via the
 // negative pid. Windows: `taskkill /T` walks and kills the whole tree.
 // Returns true if a running task was signalled.
+// Release the parent-side handles of a background task's child: the stdout/
+// stderr PIPES (ref'd — on their own they keep the event loop alive) and the
+// process handle. Called once a task is terminal or has been signalled to die,
+// so a still-draining or slowly-dying child can never pin the process past a
+// teardown. In production the agent's own REPL/run loop holds the loop open, so
+// this changes nothing there; in the vitest forks pool nothing else does, and a
+// SIGTERM'd-but-not-yet-dead child was tripping the worker-terminate deadline
+// (the POSIX-only "Timeout terminating forks worker / Worker exited
+// unexpectedly" unit-shard flake). Idempotent + best-effort.
+function _releaseBgChildHandles(task) {
+  const child = task?.child;
+  if (!child) return;
+  try {
+    child.stdout?.destroy();
+  } catch {
+    /* noop */
+  }
+  try {
+    child.stderr?.destroy();
+  } catch {
+    /* noop */
+  }
+  try {
+    child.unref?.();
+  } catch {
+    /* noop */
+  }
+}
+
 function _killTask(task) {
   const child = task?.child;
   if (!child || child.killed || task?.status !== "running") return false;
@@ -217,6 +246,9 @@ function _killTask(task) {
     } else {
       child.kill("SIGTERM");
     }
+    // Drop the ref'd pipe/process handles now — the group signal is away, so a
+    // slowly-dying child must not pin the loop while it finishes exiting.
+    _releaseBgChildHandles(task);
     return true;
   } catch (_err) {
     return false;
@@ -276,6 +308,7 @@ function _killTaskSync(task) {
     } else {
       child.kill("SIGKILL");
     }
+    _releaseBgChildHandles(task);
     return true;
   } catch (_err) {
     return false;
@@ -851,20 +884,38 @@ export function buildSystemPrompt(cwd, opts = {}) {
     // Non-critical — skill loader may not be available
   }
 
-  // Append rules.md
-  try {
-    const projectRoot = findProjectRoot(dir);
-    if (projectRoot) {
-      const rulesPath = path.join(projectRoot, ".chainlesschain", "rules.md");
-      if (fs.existsSync(rulesPath)) {
-        const content = fs.readFileSync(rulesPath, "utf-8");
-        if (content.trim()) {
-          prompt += `\n\n## Project Rules\n${content}`;
+  // Append rules.md — unless the caller opted into a lean/off prompt. `rules.md`
+  // is coding-convention DETAIL (the entry cc.md/CLAUDE.md references it), so it
+  // is shed both when project memory is fully off (`--no-project-memory` →
+  // projectMemory === false) AND in entry-only lean mode (projectMemory ===
+  // "lean", or the env signal CC_PROJECT_MEMORY=lean when no explicit value is
+  // threaded). NOTE: legacy `CC_PROJECT_MEMORY=0` intentionally still KEEPS
+  // rules.md (its long-standing contract only dropped the instruction block) —
+  // so we only honor the "lean" env here, never "0".
+  const _pm = opts.projectMemory;
+  const _envLean =
+    process.env.CC_PROJECT_MEMORY === "lean" ||
+    process.env.CC_PROJECT_MEMORY === "entry";
+  const _dropRules =
+    _pm === false ||
+    _pm === "lean" ||
+    _pm === "entry" ||
+    (_pm == null && _envLean);
+  if (!_dropRules) {
+    try {
+      const projectRoot = findProjectRoot(dir);
+      if (projectRoot) {
+        const rulesPath = path.join(projectRoot, ".chainlesschain", "rules.md");
+        if (fs.existsSync(rulesPath)) {
+          const content = fs.readFileSync(rulesPath, "utf-8");
+          if (content.trim()) {
+            prompt += `\n\n## Project Rules\n${content}`;
+          }
         }
       }
+    } catch {
+      // Non-critical
     }
-  } catch {
-    // Non-critical
   }
 
   // Advertise extra workspace roots (--add-dir) so the model knows it may
@@ -2674,6 +2725,7 @@ async function executeToolInner(
             task.status = "error";
             task.error = String(err?.message || err).substring(0, 2000);
             task.endedAt = new Date().toISOString();
+            _releaseBgChildHandles(task);
           });
           // 'close' (not 'exit') so stdout/stderr are fully drained before the
           // status leaves "running" — otherwise a poll can observe completion
@@ -2686,6 +2738,7 @@ async function executeToolInner(
             task.exitCode = code;
             task.signal = signal;
             task.endedAt = new Date().toISOString();
+            _releaseBgChildHandles(task);
           });
         } catch (err) {
           task.status = "error";

package/src/runtime/headless-runner.js

@@ -852,13 +852,21 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     }
   }
 
+  // --no-project-memory (options.projectMemory === false): lean prompt — skip
+  // rules.md (in buildSystemPrompt) + the cc.md/CLAUDE.md block. Absent flag
+  // (undefined) leaves both paths byte-identical.
+  const _leanNoProjectMemory = options.projectMemory === false;
   const systemContent = composeSystemPrompt(
-    buildSystemPrompt(cwd, { additionalDirectories }),
+    buildSystemPrompt(cwd, {
+      additionalDirectories,
+      projectMemory: options.projectMemory,
+    }),
     {
       systemPrompt: options.systemPrompt,
       appendSystemPrompt: options.appendSystemPrompt,
       outputStyle: outputStyleBody,
       instructionExcludes,
+      projectMemory: _leanNoProjectMemory ? false : undefined,
     },
   );
 

package/src/runtime/headless-stream.js

@@ -1073,8 +1073,16 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     }
   }
 
+  // --no-project-memory (options.projectMemory === false) → lean system prompt:
+  // skip both the rules.md append inside buildSystemPrompt AND the auto-loaded
+  // cc.md/CLAUDE.md instruction block. Only `=== false` changes anything; when
+  // the flag is absent (undefined) both paths stay byte-identical.
+  const _leanNoProjectMemory = options.projectMemory === false;
   const systemContent = composeSystemPrompt(
-    buildSystemPrompt(cwd, { additionalDirectories }),
+    buildSystemPrompt(cwd, {
+      additionalDirectories,
+      projectMemory: options.projectMemory,
+    }),
     {
       systemPrompt: options.systemPrompt,
       appendSystemPrompt: _jsonSchema
@@ -1084,6 +1092,7 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
         : options.appendSystemPrompt,
       outputStyle: outputStyleBody,
       instructionExcludes,
+      projectMemory: _leanNoProjectMemory ? false : undefined,
     },
   );
   const messages = [{ role: "system", content: systemContent }];

package/src/runtime/policies/agent-policy.js

@@ -49,6 +49,11 @@ export function resolveAgentPolicy({
     // before 2026-07-09, breaking --vim/--think/--thinking-budget/
     // --fallback-model/--pdh/--permission-mode for interactive sessions.
     permissionMode: overrides.permissionMode,
+    // --no-project-memory tri-state (undefined=default-on / false=lean prompt).
+    // Plain passthrough consumed by startAgentRepl → composeSystemPrompt /
+    // buildSystemPrompt; without this allowlist entry the flag would be silently
+    // dropped for interactive sessions (same class as the vim/think/pdh fixes).
+    projectMemory: overrides.projectMemory,
     vimMode: overrides.vimMode,
     thinking: overrides.thinking,
     thinkingBudget: overrides.thinkingBudget,

package/src/runtime/system-prompt.js

@@ -58,14 +58,25 @@ export function composeSystemPrompt(base, opts = {}) {
   // Project memory (cc.md / CLAUDE.md hierarchy) — injected right after the
   // base so explicit --append-system-prompt / output-style still come later.
   //
-  // Default-on at runtime; the implicit default is suppressed under vitest
-  // (process.env.VITEST) so the long-standing pure contract of this function
-  // holds for existing unit tests — callers/tests that want the block in a
-  // test pass `projectMemory: true` explicitly.
-  const pmExplicit = typeof projectMemory === "boolean" ? projectMemory : null;
-  const pmDefault =
-    process.env.CC_PROJECT_MEMORY !== "0" && !process.env.VITEST;
-  if (pmExplicit === true || (pmExplicit === null && pmDefault)) {
+  // Tri-state `projectMemory`: true (full) | false (off) | "lean" (entry-only:
+  // the cc.md/CLAUDE.md/AGENTS.md ENTRY files, skipping local + .claude/rules/*).
+  // undefined → resolve from CC_PROJECT_MEMORY ("0"=off, "lean"/"entry"=lean,
+  // else full). The full default is suppressed under vitest (process.env.VITEST)
+  // so the long-standing pure contract holds for existing unit tests — callers
+  // that want the block in a test pass `projectMemory: true`/`"lean"` explicitly.
+  let pmMode; // "off" | "lean" | "full"
+  if (projectMemory === false) pmMode = "off";
+  else if (projectMemory === true) pmMode = "full";
+  else if (projectMemory === "lean" || projectMemory === "entry")
+    pmMode = "lean";
+  else {
+    const env = process.env.CC_PROJECT_MEMORY;
+    if (env === "0") pmMode = "off";
+    else if ((env === "lean" || env === "entry") && !process.env.VITEST)
+      pmMode = "lean";
+    else pmMode = process.env.VITEST ? "off" : "full";
+  }
+  if (pmMode !== "off") {
     const block = loadProjectInstructionsBlock({
       cwd,
       home: opts.projectMemoryHome,
@@ -73,6 +84,8 @@ export function composeSystemPrompt(base, opts = {}) {
       // Large-monorepo reduction lever: subtrees whose instruction/rule/@import
       // files never load (config `instructionExcludes`, forwarded by the caller).
       instructionExcludes: opts.instructionExcludes,
+      // Lean mode → keep only the entry instruction files.
+      entryOnly: pmMode === "lean",
     });
     if (block) result = result ? `${result}\n\n${block}` : block;
   }

package/src/assets/web-panel/assets/MarkdownRenderer-DS8dE8ty.js

@@ -1 +0,0 @@
-import{P as c,J as p,b as s}from"./vendor-Bn1JzzAn.js";import{r as a}from"./markdown-Yo_c6Krv.js";import{_ as d}from"./index-Rh-ytwow.js";const _={__name:"MarkdownRenderer",props:{content:{type:String,default:""}},setup(t,{expose:o}){o();const e=t,r=s(()=>a(e.content||"")),n={props:e,rendered:r,computed:s,get renderMarkdown(){return a}};return Object.defineProperty(n,"__isScriptSetup",{enumerable:!1,value:!0}),n}},i=["innerHTML"];function m(t,o,e,r,n,u){return c(),p("div",{class:"markdown-content",innerHTML:r.rendered},null,8,i)}const w=d(_,[["render",m],["__scopeId","data-v-0b0b9f63"],["__file","/tmp/cc-web-panel-rmqPJs/repo/packages/web-panel/src/components/MarkdownRenderer.vue"]]);export{w as M};

package/src/assets/web-panel/assets/MobileProjects-Bw0k8e1B.js

@@ -1 +0,0 @@
-import{I as n,J as g,c as l,K as r,N as u,P as h,U as o,R as t,Q as m}from"./vendor-Bn1JzzAn.js";import{_ as v,b}from"./index-Rh-ytwow.js";import{a8 as y,M}from"./icons-DG5UD-6K.js";const B={__name:"MobileProjects",setup(p,{expose:i}){i();const c=u(),{t:e}=b();function a(){c.push("/projects")}function _(){c.push("/mobile-bridge")}const s={router:c,t:e,goToProjects:a,goToMobileBridge:_,get useRouter(){return u},get useI18n(){return b},get MobileOutlined(){return M},get FolderOutlined(){return y}};return Object.defineProperty(s,"__isScriptSetup",{enumerable:!1,value:!0}),s}},x={class:"mobile-projects-placeholder"},O={class:"title"},k={class:"subtitle"},w={class:"explainer"};function T(p,i,c,e,a,_){const s=n("a-alert"),d=n("a-button"),f=n("a-space"),P=n("a-empty"),j=n("a-card");return h(),g("div",x,[l(j,null,{default:r(()=>[l(P,{description:!1},{image:r(()=>[l(e.MobileOutlined,{style:{fontSize:"64px",color:"#bfbfbf"}})]),default:r(()=>[o("h2",O,t(e.t("mobileProjects.title")),1),o("p",k,t(e.t("mobileProjects.subtitle")),1),l(s,{message:e.t("mobileProjects.v02Banner"),type:"info","show-icon":"",class:"banner"},null,8,["message"]),o("div",w,[o("h3",null,t(e.t("mobileProjects.currentDirection")),1),o("p",null,t(e.t("mobileProjects.currentDirectionBody")),1),o("ul",null,[o("li",null,t(e.t("mobileProjects.stepPhone")),1),o("li",null,t(e.t("mobileProjects.stepTap")),1),o("li",null,t(e.t("mobileProjects.stepPull")),1)]),o("h3",null,t(e.t("mobileProjects.reverseDirection")),1),o("p",null,t(e.t("mobileProjects.reverseDirectionBody")),1)]),l(f,{class:"actions"},{default:r(()=>[l(d,{type:"primary",onClick:e.goToProjects},{default:r(()=>[l(e.FolderOutlined),m(" "+t(e.t("mobileProjects.viewLocalProjects")),1)]),_:1}),l(d,{onClick:e.goToMobileBridge},{default:r(()=>[l(e.MobileOutlined),m(" "+t(e.t("mobileProjects.checkBridge")),1)]),_:1})]),_:1})]),_:1})]),_:1})])}const N=v(B,[["render",T],["__scopeId","data-v-9262cc45"],["__file","/tmp/cc-web-panel-rmqPJs/repo/packages/web-panel/src/views/MobileProjects.vue"]]);export{N as default};