chainlesschain 0.162.162 → 0.162.164

package/src/repl/agent-repl.js

@@ -116,6 +116,7 @@ import { describeAskContext, raceLocalAndRemote } from "./remote-approval.js";
 import {
   parsePermissionTier,
   parsePermissionModeArg,
+  permissionModeForTier,
   describeTier,
   nextTier,
 } from "./permission-tier.js";
@@ -460,6 +461,10 @@ export async function startAgentRepl(options = {}) {
   // tier but additionally activates the autoMode.decisions classifier wrapper
   // (when settings customize it) — gateTierFor() maps mode → real gate tier.
   let _sessionTier = "strict";
+  // `/goal <condition>`: an optional SESSION completion condition. When set, the
+  // condition is evaluated + reported after each turn (interactive — no auto
+  // re-drive; that autonomous loop is headless-only). null = no session goal.
+  let _sessionGoal = null;
   const gateTierFor = (mode) =>
     mode === "auto" ? "trusted" : mode === "dontAsk" ? "strict" : mode;
   // dontAsk (headless parity, interactive form): anything that would prompt
@@ -1581,6 +1586,7 @@ export async function startAgentRepl(options = {}) {
           "/exit",
           "/export",
           "/fast",
+          "/goal",
           "/help",
           "/hooks",
           "/ide",
@@ -2182,7 +2188,10 @@ 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`,
       );
       logger.log(
         `  ${chalk.cyan("/cd <dir>")}   Change working directory mid-session (completion/memory follow)`,
@@ -3009,9 +3018,19 @@ export async function startAgentRepl(options = {}) {
           pickCheckpointForTurn,
           pruneMarksAfter,
           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,
@@ -3034,13 +3053,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(
@@ -3049,30 +3141,67 @@ export async function startAgentRepl(options = {}) {
             );
           }
         } else {
-          const res = rewindToTurn(messages, arg);
-          if (!res) {
-            logger.error(`No such turn: ${arg} — run /rewind to list.`);
+          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 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`,
-              ),
-            );
-            // 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);
+            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,
+                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 */
+            }
+            // 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") {
@@ -3089,7 +3218,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 {
@@ -3099,9 +3228,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;
           }
         }
@@ -3406,7 +3545,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,
@@ -3533,6 +3674,35 @@ export async function startAgentRepl(options = {}) {
     }
 
     // Stats
+    if (trimmed === "/goal" || trimmed.startsWith("/goal ")) {
+      // Session completion condition (distinct from `cc goal` OKR): set / show /
+      // clear a condition that is evaluated + reported after each turn.
+      try {
+        const rg = await import("../lib/repl-goal.js");
+        const cmd = rg.parseGoalCommand(trimmed.slice("/goal".length));
+        if (cmd.action === "clear") {
+          if (_sessionGoal) {
+            _sessionGoal = null;
+            logger.log(chalk.gray("◎ session goal cleared."));
+          } else {
+            logger.log(chalk.gray("No session goal to clear."));
+          }
+        } else if (cmd.action === "status") {
+          for (const l of rg.renderGoalStatus(_sessionGoal))
+            logger.log(chalk.gray(l));
+        } else {
+          // set — createReplGoal throws on a malformed spec (caught below).
+          _sessionGoal = rg.createReplGoal(cmd.spec, { now: () => Date.now() });
+          for (const l of rg.renderGoalStart(_sessionGoal))
+            logger.log(chalk.cyan(l));
+        }
+      } catch (err) {
+        logger.error(`/goal: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/stats") {
       if (contextEngine) {
         const stats = contextEngine.getStats();
@@ -4753,7 +4923,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,
@@ -5040,7 +5212,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,
@@ -5102,6 +5274,17 @@ export async function startAgentRepl(options = {}) {
         denialLog: _recentDenials,
         persistRecentDenials: true,
         permissionMode: _sessionTier,
+        // Seed the subagent-contract CEILING with the interactive session's
+        // CURRENT approval tier (mapped back to a permission mode) so a spawned
+        // sub-agent inherits/tightens from it (tighten-only), mirroring the
+        // headless runner. An autopilot session hands children bypassPermissions
+        // (→ allow confirmer); a mid-session Shift+Tab / `/permissions` change is
+        // reflected because `_sessionTier` is read per turn. A strict session
+        // resolves children to "default" exactly as before (byte-identical — the
+        // previous absent ceiling also yielded "default").
+        subAgentContract: {
+          permissionMode: permissionModeForTier(_sessionTier),
+        },
         prepareCall,
         approvalGate: _approvalGate,
         permissionRules: _permissionRules,
@@ -5161,6 +5344,71 @@ export async function startAgentRepl(options = {}) {
         if (used > 0) _ctxUsedTokens = used;
       }
 
+      // /goal (session completion condition): evaluate this turn's answer and
+      // report met / not-yet / dropped. Deterministic conditions (exit-zero /
+      // file-exists / contains / regex) run inline; a model condition reuses the
+      // session model as an independent judge. Interactive → REPORT only, never
+      // auto re-drive (that autonomous loop is headless-only). Best-effort — an
+      // eval failure never disturbs the turn.
+      if (_sessionGoal && !_sessionGoal.done) {
+        try {
+          const rg = await import("../lib/repl-goal.js");
+          const fsMod = await import("node:fs");
+          const cpMod = await import("node:child_process");
+          const judge = async (cond, { finalText }) => {
+            const { chatWithTools } = await import("../runtime/agent-core.js");
+            const { firstBalancedJson } =
+              await import("../lib/json-schema-output.js");
+            const p =
+              `Judge whether this coding session met a completion condition.\n` +
+              `Condition: ${cond.text || cond.source}\n\n` +
+              `Latest assistant output:\n${String(finalText || "").slice(0, 2000)}\n\n` +
+              `Reply with STRICT JSON only: {"met": true|false, "reason": "<short>"}.`;
+            const jr = await chatWithTools([{ role: "user", content: p }], {
+              model: activeModel,
+              provider,
+              baseUrl,
+              apiKey,
+              enabledToolNames: [],
+            });
+            const text = jr?.message?.content || "";
+            let met = false;
+            let reason = "model judge returned no verdict";
+            const block = firstBalancedJson(text, "{");
+            if (block) {
+              try {
+                const parsed = JSON.parse(block);
+                met = parsed.met === true;
+                reason =
+                  typeof parsed.reason === "string" && parsed.reason.trim()
+                    ? parsed.reason.trim()
+                    : met
+                      ? "condition met"
+                      : "condition not met";
+              } catch {
+                /* a non-JSON verdict stays unmet */
+              }
+            }
+            return { met, reason, evidence: { kind: "model" } };
+          };
+          const { decision, events, done } = await rg.evaluateReplGoalTurn(
+            _sessionGoal,
+            response || "",
+            {
+              cwd: process.cwd(),
+              spawnSync: cpMod.spawnSync,
+              existsSync: fsMod.existsSync,
+              judge,
+            },
+          );
+          for (const l of rg.renderGoalVerdict(decision, events))
+            logger.log(chalk.cyan(l));
+          if (done) _sessionGoal = null; // completed or exhausted → drop
+        } catch (err) {
+          logger.verbose(`/goal eval skipped: ${err.message}`);
+        }
+      }
+
       // Fire AssistantResponse hook with rewrite/suppress support
       const responseDirective = await fireAssistantResponse(
         _hookDb,
@@ -5306,7 +5554,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,

package/src/repl/permission-tier.js

@@ -72,6 +72,34 @@ export function parsePermissionModeArg(arg) {
   return tier ? { tier, auto: false, dontAsk: false } : null;
 }
 
+/**
+ * Inverse of the tier mapping: turn a live REPL session tier back into a
+ * subagent-contract permission MODE, so a spawned sub-agent inherits/tightens
+ * from the interactive session's CURRENT approval tier (its run-mode ceiling).
+ * Lossy on the restrictive end (strict ← default/manual/plan) — "default" is the
+ * safe representative and resolves identically for a child — but the PERMISSIVE
+ * end (autopilot → bypassPermissions) is exact, which is what lets a bypass
+ * session hand its children the allow confirmer. `auto`/`dontAsk` carry through.
+ *
+ * @param {string} tier  strict | trusted | autopilot | auto | dontAsk
+ * @returns {"default"|"acceptEdits"|"bypassPermissions"|"auto"|"dontAsk"}
+ */
+export function permissionModeForTier(tier) {
+  switch (tier) {
+    case "autopilot":
+      return "bypassPermissions";
+    case "trusted":
+      return "acceptEdits";
+    case "auto":
+      return "auto";
+    case "dontAsk":
+      return "dontAsk";
+    case "strict":
+    default:
+      return "default";
+  }
+}
+
 /** One-line description of what a tier auto-approves. */
 export function describeTier(tier) {
   switch (tier) {