chainlesschain 0.162.154 → 0.162.155

package/src/commands/agent.js

@@ -240,7 +240,7 @@ export function registerAgentCommand(program) {
     )
     .option(
       "--permission-mode <mode>",
-      "default | plan | acceptEdits | bypassPermissions (headless)",
+      "manual | auto | dontAsk | default | plan | acceptEdits | bypassPermissions (plan headless-only)",
     )
     .option(
       "--no-file-refs",
@@ -315,6 +315,10 @@ export function registerAgentCommand(program) {
       "--permission-prompt-tool <tool>",
       "Defer tool approvals to an MCP tool (mcp__<server>__<tool>; requires --mcp-config) instead of headless fail-closed",
     )
+    .option(
+      "--remote-control",
+      "Headless: route confirm-tier approvals to paired mobile/web devices — prints a pairing URI/QR, waits for remote allow/deny (fail-closed on timeout)",
+    )
     .option(
       "--settings <file>",
       "Merge an extra .claude/settings.json-shaped file for this run: permission rules (allow/ask/deny) + native config overrides (model, env)",
@@ -777,6 +781,7 @@ export function registerAgentCommand(program) {
             jetbrains: options.jetbrains,
             cwd,
             permissionPromptTool: options.permissionPromptTool || null,
+            remoteControl: options.remoteControl === true,
             interactiveApprovals: options.interactiveApprovals === true,
             settingsFile: options.settings || null,
             outputStyle: options.outputStyle || null,
@@ -840,7 +845,7 @@ export function registerAgentCommand(program) {
             process.exitCode = 1;
             return;
           }
-          const { launchBackgroundAgent } =
+          const { launchBackgroundAgent, buildFollowUpArgv } =
             await import("../lib/background-agent-supervisor.js");
           const childArgv = process.argv
             .slice(2)
@@ -856,6 +861,14 @@ export function registerAgentCommand(program) {
             options.session ||
             `session-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
           if (!hasSessionArg) childArgv.push("--session", sessionId);
+          // Follow-up template for interactive attach: same flags/session,
+          // minus the first turn's prompt tokens (built BEFORE any piped
+          // prompt is appended below). The worker appends -p <text> per turn.
+          const followUpArgv = buildFollowUpArgv(childArgv, {
+            positionalTokens: Array.isArray(task) ? task : [],
+            printValue:
+              typeof options.print === "string" ? options.print : null,
+          });
           const promptWasPiped =
             positional.length === 0 &&
             !(typeof options.print === "string" && options.print.trim());
@@ -865,6 +878,7 @@ export function registerAgentCommand(program) {
             cwd: process.cwd(),
             sessionId,
             title: prompt.slice(0, 100),
+            followUpArgv,
           });
           if (options.outputFormat === "json") {
             console.log(JSON.stringify(state));
@@ -961,6 +975,8 @@ export function registerAgentCommand(program) {
           cwd: process.cwd(),
           // --permission-prompt-tool: defer approvals to an MCP tool
           permissionPromptTool: options.permissionPromptTool || null,
+          // --remote-control: approvals from paired mobile/web devices
+          remoteControl: options.remoteControl === true,
           // --strict-mcp-config: only --mcp-config servers (ignore registered + IDE)
           strictMcpConfig: options.strictMcpConfig === true,
           // --settings: extra .claude/settings.json permission rules
@@ -1032,6 +1048,11 @@ export function registerAgentCommand(program) {
         apiKey: options.apiKey,
         sessionId: options.session,
         agentId: options.agentId,
+        // --permission-mode also applies interactively: manual → strict,
+        // acceptEdits → trusted, bypassPermissions → autopilot, auto → trusted
+        // + autoMode.decisions classifier; dontAsk denies instead of asking
+        // (plan stays headless-only).
+        permissionMode: options.permissionMode,
         recallLimit: options.recallLimit,
         recallQuery: options.recallQuery,
         recallMemory: options.recallMemory, // false when --no-recall-memory

package/src/commands/agents.js

@@ -71,6 +71,41 @@ export function registerAgentsCommand(program) {
       }
     });
 
+  cmd
+    .command("view <id>")
+    .description("Show a detailed background agent view")
+    .option("-n, --lines <n>", "Recent log lines to include", "40")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const [
+          {
+            readBackgroundAgentState,
+            effectiveBackgroundAgentState,
+            readBackgroundAgentLog,
+          },
+          { formatBackgroundAgentDetails },
+        ] = await Promise.all([
+          import("../lib/background-agent-supervisor.js"),
+          import("./background-session.js"),
+        ]);
+        const session = effectiveBackgroundAgentState(
+          readBackgroundAgentState(id),
+        );
+        if (!session) throw new Error(`Background agent not found: ${id}`);
+        const lines = Number.isFinite(Number(options.lines))
+          ? Math.max(1, Math.floor(Number(options.lines)))
+          : 40;
+        const log = readBackgroundAgentLog(id, { lines });
+        if (options.json)
+          console.log(JSON.stringify({ session, log }, null, 2));
+        else logger.log(formatBackgroundAgentDetails(session, log));
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
   cmd
     .command("stop <id>")
     .description("Stop a running background agent")
@@ -90,6 +125,29 @@ export function registerAgentsCommand(program) {
       }
     });
 
+  cmd
+    .command("rename <id> <title...>")
+    .description("Rename a background agent session")
+    .option("--json", "Output as JSON")
+    .action(async (id, title, options) => {
+      try {
+        const { renameBackgroundAgent } =
+          await import("../lib/background-agent-supervisor.js");
+        const state = renameBackgroundAgent(
+          id,
+          Array.isArray(title) ? title.join(" ") : title,
+        );
+        if (options.json) console.log(JSON.stringify(state, null, 2));
+        else {
+          logger.log(chalk.green(`Renamed background agent ${id}`));
+          logger.log(chalk.gray(`  ${state.title}`));
+        }
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
   // ── list ──────────────────────────────────────────────────────────────
   cmd
     .command("list")
@@ -172,7 +230,10 @@ export function registerAgentsCommand(program) {
     .description("Run a task headlessly as the named subagent")
     .option("--output-format <fmt>", "text | json | stream-json", "text")
     .option("--model <model>", "Override the agent's model")
-    .option("--permission-mode <mode>", "ApprovalGate tier (see cc agent)")
+    .option(
+      "--permission-mode <mode>",
+      "manual | auto | dontAsk | default | plan | acceptEdits | bypassPermissions",
+    )
     .option("--add-dir <dir...>", "Extra workspace roots")
     .action(async (name, task, options) => {
       try {

package/src/commands/auto-mode.js

@@ -0,0 +1,87 @@
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import {
+  autoModeDefaultsDocument,
+  loadAutoModeConfig,
+  resolveAutoModeDecisions,
+} from "../lib/auto-mode-config.js";
+
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+function printConfigSummary(config, resolved) {
+  logger.log(chalk.bold("Auto mode effective config"));
+  logger.log(
+    `  classifyAllShell: ${String(config.effective.classifyAllShell)}`,
+  );
+  logger.log(
+    `  classifier:       ${resolved.customized ? "autoMode.decisions (customized)" : "trusted policy (defaults)"}`,
+  );
+  for (const rule of resolved.rules || []) {
+    const match = Object.entries(rule.match)
+      .map(([k, v]) => `${k}=${v}`)
+      .join(" ");
+    logger.log(`  rule   ${match} →  ${rule.decision.padEnd(5)} (settings)`);
+  }
+  for (const riskLevel of ["low", "medium", "high"]) {
+    const rule = resolved.map[riskLevel];
+    logger.log(
+      `  ${riskLevel.padEnd(6)} risk →    ${rule.decision.padEnd(5)} (${rule.source}: ${rule.reason})`,
+    );
+  }
+  if (config.files.length) {
+    logger.log(chalk.gray(`  sources: ${config.files.join(", ")}`));
+  } else {
+    logger.log(chalk.gray("  sources: defaults only"));
+  }
+  if (config.managedFile) {
+    logger.log(chalk.yellow(`  managed: ${config.managedFile}`));
+  }
+}
+
+export function registerAutoModeCommand(program) {
+  const cmd = program
+    .command("auto-mode")
+    .alias("automode")
+    .description("Inspect auto permission-mode defaults and effective config");
+
+  cmd
+    .command("defaults")
+    .description("Print built-in auto-mode classification defaults as JSON")
+    .action(() => {
+      printJson(autoModeDefaultsDocument());
+    });
+
+  cmd
+    .command("config")
+    .description("Print the effective auto-mode config")
+    .option("--json", "Output as JSON")
+    .option("--settings <file>", "Also merge an explicit settings file")
+    .action((options) => {
+      try {
+        const config = loadAutoModeConfig({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+        const resolved = resolveAutoModeDecisions(config.effective);
+        if (options.json) {
+          printJson({
+            ...config,
+            decisions: resolved.map,
+            rules: (resolved.rules || []).map((rule) => ({
+              match: rule.match,
+              decision: rule.decision,
+              reason: rule.reason,
+            })),
+            customized: resolved.customized,
+          });
+          return;
+        }
+        printConfigSummary(config, resolved);
+      } catch (error) {
+        logger.error(chalk.red(`auto-mode config failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+}