chainlesschain 0.162.143 → 0.162.147

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/runtime/agent-core.js

@@ -44,6 +44,7 @@ import { createToolContext } from "../tools/tool-context.js";
 import { createToolTelemetryRecord } from "../tools/tool-telemetry.js";
 import { isAbortError, throwIfAborted } from "../lib/abort-utils.js";
 import { buildSearchCommand } from "../lib/search-command.js";
+import { discoverCommands } from "../lib/slash-commands.js";
 import {
   isRetryableStreamError,
   STREAM_RETRY_BASE_MS,
@@ -700,6 +701,30 @@ export function buildSystemPrompt(cwd, opts = {}) {
       extraDirs.map((d) => `- ${d}`).join("\n");
   }
 
+  // Advertise user-defined slash commands (.claude/commands/*.md etc.) so the
+  // model knows which prompt macros it can run via the slash_command tool.
+  try {
+    const macros = discoverCommands(dir);
+    if (macros.length > 0) {
+      prompt +=
+        `\n\n## Available slash commands\n` +
+        `These are reusable prompt macros the user has defined. Run one with ` +
+        `the slash_command tool (e.g. {"command":"/${macros[0].name}"}) when it ` +
+        `fits the task; the tool returns the command's expanded instructions ` +
+        `for you to carry out.\n` +
+        macros
+          .map(
+            (m) =>
+              `- /${m.name}` +
+              (m.argumentHint ? ` ${m.argumentHint}` : "") +
+              (m.description ? ` — ${m.description}` : ""),
+          )
+          .join("\n");
+    }
+  } catch {
+    // Non-critical — command discovery failure must not break the prompt.
+  }
+
   return prompt;
 }
 
@@ -1272,6 +1297,7 @@ export async function executeTool(name, args, context = {}) {
       approvalGate: context.approvalGate || null,
       shellConfirm: context.shellConfirm || null,
       additionalDirectories: context.additionalDirectories || null,
+      sandbox: context.sandbox || null,
       ruleAllowed,
       subAgentDepth: context.subAgentDepth || 0,
       subAgentBudget: context.subAgentBudget || null,
@@ -1686,6 +1712,7 @@ async function executeToolInner(
     approvalGate,
     shellConfirm,
     additionalDirectories,
+    sandbox,
     ruleAllowed = false,
     subAgentDepth = 0,
     subAgentBudget = null,
@@ -1993,6 +2020,13 @@ async function executeToolInner(
       // polls output + completion via check_shell. No timeout — that's the whole
       // point of backgrounding (builds, test suites, dev servers).
       if (args.run_in_background === true) {
+        if (sandbox) {
+          return attachDescriptor({
+            error:
+              "[Sandbox] Background shell tasks are not supported in the ephemeral sandbox. Run in the foreground or explicitly disable --sandbox.",
+            policy: { decision: "deny", via: "sandbox" },
+          });
+        }
         // Free memory from idle background tasks before adding another, so a
         // long agent run can't accumulate forgotten dev servers (no-op unless
         // the machine is actually under memory pressure).
@@ -2088,6 +2122,50 @@ async function executeToolInner(
         );
       }
 
+      if (sandbox) {
+        const { executeSandboxedShell, sandboxSummary } =
+          await import("../lib/agent-sandbox.js");
+        const result = executeSandboxedShell(args.command, sandbox, {
+          cwd: args.cwd || cwd,
+          timeout: _resolveShellTimeout(args.timeout),
+          maxBuffer: 1024 * 1024,
+          env: {
+            CLAUDECODE: "1",
+            ...(sessionId
+              ? {
+                  CC_SESSION_ID: String(sessionId),
+                  CLAUDE_CODE_SESSION_ID: String(sessionId),
+                }
+              : {}),
+          },
+        });
+        const common = {
+          sandbox: sandboxSummary(sandbox),
+          shellCommandPolicy: shellPolicy,
+          approval: approvalOutcome,
+          policyTrace: ["shell-policy", "approval", "sandbox"],
+        };
+        if (result.exitCode !== 0) {
+          return attachDescriptor(
+            {
+              error: (
+                result.stderr ||
+                `Sandbox command exited with code ${result.exitCode}`
+              ).substring(0, 2000),
+              stdout: result.stdout.substring(0, 30000),
+              stderr: result.stderr.substring(0, 2000),
+              exitCode: result.exitCode,
+              ...common,
+            },
+            override || runtimeDescriptor,
+          );
+        }
+        return attachDescriptor(
+          { stdout: result.stdout.substring(0, 30000), ...common },
+          override || runtimeDescriptor,
+        );
+      }
+
       try {
         const output = execSync(args.command, {
           cwd: args.cwd || cwd,
@@ -2348,6 +2426,59 @@ async function executeToolInner(
       }
     }
 
+    case "slash_command": {
+      try {
+        const { getCommand, expandCommand, discoverCommands } =
+          await import("../lib/slash-commands.js");
+        const raw = String(args.command || "").trim();
+        if (!raw) {
+          return attachDescriptor({
+            error: "slash_command requires a non-empty 'command'.",
+          });
+        }
+        // Parse "/name arg1 arg2" exactly like a typed slash command (leading
+        // '/' optional). First token is the command name, the rest are args.
+        const [head, ...rest] = raw.replace(/^\//, "").split(/\s+/);
+        const macro = head ? getCommand(head, cwd) : null;
+        if (!macro) {
+          const available = discoverCommands(cwd).map((c) => ({
+            name: c.name,
+            scope: c.scope,
+            description: c.description || undefined,
+          }));
+          return attachDescriptor({
+            error: `Unknown slash command "${head}".`,
+            availableCommands: available,
+            hint:
+              available.length === 0
+                ? "No user-defined slash commands found in .claude/commands/ or .chainlesschain/commands/."
+                : "Call slash_command with one of availableCommands[].name.",
+          });
+        }
+        // allowBang:false — the agent must not get an un-gated shell side
+        // channel via a command file. $ARGUMENTS / @file (read) still expand;
+        // any !`cmd` is left literal for the model to run via run_shell.
+        const { prompt: expanded, warnings } = expandCommand(
+          macro,
+          rest.filter(Boolean),
+          { cwd, allowBang: false },
+        );
+        return attachDescriptor({
+          command: macro.name,
+          scope: macro.scope,
+          expandedPrompt: expanded,
+          warnings: warnings && warnings.length ? warnings : undefined,
+          instructions:
+            "The expandedPrompt is the command's instructions. Carry them out " +
+            "now using your normal tools.",
+        });
+      } catch (err) {
+        return attachDescriptor({
+          error: `slash_command failed: ${err.message}`,
+        });
+      }
+    }
+
     case "ask_user_question": {
       if (!interaction || typeof interaction.askUser !== "function") {
         return attachDescriptor({
@@ -4633,6 +4764,7 @@ export async function* agentLoop(messages, options) {
     // false so run_code keeps its existing per-permission-mode behavior.
     interactiveApproval: options.interactiveApproval || false,
     additionalDirectories: options.additionalDirectories || null,
+    sandbox: options.sandbox || null,
     permissionRules: options.permissionRules || null,
     permissionConfirm: options.permissionConfirm || null,
     settingsHooks: options.settingsHooks || null,
@@ -5091,7 +5223,11 @@ export async function* agentLoop(messages, options) {
       });
       for (const { call, toolArgs, promise } of inflight) {
         throwIfAborted(signal);
-        yield { type: "tool-executing", tool: call.function.name, args: toolArgs };
+        yield {
+          type: "tool-executing",
+          tool: call.function.name,
+          args: toolArgs,
+        };
         const { result: toolResult, error: toolError } = await promise;
         throwIfAborted(signal);
         const warningMsg = budget.toWarningMessage();

package/src/runtime/coding-agent-contract-shared.cjs

@@ -653,6 +653,43 @@ const CODING_AGENT_TOOL_CONTRACTS = Object.freeze([
       tags: ["tool:todo_write", "contract:coding-agent", "tier:extension"],
     },
   },
+  {
+    name: "slash_command",
+    title: "Slash Command",
+    kind: "planning",
+    tier: "extension",
+    description:
+      "Run a user-defined slash command (a reusable prompt macro from " +
+      ".claude/commands/*.md or .chainlesschain/commands/*.md) and get back its " +
+      "expanded prompt text to act on. The 'command' string is the slash " +
+      "command exactly as a user would type it, e.g. '/review' or " +
+      "'/git:commit fix the typo' — the leading slash is optional and trailing " +
+      "words become $ARGUMENTS / $1..$9. @file references are expanded; " +
+      "!`shell` snippets are NOT executed when invoked this way (run them via " +
+      "run_shell if needed). Available commands are listed in the system " +
+      "prompt; calling with an unknown command returns the list.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description:
+            "The slash command to run, as typed by a user, e.g. '/review' or " +
+            "'/git:commit fix the typo'. Leading '/' optional.",
+        },
+      },
+      required: ["command"],
+    },
+    ...TOOL_POLICY_METADATA.slash_command,
+    permissions: {
+      level: "readonly",
+      scopes: ["session:read"],
+    },
+    telemetry: {
+      category: "planning",
+      tags: ["tool:slash_command", "contract:coding-agent", "tier:extension"],
+    },
+  },
   {
     name: "ask_user_question",
     title: "Ask User Question",

package/src/runtime/coding-agent-policy.cjs

@@ -149,6 +149,20 @@ const TOOL_POLICY_METADATA = Object.freeze({
     approvalFlow: "auto",
     isReadOnly: true,
   },
+  // Expand a user-defined slash command (.claude/commands/*.md) into its prompt
+  // text. Read-only by design: the agent path disables `!`cmd`` bang execution,
+  // so only $ARGUMENTS / @file (read) substitution runs — no un-gated shell.
+  // Plan-mode-safe (returns text the model then acts on via its normal tools).
+  slash_command: {
+    riskLevel: RISK_LEVELS.LOW,
+    category: TOOL_CATEGORIES.SKILL,
+    availableInPlanMode: true,
+    planModeBehavior: "allow",
+    requiresPlanApproval: false,
+    requiresConfirmation: false,
+    approvalFlow: "auto",
+    isReadOnly: true,
+  },
   search_sessions: {
     riskLevel: RISK_LEVELS.LOW,
     category: TOOL_CATEGORIES.SEARCH,

package/src/runtime/headless-runner.js

@@ -280,18 +280,31 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   // an `ask` falls closed (no human to confirm in headless). No file → null →
   // every existing risk-tier / shell-policy layer runs unchanged.
   let permissionRules = options.permissionRules || null;
-  if (!permissionRules) {
-    try {
-      const { loadSettings } = await import("../lib/settings-loader.cjs");
-      const loaded = loadSettings({ cwd, settingsFile: options.settingsFile });
+  let managedSettings = null;
+  try {
+    const { loadSettings, applyManagedPermissionPolicy } =
+      await import("../lib/settings-loader.cjs");
+    const loaded = loadSettings({
+      cwd,
+      settingsFile: options.settingsFile,
+      managedSettingsFile: options.managedSettingsFile,
+    });
+    managedSettings = loaded.managed;
+    if (!permissionRules) {
       const total =
         loaded.rules.allow.length +
         loaded.rules.ask.length +
         loaded.rules.deny.length;
       permissionRules = total > 0 ? loaded.rules : null;
-    } catch {
-      permissionRules = null; // fail-open
+    } else if (managedSettings) {
+      permissionRules = applyManagedPermissionPolicy(
+        permissionRules,
+        managedSettings,
+      );
     }
+  } catch (error) {
+    if (error?.code === "CC_MANAGED_SETTINGS_INVALID") throw error;
+    // Preserve caller-provided rules; absent settings keep legacy behavior.
   }
 
   // .claude/settings.json `hooks` block — decision-capable PreToolUse/
@@ -483,6 +496,11 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   }
 
   // ── Permission + tool resolution ──────────────────────────────────────
+  if (managedSettings) {
+    const { assertManagedPermissionMode } =
+      await import("../lib/settings-loader.cjs");
+    assertManagedPermissionMode(options.permissionMode, managedSettings);
+  }
   const perm = resolvePermissionMode(options.permissionMode);
   const enabledToolNames = resolveEnabledTools({
     // An explicit --allowed-tools wins; otherwise a matched command's
@@ -705,6 +723,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
       mcp = await doResolve(
         {
           mcpConfigPath: options.mcpConfig || null,
+          managedSettingsFile: options.managedSettingsFile,
           db: db?.getDatabase?.() || null,
           includeRegistered: options.useRegisteredMcp !== false,
           // --strict-mcp-config: use ONLY the --mcp-config servers, ignoring
@@ -803,6 +822,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     apiKey,
     cwd,
     additionalDirectories,
+    sandbox: options.sandbox || null,
     sessionId,
     autoCheckpoint: options.autoCheckpoint || false,
     checkpointSession: options.checkpointSession || sessionId,