lazyclaw 5.1.0 → 5.2.0

package/mas/mention_router.mjs

@@ -25,6 +25,7 @@ import * as tasksMod from '../tasks.mjs';
 import * as agentMemory from './agent_memory.mjs';
 import * as skillSynth from './skill_synth.mjs';
 import * as skills from '../skills.mjs';
+import { composePromptStack } from './prompt_stack.mjs';
 
 export class MentionRouterError extends Error {
   constructor(message, code) {
@@ -97,9 +98,31 @@ export function buildTurnContext({ task, team, agent, agentRecord, teammates, co
   // The agent loads a full skill on demand with the skill_view tool —
   // progressive disclosure, so skill bodies don't bloat every prompt.
   const skillsBlock = buildSkillsBlock(configDir);
+  // v5 (canonical decision C5) — prepend the 8-layer prompt stack so the
+  // workspace SOUL / personality / USER.md / long-term memory layers land
+  // ahead of the agent's role. composePromptStack returns '' on a fresh
+  // install so the prompt is byte-identical to the pre-v5 shape when no
+  // layer source exists on disk. Wrapped in try/catch so a missing
+  // configDir file never crashes a live agent turn.
+  let promptStack = '';
+  try {
+    promptStack = composePromptStack({
+      cfgDir: configDir,
+      agent: agentRecord,
+      workspace: task?.workspace || agentRecord.workspace || '',
+    }) || '';
+  } catch { /* best-effort — see comment above */ }
+  // When composePromptStack emitted a Role layer (layer 3) we drop the
+  // bare `role` line below to avoid duplicating agent.role inside the
+  // system prompt. The stack helper builds the Role layer iff
+  // agentRecord.role is non-empty, so checking `promptStack` includes
+  // the marker `## Role (` is sufficient.
+  const stackHasRole = promptStack.includes('## Role (');
   const system = [
-    role,
-    role && '\n\n---\n',
+    promptStack || null,
+    promptStack && '\n\n---\n',
+    stackHasRole ? null : role,
+    !stackHasRole && role && '\n\n---\n',
     memBlock || null,
     skillsBlock || null,
     `You are *${agentRecord.displayName || agentRecord.name}* on team "${team.displayName || team.name}".`,
@@ -113,7 +136,56 @@ export function buildTurnContext({ task, team, agent, agentRecord, teammates, co
     renderTranscript(task.turns),
     `\n\n# Your turn (as ${agentRecord.name}):`,
   ];
-  return { system, user: userParts.join('') };
+
+  // Group B / C10 — also emit history-as-messages. The legacy
+  // single-string `user` field is kept for callers that snapshot it
+  // (existing tests), but production code (runTaskTurn) now wires
+  // `history` into runAgentTurn so Anthropic's prompt cache + KV
+  // cache can lock onto the prior turns byte-identically across
+  // router iterations.
+  //
+  // Mapping:
+  //   - turn.agent === 'user'  → role:'user', plain content
+  //   - turn.agent === speaker → role:'assistant'  (the model's own
+  //     prior turn — looks like an assistant's text from its POV)
+  //   - turn.agent === any other teammate → role:'user' with a
+  //     `[FROM x]` prefix so the model knows it's a peer speaking,
+  //     not the human user
+  // We always prepend a single user-role kickoff message with the
+  // task spec so the first message in the history is anchored on the
+  // task; and we always append a final user-role "your turn" marker
+  // so the model knows when to speak.
+  const history = [];
+  const taskKickoff = [
+    `# Task: ${task.title}`,
+    task.description ? `\n${task.description}\n` : '',
+  ].join('').trim();
+  if (taskKickoff) history.push({ role: 'user', content: taskKickoff });
+  for (const t of (Array.isArray(task.turns) ? task.turns : [])) {
+    if (!t || !t.agent) continue;
+    const txt = String(t.text || '');
+    if (!txt) continue;
+    if (t.agent === 'user') {
+      history.push({ role: 'user', content: txt });
+    } else if (t.agent === agentRecord.name) {
+      history.push({ role: 'assistant', content: txt });
+    } else if (t.agent === 'system') {
+      // System pseudo-turns (kickoff seed) collapse into a user-role
+      // prefix-tagged note so message-role alternation stays clean.
+      history.push({ role: 'user', content: `[SYSTEM] ${txt}` });
+    } else {
+      history.push({ role: 'user', content: `[FROM ${t.agent}] ${txt}` });
+    }
+  }
+  // "Your turn" marker — always a user-role tail so the model is
+  // prompted to speak as the named agent. Combined with the speaker
+  // mapping above this gives Anthropic a stable cacheable prefix:
+  // the first N-1 messages are identical across router iterations
+  // for the same task, and only this final marker (plus a new prior
+  // turn) changes per router pass.
+  history.push({ role: 'user', content: `# Your turn (as ${agentRecord.name})` });
+
+  return { system, user: userParts.join(''), history };
 }
 
 // Build the system-prompt block listing the skills the agent can pull
@@ -238,7 +310,7 @@ async function autoReflect({ task, agentsById, apiKey, baseUrl, fetchImpl, confi
   for (const name of collectParticipants(task)) {
     const agentRecord = agentsById[name];
     if (!agentRecord) continue;
-    if (agentRecord.memoryWrite && agentRecord.memoryWrite !== 'auto') continue;
+    if ((agentRecord.memoryWrite ?? 'auto') !== 'auto') continue;
     try {
       const body = await agentMemory.reflectOnce({
         agent: agentRecord,
@@ -257,18 +329,19 @@ async function autoReflect({ task, agentsById, apiKey, baseUrl, fetchImpl, confi
   }
 }
 
-// Phase 20 — fire one skill-synthesis LLM call per participating agent
-// whose skillWrite is 'auto', installing the resulting SKILL.md into
-// the shared skills dir. Default skillWrite is 'manual', so this is a
-// no-op unless the user opted an agent in. Best-effort: a failed
-// synthesis is logged, never thrown, so it can't poison a finished
-// task.
+// Phase 20 / v5 Group A (M3) — fire one skill-synthesis LLM call per
+// participating agent whose skillWrite is 'auto' (the default since
+// v5). Installs the resulting SKILL.md into the shared skills dir.
+// Legacy v4 agents (no explicit skillWrite field) inherit the new
+// 'auto' default via the `?? 'auto'` guard below — without a forced
+// migration. Best-effort: a failed synthesis is logged, never thrown,
+// so it can't poison a finished task.
 async function autoSynthSkills({ task, agentsById, apiKey, baseUrl, fetchImpl, configDir, logger = () => {} }) {
   if (!task || !Array.isArray(task.turns)) return;
   for (const name of collectParticipants(task)) {
     const agentRecord = agentsById[name];
     if (!agentRecord) continue;
-    if (agentRecord.skillWrite !== 'auto') continue;
+    if ((agentRecord.skillWrite ?? 'auto') !== 'auto') continue;
     try {
       const result = await skillSynth.synthesizeSkill({ agent: agentRecord, task, apiKey, baseUrl, fetchImpl });
       if (result) {
@@ -370,10 +443,18 @@ export async function runTaskTurn({
     try {
       result = await agentTurn.runAgentTurn({
         agent: { ...agentRecord, role: ctx.system },
-        userMessage: ctx.user,
-        history: [],
+        // Group B / C10 — feed the transcript as a proper messages
+        // history. The kickoff + prior turns + "your turn" marker
+        // live in ctx.history; we leave userMessage empty so the
+        // adapter doesn't double-append a redundant user turn.
+        userMessage: '',
+        history: ctx.history,
         taskId: current.id,
         configDir, cwd, apiKey, fetchImpl, baseUrl, signal, approve,
+        // C9 — enable Anthropic prompt caching for the static system
+        // prefix + tool definitions. Non-anthropic adapters ignore
+        // the flag (it's a no-op for OpenAI/Gemini/claude-cli).
+        cache: true,
       });
     } catch (err) {
       await clearTypingPlaceholder(typing, logger);

package/mas/orchestra.mjs

@@ -0,0 +1,56 @@
+// mas/orchestra.mjs — v5.0 spec §3 / canonical decision C2.
+//
+// "Orchestra" hub — the eventual home of the multi-agent dispatcher
+// (planner + workers + synthesis). For v5.0.10 it acts as a thin
+// coordinator layer:
+//
+//   1. Re-exports `makeOrchestratorProvider` from providers/orchestrator.mjs
+//      so cli.mjs / providers/registry.mjs can migrate the import path
+//      without breaking ~20 call sites in one commit.
+//   2. Owns `POST_HOC_HOOK_NAMES` — the canonical list of triggers the
+//      orchestrator may fan into mas/learning.mjs. Mirrors the
+//      learning module's TRIGGERS so callers can `import { POST_HOC_HOOK_NAMES }
+//      from 'mas/orchestra.mjs'` without pulling the whole learning
+//      surface.
+//   3. Provides `firePostTask({ ... })` — a microtask-safe wrapper around
+//      `learning.runLearning('post-task', …)` so the SYNTHESIS phase of
+//      providers/orchestrator.mjs can hook in via a single import line.
+//
+// Future (Phase 2): the dispatcher itself moves in here and
+// providers/orchestrator.mjs becomes a thin shim that re-exports from
+// mas/orchestra.mjs. Until then the boundary is one-way — orchestra
+// imports from providers/orchestrator.mjs, never the other way around.
+
+import { makeOrchestratorProvider as _make } from '../providers/orchestrator.mjs';
+import { TRIGGERS, runLearning } from './learning.mjs';
+
+// Re-export so callers can migrate gradually.
+export const makeOrchestratorProvider = _make;
+
+// Public alias mirroring the spec language ("post-hoc hooks"). Frozen
+// so a typo on the consumer side surfaces at import time.
+export const POST_HOC_HOOK_NAMES = TRIGGERS;
+
+/**
+ * Fire a learning trigger without blocking the caller's stream. Wraps
+ * runLearning in queueMicrotask + a swallow-everything catch so a
+ * misconfigured trainer key (or a transient FS error) can never poison
+ * the user-facing orchestrator output.
+ *
+ * @param {(typeof TRIGGERS)[number]} trigger
+ * @param {Record<string, unknown>} ctx
+ */
+export function fireLearning(trigger, ctx) {
+  queueMicrotask(() => {
+    runLearning(trigger, ctx).catch(() => { /* swallow */ });
+  });
+}
+
+/**
+ * Convenience for the common case — the orchestrator's SYNTHESIS phase
+ * just finished, fire the post-task hook. Equivalent to
+ * fireLearning('post-task', ctx).
+ */
+export function firePostTask(ctx) {
+  fireLearning('post-task', ctx);
+}

package/mas/skill_synth.mjs

@@ -297,7 +297,25 @@ function buildAntiPatternPrompt(task, transcript) {
 // agent skill, which we then version-bump). Body/description are
 // re-sanitised here too so a direct caller (CLI/router) can't bypass
 // the redaction + cap. Returns { skill, path, version }.
-export function installSynthesized({ name, description = '', body = '', sourceTask = '', createdBy = 'agent' } = {}, configDir, ts = new Date()) {
+export function installSynthesized({
+  name,
+  description = '',
+  body = '',
+  sourceTask = '',
+  createdBy = 'agent',
+  // v5 (Group A — C6 + M1): forward every frontmatter field
+  // synthesizeSkill / runLearning already computed. Without these
+  // forwards the resulting SKILL.md was missing trained_by, confidence,
+  // cross_cli_tested and the anti-pattern flag — exactly the metadata
+  // the canonical learning loop needs to rank skills cross-CLI.
+  trainedBy = null,
+  trainedOnModel = null,
+  trajectoryRef = null,
+  confidence = null,
+  crossCliTested = null,
+  outcome = 'done',
+  group = null,
+} = {}, configDir, ts = new Date()) {
   // Slugify BEFORE reserving the name so a direct caller (CLI/router)
   // can't smuggle a newline/colon into the filename or inject a second
   // frontmatter key. parseSynthOutput already slugifies, but this path
@@ -313,6 +331,13 @@ export function installSynthesized({ name, description = '', body = '', sourceTa
     body: sanitizeSkillBody(body),
     version,
     ts,
+    trainedBy,
+    trainedOnModel,
+    trajectoryRef,
+    confidence,
+    crossCliTested,
+    outcome,
+    group,
   });
   const p = skills.installSkill(finalName, doc, configDir);
   // Phase A: FTS5 mirror (spec §4.4). Group fallback per canonical C5.
@@ -320,9 +345,18 @@ export function installSynthesized({ name, description = '', body = '', sourceTa
     const { meta, body: skillBody } = parseFrontmatter(doc);
     const group = meta.group
       || (finalName.includes('-') ? finalName.split('-')[0] : 'legacy');
+    // Operator-precedence fix (Group A — M5): the original expression
+    //   meta.trained_by || createdBy === 'agent' ? 'agent' : 'user'
+    // parses as
+    //   (meta.trained_by || (createdBy === 'agent')) ? 'agent' : 'user'
+    // so an agent-installed skill with frontmatter `trained_by: human`
+    // was being indexed as `trained_by: 'agent'` (the truthy `meta.trained_by`
+    // collapses to a bare boolean inside the ternary). The corrected
+    // parenthesisation honours frontmatter first, then falls back to
+    // createdBy-derived 'agent' / 'user'.
     _indexSkill({
       skill_name: finalName,
-      trained_by: meta.trained_by || createdBy === 'agent' ? 'agent' : 'user',
+      trained_by: meta.trained_by || (createdBy === 'agent' ? 'agent' : 'user'),
       group_name: group,
       content: skillBody,
     }, configDir);

package/mas/tool_runner.mjs

@@ -5,6 +5,7 @@
 
 import * as registry from './tools/registry.mjs';
 import * as audit from './audit.mjs';
+import { DEFAULT_TOOLS } from '../agents.mjs';
 
 export class ToolError extends Error {
   constructor(message, code) {
@@ -14,9 +15,15 @@ export class ToolError extends Error {
   }
 }
 
+// Resolve the tool whitelist into JSON-Schema entries.
+//   - undefined    → DEFAULT_TOOLS (the 5 safe defaults a fresh agent gets)
+//   - []           → advertise zero tools (matches the deny-check
+//                    semantics in runTool — an agent with no whitelist
+//                    is allowed to use NOTHING, not everything)
+//   - ['bash',…]   → the explicit list, intersected with the registry
 export function listToolSchemas(names) {
   const out = [];
-  const wanted = Array.isArray(names) && names.length ? names : registry.listNames();
+  const wanted = names === undefined ? DEFAULT_TOOLS : (Array.isArray(names) ? names : []);
   for (const name of wanted) {
     const t = registry.lookup(name);
     if (!t) continue;

package/mas/tools/git.mjs

@@ -4,7 +4,24 @@
 import { spawnSync } from 'node:child_process';
 
 function git(cwd, args, opts = {}) {
-  const r = spawnSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+  // M11 / C12 — detect a missing git binary (Windows without
+  // Git-for-Windows, minimal Docker base images) up front and surface
+  // a clear remediation hint. The historical behaviour returned
+  // {ok:false} with a cryptic spawn error, which made the
+  // "lazyclaw doctor" path the only reliable signal. Now any agent
+  // touching this tool also gets a one-line diagnostic.
+  const exe = process.env.GIT_EXECUTABLE || 'git';
+  const r = spawnSync(exe, args, { cwd, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+  if (r.error && r.error.code === 'ENOENT') {
+    return {
+      ok: false,
+      stdout: '',
+      stderr: '',
+      exitCode: null,
+      error: 'GIT_NOT_INSTALLED',
+      hint: 'git binary not found on PATH. Install Git, or set GIT_EXECUTABLE. See `lazyclaw doctor`.',
+    };
+  }
   return { ok: r.status === 0, stdout: r.stdout, stderr: r.stderr, exitCode: r.status };
 }
 

package/mas/tools/recall.mjs

@@ -13,7 +13,11 @@
 //   filter:    optional object of UNINDEXED column equality filters
 //              (session_id, agent, outcome, trained_by, group_name, kind, since)
 
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
 import { openIndex, recall as indexRecall } from '../index_db.mjs';
+import { sameFamily } from '../confidence.mjs';
 
 export const NAME = 'recall';
 export const DESCRIPTION =
@@ -26,6 +30,11 @@ export const PARAMETERS = {
     k: { type: 'integer', minimum: 1, maximum: 50 },
     summarize: { type: 'boolean' },
     filter: { type: 'object', additionalProperties: true },
+    // M10 — cross-CLI provider-aware ranking. When the caller is a
+    // worker on a specific provider (e.g. anthropic/openai/gemini),
+    // skills whose frontmatter cross_cli_tested[] includes that
+    // provider's family are boosted ahead of untested duplicates.
+    workerProvider: { type: 'string', description: 'Boost skills whose cross_cli_tested[] includes this provider family (e.g. "anthropic").' },
   },
   required: ['query'],
 };
@@ -33,6 +42,39 @@ export const PARAMETERS = {
 const DEFAULT_SCOPES = ['sessions', 'skills', 'trajectories', 'memories'];
 const MAX_K = 50;
 
+function _defaultConfigDir() {
+  return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
+}
+
+// Minimal frontmatter parser — read just the cross_cli_tested provider
+// list for a skill by name. Returns [] when the file is missing or
+// parse fails (best-effort ranking helper, not a strict loader).
+function _readSkillCrossCli(skillName, configDir) {
+  if (!skillName) return [];
+  try {
+    const dir = configDir || _defaultConfigDir();
+    const filePath = path.join(dir, 'skills', `${skillName}.md`);
+    if (!fs.existsSync(filePath)) return [];
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const m = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (!m) return [];
+    const fm = m[1];
+    // Find cross_cli_tested block — YAML list form:
+    //   cross_cli_tested:
+    //     - provider: anthropic
+    //       …
+    const idx = fm.indexOf('cross_cli_tested:');
+    if (idx < 0) return [];
+    const tail = fm.slice(idx);
+    const providers = [];
+    for (const line of tail.split('\n')) {
+      const pm = line.match(/^\s*-?\s*provider:\s*['"]?([\w.-]+)['"]?\s*$/);
+      if (pm) providers.push(pm[1]);
+    }
+    return providers;
+  } catch { return []; }
+}
+
 let _stubRecall = null;
 export function __setRecall(fn) { _stubRecall = typeof fn === 'function' ? fn : null; }
 
@@ -83,12 +125,34 @@ export async function exec(args, { configDir } = {}) {
     });
   }
 
+  // M10 — cross-CLI provider-aware boost. For each `skills` hit, peek
+  // at the skill file's cross_cli_tested[] frontmatter. If any entry's
+  // provider is in the same family as workerProvider, promote the hit
+  // above untested siblings. We do this AFTER the FTS5 ranking so the
+  // base bm25 ordering still dominates — boosting is a tie-breaker /
+  // small re-rank, not a wholesale replacement.
+  const workerProvider = args.workerProvider ? String(args.workerProvider).trim() : '';
+  if (workerProvider) {
+    const boosted = hits.map((h, idx) => {
+      if (h.scope !== 'skills') return { h, boost: 0, idx };
+      const skillName = h.metadata?.skill_name || '';
+      const tested = _readSkillCrossCli(skillName, configDir);
+      const matched = tested.some((p) => sameFamily(p, workerProvider));
+      return { h, boost: matched ? 1 : 0, idx };
+    });
+    // Stable sort: matching skills first (boost desc), then preserve
+    // original FTS5 order via idx for ties.
+    boosted.sort((a, b) => (b.boost - a.boost) || (a.idx - b.idx));
+    hits = boosted.map((b) => ({ ...b.h, crossCliBoosted: b.boost > 0 }));
+  }
+
   return {
     ok: true,
     query,
     hits: hits.slice(0, k),
     summary: null,           // v5.0: raw hits only; v5.1 wires trainer.
     summarizedBy: null,
+    workerProvider: workerProvider || null,
     latencyMs: Date.now() - t0,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",
@@ -50,6 +50,7 @@
     "config_features.mjs",
     "workspace.mjs",
     "browse.mjs",
+    "chat_window.mjs",
     "sandbox.mjs",
     "sandbox/",
     "skills_install.mjs",

package/providers/anthropic.mjs

@@ -145,16 +145,32 @@ export const anthropicProvider = {
       stream: true,
       messages: apiMessages,
     };
-    const sys = opts.system || messages.find(m => m.role === 'system')?.content;
-    if (sys) {
-      // Prompt caching: when opts.cache is truthy, mark the system prompt
-      // as ephemeral-cacheable so repeated calls with the same system
-      // prefix only pay full input cost once. The Messages API expects
-      // an array of text blocks here, so we lift the string into one.
-      if (opts.cache) {
-        body.system = [{ type: 'text', text: String(sys), cache_control: { type: 'ephemeral' } }];
-      } else {
-        body.system = sys;
+    // Multi-block system support (Group B / C8). When the caller has
+    // separated the STATIC prefix (workspace + skills index + agent.role
+    // + USER.md) from the VOLATILE per-turn content, we ship two text
+    // blocks so the prompt cache hits the long static prefix while the
+    // volatile suffix changes per turn. Static block carries
+    // cache_control:ephemeral; volatile does not.
+    const hasMultiBlock = (opts.systemStatic && String(opts.systemStatic).trim()) || (opts.systemVolatile && String(opts.systemVolatile).trim());
+    if (hasMultiBlock) {
+      const blocks = [];
+      const staticText = opts.systemStatic ? String(opts.systemStatic) : '';
+      const volatileText = opts.systemVolatile ? String(opts.systemVolatile) : '';
+      if (staticText) blocks.push({ type: 'text', text: staticText, cache_control: { type: 'ephemeral' } });
+      if (volatileText) blocks.push({ type: 'text', text: volatileText });
+      body.system = blocks;
+    } else {
+      const sys = opts.system || messages.find(m => m.role === 'system')?.content;
+      if (sys) {
+        // Prompt caching: when opts.cache is truthy, mark the system prompt
+        // as ephemeral-cacheable so repeated calls with the same system
+        // prefix only pay full input cost once. The Messages API expects
+        // an array of text blocks here, so we lift the string into one.
+        if (opts.cache) {
+          body.system = [{ type: 'text', text: String(sys), cache_control: { type: 'ephemeral' } }];
+        } else {
+          body.system = sys;
+        }
       }
     }
     // Extended thinking. opts.thinking: { enabled?: boolean, budgetTokens?: number }.

package/providers/orchestrator.mjs

@@ -230,30 +230,85 @@ export function makeOrchestratorProvider(opts = {}) {
       yield `\n`;
 
       // ── Phase 2: EXECUTE ────────────────────────────────────────────
-      yield `### 2. Executing ${trimmed.length} subtask${trimmed.length === 1 ? '' : 's'}\n\n`;
+      // Concurrency policy (canonical spec §3 + C11 fix):
+      //   concurrency <= 1  → sequential, streams each worker's chunks
+      //                        inline as they arrive (live-feedback UX).
+      //   concurrency >= 2  → Promise.all-based parallel dispatch. Each
+      //                        worker buffers its own chunks; we flush
+      //                        them IN PLAN ORDER (subtask 1, then 2, …)
+      //                        so the user-facing output stays readable
+      //                        regardless of which worker finished first.
+      // The number is clamped to [1, workers.length] so a runaway value
+      // can't accidentally over-subscribe a single worker.
+      const rawConcurrency = Number.isFinite(o.concurrency) ? Math.floor(o.concurrency) : 1;
+      const concurrency = Math.max(1, Math.min(rawConcurrency, workers.length));
+      yield `### 2. Executing ${trimmed.length} subtask${trimmed.length === 1 ? '' : 's'}${concurrency > 1 ? ` (concurrency=${concurrency}, parallel)` : ''}\n\n`;
       const results = [];
-      for (let i = 0; i < trimmed.length; i++) {
-        const sub = trimmed[i];
-        const worker = workers[i % workers.length];
-        yield `**Subtask ${sub.id}** \`${worker.name}${worker.model ? ':' + worker.model : ''}\` — ${sub.task}\n\n`;
-        let res = '';
-        try {
-          for await (const chunk of worker.prov.sendMessage([{ role: 'user', content: sub.task }], {
-            apiKey: keyResolver(cfg, worker.name),
-            model: worker.model || undefined,
-            signal: callerOpts.signal,
-          })) {
-            const s = String(chunk);
-            res += s;
-            yield s;
+      if (concurrency <= 1) {
+        // Sequential streaming path — historical default, preserved.
+        for (let i = 0; i < trimmed.length; i++) {
+          const sub = trimmed[i];
+          const worker = workers[i % workers.length];
+          yield `**Subtask ${sub.id}** \`${worker.name}${worker.model ? ':' + worker.model : ''}\` — ${sub.task}\n\n`;
+          let res = '';
+          try {
+            for await (const chunk of worker.prov.sendMessage([{ role: 'user', content: sub.task }], {
+              apiKey: keyResolver(cfg, worker.name),
+              model: worker.model || undefined,
+              signal: callerOpts.signal,
+            })) {
+              const s = String(chunk);
+              res += s;
+              yield s;
+            }
+            results.push({ ...sub, worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`, result: res, error: null });
+          } catch (e) {
+            const msg = e?.message || String(e);
+            yield `\n⚠ worker error: ${msg}\n`;
+            results.push({ ...sub, worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`, result: '', error: msg });
           }
-          results.push({ ...sub, worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`, result: res, error: null });
-        } catch (e) {
-          const msg = e?.message || String(e);
-          yield `\n⚠ worker error: ${msg}\n`;
-          results.push({ ...sub, worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`, result: '', error: msg });
+          yield `\n\n---\n\n`;
+        }
+      } else {
+        // Parallel dispatch — buffer chunks per subtask, then flush in
+        // plan order. We start every subtask up-front (Promise.all over
+        // the slice) so wall-clock equals max-per-subtask, not sum.
+        // A single subtask failure does NOT block the others — the
+        // _runSubtask wrapper catches and records the error inline.
+        async function _runSubtask(sub, worker) {
+          const chunks = [];
+          let error = null;
+          try {
+            for await (const chunk of worker.prov.sendMessage([{ role: 'user', content: sub.task }], {
+              apiKey: keyResolver(cfg, worker.name),
+              model: worker.model || undefined,
+              signal: callerOpts.signal,
+            })) {
+              chunks.push(String(chunk));
+            }
+          } catch (e) {
+            error = e?.message || String(e);
+          }
+          return { sub, worker, chunks, error };
+        }
+        const settled = await Promise.all(
+          trimmed.map((sub, i) => _runSubtask(sub, workers[i % workers.length])),
+        );
+        // Flush in plan order so the synthesis prompt + user view see
+        // subtask 1, then 2, etc.
+        for (const { sub, worker, chunks, error } of settled) {
+          yield `**Subtask ${sub.id}** \`${worker.name}${worker.model ? ':' + worker.model : ''}\` — ${sub.task}\n\n`;
+          const text = chunks.join('');
+          if (text) yield text;
+          if (error) yield `\n⚠ worker error: ${error}\n`;
+          results.push({
+            ...sub,
+            worker: `${worker.name}${worker.model ? ':' + worker.model : ''}`,
+            result: text,
+            error,
+          });
+          yield `\n\n---\n\n`;
         }
-        yield `\n\n---\n\n`;
       }
 
       // ── Phase 3: SYNTHESIS ──────────────────────────────────────────
@@ -276,6 +331,29 @@ export function makeOrchestratorProvider(opts = {}) {
       } catch (e) {
         yield `⚠ synthesis error: ${e?.message || String(e)}. Worker outputs above are the final material — please review them directly.\n`;
       }
+
+      // v5 (canonical decision C2) — fire the canonical post-task
+      // learning hook in a microtask so the user's stream is not
+      // blocked. Failures are silent here; mas/learning.mjs already
+      // swallows each sub-routine's errors and the audit log captures
+      // observability on its own. We import lazily so the orchestrator
+      // module stays cheap to load when learning is unused.
+      queueMicrotask(() => {
+        import('../mas/orchestra.mjs')
+          .then(o => o.firePostTask({
+            cfg,
+            agent: { name: 'orchestrator', provider: planner.name, model: planner.model, role: SYNTHESIS_SYSTEM },
+            task: {
+              id: `orch-${Date.now()}`,
+              title: userText.slice(0, 80),
+              turns: [
+                { agent: 'user', text: userText },
+                ...results.map(r => ({ agent: r.worker, text: r.result || r.error || '' })),
+              ],
+            },
+          }))
+          .catch(() => { /* swallow — learning is best-effort */ });
+      });
     },
   };
 }

package/providers/registry.mjs

@@ -524,6 +524,12 @@ export function parseSlashProviderModel(s) {
 const RESERVED_PROVIDER_NAMES = new Set([
   'mock', 'claude-cli', 'anthropic', 'openai', 'gemini', 'ollama',
   'orchestrator',
+  // M12 — `test` is reserved because the daemon intercepts
+  // GET /providers/test and POST /providers/test for batch provider
+  // probing. Allowing a custom provider literally named "test" would
+  // shadow those routes (GET/DELETE for the literal name become
+  // unreachable). Reject up-front in the POST validator.
+  'test',
   '__add_custom__', '__custom_model__', '__fetch_models__',
 ]);