multiclaw 0.12.0 → 0.13.0

package/README.md

@@ -114,6 +114,7 @@ export default defineConfig({
   defaults: {
     provider: "claude",     // which agent product runs the team
     model: "sonnet",        // default model (overridable per agent)
+    permissions: { mode: "auto" }, // optional; "auto" | "ask" | "deny"
   },
 
   agents: [
@@ -127,7 +128,7 @@ export default defineConfig({
       systemPrompt: "You are a software architect.", // optional
       taskPrompt: `Design the system for {{requirement}}.
 Read the brief at {{file:brief.md}} and write architecture.md.`,
-      tools: ["Read", "Write"],
+      permissions: { mode: "ask" }, // optional; overrides the project mode here
       dependsOn: [],          // optional; list of agent ids this agent waits for
       timeout: 600_000,       // optional; ms, default: 600 000 (10 min)
       retries: 0,             // optional; retry count on failure, default: 0
@@ -138,7 +139,6 @@ Read the brief at {{file:brief.md}} and write architecture.md.`,
       name: "Developer",
       model: "sonnet",        // override model for this agent
       taskPrompt: "Read architecture.md and implement the code.",
-      tools: ["Read", "Write", "Bash"],
       dependsOn: ["architect"],
     },
   ],
@@ -159,6 +159,7 @@ Read the brief at {{file:brief.md}} and write architecture.md.`,
 | `logDir` | string | | Log output directory. Default: `workDir/.multiclaw/logs`. |
 | `continueOnError` | boolean | | Keep running when an agent fails. Default: `false`. |
 | `maxConcurrency` | number | | Max agents running in parallel. Default: unlimited. |
+| `permissions` | `{ mode: "auto" \| "ask" \| "deny", onRequest? }` | | Approval mode for tool calls, plus the handler `"ask"` escalates to. Default: `"auto"` for `run`, `"ask"` in the console. |
 
 ### Agent fields
 
@@ -175,7 +176,7 @@ Read the brief at {{file:brief.md}} and write architecture.md.`,
 | `modelTier` | `"strong"` \| `"balanced"` \| `"fast"` | | Declares the capability this agent needs; the catalog maps each tier to a provider-specific model id. Ignored when `model` is set. |
 | `model` | string | | Override the model id for this agent (provider-specific, e.g. `"opus"`, `"sonnet"`, `"haiku"` for Claude). Takes precedence over `modelTier` and `models`. |
 | `models` | Record<string, string> | | Map of provider id (or the legacy `"acp"`) to a model id, e.g. `{ claude: "sonnet", opencode: "opencode/big-pickle" }`. Used when `model`/`modelTier` are unset. |
-| `tools` | string[] | | Allowed tools. Default: `["Read", "Write", "Bash"]`. |
+| `permissions` | `{ mode: "auto" \| "ask" \| "deny" }` | | Approval mode for this agent's tool calls. Overrides `permissions` and `defaults.permissions`. |
 | `dependsOn` | string[] | | Agent ids that must complete before this agent starts. |
 | `timeout` | number | | Per-agent timeout in ms. Default: `600000` (10 min). |
 | `retries` | number | | Number of retry attempts on failure. Default: `0`. |
@@ -229,9 +230,8 @@ TEAM                1/4 │ Architect · sonnet-4 · ⠹ running          4.2s
 | Header | Project name, turn number, and the phase or elapsed time |
 | Pipeline rail | The leader, then each stage in order, joined by `──▸` |
 | Team panel | One row per agent: status glyph, name, live time, and progress (`1/4`) |
-| Stream panel | Live output of the focused agent, with a `▼` live / `⏸` parked marker |
+| Stream panel | The focused agent's output across every turn of this session, with a `▼` live / `⏸` parked marker |
 | Reply panel | What the leader answered, when a turn needed no pipeline |
-| Review banner | `viewing turn N …` while a past turn is open |
 | Queue strip | Follow-ups typed mid-run, in the order they will run |
 | Prompt | Where you type — live even while a turn is running |
 | Hint bar | Aggregate status on the left, the keys that work *right now* on the right |
@@ -257,13 +257,14 @@ which is what keeps typing a requirement from tripping over shortcuts.
 | Key | Action |
 |-----|--------|
 | `enter` | Run the typed requirement — or queue it while a turn is running |
-| `tab` / `shift+tab` | Cycle the focused agent |
+| `tab` | Cycle the focused agent |
+| `shift+tab` | Toggle the permission mode (`auto` ↔ `ask`) |
 | `↑` `↓` `pgup` `pgdn` | Scroll the focused agent's stream |
 | `←` `→` `home` `end` | Move the caret |
-| `esc` | Stop reading a past turn, clear the line, or close an overlay |
+| `esc` | Clear the line, or close an overlay |
 | `?` | Key map (idle, empty line only) |
 | `/` | Command menu (empty line only) |
-| `ctrl+l` | Clear the focused agent's log |
+| `ctrl+l` | Clear the focused agent's output for the current turn |
 | `ctrl+c` | Cancel the running turn *and its queue*; again when idle to quit |
 
 Scrolling up parks the stream and scrolling back to the bottom resumes it, so there is no follow
@@ -280,17 +281,36 @@ the background.
 
 ### Commands
 
-Type `/` on an empty line for a filtered list.
+Type `/` on an empty line, select an operation and press Enter. Commands that need an
+agent, mode or turn open a selector; search and steering open an input field. `Esc`
+cancels the operation. The menu only offers actions relevant to the current state.
 
 | Command | Action |
 |---------|--------|
-| `/agents` | List the configured team |
-| `/focus <id>` | Focus an agent by id |
-| `/clear` | Clear the focused agent's log |
-| `/history` | Browse finished turns |
-| `/cancel` | Cancel the running turn and its queue |
-| `/help` | Key map |
-| `/quit` | Exit |
+| `/new` | Open an empty new session; type the requirement afterwards (idle only) |
+| `/sessions` | Select, switch or delete a saved session (idle only) |
+| `/focus` | Select the agent to view |
+| `/mode` | Select `ask`, `auto` or `deny` |
+| `/verbose` | Toggle tool detail |
+| `/search` | Enter search text; `Ctrl+N` / `Ctrl+P` move between matches |
+| `/latest` | Return to the latest output |
+| `/retry` | Select one failed/repair agent or all of them (idle only) |
+| `/replay` | Select a finished turn to run again (idle only) |
+| `/edit` | Select a finished turn and edit its requirement in the prompt |
+| `/export` | Select a finished turn to export as Markdown |
+| `/steer` | Enter a message for agents running now |
+| `/pause` | Pause a non-empty follow-up queue |
+| `/continue` | Resume a paused queue, or continue at a checkpoint |
+
+For direct entry, `/focus <id>`, `/mode <mode>`, `/search <text>`,
+`/retry <id>`, `/replay <turn>`, `/edit <turn>`, `/export <turn> [path]`
+and `/steer <text>` are also supported. `/new` takes no arguments.
+Editing a previous requirement does not branch the session or restore files.
+
+Approvals and agent questions are handled in their panels. Leader clarification and
+checkpoint feedback use ordinary input. `Ctrl+L` clears the current output, `?`
+opens help, `Ctrl+C` cancels a running turn and its queue or exits when idle with
+an empty prompt, and `Ctrl+D` exits with an empty prompt (also while running).
 
 The console renders on the alternate screen buffer, so your shell scrollback is preserved.
 
@@ -306,11 +326,29 @@ are per-run: `workDir/.multiclaw/runs/run-<timestamp>/logs/`.
 
 ### History
 
-`/history` lists finished turns newest first, with each turn's outcome, duration, agent count and
-requirement. `↑` `↓` select and `enter` opens one for reading — the panes render that turn behind a
-`viewing turn N` banner, and `esc` returns to the live turn. Scrolling and `tab` apply to what you
-are reading, never to the turn that is still running. The turn on screen is not listed, and the last
-20 finished turns are kept.
+The stream panel shows the focused agent's whole session: every turn it took part in, oldest first,
+separated by dim `──── turn N · <requirement> ────` rows. Scrolling up walks back through it — there
+is no separate "open a past turn" mode and no `esc` to leave one. `tab` switches agent, and each
+agent keeps its own timeline. The header appends `· N turns` once an agent has run more than once.
+The last 20 finished turns are kept.
+
+The team panel and the pipeline rail stay bound to the live turn, so the orchestration context does
+not change while you are reading history.
+
+### Permission modes
+
+`permissions: { mode: ... }` decides what happens to a provider's tool-permission request:
+
+| Mode | Behaviour |
+|------|-----------|
+| `"auto"` | Every request is approved. No prompts. |
+| `"ask"` | Every request is escalated to a human — the console's permission bar, or `permissions.onRequest`. With nobody to ask, it is refused. |
+| `"deny"` | Every request is refused. |
+
+`multiclaw run` has nobody to ask, so `"ask"` without an `onRequest` handler refuses every tool call;
+the run warns about this before it starts. The console starts in `"ask"` unless the config says
+otherwise. `shift+tab` toggles between `auto` and `ask` at runtime, and `/mode auto|ask|deny` sets any
+of the three; the active mode is shown in the header.
 
 On a narrow terminal (under 72 columns) the team panel is dropped and the stream takes the full
 width; on a short one (under 16 rows) the pipeline rail goes too. The header, prompt and hint bar are

package/dist/commands/doctor.d.ts

@@ -20,7 +20,6 @@ export interface DoctorReport {
         defaultsProvider?: string;
         defaultsProviderOk: boolean;
         agentsWithMissingProvider: string[];
-        agentsWithUnsupportedTools: string[];
     };
     runnable: boolean;
 }

package/dist/commands/init.d.ts

@@ -14,6 +14,7 @@ export declare function generateConfig(opts: {
     workDir: string;
     projectName: string;
     provider: string;
+    permissionMode: "auto" | "ask";
 }): string;
 export declare function initCommand(options?: {
     force?: boolean;

package/dist/index.js

@@ -9,11 +9,8 @@ import { Command } from "commander";
 // src/commands/doctor.ts
 import {
   detectProviders,
-  hasExplicitTools,
   presentProviders,
-  resolveCommand,
   resolveProvider,
-  specForCommand,
   specForProvider
 } from "@multiclawcli/core";
 
@@ -116,21 +113,11 @@ function buildDoctorReport(detected, config) {
     const agents2 = [...config.agents];
     if (config.leader && config.useLeader !== false) agents2.push(config.leader);
     const agentsWithMissingProvider = agents2.map((a) => ({ id: a.id, intended: resolveProvider(a, config) })).filter((a) => !present.includes(a.intended)).map((a) => a.id);
-    const agentsWithUnsupportedTools = agents2.map((a) => {
-      const command = resolveCommand(a, config);
-      const spec = specForCommand(command) ?? specForProvider(resolveProvider(a, config));
-      return {
-        id: a.id,
-        spec,
-        explicitTools: hasExplicitTools(a) || a.tools === void 0 && !!config.defaults?.tools
-      };
-    }).filter((a) => a.spec && !a.spec.tools && a.explicitTools).map((a) => a.id);
     configReport = {
       name: config.name,
       defaultsProvider,
       defaultsProviderOk,
-      agentsWithMissingProvider,
-      agentsWithUnsupportedTools
+      agentsWithMissingProvider
     };
   }
   return {
@@ -194,14 +181,6 @@ function formatDoctorReport(report, useColor = true) {
     } else {
       lines.push(c(GREEN, "  all agents resolve to an installed provider \u2713"));
     }
-    if (report.config.agentsWithUnsupportedTools.length > 0) {
-      lines.push(
-        c(
-          YELLOW,
-          `  ${report.config.agentsWithUnsupportedTools.length} agent(s) use a provider that cannot enforce tool allowlists: ${report.config.agentsWithUnsupportedTools.join(", ")}`
-        )
-      );
-    }
   }
   lines.push("");
   if (report.runnable) {
@@ -271,6 +250,8 @@ var PRESET_DESCRIPTIONS = {
 function generateConfig(opts) {
   const name = JSON.stringify(opts.projectName);
   const workDir = JSON.stringify(opts.workDir);
+  const permissions = `
+    permissions: { mode: "${opts.permissionMode}" },`;
   return `import { defineConfig, agents } from "multiclaw"
 
 export default defineConfig({
@@ -281,7 +262,7 @@ export default defineConfig({
     projectName: ${name},
   },
   defaults: {
-    provider: ${JSON.stringify(opts.provider)},
+    provider: ${JSON.stringify(opts.provider)},${permissions}
   },
   agents: [
 ${AGENT_BLOCKS[opts.preset]}
@@ -330,8 +311,18 @@ async function initCommand(options = {}) {
     message: "Work directory (where agents read and write files):",
     default: "."
   });
+  const permissionMode = await select({
+    message: "How should multiclaw handle tool permissions?",
+    choices: [
+      { value: "auto", name: "Auto \u2014 agents run without permission prompts (recommended)" },
+      { value: "ask", name: "Manual \u2014 confirm each action before it runs" }
+    ]
+  });
   try {
-    fs2.writeFileSync(configPath, generateConfig({ preset, workDir, projectName, provider }));
+    fs2.writeFileSync(
+      configPath,
+      generateConfig({ preset, workDir, projectName, provider, permissionMode })
+    );
     if (workDir !== ".") {
       fs2.mkdirSync(path2.resolve(process.cwd(), workDir), { recursive: true });
     }
@@ -350,6 +341,7 @@ async function initCommand(options = {}) {
     );
   }
   console.log(`  workDir:  ${workDir}`);
+  console.log(`  mode:     ${permissionMode}`);
   console.log("");
   if (detectedProvider?.status === "missing") {
     console.log(`\x1B[33m\u26A0 ${spec.label} is not installed.\x1B[0m`);
@@ -629,22 +621,24 @@ import * as fs6 from "fs";
 import * as path6 from "path";
 import {
   describeResumePlan,
-  Orchestrator as OrchestratorImpl
+  Orchestrator as OrchestratorImpl,
+  resolvePermissionMode
 } from "@multiclawcli/core";
 
 // src/lib.ts
 import {
   detectProviders as detectProviders3,
-  hasExplicitTools as hasExplicitTools2,
   presentProviders as presentProviders2,
-  resolveCommand as resolveCommand2,
-  runtimeRegistry,
-  validateToolsPolicy
+  resolveCommand,
+  runtimeRegistry
 } from "@multiclawcli/core";
 import { agents, defineConfig } from "@multiclawcli/core";
 async function assertRuntimesAvailable(config) {
   const checked = /* @__PURE__ */ new Set();
-  const agents2 = config.leader && config.useLeader !== false && hasExplicitTools2(config.leader) ? [config.leader, ...config.agents] : config.agents;
+  const agents2 = [
+    ...config.leader && config.useLeader !== false ? [config.leader] : [],
+    ...config.agents
+  ];
   for (const agent of agents2) {
     const name = agent.runtime ?? "acp";
     if (!runtimeRegistry.has(name)) {
@@ -652,7 +646,7 @@ async function assertRuntimesAvailable(config) {
       console.error(`\x1B[31mError: Unknown runtime "${name}". Supported: ${supported}\x1B[0m`);
       process.exit(1);
     }
-    const command = resolveCommand2(agent, config);
+    const command = resolveCommand(agent, config);
     const key = `${name}\0${command}`;
     if (checked.has(key)) continue;
     checked.add(key);
@@ -665,12 +659,6 @@ async function assertRuntimesAvailable(config) {
       process.exit(1);
     }
   }
-  try {
-    await validateToolsPolicy(config);
-  } catch (error) {
-    console.error(`\x1B[31mError: ${error instanceof Error ? error.message : String(error)}\x1B[0m`);
-    process.exit(1);
-  }
 }
 
 // src/reporters/ConsoleReporter.ts
@@ -997,6 +985,11 @@ async function runCommand(requirementArg, options) {
     return;
   }
   await assertRuntimesAvailable(config);
+  if (resolvePermissionMode(config) === "ask" && config.permissions?.onRequest === void 0) {
+    console.warn(
+      '\x1B[33mWarning: permission mode is "ask" but no permissions.onRequest handler is configured \u2014 every tool call will be refused. Set mode to "auto", or supply a handler.\x1B[0m'
+    );
+  }
   const before = snapshotFiles(config.workDir);
   const orchestrator = new OrchestratorImpl(config);
   orchestrator.eventBus.subscribe((event) => {

package/dist/lib.js

@@ -1,16 +1,17 @@
 // src/lib.ts
 import {
   detectProviders,
-  hasExplicitTools,
   presentProviders,
   resolveCommand,
-  runtimeRegistry,
-  validateToolsPolicy
+  runtimeRegistry
 } from "@multiclawcli/core";
 import { agents, defineConfig } from "@multiclawcli/core";
 async function assertRuntimesAvailable(config) {
   const checked = /* @__PURE__ */ new Set();
-  const agents2 = config.leader && config.useLeader !== false && hasExplicitTools(config.leader) ? [config.leader, ...config.agents] : config.agents;
+  const agents2 = [
+    ...config.leader && config.useLeader !== false ? [config.leader] : [],
+    ...config.agents
+  ];
   for (const agent of agents2) {
     const name = agent.runtime ?? "acp";
     if (!runtimeRegistry.has(name)) {
@@ -31,12 +32,6 @@ async function assertRuntimesAvailable(config) {
       process.exit(1);
     }
   }
-  try {
-    await validateToolsPolicy(config);
-  } catch (error) {
-    console.error(`\x1B[31mError: ${error instanceof Error ? error.message : String(error)}\x1B[0m`);
-    process.exit(1);
-  }
 }
 async function availableRuntimes() {
   const detected = await detectProviders();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaw",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "type": "module",
   "bin": {
     "multiclaw": "dist/index.js"
@@ -30,8 +30,8 @@
     "@agentclientprotocol/claude-agent-acp": "^0.95.0",
     "@agentclientprotocol/codex-acp": "^2.2.2",
     "@inquirer/prompts": "^8.7.4",
-    "@multiclawcli/core": "0.12.0",
-    "@multiclawcli/dashboard": "0.12.0",
+    "@multiclawcli/core": "0.13.0",
+    "@multiclawcli/dashboard": "0.13.0",
     "commander": "^15.0.0",
     "jiti": "^2.7.0"
   },