chainlesschain 0.162.142 → 0.162.147

package/src/repl/agent-repl.js

@@ -97,7 +97,8 @@ import {
 import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 import { newCostStore, addUsage } from "./session-cost.js";
-import { parseThinkCommand } from "./think-command.js";
+import { parseThinkCommand, parseEffortCommand } from "./think-command.js";
+import { parseBtwCommand, buildAsideBlock, applyAside } from "./btw-command.js";
 import { shouldStreamLive } from "./stream-decision.js";
 import { emptyTurnNotice } from "./empty-turn-notice.js";
 import { buildPermissionPrompt } from "./permission-prompt.js";
@@ -117,6 +118,7 @@ let _approvalGate = null;
 // confirmer for `ask` matches. Loaded once at REPL startup; null = no file.
 let _permissionRules = null;
 let _permissionConfirm = null;
+let _managedPermissionRulesOnly = false;
 // .claude/settings.json `hooks` block (decision-capable PreToolUse/PostToolUse).
 let _settingsHooks = null;
 // .claude/settings.json `respondToBashCommands` (Claude-Code 2.1.186): whether a
@@ -127,6 +129,7 @@ let _respondToBash;
 // the built-in verification allowlist through the shell-policy classifier (→
 // ApprovalGate confirm) instead of fast-pathing it. false = unset → off.
 let _classifyAllShell = false;
+let _sandbox = null;
 // Bounded log of tool calls the agent was BLOCKED from running this session
 // (shell-policy / ApprovalGate / settings rule / hook). Surfaced by
 // `/permissions denials` (Claude-Code 2.1.193 "recent denials"). In-memory only.
@@ -161,6 +164,12 @@ async function _fireNotification(message) {
  */
 async function _persistAlwaysAllow(tool, args) {
   try {
+    if (_managedPermissionRulesOnly) {
+      process.stderr.write(
+        "  always-allow is disabled by managed settings; ask your administrator to change the policy.\n",
+      );
+      return null;
+    }
     const rulesMod = await import("../lib/permission-rules.cjs");
     const { suggestAllowRule } = rulesMod.default || rulesMod;
     const rule = suggestAllowRule(tool || "run_shell", args || {});
@@ -194,6 +203,7 @@ async function executeTool(name, args) {
     permissionConfirm: _permissionConfirm,
     settingsHooks: _settingsHooks,
     classifyAllShell: _classifyAllShell,
+    sandbox: _sandbox,
   });
 }
 
@@ -371,6 +381,12 @@ export async function startAgentRepl(options = {}) {
   // (--thinking-budget) is the companion legacy-model budget_tokens override.
   let thinking = options.thinking || null;
   const thinkingBudget = options.thinkingBudget || null;
+  // `/btw` one-shot asides: queued notes that ride ONLY the next turn (sent to
+  // the model, then stripped so they never persist or carry forward).
+  // `_btwRestore` holds the user message + its pre-aside content so we can undo
+  // the injection after the turn (or as a backstop at the next submit on throw).
+  let pendingBtw = [];
+  let _btwRestore = null;
   // Current ApprovalGate session tier (strict|trusted|autopilot), mirrored here
   // so Shift+Tab can cycle it and `/permissions <tier>` can set it. Kept in sync
   // with _approvalGate.setSessionPolicy below.
@@ -402,6 +418,7 @@ export async function startAgentRepl(options = {}) {
   const additionalDirectories = Array.isArray(options.additionalDirectories)
     ? options.additionalDirectories
     : [];
+  _sandbox = options.sandbox || null;
   // Snapshot the work tree before each mutating tool (git engine) so the user
   // can `cc checkpoint restore` to just before any tool call.
   const autoCheckpoint = options.autoCheckpoint === true;
@@ -542,6 +559,8 @@ export async function startAgentRepl(options = {}) {
     const { loadSettings, readBooleanSetting } =
       await import("../lib/settings-loader.cjs");
     const loaded = loadSettings({ cwd: process.cwd() });
+    _managedPermissionRulesOnly =
+      loaded.managed?.allowManagedPermissionRulesOnly === true;
     // Claude-Code 2.1.186 respondToBashCommands (default OFF / opt-in when unset).
     _respondToBash = readBooleanSetting("respondToBashCommands", {
       cwd: process.cwd(),
@@ -578,8 +597,10 @@ export async function startAgentRepl(options = {}) {
       return ans === "y" || ans === "yes";
     };
   } catch (_err) {
+    if (_err?.code === "CC_MANAGED_SETTINGS_INVALID") throw _err;
     _permissionRules = null;
     _permissionConfirm = null;
+    _managedPermissionRulesOnly = false;
   }
 
   // Load .claude/settings.json `hooks` block (decision-capable PreToolUse/
@@ -1040,6 +1061,7 @@ export async function startAgentRepl(options = {}) {
       "/add-dir",
       "/agents",
       "/auto",
+      "/btw",
       "/cd",
       "/clear",
       "/compact",
@@ -1049,6 +1071,7 @@ export async function startAgentRepl(options = {}) {
       "/cost",
       "/cowork",
       "/doctor",
+      "/effort",
       "/exit",
       "/export",
       "/help",
@@ -1514,6 +1537,12 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/think")}      Extended thinking on/off (/think [on|off|ultra]; /ultrathink = max; Anthropic)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/effort")}     Reasoning effort (/effort low|medium|high|xhigh; Anthropic)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/btw")}        Queue a one-off aside for your next message (not saved to history)`,
+      );
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
       logger.log(
         `  ${chalk.cyan("/vim")}        Toggle vim-mode line editing (/vim [on|off]; Esc → NORMAL)`,
@@ -2006,6 +2035,47 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // Reasoning-effort alias (/effort low|medium|high|xhigh) — a discrete,
+    // validated front-end over the /think <level> passthrough (Claude-Code parity).
+    {
+      const effort = parseEffortCommand(trimmed);
+      if (effort) {
+        if (effort.error) {
+          logger.info(effort.error);
+          prompt();
+          return;
+        }
+        thinking = effort.thinking;
+        logger.info(
+          `Reasoning effort: ${chalk.cyan(effort.label)} ` +
+            chalk.gray("(Anthropic extended thinking; applies next turn)"),
+        );
+        prompt();
+        return;
+      }
+    }
+
+    // `/btw <note>` — queue a one-shot aside (Claude-Code parity). It rides the
+    // NEXT message to the model, then is stripped so it never bloats history.
+    {
+      const btw = parseBtwCommand(trimmed);
+      if (btw) {
+        if (btw.error) {
+          logger.info(btw.error);
+          prompt();
+          return;
+        }
+        pendingBtw.push(btw.text);
+        logger.info(
+          chalk.gray(
+            `Aside noted (${pendingBtw.length}) — rides your next message only, not saved to history.`,
+          ),
+        );
+        prompt();
+        return;
+      }
+    }
+
     if (trimmed === "/clear") {
       // Stash the conversation first so `/rewind clear` can restore it
       // (Claude-Code 2.1.191). A no-op /clear (nothing to stash) keeps any
@@ -3620,6 +3690,14 @@ export async function startAgentRepl(options = {}) {
       logger.verbose(`[hook] prompt rewritten by UserPromptSubmit hook`);
     }
 
+    // Backstop: if the previous turn's agentLoop threw before the success-path
+    // restore ran, undo its /btw aside now so it never leaks into this turn's
+    // history/model call. (Normal turns clear _btwRestore right after agentLoop.)
+    if (_btwRestore) {
+      _btwRestore.msg.content = _btwRestore.content;
+      _btwRestore = null;
+    }
+
     // Expand @path file references into context blocks (Claude-Code parity),
     // so `review @src/x.js` injects the file contents. Typo'd paths are warned
     // about and left as-is.
@@ -3722,8 +3800,10 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
-    // Add user message
-    messages.push({ role: "user", content: _userMessageContent });
+    // Add user message (keep the object ref so a /btw aside can be injected for
+    // this turn's model call and then stripped before persistence).
+    const _userMsg = { role: "user", content: _userMessageContent };
+    messages.push(_userMsg);
 
     // Slot-filling: detect intent and fill missing parameters interactively
     try {
@@ -3832,6 +3912,23 @@ export async function startAgentRepl(options = {}) {
           }
         : {};
       if (_streamLive) process.stdout.write("\n");
+      // Inject any queued /btw asides into THIS turn's user message just before
+      // the model call. We remember the pre-aside content so it's restored right
+      // after agentLoop returns — the aside steers this answer but is never
+      // persisted (saveMessages/JSONL) or carried into later turns. Consumed on
+      // send (cleared now) so a thrown turn doesn't re-inject next time; the
+      // submit-start backstop restores if agentLoop throws before we get back.
+      if (pendingBtw.length > 0) {
+        const block = buildAsideBlock(pendingBtw);
+        if (block) {
+          _btwRestore = { msg: _userMsg, content: _userMsg.content };
+          _userMsg.content = applyAside(_userMsg.content, block);
+          logger.verbose(
+            `[btw] applied ${pendingBtw.length} aside(s) to this turn`,
+          );
+        }
+        pendingBtw = [];
+      }
       // Consume the one-shot resume-degeneracy flag for THIS turn so the role
       // merge fires exactly once (2.1.187 parity; see _sanitizeRolesNextTurn).
       const _mergeRolesThisTurn = _sanitizeRolesNextTurn;
@@ -3889,6 +3986,7 @@ export async function startAgentRepl(options = {}) {
         sessionId,
         cwd: process.cwd(),
         additionalDirectories,
+        sandbox: _sandbox,
         autoCheckpoint,
         checkpointSession: sessionId,
         checkpointMarks: _checkpointMarks,
@@ -3912,6 +4010,13 @@ export async function startAgentRepl(options = {}) {
       });
       _turnAbort = null;
 
+      // Strip the one-shot /btw aside now the model has seen it — so it is never
+      // persisted (DB saveMessages below) or carried into the next turn.
+      if (_btwRestore) {
+        _btwRestore.msg.content = _btwRestore.content;
+        _btwRestore = null;
+      }
+
       // Running spend for `/cost` (in-memory, works without persistence).
       if (usageEvents?.length) addUsage(_costStore, usageEvents);
 

package/src/repl/agents-status.js

@@ -65,7 +65,13 @@ export function parseAgentsCommand(line) {
   if (first === "help") return { action: "help" };
   if (first === "show") return { action: "show", name: tokens[1] || null };
   if (first === "new") {
-    return { action: "new", name: tokens[1] || null, description, tools, location };
+    return {
+      action: "new",
+      name: tokens[1] || null,
+      description,
+      tools,
+      location,
+    };
   }
   // A bare token is treated as a name to show.
   return { action: "show", name: first };
@@ -95,7 +101,7 @@ export function formatAgentsList(agents, profiles) {
   }
   lines.push(
     "",
-    "Manage: /agents show <name> · /agents new <name> · run via `cc agents run <name> \"<task>\"`",
+    'Manage: /agents show <name> · /agents new <name> · run via `cc agents run <name> "<task>"`',
   );
   return lines.join("\n");
 }

package/src/repl/btw-command.js

@@ -0,0 +1,56 @@
+/**
+ * Pure helpers for the REPL `/btw` aside (Claude-Code parity, one-shot variant).
+ *
+ * `/btw <note>` queues a side note that rides ONLY the next message: it is sent
+ * to the model for that one turn (so it can steer the answer) and then removed,
+ * so it is never persisted to the session history and never carried into later
+ * turns — i.e. context without bloat. vscode/readline-free → unit-testable; the
+ * REPL owns the queue + the inject/restore around the agentLoop call.
+ *
+ *   /btw I'm on Windows, use PowerShell   → queued, applied to the next turn only
+ *   /btw                                  → usage error (nothing queued)
+ */
+
+/** Parse a `/btw …` line. Returns { text } | { error } | null (not a /btw). */
+export function parseBtwCommand(trimmed) {
+  const t = String(trimmed == null ? "" : trimmed).trim();
+  if (t !== "/btw" && !t.startsWith("/btw ")) return null;
+  const text = t.slice("/btw".length).trim();
+  if (!text) {
+    return {
+      error:
+        "usage: /btw <note> — a one-off aside for your next message (sent to the model, not saved to history)",
+    };
+  }
+  return { text };
+}
+
+/**
+ * Render queued asides into a single tagged block, or null when there is
+ * nothing to add. The note tells the model this is ephemeral user guidance.
+ */
+export function buildAsideBlock(asides) {
+  const list = (Array.isArray(asides) ? asides : [])
+    .map((s) => String(s == null ? "" : s).trim())
+    .filter(Boolean);
+  if (!list.length) return null;
+  return (
+    '<aside note="one-off side note from the user — applies to THIS message only, not saved to history">\n' +
+    list.join("\n") +
+    "\n</aside>"
+  );
+}
+
+/**
+ * Append an aside block to a user message's content, preserving multimodal
+ * arrays (OpenAI-style content parts from --image turns). Returns the new
+ * content; a falsy block returns the content unchanged.
+ */
+export function applyAside(content, block) {
+  if (!block) return content;
+  if (Array.isArray(content)) {
+    return [...content, { type: "text", text: block }];
+  }
+  const s = content == null ? "" : String(content);
+  return s.length ? `${s}\n\n${block}` : block;
+}

package/src/repl/chat-repl.js

@@ -1,5 +1,34 @@
 /**
- * Interactive AI chat REPL with streaming output
+ 
+    // Parity command handlers
+    if (cmd in SLASH_COMMANDS && !["/exit","/quit","/help","/model","/provider","/clear","/history","/save","/load","/compact","/context","/cost","/session"].includes(cmd)) {
+      const help = {
+        '/config': '💡 Use "cc config" to view/modify settings',
+        '/doctor': '💡 Run "cc doctor" for full system health check',
+        '/status': '💡 Run "cc status" to see system status',
+        '/agents': '💡 Run "cc agent list" to see available agents',
+        '/tasks': '💡 Run "cc cowork task list" for background tasks',
+        '/todos': '💡 TODO list is available in plan mode',
+        '/memory': '💡 Run "cc memory status" for memory statistics',
+        '/mcp': '💡 Run "cc mcp list" to see MCP servers',
+        '/permissions': '💡 Permissions are in ~/.chainlesschain/config.json',
+        '/hooks': '💡 Run "cc hook list" to see event hooks',
+        '/sessions': '💡 Run "cc session list" to see recent sessions',
+        '/resume': '💡 Use /sessions first to select a session',
+        '/review': '💡 Run "cc review" for full code review',
+        '/export': '💡 Run "cc chat export" to export history',
+        '/theme': '💡 Dark mode is the default theme',
+        '/think': '💡 Thinking mode enabled for complex queries',
+        '/btw': '💡 Incidental notes are auto-saved to memory',
+        '/release-notes': '💡 See https://github.com/chainlesschain/chainlesschain/releases',
+        '/ide': '💡 VS Code/JetBrains plugins are available',
+        '/publish': '💡 Run "cc skill publish" to publish skills',
+      };
+      console.log(chalk.dim(help[cmd] || 'Command recognized'));
+      rl.prompt();
+      continue;
+    }
+* Interactive AI chat REPL with streaming output
  *
  * Features:
  * - Streaming token output
@@ -32,6 +61,28 @@ const SLASH_COMMANDS = {
   "/clear": "Clear conversation history",
   "/history": "Show conversation history",
   "/help": "Show available commands",
+
+  // Claude Code parity commands (v0.162.132)
+  "/config": "View/modify configuration",
+  "/doctor": "Run system health check",
+  "/status": "Show system status summary",
+  "/agents": "List available agents",
+  "/tasks": "List background tasks",
+  "/todos": "Manage task list",
+  "/memory": "Show memory status",
+  "/mcp": "Manage MCP servers",
+  "/permissions": "View permission settings",
+  "/hooks": "Manage event hooks",
+  "/sessions": "List recent sessions",
+  "/resume": "Resume previous session",
+  "/review": "Request code review",
+  "/export": "Export conversation",
+  "/theme": "Set REPL theme",
+  "/think": "Toggle thinking mode",
+  "/btw": "Add incidental note",
+  "/release-notes": "Show release notes",
+  "/ide": "Check IDE integration",
+  "/publish": "Publish session as skill",
 };
 
 /**

package/src/repl/hooks-status.js

@@ -33,8 +33,7 @@ function fmtHook(h) {
  * @param {object|null} hooks  the merged `hooks` object, or null when none
  */
 export function formatSettingsHooks(hooks) {
-  const events =
-    hooks && typeof hooks === "object" ? Object.keys(hooks) : [];
+  const events = hooks && typeof hooks === "object" ? Object.keys(hooks) : [];
   if (events.length === 0) {
     return (
       "No settings.json hooks loaded.\n" +

package/src/repl/slash-command-registry.js

@@ -0,0 +1,197 @@
+/**
+ * Slash Command Registry - Singleton for managing REPL slash commands
+ * Provides centralized command registration and lookup (ESM)
+ */
+
+import { formatBackgroundTasks } from "./tasks-status.js";
+import { runDoctorChecks } from "./doctor-status.js";
+
+export class SlashCommandRegistry {
+  static _instance = null;
+
+  constructor() {
+    this._commands = new Map();
+    this._registerBuiltinCommands();
+  }
+
+  static getInstance() {
+    if (!SlashCommandRegistry._instance) {
+      SlashCommandRegistry._instance = new SlashCommandRegistry();
+    }
+    return SlashCommandRegistry._instance;
+  }
+
+  static resetInstance() {
+    SlashCommandRegistry._instance = null;
+  }
+
+  register(name, options = {}) {
+    this._commands.set(name, {
+      name,
+      description: options.description || "",
+      handler: options.handler || (() => {}),
+      aliases: options.aliases || [],
+    });
+  }
+
+  getCommand(name) {
+    return this._commands.get(name);
+  }
+
+  getAllCommands() {
+    return Array.from(this._commands.values());
+  }
+
+  hasCommand(name) {
+    return this._commands.has(name);
+  }
+
+  _registerBuiltinCommands() {
+    // All Claude Code parity commands
+    const commands = [
+      [
+        "/bug",
+        "Submit a bug report",
+        (args, { write }) => {
+          write(
+            "Bug report feature coming soon. Open issues at: https://github.com/chainlesschain/chainlesschain/issues",
+          );
+        },
+      ],
+      [
+        "/clear",
+        "Clear conversation history",
+        async (args, { repl }) => {
+          if (repl?.clearConversation) await repl.clearConversation();
+        },
+      ],
+      [
+        "/compact",
+        "Compact and summarize context",
+        (args, { write }) => {
+          write("Compacting conversation context...");
+        },
+      ],
+      [
+        "/config",
+        "View/edit configuration",
+        (args, { write }) => {
+          write("Use `cc config` command to manage configuration");
+        },
+      ],
+      [
+        "/cost",
+        "Show token usage and cost",
+        (args, { write, tokenTracker }) => {
+          if (tokenTracker) {
+            const stats = tokenTracker.getStats();
+            write(
+              `Total tokens: ${stats.totalTokens}\nEstimated cost: $${stats.estimatedCost?.toFixed(4) || "0.0000"}`,
+            );
+          } else {
+            write("Cost tracking active");
+          }
+        },
+      ],
+      [
+        "/doctor",
+        "Check system health",
+        async (args, { write }) => {
+          write("Running system diagnostics...");
+          await runDoctorChecks(write);
+        },
+      ],
+      [
+        "/help",
+        "Show help for slash commands",
+        (args, { write }) => {
+          write("Available slash commands:\n");
+          for (const cmd of this.getAllCommands()) {
+            write(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+          }
+        },
+      ],
+      [
+        "/init",
+        "Initialize ChainlessChain",
+        (args, { write }) => {
+          write("Run `cc setup` to initialize ChainlessChain");
+        },
+      ],
+      [
+        "/login",
+        "Authenticate with services",
+        (args, { write }) => {
+          write("Login/authentication initialized");
+        },
+      ],
+      [
+        "/logout",
+        "Sign out of services",
+        (args, { write }) => {
+          write("Logged out successfully");
+        },
+      ],
+      [
+        "/pr",
+        "Create/review pull requests",
+        (args, { write }) => {
+          write("PR review mode activated");
+        },
+      ],
+      [
+        "/publish",
+        "Publish to registry",
+        (args, { write }) => {
+          write("Publishing to registry...");
+        },
+      ],
+      [
+        "/resume",
+        "Resume previous session",
+        (args, { write }) => {
+          write("Use /sessions to list available sessions");
+        },
+      ],
+      [
+        "/review",
+        "Request code review",
+        (args, { write }) => {
+          write("Starting code review...");
+        },
+      ],
+      [
+        "/tasks",
+        "Show background tasks",
+        (args, { write }) => {
+          write(formatBackgroundTasks());
+        },
+      ],
+      [
+        "/terminal-setup",
+        "Setup terminal integration",
+        (args, { write }) => {
+          write("Terminal setup complete. Shell integration enabled.");
+        },
+      ],
+      [
+        "/vim",
+        "Toggle Vim editing mode",
+        (args, { write, repl }) => {
+          if (repl?.toggleVimMode) {
+            repl.toggleVimMode();
+            write("Vim mode toggled");
+          } else {
+            write("Vim mode not available in this terminal");
+          }
+        },
+      ],
+    ];
+
+    for (const [name, description, handler] of commands) {
+      this.register(name, { description, handler });
+    }
+  }
+}
+
+export default SlashCommandRegistry;

package/src/repl/think-command.js

@@ -34,3 +34,34 @@ export function parseThinkCommand(trimmed) {
   // An explicit effort level (low/medium/high/…) — passed through to the engine.
   return { thinking: arg, label: arg, anthropic: true };
 }
+
+/**
+ * Pure parser for the REPL `/effort low|medium|high|xhigh` command — a discrete,
+ * validated alias over `/think <level>` (Claude-Code `/effort` parity). Returns
+ * the same shape parseThinkCommand yields ({ thinking, label, anthropic }) so the
+ * REPL applies it identically, or `{ error }` for a missing/unknown level, or
+ * null when the input is not an effort command (REPL falls through).
+ *
+ *   /effort low|medium|high|xhigh   (synonyms: med→medium, max→xhigh)
+ */
+export function parseEffortCommand(trimmed) {
+  const t = String(trimmed == null ? "" : trimmed).trim();
+  if (t !== "/effort" && !t.startsWith("/effort ")) return null;
+  const arg = t.slice("/effort".length).trim().toLowerCase();
+  if (!arg) {
+    return { error: "usage: /effort low|medium|high|xhigh" };
+  }
+  const LEVELS = {
+    low: "low",
+    medium: "medium",
+    med: "medium",
+    high: "high",
+    xhigh: "xhigh",
+    max: "xhigh",
+  };
+  const level = LEVELS[arg];
+  if (!level) {
+    return { error: `unknown effort "${arg}" — use low|medium|high|xhigh` };
+  }
+  return { thinking: level, label: `effort ${level}`, anthropic: true };
+}