@jaggerxtrm/specialists 3.2.1 → 3.3.0

package/dist/index.js

@@ -17423,7 +17423,7 @@ async function parseSpecialist(yamlContent) {
   const raw = $parse(yamlContent);
   return SpecialistSchema.parseAsync(raw);
 }
-var KebabCase, Semver, MetadataSchema, ExecutionSchema, PromptSchema2, SkillsSchema, CapabilitiesSchema, CommunicationSchema, ValidationSchema, SpecialistSchema;
+var KebabCase, Semver, MetadataSchema, ExecutionSchema, PromptSchema2, ScriptEntrySchema, SkillsSchema, CapabilitiesSchema, CommunicationSchema, ValidationSchema, SpecialistSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_dist();
@@ -17447,6 +17447,7 @@ var init_schema = __esm(() => {
     stall_timeout_ms: numberType().optional(),
     response_format: enumType(["text", "json", "markdown"]).default("text"),
     permission_required: enumType(["READ_ONLY", "LOW", "MEDIUM", "HIGH"]).default("READ_ONLY"),
+    thinking_level: enumType(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
     preferred_profile: stringType().optional(),
     approval_mode: stringType().optional()
   });
@@ -17458,27 +17459,26 @@ var init_schema = __esm(() => {
     examples: arrayType(unknownType()).optional(),
     skill_inherit: stringType().optional()
   });
+  ScriptEntrySchema = objectType({
+    run: stringType().optional(),
+    path: stringType().optional(),
+    phase: enumType(["pre", "post"]),
+    inject_output: booleanType().default(false)
+  }).transform((s) => ({
+    run: s.run ?? s.path ?? "",
+    phase: s.phase,
+    inject_output: s.inject_output
+  }));
   SkillsSchema = objectType({
-    scripts: arrayType(objectType({
-      path: stringType(),
-      phase: enumType(["pre", "post"]),
-      inject_output: booleanType().default(false)
-    })).optional(),
-    references: arrayType(unknownType()).optional(),
-    tools: arrayType(stringType()).optional(),
-    paths: arrayType(stringType()).optional()
+    paths: arrayType(stringType()).optional(),
+    scripts: arrayType(ScriptEntrySchema).optional()
   }).optional();
   CapabilitiesSchema = objectType({
-    file_scope: arrayType(stringType()).optional(),
-    blocked_tools: arrayType(stringType()).optional(),
-    can_spawn: booleanType().optional(),
-    tools: arrayType(objectType({ name: stringType(), purpose: stringType() })).optional(),
-    diagnostic_scripts: arrayType(stringType()).optional()
+    required_tools: arrayType(stringType()).optional(),
+    external_commands: arrayType(stringType()).optional()
   }).optional();
   CommunicationSchema = objectType({
-    publishes: arrayType(stringType()).optional(),
-    subscribes: arrayType(stringType()).optional(),
-    output_to: stringType().optional()
+    next_specialists: unionType([stringType(), arrayType(stringType())]).optional()
   }).optional();
   ValidationSchema = objectType({
     files_to_watch: arrayType(stringType()).optional(),
@@ -17494,6 +17494,7 @@ var init_schema = __esm(() => {
       capabilities: CapabilitiesSchema,
       communication: CommunicationSchema,
       validation: ValidationSchema,
+      output_file: stringType().optional(),
       beads_integration: enumType(["auto", "always", "never"]).default("auto"),
       heartbeat: unknownType().optional()
     })
@@ -17503,7 +17504,6 @@ var init_schema = __esm(() => {
 // src/specialist/loader.ts
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { homedir } from "node:os";
 import { existsSync } from "node:fs";
 async function checkStaleness(summary) {
   if (!summary.filestoWatch?.length || !summary.updated)
@@ -17527,17 +17527,13 @@ async function checkStaleness(summary) {
 class SpecialistLoader {
   cache = new Map;
   projectDir;
-  userDir;
   constructor(options = {}) {
     this.projectDir = options.projectDir ?? process.cwd();
-    this.userDir = options.userDir ?? join(homedir(), ".agents", "specialists");
   }
   getScanDirs() {
     const dirs = [
-      { path: join(this.projectDir, "specialists"), scope: "project" },
-      { path: join(this.projectDir, ".claude", "specialists"), scope: "project" },
-      { path: join(this.projectDir, ".agent-forge", "specialists"), scope: "project" },
-      { path: this.userDir, scope: "user" }
+      { path: join(this.projectDir, ".specialists", "user", "specialists"), scope: "user" },
+      { path: join(this.projectDir, ".specialists", "default", "specialists"), scope: "default" }
     ];
     return dirs.filter((d) => existsSync(d.path));
   }
@@ -17569,7 +17565,11 @@ class SpecialistLoader {
             filestoWatch: spec.specialist.validation?.files_to_watch,
             staleThresholdDays: spec.specialist.validation?.stale_threshold_days
           });
-        } catch {}
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : String(e);
+          process.stderr.write(`[specialists] skipping ${filePath}: ${reason}
+`);
+        }
       }
     }
     return results;
@@ -17584,11 +17584,10 @@ class SpecialistLoader {
         const spec = await parseSpecialist(content);
         const rawPaths = spec.specialist.skills?.paths;
         if (rawPaths?.length) {
-          const home = homedir();
           const fileDir = dir.path;
           const resolved = rawPaths.map((p) => {
             if (p.startsWith("~/"))
-              return join(home, p.slice(2));
+              return join(process.env.HOME || "", p.slice(2));
             if (p.startsWith("./"))
               return join(fileDir, p.slice(2));
             return p;
@@ -17651,16 +17650,16 @@ var init_backendMap = __esm(() => {
 // src/pi/session.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { homedir } from "node:os";
 import { join as join2 } from "node:path";
 function mapPermissionToTools(level) {
   switch (level?.toUpperCase()) {
     case "READ_ONLY":
-      return "read,bash,grep,find,ls";
-    case "BASH_ONLY":
-      return "bash";
+      return "read,grep,find,ls";
     case "LOW":
+      return "read,bash,grep,find,ls";
     case "MEDIUM":
+      return "read,bash,edit,grep,find,ls";
     case "HIGH":
       return "read,bash,edit,write,grep,find,ls";
     default:
@@ -17708,7 +17707,13 @@ class PiAgentSession {
     const toolsFlag = mapPermissionToTools(this.options.permissionLevel);
     if (toolsFlag)
       args.push("--tools", toolsFlag);
-    const piExtDir = join2(homedir2(), ".pi", "agent", "extensions");
+    if (this.options.thinkingLevel) {
+      args.push("--thinking", this.options.thinkingLevel);
+    }
+    for (const skillPath of this.options.skillPaths ?? []) {
+      args.push("--skill", skillPath);
+    }
+    const piExtDir = join2(homedir(), ".pi", "agent", "extensions");
     const permLevel = (this.options.permissionLevel ?? "").toUpperCase();
     if (permLevel !== "READ_ONLY") {
       const qgPath = join2(piExtDir, "quality-gates");
@@ -17902,6 +17907,30 @@ class PiAgentSession {
     this.proc = undefined;
     this._doneReject?.(new SessionKilledError);
   }
+  async steer(message) {
+    if (this._killed || !this.proc?.stdin) {
+      throw new Error("Session is not active");
+    }
+    const cmd = JSON.stringify({ type: "steer", message }) + `
+`;
+    await new Promise((resolve, reject) => {
+      this.proc.stdin.write(cmd, (err) => err ? reject(err) : resolve());
+    });
+  }
+  async resume(task, timeout) {
+    if (this._killed || !this.proc?.stdin) {
+      throw new Error("Session is not active");
+    }
+    this._agentEndReceived = false;
+    const donePromise = new Promise((resolve, reject) => {
+      this._doneResolve = resolve;
+      this._doneReject = reject;
+    });
+    donePromise.catch(() => {});
+    this._donePromise = donePromise;
+    await this.prompt(task);
+    await this.waitForDone(timeout);
+  }
 }
 var SessionKilledError;
 var init_session = __esm(() => {
@@ -18055,14 +18084,16 @@ var init_beads = () => {};
 // src/specialist/runner.ts
 import { createHash } from "node:crypto";
 import { writeFile } from "node:fs/promises";
-import { execSync } from "node:child_process";
-import { basename } from "node:path";
-function runScript(scriptPath) {
+import { execSync, spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function runScript(run) {
   try {
-    const output = execSync(scriptPath, { encoding: "utf8", timeout: 30000 });
-    return { name: basename(scriptPath), output, exitCode: 0 };
+    const output = execSync(run, { encoding: "utf8", timeout: 30000 });
+    return { name: basename(run.split(" ")[0]), output, exitCode: 0 };
   } catch (e) {
-    return { name: basename(scriptPath), output: e.stdout ?? e.message ?? "", exitCode: e.status ?? 1 };
+    return { name: basename(run.split(" ")[0]), output: e.stdout ?? e.message ?? "", exitCode: e.status ?? 1 };
   }
 }
 function formatScriptOutput(results) {
@@ -18080,6 +18111,77 @@ ${r.output.trim()}
 ${blocks}
 </pre_flight_context>`;
 }
+function resolvePath(p) {
+  return p.startsWith("~/") ? resolve(homedir2(), p.slice(2)) : resolve(p);
+}
+function commandExists(cmd) {
+  const result = spawnSync2("which", [cmd], { stdio: "ignore" });
+  return result.status === 0;
+}
+function validateShebang(filePath, errors5) {
+  try {
+    const head = readFileSync(filePath, "utf-8").slice(0, 120);
+    if (!head.startsWith("#!"))
+      return;
+    const shebang = head.split(`
+`)[0].toLowerCase();
+    const typos = [
+      [/pytho[^n]|pyton|pyhon/, "python"],
+      [/nod[^e]b/, "node"],
+      [/bsh$|bas$/, "bash"],
+      [/rub[^y]/, "ruby"]
+    ];
+    for (const [pattern, correct] of typos) {
+      if (pattern.test(shebang)) {
+        errors5.push(`  ✗ ${filePath}: shebang looks wrong — did you mean '${correct}'? (got: ${shebang})`);
+      }
+    }
+  } catch {}
+}
+function validateBeforeRun(spec) {
+  const errors5 = [];
+  const warnings = [];
+  for (const p of spec.specialist.skills?.paths ?? []) {
+    const abs = resolvePath(p);
+    if (!existsSync3(abs))
+      warnings.push(`  ⚠ skills.paths: file not found: ${p}`);
+  }
+  for (const script of spec.specialist.skills?.scripts ?? []) {
+    const { run } = script;
+    if (!run)
+      continue;
+    const isFilePath = run.startsWith("./") || run.startsWith("../") || run.startsWith("/") || run.startsWith("~/");
+    if (isFilePath) {
+      const abs = resolvePath(run);
+      if (!existsSync3(abs)) {
+        errors5.push(`  ✗ skills.scripts: script not found: ${run}`);
+      } else {
+        validateShebang(abs, errors5);
+      }
+    } else {
+      const binary = run.split(" ")[0];
+      if (!commandExists(binary)) {
+        errors5.push(`  ✗ skills.scripts: command not found on PATH: ${binary}`);
+      }
+    }
+  }
+  for (const cmd of spec.specialist.capabilities?.external_commands ?? []) {
+    if (!commandExists(cmd)) {
+      errors5.push(`  ✗ capabilities.external_commands: not found on PATH: ${cmd}`);
+    }
+  }
+  if (warnings.length > 0) {
+    process.stderr.write(`[specialists] pre-run warnings:
+${warnings.join(`
+`)}
+`);
+  }
+  if (errors5.length > 0) {
+    throw new Error(`Specialist pre-run validation failed:
+${errors5.join(`
+`)}`);
+  }
+}
 
 class SpecialistRunner {
   deps;
@@ -18088,12 +18190,12 @@ class SpecialistRunner {
     this.deps = deps;
     this.sessionFactory = deps.sessionFactory ?? PiAgentSession.create.bind(PiAgentSession);
   }
-  async run(options, onProgress, onEvent, onMeta, onKillRegistered, onBeadCreated) {
+  async run(options, onProgress, onEvent, onMeta, onKillRegistered, onBeadCreated, onSteerRegistered, onResumeReady) {
     const { loader, hooks, circuitBreaker, beadsClient } = this.deps;
     const invocationId = crypto.randomUUID();
     const start = Date.now();
     const spec = await loader.get(options.name);
-    const { metadata, execution, prompt, communication } = spec.specialist;
+    const { metadata, execution, prompt, output_file } = spec.specialist;
     const primaryModel = options.backendOverride ?? execution.model;
     const model = circuitBreaker.isAvailable(primaryModel) ? primaryModel : execution.fallback_model ?? primaryModel;
     const fallbackUsed = model !== primaryModel;
@@ -18104,8 +18206,9 @@ class SpecialistRunner {
       circuit_breaker_state: circuitBreaker.getState(model),
       scope: "project"
     });
+    validateBeforeRun(spec);
     const preScripts = spec.specialist.skills?.scripts?.filter((s) => s.phase === "pre") ?? [];
-    const preResults = preScripts.map((s) => runScript(s.path)).filter((_, i) => preScripts[i].inject_output);
+    const preResults = preScripts.map((s) => runScript(s.run)).filter((_, i) => preScripts[i].inject_output);
     const preScriptOutput = formatScriptOutput(preResults);
     const beadVariables = options.inputBeadId ? { bead_context: options.prompt, bead_id: options.inputBeadId } : {};
     const variables = {
@@ -18123,40 +18226,32 @@ class SpecialistRunner {
       estimated_tokens: Math.ceil(renderedTask.length / 4),
       system_prompt_present: !!prompt.system
     });
-    const { readFile: readFile2 } = await import("node:fs/promises");
-    let agentsMd = prompt.system ?? "";
-    if (prompt.skill_inherit) {
-      const skillContent = await readFile2(prompt.skill_inherit, "utf-8").catch(() => "");
-      if (skillContent)
-        agentsMd += `
-
----
-# Service Knowledge
-
-${skillContent}`;
-    }
-    const skillPaths = spec.specialist.skills?.paths ?? [];
-    for (const skillPath of skillPaths) {
-      const skillContent = await readFile2(skillPath, "utf-8").catch(() => "");
-      if (skillContent)
-        agentsMd += `
-
----
-# Skill: ${skillPath}
-
-${skillContent}`;
-    }
-    if (spec.specialist.capabilities?.diagnostic_scripts?.length) {
-      agentsMd += `
-
----
-# Diagnostic Scripts
-You have access via Bash:
-`;
-      for (const s of spec.specialist.capabilities.diagnostic_scripts) {
-        agentsMd += `- \`${s}\`
-`;
+    const agentsMd = prompt.system ?? "";
+    const skillPaths = [];
+    if (prompt.skill_inherit)
+      skillPaths.push(prompt.skill_inherit);
+    skillPaths.push(...spec.specialist.skills?.paths ?? []);
+    if (skillPaths.length > 0 || preScripts.length > 0) {
+      const line = "━".repeat(56);
+      onProgress?.(`
+${line}
+◆ AUTO INJECTED
+`);
+      if (skillPaths.length > 0) {
+        onProgress?.(`  skills (--skill):
+${skillPaths.map((p) => `    • ${p}`).join(`
+`)}
+`);
       }
+      if (preScripts.length > 0) {
+        onProgress?.(`  pre scripts/commands:
+${preScripts.map((s) => `    • ${s.run}${s.inject_output ? " → $pre_script_output" : ""}`).join(`
+`)}
+`);
+      }
+      onProgress?.(`${line}
+
+`);
     }
     const permissionLevel = options.autonomyLevel ?? execution.permission_required;
     await hooks.emit("pre_execute", invocationId, metadata.name, metadata.version, {
@@ -18180,10 +18275,13 @@ You have access via Bash:
     let output;
     let sessionBackend = model;
     let session;
+    let keepAliveActive = false;
     try {
       session = await this.sessionFactory({
         model,
         systemPrompt: agentsMd || undefined,
+        skillPaths: skillPaths.length > 0 ? skillPaths : undefined,
+        thinkingLevel: execution.thinking_level,
         permissionLevel,
         cwd: process.cwd(),
         onToken: (delta) => onProgress?.(delta),
@@ -18197,15 +18295,29 @@ You have access via Bash:
       });
       await session.start();
       onKillRegistered?.(session.kill.bind(session));
+      onSteerRegistered?.((msg) => session.steer(msg));
       await session.prompt(renderedTask);
       await session.waitForDone(execution.timeout_ms);
       sessionBackend = session.meta.backend;
       output = await session.getLastOutput();
       sessionBackend = session.meta.backend;
-      await session.close();
+      if (options.keepAlive && onResumeReady) {
+        keepAliveActive = true;
+        const resumeFn = async (msg) => {
+          await session.resume(msg, execution.timeout_ms);
+          return session.getLastOutput();
+        };
+        const closeFn = async () => {
+          keepAliveActive = false;
+          await session.close();
+        };
+        onResumeReady(resumeFn, closeFn);
+      } else {
+        await session.close();
+      }
       const postScripts = spec.specialist.skills?.scripts?.filter((s) => s.phase === "post") ?? [];
       for (const script of postScripts)
-        runScript(script.path);
+        runScript(script.run);
       circuitBreaker.recordSuccess(model);
     } catch (err) {
       const isCancelled = err instanceof SessionKilledError;
@@ -18226,11 +18338,13 @@ You have access via Bash:
       });
       throw err;
     } finally {
-      session?.kill();
+      if (!keepAliveActive) {
+        session?.kill();
+      }
     }
     const durationMs = Date.now() - start;
-    if (communication?.output_to) {
-      await writeFile(communication.output_to, output, "utf-8").catch(() => {});
+    if (output_file) {
+      await writeFile(output_file, output, "utf-8").catch(() => {});
     }
     await hooks.emit("post_execute", invocationId, metadata.name, metadata.version, {
       status: "COMPLETE",
@@ -18264,7 +18378,7 @@ You have access via Bash:
       model: "?",
       specialistVersion
     });
-    this.run(options, (text) => registry2.appendOutput(jobId, text), (eventType) => registry2.setCurrentEvent(jobId, eventType), (meta) => registry2.setMeta(jobId, meta), (killFn) => registry2.setKillFn(jobId, killFn), (beadId) => registry2.setBeadId(jobId, beadId)).then((result) => registry2.complete(jobId, result)).catch((err) => registry2.fail(jobId, err));
+    this.run(options, (text) => registry2.appendOutput(jobId, text), (eventType) => registry2.setCurrentEvent(jobId, eventType), (meta) => registry2.setMeta(jobId, meta), (killFn) => registry2.setKillFn(jobId, killFn), (beadId) => registry2.setBeadId(jobId, beadId), (steerFn) => registry2.setSteerFn(jobId, steerFn), (resumeFn, closeFn) => registry2.setResumeFn(jobId, resumeFn, closeFn)).then((result) => registry2.complete(jobId, result)).catch((err) => registry2.fail(jobId, err));
     return jobId;
   }
 }
@@ -18344,656 +18458,198 @@ class CircuitBreaker {
   }
 }
 
-// src/cli/install.ts
-var exports_install = {};
-__export(exports_install, {
-  run: () => run
-});
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { dirname as dirname2, join as join5 } from "node:path";
-async function run() {
-  const installerPath = join5(dirname2(fileURLToPath(import.meta.url)), "..", "bin", "install.js");
-  execFileSync(process.execPath, [installerPath], { stdio: "inherit" });
+// src/specialist/timeline-events.ts
+function mapCallbackEventToTimelineEvent(callbackEvent, context) {
+  const t = Date.now();
+  switch (callbackEvent) {
+    case "thinking":
+      return { t, type: TIMELINE_EVENT_TYPES.THINKING };
+    case "toolcall":
+      return {
+        t,
+        type: TIMELINE_EVENT_TYPES.TOOL,
+        tool: context.tool ?? "unknown",
+        phase: "start",
+        tool_call_id: context.toolCallId
+      };
+    case "tool_execution_end":
+      return {
+        t,
+        type: TIMELINE_EVENT_TYPES.TOOL,
+        tool: context.tool ?? "unknown",
+        phase: "end",
+        tool_call_id: context.toolCallId,
+        is_error: context.isError
+      };
+    case "text":
+      return { t, type: TIMELINE_EVENT_TYPES.TEXT };
+    case "agent_end":
+    case "message_done":
+    case "done":
+      return null;
+    default:
+      return null;
+  }
 }
-var init_install = () => {};
-
-// src/cli/version.ts
-var exports_version = {};
-__export(exports_version, {
-  run: () => run2
-});
-import { createRequire as createRequire2 } from "node:module";
-async function run2() {
-  const req = createRequire2(import.meta.url);
-  const pkg = req("../package.json");
-  console.log(`${pkg.name} v${pkg.version}`);
+function createRunStartEvent(specialist, beadId) {
+  return {
+    t: Date.now(),
+    type: TIMELINE_EVENT_TYPES.RUN_START,
+    specialist,
+    bead_id: beadId
+  };
 }
-var init_version = () => {};
-
-// src/cli/list.ts
-var exports_list = {};
-__export(exports_list, {
-  run: () => run3,
-  parseArgs: () => parseArgs,
-  ArgParseError: () => ArgParseError
-});
-function parseArgs(argv) {
-  const result = {};
-  for (let i = 0;i < argv.length; i++) {
-    const token = argv[i];
-    if (token === "--category") {
-      const value = argv[++i];
-      if (!value || value.startsWith("--")) {
-        throw new ArgParseError("--category requires a value");
-      }
-      result.category = value;
-      continue;
-    }
-    if (token === "--scope") {
-      const value = argv[++i];
-      if (value !== "project" && value !== "user") {
-        throw new ArgParseError(`--scope must be "project" or "user", got: "${value ?? ""}"`);
-      }
-      result.scope = value;
-      continue;
-    }
-    if (token === "--json") {
-      result.json = true;
-      continue;
-    }
-  }
-  return result;
+function createMetaEvent(model, backend) {
+  return {
+    t: Date.now(),
+    type: TIMELINE_EVENT_TYPES.META,
+    model,
+    backend
+  };
 }
-async function run3() {
-  let args;
+function createRunCompleteEvent(status, elapsed_s, options) {
+  return {
+    t: Date.now(),
+    type: TIMELINE_EVENT_TYPES.RUN_COMPLETE,
+    status,
+    elapsed_s,
+    ...options
+  };
+}
+function parseTimelineEvent(line) {
   try {
-    args = parseArgs(process.argv.slice(3));
-  } catch (err) {
-    if (err instanceof ArgParseError) {
-      console.error(`Error: ${err.message}`);
-      process.exit(1);
+    const parsed = JSON.parse(line);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    if (typeof parsed.t !== "number")
+      return null;
+    if (typeof parsed.type !== "string")
+      return null;
+    if (parsed.type === TIMELINE_EVENT_TYPES.DONE) {
+      return {
+        t: parsed.t,
+        type: TIMELINE_EVENT_TYPES.DONE,
+        elapsed_s: typeof parsed.elapsed_s === "number" ? parsed.elapsed_s : undefined
+      };
     }
-    throw err;
-  }
-  const loader = new SpecialistLoader;
-  let specialists = await loader.list(args.category);
-  if (args.scope) {
-    specialists = specialists.filter((s) => s.scope === args.scope);
-  }
-  if (args.json) {
-    console.log(JSON.stringify(specialists, null, 2));
-    return;
-  }
-  if (specialists.length === 0) {
-    console.log("No specialists found.");
-    return;
-  }
-  const nameWidth = Math.max(...specialists.map((s) => s.name.length), 4);
-  console.log(`
-${bold(`Specialists (${specialists.length})`)}
-`);
-  for (const s of specialists) {
-    const name = cyan(s.name.padEnd(nameWidth));
-    const scopeTag = yellow(`[${s.scope}]`);
-    const model = dim(s.model);
-    const desc = s.description.length > 80 ? s.description.slice(0, 79) + "…" : s.description;
-    console.log(`  ${name}  ${scopeTag}  ${model}`);
-    console.log(`  ${" ".repeat(nameWidth)}  ${dim(desc)}`);
-    console.log();
-  }
-}
-var dim = (s) => `\x1B[2m${s}\x1B[0m`, bold = (s) => `\x1B[1m${s}\x1B[0m`, cyan = (s) => `\x1B[36m${s}\x1B[0m`, yellow = (s) => `\x1B[33m${s}\x1B[0m`, ArgParseError;
-var init_list = __esm(() => {
-  init_loader();
-  ArgParseError = class ArgParseError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "ArgParseError";
+    if (parsed.type === TIMELINE_EVENT_TYPES.AGENT_END) {
+      return {
+        t: parsed.t,
+        type: TIMELINE_EVENT_TYPES.AGENT_END,
+        elapsed_s: typeof parsed.elapsed_s === "number" ? parsed.elapsed_s : undefined
+      };
     }
-  };
-});
-
-// src/cli/models.ts
-var exports_models = {};
-__export(exports_models, {
-  run: () => run4
-});
-import { spawnSync as spawnSync3 } from "node:child_process";
-function parsePiModels() {
-  const r = spawnSync3("pi", ["--list-models"], {
-    encoding: "utf8",
-    stdio: "pipe",
-    timeout: 8000
-  });
-  if (r.status !== 0 || r.error)
+    const knownTypes = Object.values(TIMELINE_EVENT_TYPES).filter((type) => type !== TIMELINE_EVENT_TYPES.DONE && type !== TIMELINE_EVENT_TYPES.AGENT_END);
+    if (!knownTypes.includes(parsed.type))
+      return null;
+    return parsed;
+  } catch {
     return null;
-  return r.stdout.split(`
-`).slice(1).map((line) => line.trim()).filter(Boolean).map((line) => {
-    const cols = line.split(/\s+/);
-    return {
-      provider: cols[0] ?? "",
-      model: cols[1] ?? "",
-      context: cols[2] ?? "",
-      maxOut: cols[3] ?? "",
-      thinking: cols[4] === "yes",
-      images: cols[5] === "yes"
-    };
-  }).filter((m) => m.provider && m.model);
-}
-function parseArgs2(argv) {
-  const out = {};
-  for (let i = 0;i < argv.length; i++) {
-    if (argv[i] === "--provider" && argv[i + 1]) {
-      out.provider = argv[++i];
-      continue;
-    }
-    if (argv[i] === "--used") {
-      out.used = true;
-      continue;
-    }
   }
-  return out;
 }
-async function run4() {
-  const args = parseArgs2(process.argv.slice(3));
-  const loader = new SpecialistLoader;
-  const specialists = await loader.list();
-  const usedBy = new Map;
-  for (const s of specialists) {
-    const key = s.model;
-    if (!usedBy.has(key))
-      usedBy.set(key, []);
-    usedBy.get(key).push(s.name);
-  }
-  const allModels = parsePiModels();
-  if (!allModels) {
-    console.error("pi not found or failed — install and configure pi first");
-    process.exit(1);
-  }
-  let models = allModels;
-  if (args.provider) {
-    models = models.filter((m) => m.provider.toLowerCase().includes(args.provider.toLowerCase()));
-  }
-  if (args.used) {
-    models = models.filter((m) => usedBy.has(`${m.provider}/${m.model}`));
-  }
-  if (models.length === 0) {
-    console.log("No models match.");
-    return;
-  }
-  const byProvider = new Map;
-  for (const m of models) {
-    if (!byProvider.has(m.provider))
-      byProvider.set(m.provider, []);
-    byProvider.get(m.provider).push(m);
-  }
-  const total = models.length;
-  console.log(`
-${bold2(`Models on pi`)}  ${dim2(`(${total} total)`)}
-`);
-  for (const [provider, pModels] of byProvider) {
-    console.log(`  ${cyan2(provider)}  ${dim2(`${pModels.length} model${pModels.length !== 1 ? "s" : ""}`)}`);
-    const modelWidth = Math.max(...pModels.map((m) => m.model.length));
-    for (const m of pModels) {
-      const key = `${m.provider}/${m.model}`;
-      const inUse = usedBy.get(key);
-      const flags = [
-        m.thinking ? green("thinking") : dim2("·"),
-        m.images ? dim2("images") : ""
-      ].filter(Boolean).join("  ");
-      const ctx = dim2(`ctx ${m.context}`);
-      const usedLabel = inUse ? `  ${yellow2("←")} ${dim2(inUse.join(", "))}` : "";
-      console.log(`    ${m.model.padEnd(modelWidth)}  ${ctx.padEnd(18)}  ${flags}${usedLabel}`);
-    }
-    console.log();
-  }
-  if (!args.used) {
-    console.log(dim2(`  --provider <name>  filter by provider`));
-    console.log(dim2(`  --used             only show models used by your specialists`));
-    console.log();
-  }
+function isRunCompleteEvent(event) {
+  return event.type === TIMELINE_EVENT_TYPES.RUN_COMPLETE;
 }
-var bold2 = (s) => `\x1B[1m${s}\x1B[0m`, dim2 = (s) => `\x1B[2m${s}\x1B[0m`, cyan2 = (s) => `\x1B[36m${s}\x1B[0m`, yellow2 = (s) => `\x1B[33m${s}\x1B[0m`, green = (s) => `\x1B[32m${s}\x1B[0m`;
-var init_models = __esm(() => {
-  init_loader();
+function compareTimelineEvents(a, b) {
+  return a.t - b.t;
+}
+var TIMELINE_EVENT_TYPES;
+var init_timeline_events = __esm(() => {
+  TIMELINE_EVENT_TYPES = {
+    RUN_START: "run_start",
+    META: "meta",
+    THINKING: "thinking",
+    TOOL: "tool",
+    TEXT: "text",
+    RUN_COMPLETE: "run_complete",
+    DONE: "done",
+    AGENT_END: "agent_end"
+  };
 });
 
-// src/cli/init.ts
-var exports_init = {};
-__export(exports_init, {
-  run: () => run5
-});
-import { existsSync as existsSync4, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join as join6 } from "node:path";
-function ok(msg) {
-  console.log(`  ${green2("✓")} ${msg}`);
-}
-function skip(msg) {
-  console.log(`  ${yellow3("○")} ${msg}`);
-}
-function loadJson(path, fallback) {
-  if (!existsSync4(path))
-    return structuredClone(fallback);
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return structuredClone(fallback);
-  }
-}
-function saveJson(path, value) {
-  writeFileSync(path, JSON.stringify(value, null, 2) + `
-`, "utf-8");
-}
-function ensureProjectMcp(cwd) {
-  const mcpPath = join6(cwd, MCP_FILE);
-  const mcp = loadJson(mcpPath, { mcpServers: {} });
-  mcp.mcpServers ??= {};
-  const existing = mcp.mcpServers[MCP_SERVER_NAME];
-  if (existing && existing.command === MCP_SERVER_CONFIG.command && Array.isArray(existing.args) && existing.args.length === MCP_SERVER_CONFIG.args.length) {
-    skip(".mcp.json already registers specialists");
+// src/specialist/supervisor.ts
+import {
+  closeSync,
+  existsSync as existsSync4,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+  writeSync
+} from "node:fs";
+import { join as join3 } from "node:path";
+import { createInterface } from "node:readline";
+import { createReadStream } from "node:fs";
+import { spawnSync as spawnSync3, execFileSync } from "node:child_process";
+function getCurrentGitSha() {
+  const result = spawnSync3("git", ["rev-parse", "HEAD"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0)
     return;
-  }
-  mcp.mcpServers[MCP_SERVER_NAME] = MCP_SERVER_CONFIG;
-  saveJson(mcpPath, mcp);
-  ok("registered specialists in project .mcp.json");
+  const sha = result.stdout?.trim();
+  return sha || undefined;
 }
-async function run5() {
-  const cwd = process.cwd();
-  console.log(`
-${bold3("specialists init")}
+function formatBeadNotes(result) {
+  const metadata = [
+    `prompt_hash=${result.promptHash}`,
+    `git_sha=${getCurrentGitSha() ?? "unknown"}`,
+    `elapsed_ms=${Math.round(result.durationMs)}`,
+    `model=${result.model}`,
+    `backend=${result.backend}`
+  ].join(`
 `);
-  const specialistsDir = join6(cwd, "specialists");
-  if (existsSync4(specialistsDir)) {
-    skip("specialists/ already exists");
-  } else {
-    mkdirSync(specialistsDir, { recursive: true });
-    ok("created specialists/");
-  }
-  const runtimeDir = join6(cwd, ".specialists");
-  if (existsSync4(runtimeDir)) {
-    skip(".specialists/ already exists");
-  } else {
-    mkdirSync(join6(runtimeDir, "jobs"), { recursive: true });
-    mkdirSync(join6(runtimeDir, "ready"), { recursive: true });
-    ok("created .specialists/ (jobs/, ready/)");
-  }
-  const gitignorePath = join6(cwd, ".gitignore");
-  if (existsSync4(gitignorePath)) {
-    const existing = readFileSync(gitignorePath, "utf-8");
-    if (existing.includes(GITIGNORE_ENTRY)) {
-      skip(".gitignore already has .specialists/ entry");
-    } else {
-      const separator = existing.endsWith(`
-`) ? "" : `
-`;
-      writeFileSync(gitignorePath, existing + separator + GITIGNORE_ENTRY + `
-`, "utf-8");
-      ok("added .specialists/ to .gitignore");
-    }
-  } else {
-    writeFileSync(gitignorePath, GITIGNORE_ENTRY + `
-`, "utf-8");
-    ok("created .gitignore with .specialists/ entry");
-  }
-  const agentsPath = join6(cwd, "AGENTS.md");
-  if (existsSync4(agentsPath)) {
-    const existing = readFileSync(agentsPath, "utf-8");
-    if (existing.includes(AGENTS_MARKER)) {
-      skip("AGENTS.md already has Specialists section");
-    } else {
-      writeFileSync(agentsPath, existing.trimEnd() + `
+  return `${result.output}
 
-` + AGENTS_BLOCK, "utf-8");
-      ok("appended Specialists section to AGENTS.md");
-    }
-  } else {
-    writeFileSync(agentsPath, AGENTS_BLOCK, "utf-8");
-    ok("created AGENTS.md with Specialists section");
-  }
-  ensureProjectMcp(cwd);
-  console.log(`
-${bold3("Done!")}
-`);
-  console.log(`  ${dim3("Next steps:")}`);
-  console.log(`  1. Add your specialists to ${yellow3("specialists/")}`);
-  console.log(`  2. Run ${yellow3("specialists list")} to verify they are discovered`);
-  console.log(`  3. Restart Claude Code to pick up AGENTS.md / .mcp.json changes
-`);
+---
+${metadata}`;
 }
-var bold3 = (s) => `\x1B[1m${s}\x1B[0m`, green2 = (s) => `\x1B[32m${s}\x1B[0m`, yellow3 = (s) => `\x1B[33m${s}\x1B[0m`, dim3 = (s) => `\x1B[2m${s}\x1B[0m`, AGENTS_BLOCK, AGENTS_MARKER = "## Specialists", GITIGNORE_ENTRY = ".specialists/", MCP_FILE = ".mcp.json", MCP_SERVER_NAME = "specialists", MCP_SERVER_CONFIG;
-var init_init = __esm(() => {
-  AGENTS_BLOCK = `
-## Specialists
 
-Call \`specialist_init\` at the start of every session to bootstrap context and
-see available specialists. Use \`use_specialist\` or \`start_specialist\` to
-delegate heavy tasks (code review, bug hunting, deep reasoning) to the right
-specialist without user intervention.
-`.trimStart();
-  MCP_SERVER_CONFIG = { command: "specialists", args: [] };
-});
-
-// src/cli/edit.ts
-var exports_edit = {};
-__export(exports_edit, {
-  run: () => run6
-});
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-function parseArgs3(argv) {
-  const name = argv[0];
-  if (!name || name.startsWith("--")) {
-    console.error("Usage: specialists edit <name> --<field> <value> [--dry-run]");
-    console.error(`  Fields: ${Object.keys(FIELD_MAP).join(", ")}`);
-    process.exit(1);
+class Supervisor {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
   }
-  let field;
-  let value;
-  let dryRun = false;
-  let scope;
-  for (let i = 1;i < argv.length; i++) {
-    const token = argv[i];
-    if (token === "--dry-run") {
-      dryRun = true;
-      continue;
-    }
-    if (token === "--scope") {
-      const v = argv[++i];
-      if (v !== "project" && v !== "user") {
-        console.error(`Error: --scope must be "project" or "user", got: "${v ?? ""}"`);
-        process.exit(1);
-      }
-      scope = v;
-      continue;
-    }
-    if (token.startsWith("--") && !field) {
-      field = token.slice(2);
-      value = argv[++i];
-      continue;
-    }
+  jobDir(id) {
+    return join3(this.opts.jobsDir, id);
   }
-  if (!field || !FIELD_MAP[field]) {
-    console.error(`Error: unknown or missing field. Valid fields: ${Object.keys(FIELD_MAP).join(", ")}`);
-    process.exit(1);
+  statusPath(id) {
+    return join3(this.jobDir(id), "status.json");
   }
-  if (value === undefined || value === "") {
-    console.error(`Error: --${field} requires a value`);
-    process.exit(1);
+  resultPath(id) {
+    return join3(this.jobDir(id), "result.txt");
   }
-  if (field === "permission" && !VALID_PERMISSIONS.includes(value)) {
-    console.error(`Error: --permission must be one of: ${VALID_PERMISSIONS.join(", ")}`);
-    process.exit(1);
+  eventsPath(id) {
+    return join3(this.jobDir(id), "events.jsonl");
   }
-  if (field === "timeout" && !/^\d+$/.test(value)) {
-    console.error("Error: --timeout must be a number (milliseconds)");
-    process.exit(1);
-  }
-  return { name, field, value, dryRun, scope };
-}
-function setIn(doc2, path, value) {
-  let node = doc2;
-  for (let i = 0;i < path.length - 1; i++) {
-    node = node.get(path[i], true);
-  }
-  const leaf = path[path.length - 1];
-  if (Array.isArray(value)) {
-    node.set(leaf, value);
-  } else {
-    node.set(leaf, value);
-  }
-}
-async function run6() {
-  const args = parseArgs3(process.argv.slice(3));
-  const { name, field, value, dryRun, scope } = args;
-  const loader = new SpecialistLoader;
-  const all = await loader.list();
-  const match = all.find((s) => s.name === name && (scope === undefined || s.scope === scope));
-  if (!match) {
-    const hint = scope ? ` (scope: ${scope})` : "";
-    console.error(`Error: specialist "${name}" not found${hint}`);
-    console.error(`  Run ${yellow4("specialists list")} to see available specialists`);
-    process.exit(1);
-  }
-  const raw = readFileSync2(match.filePath, "utf-8");
-  const doc2 = $parseDocument(raw);
-  const yamlPath = FIELD_MAP[field];
-  let typedValue = value;
-  if (field === "timeout") {
-    typedValue = parseInt(value, 10);
-  } else if (field === "tags") {
-    typedValue = value.split(",").map((t) => t.trim()).filter(Boolean);
-  }
-  setIn(doc2, yamlPath, typedValue);
-  const updated = doc2.toString();
-  if (dryRun) {
-    console.log(`
-${bold4(`[dry-run] ${match.filePath}`)}
-`);
-    console.log(dim4("--- current"));
-    console.log(dim4(`+++ updated`));
-    const oldLines = raw.split(`
-`);
-    const newLines = updated.split(`
-`);
-    newLines.forEach((line, i) => {
-      if (line !== oldLines[i]) {
-        if (oldLines[i] !== undefined)
-          console.log(dim4(`- ${oldLines[i]}`));
-        console.log(green3(`+ ${line}`));
-      }
-    });
-    console.log();
-    return;
-  }
-  writeFileSync2(match.filePath, updated, "utf-8");
-  const displayValue = field === "tags" ? `[${typedValue.join(", ")}]` : String(typedValue);
-  console.log(`${green3("✓")} ${bold4(name)}: ${yellow4(field)} = ${displayValue}` + dim4(` (${match.filePath})`));
-}
-var bold4 = (s) => `\x1B[1m${s}\x1B[0m`, green3 = (s) => `\x1B[32m${s}\x1B[0m`, yellow4 = (s) => `\x1B[33m${s}\x1B[0m`, dim4 = (s) => `\x1B[2m${s}\x1B[0m`, FIELD_MAP, VALID_PERMISSIONS;
-var init_edit = __esm(() => {
-  init_dist();
-  init_loader();
-  FIELD_MAP = {
-    model: ["specialist", "execution", "model"],
-    "fallback-model": ["specialist", "execution", "fallback_model"],
-    description: ["specialist", "metadata", "description"],
-    permission: ["specialist", "execution", "permission_required"],
-    timeout: ["specialist", "execution", "timeout_ms"],
-    tags: ["specialist", "metadata", "tags"]
-  };
-  VALID_PERMISSIONS = ["READ_ONLY", "LOW", "MEDIUM", "HIGH"];
-});
-
-// src/specialist/timeline-events.ts
-function mapCallbackEventToTimelineEvent(callbackEvent, context) {
-  const t = Date.now();
-  switch (callbackEvent) {
-    case "thinking":
-      return { t, type: TIMELINE_EVENT_TYPES.THINKING };
-    case "toolcall":
-      return {
-        t,
-        type: TIMELINE_EVENT_TYPES.TOOL,
-        tool: context.tool ?? "unknown",
-        phase: "start",
-        tool_call_id: context.toolCallId
-      };
-    case "tool_execution_end":
-      return {
-        t,
-        type: TIMELINE_EVENT_TYPES.TOOL,
-        tool: context.tool ?? "unknown",
-        phase: "end",
-        tool_call_id: context.toolCallId,
-        is_error: context.isError
-      };
-    case "text":
-      return { t, type: TIMELINE_EVENT_TYPES.TEXT };
-    case "agent_end":
-    case "message_done":
-    case "done":
-      return null;
-    default:
-      return null;
-  }
-}
-function createRunStartEvent(specialist, beadId) {
-  return {
-    t: Date.now(),
-    type: TIMELINE_EVENT_TYPES.RUN_START,
-    specialist,
-    bead_id: beadId
-  };
-}
-function createMetaEvent(model, backend) {
-  return {
-    t: Date.now(),
-    type: TIMELINE_EVENT_TYPES.META,
-    model,
-    backend
-  };
-}
-function createRunCompleteEvent(status, elapsed_s, options) {
-  return {
-    t: Date.now(),
-    type: TIMELINE_EVENT_TYPES.RUN_COMPLETE,
-    status,
-    elapsed_s,
-    ...options
-  };
-}
-function parseTimelineEvent(line) {
-  try {
-    const parsed = JSON.parse(line);
-    if (!parsed || typeof parsed !== "object")
-      return null;
-    if (typeof parsed.t !== "number")
-      return null;
-    if (typeof parsed.type !== "string")
-      return null;
-    if (parsed.type === TIMELINE_EVENT_TYPES.DONE) {
-      return {
-        t: parsed.t,
-        type: TIMELINE_EVENT_TYPES.DONE,
-        elapsed_s: typeof parsed.elapsed_s === "number" ? parsed.elapsed_s : undefined
-      };
-    }
-    if (parsed.type === TIMELINE_EVENT_TYPES.AGENT_END) {
-      return {
-        t: parsed.t,
-        type: TIMELINE_EVENT_TYPES.AGENT_END,
-        elapsed_s: typeof parsed.elapsed_s === "number" ? parsed.elapsed_s : undefined
-      };
-    }
-    const knownTypes = Object.values(TIMELINE_EVENT_TYPES).filter((type) => type !== TIMELINE_EVENT_TYPES.DONE && type !== TIMELINE_EVENT_TYPES.AGENT_END);
-    if (!knownTypes.includes(parsed.type))
-      return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isRunCompleteEvent(event) {
-  return event.type === TIMELINE_EVENT_TYPES.RUN_COMPLETE;
-}
-function compareTimelineEvents(a, b) {
-  return a.t - b.t;
-}
-var TIMELINE_EVENT_TYPES;
-var init_timeline_events = __esm(() => {
-  TIMELINE_EVENT_TYPES = {
-    RUN_START: "run_start",
-    META: "meta",
-    THINKING: "thinking",
-    TOOL: "tool",
-    TEXT: "text",
-    RUN_COMPLETE: "run_complete",
-    DONE: "done",
-    AGENT_END: "agent_end"
-  };
-});
-
-// src/specialist/supervisor.ts
-import {
-  closeSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync2,
-  openSync,
-  readdirSync,
-  readFileSync as readFileSync3,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync as writeFileSync3,
-  writeSync
-} from "node:fs";
-import { join as join7 } from "node:path";
-import { spawnSync as spawnSync4 } from "node:child_process";
-function getCurrentGitSha() {
-  const result = spawnSync4("git", ["rev-parse", "HEAD"], {
-    encoding: "utf-8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  if (result.status !== 0)
-    return;
-  const sha = result.stdout?.trim();
-  return sha || undefined;
-}
-function formatBeadNotes(result) {
-  const metadata = [
-    `prompt_hash=${result.promptHash}`,
-    `git_sha=${getCurrentGitSha() ?? "unknown"}`,
-    `elapsed_ms=${Math.round(result.durationMs)}`,
-    `model=${result.model}`,
-    `backend=${result.backend}`
-  ].join(`
-`);
-  return `${result.output}
-
----
-${metadata}`;
-}
-
-class Supervisor {
-  opts;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  jobDir(id) {
-    return join7(this.opts.jobsDir, id);
-  }
-  statusPath(id) {
-    return join7(this.jobDir(id), "status.json");
-  }
-  resultPath(id) {
-    return join7(this.jobDir(id), "result.txt");
-  }
-  eventsPath(id) {
-    return join7(this.jobDir(id), "events.jsonl");
-  }
-  readyDir() {
-    return join7(this.opts.jobsDir, "..", "ready");
+  readyDir() {
+    return join3(this.opts.jobsDir, "..", "ready");
   }
   readStatus(id) {
     const path = this.statusPath(id);
-    if (!existsSync5(path))
+    if (!existsSync4(path))
       return null;
     try {
-      return JSON.parse(readFileSync3(path, "utf-8"));
+      return JSON.parse(readFileSync2(path, "utf-8"));
     } catch {
       return null;
     }
   }
   listJobs() {
-    if (!existsSync5(this.opts.jobsDir))
+    if (!existsSync4(this.opts.jobsDir))
       return [];
     const jobs = [];
     for (const entry of readdirSync(this.opts.jobsDir)) {
-      const path = join7(this.opts.jobsDir, entry, "status.json");
-      if (!existsSync5(path))
+      const path = join3(this.opts.jobsDir, entry, "status.json");
+      if (!existsSync4(path))
         continue;
       try {
-        jobs.push(JSON.parse(readFileSync3(path, "utf-8")));
+        jobs.push(JSON.parse(readFileSync2(path, "utf-8")));
       } catch {}
     }
     return jobs.sort((a, b) => b.started_at_ms - a.started_at_ms);
@@ -19001,7 +18657,7 @@ class Supervisor {
   writeStatusFile(id, data) {
     const path = this.statusPath(id);
     const tmp = path + ".tmp";
-    writeFileSync3(tmp, JSON.stringify(data, null, 2), "utf-8");
+    writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
     renameSync(tmp, path);
   }
   updateStatus(id, updates) {
@@ -19011,11 +18667,11 @@ class Supervisor {
     this.writeStatusFile(id, { ...current, ...updates });
   }
   gc() {
-    if (!existsSync5(this.opts.jobsDir))
+    if (!existsSync4(this.opts.jobsDir))
       return;
     const cutoff = Date.now() - JOB_TTL_DAYS * 86400000;
     for (const entry of readdirSync(this.opts.jobsDir)) {
-      const dir = join7(this.opts.jobsDir, entry);
+      const dir = join3(this.opts.jobsDir, entry);
       try {
         const stat2 = statSync(dir);
         if (!stat2.isDirectory())
@@ -19026,14 +18682,14 @@ class Supervisor {
     }
   }
   crashRecovery() {
-    if (!existsSync5(this.opts.jobsDir))
+    if (!existsSync4(this.opts.jobsDir))
       return;
     for (const entry of readdirSync(this.opts.jobsDir)) {
-      const statusPath = join7(this.opts.jobsDir, entry, "status.json");
-      if (!existsSync5(statusPath))
+      const statusPath = join3(this.opts.jobsDir, entry, "status.json");
+      if (!existsSync4(statusPath))
         continue;
       try {
-        const s = JSON.parse(readFileSync3(statusPath, "utf-8"));
+        const s = JSON.parse(readFileSync2(statusPath, "utf-8"));
         if (s.status !== "running" && s.status !== "starting")
           continue;
         if (!s.pid)
@@ -19043,7 +18699,7 @@ class Supervisor {
         } catch {
           const tmp = statusPath + ".tmp";
           const updated = { ...s, status: "error", error: "Process crashed or was killed" };
-          writeFileSync3(tmp, JSON.stringify(updated, null, 2), "utf-8");
+          writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
           renameSync(tmp, statusPath);
         }
       } catch {}
@@ -19056,8 +18712,8 @@ class Supervisor {
     const id = crypto.randomUUID().slice(0, 6);
     const dir = this.jobDir(id);
     const startedAtMs = Date.now();
-    mkdirSync2(dir, { recursive: true });
-    mkdirSync2(this.readyDir(), { recursive: true });
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(this.readyDir(), { recursive: true });
     const initialStatus = {
       id,
       specialist: runOptions.name,
@@ -19074,10 +18730,18 @@ class Supervisor {
       } catch {}
     };
     appendTimelineEvent(createRunStartEvent(runOptions.name));
+    const fifoPath = join3(dir, "steer.pipe");
+    try {
+      execFileSync("mkfifo", [fifoPath]);
+      this.updateStatus(id, { fifo_path: fifoPath });
+    } catch {}
     let textLogged = false;
     let currentTool = "";
     let currentToolCallId = "";
     let killFn;
+    let steerFn;
+    let resumeFn;
+    let closeFn;
     const sigtermHandler = () => killFn?.();
     process.once("SIGTERM", sigtermHandler);
     try {
@@ -19112,9 +18776,44 @@ class Supervisor {
         killFn = fn;
       }, (beadId) => {
         this.updateStatus(id, { bead_id: beadId });
+      }, (fn) => {
+        steerFn = fn;
+        if (existsSync4(fifoPath)) {
+          const rl = createInterface({ input: createReadStream(fifoPath, { flags: "r+" }) });
+          rl.on("line", (line) => {
+            try {
+              const parsed = JSON.parse(line);
+              if (parsed?.type === "steer" && typeof parsed.message === "string") {
+                steerFn?.(parsed.message).catch(() => {});
+              } else if (parsed?.type === "prompt" && typeof parsed.message === "string") {
+                if (resumeFn) {
+                  this.updateStatus(id, { status: "running", current_event: "starting" });
+                  resumeFn(parsed.message).then((output) => {
+                    writeFileSync(this.resultPath(id), output, "utf-8");
+                    this.updateStatus(id, {
+                      status: "waiting",
+                      current_event: "waiting",
+                      elapsed_s: Math.round((Date.now() - startedAtMs) / 1000),
+                      last_event_at_ms: Date.now()
+                    });
+                  }).catch((err) => {
+                    this.updateStatus(id, { status: "error", error: err?.message ?? String(err) });
+                  });
+                }
+              } else if (parsed?.type === "close") {
+                closeFn?.().catch(() => {});
+              }
+            } catch {}
+          });
+          rl.on("error", () => {});
+        }
+      }, (rFn, cFn) => {
+        resumeFn = rFn;
+        closeFn = cFn;
+        this.updateStatus(id, { status: "waiting", current_event: "waiting" });
       });
       const elapsed = Math.round((Date.now() - startedAtMs) / 1000);
-      writeFileSync3(this.resultPath(id), result.output, "utf-8");
+      writeFileSync(this.resultPath(id), result.output, "utf-8");
       if (result.beadId) {
         this.opts.beadsClient?.updateBeadNotes(result.beadId, formatBeadNotes(result));
       }
@@ -19131,7 +18830,7 @@ class Supervisor {
         backend: result.backend,
         bead_id: result.beadId
       }));
-      writeFileSync3(join7(this.readyDir(), id), "", "utf-8");
+      writeFileSync(join3(this.readyDir(), id), "", "utf-8");
       return id;
     } catch (err) {
       const elapsed = Math.round((Date.now() - startedAtMs) / 1000);
@@ -19148,13 +18847,663 @@ class Supervisor {
     } finally {
       process.removeListener("SIGTERM", sigtermHandler);
       closeSync(eventsFd);
+      try {
+        if (existsSync4(fifoPath))
+          rmSync(fifoPath);
+      } catch {}
     }
   }
 }
-var JOB_TTL_DAYS;
-var init_supervisor = __esm(() => {
-  init_timeline_events();
-  JOB_TTL_DAYS = Number(process.env.SPECIALISTS_JOB_TTL_DAYS ?? 7);
+var JOB_TTL_DAYS;
+var init_supervisor = __esm(() => {
+  init_timeline_events();
+  JOB_TTL_DAYS = Number(process.env.SPECIALISTS_JOB_TTL_DAYS ?? 7);
+});
+
+// src/cli/install.ts
+var exports_install = {};
+__export(exports_install, {
+  run: () => run
+});
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname as dirname2, join as join8 } from "node:path";
+async function run() {
+  const installerPath = join8(dirname2(fileURLToPath(import.meta.url)), "..", "bin", "install.js");
+  execFileSync2(process.execPath, [installerPath], { stdio: "inherit" });
+}
+var init_install = () => {};
+
+// src/cli/version.ts
+var exports_version = {};
+__export(exports_version, {
+  run: () => run2
+});
+import { createRequire as createRequire2 } from "node:module";
+async function run2() {
+  const req = createRequire2(import.meta.url);
+  const pkg = req("../package.json");
+  console.log(`${pkg.name} v${pkg.version}`);
+}
+var init_version = () => {};
+
+// src/cli/list.ts
+var exports_list = {};
+__export(exports_list, {
+  run: () => run3,
+  parseArgs: () => parseArgs,
+  ArgParseError: () => ArgParseError
+});
+function parseArgs(argv) {
+  const result = {};
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--category") {
+      const value = argv[++i];
+      if (!value || value.startsWith("--")) {
+        throw new ArgParseError("--category requires a value");
+      }
+      result.category = value;
+      continue;
+    }
+    if (token === "--scope") {
+      const value = argv[++i];
+      if (value !== "default" && value !== "user") {
+        throw new ArgParseError(`--scope must be "default" or "user", got: "${value ?? ""}"`);
+      }
+      result.scope = value;
+      continue;
+    }
+    if (token === "--json") {
+      result.json = true;
+      continue;
+    }
+  }
+  return result;
+}
+async function run3() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(3));
+  } catch (err) {
+    if (err instanceof ArgParseError) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  const loader = new SpecialistLoader;
+  let specialists = await loader.list(args.category);
+  if (args.scope) {
+    specialists = specialists.filter((s) => s.scope === args.scope);
+  }
+  if (args.json) {
+    console.log(JSON.stringify(specialists, null, 2));
+    return;
+  }
+  if (specialists.length === 0) {
+    console.log("No specialists found.");
+    return;
+  }
+  const nameWidth = Math.max(...specialists.map((s) => s.name.length), 4);
+  console.log(`
+${bold(`Specialists (${specialists.length})`)}
+`);
+  for (const s of specialists) {
+    const name = cyan(s.name.padEnd(nameWidth));
+    const scopeTag = s.scope === "default" ? green("[default]") : yellow("[user]");
+    const model = dim(s.model);
+    const desc = s.description.length > 80 ? s.description.slice(0, 79) + "…" : s.description;
+    console.log(`  ${name}  ${scopeTag}  ${model}`);
+    console.log(`  ${" ".repeat(nameWidth)}  ${dim(desc)}`);
+    console.log();
+  }
+}
+var dim = (s) => `\x1B[2m${s}\x1B[0m`, bold = (s) => `\x1B[1m${s}\x1B[0m`, cyan = (s) => `\x1B[36m${s}\x1B[0m`, green = (s) => `\x1B[32m${s}\x1B[0m`, yellow = (s) => `\x1B[33m${s}\x1B[0m`, ArgParseError;
+var init_list = __esm(() => {
+  init_loader();
+  ArgParseError = class ArgParseError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ArgParseError";
+    }
+  };
+});
+
+// src/cli/models.ts
+var exports_models = {};
+__export(exports_models, {
+  run: () => run4
+});
+import { spawnSync as spawnSync5 } from "node:child_process";
+function parsePiModels() {
+  const r = spawnSync5("pi", ["--list-models"], {
+    encoding: "utf8",
+    stdio: "pipe",
+    timeout: 8000
+  });
+  if (r.status !== 0 || r.error)
+    return null;
+  return r.stdout.split(`
+`).slice(1).map((line) => line.trim()).filter(Boolean).map((line) => {
+    const cols = line.split(/\s+/);
+    return {
+      provider: cols[0] ?? "",
+      model: cols[1] ?? "",
+      context: cols[2] ?? "",
+      maxOut: cols[3] ?? "",
+      thinking: cols[4] === "yes",
+      images: cols[5] === "yes"
+    };
+  }).filter((m) => m.provider && m.model);
+}
+function parseArgs2(argv) {
+  const out = {};
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--provider" && argv[i + 1]) {
+      out.provider = argv[++i];
+      continue;
+    }
+    if (argv[i] === "--used") {
+      out.used = true;
+      continue;
+    }
+  }
+  return out;
+}
+async function run4() {
+  const args = parseArgs2(process.argv.slice(3));
+  const loader = new SpecialistLoader;
+  const specialists = await loader.list();
+  const usedBy = new Map;
+  for (const s of specialists) {
+    const key = s.model;
+    if (!usedBy.has(key))
+      usedBy.set(key, []);
+    usedBy.get(key).push(s.name);
+  }
+  const allModels = parsePiModels();
+  if (!allModels) {
+    console.error("pi not found or failed — install and configure pi first");
+    process.exit(1);
+  }
+  let models = allModels;
+  if (args.provider) {
+    models = models.filter((m) => m.provider.toLowerCase().includes(args.provider.toLowerCase()));
+  }
+  if (args.used) {
+    models = models.filter((m) => usedBy.has(`${m.provider}/${m.model}`));
+  }
+  if (models.length === 0) {
+    console.log("No models match.");
+    return;
+  }
+  const byProvider = new Map;
+  for (const m of models) {
+    if (!byProvider.has(m.provider))
+      byProvider.set(m.provider, []);
+    byProvider.get(m.provider).push(m);
+  }
+  const total = models.length;
+  console.log(`
+${bold2(`Models on pi`)}  ${dim2(`(${total} total)`)}
+`);
+  for (const [provider, pModels] of byProvider) {
+    console.log(`  ${cyan2(provider)}  ${dim2(`${pModels.length} model${pModels.length !== 1 ? "s" : ""}`)}`);
+    const modelWidth = Math.max(...pModels.map((m) => m.model.length));
+    for (const m of pModels) {
+      const key = `${m.provider}/${m.model}`;
+      const inUse = usedBy.get(key);
+      const flags = [
+        m.thinking ? green2("thinking") : dim2("·"),
+        m.images ? dim2("images") : ""
+      ].filter(Boolean).join("  ");
+      const ctx = dim2(`ctx ${m.context}`);
+      const usedLabel = inUse ? `  ${yellow2("←")} ${dim2(inUse.join(", "))}` : "";
+      console.log(`    ${m.model.padEnd(modelWidth)}  ${ctx.padEnd(18)}  ${flags}${usedLabel}`);
+    }
+    console.log();
+  }
+  if (!args.used) {
+    console.log(dim2(`  --provider <name>  filter by provider`));
+    console.log(dim2(`  --used             only show models used by your specialists`));
+    console.log();
+  }
+}
+var bold2 = (s) => `\x1B[1m${s}\x1B[0m`, dim2 = (s) => `\x1B[2m${s}\x1B[0m`, cyan2 = (s) => `\x1B[36m${s}\x1B[0m`, yellow2 = (s) => `\x1B[33m${s}\x1B[0m`, green2 = (s) => `\x1B[32m${s}\x1B[0m`;
+var init_models = __esm(() => {
+  init_loader();
+});
+
+// src/cli/init.ts
+var exports_init = {};
+__export(exports_init, {
+  run: () => run5
+});
+import { copyFileSync, cpSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join9 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function ok(msg) {
+  console.log(`  ${green3("✓")} ${msg}`);
+}
+function skip(msg) {
+  console.log(`  ${yellow3("○")} ${msg}`);
+}
+function loadJson(path, fallback) {
+  if (!existsSync6(path))
+    return structuredClone(fallback);
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return structuredClone(fallback);
+  }
+}
+function saveJson(path, value) {
+  writeFileSync4(path, JSON.stringify(value, null, 2) + `
+`, "utf-8");
+}
+function resolvePackagePath(relativePath) {
+  const configPath = `config/${relativePath}`;
+  let resolved = fileURLToPath2(new URL(`../${configPath}`, import.meta.url));
+  if (existsSync6(resolved))
+    return resolved;
+  resolved = fileURLToPath2(new URL(`../../${configPath}`, import.meta.url));
+  if (existsSync6(resolved))
+    return resolved;
+  return null;
+}
+function copyCanonicalSpecialists(cwd) {
+  const sourceDir = resolvePackagePath("specialists");
+  if (!sourceDir) {
+    skip("no canonical specialists found in package");
+    return;
+  }
+  const targetDir = join9(cwd, ".specialists", "default", "specialists");
+  const files = readdirSync2(sourceDir).filter((f) => f.endsWith(".specialist.yaml"));
+  if (files.length === 0) {
+    skip("no specialist files found in package");
+    return;
+  }
+  if (!existsSync6(targetDir)) {
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  let copied = 0;
+  let skipped = 0;
+  for (const file of files) {
+    const src = join9(sourceDir, file);
+    const dest = join9(targetDir, file);
+    if (existsSync6(dest)) {
+      skipped++;
+    } else {
+      copyFileSync(src, dest);
+      copied++;
+    }
+  }
+  if (copied > 0) {
+    ok(`copied ${copied} canonical specialist${copied === 1 ? "" : "s"} to .specialists/default/specialists/`);
+  }
+  if (skipped > 0) {
+    skip(`${skipped} specialist${skipped === 1 ? "" : "s"} already exist (not overwritten)`);
+  }
+}
+function copyCanonicalHooks(cwd) {
+  const sourceDir = resolvePackagePath("hooks");
+  if (!sourceDir) {
+    skip("no canonical hooks found in package");
+    return;
+  }
+  const targetDir = join9(cwd, ".specialists", "default", "hooks");
+  const hooks = readdirSync2(sourceDir).filter((f) => f.endsWith(".mjs"));
+  if (hooks.length === 0) {
+    skip("no hook files found in package");
+    return;
+  }
+  if (!existsSync6(targetDir)) {
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  let copied = 0;
+  let skipped = 0;
+  for (const file of hooks) {
+    const src = join9(sourceDir, file);
+    const dest = join9(targetDir, file);
+    if (existsSync6(dest)) {
+      skipped++;
+    } else {
+      copyFileSync(src, dest);
+      copied++;
+    }
+  }
+  if (copied > 0) {
+    ok(`copied ${copied} hook${copied === 1 ? "" : "s"} to .specialists/default/hooks/`);
+  }
+  if (skipped > 0) {
+    skip(`${skipped} hook${skipped === 1 ? "" : "s"} already exist (not overwritten)`);
+  }
+}
+function ensureProjectHooks(cwd) {
+  const settingsPath = join9(cwd, ".claude", "settings.json");
+  const settingsDir = join9(cwd, ".claude");
+  if (!existsSync6(settingsDir)) {
+    mkdirSync2(settingsDir, { recursive: true });
+  }
+  const settings = loadJson(settingsPath, {});
+  let changed = false;
+  function addHook(event, command) {
+    const eventList = settings[event] ?? [];
+    settings[event] = eventList;
+    const alreadyWired = eventList.some((entry) => entry?.hooks?.some?.((h) => h?.command === command));
+    if (!alreadyWired) {
+      eventList.push({ matcher: "", hooks: [{ type: "command", command }] });
+      changed = true;
+    }
+  }
+  addHook("UserPromptSubmit", "node .specialists/default/hooks/specialists-complete.mjs");
+  addHook("SessionStart", "node .specialists/default/hooks/specialists-session-start.mjs");
+  if (changed) {
+    saveJson(settingsPath, settings);
+    ok("wired specialists hooks in .claude/settings.json");
+  } else {
+    skip(".claude/settings.json already has specialists hooks");
+  }
+}
+function copyCanonicalSkills(cwd) {
+  const sourceDir = resolvePackagePath("skills");
+  if (!sourceDir) {
+    skip("no canonical skills found in package");
+    return;
+  }
+  const skills = readdirSync2(sourceDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (skills.length === 0) {
+    skip("no skill directories found in package");
+    return;
+  }
+  const targetDir = join9(cwd, ".specialists", "default", "skills");
+  if (!existsSync6(targetDir)) {
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  let copied = 0;
+  let skipped = 0;
+  for (const skill of skills) {
+    const src = join9(sourceDir, skill);
+    const dest = join9(targetDir, skill);
+    if (existsSync6(dest)) {
+      skipped++;
+    } else {
+      cpSync(src, dest, { recursive: true });
+      copied++;
+    }
+  }
+  if (copied > 0) {
+    ok(`copied ${copied} skill${copied === 1 ? "" : "s"} to .specialists/default/skills/`);
+  }
+  if (skipped > 0) {
+    skip(`${skipped} skill${skipped === 1 ? "" : "s"} already exist (not overwritten)`);
+  }
+}
+function createUserDirs(cwd) {
+  const userDirs = [
+    join9(cwd, ".specialists", "user", "specialists"),
+    join9(cwd, ".specialists", "user", "hooks"),
+    join9(cwd, ".specialists", "user", "skills")
+  ];
+  let created = 0;
+  for (const dir of userDirs) {
+    if (!existsSync6(dir)) {
+      mkdirSync2(dir, { recursive: true });
+      created++;
+    }
+  }
+  if (created > 0) {
+    ok("created .specialists/user/ directories for custom assets");
+  }
+}
+function createRuntimeDirs(cwd) {
+  const runtimeDirs = [
+    join9(cwd, ".specialists", "jobs"),
+    join9(cwd, ".specialists", "ready")
+  ];
+  let created = 0;
+  for (const dir of runtimeDirs) {
+    if (!existsSync6(dir)) {
+      mkdirSync2(dir, { recursive: true });
+      created++;
+    }
+  }
+  if (created > 0) {
+    ok("created .specialists/jobs/ and .specialists/ready/");
+  }
+}
+function ensureProjectMcp(cwd) {
+  const mcpPath = join9(cwd, MCP_FILE);
+  const mcp = loadJson(mcpPath, { mcpServers: {} });
+  mcp.mcpServers ??= {};
+  const existing = mcp.mcpServers[MCP_SERVER_NAME];
+  if (existing && existing.command === MCP_SERVER_CONFIG.command && Array.isArray(existing.args) && existing.args.length === MCP_SERVER_CONFIG.args.length) {
+    skip(".mcp.json already registers specialists");
+    return;
+  }
+  mcp.mcpServers[MCP_SERVER_NAME] = MCP_SERVER_CONFIG;
+  saveJson(mcpPath, mcp);
+  ok("registered specialists in project .mcp.json");
+}
+function ensureGitignore(cwd) {
+  const gitignorePath = join9(cwd, ".gitignore");
+  const existing = existsSync6(gitignorePath) ? readFileSync3(gitignorePath, "utf-8") : "";
+  let added = 0;
+  const lines = existing.split(`
+`);
+  for (const entry of GITIGNORE_ENTRIES) {
+    if (!lines.includes(entry)) {
+      lines.push(entry);
+      added++;
+    }
+  }
+  if (added > 0) {
+    writeFileSync4(gitignorePath, lines.join(`
+`) + `
+`, "utf-8");
+    ok("added .specialists/jobs/ and .specialists/ready/ to .gitignore");
+  } else {
+    skip(".gitignore already has runtime entries");
+  }
+}
+function ensureAgentsMd(cwd) {
+  const agentsPath = join9(cwd, "AGENTS.md");
+  if (existsSync6(agentsPath)) {
+    const existing = readFileSync3(agentsPath, "utf-8");
+    if (existing.includes(AGENTS_MARKER)) {
+      skip("AGENTS.md already has Specialists section");
+    } else {
+      writeFileSync4(agentsPath, existing.trimEnd() + `
+
+` + AGENTS_BLOCK, "utf-8");
+      ok("appended Specialists section to AGENTS.md");
+    }
+  } else {
+    writeFileSync4(agentsPath, AGENTS_BLOCK, "utf-8");
+    ok("created AGENTS.md with Specialists section");
+  }
+}
+async function run5() {
+  const cwd = process.cwd();
+  console.log(`
+${bold3("specialists init")}
+`);
+  copyCanonicalSpecialists(cwd);
+  copyCanonicalHooks(cwd);
+  copyCanonicalSkills(cwd);
+  createUserDirs(cwd);
+  createRuntimeDirs(cwd);
+  ensureGitignore(cwd);
+  ensureAgentsMd(cwd);
+  ensureProjectMcp(cwd);
+  ensureProjectHooks(cwd);
+  console.log(`
+${bold3("Done!")}
+`);
+  console.log(`  ${dim3("Directory structure:")}`);
+  console.log(`  .specialists/`);
+  console.log(`  ├── default/      ${dim3("# canonical assets (from init)")}`);
+  console.log(`  │   ├── specialists/`);
+  console.log(`  │   ├── hooks/`);
+  console.log(`  │   └── skills/`);
+  console.log(`  ├── user/         ${dim3("# your custom additions")}`);
+  console.log(`  │   ├── specialists/`);
+  console.log(`  │   ├── hooks/`);
+  console.log(`  │   └── skills/`);
+  console.log(`  ├── jobs/         ${dim3("# runtime (gitignored)")}`);
+  console.log(`  └── ready/        ${dim3("# runtime (gitignored)")}`);
+  console.log(`
+  ${dim3("Next steps:")}`);
+  console.log(`  1. Run ${yellow3("specialists list")} to see available specialists`);
+  console.log(`  2. Add custom specialists to ${yellow3(".specialists/user/specialists/")}`);
+  console.log(`  3. Restart Claude Code to pick up changes
+`);
+}
+var bold3 = (s) => `\x1B[1m${s}\x1B[0m`, green3 = (s) => `\x1B[32m${s}\x1B[0m`, yellow3 = (s) => `\x1B[33m${s}\x1B[0m`, dim3 = (s) => `\x1B[2m${s}\x1B[0m`, AGENTS_BLOCK, AGENTS_MARKER = "## Specialists", GITIGNORE_ENTRIES, MCP_FILE = ".mcp.json", MCP_SERVER_NAME = "specialists", MCP_SERVER_CONFIG;
+var init_init = __esm(() => {
+  AGENTS_BLOCK = `
+## Specialists
+
+Call \`specialist_init\` at the start of every session to bootstrap context and
+see available specialists. Use \`use_specialist\` or \`start_specialist\` to
+delegate heavy tasks (code review, bug hunting, deep reasoning) to the right
+specialist without user intervention.
+
+Add custom specialists to \`.specialists/user/specialists/\` to extend the defaults.
+`.trimStart();
+  GITIGNORE_ENTRIES = [".specialists/jobs/", ".specialists/ready/"];
+  MCP_SERVER_CONFIG = { command: "specialists", args: [] };
+});
+
+// src/cli/edit.ts
+var exports_edit = {};
+__export(exports_edit, {
+  run: () => run6
+});
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
+function parseArgs3(argv) {
+  const name = argv[0];
+  if (!name || name.startsWith("--")) {
+    console.error("Usage: specialists|sp edit <name> --<field> <value> [--dry-run]");
+    console.error(`  Fields: ${Object.keys(FIELD_MAP).join(", ")}`);
+    process.exit(1);
+  }
+  let field;
+  let value;
+  let dryRun = false;
+  let scope;
+  for (let i = 1;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (token === "--scope") {
+      const v = argv[++i];
+      if (v !== "project" && v !== "user") {
+        console.error(`Error: --scope must be "project" or "user", got: "${v ?? ""}"`);
+        process.exit(1);
+      }
+      scope = v;
+      continue;
+    }
+    if (token.startsWith("--") && !field) {
+      field = token.slice(2);
+      value = argv[++i];
+      continue;
+    }
+  }
+  if (!field || !FIELD_MAP[field]) {
+    console.error(`Error: unknown or missing field. Valid fields: ${Object.keys(FIELD_MAP).join(", ")}`);
+    process.exit(1);
+  }
+  if (value === undefined || value === "") {
+    console.error(`Error: --${field} requires a value`);
+    process.exit(1);
+  }
+  if (field === "permission" && !VALID_PERMISSIONS.includes(value)) {
+    console.error(`Error: --permission must be one of: ${VALID_PERMISSIONS.join(", ")}`);
+    process.exit(1);
+  }
+  if (field === "timeout" && !/^\d+$/.test(value)) {
+    console.error("Error: --timeout must be a number (milliseconds)");
+    process.exit(1);
+  }
+  return { name, field, value, dryRun, scope };
+}
+function setIn(doc2, path, value) {
+  let node = doc2;
+  for (let i = 0;i < path.length - 1; i++) {
+    node = node.get(path[i], true);
+  }
+  const leaf = path[path.length - 1];
+  if (Array.isArray(value)) {
+    node.set(leaf, value);
+  } else {
+    node.set(leaf, value);
+  }
+}
+async function run6() {
+  const args = parseArgs3(process.argv.slice(3));
+  const { name, field, value, dryRun, scope } = args;
+  const loader = new SpecialistLoader;
+  const all = await loader.list();
+  const match = all.find((s) => s.name === name && (scope === undefined || s.scope === scope));
+  if (!match) {
+    const hint = scope ? ` (scope: ${scope})` : "";
+    console.error(`Error: specialist "${name}" not found${hint}`);
+    console.error(`  Run ${yellow4("specialists list")} to see available specialists`);
+    process.exit(1);
+  }
+  const raw = readFileSync4(match.filePath, "utf-8");
+  const doc2 = $parseDocument(raw);
+  const yamlPath = FIELD_MAP[field];
+  let typedValue = value;
+  if (field === "timeout") {
+    typedValue = parseInt(value, 10);
+  } else if (field === "tags") {
+    typedValue = value.split(",").map((t) => t.trim()).filter(Boolean);
+  }
+  setIn(doc2, yamlPath, typedValue);
+  const updated = doc2.toString();
+  if (dryRun) {
+    console.log(`
+${bold4(`[dry-run] ${match.filePath}`)}
+`);
+    console.log(dim4("--- current"));
+    console.log(dim4(`+++ updated`));
+    const oldLines = raw.split(`
+`);
+    const newLines = updated.split(`
+`);
+    newLines.forEach((line, i) => {
+      if (line !== oldLines[i]) {
+        if (oldLines[i] !== undefined)
+          console.log(dim4(`- ${oldLines[i]}`));
+        console.log(green4(`+ ${line}`));
+      }
+    });
+    console.log();
+    return;
+  }
+  writeFileSync5(match.filePath, updated, "utf-8");
+  const displayValue = field === "tags" ? `[${typedValue.join(", ")}]` : String(typedValue);
+  console.log(`${green4("✓")} ${bold4(name)}: ${yellow4(field)} = ${displayValue}` + dim4(` (${match.filePath})`));
+}
+var bold4 = (s) => `\x1B[1m${s}\x1B[0m`, green4 = (s) => `\x1B[32m${s}\x1B[0m`, yellow4 = (s) => `\x1B[33m${s}\x1B[0m`, dim4 = (s) => `\x1B[2m${s}\x1B[0m`, FIELD_MAP, VALID_PERMISSIONS;
+var init_edit = __esm(() => {
+  init_dist();
+  init_loader();
+  FIELD_MAP = {
+    model: ["specialist", "execution", "model"],
+    "fallback-model": ["specialist", "execution", "fallback_model"],
+    description: ["specialist", "metadata", "description"],
+    permission: ["specialist", "execution", "permission_required"],
+    timeout: ["specialist", "execution", "timeout_ms"],
+    tags: ["specialist", "metadata", "tags"]
+  };
+  VALID_PERMISSIONS = ["READ_ONLY", "LOW", "MEDIUM", "HIGH"];
 });
 
 // src/cli/run.ts
@@ -19162,11 +19511,12 @@ var exports_run = {};
 __export(exports_run, {
   run: () => run7
 });
-import { join as join8 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { join as join10 } from "node:path";
 async function parseArgs4(argv) {
   const name = argv[0];
   if (!name || name.startsWith("--")) {
-    console.error('Usage: specialists run <name> [--prompt "..."] [--bead <id>] [--context-depth <n>] [--model <model>] [--no-beads] [--background]');
+    console.error('Usage: specialists|sp run <name> [--prompt "..."] [--bead <id>] [--context-depth <n>] [--model <model>] [--no-beads] [--background] [--follow]');
     process.exit(1);
   }
   let prompt = "";
@@ -19174,6 +19524,8 @@ async function parseArgs4(argv) {
   let model;
   let noBeads = false;
   let background = false;
+  let follow = false;
+  let keepAlive = false;
   let contextDepth = 1;
   for (let i = 1;i < argv.length; i++) {
     const token = argv[i];
@@ -19201,32 +19553,40 @@ async function parseArgs4(argv) {
       background = true;
       continue;
     }
+    if (token === "--follow") {
+      follow = true;
+      continue;
+    }
+    if (token === "--keep-alive") {
+      keepAlive = true;
+      continue;
+    }
   }
   if (prompt && beadId) {
     console.error("Error: use either --prompt or --bead, not both.");
     process.exit(1);
   }
   if (!prompt && !beadId && !process.stdin.isTTY) {
-    prompt = await new Promise((resolve) => {
+    prompt = await new Promise((resolve2) => {
       let buf = "";
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (chunk) => {
         buf += chunk;
       });
-      process.stdin.on("end", () => resolve(buf.trim()));
+      process.stdin.on("end", () => resolve2(buf.trim()));
     });
   }
   if (!prompt && !beadId) {
     console.error("Error: provide --prompt, pipe stdin, or use --bead <id>.");
     process.exit(1);
   }
-  return { name, prompt, beadId, model, noBeads, background, contextDepth };
+  return { name, prompt, beadId, model, noBeads, background, follow, keepAlive, contextDepth };
 }
 async function run7() {
   const args = await parseArgs4(process.argv.slice(3));
   const loader = new SpecialistLoader;
   const circuitBreaker = new CircuitBreaker;
-  const hooks = new HookEmitter({ tracePath: join8(process.cwd(), ".specialists", "trace.jsonl") });
+  const hooks = new HookEmitter({ tracePath: join10(process.cwd(), ".specialists", "trace.jsonl") });
   const beadsClient = args.noBeads ? undefined : new BeadsClient;
   const beadReader = beadsClient ?? new BeadsClient;
   let prompt = args.prompt;
@@ -19255,8 +19615,8 @@ async function run7() {
     circuitBreaker,
     beadsClient
   });
-  if (args.background) {
-    const jobsDir = join8(process.cwd(), ".specialists", "jobs");
+  if (args.background || args.follow) {
+    const jobsDir = join10(process.cwd(), ".specialists", "jobs");
     const supervisor = new Supervisor({
       runner,
       runOptions: {
@@ -19264,20 +19624,46 @@ async function run7() {
         prompt,
         variables,
         backendOverride: args.model,
-        inputBeadId: args.beadId
+        inputBeadId: args.beadId,
+        keepAlive: args.keepAlive
       },
       jobsDir,
       beadsClient
     });
+    let jobId;
     try {
-      const jobId = await supervisor.run();
-      process.stdout.write(`Job started: ${jobId}
+      jobId = await supervisor.run();
+      if (!args.follow) {
+        process.stdout.write(`Job started: ${jobId}
 `);
+      }
     } catch (err) {
       process.stderr.write(`Error: ${err?.message ?? err}
 `);
       process.exit(1);
     }
+    if (args.follow) {
+      await new Promise((resolve2, reject) => {
+        const feed = spawn2("specialists", ["feed", "--job", jobId, "--follow"], {
+          cwd: process.cwd(),
+          stdio: "inherit"
+        });
+        feed.on("close", (code) => {
+          if (code === 0) {
+            resolve2();
+          } else {
+            reject(new Error(`Feed exited with code ${code}`));
+          }
+        });
+        feed.on("error", (err) => {
+          reject(err);
+        });
+      }).catch((err) => {
+        process.stderr.write(`Error: ${err.message}
+`);
+        process.exit(1);
+      });
+    }
     return;
   }
   process.stderr.write(`
@@ -19321,11 +19707,11 @@ Interrupted.
     dim5(result.model)
   ].filter(Boolean).join("  ");
   process.stderr.write(`
-${green4("✓")} ${footer}
+${green5("✓")} ${footer}
 
 `);
 }
-var bold5 = (s) => `\x1B[1m${s}\x1B[0m`, dim5 = (s) => `\x1B[2m${s}\x1B[0m`, green4 = (s) => `\x1B[32m${s}\x1B[0m`, cyan3 = (s) => `\x1B[36m${s}\x1B[0m`;
+var bold5 = (s) => `\x1B[1m${s}\x1B[0m`, dim5 = (s) => `\x1B[2m${s}\x1B[0m`, green5 = (s) => `\x1B[32m${s}\x1B[0m`, cyan3 = (s) => `\x1B[36m${s}\x1B[0m`;
 var init_run = __esm(() => {
   init_loader();
   init_runner();
@@ -19407,9 +19793,9 @@ function formatEventLine(event, options) {
   const detail = detailParts.length > 0 ? dim6(detailParts.join(" ")) : "";
   return `${ts} ${prefix}  ${label}${detail ? ` ${detail}` : ""}`.trimEnd();
 }
-var dim6 = (s) => `\x1B[2m${s}\x1B[0m`, bold6 = (s) => `\x1B[1m${s}\x1B[0m`, cyan4 = (s) => `\x1B[36m${s}\x1B[0m`, yellow5 = (s) => `\x1B[33m${s}\x1B[0m`, red = (s) => `\x1B[31m${s}\x1B[0m`, green5 = (s) => `\x1B[32m${s}\x1B[0m`, blue = (s) => `\x1B[34m${s}\x1B[0m`, magenta = (s) => `\x1B[35m${s}\x1B[0m`, JOB_COLORS, EVENT_LABELS;
+var dim6 = (s) => `\x1B[2m${s}\x1B[0m`, bold6 = (s) => `\x1B[1m${s}\x1B[0m`, cyan4 = (s) => `\x1B[36m${s}\x1B[0m`, yellow5 = (s) => `\x1B[33m${s}\x1B[0m`, red = (s) => `\x1B[31m${s}\x1B[0m`, green6 = (s) => `\x1B[32m${s}\x1B[0m`, blue = (s) => `\x1B[34m${s}\x1B[0m`, magenta = (s) => `\x1B[35m${s}\x1B[0m`, JOB_COLORS, EVENT_LABELS;
 var init_format_helpers = __esm(() => {
-  JOB_COLORS = [cyan4, yellow5, magenta, green5, blue, red];
+  JOB_COLORS = [cyan4, yellow5, magenta, green6, blue, red];
   EVENT_LABELS = {
     run_start: "START",
     meta: "META",
@@ -19428,17 +19814,17 @@ var exports_status = {};
 __export(exports_status, {
   run: () => run8
 });
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join9 } from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join11 } from "node:path";
 function ok2(msg) {
-  console.log(`  ${green5("✓")} ${msg}`);
+  console.log(`  ${green6("✓")} ${msg}`);
 }
 function warn(msg) {
   console.log(`  ${yellow5("○")} ${msg}`);
 }
 function fail(msg) {
-  console.log(`  ${red2("✗")} ${msg}`);
+  console.log(`  ${red("✗")} ${msg}`);
 }
 function info(msg) {
   console.log(`  ${dim6(msg)}`);
@@ -19449,7 +19835,7 @@ function section(label) {
 ${bold6(`── ${label} ${line}`)}`);
 }
 function cmd(bin, args) {
-  const r = spawnSync5(bin, args, {
+  const r = spawnSync6(bin, args, {
     encoding: "utf8",
     stdio: "pipe",
     timeout: 5000
@@ -19457,7 +19843,7 @@ function cmd(bin, args) {
   return { ok: r.status === 0 && !r.error, stdout: (r.stdout ?? "").trim() };
 }
 function isInstalled(bin) {
-  return spawnSync5("which", [bin], { encoding: "utf8", timeout: 2000 }).status === 0;
+  return spawnSync6("which", [bin], { encoding: "utf8", timeout: 2000 }).status === 0;
 }
 function formatElapsed2(s) {
   if (s.elapsed_s === undefined)
@@ -19469,11 +19855,11 @@ function formatElapsed2(s) {
 function statusColor(status) {
   switch (status) {
     case "running":
-      return cyan5(status);
+      return cyan4(status);
     case "done":
-      return green5(status);
+      return green6(status);
     case "error":
-      return red2(status);
+      return red(status);
     case "starting":
       return yellow5(status);
     default:
@@ -19492,11 +19878,11 @@ async function run8() {
 `).slice(1).map((line) => line.split(/\s+/)[0]).filter(Boolean)) : new Set;
   const bdInstalled = isInstalled("bd");
   const bdVersion = bdInstalled ? cmd("bd", ["--version"]) : null;
-  const beadsPresent = existsSync6(join9(process.cwd(), ".beads"));
+  const beadsPresent = existsSync7(join11(process.cwd(), ".beads"));
   const specialistsBin = cmd("which", ["specialists"]);
-  const jobsDir = join9(process.cwd(), ".specialists", "jobs");
+  const jobsDir = join11(process.cwd(), ".specialists", "jobs");
   let jobs = [];
-  if (existsSync6(jobsDir)) {
+  if (existsSync7(jobsDir)) {
     const supervisor = new Supervisor({
       runner: null,
       runOptions: null,
@@ -19562,7 +19948,7 @@ ${bold6("specialists status")}
     for (const s of allSpecialists) {
       const staleness = stalenessMap[s.name];
       if (staleness === "AGED") {
-        warn(`${s.name}  ${red2("AGED")}  ${dim6(s.scope)}`);
+        warn(`${s.name}  ${red("AGED")}  ${dim6(s.scope)}`);
       } else if (staleness === "STALE") {
         warn(`${s.name}  ${yellow5("STALE")}  ${dim6(s.scope)}`);
       }
@@ -19599,13 +19985,12 @@ ${bold6("specialists status")}
     section("Active Jobs");
     for (const job of jobs) {
       const elapsed = formatElapsed2(job);
-      const detail = job.status === "error" ? red2(job.error?.slice(0, 40) ?? "error") : job.current_tool ? dim6(`tool: ${job.current_tool}`) : dim6(job.current_event ?? "");
+      const detail = job.status === "error" ? red(job.error?.slice(0, 40) ?? "error") : job.current_tool ? dim6(`tool: ${job.current_tool}`) : dim6(job.current_event ?? "");
       console.log(`  ${dim6(job.id)}  ${job.specialist.padEnd(20)}  ${statusColor(job.status).padEnd(7)}  ${elapsed.padStart(6)}  ${detail}`);
     }
   }
   console.log();
 }
-var red2 = (s) => `\x1B[31m${s}\x1B[0m`, cyan5 = (s) => `\x1B[36m${s}\x1B[0m`;
 var init_status = __esm(() => {
   init_loader();
   init_supervisor();
@@ -19617,15 +20002,15 @@ var exports_result = {};
 __export(exports_result, {
   run: () => run9
 });
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 async function run9() {
   const jobId = process.argv[3];
   if (!jobId) {
-    console.error("Usage: specialists result <job-id>");
+    console.error("Usage: specialists|sp result <job-id>");
     process.exit(1);
   }
-  const jobsDir = join10(process.cwd(), ".specialists", "jobs");
+  const jobsDir = join12(process.cwd(), ".specialists", "jobs");
   const supervisor = new Supervisor({ runner: null, runOptions: null, jobsDir });
   const status = supervisor.readStatus(jobId);
   if (!status) {
@@ -19638,30 +20023,30 @@ async function run9() {
     process.exit(1);
   }
   if (status.status === "error") {
-    process.stderr.write(`${red3(`Job ${jobId} failed:`)} ${status.error ?? "unknown error"}
+    process.stderr.write(`${red2(`Job ${jobId} failed:`)} ${status.error ?? "unknown error"}
 `);
     process.exit(1);
   }
-  const resultPath = join10(jobsDir, jobId, "result.txt");
-  if (!existsSync7(resultPath)) {
+  const resultPath = join12(jobsDir, jobId, "result.txt");
+  if (!existsSync8(resultPath)) {
     console.error(`Result file not found for job ${jobId}`);
     process.exit(1);
   }
-  process.stdout.write(readFileSync4(resultPath, "utf-8"));
+  process.stdout.write(readFileSync5(resultPath, "utf-8"));
 }
-var dim7 = (s) => `\x1B[2m${s}\x1B[0m`, red3 = (s) => `\x1B[31m${s}\x1B[0m`;
+var dim7 = (s) => `\x1B[2m${s}\x1B[0m`, red2 = (s) => `\x1B[31m${s}\x1B[0m`;
 var init_result = __esm(() => {
   init_supervisor();
 });
 
 // src/specialist/timeline-query.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join13 } from "node:path";
 function readJobEvents(jobDir) {
-  const eventsPath = join11(jobDir, "events.jsonl");
-  if (!existsSync8(eventsPath))
+  const eventsPath = join13(jobDir, "events.jsonl");
+  if (!existsSync9(eventsPath))
     return [];
-  const content = readFileSync5(eventsPath, "utf-8");
+  const content = readFileSync6(eventsPath, "utf-8");
   const lines = content.split(`
 `).filter(Boolean);
   const events = [];
@@ -19674,12 +20059,12 @@ function readJobEvents(jobDir) {
   return events;
 }
 function readAllJobEvents(jobsDir) {
-  if (!existsSync8(jobsDir))
+  if (!existsSync9(jobsDir))
     return [];
   const batches = [];
-  const entries = readdirSync2(jobsDir);
+  const entries = readdirSync3(jobsDir);
   for (const entry of entries) {
-    const jobDir = join11(jobsDir, entry);
+    const jobDir = join13(jobsDir, entry);
     try {
       const stat2 = __require("node:fs").statSync(jobDir);
       if (!stat2.isDirectory())
@@ -19688,12 +20073,12 @@ function readAllJobEvents(jobsDir) {
       continue;
     }
     const jobId = entry;
-    const statusPath = join11(jobDir, "status.json");
+    const statusPath = join13(jobDir, "status.json");
     let specialist = "unknown";
     let beadId;
-    if (existsSync8(statusPath)) {
+    if (existsSync9(statusPath)) {
       try {
-        const status = JSON.parse(readFileSync5(statusPath, "utf-8"));
+        const status = JSON.parse(readFileSync6(statusPath, "utf-8"));
         specialist = status.specialist ?? "unknown";
         beadId = status.bead_id;
       } catch {}
@@ -19756,8 +20141,8 @@ var exports_feed = {};
 __export(exports_feed, {
   run: () => run10
 });
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join14 } from "node:path";
 function getHumanEventKey(event) {
   switch (event.type) {
     case "meta":
@@ -19907,7 +20292,7 @@ async function followMerged(jobsDir, options) {
   }
   const lastPrintedEventKey = new Map;
   const seenMetaKey = new Map;
-  await new Promise((resolve) => {
+  await new Promise((resolve2) => {
     const interval = setInterval(() => {
       const batches = filteredBatches();
       const newEvents = [];
@@ -19944,15 +20329,15 @@ async function followMerged(jobsDir, options) {
       }
       if (!options.forever && batches.length > 0 && completedJobs.size === batches.length) {
         clearInterval(interval);
-        resolve();
+        resolve2();
       }
     }, 500);
   });
 }
 async function run10() {
   const options = parseArgs5(process.argv.slice(3));
-  const jobsDir = join12(process.cwd(), ".specialists", "jobs");
-  if (!existsSync9(jobsDir)) {
+  const jobsDir = join14(process.cwd(), ".specialists", "jobs");
+  if (!existsSync10(jobsDir)) {
     console.log(dim6("No jobs directory found."));
     return;
   }
@@ -19974,19 +20359,121 @@ var init_feed = __esm(() => {
   init_format_helpers();
 });
 
+// src/cli/steer.ts
+var exports_steer = {};
+__export(exports_steer, {
+  run: () => run11
+});
+import { join as join15 } from "node:path";
+import { writeFileSync as writeFileSync6 } from "node:fs";
+async function run11() {
+  const jobId = process.argv[3];
+  const message = process.argv[4];
+  if (!jobId || !message) {
+    console.error('Usage: specialists|sp steer <job-id> "<message>"');
+    process.exit(1);
+  }
+  const jobsDir = join15(process.cwd(), ".specialists", "jobs");
+  const supervisor = new Supervisor({ runner: null, runOptions: null, jobsDir });
+  const status = supervisor.readStatus(jobId);
+  if (!status) {
+    console.error(`No job found: ${jobId}`);
+    process.exit(1);
+  }
+  if (status.status === "done" || status.status === "error") {
+    process.stderr.write(`Job ${jobId} is already ${status.status}.
+`);
+    process.exit(1);
+  }
+  if (!status.fifo_path) {
+    process.stderr.write(`${red3("Error:")} Job ${jobId} has no steer pipe.
+`);
+    process.stderr.write(`Only jobs started with --background support mid-run steering.
+`);
+    process.exit(1);
+  }
+  try {
+    const payload = JSON.stringify({ type: "steer", message }) + `
+`;
+    writeFileSync6(status.fifo_path, payload, { flag: "a" });
+    process.stdout.write(`${green7("✓")} Steer message sent to job ${jobId}
+`);
+  } catch (err) {
+    process.stderr.write(`${red3("Error:")} Failed to write to steer pipe: ${err?.message}
+`);
+    process.exit(1);
+  }
+}
+var green7 = (s) => `\x1B[32m${s}\x1B[0m`, red3 = (s) => `\x1B[31m${s}\x1B[0m`;
+var init_steer = __esm(() => {
+  init_supervisor();
+});
+
+// src/cli/follow-up.ts
+var exports_follow_up = {};
+__export(exports_follow_up, {
+  run: () => run12
+});
+import { join as join16 } from "node:path";
+import { writeFileSync as writeFileSync7 } from "node:fs";
+async function run12() {
+  const jobId = process.argv[3];
+  const message = process.argv[4];
+  if (!jobId || !message) {
+    console.error('Usage: specialists|sp follow-up <job-id> "<message>"');
+    process.exit(1);
+  }
+  const jobsDir = join16(process.cwd(), ".specialists", "jobs");
+  const supervisor = new Supervisor({ runner: null, runOptions: null, jobsDir });
+  const status = supervisor.readStatus(jobId);
+  if (!status) {
+    console.error(`No job found: ${jobId}`);
+    process.exit(1);
+  }
+  if (status.status !== "waiting") {
+    process.stderr.write(`${red4("Error:")} Job ${jobId} is not in waiting state (status: ${status.status}).
+`);
+    process.stderr.write(`Only jobs started with --keep-alive and --background support follow-up prompts.
+`);
+    process.exit(1);
+  }
+  if (!status.fifo_path) {
+    process.stderr.write(`${red4("Error:")} Job ${jobId} has no steer pipe.
+`);
+    process.exit(1);
+  }
+  try {
+    const payload = JSON.stringify({ type: "prompt", message }) + `
+`;
+    writeFileSync7(status.fifo_path, payload, { flag: "a" });
+    process.stdout.write(`${green8("✓")} Follow-up sent to job ${jobId}
+`);
+    process.stdout.write(`  Use 'specialists feed ${jobId} --follow' to watch the response.
+`);
+  } catch (err) {
+    process.stderr.write(`${red4("Error:")} Failed to write to steer pipe: ${err?.message}
+`);
+    process.exit(1);
+  }
+}
+var green8 = (s) => `\x1B[32m${s}\x1B[0m`, red4 = (s) => `\x1B[31m${s}\x1B[0m`;
+var init_follow_up = __esm(() => {
+  init_supervisor();
+});
+
 // src/cli/stop.ts
 var exports_stop = {};
 __export(exports_stop, {
-  run: () => run11
+  run: () => run13
 });
-import { join as join13 } from "node:path";
-async function run11() {
+import { join as join17 } from "node:path";
+async function run13() {
   const jobId = process.argv[3];
   if (!jobId) {
-    console.error("Usage: specialists stop <job-id>");
+    console.error("Usage: specialists|sp stop <job-id>");
     process.exit(1);
   }
-  const jobsDir = join13(process.cwd(), ".specialists", "jobs");
+  const jobsDir = join17(process.cwd(), ".specialists", "jobs");
   const supervisor = new Supervisor({ runner: null, runOptions: null, jobsDir });
   const status = supervisor.readStatus(jobId);
   if (!status) {
@@ -20005,7 +20492,7 @@ async function run11() {
   }
   try {
     process.kill(status.pid, "SIGTERM");
-    process.stdout.write(`${green7("✓")} Sent SIGTERM to PID ${status.pid} (job ${jobId})
+    process.stdout.write(`${green9("✓")} Sent SIGTERM to PID ${status.pid} (job ${jobId})
 `);
   } catch (err) {
     if (err.code === "ESRCH") {
@@ -20018,7 +20505,7 @@ async function run11() {
     }
   }
 }
-var green7 = (s) => `\x1B[32m${s}\x1B[0m`, red5 = (s) => `\x1B[31m${s}\x1B[0m`, dim8 = (s) => `\x1B[2m${s}\x1B[0m`;
+var green9 = (s) => `\x1B[32m${s}\x1B[0m`, red5 = (s) => `\x1B[31m${s}\x1B[0m`, dim8 = (s) => `\x1B[2m${s}\x1B[0m`;
 var init_stop = __esm(() => {
   init_supervisor();
 });
@@ -20026,25 +20513,26 @@ var init_stop = __esm(() => {
 // src/cli/quickstart.ts
 var exports_quickstart = {};
 __export(exports_quickstart, {
-  run: () => run12
+  run: () => run14
 });
 function section2(title) {
   const bar = "─".repeat(60);
   return `
-${bold7(cyan7(title))}
+${bold7(cyan5(title))}
 ${dim9(bar)}`;
 }
 function cmd2(s) {
   return yellow6(s);
 }
 function flag(s) {
-  return green8(s);
+  return green10(s);
 }
-async function run12() {
+async function run14() {
   const lines = [
     "",
     bold7("specialists  ·  Quick Start Guide"),
     dim9("One MCP server. Multiple AI backends. Intelligent orchestration."),
+    dim9("Tip: sp is a shorter alias — sp run, sp list, sp feed etc. work identically."),
     ""
   ];
   lines.push(section2("1. Installation"));
@@ -20106,6 +20594,17 @@ async function run12() {
   lines.push(`  ${bold7("Read results")} — print the final output:`);
   lines.push(`  ${cmd2("specialists result job_a1b2c3d4")}          # exits 1 if still running`);
   lines.push("");
+  lines.push(`  ${bold7("Steer a running job")} — redirect the agent mid-run without cancelling:`);
+  lines.push(`  ${cmd2("specialists steer job_a1b2c3d4")} ${flag('"focus only on supervisor.ts"')}`);
+  lines.push(`  ${dim9("  # delivered after current tool calls finish, before the next LLM call")}`);
+  lines.push("");
+  lines.push(`  ${bold7("Keep-alive multi-turn")} — start with ${flag("--keep-alive")}, then follow up:`);
+  lines.push(`  ${cmd2("specialists run bug-hunt")} ${flag("--bead unitAI-abc --keep-alive --background")}`);
+  lines.push(`  ${dim9("  # → Job started: a1b2c3  (status: waiting after first turn)")}`);
+  lines.push(`  ${cmd2("specialists result a1b2c3")}                   # read first turn`);
+  lines.push(`  ${cmd2("specialists follow-up a1b2c3")} ${flag('"now write the fix"')}    # next turn, same Pi context`);
+  lines.push(`  ${cmd2("specialists feed a1b2c3")} ${flag("--follow")}               # watch response`);
+  lines.push("");
   lines.push(`  ${bold7("Cancel a job")}:`);
   lines.push(`  ${cmd2("specialists stop job_a1b2c3d4")}            # sends SIGTERM to the agent process`);
   lines.push("");
@@ -20113,6 +20612,7 @@ async function run12() {
   lines.push(`  ${dim9("status.json")}   — id, specialist, status, pid, started_at, elapsed_s, current_tool`);
   lines.push(`  ${dim9("events.jsonl")} — one JSON event per line (tool_use, text, agent_end, error …)`);
   lines.push(`  ${dim9("result.txt")}    — final output (written when status=done)`);
+  lines.push(`  ${dim9("steer.pipe")}    — named FIFO for mid-run steering (removed on job completion)`);
   lines.push("");
   lines.push(section2("6. Editing Specialists"));
   lines.push("");
@@ -20200,7 +20700,9 @@ async function run12() {
   lines.push(`  ${bold7("run_parallel")}       — concurrent or pipeline execution`);
   lines.push(`  ${bold7("start_specialist")}   — async job start, returns job ID`);
   lines.push(`  ${bold7("poll_specialist")}    — poll job status/output by ID`);
-  lines.push(`  ${bold7("stop_specialist")}    — cancel a running job by ID`);
+  lines.push(`  ${bold7("steer_specialist")}      — send a mid-run message to a running job`);
+  lines.push(`  ${bold7("follow_up_specialist")} — send a next-turn prompt to a keep-alive session`);
+  lines.push(`  ${bold7("stop_specialist")}      — cancel a running job by ID`);
   lines.push(`  ${bold7("specialist_status")}  — circuit breaker health + staleness`);
   lines.push("");
   lines.push(section2("10. Common Workflows"));
@@ -20213,6 +20715,17 @@ async function run12() {
   lines.push(`  ${cmd2("specialists feed <job-id> --follow")}`);
   lines.push(`  ${cmd2("specialists result <job-id> > analysis.md")}`);
   lines.push("");
+  lines.push(`  ${bold7("Steer a job mid-run:")}`);
+  lines.push(`  ${cmd2('specialists run deep-analysis --prompt "..." --background')}`);
+  lines.push(`  ${cmd2('specialists steer <job-id> "focus only on the auth module"')}`);
+  lines.push(`  ${cmd2("specialists result <job-id>")}`);
+  lines.push("");
+  lines.push(`  ${bold7("Multi-turn keep-alive (iterative work):")}`);
+  lines.push(`  ${cmd2("specialists run bug-hunt --bead unitAI-abc --keep-alive --background")}`);
+  lines.push(`  ${cmd2("specialists result <job-id>")}`);
+  lines.push(`  ${cmd2('specialists follow-up <job-id> "now write the fix for the root cause"')}`);
+  lines.push(`  ${cmd2("specialists feed <job-id> --follow")}`);
+  lines.push("");
   lines.push(`  ${bold7("Override model for a single run:")}`);
   lines.push(`  ${cmd2('specialists run code-review --model anthropic/claude-opus-4-6 --prompt "..."')}`);
   lines.push("");
@@ -20223,18 +20736,18 @@ async function run12() {
   console.log(lines.join(`
 `));
 }
-var bold7 = (s) => `\x1B[1m${s}\x1B[0m`, dim9 = (s) => `\x1B[2m${s}\x1B[0m`, yellow6 = (s) => `\x1B[33m${s}\x1B[0m`, cyan7 = (s) => `\x1B[36m${s}\x1B[0m`, blue2 = (s) => `\x1B[34m${s}\x1B[0m`, green8 = (s) => `\x1B[32m${s}\x1B[0m`;
+var bold7 = (s) => `\x1B[1m${s}\x1B[0m`, dim9 = (s) => `\x1B[2m${s}\x1B[0m`, yellow6 = (s) => `\x1B[33m${s}\x1B[0m`, cyan5 = (s) => `\x1B[36m${s}\x1B[0m`, blue2 = (s) => `\x1B[34m${s}\x1B[0m`, green10 = (s) => `\x1B[32m${s}\x1B[0m`;
 
 // src/cli/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
-  run: () => run13
+  run: () => run15
 });
-import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync as readdirSync3 } from "node:fs";
-import { join as join14 } from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
+import { join as join18 } from "node:path";
 function ok3(msg) {
-  console.log(`  ${green9("✓")} ${msg}`);
+  console.log(`  ${green11("✓")} ${msg}`);
 }
 function warn2(msg) {
   console.log(`  ${yellow7("○")} ${msg}`);
@@ -20254,17 +20767,17 @@ function section3(label) {
 ${bold8(`── ${label} ${line}`)}`);
 }
 function sp(bin, args) {
-  const r = spawnSync6(bin, args, { encoding: "utf8", stdio: "pipe", timeout: 5000 });
+  const r = spawnSync7(bin, args, { encoding: "utf8", stdio: "pipe", timeout: 5000 });
   return { ok: r.status === 0 && !r.error, stdout: (r.stdout ?? "").trim() };
 }
 function isInstalled2(bin) {
-  return spawnSync6("which", [bin], { encoding: "utf8", timeout: 2000 }).status === 0;
+  return spawnSync7("which", [bin], { encoding: "utf8", timeout: 2000 }).status === 0;
 }
 function loadJson2(path) {
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return null;
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
@@ -20297,7 +20810,7 @@ function checkBd() {
     return false;
   }
   ok3(`bd installed  ${dim10(sp("bd", ["--version"]).stdout || "")}`);
-  if (existsSync10(join14(CWD, ".beads")))
+  if (existsSync11(join18(CWD, ".beads")))
     ok3(".beads/ present in project");
   else
     warn2(".beads/ not found in project");
@@ -20317,8 +20830,8 @@ function checkHooks() {
   section3("Claude Code hooks  (2 expected)");
   let allPresent = true;
   for (const name of HOOK_NAMES) {
-    const dest = join14(HOOKS_DIR, name);
-    if (!existsSync10(dest)) {
+    const dest = join18(HOOKS_DIR, name);
+    if (!existsSync11(dest)) {
       fail2(`${name}  ${red6("missing")}`);
       fix("specialists install");
       allPresent = false;
@@ -20332,14 +20845,13 @@ function checkHooks() {
     fix("specialists install");
     return false;
   }
-  const hooks = settings.hooks ?? {};
   const wiredCommands = new Set([
-    ...hooks.UserPromptSubmit ?? [],
-    ...hooks.SessionStart ?? []
+    ...settings.UserPromptSubmit ?? [],
+    ...settings.SessionStart ?? []
   ].flatMap((entry) => (entry.hooks ?? []).map((h) => h.command ?? "")));
   for (const name of HOOK_NAMES) {
-    const expected = join14(HOOKS_DIR, name);
-    if (!wiredCommands.has(expected)) {
+    const expectedRelative = `node .specialists/default/hooks/${name}`;
+    if (!wiredCommands.has(expectedRelative)) {
       warn2(`${name} not wired in settings.json`);
       fix("specialists install");
       allPresent = false;
@@ -20363,18 +20875,18 @@ function checkMCP() {
 }
 function checkRuntimeDirs() {
   section3(".specialists/ runtime directories");
-  const rootDir = join14(CWD, ".specialists");
-  const jobsDir = join14(rootDir, "jobs");
-  const readyDir = join14(rootDir, "ready");
+  const rootDir = join18(CWD, ".specialists");
+  const jobsDir = join18(rootDir, "jobs");
+  const readyDir = join18(rootDir, "ready");
   let allOk = true;
-  if (!existsSync10(rootDir)) {
+  if (!existsSync11(rootDir)) {
     warn2(".specialists/ not found in current project");
     fix("specialists init");
     allOk = false;
   } else {
     ok3(".specialists/ present");
     for (const [subDir, label] of [[jobsDir, "jobs"], [readyDir, "ready"]]) {
-      if (!existsSync10(subDir)) {
+      if (!existsSync11(subDir)) {
         warn2(`.specialists/${label}/ missing — auto-creating`);
         mkdirSync3(subDir, { recursive: true });
         ok3(`.specialists/${label}/ created`);
@@ -20387,14 +20899,14 @@ function checkRuntimeDirs() {
 }
 function checkZombieJobs() {
   section3("Background jobs");
-  const jobsDir = join14(CWD, ".specialists", "jobs");
-  if (!existsSync10(jobsDir)) {
+  const jobsDir = join18(CWD, ".specialists", "jobs");
+  if (!existsSync11(jobsDir)) {
     hint("No .specialists/jobs/ — skipping");
     return true;
   }
   let entries;
   try {
-    entries = readdirSync3(jobsDir);
+    entries = readdirSync4(jobsDir);
   } catch {
     entries = [];
   }
@@ -20406,11 +20918,11 @@ function checkZombieJobs() {
   let total = 0;
   let running = 0;
   for (const jobId of entries) {
-    const statusPath = join14(jobsDir, jobId, "status.json");
-    if (!existsSync10(statusPath))
+    const statusPath = join18(jobsDir, jobId, "status.json");
+    if (!existsSync11(statusPath))
       continue;
     try {
-      const status = JSON.parse(readFileSync6(statusPath, "utf8"));
+      const status = JSON.parse(readFileSync7(statusPath, "utf8"));
       total++;
       if (status.status === "running" || status.status === "starting") {
         const pid = status.pid;
@@ -20437,7 +20949,7 @@ function checkZombieJobs() {
   }
   return zombies === 0;
 }
-async function run13() {
+async function run15() {
   console.log(`
 ${bold8("specialists doctor")}
 `);
@@ -20451,20 +20963,21 @@ ${bold8("specialists doctor")}
   const allOk = piOk && bdOk && xtOk && hooksOk && mcpOk && dirsOk && jobsOk;
   console.log("");
   if (allOk) {
-    console.log(`  ${green9("✓")} ${bold8("All checks passed")}  — specialists is healthy`);
+    console.log(`  ${green11("✓")} ${bold8("All checks passed")}  — specialists is healthy`);
   } else {
     console.log(`  ${yellow7("○")} ${bold8("Some checks failed")}  — follow the fix hints above`);
     console.log(`  ${dim10("specialists install fixes hook + MCP registration; pi, bd, and xt must be installed separately.")}`);
   }
   console.log("");
 }
-var bold8 = (s) => `\x1B[1m${s}\x1B[0m`, dim10 = (s) => `\x1B[2m${s}\x1B[0m`, green9 = (s) => `\x1B[32m${s}\x1B[0m`, yellow7 = (s) => `\x1B[33m${s}\x1B[0m`, red6 = (s) => `\x1B[31m${s}\x1B[0m`, CWD, CLAUDE_DIR, HOOKS_DIR, SETTINGS_FILE, MCP_FILE2, HOOK_NAMES;
+var bold8 = (s) => `\x1B[1m${s}\x1B[0m`, dim10 = (s) => `\x1B[2m${s}\x1B[0m`, green11 = (s) => `\x1B[32m${s}\x1B[0m`, yellow7 = (s) => `\x1B[33m${s}\x1B[0m`, red6 = (s) => `\x1B[31m${s}\x1B[0m`, CWD, CLAUDE_DIR, SPECIALISTS_DIR, HOOKS_DIR, SETTINGS_FILE, MCP_FILE2, HOOK_NAMES;
 var init_doctor = __esm(() => {
   CWD = process.cwd();
-  CLAUDE_DIR = join14(CWD, ".claude");
-  HOOKS_DIR = join14(CLAUDE_DIR, "hooks");
-  SETTINGS_FILE = join14(CLAUDE_DIR, "settings.json");
-  MCP_FILE2 = join14(CWD, ".mcp.json");
+  CLAUDE_DIR = join18(CWD, ".claude");
+  SPECIALISTS_DIR = join18(CWD, ".specialists");
+  HOOKS_DIR = join18(SPECIALISTS_DIR, "default", "hooks");
+  SETTINGS_FILE = join18(CLAUDE_DIR, "settings.json");
+  MCP_FILE2 = join18(CWD, ".mcp.json");
   HOOK_NAMES = [
     "specialists-complete.mjs",
     "specialists-session-start.mjs"
@@ -20474,13 +20987,13 @@ var init_doctor = __esm(() => {
 // src/cli/setup.ts
 var exports_setup = {};
 __export(exports_setup, {
-  run: () => run14
+  run: () => run16
 });
-import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join15, resolve } from "node:path";
+import { join as join19, resolve as resolve2 } from "node:path";
 function ok4(msg) {
-  console.log(`  ${green10("✓")} ${msg}`);
+  console.log(`  ${green12("✓")} ${msg}`);
 }
 function skip2(msg) {
   console.log(`  ${yellow8("○")} ${msg}`);
@@ -20488,12 +21001,12 @@ function skip2(msg) {
 function resolveTarget(target) {
   switch (target) {
     case "global":
-      return join15(homedir3(), ".claude", "CLAUDE.md");
+      return join19(homedir3(), ".claude", "CLAUDE.md");
     case "agents":
-      return join15(process.cwd(), "AGENTS.md");
+      return join19(process.cwd(), "AGENTS.md");
     case "project":
     default:
-      return join15(process.cwd(), "CLAUDE.md");
+      return join19(process.cwd(), "CLAUDE.md");
   }
 }
 function parseArgs6() {
@@ -20521,17 +21034,17 @@ function parseArgs6() {
   }
   return { target, dryRun };
 }
-async function run14() {
+async function run16() {
   const { target, dryRun } = parseArgs6();
-  const filePath = resolve(resolveTarget(target));
+  const filePath = resolve2(resolveTarget(target));
   const label = target === "global" ? "~/.claude/CLAUDE.md" : filePath.replace(process.cwd() + "/", "");
   console.log(`
 ${bold9("specialists setup")}
 `);
   console.log(`  Target: ${yellow8(label)}${dryRun ? dim11("  (dry-run)") : ""}
 `);
-  if (existsSync11(filePath)) {
-    const existing = readFileSync7(filePath, "utf8");
+  if (existsSync12(filePath)) {
+    const existing = readFileSync8(filePath, "utf8");
     if (existing.includes(MARKER)) {
       skip2(`${label} already contains Specialists Workflow section`);
       console.log(`
@@ -20552,7 +21065,7 @@ ${bold9("specialists setup")}
 ` : `
 
 `;
-    writeFileSync4(filePath, existing.trimEnd() + separator + WORKFLOW_BLOCK, "utf8");
+    writeFileSync8(filePath, existing.trimEnd() + separator + WORKFLOW_BLOCK, "utf8");
     ok4(`Appended Specialists Workflow section to ${label}`);
   } else {
     if (dryRun) {
@@ -20563,7 +21076,7 @@ ${bold9("specialists setup")}
       console.log(dim11("─".repeat(60)));
       return;
     }
-    writeFileSync4(filePath, WORKFLOW_BLOCK, "utf8");
+    writeFileSync8(filePath, WORKFLOW_BLOCK, "utf8");
     ok4(`Created ${label} with Specialists Workflow section`);
   }
   console.log("");
@@ -20573,7 +21086,7 @@ ${bold9("specialists setup")}
   console.log(`  • Run ${yellow8("specialist_init")} in a new session to bootstrap context`);
   console.log("");
 }
-var bold9 = (s) => `\x1B[1m${s}\x1B[0m`, dim11 = (s) => `\x1B[2m${s}\x1B[0m`, green10 = (s) => `\x1B[32m${s}\x1B[0m`, yellow8 = (s) => `\x1B[33m${s}\x1B[0m`, MARKER = "## Specialists Workflow", WORKFLOW_BLOCK = `## Specialists Workflow
+var bold9 = (s) => `\x1B[1m${s}\x1B[0m`, dim11 = (s) => `\x1B[2m${s}\x1B[0m`, green12 = (s) => `\x1B[32m${s}\x1B[0m`, yellow8 = (s) => `\x1B[33m${s}\x1B[0m`, MARKER = "## Specialists Workflow", WORKFLOW_BLOCK = `## Specialists Workflow
 
 > Injected by \`specialists setup\`. Keep this section — agents use it for context.
 
@@ -20641,26 +21154,28 @@ var init_setup = () => {};
 // src/cli/help.ts
 var exports_help = {};
 __export(exports_help, {
-  run: () => run15
+  run: () => run17
 });
 function formatCommands(entries) {
   const width = Math.max(...entries.map(([cmd3]) => cmd3.length));
   return entries.map(([cmd3, desc]) => `  ${cmd3.padEnd(width)}   ${desc}`);
 }
-async function run15() {
+async function run17() {
   const lines = [
     "",
     "Specialists lets you run project-scoped specialist agents with a bead-first workflow.",
     "",
     bold10("Usage:"),
-    "  specialists [command]",
-    "  specialists [command] --help",
+    "  specialists|sp [command]",
+    "  specialists|sp [command] --help",
+    "",
+    dim12("  sp is a shorter alias — sp run, sp list, sp feed etc. all work identically."),
     "",
     bold10("Common flows:"),
     "",
     "  Tracked work (primary)",
     '    bd create "Task title" -t task -p 1 --json',
-    "    specialists run <name> --bead <id> [--context-depth N] [--background]",
+    "    specialists run <name> --bead <id> [--context-depth N] [--background] [--follow]",
     "    specialists feed -f",
     '    bd close <id> --reason "Done"',
     "",
@@ -20672,6 +21187,7 @@ async function run15() {
     "    --prompt is for quick untracked work",
     "    --context-depth defaults to 1 with --bead",
     "    --no-beads does not disable bead reading",
+    "    --follow runs in background and streams output live",
     "",
     bold10("Core commands:"),
     ...formatCommands(CORE_COMMANDS),
@@ -20686,15 +21202,20 @@ async function run15() {
     "  specialists init",
     "  specialists list",
     "  specialists run bug-hunt --bead unitAI-123 --background",
+    "  specialists run sync-docs --follow                 # run + stream live output",
     '  specialists run codebase-explorer --prompt "Map the CLI architecture"',
     "  specialists feed -f",
+    '  specialists steer <job-id> "focus only on supervisor.ts"',
+    '  specialists follow-up <job-id> "now write the fix"',
     "  specialists result <job-id>",
     "",
     bold10("More help:"),
-    "  specialists quickstart      Full guide and workflow reference",
-    "  specialists run --help      Run command details and flags",
-    "  specialists init --help     Bootstrap behavior and workflow injection",
-    "  specialists feed --help     Background job monitoring details",
+    "  specialists quickstart         Full guide and workflow reference",
+    "  specialists run --help         Run command details and flags",
+    "  specialists steer --help       Mid-run steering details",
+    "  specialists follow-up --help   Multi-turn keep-alive details",
+    "  specialists init --help        Bootstrap behavior and workflow injection",
+    "  specialists feed --help        Background job monitoring details",
     "",
     dim12("Project model: specialists are project-only; user-scope discovery is deprecated."),
     ""
@@ -20710,6 +21231,8 @@ var init_help = __esm(() => {
     ["run", "Run a specialist with --bead for tracked work or --prompt for ad-hoc work"],
     ["feed", "Tail job events; use -f to follow all jobs"],
     ["result", "Print final output of a completed background job"],
+    ["steer", "Send a mid-run message to a running background job"],
+    ["follow-up", "Send a next-turn prompt to a keep-alive session (retains full context)"],
     ["stop", "Stop a running background job"],
     ["status", "Show health, MCP state, and active jobs"],
     ["doctor", "Diagnose installation/runtime problems"],
@@ -28002,7 +28525,7 @@ class StdioServerTransport {
 }
 
 // src/server.ts
-import { join as join4 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/constants.ts
 var LOG_PREFIX = "[specialists]";
@@ -28118,8 +28641,7 @@ function createUseSpecialistTool(runner) {
         if (!bead) {
           throw new Error(`Unable to read bead '${input.bead_id}' via bd show --json`);
         }
-        const blockers = input.context_depth && input.context_depth > 0 ? beadsClient.getBlockers(input.bead_id, input.context_depth) : [];
-        const beadContext = buildBeadContext(bead, { blockers, depth: input.context_depth ?? 0 });
+        const beadContext = buildBeadContext(bead);
         prompt = beadContext;
         variables = {
           ...input.variables ?? {},
@@ -28239,17 +28761,17 @@ function createSpecialistStatusTool(loader, circuitBreaker) {
     async execute(_) {
       const list = await loader.list();
       const stalenessResults = await Promise.all(list.map((s) => checkStaleness(s)));
-      const { existsSync: existsSync3, readdirSync, readFileSync } = await import("node:fs");
+      const { existsSync: existsSync4, readdirSync, readFileSync: readFileSync2 } = await import("node:fs");
       const { join: join3 } = await import("node:path");
       const jobsDir = join3(process.cwd(), ".specialists", "jobs");
       const jobs = [];
-      if (existsSync3(jobsDir)) {
+      if (existsSync4(jobsDir)) {
         for (const entry of readdirSync(jobsDir)) {
           const statusPath = join3(jobsDir, entry, "status.json");
-          if (!existsSync3(statusPath))
+          if (!existsSync4(statusPath))
             continue;
           try {
-            jobs.push(JSON.parse(readFileSync(statusPath, "utf-8")));
+            jobs.push(JSON.parse(readFileSync2(statusPath, "utf-8")));
           } catch {}
         }
         jobs.sort((a, b) => b.started_at_ms - a.started_at_ms);
@@ -28328,6 +28850,74 @@ class JobRegistry {
     }
     job.killFn = killFn;
   }
+  setSteerFn(id, steerFn) {
+    const job = this.jobs.get(id);
+    if (!job)
+      return;
+    job.steerFn = steerFn;
+  }
+  setResumeFn(id, resumeFn, closeFn) {
+    const job = this.jobs.get(id);
+    if (!job)
+      return;
+    job.resumeFn = resumeFn;
+    job.closeFn = closeFn;
+    job.status = "waiting";
+    job.currentEvent = "waiting";
+  }
+  async followUp(id, message) {
+    const job = this.jobs.get(id);
+    if (!job)
+      return { ok: false, error: `Job not found: ${id}` };
+    if (job.status !== "waiting")
+      return { ok: false, error: `Job is not waiting (status: ${job.status})` };
+    if (!job.resumeFn)
+      return { ok: false, error: "Job has no resume function" };
+    job.status = "running";
+    job.currentEvent = "starting";
+    try {
+      const output = await job.resumeFn(message);
+      job.outputBuffer = output;
+      job.status = "waiting";
+      job.currentEvent = "waiting";
+      return { ok: true, output };
+    } catch (err) {
+      job.status = "error";
+      job.error = err?.message ?? String(err);
+      return { ok: false, error: job.error };
+    }
+  }
+  async closeSession(id) {
+    const job = this.jobs.get(id);
+    if (!job)
+      return { ok: false, error: `Job not found: ${id}` };
+    if (job.status !== "waiting")
+      return { ok: false, error: `Job is not in waiting state` };
+    try {
+      await job.closeFn?.();
+      job.status = "done";
+      job.currentEvent = "done";
+      job.endedAtMs = Date.now();
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err?.message ?? String(err) };
+    }
+  }
+  async steer(id, message) {
+    const job = this.jobs.get(id);
+    if (!job)
+      return { ok: false, error: `Job not found: ${id}` };
+    if (job.status !== "running")
+      return { ok: false, error: `Job is not running (status: ${job.status})` };
+    if (!job.steerFn)
+      return { ok: false, error: "Job session not ready for steering yet" };
+    try {
+      await job.steerFn(message);
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err?.message ?? String(err) };
+    }
+  }
   complete(id, result) {
     const job = this.jobs.get(id);
     if (!job || job.status !== "running")
@@ -28452,20 +29042,117 @@ function createStopSpecialistTool(registry2) {
   };
 }
 
+// src/tools/specialist/steer_specialist.tool.ts
+init_zod();
+init_supervisor();
+import { writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+var steerSpecialistSchema = exports_external.object({
+  job_id: exports_external.string().describe("Job ID returned by start_specialist or specialists run --background"),
+  message: exports_external.string().describe('Steering instruction to send to the running agent (e.g. "focus only on supervisor.ts")')
+});
+function createSteerSpecialistTool(registry2) {
+  return {
+    name: "steer_specialist",
+    description: "Send a mid-run steering message to a running specialist job. The agent receives the message after its current tool calls finish, before the next LLM call. Works for both in-process jobs (start_specialist) and background CLI jobs (specialists run --background).",
+    inputSchema: steerSpecialistSchema,
+    async execute(input) {
+      const snap = registry2.snapshot(input.job_id);
+      if (snap) {
+        const result = await registry2.steer(input.job_id, input.message);
+        if (result.ok) {
+          return { status: "steered", job_id: input.job_id, message: input.message };
+        }
+        return { status: "error", error: result.error, job_id: input.job_id };
+      }
+      const jobsDir = join4(process.cwd(), ".specialists", "jobs");
+      const supervisor = new Supervisor({ runner: null, runOptions: null, jobsDir });
+      const status = supervisor.readStatus(input.job_id);
+      if (!status) {
+        return { status: "error", error: `Job not found: ${input.job_id}`, job_id: input.job_id };
+      }
+      if (status.status === "done" || status.status === "error") {
+        return { status: "error", error: `Job is already ${status.status}`, job_id: input.job_id };
+      }
+      if (!status.fifo_path) {
+        return { status: "error", error: "Job has no steer pipe (may have been started without FIFO support)", job_id: input.job_id };
+      }
+      try {
+        const payload = JSON.stringify({ type: "steer", message: input.message }) + `
+`;
+        writeFileSync2(status.fifo_path, payload, { flag: "a" });
+        return { status: "steered", job_id: input.job_id, message: input.message };
+      } catch (err) {
+        return { status: "error", error: `Failed to write to steer pipe: ${err?.message}`, job_id: input.job_id };
+      }
+    }
+  };
+}
+
+// src/tools/specialist/follow_up_specialist.tool.ts
+init_zod();
+init_supervisor();
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+var followUpSpecialistSchema = exports_external.object({
+  job_id: exports_external.string().describe("Job ID of a waiting keep-alive specialist session"),
+  message: exports_external.string().describe("Next prompt to send to the specialist (conversation history is retained)")
+});
+function createFollowUpSpecialistTool(registry2) {
+  return {
+    name: "follow_up_specialist",
+    description: "Send a follow-up prompt to a waiting keep-alive specialist session. The Pi session retains full conversation history between turns. Only works for jobs started with keepAlive=true (CLI: --keep-alive --background).",
+    inputSchema: followUpSpecialistSchema,
+    async execute(input) {
+      const snap = registry2.snapshot(input.job_id);
+      if (snap) {
+        if (snap.status !== "waiting") {
+          return { status: "error", error: `Job is not waiting (status: ${snap.status})`, job_id: input.job_id };
+        }
+        const result = await registry2.followUp(input.job_id, input.message);
+        if (result.ok) {
+          return { status: "resumed", job_id: input.job_id, output: result.output };
+        }
+        return { status: "error", error: result.error, job_id: input.job_id };
+      }
+      const jobsDir = join5(process.cwd(), ".specialists", "jobs");
+      const supervisor = new Supervisor({ runner: null, runOptions: null, jobsDir });
+      const status = supervisor.readStatus(input.job_id);
+      if (!status) {
+        return { status: "error", error: `Job not found: ${input.job_id}`, job_id: input.job_id };
+      }
+      if (status.status !== "waiting") {
+        return { status: "error", error: `Job is not waiting (status: ${status.status})`, job_id: input.job_id };
+      }
+      if (!status.fifo_path) {
+        return { status: "error", error: "Job has no steer pipe", job_id: input.job_id };
+      }
+      try {
+        const payload = JSON.stringify({ type: "prompt", message: input.message }) + `
+`;
+        writeFileSync3(status.fifo_path, payload, { flag: "a" });
+        return { status: "sent", job_id: input.job_id, message: input.message };
+      } catch (err) {
+        return { status: "error", error: `Failed to write to steer pipe: ${err?.message}`, job_id: input.job_id };
+      }
+    }
+  };
+}
+
 // src/server.ts
 init_zod();
 
 // src/tools/specialist/specialist_init.tool.ts
 init_zod();
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join6 } from "node:path";
 var specialistInitSchema = objectType({});
 function createSpecialistInitTool(loader, deps) {
   const resolved = deps ?? {
-    bdAvailable: () => spawnSync2("bd", ["--version"], { stdio: "ignore" }).status === 0,
-    beadsExists: () => existsSync3(join3(process.cwd(), ".beads")),
-    bdInit: () => spawnSync2("bd", ["init"], { stdio: "ignore" })
+    bdAvailable: () => spawnSync4("bd", ["--version"], { stdio: "ignore" }).status === 0,
+    beadsExists: () => existsSync5(join6(process.cwd(), ".beads")),
+    bdInit: () => spawnSync4("bd", ["init"], { stdio: "ignore" })
   };
   return {
     name: "specialist_init",
@@ -28499,7 +29186,7 @@ class SpecialistsServer {
     const circuitBreaker = new CircuitBreaker;
     const loader = new SpecialistLoader;
     const hooks = new HookEmitter({
-      tracePath: join4(process.cwd(), ".specialists", "trace.jsonl")
+      tracePath: join7(process.cwd(), ".specialists", "trace.jsonl")
     });
     const beadsClient = new BeadsClient;
     const runner = new SpecialistRunner({ loader, hooks, circuitBreaker, beadsClient });
@@ -28512,6 +29199,8 @@ class SpecialistsServer {
       createStartSpecialistTool(runner, registry2),
       createPollSpecialistTool(registry2),
       createStopSpecialistTool(registry2),
+      createSteerSpecialistTool(registry2),
+      createFollowUpSpecialistTool(registry2),
       createSpecialistInitTool(loader)
     ];
     this.server = new Server({ name: MCP_CONFIG.SERVER_NAME, version: MCP_CONFIG.VERSION }, { capabilities: MCP_CONFIG.CAPABILITIES });
@@ -28527,6 +29216,8 @@ class SpecialistsServer {
       start_specialist: startSpecialistSchema,
       poll_specialist: pollSpecialistSchema,
       stop_specialist: stopSpecialistSchema,
+      steer_specialist: steerSpecialistSchema,
+      follow_up_specialist: followUpSpecialistSchema,
       specialist_init: specialistInitSchema
     };
     this.toolSchemas = schemaMap;
@@ -28599,7 +29290,7 @@ var next = process.argv[3];
 function wantsHelp() {
   return next === "--help" || next === "-h";
 }
-async function run16() {
+async function run18() {
   if (sub === "install") {
     if (wantsHelp()) {
       console.log([
@@ -28754,11 +29445,13 @@ async function run16() {
         "  --context-depth <n>  Dependency context depth when using --bead (default: 1)",
         "  --no-beads           Do not create a new tracking bead (does not disable bead reading)",
         "  --background         Start async and return a job id",
+        "  --follow             Run in background and stream output live",
         "  --model <model>      Override the configured model for this run",
         "",
         "Examples:",
         "  specialists run bug-hunt --bead unitAI-55d",
         "  specialists run bug-hunt --bead unitAI-55d --context-depth 2 --background",
+        "  specialists run sync-docs --follow",
         '  specialists run code-review --prompt "Audit src/api.ts"',
         "  cat brief.md | specialists run report-generator",
         "",
@@ -28857,6 +29550,65 @@ async function run16() {
     const { run: handler } = await Promise.resolve().then(() => (init_feed(), exports_feed));
     return handler();
   }
+  if (sub === "steer") {
+    if (wantsHelp()) {
+      console.log([
+        "",
+        'Usage: specialists steer <job-id> "<message>"',
+        "",
+        "Send a mid-run steering message to a running background specialist job.",
+        "The agent receives the message after its current tool calls finish,",
+        "before the next LLM call.",
+        "",
+        'Pi RPC steer command: {"type":"steer","message":"..."}',
+        'Response: {"type":"response","command":"steer","success":true}',
+        "",
+        "Examples:",
+        '  specialists steer a1b2c3 "focus only on supervisor.ts"',
+        '  specialists steer a1b2c3 "skip tests, just fix the bug"',
+        "",
+        "Notes:",
+        "  - Only works for jobs started with --background.",
+        "  - Delivery is best-effort: the agent processes it on its next turn.",
+        ""
+      ].join(`
+`));
+      return;
+    }
+    const { run: handler } = await Promise.resolve().then(() => (init_steer(), exports_steer));
+    return handler();
+  }
+  if (sub === "follow-up") {
+    if (wantsHelp()) {
+      console.log([
+        "",
+        'Usage: specialists follow-up <job-id> "<message>"',
+        "",
+        "Send a follow-up prompt to a waiting keep-alive specialist session.",
+        "The Pi session retains full conversation history between turns.",
+        "",
+        "Requires: job started with --keep-alive --background.",
+        "",
+        "Examples:",
+        '  specialists follow-up a1b2c3 "Now write the fix for the bug you found"',
+        '  specialists follow-up a1b2c3 "Focus only on the auth module"',
+        "",
+        "Workflow:",
+        "  specialists run bug-hunt --bead <id> --keep-alive --background",
+        "  # → Job started: a1b2c3  (status: waiting after first turn)",
+        "  specialists result a1b2c3            # read first turn output",
+        '  specialists follow-up a1b2c3 "..."   # send next prompt',
+        "  specialists feed a1b2c3 --follow      # watch response",
+        "",
+        "See also: specialists steer (mid-run redirect)",
+        ""
+      ].join(`
+`));
+      return;
+    }
+    const { run: handler } = await Promise.resolve().then(() => (init_follow_up(), exports_follow_up));
+    return handler();
+  }
   if (sub === "stop") {
     if (wantsHelp()) {
       console.log([
@@ -28952,7 +29704,7 @@ Run 'specialists help' to see available commands.`);
   const server = new SpecialistsServer;
   await server.start();
 }
-run16().catch((error2) => {
+run18().catch((error2) => {
   logger.error(`Fatal error: ${error2}`);
   process.exit(1);
 });