chainlesschain 0.162.161 → 0.162.163

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",
@@ -2184,6 +2190,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/rewind")}     Rewind to an earlier turn (double-Esc lists); ${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,6 +3018,8 @@ export async function startAgentRepl(options = {}) {
           pickCheckpointForTurn,
           pruneMarksAfter,
           restoreClearedConversation,
+          buildRewindPlan,
+          renderRewindWarnings,
         } = await import("../lib/repl-rewind.js");
         const arg = trimmed.slice("/rewind".length).trim();
         if (arg === "clear" || arg === "undo-clear") {
@@ -3049,6 +3060,9 @@ 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 preRewind = messages.slice();
           const res = rewindToTurn(messages, arg);
           if (!res) {
             logger.error(`No such turn: ${arg} — run /rewind to list.`);
@@ -3058,6 +3072,23 @@ export async function startAgentRepl(options = {}) {
                 `⎌ 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);
+            // best-effort so the advisory never blocks the rewind itself.
+            try {
+              const plan = buildRewindPlan(
+                preRewind,
+                _checkpointMarks,
+                res.index,
+              );
+              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
@@ -3533,6 +3564,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();
@@ -5102,6 +5162,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 +5232,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,

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) {