@jaggerxtrm/specialists 3.12.0 → 3.14.0

package/dist/index.js

@@ -5,25 +5,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -10248,7 +10266,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str) {
+    return function time3(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -11014,6 +11032,8 @@ var require_Alias = __commonJS((exports) => {
       });
     }
     resolve(doc2, ctx) {
+      if (ctx?.maxAliasCount === 0)
+        throw new ReferenceError("Alias resolution is disabled");
       let nodes;
       if (ctx?.aliasResolveCache) {
         nodes = ctx.aliasResolveCache;
@@ -11793,6 +11813,7 @@ var require_stringify = __commonJS((exports) => {
       nullStr: "null",
       simpleKeys: false,
       singleQuote: null,
+      trailingComma: false,
       trueStr: "true",
       verifyAliasOrder: true
     }, doc2.schema.toStringOptions, options);
@@ -12062,18 +12083,18 @@ var require_merge = __commonJS((exports) => {
   };
   var isMergeKey = (ctx, key) => (merge2.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge2.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge2.tag && tag.default);
   function addMergeToJSMap(ctx, map2, value) {
-    value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-    if (identity.isSeq(value))
-      for (const it of value.items)
+    const source = resolveAliasValue(ctx, value);
+    if (identity.isSeq(source))
+      for (const it of source.items)
         mergeValue(ctx, map2, it);
-    else if (Array.isArray(value))
-      for (const it of value)
+    else if (Array.isArray(source))
+      for (const it of source)
         mergeValue(ctx, map2, it);
     else
-      mergeValue(ctx, map2, value);
+      mergeValue(ctx, map2, source);
   }
   function mergeValue(ctx, map2, value) {
-    const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+    const source = resolveAliasValue(ctx, value);
     if (!identity.isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
     const srcMap = source.toJSON(null, ctx, Map);
@@ -12094,6 +12115,9 @@ var require_merge = __commonJS((exports) => {
     }
     return map2;
   }
+  function resolveAliasValue(ctx, value) {
+    return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
+  }
   exports.addMergeToJSMap = addMergeToJSMap;
   exports.isMergeKey = isMergeKey;
   exports.merge = merge2;
@@ -12301,13 +12325,20 @@ ${indent}${line}` : `
       if (comment)
         reqNewline = true;
       let str = stringify.stringify(item, itemCtx, () => comment = null);
-      if (i < items.length - 1)
+      reqNewline || (reqNewline = lines.length > linesAtValue || str.includes(`
+`));
+      if (i < items.length - 1) {
         str += ",";
+      } else if (ctx.options.trailingComma) {
+        if (ctx.options.lineWidth > 0) {
+          reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+        }
+        if (reqNewline) {
+          str += ",";
+        }
+      }
       if (comment)
         str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
-      if (!reqNewline && (lines.length > linesAtValue || str.includes(`
-`)))
-        reqNewline = true;
       lines.push(str);
       linesAtValue = lines.length;
     }
@@ -12662,7 +12693,7 @@ var require_stringifyNumber = __commonJS((exports) => {
     if (!isFinite(num))
       return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
     let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
-    if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
+    if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
       let i = n.indexOf(".");
       if (i < 0) {
         i = n.length;
@@ -14887,7 +14918,7 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
           while (next === " " || next === "\t")
             next = source[++i + 1];
         } else if (next === "x" || next === "u" || next === "U") {
-          const length = { x: 2, u: 4, U: 8 }[next];
+          const length = next === "x" ? 2 : next === "u" ? 4 : 8;
           res += parseCharCode(source, i + 1, length, onError);
           i += length;
         } else {
@@ -14956,12 +14987,13 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
     const cc = source.substr(offset, length);
     const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
     const code = ok ? parseInt(cc, 16) : NaN;
-    if (isNaN(code)) {
+    try {
+      return String.fromCodePoint(code);
+    } catch {
       const raw = source.substr(offset - 2, length + 2);
       onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
       return raw;
     }
-    return String.fromCodePoint(code);
   }
   exports.resolveFlowScalar = resolveFlowScalar;
 });
@@ -15102,17 +15134,22 @@ var require_compose_node = __commonJS((exports) => {
       case "block-map":
       case "block-seq":
       case "flow-collection":
-        node = composeCollection.composeCollection(CN, ctx, token, props, onError);
-        if (anchor)
-          node.anchor = anchor.source.substring(1);
+        try {
+          node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+          if (anchor)
+            node.anchor = anchor.source.substring(1);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          onError(token, "RESOURCE_EXHAUSTION", message);
+        }
         break;
       default: {
         const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
         onError(token, "UNEXPECTED_TOKEN", message);
-        node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError);
         isSrcToken = false;
       }
     }
+    node ?? (node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError));
     if (anchor && node.anchor === "")
       onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
     if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
@@ -17524,6 +17561,7 @@ var init_schema = __esm(() => {
     max_retries: numberType().int().min(0).default(0),
     interactive: booleanType().default(false),
     stdout_limit_bytes: numberType().int().positive().optional(),
+    prompt_limit_bytes: numberType().int().positive().optional(),
     response_format: enumType(["text", "json", "markdown"]).default("text"),
     output_type: enumType(["codegen", "analysis", "review", "synthesis", "orchestration", "workflow", "research", "custom"]).default("custom"),
     permission_required: enumType(["READ_ONLY", "LOW", "MEDIUM", "HIGH"]).default("READ_ONLY"),
@@ -19119,8 +19157,8 @@ function resolveCurrentBranch(cwd = process.cwd()) {
 var init_job_root = () => {};
 
 // src/specialist/observability-sqlite.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, statSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, statSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
 function loadBunDatabase() {
   if (_probed)
     return _BunDatabase;
@@ -21183,23 +21221,30 @@ function hasRunCompleteEvent(jobId, cwd = process.cwd()) {
   }
   return false;
 }
-function createObservabilitySqliteClient(cwd = process.cwd()) {
+function openObservabilitySqliteClient(dbPath) {
   if (!loadBunDatabase())
     return null;
-  const location = resolveObservabilityDbLocation(cwd);
-  if (!existsSync5(location.dbPath))
-    return null;
   try {
     const Ctor = loadBunDatabase();
-    const initDb = new Ctor(location.dbPath);
+    const initDb = new Ctor(dbPath);
     initDb.run(`PRAGMA busy_timeout=${BUSY_TIMEOUT_MS}`);
     initSchema(initDb);
     initDb.close();
-    return new SqliteClient(location.dbPath);
+    return new SqliteClient(dbPath);
   } catch {
     return null;
   }
 }
+function createObservabilitySqliteClient(cwd = process.cwd()) {
+  const location = resolveObservabilityDbLocation(cwd);
+  if (!existsSync5(location.dbPath))
+    return null;
+  return openObservabilitySqliteClient(location.dbPath);
+}
+function createObservabilitySqliteClientAtPath(dbPath) {
+  mkdirSync3(dirname3(dbPath), { recursive: true });
+  return openObservabilitySqliteClient(dbPath);
+}
 var _BunDatabase = null, _probed = false, BUSY_TIMEOUT_MS = 5000, MAX_RETRY_ATTEMPTS = 5, BASE_RETRY_DELAY_MS = 50, STALE_CLAIM_AGE_MS = 60000;
 var init_observability_sqlite = __esm(() => {
   init_observability_db();
@@ -21582,24 +21627,27 @@ function readMandatoryRuleSet(cwd, id) {
 }
 function formatMandatoryRulesBlock(sets, inlineRules = []) {
   if (sets.length === 0 && inlineRules.length === 0)
-    return "";
+    return { block: "", sections: [] };
   const sections = [
     ...sets.map((set2) => {
       const rules = set2.rules.map((rule) => `- [${rule.level}] ${rule.text}`).join(`
 `);
-      return `### ${set2.id}
-${rules}`;
+      return { setId: set2.id, block: `### ${set2.id}
+${rules}` };
     }),
     ...inlineRules.length > 0 ? [
-      `### specialist-inline-rules
+      {
+        setId: "specialist-inline-rules",
+        block: `### specialist-inline-rules
 ${inlineRules.map((rule, index) => `- [${rule.level}] ${rule.text}${rule.id ? ` (id: ${rule.id})` : ` (id: inline-${index + 1})`}`).join(`
 `)}`
+      }
     ] : []
   ];
-  return `## MANDATORY_RULES
-${sections.join(`
+  return { block: `## MANDATORY_RULES
+${sections.map((section) => section.block).join(`
 
-`)}`;
+`)}`, sections };
 }
 function collectMandatoryRuleSets(cwd, setIds) {
   const seen = new Set;
@@ -21633,9 +21681,10 @@ function buildMandatoryRulesInjection(specialistConfig) {
     id: "workflow-quick-rules",
     rules: [{ id: "workflow-quick-rules-1", level: "required", text: STATIC_WORKFLOW_RULES_BLOCK.trim().replace(/^##\s+Beads Workflow Quick Rules\n/, "") }]
   }];
-  const block = formatMandatoryRulesBlock([...globals, ...sets], inlineRules);
+  const formatted = formatMandatoryRulesBlock([...globals, ...sets], inlineRules);
   return {
-    block,
+    block: formatted.block,
+    sections: formatted.sections,
     setsLoaded: [...globals.map((set2) => set2.id), ...sets.map((set2) => set2.id)],
     ruleCount: [...globals, ...sets].reduce((count, set2) => count + set2.rules.length, 0) + inlineRules.length,
     inlineRulesCount: inlineRules.length,
@@ -22565,9 +22614,8 @@ ${summaries.join(`
       skillPaths.push(prompt.skill_inherit);
     skillPaths.push(...spec.specialist.skills?.paths ?? []);
     if (mandatoryRulesInjection) {
-      for (const setId of mandatoryRulesInjection.setsLoaded) {
-        payloadComponents.push(measurePayloadComponent("mandatory_rule", setId, `${setId}
-${mandatoryRulesBlock}`));
+      for (const section of mandatoryRulesInjection.sections) {
+        payloadComponents.push(measurePayloadComponent("mandatory_rule", section.setId, section.block));
       }
     }
     for (const skillPath of skillPaths) {
@@ -22983,7 +23031,7 @@ var init_runner = __esm(() => {
 
 // src/specialist/hooks.ts
 import { appendFile, mkdir } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 
 class HookEmitter {
   tracePath;
@@ -22991,7 +23039,7 @@ class HookEmitter {
   ready;
   constructor(options) {
     this.tracePath = options.tracePath;
-    this.ready = mkdir(dirname3(options.tracePath), { recursive: true }).then(() => {});
+    this.ready = mkdir(dirname4(options.tracePath), { recursive: true }).then(() => {});
   }
   async emit(hook, invocationId, specialistName, specialistVersion, payload) {
     await this.ready;
@@ -23045,11 +23093,11 @@ __export(exports_version, {
 });
 import { createRequire } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname5, join as join7 } from "path";
 import { existsSync as existsSync8 } from "fs";
 async function run2() {
   const req = createRequire(import.meta.url);
-  const here = dirname4(fileURLToPath2(import.meta.url));
+  const here = dirname5(fileURLToPath2(import.meta.url));
   const bundlePkgPath = join7(here, "..", "package.json");
   const sourcePkgPath = join7(here, "..", "..", "package.json");
   let pkg;
@@ -24179,7 +24227,7 @@ import {
   closeSync,
   existsSync as existsSync10,
   fsyncSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   openSync,
   readdirSync as readdirSync2,
   readFileSync as readFileSync8,
@@ -24616,7 +24664,7 @@ class Supervisor {
     return join9(this.resolvedJobsDir, "..", "ready");
   }
   writeReadyMarker(id) {
-    mkdirSync3(this.readyDir(), { recursive: true });
+    mkdirSync4(this.readyDir(), { recursive: true });
     writeFileSync3(join9(this.readyDir(), id), "", "utf-8");
   }
   withComputedLiveness(status) {
@@ -24747,7 +24795,7 @@ class Supervisor {
     if (!this.isJobFileOutputEnabled)
       return;
     const normalizedStatus = this.withStatusLineageDefaults(id, data);
-    mkdirSync3(this.jobDir(id), { recursive: true });
+    mkdirSync4(this.jobDir(id), { recursive: true });
     const path = this.statusPath(id);
     const tmp = path + ".tmp";
     writeFileSync3(tmp, JSON.stringify(normalizedStatus, null, 2), "utf-8");
@@ -24909,8 +24957,8 @@ class Supervisor {
     const id = crypto.randomUUID().slice(0, 6);
     const dir = this.jobDir(id);
     const startedAtMs = Date.now();
-    mkdirSync3(dir, { recursive: true });
-    mkdirSync3(this.readyDir(), { recursive: true });
+    mkdirSync4(dir, { recursive: true });
+    mkdirSync4(this.readyDir(), { recursive: true });
     const nodeId = runOptions.variables?.node_id ?? runOptions.variables?.SPECIALISTS_NODE_ID;
     const variablesKeys = Object.keys(runOptions.variables ?? {});
     const activatedSkills = (runOptions.variables?.activated_skills ?? runOptions.variables?.skills_activated ?? "").split(",").map((skill) => skill.trim()).filter((skill) => skill.length > 0);
@@ -25188,7 +25236,7 @@ ${appendError}
       try {
         const output = await resumeFn(task);
         latestOutput = output;
-        mkdirSync3(this.jobDir(id), { recursive: true });
+        mkdirSync4(this.jobDir(id), { recursive: true });
         writeFileSync3(this.resultPath(id), output, "utf-8");
         try {
           this.withSqliteOperation("upsertResult:resume_turn", (client) => client.upsertResult(id, output));
@@ -25596,7 +25644,7 @@ ${appendError}
       });
       latestOutput = result.output;
       if (this.isJobFileOutputEnabled) {
-        mkdirSync3(this.jobDir(id), { recursive: true });
+        mkdirSync4(this.jobDir(id), { recursive: true });
         writeFileSync3(this.resultPath(id), latestOutput, "utf-8");
       }
       const elapsed = Math.round((Date.now() - startedAtMs) / 1000);
@@ -26584,9 +26632,9 @@ var exports_init = {};
 __export(exports_init, {
   run: () => run7
 });
-import { copyFileSync, cpSync, existsSync as existsSync12, lstatSync, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync10, readlinkSync, renameSync as renameSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { copyFileSync, cpSync, existsSync as existsSync12, lstatSync, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync10, readlinkSync, renameSync as renameSync2, symlinkSync, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { spawnSync as spawnSync9 } from "child_process";
-import { basename as basename4, dirname as dirname5, join as join11, relative, resolve as resolve6 } from "path";
+import { basename as basename4, dirname as dirname6, join as join11, relative, resolve as resolve6 } from "path";
 function ok(msg) {
   console.log(`  ${green4("\u2713")} ${msg}`);
 }
@@ -26640,7 +26688,7 @@ function migrateLegacySpecialists(cwd, scope) {
     return;
   const targetDir = join11(cwd, ".specialists", scope);
   if (!existsSync12(targetDir)) {
-    mkdirSync4(targetDir, { recursive: true });
+    mkdirSync5(targetDir, { recursive: true });
   }
   const files = readdirSync4(sourceDir).filter((f) => f.endsWith(".specialist.json") || f.endsWith(".specialist.json"));
   if (files.length === 0)
@@ -26677,7 +26725,7 @@ function copyCanonicalSpecialists(cwd) {
     return;
   }
   if (!existsSync12(targetDir)) {
-    mkdirSync4(targetDir, { recursive: true });
+    mkdirSync5(targetDir, { recursive: true });
   }
   let copied = 0;
   let refreshed = 0;
@@ -26712,7 +26760,7 @@ function copyCanonicalMandatoryRules(cwd) {
     return;
   }
   if (!existsSync12(targetDir)) {
-    mkdirSync4(targetDir, { recursive: true });
+    mkdirSync5(targetDir, { recursive: true });
   }
   let copied = 0;
   let refreshed = 0;
@@ -26747,7 +26795,7 @@ function copyCanonicalNodeConfigs(cwd) {
     return;
   }
   if (!existsSync12(targetDir)) {
-    mkdirSync4(targetDir, { recursive: true });
+    mkdirSync5(targetDir, { recursive: true });
   }
   let copied = 0;
   let refreshed = 0;
@@ -26783,8 +26831,8 @@ function installProjectHooks(cwd) {
     skip("no hook files found in package");
     return;
   }
-  mkdirSync4(targetDir, { recursive: true });
-  mkdirSync4(claudeHooksDir, { recursive: true });
+  mkdirSync5(targetDir, { recursive: true });
+  mkdirSync5(claudeHooksDir, { recursive: true });
   let copied = 0;
   let skippedCopies = 0;
   let linked = 0;
@@ -26809,7 +26857,7 @@ function installProjectHooks(cwd) {
         rewiredLinks++;
         continue;
       }
-      const currentTarget = resolve6(dirname5(claudeHookPath), readlinkSync(claudeHookPath));
+      const currentTarget = resolve6(dirname6(claudeHookPath), readlinkSync(claudeHookPath));
       if (currentTarget !== xtrmDest) {
         unlinkSync(claudeHookPath);
         symlinkSync(relativeTarget, claudeHookPath);
@@ -26837,7 +26885,7 @@ function ensureProjectHookWiring(cwd) {
   const settingsPath = join11(cwd, ".claude", "settings.json");
   const settingsDir = join11(cwd, ".claude");
   if (!existsSync12(settingsDir)) {
-    mkdirSync4(settingsDir, { recursive: true });
+    mkdirSync5(settingsDir, { recursive: true });
   }
   const settings = loadJson(settingsPath, {});
   if (!settings.hooks || typeof settings.hooks !== "object") {
@@ -26873,10 +26921,10 @@ function ensureProjectHookWiring(cwd) {
 }
 function ensureRootSymlink(rootPath, expectedTargetPath) {
   if (!existsSync12(rootPath)) {
-    mkdirSync4(dirname5(rootPath), { recursive: true });
-    const relTarget = relative(dirname5(rootPath), expectedTargetPath);
+    mkdirSync5(dirname6(rootPath), { recursive: true });
+    const relTarget = relative(dirname6(rootPath), expectedTargetPath);
     symlinkSync(relTarget, rootPath);
-    ok(`created ${basename4(dirname5(rootPath))}/${basename4(rootPath)} \u2192 ${relTarget}`);
+    ok(`created ${basename4(dirname6(rootPath))}/${basename4(rootPath)} \u2192 ${relTarget}`);
     return;
   }
   const stats = lstatSync(rootPath);
@@ -26884,7 +26932,7 @@ function ensureRootSymlink(rootPath, expectedTargetPath) {
     throw new Error(`${rootPath} must be a symlink to ${expectedTargetPath}. Aborting.`);
   }
   const linkTarget = readlinkSync(rootPath);
-  const resolvedTarget = resolve6(dirname5(rootPath), linkTarget);
+  const resolvedTarget = resolve6(dirname6(rootPath), linkTarget);
   const resolvedExpected = resolve6(expectedTargetPath);
   if (resolvedTarget === resolvedExpected) {
     return;
@@ -26895,9 +26943,9 @@ function ensureRootSymlink(rootPath, expectedTargetPath) {
   ];
   if (legacyTargets.includes(resolvedTarget)) {
     unlinkSync(rootPath);
-    const relTarget = relative(dirname5(rootPath), expectedTargetPath);
+    const relTarget = relative(dirname6(rootPath), expectedTargetPath);
     symlinkSync(relTarget, rootPath);
-    ok(`rewired ${basename4(dirname5(rootPath))}/${basename4(rootPath)} \u2192 ${relTarget}`);
+    ok(`rewired ${basename4(dirname6(rootPath))}/${basename4(rootPath)} \u2192 ${relTarget}`);
     return;
   }
   throw new Error(`${rootPath} points to ${linkTarget}, expected ${expectedTargetPath}. Aborting.`);
@@ -26918,7 +26966,7 @@ function ensureActiveSkillSymlink(defaultSkillPath, activeLinkPath) {
   if (!stats.isSymbolicLink()) {
     throw new Error(`${activeLinkPath} already exists and is not a symlink.`);
   }
-  const currentTarget = resolve6(dirname5(activeLinkPath), readlinkSync(activeLinkPath));
+  const currentTarget = resolve6(dirname6(activeLinkPath), readlinkSync(activeLinkPath));
   if (currentTarget !== resolve6(defaultSkillPath)) {
     throw new Error(`${activeLinkPath} points to an unexpected target.`);
   }
@@ -26940,8 +26988,8 @@ function installProjectSkills(cwd, syncSkills) {
   }
   const defaultRoot = join11(cwd, ".xtrm", "skills", "default");
   const activeRoot = join11(cwd, ".xtrm", "skills", "active");
-  mkdirSync4(defaultRoot, { recursive: true });
-  mkdirSync4(activeRoot, { recursive: true });
+  mkdirSync5(defaultRoot, { recursive: true });
+  mkdirSync5(activeRoot, { recursive: true });
   ensureRootSymlink(join11(cwd, ".claude", "skills"), activeRoot);
   ensureRootSymlink(join11(cwd, ".pi", "skills"), activeRoot);
   let copied = 0;
@@ -26972,7 +27020,7 @@ function createSpecialistsDirs(cwd) {
   let created = 0;
   for (const dir of [defaultDir, userDir]) {
     if (!existsSync12(dir)) {
-      mkdirSync4(dir, { recursive: true });
+      mkdirSync5(dir, { recursive: true });
       created++;
     }
   }
@@ -26988,7 +27036,7 @@ function createRuntimeDirs(cwd) {
   let created = 0;
   for (const dir of runtimeDirs) {
     if (!existsSync12(dir)) {
-      mkdirSync4(dir, { recursive: true });
+      mkdirSync5(dir, { recursive: true });
       created++;
     }
   }
@@ -27121,7 +27169,7 @@ function validateInitPostconditions(cwd) {
       continue;
     }
     const expectedTarget = resolve6(xtrmHooksDir, hookFile);
-    const resolvedTarget = resolve6(dirname5(claudeHookPath), readlinkSync(claudeHookPath));
+    const resolvedTarget = resolve6(dirname6(claudeHookPath), readlinkSync(claudeHookPath));
     if (resolvedTarget !== expectedTarget) {
       warnings.push(`.claude/hooks/${hookFile} points to unexpected target`);
     }
@@ -27175,7 +27223,7 @@ function validateInitPostconditions(cwd) {
       warnings.push(`${relative(cwd, symlink.linkPath)} is not a symlink`);
       continue;
     }
-    const resolvedTarget = resolve6(dirname5(symlink.linkPath), readlinkSync(symlink.linkPath));
+    const resolvedTarget = resolve6(dirname6(symlink.linkPath), readlinkSync(symlink.linkPath));
     if (resolvedTarget !== resolve6(symlink.expectedTarget)) {
       warnings.push(`${relative(cwd, symlink.linkPath)} points to an unexpected target`);
     }
@@ -27352,8 +27400,8 @@ var exports_db = {};
 __export(exports_db, {
   run: () => run9
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readdirSync as readdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname6, join as join12, resolve as resolve7 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, join as join12, resolve as resolve7 } from "path";
 function formatBytes(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
@@ -28013,8 +28061,8 @@ function runBenchmarkExport(options) {
       });
     }
     rows.sort((a, b) => a.task_id.localeCompare(b.task_id) || a.executor_job_id.localeCompare(b.executor_job_id));
-    const outputDirectory = dirname6(options.outputPath);
-    mkdirSync5(outputDirectory, { recursive: true });
+    const outputDirectory = dirname7(options.outputPath);
+    mkdirSync6(outputDirectory, { recursive: true });
     const jsonl = rows.map((row) => JSON.stringify(row)).join(`
 `);
     writeFileSync5(options.outputPath, rows.length > 0 ? `${jsonl}
@@ -28105,6 +28153,19 @@ var init_db = __esm(() => {
 import { spawn as spawn3 } from "child_process";
 import { createHash as createHash3, randomUUID } from "crypto";
 import { readFileSync as readFileSync12 } from "fs";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve8 } from "path";
+function isPathWithinRoot(candidatePath, rootPath) {
+  const candidate = resolve8(candidatePath);
+  const root = resolve8(rootPath);
+  const rel = relative2(root, candidate);
+  return rel === "" || rel.length > 0 && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+function assertSkillPathWithinRoots(field, path, roots) {
+  const allowed = roots.some((root) => isPathWithinRoot(path, root));
+  if (!allowed) {
+    throw new CompatGuardError(field, `skill path '${path}' not under any --allow-skills-roots entry`);
+  }
+}
 function hasUnsubstitutedVariables(template, variables) {
   const matches = template.match(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g) ?? [];
   for (const match of matches) {
@@ -28123,8 +28184,8 @@ function compatGuard(spec, trust) {
   if (execution.permission_required !== "READ_ONLY")
     throw new CompatGuardError("execution.permission_required", "permission_required must be READ_ONLY");
   const hasScripts = (spec.specialist.skills?.scripts?.length ?? 0) > 0;
-  if (hasScripts && !trust?.allowLocalScripts) {
-    throw new CompatGuardError("skills.scripts", "scripts not allowed (enable with --allow-local-scripts)");
+  if (hasScripts) {
+    throw new CompatGuardError("skills.scripts", "local scripts are not supported in script-class specialists");
   }
   const hasPaths = (spec.specialist.skills?.paths?.length ?? 0) > 0;
   const hasSkillInherit = Boolean(spec.specialist.prompt.skill_inherit);
@@ -28134,26 +28195,34 @@ function compatGuard(spec, trust) {
   if (hasSkillInherit && !trust?.allowSkills) {
     throw new CompatGuardError("prompt.skill_inherit", "skills not allowed (enable with --allow-skills)");
   }
-  if (hasPaths && trust?.allowSkills && trust.allowSkillsRoots && trust.allowSkillsRoots.length > 0) {
+  if (trust?.allowSkills && trust.allowSkillsRoots && trust.allowSkillsRoots.length > 0) {
     const paths = spec.specialist.skills?.paths ?? [];
-    for (const path of paths) {
-      const allowed = trust.allowSkillsRoots.some((root) => path.startsWith(root));
-      if (!allowed) {
-        throw new CompatGuardError("skills.paths", `skill path '${path}' not under any --allow-skills-roots entry`);
-      }
+    for (const path of paths)
+      assertSkillPathWithinRoots("skills.paths", path, trust.allowSkillsRoots);
+    if (typeof spec.specialist.prompt.skill_inherit === "string") {
+      assertSkillPathWithinRoots("prompt.skill_inherit", spec.specialist.prompt.skill_inherit, trust.allowSkillsRoots);
     }
   }
 }
+function collectSkillPathEntries(spec) {
+  return [
+    ...(spec.specialist.skills?.paths ?? []).map((path) => ({ path, source: "skills.paths" })),
+    ...typeof spec.specialist.prompt.skill_inherit === "string" ? [{ path: spec.specialist.prompt.skill_inherit, source: "prompt.skill_inherit" }] : []
+  ];
+}
+function collectSkillPaths(spec) {
+  return collectSkillPathEntries(spec).map((entry) => entry.path);
+}
 function computeSkillSources(spec) {
-  const paths = spec.specialist.skills?.paths ?? [];
+  const entries = collectSkillPathEntries(spec);
   const sources = [];
-  for (const path of paths) {
+  for (const { path, source } of entries) {
     try {
       const content = readFileSync12(path);
       const sha256 = createHash3("sha256").update(content).digest("hex");
-      sources.push({ path, sha256 });
+      sources.push({ path, sha256, source });
     } catch {
-      sources.push({ path, sha256: "unreadable" });
+      sources.push({ path, sha256: "unreadable", source });
     }
   }
   return sources;
@@ -28164,6 +28233,34 @@ function renderTaskTemplate(template, variables) {
     throw new Error(`Missing template variable: ${missing}`);
   return renderTemplate(template, variables);
 }
+function truncateForPrompt(value, limitBytes) {
+  if (Buffer.byteLength(value, "utf8") <= limitBytes)
+    return value;
+  return `${value.slice(0, limitBytes)}
+... truncated ...`;
+}
+function buildJsonOutputContract(spec) {
+  if (spec.specialist.execution.response_format !== "json")
+    return;
+  const schema = spec.specialist.prompt.output_schema;
+  const required2 = Array.isArray(schema?.required) ? schema.required.filter((value) => typeof value === "string") : [];
+  const lines = [
+    "Output contract:",
+    "- Return only valid JSON. Do not include Markdown fences, prose, or commentary."
+  ];
+  if (required2.length > 0)
+    lines.push(`- Include these required top-level keys: ${required2.join(", ")}.`);
+  if (schema)
+    lines.push(`- JSON schema: ${truncateForPrompt(JSON.stringify(schema), 4096)}`);
+  return lines.join(`
+`);
+}
+function applyOutputContract(prompt, spec) {
+  const contract = buildJsonOutputContract(spec);
+  return contract ? `${prompt}
+
+${contract}` : prompt;
+}
 function mapErrorType(message) {
   if (message.includes("Specialist not found"))
     return "specialist_not_found";
@@ -28171,6 +28268,8 @@ function mapErrorType(message) {
     return "specialist_load_error";
   if (message.includes("Missing template variable"))
     return "template_variable_missing";
+  if (message.includes("prompt too large"))
+    return "prompt_too_large";
   if (message.includes("output too large"))
     return "output_too_large";
   if (message.includes("auth") || message.includes("403") || message.includes("401"))
@@ -28238,6 +28337,18 @@ function writeTraceRow(client, specialist, model, traceId, output2, durationMs,
     onAuditFailure?.(error2);
   }
 }
+function resolvePromptLimitBytes(spec) {
+  return spec.specialist.execution.prompt_limit_bytes ?? resolveEnvPromptLimitBytes() ?? DEFAULT_PROMPT_LIMIT_BYTES;
+}
+function resolveEnvPromptLimitBytes() {
+  const raw = process.env.SPECIALISTS_SCRIPT_PROMPT_LIMIT_BYTES;
+  if (raw === undefined)
+    return;
+  const envLimit = Number(raw);
+  if (!Number.isFinite(envLimit) || envLimit <= 0)
+    return;
+  return Math.floor(envLimit);
+}
 function resolveAssistantTextLimitBytes(spec) {
   return spec.specialist.execution.stdout_limit_bytes ?? resolveEnvAssistantTextLimitBytes() ?? DEFAULT_ASSISTANT_TEXT_LIMIT_BYTES;
 }
@@ -28253,8 +28364,9 @@ function resolveEnvAssistantTextLimitBytes() {
   return Math.floor(envLimit);
 }
 function openObservabilityClient(options) {
-  const dbPath = options.observabilityDbPath ?? options.projectDir;
-  return createObservabilitySqliteClient(dbPath);
+  if (options.observabilityDbPath)
+    return createObservabilitySqliteClientAtPath(options.observabilityDbPath);
+  return createObservabilitySqliteClient(options.projectDir);
 }
 function resolveScriptSpecialistName(name) {
   if (name === "changelog-keeper")
@@ -28268,9 +28380,28 @@ async function runScriptSpecialist(input2, options) {
     const resolvedSpecialist = resolveScriptSpecialistName(input2.specialist);
     const spec = await options.loader.get(resolvedSpecialist);
     compatGuard(spec, options.trust);
+    const skillPaths = options.trust?.allowSkills ? collectSkillPaths(spec) : [];
     const skillSources = options.trust?.allowSkills ? computeSkillSources(spec) : undefined;
     const template = input2.template ?? spec.specialist.prompt.task_template;
-    const prompt = renderTaskTemplate(template, input2.variables ?? {});
+    const prompt = applyOutputContract(renderTaskTemplate(template, input2.variables ?? {}), spec);
+    const modelCandidates = collectModelCandidates(input2, spec, options);
+    const promptLimitBytes = resolvePromptLimitBytes(spec);
+    const promptBytes = Buffer.byteLength(prompt, "utf8");
+    if (promptBytes > promptLimitBytes) {
+      return {
+        success: false,
+        error: `prompt too large: ${promptBytes} bytes exceeds limit ${promptLimitBytes} bytes`,
+        error_type: "prompt_too_large",
+        meta: {
+          specialist: resolvedSpecialist,
+          requested_specialist: input2.requested_specialist ?? input2.specialist,
+          resolved_specialist: resolvedSpecialist,
+          model: modelCandidates[0],
+          duration_ms: Date.now() - startedAt,
+          trace_id: traceId
+        }
+      };
+    }
     if (process.env.SPECIALISTS_SCRIPT_STUB_OUTPUT) {
       return {
         success: true,
@@ -28286,11 +28417,11 @@ async function runScriptSpecialist(input2, options) {
       };
     }
     const timeoutMs = input2.timeout_ms ?? spec.specialist.execution.timeout_ms ?? 120000;
-    const modelCandidates = collectModelCandidates(input2, spec, options);
     const assistantTextLimitBytes = resolveAssistantTextLimitBytes(spec);
     const attempts = [];
     for (const model of modelCandidates) {
-      const attempt = await runSingleAttempt(prompt, model, input2.thinking_level ?? spec.specialist.execution.thinking_level, timeoutMs, assistantTextLimitBytes, options);
+      const systemPrompt = spec.specialist.prompt.system || undefined;
+      const attempt = await runSingleAttempt(prompt, model, input2.thinking_level ?? spec.specialist.execution.thinking_level, timeoutMs, assistantTextLimitBytes, options, systemPrompt, skillPaths);
       attempts.push(attempt);
       const parsed = classifyAttempt(attempt);
       if (parsed.retryable)
@@ -28333,14 +28464,23 @@ function collectModelCandidates(input2, spec, options) {
   const candidates = [input2.model_override, spec.specialist.execution.model, spec.specialist.execution.fallback_model, options.fallbackModel].filter((value) => typeof value === "string" && value.length > 0);
   return [...new Set(candidates)];
 }
-function runSingleAttempt(prompt, model, thinkingLevel, timeoutMs, assistantTextLimitBytes, options) {
-  return new Promise((resolve8, reject) => {
-    const args = ["--mode", "json", "--no-session", "--no-extensions", "--no-tools", "--model", model];
+function runSingleAttempt(prompt, model, thinkingLevel, timeoutMs, assistantTextLimitBytes, options, systemPrompt, skillPaths = []) {
+  return new Promise((resolve9, reject) => {
+    const args = ["--mode", "json", "--no-session", "--no-extensions", "--no-tools", "--offline", "--no-context-files", "--no-prompt-templates", "--no-themes"];
+    if (skillPaths.length === 0)
+      args.push("--no-skills");
+    for (const skillPath of skillPaths)
+      args.push("--skill", skillPath);
+    args.push("--model", model);
     if (thinkingLevel)
       args.push("--thinking", thinkingLevel);
-    args.push(prompt);
-    const pi = spawn3("pi", args, { stdio: ["ignore", "pipe", "pipe"] });
+    if (systemPrompt)
+      args.push("--system-prompt", systemPrompt);
+    const pi = spawn3("pi", args, { stdio: ["pipe", "pipe", "pipe"], cwd: options.projectDir ?? process.cwd() });
     options.onChild?.(pi);
+    pi.stdin?.on("error", () => {});
+    pi.stdin?.write(prompt);
+    pi.stdin?.end();
     let stderr = "";
     let timedOut = false;
     let outputTooLarge = false;
@@ -28409,7 +28549,7 @@ function runSingleAttempt(prompt, model, thinkingLevel, timeoutMs, assistantText
     pi.on("error", reject);
     pi.on("close", (code) => {
       clearTimeout(timer);
-      resolve8({
+      resolve9({
         model,
         text: assistantText,
         stderr,
@@ -28446,7 +28586,7 @@ function classifyAttempt(attempt) {
 function isRetryableModelFailure(stderr, text) {
   return stderr.includes("0 tokens") || stderr.includes("quota") || stderr.includes("rate limit") || stderr.includes("403") || stderr.includes("401") || stderr.includes("insufficient_quota") || !text && !stderr.trim();
 }
-var CompatGuardError, DEFAULT_PENDING_LINE_LIMIT_BYTES, DEFAULT_ASSISTANT_TEXT_LIMIT_BYTES, DEFAULT_STDERR_LIMIT_BYTES;
+var CompatGuardError, DEFAULT_PENDING_LINE_LIMIT_BYTES, DEFAULT_ASSISTANT_TEXT_LIMIT_BYTES, DEFAULT_STDERR_LIMIT_BYTES, DEFAULT_PROMPT_LIMIT_BYTES;
 var init_script_runner = __esm(() => {
   init_observability_sqlite();
   CompatGuardError = class CompatGuardError extends Error {
@@ -28460,6 +28600,7 @@ var init_script_runner = __esm(() => {
   DEFAULT_PENDING_LINE_LIMIT_BYTES = 16 * 1024 * 1024;
   DEFAULT_ASSISTANT_TEXT_LIMIT_BYTES = 4 * 1024 * 1024;
   DEFAULT_STDERR_LIMIT_BYTES = 1 * 1024 * 1024;
+  DEFAULT_PROMPT_LIMIT_BYTES = 4 * 1024 * 1024;
 });
 
 // src/cli/validate.ts
@@ -28612,7 +28753,7 @@ var exports_edit = {};
 __export(exports_edit, {
   run: () => run11
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
 import { join as join13 } from "path";
 function loadPresets() {
   const paths = [
@@ -29050,7 +29191,7 @@ function createUserFork(source, targetName) {
   if (source.scope === "user")
     return source;
   const targetDir = join13(process.cwd(), ".specialists", "user");
-  mkdirSync6(targetDir, { recursive: true });
+  mkdirSync7(targetDir, { recursive: true });
   const targetFile = join13(targetDir, `${targetName}.specialist.json`);
   const doc2 = readJsonFile2(source.filePath);
   doc2.specialist = doc2.specialist ?? {};
@@ -29360,7 +29501,7 @@ __export(exports_config, {
 });
 import { readFileSync as readFileSync14 } from "fs";
 import { spawnSync as spawnSync10 } from "child_process";
-import { dirname as dirname7, join as join15 } from "path";
+import { dirname as dirname8, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function usage2() {
   return [
@@ -29406,7 +29547,7 @@ function getGitTopLevel(projectDir) {
   return result.stdout.trim() || undefined;
 }
 function getRuntimePackageVersion() {
-  const runtimeDir = dirname7(fileURLToPath3(import.meta.url));
+  const runtimeDir = dirname8(fileURLToPath3(import.meta.url));
   const packageJsonPath = runtimeDir.includes("/dist/") ? join15(runtimeDir, "..", "package.json") : join15(runtimeDir, "..", "..", "package.json");
   return readPackageVersion(packageJsonPath);
 }
@@ -29545,8 +29686,8 @@ var init_config = __esm(() => {
 });
 
 // src/specialist/worktree.ts
-import { existsSync as existsSync16, symlinkSync as symlinkSync2, mkdirSync as mkdirSync7 } from "fs";
-import { join as join16, resolve as resolve8 } from "path";
+import { existsSync as existsSync16, symlinkSync as symlinkSync2, mkdirSync as mkdirSync8 } from "fs";
+import { join as join16, resolve as resolve9 } from "path";
 import { spawnSync as spawnSync11, execFileSync as execFileSync2 } from "child_process";
 function deriveBranchName(beadId, specialistName) {
   return `feature/${beadId}-${slugify(specialistName)}`;
@@ -29579,11 +29720,11 @@ function provisionWorktree(options) {
   const branch = deriveBranchName(options.beadId, options.specialistName);
   const existingPath = findExistingWorktree(branch, cwd);
   if (existingPath) {
-    return { branch, worktreePath: resolve8(existingPath), reused: true };
+    return { branch, worktreePath: resolve9(existingPath), reused: true };
   }
   const worktreeBase = options.worktreeBase ?? join16(commonRoot, ".worktrees", options.beadId);
   const worktreeName = deriveWorktreeName(options.beadId, options.specialistName);
-  const worktreePath = resolve8(join16(worktreeBase, worktreeName));
+  const worktreePath = resolve9(join16(worktreeBase, worktreeName));
   createWorktreeViaBd(worktreePath, branch, commonRoot);
   symlinkPiNpmCache(commonRoot, worktreePath);
   return { branch, worktreePath, reused: false };
@@ -29594,7 +29735,7 @@ function symlinkPiNpmCache(commonRoot, worktreePath) {
   if (!existsSync16(source) || existsSync16(target))
     return;
   try {
-    mkdirSync7(join16(worktreePath, ".pi"), { recursive: true });
+    mkdirSync8(join16(worktreePath, ".pi"), { recursive: true });
     symlinkSync2(source, target);
   } catch {}
 }
@@ -29634,12 +29775,12 @@ var init_worktree = __esm(() => {
 });
 
 // src/specialist/epic-reconciler.ts
-import { mkdirSync as mkdirSync8, openSync as openSync2, readFileSync as readFileSync15, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync9, openSync as openSync2, readFileSync as readFileSync15, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
 import { join as join17 } from "path";
 function buildEpicLockPath(epicId) {
   const location = resolveObservabilityDbLocation();
   const lockDir = join17(location.dbDirectory, "locks");
-  mkdirSync8(lockDir, { recursive: true });
+  mkdirSync9(lockDir, { recursive: true });
   return join17(lockDir, `epic-${epicId}.lock`);
 }
 function withEpicAdvisoryLock(epicId, action) {
@@ -30981,13 +31122,13 @@ async function parseArgs7(argv) {
     process.exit(1);
   }
   if (!prompt && !beadId && !process.stdin.isTTY) {
-    prompt = await new Promise((resolve9) => {
+    prompt = await new Promise((resolve10) => {
       let buf = "";
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (chunk) => {
         buf += chunk;
       });
-      process.stdin.on("end", () => resolve9(buf.trim()));
+      process.stdin.on("end", () => resolve10(buf.trim()));
     });
   }
   if (!prompt && !beadId && !reuseJobId) {
@@ -31105,7 +31246,7 @@ function resolveWorkingDirectory(args, jobsDir, permissionRequired, readStatus)
   if (args.reuseJobId !== undefined) {
     const targetStatus = readStatus(args.reuseJobId);
     if (!targetStatus) {
-      console.error(`Error: cannot read status for job '${args.reuseJobId}'. ` + `Check the job id with: specialists poll ${args.reuseJobId} --json`);
+      console.error(`Error: cannot read status for job '${args.reuseJobId}'. ` + `Check the job id with: specialists ps ${args.reuseJobId} --json`);
       process.exit(1);
     }
     const targetJobStatus = targetStatus.status;
@@ -31553,7 +31694,9 @@ ${bold11(`Running ${cyan6(args.name)}`)}
 ${green9("\u2713")} ${footer}
 
 `);
-  process.stderr.write(dim9(`Poll: specialists poll ${jobId} --json
+  process.stderr.write(dim9(`Status: specialists ps ${jobId} --json
+`));
+  process.stderr.write(dim9(`Events: specialists feed ${jobId}
 
 `));
   process.exit(0);
@@ -31658,8 +31801,8 @@ class JobControl {
       }
     };
     let resolveJobId;
-    const jobIdPromise = new Promise((resolve9) => {
-      resolveJobId = resolve9;
+    const jobIdPromise = new Promise((resolve10) => {
+      resolveJobId = resolve10;
     });
     this.supervisor = new Supervisor({
       runner: this.runner,
@@ -31724,7 +31867,7 @@ class JobControl {
       if (deadline !== undefined && Date.now() >= deadline) {
         throw new Error(`Timed out waiting for terminal status for job ${jobId}`);
       }
-      await new Promise((resolve9) => setTimeout(resolve9, backoffMs));
+      await new Promise((resolve10) => setTimeout(resolve10, backoffMs));
       backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
     }
   }
@@ -31903,7 +32046,7 @@ function hashOutput(output2, salt) {
   return createHash4("sha256").update(value).digest("hex");
 }
 function sleep2(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 function toContextHealth(contextPct) {
   if (contextPct === null)
@@ -33819,7 +33962,7 @@ __export(exports_node, {
 import { existsSync as existsSync19, readFileSync as readFileSync19, readdirSync as readdirSync7 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawnSync as spawnSync14 } from "child_process";
-import { basename as basename5, join as join21, resolve as resolve9 } from "path";
+import { basename as basename5, join as join21, resolve as resolve10 } from "path";
 function parseNodeArgs(argv) {
   const command = argv[0];
   const supportedCommands = new Set(["run", "list", "promote", "members", "memory", "stop", "spawn-member", "create-bead", "complete", "wait-phase"]);
@@ -34008,7 +34151,7 @@ function toNodeName(filePath) {
 function discoverNodeConfigs(cwd) {
   const discoveredByName = new Map;
   for (const directory of NODE_DISCOVERY_DIRS) {
-    const absoluteDir = resolve9(cwd, directory.path);
+    const absoluteDir = resolve10(cwd, directory.path);
     if (!existsSync19(absoluteDir))
       continue;
     const files = readdirSync7(absoluteDir).filter((fileName) => fileName.endsWith(NODE_CONFIG_SUFFIX));
@@ -34030,7 +34173,7 @@ function getNodeDiscoverySummary() {
 `);
 }
 function resolveNodeConfigPath(cwd, input2) {
-  const explicitPath = resolve9(cwd, input2);
+  const explicitPath = resolve10(cwd, input2);
   if (existsSync19(explicitPath)) {
     return { name: toNodeName(explicitPath), path: explicitPath, source: "repo" };
   }
@@ -34583,7 +34726,7 @@ async function handleNodeAction(args) {
           if (deadline !== null && Date.now() >= deadline) {
             throw new Error(`Timed out waiting for phase '${args.phaseId}' members: ${memberKeys.join(", ")}`);
           }
-          await new Promise((resolve10) => setTimeout(resolve10, 500));
+          await new Promise((resolve11) => setTimeout(resolve11, 500));
         }
       } finally {
         sqliteClient.close();
@@ -35455,9 +35598,19 @@ var init_epic = __esm(() => {
 
 // src/cli/version-check.ts
 import { spawnSync as spawnSync16 } from "child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join22 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname9, join as join22 } from "path";
 import { createRequire as createRequire3 } from "module";
+function readBundledPackageVersion(requireFn = require3) {
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      const pkg = requireFn(candidate);
+      if (typeof pkg.version === "string" && pkg.version.length > 0)
+        return pkg.version;
+    } catch {}
+  }
+  return "0.0.0";
+}
 function shouldRunVersionCheck() {
   if (process.env.SPECIALISTS_OFFLINE === "1")
     return false;
@@ -35480,7 +35633,7 @@ function readCachedVersionCheck() {
   return readCache();
 }
 function writeCache(cache) {
-  mkdirSync9(dirname8(CACHE_PATH), { recursive: true });
+  mkdirSync10(dirname9(CACHE_PATH), { recursive: true });
   writeFileSync9(CACHE_PATH, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
@@ -35565,7 +35718,7 @@ function markVersionCheckNotified(result) {
 var require3, packageVersion, localVersion, CACHE_PATH, CACHE_MAX_AGE_MS2, NETWORK_TIMEOUT_MS = 2000;
 var init_version_check = __esm(() => {
   require3 = createRequire3(import.meta.url);
-  ({ version: packageVersion } = require3("../../package.json"));
+  packageVersion = readBundledPackageVersion();
   localVersion = packageVersion;
   CACHE_PATH = join22(process.cwd(), ".specialists", "version-check.json");
   CACHE_MAX_AGE_MS2 = 6 * 60 * 60 * 1000;
@@ -37382,9 +37535,6 @@ function readJobEvents(jobDir) {
   events.sort(compareTimelineEvents);
   return events;
 }
-function readJobEventsById(jobsDir, jobId) {
-  return readJobEvents(join26(jobsDir, jobId));
-}
 function readAllJobEvents(jobsDir) {
   const sqliteClient = createObservabilitySqliteClient();
   try {
@@ -38056,7 +38206,7 @@ async function followMerged(sqliteClient, jobsDir, options) {
   }
   const lastPrintedEventKey = new Map;
   const seenMetaKey = new Map;
-  await new Promise((resolve10) => {
+  await new Promise((resolve11) => {
     const interval = setInterval(() => {
       const currentJobIds = listMatchingJobIds(sqliteClient, jobsDir, options);
       const statusByJobId = new Map;
@@ -38144,7 +38294,7 @@ async function followMerged(sqliteClient, jobsDir, options) {
         });
         if (completedJobs.size === trackedJobs.size || allTrackedTerminal) {
           clearInterval(interval);
-          resolve10();
+          resolve11();
         }
       }
     }, 750);
@@ -38189,130 +38339,13 @@ var init_feed = __esm(() => {
   init_format_helpers();
 });
 
-// src/cli/poll.ts
-var exports_poll = {};
-__export(exports_poll, {
-  run: () => run19
-});
-import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
-import { join as join28 } from "path";
-function parseArgs11(argv) {
-  let jobId;
-  let cursor = 0;
-  let outputCursor = 0;
-  for (let i = 0;i < argv.length; i++) {
-    if (argv[i] === "--cursor" && argv[i + 1]) {
-      cursor = parseInt(argv[++i], 10);
-      if (isNaN(cursor) || cursor < 0)
-        cursor = 0;
-      continue;
-    }
-    if (argv[i] === "--output-cursor" && argv[i + 1]) {
-      outputCursor = parseInt(argv[++i], 10);
-      if (isNaN(outputCursor) || outputCursor < 0)
-        outputCursor = 0;
-      continue;
-    }
-    if (argv[i] === "--json") {
-      continue;
-    }
-    if (argv[i] === "--follow" || argv[i] === "-f") {
-      process.stderr.write(`--follow removed from poll. Use 'specialists feed --follow' for live human-readable output.
-`);
-      process.exit(1);
-    }
-    if (!argv[i].startsWith("-")) {
-      jobId = argv[i];
-    }
-  }
-  if (!jobId) {
-    console.error("Usage: specialists poll <job-id> [--cursor N] [--output-cursor N]");
-    process.exit(1);
-  }
-  return { jobId, cursor, outputCursor };
-}
-function readJobState(jobsDir, jobId, cursor, outputCursor) {
-  const jobDir = join28(jobsDir, jobId);
-  const statusPath = join28(jobDir, "status.json");
-  let status = null;
-  if (existsSync26(statusPath)) {
-    try {
-      status = JSON.parse(readFileSync26(statusPath, "utf-8"));
-    } catch {}
-  }
-  const resultPath = join28(jobDir, "result.txt");
-  let fullOutput = "";
-  if (existsSync26(resultPath)) {
-    try {
-      fullOutput = readFileSync26(resultPath, "utf-8");
-    } catch {}
-  }
-  const events = readJobEventsById(jobsDir, jobId);
-  const newEvents = events.slice(cursor);
-  const nextCursor = events.length;
-  const startedAt = status?.started_at_ms ?? Date.now();
-  const lastEvent = status?.last_event_at_ms ?? Date.now();
-  const elapsedMs = status?.status === "done" || status?.status === "error" ? lastEvent - startedAt : Date.now() - startedAt;
-  const isDone = status?.status === "done";
-  const output2 = isDone ? fullOutput : "";
-  const outputDelta = fullOutput.length > outputCursor ? fullOutput.slice(outputCursor) : "";
-  const nextOutputCursor = fullOutput.length;
-  return {
-    job_id: jobId,
-    status: status?.status ?? "starting",
-    elapsed_ms: elapsedMs,
-    cursor: nextCursor,
-    output_cursor: nextOutputCursor,
-    output: output2,
-    output_delta: outputDelta,
-    events: newEvents,
-    current_event: status?.current_event,
-    current_tool: status?.current_tool,
-    model: status?.model,
-    backend: status?.backend,
-    bead_id: status?.bead_id,
-    error: status?.error
-  };
-}
-async function run19() {
-  process.stderr.write(`[DEPRECATED] 'specialists poll' is scheduled for removal. Use 'sp ps <id> --json' for status and 'sp feed <id>' for events.
-`);
-  const { jobId, cursor, outputCursor } = parseArgs11(process.argv.slice(3));
-  const jobsDir = join28(process.cwd(), ".specialists", "jobs");
-  const jobDir = join28(jobsDir, jobId);
-  if (!existsSync26(jobDir)) {
-    const result2 = {
-      job_id: jobId,
-      status: "error",
-      elapsed_ms: 0,
-      cursor: 0,
-      output_cursor: 0,
-      output: "",
-      output_delta: "",
-      events: [],
-      error: `Job not found: ${jobId}`
-    };
-    console.log(JSON.stringify(result2));
-    process.exit(1);
-  }
-  const result = readJobState(jobsDir, jobId, cursor, outputCursor);
-  if (result.status !== "done" && result.status !== "error" && !result.output_delta) {
-    process.stderr.write(`Tip: use 'specialists feed --follow' for live human-readable output.
-`);
-  }
-  console.log(JSON.stringify(result));
-}
-var init_poll = __esm(() => {
-  init_timeline_query();
-});
-
 // src/cli/steer.ts
 var exports_steer = {};
 __export(exports_steer, {
-  run: () => run20
+  run: () => run19
 });
 import { writeFileSync as writeFileSync10 } from "fs";
-async function run20() {
+async function run19() {
   const jobId = process.argv[3];
   const message = process.argv[4];
   if (!jobId || !message) {
@@ -38363,10 +38396,10 @@ var init_steer = __esm(() => {
 // src/cli/resume.ts
 var exports_resume = {};
 __export(exports_resume, {
-  run: () => run21
+  run: () => run20
 });
 import { writeFileSync as writeFileSync11 } from "fs";
-async function run21() {
+async function run20() {
   const jobId = process.argv[3];
   const task = process.argv[4];
   if (!jobId || !task) {
@@ -38419,24 +38452,24 @@ var init_resume = __esm(() => {
 // src/cli/follow-up.ts
 var exports_follow_up = {};
 __export(exports_follow_up, {
-  run: () => run22
+  run: () => run21
 });
-async function run22() {
+async function run21() {
   process.stderr.write("\x1B[33m\u26A0 DEPRECATED:\x1B[0m `specialists follow-up` is deprecated. Use `specialists resume` instead.\n\n");
   const { run: resumeRun } = await Promise.resolve().then(() => (init_resume(), exports_resume));
   return resumeRun();
 }
 
 // src/specialist/worktree-gc.ts
-import { existsSync as existsSync27, readdirSync as readdirSync11, readFileSync as readFileSync27 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync26, readdirSync as readdirSync11, readFileSync as readFileSync26 } from "fs";
+import { join as join28 } from "path";
 import { spawnSync as spawnSync19 } from "child_process";
 function readJobStatus2(jobDir) {
-  const statusPath = join29(jobDir, "status.json");
-  if (!existsSync27(statusPath))
+  const statusPath = join28(jobDir, "status.json");
+  if (!existsSync26(statusPath))
     return null;
   try {
-    return JSON.parse(readFileSync27(statusPath, "utf-8"));
+    return JSON.parse(readFileSync26(statusPath, "utf-8"));
   } catch {
     return null;
   }
@@ -38458,7 +38491,7 @@ function collectWorktreeGcCandidates(jobsDir) {
       const worktreePath = status.worktree_path;
       if (!worktreePath)
         return null;
-      if (!existsSync27(worktreePath))
+      if (!existsSync26(worktreePath))
         return null;
       return {
         jobId: status.id,
@@ -38470,13 +38503,13 @@ function collectWorktreeGcCandidates(jobsDir) {
   }
   if (!getFileFallbackEnabled())
     return [];
-  if (!existsSync27(jobsDir))
+  if (!existsSync26(jobsDir))
     return [];
   const candidates = [];
   for (const entry of readdirSync11(jobsDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
-    const status = readJobStatus2(join29(jobsDir, entry.name));
+    const status = readJobStatus2(join28(jobsDir, entry.name));
     if (!status)
       continue;
     if (isActive(status.status))
@@ -38486,7 +38519,7 @@ function collectWorktreeGcCandidates(jobsDir) {
     const { worktree_path: worktreePath, branch } = status;
     if (!worktreePath)
       continue;
-    if (!existsSync27(worktreePath))
+    if (!existsSync26(worktreePath))
       continue;
     candidates.push({
       jobId: status.id,
@@ -38530,10 +38563,10 @@ var init_worktree_gc = __esm(() => {
 // src/cli/clean.ts
 var exports_clean = {};
 __export(exports_clean, {
-  run: () => run23
+  run: () => run22
 });
-import { existsSync as existsSync28, readFileSync as readFileSync28, readdirSync as readdirSync12, rmSync as rmSync3, statSync as statSync4 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync27, readdirSync as readdirSync12, rmSync as rmSync3, statSync as statSync4 } from "fs";
+import { join as join29 } from "path";
 function parseTtlDaysFromEnvironment() {
   const rawValue = process.env.SPECIALISTS_JOB_TTL_DAYS ?? process.env.JOB_TTL_DAYS;
   if (!rawValue)
@@ -38616,7 +38649,7 @@ function parseOptions2(argv) {
 function readDirectorySizeBytes(directoryPath) {
   let totalBytes = 0;
   for (const entry of readdirSync12(directoryPath, { withFileTypes: true })) {
-    const entryPath = join30(directoryPath, entry.name);
+    const entryPath = join29(directoryPath, entry.name);
     const stats = statSync4(entryPath);
     totalBytes += stats.isDirectory() ? readDirectorySizeBytes(entryPath) : stats.size;
   }
@@ -38624,7 +38657,7 @@ function readDirectorySizeBytes(directoryPath) {
 }
 function containsProtectedSqliteArtifact(directoryPath) {
   for (const entry of readdirSync12(directoryPath, { withFileTypes: true })) {
-    const entryPath = join30(directoryPath, entry.name);
+    const entryPath = join29(directoryPath, entry.name);
     if (entry.isDirectory()) {
       if (containsProtectedSqliteArtifact(entryPath))
         return true;
@@ -38645,15 +38678,15 @@ function getJobTimestamps(status) {
 function readCompletedJobDirectory(baseDirectory, entry) {
   if (!entry.isDirectory())
     return null;
-  const directoryPath = join30(baseDirectory, entry.name);
+  const directoryPath = join29(baseDirectory, entry.name);
   if (containsProtectedSqliteArtifact(directoryPath))
     return null;
-  const statusFilePath = join30(directoryPath, "status.json");
-  if (!existsSync28(statusFilePath))
+  const statusFilePath = join29(directoryPath, "status.json");
+  if (!existsSync27(statusFilePath))
     return null;
   let statusData;
   try {
-    statusData = JSON.parse(readFileSync28(statusFilePath, "utf-8"));
+    statusData = JSON.parse(readFileSync27(statusFilePath, "utf-8"));
   } catch {
     return null;
   }
@@ -38667,8 +38700,8 @@ function collectCompletedJobs(jobsDirectoryPath) {
   const statuses = sqliteClient?.listStatuses() ?? [];
   if (statuses.length > 0) {
     return statuses.filter((status) => COMPLETED_STATUSES.has(status.status)).map((status) => {
-      const directoryPath = join30(jobsDirectoryPath, status.id);
-      if (!existsSync28(directoryPath) || containsProtectedSqliteArtifact(directoryPath))
+      const directoryPath = join29(jobsDirectoryPath, status.id);
+      if (!existsSync27(directoryPath) || containsProtectedSqliteArtifact(directoryPath))
         return null;
       const { createdAtMs, completedAtMs } = getJobTimestamps(status);
       return { id: status.id, directoryPath, completedAtMs, createdAtMs, sizeBytes: readDirectorySizeBytes(directoryPath) };
@@ -38808,7 +38841,7 @@ function removeStaleProcesses(statuses, dryRun) {
   }
   return updatedCount;
 }
-async function run23() {
+async function run22() {
   let options;
   try {
     options = parseOptions2(process.argv.slice(3));
@@ -38817,7 +38850,7 @@ async function run23() {
     printUsageAndExit2(message);
   }
   const jobsDirectoryPath = resolveJobsDir();
-  if (!existsSync28(jobsDirectoryPath)) {
+  if (!existsSync27(jobsDirectoryPath)) {
     console.log("No jobs directory found.");
     return;
   }
@@ -38871,7 +38904,7 @@ var init_clean = __esm(() => {
 // src/cli/end.ts
 var exports_end = {};
 __export(exports_end, {
-  run: () => run24
+  run: () => run23
 });
 import { spawnSync as spawnSync20 } from "child_process";
 function parseOptions3(argv) {
@@ -38955,7 +38988,7 @@ async function publishChain(beadId, options) {
     console.log("Publication mode: direct merge");
   }
 }
-async function run24() {
+async function run23() {
   let options;
   try {
     options = parseOptions3(process.argv.slice(3));
@@ -38996,7 +39029,7 @@ var init_end = __esm(() => {
 // src/cli/stop.ts
 var exports_stop = {};
 __export(exports_stop, {
-  run: () => run25
+  run: () => run24
 });
 function resolveTerminalStatus(jobId) {
   return hasRunCompleteEvent(jobId) ? "done" : "cancelled";
@@ -39027,7 +39060,7 @@ async function waitForProcessExit(pid, timeoutMs) {
   while (Date.now() < deadline) {
     if (!isProcessAlive(pid))
       return true;
-    await new Promise((resolve10) => setTimeout(resolve10, 100));
+    await new Promise((resolve11) => setTimeout(resolve11, 100));
   }
   return !isProcessAlive(pid);
 }
@@ -39039,7 +39072,7 @@ function tryKillProcessGroup(pid) {
       throw err;
   }
 }
-async function run25() {
+async function run24() {
   let parsed;
   try {
     parsed = parseStopArgs(process.argv.slice(3));
@@ -39153,18 +39186,18 @@ var init_stop = __esm(() => {
 // src/cli/attach.ts
 var exports_attach = {};
 __export(exports_attach, {
-  run: () => run26
+  run: () => run25
 });
 import { execFileSync as execFileSync3, spawnSync as spawnSync21 } from "child_process";
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join31 } from "path";
+import { readFileSync as readFileSync28 } from "fs";
+import { join as join30 } from "path";
 function exitWithError(message) {
   console.error(message);
   process.exit(1);
 }
 function readStatus(statusPath, jobId) {
   try {
-    return JSON.parse(readFileSync29(statusPath, "utf-8"));
+    return JSON.parse(readFileSync28(statusPath, "utf-8"));
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
       exitWithError(`Job \`${jobId}\` not found. Run \`specialists status\` to see active jobs in current mode.`);
@@ -39173,13 +39206,13 @@ function readStatus(statusPath, jobId) {
     exitWithError(`Failed to read status for job \`${jobId}\`: ${details}`);
   }
 }
-async function run26() {
+async function run25() {
   const [jobId] = process.argv.slice(3);
   if (!jobId) {
     exitWithError("Usage: specialists attach <job-id>  (normal runtime is DB-backed; job files are legacy/operator-only)");
   }
-  const jobsDir = join31(process.cwd(), ".specialists", "jobs");
-  const statusPath = join31(jobsDir, jobId, "status.json");
+  const jobsDir = join30(process.cwd(), ".specialists", "jobs");
+  const statusPath = join30(jobsDir, jobId, "status.json");
   const status = readStatus(statusPath, jobId);
   if (status.status === "done" || status.status === "error") {
     exitWithError(`Job \`${jobId}\` has already completed (status: ${status.status}). Use \`specialists result ${jobId}\` to read output.`);
@@ -39201,15 +39234,15 @@ async function run26() {
 var init_attach = () => {};
 
 // src/specialist/drift-detector.ts
-import { existsSync as existsSync29, readFileSync as readFileSync30, readdirSync as readdirSync13, rmSync as rmSync4 } from "fs";
-import { join as join32, resolve as resolve10, relative as relative2 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync29, readdirSync as readdirSync13, rmSync as rmSync4 } from "fs";
+import { join as join31, resolve as resolve11, relative as relative3 } from "path";
 function listFiles(root) {
-  if (!existsSync29(root))
+  if (!existsSync28(root))
     return [];
   const out = [];
   const visit2 = (dir) => {
     for (const entry of readdirSync13(dir, { withFileTypes: true })) {
-      const full = join32(dir, entry.name);
+      const full = join31(dir, entry.name);
       if (entry.isDirectory()) {
         visit2(full);
         continue;
@@ -39222,7 +39255,7 @@ function listFiles(root) {
   return out;
 }
 function relPath(path, base) {
-  return relative2(base, path) || ".";
+  return relative3(base, path) || ".";
 }
 function makeFinding(repoRoot, kind, scope, path, canonicalPath, bytesEqual) {
   const rel = relPath(path, repoRoot);
@@ -39240,18 +39273,18 @@ function detectDriftForRepo(repoRoot) {
     if (!asset.canonicalDir)
       continue;
     const scopes = [
-      { scope: "default", dir: resolve10(repoRoot, asset.managedDir) },
-      { scope: "user", dir: resolve10(repoRoot, ".specialists/user") }
+      { scope: "default", dir: resolve11(repoRoot, asset.managedDir) },
+      { scope: "user", dir: resolve11(repoRoot, ".specialists/user") }
     ];
     for (const { scope, dir } of scopes) {
-      if (!existsSync29(dir))
+      if (!existsSync28(dir))
         continue;
       for (const file of listFiles(dir)) {
         const rel = relPath(file, dir);
-        const canonicalPath = join32(asset.canonicalDir, rel);
-        if (!existsSync29(canonicalPath))
+        const canonicalPath = join31(asset.canonicalDir, rel);
+        if (!existsSync28(canonicalPath))
           continue;
-        const bytesEqual = readFileSync30(file).equals(readFileSync30(canonicalPath));
+        const bytesEqual = readFileSync29(file).equals(readFileSync29(canonicalPath));
         findings.push(makeFinding(repoRoot, asset.kind, scope, file, canonicalPath, bytesEqual));
       }
     }
@@ -39275,13 +39308,13 @@ function detectDriftUnderRoot(root) {
         continue;
       if (entry.name === "node_modules" || entry.name === ".git")
         continue;
-      visit2(join32(dir, entry.name));
+      visit2(join31(dir, entry.name));
     }
   };
-  visit2(resolve10(root));
+  visit2(resolve11(root));
   const summary = repos.flatMap((r) => r.findings);
   return {
-    root: resolve10(root),
+    root: resolve11(root),
     repos,
     summary: {
       repos: repos.length,
@@ -39315,10 +39348,10 @@ var init_drift_detector = __esm(() => {
 // src/cli/prune-stale-defaults.ts
 var exports_prune_stale_defaults = {};
 __export(exports_prune_stale_defaults, {
-  run: () => run27
+  run: () => run26
 });
-import { resolve as resolve11 } from "path";
-function parseArgs12(argv) {
+import { resolve as resolve12 } from "path";
+function parseArgs11(argv) {
   let dryRun = false;
   let root = process.cwd();
   let help = false;
@@ -39332,7 +39365,7 @@ function parseArgs12(argv) {
       const value = argv[i + 1];
       if (!value || value.startsWith("--"))
         throw new Error("--root requires a value");
-      root = resolve11(value);
+      root = resolve12(value);
       i += 1;
       continue;
     }
@@ -39349,8 +39382,8 @@ function printHelp() {
   console.log("  --dry-run  List stale default snapshots without pruning");
   console.log("  --root     Repo root to scan");
 }
-async function run27(argv = process.argv.slice(3)) {
-  const { dryRun, root, help } = parseArgs12(argv);
+async function run26(argv = process.argv.slice(3)) {
+  const { dryRun, root, help } = parseArgs11(argv);
   if (help) {
     printHelp();
     return;
@@ -39376,7 +39409,7 @@ var init_prune_stale_defaults = __esm(() => {
 // src/cli/quickstart.ts
 var exports_quickstart = {};
 __export(exports_quickstart, {
-  run: () => run28
+  run: () => run27
 });
 function section2(title) {
   const bar = "\u2500".repeat(60);
@@ -39390,7 +39423,7 @@ function cmd2(s) {
 function flag(s) {
   return green13(s);
 }
-async function run28() {
+async function run27() {
   const lines = [
     "",
     bold12("specialists  \xB7  Quick Start Guide"),
@@ -39605,7 +39638,7 @@ var bold12 = (s) => `\x1B[1m${s}\x1B[0m`, dim12 = (s) => `\x1B[2m${s}\x1B[0m`, y
 var exports_doctor = {};
 __export(exports_doctor, {
   setStatusError: () => setStatusError,
-  run: () => run29,
+  run: () => run28,
   renderProcessSummary: () => renderProcessSummary,
   parseVersionTuple: () => parseVersionTuple,
   compareVersions: () => compareVersions2,
@@ -39613,8 +39646,8 @@ __export(exports_doctor, {
 });
 import { createHash as createHash5 } from "crypto";
 import { spawnSync as spawnSync22 } from "child_process";
-import { existsSync as existsSync30, lstatSync as lstatSync2, mkdirSync as mkdirSync10, readdirSync as readdirSync14, readFileSync as readFileSync31, readlinkSync as readlinkSync2, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname9, join as join33, relative as relative3, resolve as resolve12 } from "path";
+import { existsSync as existsSync29, lstatSync as lstatSync2, mkdirSync as mkdirSync11, readdirSync as readdirSync14, readFileSync as readFileSync30, readlinkSync as readlinkSync2, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname10, join as join32, relative as relative4, resolve as resolve13 } from "path";
 function ok3(msg) {
   console.log(`  ${green14("\u2713")} ${msg}`);
 }
@@ -39643,10 +39676,10 @@ function isInstalled3(bin) {
   return spawnSync22("which", [bin], { encoding: "utf8", timeout: 2000 }).status === 0;
 }
 function loadJson2(path) {
-  if (!existsSync30(path))
+  if (!existsSync29(path))
     return null;
   try {
-    return JSON.parse(readFileSync31(path, "utf8"));
+    return JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return null;
   }
@@ -39689,7 +39722,7 @@ function checkBd() {
     return false;
   }
   ok3(`bd installed  ${dim13(sp("bd", ["--version"]).stdout || "")}`);
-  if (existsSync30(join33(CWD, ".beads")))
+  if (existsSync29(join32(CWD, ".beads")))
     ok3(".beads/ present in project");
   else
     warn3(".beads/ not found in project");
@@ -39709,22 +39742,22 @@ function checkHooks() {
   section3("Claude Code hooks  (2 expected)");
   let allPresent = true;
   for (const name of HOOK_NAMES) {
-    const canonicalPath = join33(HOOKS_DIR, name);
-    if (!existsSync30(canonicalPath)) {
-      fail4(`${relative3(CWD, canonicalPath)}  ${red7("missing")}`);
+    const canonicalPath = join32(HOOKS_DIR, name);
+    if (!existsSync29(canonicalPath)) {
+      fail4(`${relative4(CWD, canonicalPath)}  ${red7("missing")}`);
       fix("specialists init");
       allPresent = false;
     } else {
-      ok3(relative3(CWD, canonicalPath));
+      ok3(relative4(CWD, canonicalPath));
     }
-    const claudeHookPath = join33(CLAUDE_HOOKS_DIR, name);
+    const claudeHookPath = join32(CLAUDE_HOOKS_DIR, name);
     const symlinkState = isSymlinkTo(claudeHookPath, canonicalPath);
     if (symlinkState.ok) {
-      ok3(`${relative3(CWD, claudeHookPath)} -> ${relative3(dirname9(claudeHookPath), canonicalPath)}`);
+      ok3(`${relative4(CWD, claudeHookPath)} -> ${relative4(dirname10(claudeHookPath), canonicalPath)}`);
       continue;
     }
     allPresent = false;
-    const relHookPath = relative3(CWD, claudeHookPath);
+    const relHookPath = relative4(CWD, claudeHookPath);
     if (symlinkState.reason === "missing") {
       fail4(`${relHookPath} missing`);
     } else if (symlinkState.reason === "not-symlink") {
@@ -39792,30 +39825,30 @@ function checkVersion() {
 }
 function hashFile(path) {
   const hash = createHash5("sha256");
-  hash.update(readFileSync31(path));
+  hash.update(readFileSync30(path));
   return hash.digest("hex");
 }
 function collectFileHashes(rootDir) {
   const hashes = new Map;
   const visit2 = (dir) => {
     for (const entry of readdirSync14(dir, { withFileTypes: true })) {
-      const fullPath = join33(dir, entry.name);
+      const fullPath = join32(dir, entry.name);
       if (entry.isDirectory()) {
         visit2(fullPath);
         continue;
       }
       if (!entry.isFile())
         continue;
-      const relPath2 = relative3(rootDir, fullPath);
+      const relPath2 = relative4(rootDir, fullPath);
       hashes.set(relPath2, hashFile(fullPath));
     }
   };
-  if (existsSync30(rootDir))
+  if (existsSync29(rootDir))
     visit2(rootDir);
   return hashes;
 }
 function isSymlinkTo(linkPath, expectedTargetPath) {
-  if (!existsSync30(linkPath))
+  if (!existsSync29(linkPath))
     return { ok: false, reason: "missing" };
   let stats;
   try {
@@ -39827,8 +39860,8 @@ function isSymlinkTo(linkPath, expectedTargetPath) {
     return { ok: false, reason: "not-symlink" };
   try {
     const rawTarget = readlinkSync2(linkPath);
-    const resolvedTarget = resolve12(dirname9(linkPath), rawTarget);
-    const resolvedExpected = resolve12(expectedTargetPath);
+    const resolvedTarget = resolve13(dirname10(linkPath), rawTarget);
+    const resolvedExpected = resolve13(expectedTargetPath);
     if (resolvedTarget !== resolvedExpected) {
       return { ok: false, reason: "wrong-target", target: rawTarget };
     }
@@ -39839,12 +39872,12 @@ function isSymlinkTo(linkPath, expectedTargetPath) {
 }
 function checkSkillDrift() {
   section3("Skill drift  (.xtrm skill sync)");
-  if (!existsSync30(CONFIG_SKILLS_DIR)) {
+  if (!existsSync29(CONFIG_SKILLS_DIR)) {
     fail4("config/skills/ missing");
     fix("restore config/skills/ from git");
     return false;
   }
-  if (!existsSync30(XTRM_DEFAULT_SKILLS_DIR)) {
+  if (!existsSync29(XTRM_DEFAULT_SKILLS_DIR)) {
     fail4(".xtrm/skills/default/ missing");
     fix("specialists init --sync-skills");
     return false;
@@ -39886,22 +39919,22 @@ function checkSkillDrift() {
   }
   let linksOk = true;
   for (const scope of ["claude", "pi"]) {
-    const activeRoot = join33(XTRM_ACTIVE_SKILLS_DIR, scope);
-    if (!existsSync30(activeRoot)) {
-      fail4(`${relative3(CWD, activeRoot)}/ missing`);
+    const activeRoot = join32(XTRM_ACTIVE_SKILLS_DIR, scope);
+    if (!existsSync29(activeRoot)) {
+      fail4(`${relative4(CWD, activeRoot)}/ missing`);
       fix("specialists init --sync-skills");
       linksOk = false;
       continue;
     }
     const defaultSkills = readdirSync14(XTRM_DEFAULT_SKILLS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     for (const skillName of defaultSkills) {
-      const activeLinkPath = join33(activeRoot, skillName);
-      const expectedTarget = join33(XTRM_DEFAULT_SKILLS_DIR, skillName);
+      const activeLinkPath = join32(activeRoot, skillName);
+      const expectedTarget = join32(XTRM_DEFAULT_SKILLS_DIR, skillName);
       const state = isSymlinkTo(activeLinkPath, expectedTarget);
       if (state.ok)
         continue;
       linksOk = false;
-      const relLink = relative3(CWD, activeLinkPath);
+      const relLink = relative4(CWD, activeLinkPath);
       if (state.reason === "missing") {
         fail4(`${relLink} missing`);
       } else if (state.reason === "not-symlink") {
@@ -39915,18 +39948,18 @@ function checkSkillDrift() {
     }
   }
   const skillRootChecks = [
-    { root: join33(CLAUDE_DIR, "skills"), expected: ACTIVE_CLAUDE_SKILLS_DIR },
-    { root: join33(PI_DIR, "skills"), expected: ACTIVE_PI_SKILLS_DIR }
+    { root: join32(CLAUDE_DIR, "skills"), expected: ACTIVE_CLAUDE_SKILLS_DIR },
+    { root: join32(PI_DIR, "skills"), expected: ACTIVE_PI_SKILLS_DIR }
   ];
   let rootLinksOk = true;
   for (const check2 of skillRootChecks) {
     const state = isSymlinkTo(check2.root, check2.expected);
     if (state.ok) {
-      ok3(`${relative3(CWD, check2.root)} -> ${relative3(dirname9(check2.root), check2.expected)}`);
+      ok3(`${relative4(CWD, check2.root)} -> ${relative4(dirname10(check2.root), check2.expected)}`);
       continue;
     }
     rootLinksOk = false;
-    const relRoot = relative3(CWD, check2.root);
+    const relRoot = relative4(CWD, check2.root);
     if (state.reason === "missing") {
       fail4(`${relRoot} missing`);
     } else if (state.reason === "not-symlink") {
@@ -39941,13 +39974,13 @@ function checkSkillDrift() {
   return drifted.length === 0 && missingInDefault.length === 0 && linksOk && rootLinksOk;
 }
 function checkManagedMirror(label, sourceDir, mirrorDir, fixHint) {
-  if (!existsSync30(sourceDir)) {
-    warn3(`${label} source missing: ${relative3(CWD, sourceDir)}`);
+  if (!existsSync29(sourceDir)) {
+    warn3(`${label} source missing: ${relative4(CWD, sourceDir)}`);
     fix(fixHint);
     return false;
   }
-  if (!existsSync30(mirrorDir)) {
-    fail4(`${label} mirror missing: ${relative3(CWD, mirrorDir)}`);
+  if (!existsSync29(mirrorDir)) {
+    fail4(`${label} mirror missing: ${relative4(CWD, mirrorDir)}`);
     fix(fixHint);
     return false;
   }
@@ -39978,13 +40011,13 @@ function checkManagedMirror(label, sourceDir, mirrorDir, fixHint) {
 function checkManagedAssetMirrors() {
   section3("Managed mirrors  (specialists / mandatory-rules / nodes)");
   const specialistsOk = checkManagedMirror("specialists", CONFIG_SPECIALISTS_DIR, DEFAULT_SPECIALISTS_DIR, "specialists init --sync-defaults");
-  const rulesOk = checkManagedMirror("mandatory-rules", CONFIG_MANDATORY_RULES_DIR, join33(DEFAULT_SPECIALISTS_DIR, "mandatory-rules"), "specialists init --sync-defaults");
-  const nodesOk = checkManagedMirror("nodes", CONFIG_NODES_DIR, join33(DEFAULT_SPECIALISTS_DIR, "nodes"), "specialists init --sync-defaults");
+  const rulesOk = checkManagedMirror("mandatory-rules", CONFIG_MANDATORY_RULES_DIR, join32(DEFAULT_SPECIALISTS_DIR, "mandatory-rules"), "specialists init --sync-defaults");
+  const nodesOk = checkManagedMirror("nodes", CONFIG_NODES_DIR, join32(DEFAULT_SPECIALISTS_DIR, "nodes"), "specialists init --sync-defaults");
   return specialistsOk && rulesOk && nodesOk;
 }
 function checkUserOverlayDrift() {
   section3("User specialist overlays");
-  if (!existsSync30(USER_SPECIALISTS_DIR)) {
+  if (!existsSync29(USER_SPECIALISTS_DIR)) {
     ok3("no user overlays present");
     return true;
   }
@@ -39995,14 +40028,14 @@ function checkUserOverlayDrift() {
   }
   let allOk = true;
   for (const name of overlays) {
-    const userPath = join33(USER_SPECIALISTS_DIR, name);
-    const defaultPath = join33(DEFAULT_SPECIALISTS_DIR, name);
+    const userPath = join32(USER_SPECIALISTS_DIR, name);
+    const defaultPath = join32(DEFAULT_SPECIALISTS_DIR, name);
     const userSpec = loadJson2(userPath);
     if (!userSpec) {
       warn3(`${name}: failed to parse \u2014 skipping drift check`);
       continue;
     }
-    if (!existsSync30(defaultPath)) {
+    if (!existsSync29(defaultPath)) {
       ok3(`${name}: user-only overlay (no default to drift from)`);
       continue;
     }
@@ -40030,20 +40063,20 @@ function checkUserOverlayDrift() {
 }
 function checkRuntimeDirs() {
   section3(".specialists/ runtime directories");
-  const rootDir = join33(CWD, ".specialists");
-  const jobsDir = join33(rootDir, "jobs");
-  const readyDir = join33(rootDir, "ready");
+  const rootDir = join32(CWD, ".specialists");
+  const jobsDir = join32(rootDir, "jobs");
+  const readyDir = join32(rootDir, "ready");
   let allOk = true;
-  if (!existsSync30(rootDir)) {
+  if (!existsSync29(rootDir)) {
     warn3(".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 (!existsSync30(subDir)) {
+      if (!existsSync29(subDir)) {
         warn3(`.specialists/${label}/ missing \u2014 auto-creating`);
-        mkdirSync10(subDir, { recursive: true });
+        mkdirSync11(subDir, { recursive: true });
         ok3(`.specialists/${label}/ created`);
       } else {
         ok3(`.specialists/${label}/ present`);
@@ -40055,8 +40088,8 @@ function checkRuntimeDirs() {
 function checkClaudeMdFragments() {
   section3("CLAUDE.md fragments");
   const projectRoot = process.cwd();
-  const claudeMd = join33(projectRoot, "CLAUDE.md");
-  if (!existsSync30(claudeMd)) {
+  const claudeMd = join32(projectRoot, "CLAUDE.md");
+  if (!existsSync29(claudeMd)) {
     warn3("No CLAUDE.md in project root \u2014 skipping fragment check");
     return true;
   }
@@ -40125,7 +40158,7 @@ function parseDoctorArgs(argv) {
       const value = argv[i + 1];
       if (!value || value.startsWith("--"))
         throw new Error("--root requires a value");
-      opts.root = resolve12(value);
+      opts.root = resolve13(value);
       i += 1;
       continue;
     }
@@ -40182,7 +40215,7 @@ function compareVersions2(left, right) {
 }
 function setStatusError(statusPath) {
   try {
-    const raw = readFileSync31(statusPath, "utf8");
+    const raw = readFileSync30(statusPath, "utf8");
     const status = JSON.parse(raw);
     status.status = "error";
     writeFileSync12(statusPath, `${JSON.stringify(status, null, 2)}
@@ -40236,11 +40269,11 @@ function cleanupProcesses(jobsDir, dryRun) {
     zombieJobIds: []
   };
   for (const jobId of entries) {
-    const statusPath = join33(jobsDir, jobId, "status.json");
-    if (!existsSync30(statusPath))
+    const statusPath = join32(jobsDir, jobId, "status.json");
+    if (!existsSync29(statusPath))
       continue;
     try {
-      const status = JSON.parse(readFileSync31(statusPath, "utf8"));
+      const status = JSON.parse(readFileSync30(statusPath, "utf8"));
       result.total += 1;
       if (status.status !== "running" && status.status !== "starting")
         continue;
@@ -40325,8 +40358,8 @@ function resolveWatchdogMode() {
 function checkZombieJobs() {
   section3("Background jobs");
   hint(`watchdog mode: ${resolveWatchdogMode()}`);
-  const jobsDir = join33(CWD, ".specialists", "jobs");
-  if (!existsSync30(jobsDir)) {
+  const jobsDir = join32(CWD, ".specialists", "jobs");
+  if (!existsSync29(jobsDir)) {
     hint("No .specialists/jobs/ \u2014 skipping");
     return true;
   }
@@ -40344,7 +40377,7 @@ function checkZombieJobs() {
   }
   return result.zombies === 0;
 }
-async function run29(argv = process.argv.slice(3)) {
+async function run28(argv = process.argv.slice(3)) {
   const subcommand = argv[0];
   if (subcommand === "orphans") {
     runDoctorOrphans();
@@ -40391,24 +40424,24 @@ var init_doctor = __esm(() => {
   init_drift_detector();
   init_version_check();
   CWD = process.cwd();
-  CLAUDE_DIR = join33(CWD, ".claude");
-  PI_DIR = join33(CWD, ".pi");
-  XTRM_SKILLS_DIR = join33(CWD, ".xtrm", "skills");
-  XTRM_DEFAULT_SKILLS_DIR = join33(XTRM_SKILLS_DIR, "default");
-  XTRM_ACTIVE_SKILLS_DIR = join33(XTRM_SKILLS_DIR, "active");
-  ACTIVE_CLAUDE_SKILLS_DIR = join33(XTRM_ACTIVE_SKILLS_DIR, "claude");
-  ACTIVE_PI_SKILLS_DIR = join33(XTRM_ACTIVE_SKILLS_DIR, "pi");
-  CONFIG_SKILLS_DIR = join33(CWD, "config", "skills");
-  CONFIG_SPECIALISTS_DIR = join33(CWD, "config", "specialists");
-  CONFIG_MANDATORY_RULES_DIR = join33(CWD, "config", "mandatory-rules");
-  CONFIG_NODES_DIR = join33(CWD, "config", "nodes");
-  SPECIALISTS_DIR = join33(CWD, ".specialists");
-  DEFAULT_SPECIALISTS_DIR = join33(SPECIALISTS_DIR, "default");
-  USER_SPECIALISTS_DIR = join33(SPECIALISTS_DIR, "user");
-  HOOKS_DIR = join33(CWD, ".xtrm", "hooks", "specialists");
-  CLAUDE_HOOKS_DIR = join33(CLAUDE_DIR, "hooks");
-  SETTINGS_FILE = join33(CLAUDE_DIR, "settings.json");
-  MCP_FILE2 = join33(CWD, ".mcp.json");
+  CLAUDE_DIR = join32(CWD, ".claude");
+  PI_DIR = join32(CWD, ".pi");
+  XTRM_SKILLS_DIR = join32(CWD, ".xtrm", "skills");
+  XTRM_DEFAULT_SKILLS_DIR = join32(XTRM_SKILLS_DIR, "default");
+  XTRM_ACTIVE_SKILLS_DIR = join32(XTRM_SKILLS_DIR, "active");
+  ACTIVE_CLAUDE_SKILLS_DIR = join32(XTRM_ACTIVE_SKILLS_DIR, "claude");
+  ACTIVE_PI_SKILLS_DIR = join32(XTRM_ACTIVE_SKILLS_DIR, "pi");
+  CONFIG_SKILLS_DIR = join32(CWD, "config", "skills");
+  CONFIG_SPECIALISTS_DIR = join32(CWD, "config", "specialists");
+  CONFIG_MANDATORY_RULES_DIR = join32(CWD, "config", "mandatory-rules");
+  CONFIG_NODES_DIR = join32(CWD, "config", "nodes");
+  SPECIALISTS_DIR = join32(CWD, ".specialists");
+  DEFAULT_SPECIALISTS_DIR = join32(SPECIALISTS_DIR, "default");
+  USER_SPECIALISTS_DIR = join32(SPECIALISTS_DIR, "user");
+  HOOKS_DIR = join32(CWD, ".xtrm", "hooks", "specialists");
+  CLAUDE_HOOKS_DIR = join32(CLAUDE_DIR, "hooks");
+  SETTINGS_FILE = join32(CLAUDE_DIR, "settings.json");
+  MCP_FILE2 = join32(CWD, ".mcp.json");
   HOOK_NAMES = [
     "specialists-complete.mjs",
     "specialists-session-start.mjs"
@@ -40418,9 +40451,9 @@ var init_doctor = __esm(() => {
 // src/cli/setup.ts
 var exports_setup = {};
 __export(exports_setup, {
-  run: () => run30
+  run: () => run29
 });
-async function run30() {
+async function run29() {
   console.log("");
   console.log(yellow13("\u26A0 DEPRECATED: `specialists setup` is deprecated"));
   console.log("");
@@ -40441,20 +40474,20 @@ async function run30() {
 var bold14 = (s) => `\x1B[1m${s}\x1B[0m`, yellow13 = (s) => `\x1B[33m${s}\x1B[0m`, dim14 = (s) => `\x1B[2m${s}\x1B[0m`;
 
 // src/cli/serve-hot-reload.ts
-import { existsSync as existsSync31, readdirSync as readdirSync15, statSync as statSync5, watch as fsWatch } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync15, statSync as statSync5, watch as fsWatch } from "fs";
+import { join as join33 } from "path";
 function specialistNameFromFile(file) {
   const match = file.match(/^(.+)\.specialist\.(json|yaml)$/);
   return match ? match[1] : null;
 }
 function snapshotMtimes(dir) {
   const out = new Map;
-  if (!existsSync31(dir))
+  if (!existsSync30(dir))
     return out;
   const entries = readdirSync15(dir).filter((name) => specialistNameFromFile(name) !== null);
   for (const name of entries) {
     try {
-      out.set(name, statSync5(join34(dir, name)).mtimeMs);
+      out.set(name, statSync5(join33(dir, name)).mtimeMs);
     } catch {}
   }
   return out;
@@ -40511,7 +40544,7 @@ function createUserDirWatcher(opts) {
       for (const file of changed)
         queue(file);
     }, opts.pollMs);
-  } else if (existsSync31(opts.userDir)) {
+  } else if (existsSync30(opts.userDir)) {
     try {
       watcher = fsWatch(opts.userDir, { persistent: false }, (_eventType, filename) => {
         queue(filename ? String(filename) : null);
@@ -40543,17 +40576,20 @@ var init_serve_hot_reload = () => {};
 var exports_serve = {};
 __export(exports_serve, {
   startServe: () => startServe,
-  run: () => run31,
+  run: () => run30,
   recordAuditFailure: () => recordAuditFailure,
   evaluateReadiness: () => evaluateReadiness2,
-  createReadinessState: () => createReadinessState
+  createReadinessState: () => createReadinessState,
+  checkPiHelpForFlags: () => checkPiHelpForFlags
 });
 import { createServer } from "http";
+import { randomUUID as randomUUID3 } from "crypto";
 import { once } from "events";
+import { spawnSync as spawnSync23 } from "child_process";
 import { access, readdir as readdir2, readFile as readFile5, constants } from "fs/promises";
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join35 } from "path";
+import { join as join34 } from "path";
 function createReadinessState() {
   return { shuttingDown: false, auditFailures: [], dbWriteFailuresTotal: 0 };
 }
@@ -40569,7 +40605,7 @@ function pruneAuditFailures(state, now = Date.now()) {
   }
 }
 async function checkUserDirSpecs(userDir) {
-  if (!existsSync32(userDir))
+  if (!existsSync31(userDir))
     return "empty";
   const entries = await readdir2(userDir).catch(() => []);
   const specFiles = entries.filter((name) => name.endsWith(".specialist.json") || name.endsWith(".specialist.yaml"));
@@ -40578,7 +40614,7 @@ async function checkUserDirSpecs(userDir) {
   let validCount = 0;
   for (const file of specFiles) {
     try {
-      const content = await readFile5(join35(userDir, file), "utf-8");
+      const content = await readFile5(join34(userDir, file), "utf-8");
       const json = file.endsWith(".json") ? content : null;
       if (!json)
         continue;
@@ -40596,7 +40632,7 @@ async function evaluateReadiness2(opts) {
   if (opts.state.auditFailures.length > opts.auditFailureThreshold) {
     return { ready: false, reason: "degraded:audit" };
   }
-  const piConfigPath = opts.piConfigPath ?? join35(homedir3(), ".pi", "agent", "auth.json");
+  const piConfigPath = opts.piConfigPath ?? join34(homedir3(), ".pi", "agent", "auth.json");
   try {
     await access(piConfigPath, constants.R_OK);
   } catch {
@@ -40607,26 +40643,41 @@ async function evaluateReadiness2(opts) {
   } catch {
     return { ready: false, reason: "db_not_writable" };
   }
-  const userDir = join35(opts.projectDir, ".specialists", "user");
+  let warning;
+  const canaryMode = opts.piCanaryMode ?? "off";
+  if (canaryMode !== "off" && opts.piCanaryCheck) {
+    const canaryFailure = await opts.piCanaryCheck();
+    if (canaryFailure) {
+      if (canaryMode === "require")
+        return { ready: false, reason: canaryFailure };
+      warning = canaryFailure;
+    }
+  }
+  const userDir = join34(opts.projectDir, ".specialists", "user");
   const userDirResult = await checkUserDirSpecs(userDir);
   if (userDirResult === "empty")
     return { ready: false, reason: "empty_user_dir" };
   if (userDirResult === "invalid")
     return { ready: false, reason: "invalid_spec_in_user_dir" };
-  return { ready: true };
+  return warning ? { ready: true, warning } : { ready: true };
 }
-function parseArgs13(argv) {
+function parseArgs12(argv) {
   let port = 8000;
   let concurrency = 4;
   let queueTimeoutMs = 5000;
   let shutdownGraceMs = 30000;
   let projectDir = process.cwd();
+  let dbPath;
   let fallbackModel;
   let auditFailureThreshold = 5;
   let allowSkills = false;
   let allowSkillsRoots = [];
-  let allowLocalScripts = false;
   let reloadPollMs = 0;
+  let readinessCanaryMode = "off";
+  const readinessRequiredPiFlags = [];
+  let readinessCanarySpecialist;
+  let readinessCanaryTimeoutMs = 5000;
+  let logLevel = "info";
   for (let i = 0;i < argv.length; i++) {
     const token = argv[i];
     if (token === "--port" && argv[i + 1])
@@ -40639,6 +40690,8 @@ function parseArgs13(argv) {
       shutdownGraceMs = Number(argv[++i]);
     else if ((token === "--project-dir" || token === "--user-dir") && argv[i + 1])
       projectDir = argv[++i];
+    else if (token === "--db-path" && argv[i + 1])
+      dbPath = argv[++i];
     else if (token === "--fallback-model" && argv[i + 1])
       fallbackModel = argv[++i];
     else if (token === "--audit-failure-threshold" && argv[i + 1])
@@ -40648,16 +40701,51 @@ function parseArgs13(argv) {
     else if (token === "--allow-skills-roots" && argv[i + 1])
       allowSkillsRoots = argv[++i].split(":").filter(Boolean);
     else if (token === "--allow-local-scripts")
-      allowLocalScripts = true;
+      throw new Error("--allow-local-scripts is not supported for script-class specialists");
     else if (token === "--reload-poll-ms" && argv[i + 1])
       reloadPollMs = Number(argv[++i]);
+    else if (token === "--readiness-canary" && argv[i + 1]) {
+      const mode = argv[++i];
+      if (mode === "off" || mode === "warn" || mode === "require")
+        readinessCanaryMode = mode;
+    } else if (token === "--readiness-required-pi-flag" && argv[i + 1])
+      readinessRequiredPiFlags.push(argv[++i]);
+    else if (token === "--readiness-canary-specialist" && argv[i + 1])
+      readinessCanarySpecialist = argv[++i];
+    else if (token === "--readiness-canary-timeout-ms" && argv[i + 1])
+      readinessCanaryTimeoutMs = Number(argv[++i]);
+    else if (token === "--log-level" && argv[i + 1]) {
+      const value = argv[++i];
+      if (value === "off" || value === "info" || value === "debug")
+        logLevel = value;
+      else
+        throw new Error("--log-level must be one of: off, info, debug");
+    }
   }
-  return { port, concurrency, queueTimeoutMs, shutdownGraceMs, projectDir, fallbackModel, auditFailureThreshold, allowSkills, allowSkillsRoots, allowLocalScripts, reloadPollMs };
+  return { port, concurrency, queueTimeoutMs, shutdownGraceMs, projectDir, dbPath, fallbackModel, auditFailureThreshold, allowSkills, allowSkillsRoots, reloadPollMs, readinessCanaryMode, readinessRequiredPiFlags, readinessCanarySpecialist, readinessCanaryTimeoutMs, logLevel };
+}
+function checkPiHelpForFlags(flags = DEFAULT_REQUIRED_PI_FLAGS) {
+  const result = spawnSync23("pi", ["--help"], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+  if (result.error || result.status === 127)
+    return "pi_binary_missing";
+  const help = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+  const missing = flags.find((flag2) => !help.includes(flag2));
+  return missing ? "pi_flag_missing" : undefined;
 }
 function sendJson(res, statusCode, body) {
   res.writeHead(statusCode, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
 }
+function emitGenerateLog(logLevel, entry) {
+  if (logLevel === "off")
+    return;
+  console.log(JSON.stringify({ level: logLevel, ts: new Date().toISOString(), ...entry }));
+}
+function shortLogError(value, limit = 240) {
+  const message = value instanceof Error ? value.message : String(value);
+  return message.length <= limit ? message : `${message.slice(0, limit)}\u2026`;
+}
 async function readBody(req) {
   const chunks = [];
   for await (const chunk of req)
@@ -40672,21 +40760,38 @@ async function waitForSlot(limit, timeoutMs, getActive) {
   while (getActive() >= limit) {
     if (Date.now() - startedAt >= timeoutMs)
       return false;
-    await new Promise((resolve13) => setTimeout(resolve13, 25));
+    await new Promise((resolve14) => setTimeout(resolve14, 25));
   }
   return true;
 }
 async function startServe(argv = process.argv.slice(3)) {
-  const args = parseArgs13(argv);
+  const args = parseArgs12(argv);
   const loader = new SpecialistLoader({ projectDir: args.projectDir });
   const dbLocation = resolveObservabilityDbLocation(args.projectDir);
-  ensureObservabilityDbFile(dbLocation);
-  const db = createObservabilitySqliteClient(args.projectDir);
+  const dbPath = args.dbPath ?? dbLocation.dbPath;
+  const db = args.dbPath ? createObservabilitySqliteClientAtPath(args.dbPath) : (() => {
+    ensureObservabilityDbFile(dbLocation);
+    return createObservabilitySqliteClient(args.projectDir);
+  })();
   const readinessState = createReadinessState();
-  const userDir = join35(args.projectDir, ".specialists", "user");
+  const userDir = join34(args.projectDir, ".specialists", "user");
   const hotReload = createUserDirWatcher({ loader, userDir, pollMs: args.reloadPollMs });
   let active = 0;
   const children = new Set;
+  const piCanaryCheck = async () => {
+    const requiredFlags = args.readinessRequiredPiFlags.length > 0 ? args.readinessRequiredPiFlags : DEFAULT_REQUIRED_PI_FLAGS;
+    const compatibilityFailure = checkPiHelpForFlags(requiredFlags);
+    if (compatibilityFailure)
+      return compatibilityFailure;
+    if (!args.readinessCanarySpecialist)
+      return;
+    const result = await runScriptSpecialist({ specialist: args.readinessCanarySpecialist, trace: false, timeout_ms: args.readinessCanaryTimeoutMs }, {
+      loader,
+      fallbackModel: args.fallbackModel,
+      observabilityDbPath: args.projectDir
+    });
+    return result.success ? undefined : "pi_smoke_failed";
+  };
   const server = createServer(async (req, res) => {
     if (req.url === "/healthz")
       return sendJson(res, 200, { ok: true });
@@ -40694,11 +40799,13 @@ async function startServe(argv = process.argv.slice(3)) {
       const result = await evaluateReadiness2({
         state: readinessState,
         projectDir: args.projectDir,
-        dbPath: dbLocation.dbPath,
-        auditFailureThreshold: args.auditFailureThreshold
+        dbPath,
+        auditFailureThreshold: args.auditFailureThreshold,
+        piCanaryMode: args.readinessCanaryMode,
+        piCanaryCheck
       });
       if (result.ready) {
-        return sendJson(res, 200, { ready: true, db_write_failures_total: readinessState.dbWriteFailuresTotal });
+        return sendJson(res, 200, { ready: true, ...result.warning ? { warning: result.warning } : {}, db_write_failures_total: readinessState.dbWriteFailuresTotal });
       }
       return sendJson(res, 503, {
         ready: false,
@@ -40708,27 +40815,65 @@ async function startServe(argv = process.argv.slice(3)) {
     }
     if (req.method !== "POST" || req.url !== "/v1/generate")
       return sendJson(res, 404, { success: false, error: "not_found", error_type: "internal" });
-    if (readinessState.shuttingDown)
+    const requestStartedAt = Date.now();
+    const method = req.method ?? "POST";
+    const path = req.url ?? "/v1/generate";
+    const requestTraceId = randomUUID3();
+    if (readinessState.shuttingDown) {
+      emitGenerateLog(args.logLevel, {
+        trace_id: requestTraceId,
+        specialist: "unknown",
+        status: "internal",
+        duration_ms: Date.now() - requestStartedAt,
+        prompt_bytes: 0,
+        method,
+        path,
+        error: "shutting_down"
+      });
       return sendJson(res, 503, { success: false, error: "shutting_down", error_type: "internal" });
+    }
     const entered = await waitForSlot(args.concurrency, args.queueTimeoutMs, () => active);
-    if (!entered)
+    if (!entered) {
+      emitGenerateLog(args.logLevel, {
+        trace_id: requestTraceId,
+        specialist: "unknown",
+        status: "quota",
+        duration_ms: Date.now() - requestStartedAt,
+        prompt_bytes: 0,
+        method,
+        path,
+        error: "too_many_requests"
+      });
       return sendJson(res, 429, { success: false, error: "too_many_requests", error_type: "quota" });
+    }
     active++;
     const work = (async () => {
+      let promptBytes = 0;
+      let requestedSpecialist = "unknown";
       try {
         const raw = await readBody(req);
+        promptBytes = Buffer.byteLength(raw, "utf8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
         } catch {
+          const duration_ms2 = Date.now() - requestStartedAt;
+          const trace_id = requestTraceId;
+          emitGenerateLog(args.logLevel, { trace_id, specialist: "unknown", status: "invalid_json", duration_ms: duration_ms2, prompt_bytes: promptBytes, method, path, error: "malformed_request" });
           return sendJson(res, 400, { success: false, error: "malformed_request", error_type: "invalid_json" });
         }
-        if (!isValidRequest(parsed))
+        if (!isValidRequest(parsed)) {
+          const duration_ms2 = Date.now() - requestStartedAt;
+          const trace_id = requestTraceId;
+          emitGenerateLog(args.logLevel, { trace_id, specialist: "unknown", status: "invalid_json", duration_ms: duration_ms2, prompt_bytes: promptBytes, method, path, error: "malformed_request" });
           return sendJson(res, 400, { success: false, error: "malformed_request", error_type: "invalid_json" });
+        }
+        requestedSpecialist = parsed.specialist;
         const result = await runScriptSpecialist(parsed, {
           loader,
+          projectDir: args.projectDir,
           fallbackModel: args.fallbackModel,
-          observabilityDbPath: args.projectDir,
+          ...args.dbPath ? { observabilityDbPath: args.dbPath } : {},
           onChild: (child) => {
             children.add(child);
             child.once("exit", () => children.delete(child));
@@ -40736,11 +40881,37 @@ async function startServe(argv = process.argv.slice(3)) {
           onAuditFailure: () => recordAuditFailure(readinessState),
           trust: {
             allowSkills: args.allowSkills,
-            allowSkillsRoots: args.allowSkillsRoots,
-            allowLocalScripts: args.allowLocalScripts
+            allowSkillsRoots: args.allowSkillsRoots
           }
         });
+        const duration_ms = Date.now() - requestStartedAt;
+        const meta = result.meta ?? {};
+        emitGenerateLog(args.logLevel, {
+          trace_id: meta.trace_id ?? requestTraceId,
+          specialist: meta.specialist ?? (typeof parsed === "object" && parsed !== null ? String(parsed.specialist ?? "unknown") : "unknown"),
+          resolved_specialist: meta.resolved_specialist,
+          model: meta.model,
+          status: result.success ? "success" : result.error_type,
+          duration_ms: meta.duration_ms ?? duration_ms,
+          prompt_bytes: promptBytes,
+          method,
+          path,
+          ...result.success ? {} : { error: shortLogError(result.error) }
+        });
         return sendJson(res, 200, result);
+      } catch (error2) {
+        emitGenerateLog(args.logLevel, {
+          trace_id: requestTraceId,
+          specialist: requestedSpecialist,
+          status: "internal",
+          duration_ms: Date.now() - requestStartedAt,
+          prompt_bytes: promptBytes,
+          method,
+          path,
+          error: shortLogError(error2)
+        });
+        if (!res.headersSent)
+          return sendJson(res, 500, { success: false, error: "internal_error", error_type: "internal" });
       } finally {
         active--;
       }
@@ -40768,10 +40939,10 @@ async function startServe(argv = process.argv.slice(3)) {
   console.log(`sp serve listening on ${args.port}`);
   return { server, args, db, readinessState };
 }
-async function run31(argv = process.argv.slice(3)) {
+async function run30(argv = process.argv.slice(3)) {
   await startServe(argv);
 }
-var AUDIT_WINDOW_MS = 60000;
+var AUDIT_WINDOW_MS = 60000, DEFAULT_REQUIRED_PI_FLAGS;
 var init_serve = __esm(() => {
   init_loader();
   init_script_runner();
@@ -40779,24 +40950,25 @@ var init_serve = __esm(() => {
   init_observability_db();
   init_schema();
   init_serve_hot_reload();
+  DEFAULT_REQUIRED_PI_FLAGS = ["--mode", "--no-session", "--no-extensions", "--no-tools", "--no-context-files", "--no-skills", "--no-prompt-templates", "--no-themes"];
 });
 
 // src/cli/script.ts
 var exports_script = {};
 __export(exports_script, {
   scriptCli: () => scriptCli,
-  run: () => run32,
-  parseArgs: () => parseArgs14,
+  run: () => run31,
+  parseArgs: () => parseArgs13,
   mapExitCode: () => mapExitCode
 });
-import { spawnSync as spawnSync23 } from "child_process";
+import { spawnSync as spawnSync24 } from "child_process";
 function parseVar(entry) {
   const index = entry.indexOf("=");
   if (index <= 0)
     throw new Error(`Invalid --vars entry: ${entry}`);
   return [entry.slice(0, index), entry.slice(index + 1)];
 }
-function parseArgs14(argv) {
+function parseArgs13(argv) {
   if (argv.length === 0)
     throw new Error("Missing specialist name");
   const specialist = argv[0];
@@ -40892,7 +41064,7 @@ function printResult(result, json) {
   console.error(result.error);
 }
 function runUnderLock(lockPath, argv) {
-  const flock = spawnSync23("flock", ["-n", lockPath, "env", "SP_SCRIPT_NO_LOCK=1", process.execPath, process.argv[1], "script", ...argv], {
+  const flock = spawnSync24("flock", ["-n", lockPath, "env", "SP_SCRIPT_NO_LOCK=1", process.execPath, process.argv[1], "script", ...argv], {
     encoding: "utf-8",
     stdio: "inherit"
   });
@@ -40902,13 +41074,17 @@ function runUnderLock(lockPath, argv) {
     return 75;
   return flock.status ?? 1;
 }
-async function run32(argv = process.argv.slice(3)) {
-  const args = parseArgs14(argv);
+async function run31(argv = process.argv.slice(3)) {
+  const args = parseArgs13(argv);
   if (args.singleInstance && !process.env.SP_SCRIPT_NO_LOCK) {
     process.exit(runUnderLock(args.singleInstance, argv));
   }
   const loader = new SpecialistLoader({ projectDir: args.projectDir });
-  const result = await runScriptSpecialist(buildRequest(args), { loader, projectDir: args.projectDir, observabilityDbPath: args.dbPath ?? args.projectDir });
+  const result = await runScriptSpecialist(buildRequest(args), {
+    loader,
+    projectDir: args.projectDir,
+    ...args.dbPath ? { observabilityDbPath: args.dbPath } : {}
+  });
   printResult(result, args.json);
   process.exit(mapExitCode(result));
 }
@@ -40916,19 +41092,19 @@ var scriptCli;
 var init_script = __esm(() => {
   init_loader();
   init_script_runner();
-  scriptCli = { parseArgs: parseArgs14, mapExitCode };
+  scriptCli = { parseArgs: parseArgs13, mapExitCode };
 });
 
 // src/cli/help.ts
 var exports_help = {};
 __export(exports_help, {
-  run: () => run33
+  run: () => run32
 });
 function formatCommands(entries) {
   const width = Math.max(...entries.map(([cmd3]) => cmd3.length));
   return entries.map(([cmd3, desc]) => `  ${cmd3.padEnd(width)}   ${desc}`);
 }
-async function run33() {
+async function run32() {
   const lines = [
     "",
     "Specialists lets you run project-scoped specialist agents with a bead-first workflow.",
@@ -40964,7 +41140,7 @@ async function run33() {
     "  Async patterns",
     "    MCP:   use_specialist (foreground, returns result directly)",
     '    CLI:   specialists run <name> --prompt "..."       # job ID prints on stderr',
-    "           specialists feed|poll|result <job-id>         # observe/progress/final output",
+    "           specialists ps|feed|result <job-id>           # observe/progress/final output",
     '    Shell: specialists run <name> --prompt "..." &      # native shell backgrounding',
     "",
     "  Background workflow",
@@ -41014,7 +41190,6 @@ async function run33() {
     "  specialists view --help        View specialist configs",
     "  specialists edit --help        Edit specialist fields (dot-path, presets)",
     "  specialists run --help         Run command details and flags",
-    "  specialists poll --help        [DEPRECATED] use sp ps + sp feed",
     "  specialists steer --help       Mid-run steering details",
     "  specialists resume --help      Multi-turn keep-alive details",
     "  specialists init --help        Bootstrap behavior and workflow injection",
@@ -41042,7 +41217,6 @@ var init_help = __esm(() => {
     ["node", "Run and inspect NodeSupervisor nodes (run/status)"],
     ["epic", "Epic lifecycle management: list/status/resolve wave-bound chain groups"],
     ["feed", "Tail job events; use -f to follow all jobs"],
-    ["poll", "Machine-readable job status polling (for scripts/Claude Code)"],
     ["result", "Print final output of a completed job; --wait polls until done, --timeout <ms> sets a limit"],
     ["clean", "Purge completed job directories (TTL, --all, --keep, --dry-run)"],
     ["merge", "Publish one standalone chain (refuses unresolved epic chains)"],
@@ -41083,7 +41257,7 @@ var init_help = __esm(() => {
 });
 
 // src/index.ts
-import { spawnSync as spawnSync24 } from "child_process";
+import { spawnSync as spawnSync25 } from "child_process";
 
 // node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
@@ -44857,7 +45031,7 @@ var AssertObjectSchema = custom2((v) => v !== null && (typeof v === "object" ||
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
 var TaskCreationParamsSchema = looseObject({
-  ttl: union([number2(), _null3()]).optional(),
+  ttl: number2().optional(),
   pollInterval: number2().optional()
 });
 var TaskMetadataSchema = object2({
@@ -45011,7 +45185,8 @@ var ClientCapabilitiesSchema = object2({
   roots: object2({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   protocolVersion: string2(),
@@ -45036,7 +45211,8 @@ var ServerCapabilitiesSchema = object2({
   tools: object2({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: string2(),
@@ -45151,6 +45327,7 @@ var ResourceSchema = object2({
   uri: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  size: optional(number2()),
   annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
@@ -47146,6 +47323,10 @@ class Protocol {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
       controller.abort();
     }
@@ -47276,7 +47457,9 @@ class Protocol {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request.id);
+      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request.id);
+      }
     });
   }
   _onprogress(notification) {
@@ -48578,7 +48761,7 @@ var next = process.argv[3];
 function wantsHelp() {
   return next === "--help" || next === "-h";
 }
-async function run34() {
+async function run33() {
   if (sub === "install") {
     if (wantsHelp()) {
       console.log([
@@ -48963,7 +49146,7 @@ async function run34() {
         "",
         "Async execution patterns:",
         "  MCP:   use_specialist (foreground, returns result directly)",
-        "  CLI:   run prints [job started: <id>] on stderr, then use feed/poll/result",
+        "  CLI:   run prints [job started: <id>] on stderr, then use ps/feed/result",
         '  Shell: specialists run <name> --prompt "..." &',
         ""
       ].join(`
@@ -49201,53 +49384,6 @@ async function run34() {
     const { run: handler } = await Promise.resolve().then(() => (init_feed(), exports_feed));
     return handler();
   }
-  if (sub === "poll") {
-    if (wantsHelp()) {
-      console.log([
-        "",
-        "Usage: specialists poll <job-id> [--cursor N] [--json]",
-        "",
-        "[DEPRECATED] Scheduled for removal. Use:",
-        "  sp ps <id> --json   for status",
-        "  sp feed <id>        for events",
-        "",
-        "Machine-readable job status polling for scripts and Claude Code.",
-        "Currently file-based; replacements above are DB-canonical.",
-        "",
-        "Output (JSON mode):",
-        "  {",
-        '    "job_id": "abc123",',
-        '    "status": "running" | "done" | "error" | "waiting",',
-        '    "elapsed_ms": 45000,',
-        '    "cursor": 15,',
-        '    "events": [...],          // new events since cursor',
-        '    "output": "...",           // full output when done',
-        '    "model": "claude-sonnet-4-6",',
-        '    "bead_id": "unitAI-123"',
-        "  }",
-        "",
-        "Options:",
-        "  --cursor N   Event index to start from (default: 0)",
-        "  --json       Output as JSON (machine-readable)",
-        "",
-        "Examples:",
-        "  specialists poll abc123 --json",
-        "  specialists poll abc123 --cursor 5 --json",
-        "",
-        "Polling pattern in Claude Code:",
-        "  1. Start job (blocks until done):",
-        "     specialists run planner --bead xtrm-p38n.1",
-        "  2. Or use Claude Code native backgrounding",
-        "  3. Poll for incremental status:",
-        "     specialists poll <job-id> --json",
-        ""
-      ].join(`
-`));
-      return;
-    }
-    const { run: pollHandler } = await Promise.resolve().then(() => (init_poll(), exports_poll));
-    return pollHandler();
-  }
   if (sub === "steer") {
     if (wantsHelp()) {
       console.log([
@@ -49531,7 +49667,7 @@ async function run34() {
     if (wantsHelp()) {
       console.log([
         "",
-        "Usage: specialists serve [--port <n>] [--concurrency <n>] [--shutdown-grace-ms <n>] [--project-dir <path>]",
+        "Usage: specialists serve [--port <n>] [--concurrency <n>] [--shutdown-grace-ms <n>] [--project-dir <path>] [--db-path <observability.db>] [--readiness-canary off|warn|require] [--log-level off|info|debug]",
         "",
         "HTTP wrapper for script-class specialists.",
         "",
@@ -49567,7 +49703,7 @@ async function run34() {
   }
   if (sub === "release") {
     console.error("Deprecated. Use `xt release prepare/publish`. This alias will be removed in v4.0.");
-    const result = spawnSync24("xt", ["release", ...process.argv.slice(3)], { stdio: "inherit" });
+    const result = spawnSync25("xt", ["release", ...process.argv.slice(3)], { stdio: "inherit" });
     if (result.error) {
       console.error(`Failed to run xt release: ${result.error.message}`);
       process.exit(1);
@@ -49587,7 +49723,7 @@ Run 'specialists help' to see available commands.`);
   const server = new SpecialistsServer;
   await server.start();
 }
-run34().catch((error2) => {
+run33().catch((error2) => {
   logger.error(`Fatal error: ${error2}`);
   process.exit(1);
 });