chainlesschain 0.162.166 → 0.162.168

package/src/repl/agent-repl.js

@@ -1045,6 +1045,7 @@ export async function startAgentRepl(options = {}) {
   // `undefined` so the runtime default-on path — and CC_PROJECT_MEMORY=0 — keep
   // their existing behaviour byte-identically.
   const _leanNoProjectMemory = options.projectMemory === false;
+  let _loadedReplInstructions = null;
   let _replBaseSystem = composeSystemPrompt(
     buildSystemPrompt(process.cwd(), {
       additionalDirectories,
@@ -1054,6 +1055,9 @@ export async function startAgentRepl(options = {}) {
       systemPrompt: options.systemPrompt,
       appendSystemPrompt: options.appendSystemPrompt,
       projectMemory: _leanNoProjectMemory ? false : undefined,
+      onInstructionsLoaded: (loaded) => {
+        _loadedReplInstructions = loaded;
+      },
     },
   );
   let _activeOutputStyle = null; // { name, body }
@@ -1088,6 +1092,25 @@ export async function startAgentRepl(options = {}) {
     // best-effort — no output style
   }
 
+  // settings.json InstructionsLoaded hooks (observe-only): fire once with the
+  // exact loaded instruction file set so a hook can audit which cc.md/CLAUDE.md/
+  // AGENTS.md/rules are authoritative this session. Best-effort; no-op when
+  // project memory is off or no hook is registered.
+  if (_settingsHooks && _loadedReplInstructions) {
+    try {
+      const { runInstructionsLoadedHooks } =
+        await import("../lib/settings-hook-events.cjs");
+      const ctx = runInstructionsLoadedHooks(_settingsHooks, {
+        files: _loadedReplInstructions.files,
+        cwd: process.cwd(),
+        sessionId,
+      }).additionalContext;
+      if (ctx) messages.push({ role: "system", content: ctx });
+    } catch (_err) {
+      // best-effort
+    }
+  }
+
   // settings.json SessionStart hooks → inject session context (observe-only).
   if (_settingsHooks) {
     try {
@@ -1267,6 +1290,23 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
+  // Seed connected MCP servers with the startup workspace roots when the session
+  // began with extra `--add-dir` roots — otherwise `roots/list` would only ever
+  // return the cwd until the first mid-session /add-dir. No-op (byte-unchanged)
+  // when there are no extra roots. Best-effort.
+  if (additionalDirectories.length > 0) {
+    try {
+      const { workspaceRootDirs, notifyMcpRootsChanged } =
+        await import("./add-dir.js");
+      notifyMcpRootsChanged(
+        [_adhocMcp?.mcpClient, _bundleMcpClient],
+        workspaceRootDirs(process.cwd(), additionalDirectories),
+      );
+    } catch {
+      /* best-effort — root advertisement must not block session startup */
+    }
+  }
+
   // Apply bundle approval policy to this session (after both gate and sessionId are ready)
   if (_bundleResolved?.approvalPolicy?.default && _approvalGate && sessionId) {
     try {
@@ -2382,8 +2422,12 @@ export async function startAgentRepl(options = {}) {
     if (trimmed === "/add-dir" || trimmed.startsWith("/add-dir ")) {
       const arg = trimmed.slice("/add-dir".length).trim();
       try {
-        const { resolveAddDir, formatAddDirRoots } =
-          await import("./add-dir.js");
+        const {
+          resolveAddDir,
+          formatAddDirRoots,
+          workspaceRootDirs,
+          notifyMcpRootsChanged,
+        } = await import("./add-dir.js");
         if (!arg) {
           logger.log(
             "\n" +
@@ -2417,6 +2461,14 @@ export async function startAgentRepl(options = {}) {
             messages[0].content = _activeOutputStyle
               ? `${_replBaseSystem}\n\n${_activeOutputStyle.body}`
               : _replBaseSystem;
+            // The workspace root LIST changed — advertise it to connected MCP
+            // servers and fire notifications/roots/list_changed so they re-query
+            // roots/list (Claude-Code 2.1.203 parity, same as /cd but with an
+            // explicit new root, not just a cwd-derived change).
+            notifyMcpRootsChanged(
+              [_adhocMcp?.mcpClient, _bundleMcpClient],
+              workspaceRootDirs(process.cwd(), additionalDirectories),
+            );
             logger.log(chalk.green(`Added working root: ${res.dir}`));
           }
         }
@@ -3002,9 +3054,11 @@ export async function startAgentRepl(options = {}) {
         logger.info(`cwd: ${process.cwd()}`);
       } else {
         try {
+          const oldCwd = process.cwd();
           const expanded = target.replace(/^~(?=$|[\\/])/, os.homedir());
           process.chdir(path.resolve(process.cwd(), expanded));
-          logger.log(chalk.green(`cwd → ${process.cwd()}`));
+          const newCwd = process.cwd();
+          logger.log(chalk.green(`cwd → ${newCwd}`));
           // MCP roots derive from cwd — tell connected servers to re-query
           // roots/list (Claude-Code 2.1.203 change-notification parity).
           for (const c of [_adhocMcp?.mcpClient, _bundleMcpClient]) {
@@ -3016,6 +3070,34 @@ export async function startAgentRepl(options = {}) {
               }
             }
           }
+          // CwdChanged settings hooks (lifecycle-event parity): the working dir
+          // just changed, so fire CwdChanged with old→new cwd — a hook can
+          // observe/react (re-audit the new dir's trust, reload per-dir config).
+          // Observe-only (a cwd change never gates flow); best-effort; no-op
+          // (byte-unchanged) without a registered CwdChanged hook.
+          if (_settingsHooks && oldCwd !== newCwd) {
+            try {
+              const { runCwdChangedHooks, dispatchAsyncHooks } =
+                await import("../lib/settings-hook-events.cjs");
+              const payload = { oldCwd, newCwd, sessionId };
+              runCwdChangedHooks(_settingsHooks, payload);
+              if (!_asyncHookSupervisor) {
+                const { AsyncHookSupervisor } =
+                  await import("../lib/async-hook-supervisor.cjs");
+                _asyncHookSupervisor = new AsyncHookSupervisor({
+                  persistStats: true,
+                });
+              }
+              dispatchAsyncHooks(
+                _settingsHooks,
+                "CwdChanged",
+                { old_cwd: oldCwd, cwd: newCwd, session_id: sessionId || null },
+                { cwd: newCwd, supervisor: _asyncHookSupervisor },
+              );
+            } catch {
+              /* CwdChanged firing is best-effort */
+            }
+          }
         } catch (err) {
           logger.error(`/cd failed: ${err.message}`);
         }