chainlesschain 0.162.163 → 0.162.165

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 }
@@ -2188,7 +2199,7 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/export")}     Save this conversation to a Markdown file (/export [path])`,
       );
       logger.log(
-        `  ${chalk.cyan("/rewind")}     Rewind to an earlier turn (double-Esc lists); ${chalk.cyan("/rewind clear")} restores a /clear`,
+        `  ${chalk.cyan("/rewind")}     Rewind to an earlier turn (double-Esc lists); ${chalk.cyan("/rewind <n> --files|--conversation")} scopes it; ${chalk.cyan("/rewind <n> --branch")} forks a session; ${chalk.cyan("/rewind clear")} restores a /clear`,
       );
       logger.log(
         `  ${chalk.cyan("/goal <cond>")} Set a session goal checked after each turn (exit-zero:/file-exists:/contains:/regex:/text); ${chalk.cyan("/goal")} shows, ${chalk.cyan("/goal clear")} drops`,
@@ -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
@@ -3020,9 +3035,17 @@ export async function startAgentRepl(options = {}) {
           restoreClearedConversation,
           buildRewindPlan,
           renderRewindWarnings,
+          buildBranchPlan,
+          renderBranchPlan,
+          parseRewindArg,
+          RESTORE_SCOPE,
         } = await import("../lib/repl-rewind.js");
         const arg = trimmed.slice("/rewind".length).trim();
-        if (arg === "clear" || arg === "undo-clear") {
+        // Parse the turn number + optional restore scope (--conversation /
+        // --files / --both). Claude-Code parity: a rewind can restore the
+        // conversation only, the files only, or both.
+        const parsed = parseRewindArg(arg);
+        if (parsed.command === "clear") {
           // Restore the conversation stashed by /clear (Claude-Code 2.1.191).
           const r = restoreClearedConversation(
             messages,
@@ -3045,13 +3068,86 @@ export async function startAgentRepl(options = {}) {
           prompt();
           return;
         }
-        if (!arg) {
+        if (parsed.command === "branch") {
+          // "从这里分支" (P0-3's fourth restore action): fork a NEW independent
+          // session that keeps history up to the chosen turn and diverges from
+          // there. The origin session is NEVER truncated (preservesParent), so
+          // the live conversation continues unchanged.
+          const targetTurn = listUserTurns(messages, { limit: 1000 }).find(
+            (t) => t.n === parsed.n,
+          );
+          if (!targetTurn) {
+            logger.error(`No such turn: ${parsed.n} — run /rewind to list.`);
+          } else if (!sessionId) {
+            logger.error(
+              "Branch needs a persisted session — none is active yet.",
+            );
+          } else {
+            const turnIndex = targetTurn.index;
+            const plan = buildBranchPlan(
+              messages,
+              _checkpointMarks,
+              turnIndex,
+              {
+                parentSessionId: sessionId,
+                writeIntent: parsed.writeIntent,
+              },
+            );
+            if (!plan || !plan.branchSessionId) {
+              logger.error("Could not plan a branch from that turn.");
+            } else {
+              try {
+                const { createBranchSession } =
+                  await import("../harness/jsonl-session-store.js");
+                const res = createBranchSession({
+                  branchSessionId: plan.branchSessionId,
+                  parentSessionId: sessionId,
+                  parentTurnId: plan.parentTurnId,
+                  messages: messages.slice(0, turnIndex),
+                  meta: { title: `Branch of ${sessionId}` },
+                });
+                logger.log(
+                  chalk.green(
+                    res.created
+                      ? `🌿 branched to ${res.branchSessionId} — ${res.messages} message(s) kept; parent ${sessionId} untouched`
+                      : `🌿 branch ${res.branchSessionId} already exists; parent ${sessionId} untouched`,
+                  ),
+                );
+                for (const line of renderBranchPlan(plan))
+                  logger.log(chalk.yellow(line));
+                logger.log(
+                  chalk.gray(
+                    `  resume it with  cc agent --resume ${res.branchSessionId}` +
+                      (plan.requiresWorktree
+                        ? "  (write task → branch into an isolated worktree)"
+                        : ""),
+                  ),
+                );
+              } catch (e) {
+                logger.error(`branch failed: ${e.message}`);
+              }
+            }
+          }
+          prompt();
+          return;
+        }
+        if (parsed.command === "list") {
           logger.log(chalk.bold("\nRewind — pick a user turn (newest first):"));
           logger.log(renderTurnList(listUserTurns(messages)));
           const fileHint = _checkpointMarks.length
             ? "  (restores files to that point too — checkpoints are on)"
             : "  (conversation only — start with --checkpoint / git to also rewind files)";
           logger.log(chalk.gray(`Usage: /rewind <n>${fileHint}`));
+          logger.log(
+            chalk.gray(
+              "  scope: /rewind <n> --conversation | --files | --both (default)",
+            ),
+          );
+          logger.log(
+            chalk.gray(
+              "  branch: /rewind <n> --branch [--write] forks an independent session (parent kept)",
+            ),
+          );
           if (_clearedConversation) {
             logger.log(
               chalk.gray(
@@ -3060,50 +3156,67 @@ export async function startAgentRepl(options = {}) {
             );
           }
         } else {
-          // Snapshot BEFORE rewindToTurn truncates `messages`: buildRewindPlan
-          // needs the target turn still present to bind it to its checkpoint.
+          const scope = parsed.scope;
+          const rewindConversation = scope !== RESTORE_SCOPE.FILES;
+          const restoreFiles = scope !== RESTORE_SCOPE.CONVERSATION;
+          // Snapshot + locate the target turn BEFORE any truncation:
+          // buildRewindPlan needs the turn still present to bind its checkpoint,
+          // and a files-only rewind keeps the conversation intact entirely.
           const preRewind = messages.slice();
-          const res = rewindToTurn(messages, arg);
-          if (!res) {
-            logger.error(`No such turn: ${arg} — run /rewind to list.`);
+          const targetTurn = listUserTurns(messages, { limit: 1000 }).find(
+            (t) => t.n === parsed.n,
+          );
+          if (!targetTurn) {
+            logger.error(`No such turn: ${parsed.n} — run /rewind to list.`);
           } else {
-            logger.log(
-              chalk.yellow(
-                `⎌ rewound — dropped ${res.removed} message(s); edit and resend below`,
-              ),
-            );
-            // Coverage-aware honesty (P1 turn/checkpoint binding): print what a
-            // restore can and cannot promise for this turn BEFORE offering the
-            // file restore — a shell/external side-effect → PARTIAL, no
-            // checkpoint → files can't be restored, conversation/files drift.
-            // Derived from the REPL's existing marks (no new agent-loop events);
+            const turnIndex = targetTurn.index;
+            // 1) Conversation rewind (skipped for files-only).
+            if (rewindConversation) {
+              const res = rewindToTurn(messages, parsed.n);
+              logger.log(
+                chalk.yellow(
+                  `⎌ rewound — dropped ${res.removed} message(s); edit and resend below`,
+                ),
+              );
+            } else {
+              logger.log(
+                chalk.yellow("⎌ files-only rewind — conversation left intact"),
+              );
+            }
+            // 2) Coverage-aware honesty for the CHOSEN scope (P1 turn/checkpoint
+            // binding): print what a restore can and cannot promise — a shell/
+            // external side-effect → PARTIAL, no checkpoint → files can't be
+            // restored, and a scope-specific conversation/files drift. Derived
+            // from the REPL's existing marks (no new agent-loop events);
             // best-effort so the advisory never blocks the rewind itself.
             try {
               const plan = buildRewindPlan(
                 preRewind,
                 _checkpointMarks,
-                res.index,
+                turnIndex,
+                scope,
               );
               for (const line of renderRewindWarnings(plan))
                 logger.log(chalk.yellow(line));
             } catch {
               /* advisory only — a rewind must never fail over its own warning */
             }
-            // Claude-Code parity: rewind restores files too. Match the dropped
-            // turn to the snapshot taken just before it first mutated the tree,
-            // then offer to roll the working tree back to it (undoable — the
-            // restore takes its own safety checkpoint first).
-            const cp = pickCheckpointForTurn(_checkpointMarks, res.index);
-            pruneMarksAfter(_checkpointMarks, res.index);
+            // 3) File restore (skipped for conversation-only). Match the turn to
+            // the snapshot taken just before it first mutated the tree, then
+            // offer to roll the working tree back to it (undoable — the restore
+            // takes its own safety checkpoint first). Prune dropped-turn marks
+            // only when the conversation was actually truncated.
+            const cp = restoreFiles
+              ? pickCheckpointForTurn(_checkpointMarks, turnIndex)
+              : null;
+            if (rewindConversation)
+              pruneMarksAfter(_checkpointMarks, turnIndex);
             if (cp) {
               const q = (p) => new Promise((r) => rl.question(p, r));
-              const ans = (
-                await q(
-                  chalk.yellow(
-                    `  Also restore files to before this turn? (checkpoint ${cp.id}) [Y/n] `,
-                  ),
-                )
-              )
+              const promptText = rewindConversation
+                ? `  Also restore files to before this turn? (checkpoint ${cp.id}) [Y/n] `
+                : `  Restore files to before this turn? (checkpoint ${cp.id}) [Y/n] `;
+              const ans = (await q(chalk.yellow(promptText)))
                 .trim()
                 .toLowerCase();
               if (ans === "" || ans === "y" || ans === "yes") {
@@ -3120,7 +3233,7 @@ export async function startAgentRepl(options = {}) {
                   );
                 } catch (e) {
                   logger.error(
-                    `  file restore skipped: ${e.message} (conversation already rewound)`,
+                    `  file restore skipped: ${e.message}${rewindConversation ? " (conversation already rewound)" : ""}`,
                   );
                 }
               } else {
@@ -3130,9 +3243,19 @@ export async function startAgentRepl(options = {}) {
                   ),
                 );
               }
+            } else if (restoreFiles && scope === RESTORE_SCOPE.FILES) {
+              logger.log(
+                chalk.gray(
+                  "  no checkpoint captured for that turn — nothing to restore",
+                ),
+              );
             }
             prompt();
-            if (res.text) rl.write(res.text);
+            // Prefill the input line with the turn's text only when the
+            // conversation was rewound (edit-and-resend); files-only leaves the
+            // conversation and the prompt untouched.
+            if (rewindConversation && typeof targetTurn.content === "string")
+              rl.write(targetTurn.content);
             return;
           }
         }
@@ -3437,7 +3560,9 @@ export async function startAgentRepl(options = {}) {
             if (!_asyncHookSupervisor) {
               const { AsyncHookSupervisor } =
                 await import("../lib/async-hook-supervisor.cjs");
-              _asyncHookSupervisor = new AsyncHookSupervisor();
+              _asyncHookSupervisor = new AsyncHookSupervisor({
+                persistStats: true,
+              });
             }
             dispatchAsyncHooks(_settingsHooks, "ConfigChange", payload, {
               cwd,
@@ -4813,7 +4938,9 @@ export async function startAgentRepl(options = {}) {
         if (!_asyncHookSupervisor) {
           const { AsyncHookSupervisor } =
             await import("../lib/async-hook-supervisor.cjs");
-          _asyncHookSupervisor = new AsyncHookSupervisor();
+          _asyncHookSupervisor = new AsyncHookSupervisor({
+            persistStats: true,
+          });
         }
         dispatchAsyncHooks(
           _settingsHooks,
@@ -5100,7 +5227,7 @@ export async function startAgentRepl(options = {}) {
       if (_settingsHooks && !_asyncHookSupervisor) {
         const { AsyncHookSupervisor } =
           await import("../lib/async-hook-supervisor.cjs");
-        _asyncHookSupervisor = new AsyncHookSupervisor();
+        _asyncHookSupervisor = new AsyncHookSupervisor({ persistStats: true });
       }
       const {
         content: response,
@@ -5442,7 +5569,9 @@ export async function startAgentRepl(options = {}) {
           if (!_asyncHookSupervisor) {
             const { AsyncHookSupervisor } =
               await import("../lib/async-hook-supervisor.cjs");
-            _asyncHookSupervisor = new AsyncHookSupervisor();
+            _asyncHookSupervisor = new AsyncHookSupervisor({
+              persistStats: true,
+            });
           }
           dispatchAsyncHooks(
             _settingsHooks,