pi-crew 0.10.5 → 0.10.6

package/dist/index.mjs

@@ -10606,7 +10606,8 @@ var init_config_schema = __esm({
         forcePreflight: Type.Optional(Type.Boolean()),
         ambientStatusInjection: Type.Optional(Type.Boolean()),
         perWriteValidation: Type.Optional(Type.Boolean()),
-        scopeModels: Type.Optional(Type.Boolean())
+        scopeModels: Type.Optional(Type.Boolean()),
+        loopGuard: Type.Optional(Type.Boolean())
       },
       { additionalProperties: false }
     );
@@ -11253,6 +11254,7 @@ function parseReliabilityConfig(value) {
     forcePreflight: parseWithSchema(Type.Boolean(), obj.forcePreflight),
     ambientStatusInjection: parseWithSchema(Type.Boolean(), obj.ambientStatusInjection),
     perWriteValidation: parseWithSchema(Type.Boolean(), obj.perWriteValidation),
+    loopGuard: parseWithSchema(Type.Boolean(), obj.loopGuard),
     scopeModels: parseWithSchema(Type.Boolean(), obj.scopeModels)
   };
   return Object.values(reliability).some((entry) => entry !== void 0) ? reliability : void 0;
@@ -12592,7 +12594,10 @@ function parseLines(raw) {
     const separator = trimmed.indexOf(":");
     if (separator === -1) continue;
     const key = trimmed.slice(0, separator).trim();
-    const value = trimmed.slice(separator + 1).trim();
+    let value = trimmed.slice(separator + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
     if (key) frontmatter[key] = value;
   }
   return frontmatter;
@@ -15396,7 +15401,7 @@ var init_errors3 = __esm({
       [ErrorCode.EventLogLockTimeout]: "Another process holds the event-log lock. Check for orphaned `.mkdirlock` directories or stale pi-crew processes, then retry.",
       [ErrorCode.DepthLimitExceeded]: "A pipeline/chain exceeded the recursion depth limit, which usually indicates a circular stage dependency. Review step `dependsOn` chains.",
       [ErrorCode.RunStale]: "The worker stopped heartbeating and was treated as a zombie. Re-run the team (resume or fresh); if it recurs, check `runtime.executeWorkers` / system load.",
-      [ErrorCode.ModelOutOfScope]: "The requested model is not in your pi `enabledModels` allowlist. Either pick a model listed in `enabledModels` (settings.json) or extend the allowlist. The scope gate is opt-in \u2014 disable `runtime.reliability.scopeModels` to allow any model."
+      [ErrorCode.ModelOutOfScope]: "The requested model is not in your pi `enabledModels` allowlist. Either pick a model listed in `enabledModels` (settings.json) or extend the allowlist. The scope gate is opt-in \u2014 disable `reliability.scopeModels` to allow any model."
     };
     CrewError = class extends Error {
       code;
@@ -17345,10 +17350,10 @@ function dedupeTerminalEvents(events) {
   const seen = /* @__PURE__ */ new Set();
   const output = [];
   for (const event of events) {
-    const fingerprint = event.metadata?.fingerprint;
-    if (fingerprint && TERMINAL_EVENT_TYPES.has(event.type)) {
-      if (seen.has(fingerprint)) continue;
-      seen.add(fingerprint);
+    const fingerprint2 = event.metadata?.fingerprint;
+    if (fingerprint2 && TERMINAL_EVENT_TYPES.has(event.type)) {
+      if (seen.has(fingerprint2)) continue;
+      seen.add(fingerprint2);
     }
     output.push(event);
   }
@@ -17692,6 +17697,13 @@ var init_run_event_bus = __esm({
 });
 
 // src/runtime/broker/broker-issuer.ts
+var broker_issuer_exports = {};
+__export(broker_issuer_exports, {
+  getActiveBrokerIssuer: () => getActiveBrokerIssuer,
+  getActiveBrokerRevoker: () => getActiveBrokerRevoker,
+  setActiveBrokerIssuer: () => setActiveBrokerIssuer,
+  setActiveBrokerRevoker: () => setActiveBrokerRevoker
+});
 function setActiveBrokerIssuer(issuer) {
   activeIssuer = issuer;
 }
@@ -29423,8 +29435,21 @@ var init_i18n = __esm({
 });
 
 // src/runtime/run-tracker.ts
+var run_tracker_exports = {};
+__export(run_tracker_exports, {
+  clearRunPromisesForTest: () => clearRunPromisesForTest,
+  detachRunPromise: () => detachRunPromise,
+  hasActiveRunPromise: () => hasActiveRunPromise,
+  hasPendingRunDetach: () => hasPendingRunDetach,
+  registerRunPromise: () => registerRunPromise,
+  rejectRunPromise: () => rejectRunPromise,
+  resolveRunPromise: () => resolveRunPromise,
+  waitForRun: () => waitForRun
+});
 import * as fs49 from "node:fs";
 function registerRunPromise(runId) {
+  const existing = activeRunPromises.get(runId);
+  if (existing) return existing;
   detachRequests.delete(runId);
   let resolve27;
   let reject;
@@ -29436,12 +29461,33 @@ function registerRunPromise(runId) {
   activeRunPromises.set(runId, entry);
   return entry;
 }
+function detachRunPromise(runId, cwd) {
+  const loaded = loadRunManifestById(cwd, runId);
+  if (!loaded) return false;
+  const entry = activeRunPromises.get(runId);
+  if (entry) {
+    activeRunPromises.delete(runId);
+    detachRequests.delete(runId);
+    entry.resolve({ ...loaded, detached: true });
+    return true;
+  }
+  detachRequests.add(runId);
+  return true;
+}
+function hasPendingRunDetach(runId) {
+  return detachRequests.has(runId);
+}
 function resolveRunPromise(runId, result4) {
   const entry = activeRunPromises.get(runId);
   if (entry) {
     entry.resolve(result4);
     activeRunPromises.delete(runId);
   }
+  resolvedRunResults.set(runId, result4);
+  if (resolvedRunResults.size > RESOLVED_TOMBSTONE_LIMIT) {
+    const oldest = resolvedRunResults.keys().next().value;
+    if (oldest !== void 0) resolvedRunResults.delete(oldest);
+  }
 }
 function rejectRunPromise(runId, reason) {
   const entry = activeRunPromises.get(runId);
@@ -29450,6 +29496,16 @@ function rejectRunPromise(runId, reason) {
     activeRunPromises.delete(runId);
   }
 }
+function raceRunPromise(entry, timeoutMs, deadline) {
+  let timer;
+  const remaining = Math.max(0, deadline - Date.now());
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`waitForRun timed out after ${timeoutMs}ms`)), remaining);
+  });
+  return Promise.race([entry.promise, timeoutPromise]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
 async function waitForRun(runId, cwd, options = {}) {
   const { timeoutMs = 3e5, pollIntervalMs = 500 } = options;
   const deadline = Date.now() + timeoutMs;
@@ -29462,23 +29518,15 @@ async function waitForRun(runId, cwd, options = {}) {
     return { ...loaded, detached: true };
   }
   const entry = activeRunPromises.get(runId);
-  if (entry) {
-    let timer;
-    const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => reject(new Error(`waitForRun timed out after ${timeoutMs}ms`)), timeoutMs);
-    });
-    try {
-      return await Promise.race([entry.promise, timeoutPromise]);
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
+  if (entry) return await raceRunPromise(entry, timeoutMs, deadline);
   let attempt = 0;
   while (Date.now() < deadline) {
     if (detachRequests.delete(runId)) {
       const current = loadRunManifestById(cwd, runId);
       if (current) return { ...current, detached: true };
     }
+    const entryNow = activeRunPromises.get(runId);
+    if (entryNow) return await raceRunPromise(entryNow, timeoutMs, deadline);
     if (attempt === 0) {
       const runDir = createRunPaths(cwd, runId).stateRoot;
       if (!fs49.existsSync(runDir)) {
@@ -29489,13 +29537,29 @@ async function waitForRun(runId, cwd, options = {}) {
     if (fresh && isFinishedRunStatus(fresh.manifest.status)) {
       return fresh;
     }
+    const tombstone = resolvedRunResults.get(runId);
+    if (tombstone) {
+      resolvedRunResults.delete(runId);
+      return tombstone;
+    }
     const delay = Math.min(pollIntervalMs, 50 * 2 ** Math.min(attempt, 6));
     await new Promise((r) => setTimeout(r, delay));
     attempt++;
   }
   throw new Error(`waitForRun timed out after ${timeoutMs}ms`);
 }
-var activeRunPromises, detachRequests;
+function hasActiveRunPromise(runId) {
+  return activeRunPromises.has(runId);
+}
+function clearRunPromisesForTest() {
+  detachRequests.clear();
+  resolvedRunResults.clear();
+  for (const entry of activeRunPromises.values()) {
+    entry.reject(new Error("Cleared by test"));
+  }
+  activeRunPromises.clear();
+}
+var activeRunPromises, detachRequests, resolvedRunResults, RESOLVED_TOMBSTONE_LIMIT;
 var init_run_tracker = __esm({
   "src/runtime/run-tracker.ts"() {
     "use strict";
@@ -29503,6 +29567,8 @@ var init_run_tracker = __esm({
     init_process_status();
     activeRunPromises = /* @__PURE__ */ new Map();
     detachRequests = /* @__PURE__ */ new Set();
+    resolvedRunResults = /* @__PURE__ */ new Map();
+    RESOLVED_TOMBSTONE_LIMIT = 32;
   }
 });
 
@@ -29874,7 +29940,6 @@ __export(skill_instructions_exports, {
 });
 import * as fs50 from "node:fs";
 import * as path38 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
 import * as os11 from "node:os";
 function isValidSkillName(name) {
   return name.length > 0 && name.length <= MAX_SKILL_NAME_CHARS && isSafePathId(name);
@@ -29912,8 +29977,19 @@ function collectTaskSkillNames(input) {
   if (input.agent?.skills?.length) names.push(...input.agent.skills);
   if (Array.isArray(input.teamRole?.skills)) names.push(...input.teamRole.skills);
   if (Array.isArray(input.step?.skills)) names.push(...input.step.skills);
-  if (Array.isArray(input.override)) names.push(...input.override);
-  return unique(names);
+  const denylist = /* @__PURE__ */ new Set();
+  if (Array.isArray(input.override)) {
+    for (const item of input.override) {
+      if (item === "*") {
+      } else if (item.startsWith("!")) {
+        denylist.add(item.slice(1));
+      } else {
+        names.push(item);
+      }
+    }
+  }
+  if (denylist.size === 0) return unique(names);
+  return unique(names).filter((n) => !denylist.has(n));
 }
 function resolveTaskSkillNames(input) {
   return collectTaskSkillNames(input).slice(0, MAX_SELECTED_SKILLS);
@@ -30124,10 +30200,11 @@ var init_skill_instructions = __esm({
   "src/runtime/skill-instructions.ts"() {
     "use strict";
     init_internal_error();
+    init_paths();
     init_safe_paths();
     init_skill_effectiveness();
     init_peer_dep();
-    PACKAGE_SKILLS_DIR = path38.resolve(path38.dirname(fileURLToPath4(import.meta.url)), "..", "..", "skills");
+    PACKAGE_SKILLS_DIR = path38.join(packageRoot(), "skills");
     MAX_SKILL_CHARS = 1500;
     MAX_TOTAL_CHARS = 6e3;
     MAX_SKILL_NAME_CHARS = 80;
@@ -32305,7 +32382,6 @@ var init_validate = __esm({
 import * as fs54 from "node:fs";
 import * as os12 from "node:os";
 import * as path40 from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
 function listSkillDirs(cwd) {
   return [
     { root: PACKAGE_SKILLS_DIR2, source: "package" },
@@ -32423,9 +32499,10 @@ var init_discover_skills = __esm({
     "use strict";
     init_peer_dep();
     init_internal_error();
+    init_paths();
     init_safe_paths();
     init_validate();
-    PACKAGE_SKILLS_DIR2 = path40.resolve(path40.dirname(fileURLToPath5(import.meta.url)), "..", "..", "skills");
+    PACKAGE_SKILLS_DIR2 = path40.join(packageRoot(), "skills");
     CACHE_TTL_MS = 3e4;
     cache2 = null;
     lastDiagnostics = [];
@@ -46534,14 +46611,14 @@ var init_protocol = __esm({
 });
 
 // src/runtime/scratchpad/engine.ts
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SNAPSHOT_MAX_BYTES, GUEST_PATH;
 var init_engine = __esm({
   "src/runtime/scratchpad/engine.ts"() {
     "use strict";
     init_protocol();
     SNAPSHOT_MAX_BYTES = 4 * 1024 * 1024;
-    GUEST_PATH = fileURLToPath6(new URL("./guest.ts", import.meta.url));
+    GUEST_PATH = fileURLToPath4(new URL("./guest.ts", import.meta.url));
   }
 });
 
@@ -48535,6 +48612,7 @@ function buildKnowledgeFragment(cwd, query) {
 }
 function registerKnowledgeInjection(pi) {
   pi.on("before_agent_start", (event) => {
+    if (process.env.PI_CREW_KIND === "subagent") return;
     const options = event.systemPromptOptions ?? {};
     const cwd = typeof options.cwd === "string" ? options.cwd : process.cwd();
     const fragment = buildKnowledgeFragment(cwd);
@@ -49079,10 +49157,11 @@ function readOnlyRoleInstructions(role) {
     "- Your final RESULT TEXT is persisted automatically by the runner (as a result artifact and, if the step declares `output:`, to a shared file). To deliver a plan, report, or findings, EMIT THEM AS TEXT in your final result \u2014 do NOT try to write a file yourself."
   ].join("\n");
 }
-function coordinationBridgeInstructions(task) {
+function coordinationBridgeInstructions(task, opts) {
+  const includeMailboxTarget = opts?.includeMailboxTarget ?? true;
   return [
     "# Crew Coordination Channel",
-    `Mailbox target for this task: ${task.id}`,
+    ...includeMailboxTarget ? [`Mailbox target for this task: ${task.id}`] : [],
     "Use the run mailbox contract for coordination with the leader/orchestrator:",
     "- If blocked or uncertain, report the blocker in your final result and, when mailbox tools/API are available, send an inbox/outbox message addressed to the leader.",
     "- Never guess implementation details that materially affect decisions. If the `ask` tool is available and you need a clarification, a decision, or a missing requirement before you can proceed safely, call `ask` and wait \u2014 a parked question is cheaper than a wrong build.",
@@ -49212,8 +49291,6 @@ async function renderTaskPrompt(manifest, step, task, agent, skillBlock = "", pr
     `State root: ${manifest.stateRoot}`,
     `Artifacts root: ${manifest.artifactsRoot}`,
     `Events path: ${manifest.eventsPath}`,
-    `Task ID: ${task.id}`,
-    `Task cwd: ${task.cwd}`,
     `Workspace mode: ${manifest.workspaceMode}`,
     "",
     "Protocol:",
@@ -49221,10 +49298,14 @@ async function renderTaskPrompt(manifest, step, task, agent, skillBlock = "", pr
     "- Report blockers and verification evidence in the final result.",
     "- Do not claim completion without evidence.",
     "- Follow the Task Packet contract below; escalate if any contract field is impossible to satisfy.",
+    // PROMPT-2 (port of OMO-slim task-rejection, improved phrasing): a
+    // universal lane-guard for every role — complements the per-agent reject
+    // sections in agents/*.md with a scaffold-level instruction.
+    "- If a task falls outside your role, do not attempt partial work. Return a concise rejection to the leader naming the lane that should own it.",
     "",
     readOnlyRoleInstructions(task.role),
     "",
-    coordinationBridgeInstructions(task),
+    coordinationBridgeInstructions(task, { includeMailboxTarget: false }),
     "",
     stableComponents.treeBlock,
     "",
@@ -49232,12 +49313,19 @@ async function renderTaskPrompt(manifest, step, task, agent, skillBlock = "", pr
     "",
     toolGuidanceBlock(agent),
     "",
-    // O4: project knowledge (.crew/knowledge.md) — workers don't load the
-    // pi-crew extension (spawned with --no-extensions), so before_agent_start
-    // never fires for them. Inject here so every worker sees project knowledge.
+    // O4 (ARCH-2 corrected): project knowledge (.crew/knowledge.md). Builtin
+    // workers don't load the pi-crew extension (agents declare no `extensions:`
+    // in frontmatter), so before_agent_start knowledge injection doesn't fire
+    // for them — and the knowledge-injection hook now early-returns on
+    // PI_CREW_KIND=subagent, so even agents that DO declare the extension
+    // can't double-inject. This prompt-builder fragment is the single source
+    // of worker project knowledge.
     stableComponents.knowledgeFragment
   ].filter(Boolean).join("\n");
   const dynamicSuffix = [
+    `Task ID: ${task.id}`,
+    `Task cwd: ${task.cwd}`,
+    `Mailbox target: ${task.id}`,
     `Goal:
 ${manifest.goal}`,
     "",
@@ -56505,6 +56593,11 @@ var init_handle_settings = __esm({
       "reliability.autoRetry": false,
       "reliability.autoRecover": false,
       "reliability.cleanupOrphanedTempDirs": true,
+      "reliability.loopGuard": true,
+      "reliability.perWriteValidation": true,
+      "reliability.ambientStatusInjection": true,
+      "reliability.forcePreflight": false,
+      "reliability.scopeModels": false,
       "telemetry.enabled": false,
       "notifications.enabled": false
     };
@@ -56584,6 +56677,11 @@ var init_handle_settings = __esm({
       "reliability.autoRetry",
       "reliability.autoRecover",
       "reliability.cleanupOrphanedTempDirs",
+      "reliability.loopGuard",
+      "reliability.perWriteValidation",
+      "reliability.ambientStatusInjection",
+      "reliability.forcePreflight",
+      "reliability.scopeModels",
       "reliability.deadletterThreshold",
       "reliability.retryPolicy.maxAttempts",
       "reliability.retryPolicy.backoffMs",
@@ -57252,15 +57350,13 @@ import { spawn as spawn6 } from "node:child_process";
 import * as fs89 from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import * as path69 from "node:path";
-import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL2 } from "node:url";
-function packageRootFromRuntime() {
-  return path69.resolve(path69.dirname(fileURLToPath7(import.meta.url)), "..", "..");
-}
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 function jitiRegisterPathFromPackageJson(packageJsonPath) {
   return path69.join(path69.dirname(packageJsonPath), "lib", "jiti-register.mjs");
 }
-function resolveJitiRegisterPath(packageRoot2 = packageRootFromRuntime(), exists = fs89.existsSync) {
-  let current = path69.resolve(packageRoot2);
+function resolveJitiRegisterPath(pkgRoot, exists = fs89.existsSync) {
+  const effectiveRoot = pkgRoot ?? packageRoot();
+  let current = path69.resolve(effectiveRoot);
   const root = path69.parse(current).root;
   while (true) {
     const candidate = path69.join(current, "node_modules", "jiti", "lib", "jiti-register.mjs");
@@ -57313,7 +57409,7 @@ function buildLoaderUnavailableMessage(searchedFrom) {
 }
 function getBackgroundRunnerCommand(runnerPath, cwd, runId, loaderInput = resolveTypeScriptLoader(), reportDirectory) {
   const loader = normalizeLoaderInput(loaderInput);
-  if (!loader) throw new Error(buildLoaderUnavailableMessage(packageRootFromRuntime()));
+  if (!loader) throw new Error(buildLoaderUnavailableMessage(packageRoot()));
   const memoryLimit = "--max-old-space-size=512";
   const reportOn = !(getCrewEnv("PI_CREW_BG_REPORT_ON_FATAL") === "0" || getCrewEnv("PI_TEAMS_BG_REPORT_ON_FATAL") === "0");
   const reportDir = reportDirectory ?? path69.dirname(runnerPath);
@@ -57343,6 +57439,10 @@ function getBackgroundRunnerCommand(runnerPath, cwd, runId, loaderInput = resolv
 function buildBackgroundRunnerEnv(env) {
   return { ...env, PI_CREW_ASYNC_RUN: "1" };
 }
+function buildBrokerStdinLine(runId, socketPath, tasks) {
+  return `${JSON.stringify({ v: 2, runId, socketPath, tasks })}
+`;
+}
 async function spawnBackgroundTeamRun(manifest) {
   const runnerPath = path69.join(packageRoot(), "src", "runtime", "background-runner.ts");
   const logPath = path69.join(manifest.stateRoot, "background.log");
@@ -57354,7 +57454,7 @@ async function spawnBackgroundTeamRun(manifest) {
   const childEnv = buildBackgroundRunnerEnv(peerDepDir ? { ...filteredEnv, [PEER_DEP_DIR_ENV]: peerDepDir } : filteredEnv);
   const loader = resolveTypeScriptLoader();
   if (!loader) {
-    const message = buildLoaderUnavailableMessage(packageRootFromRuntime());
+    const message = buildLoaderUnavailableMessage(packageRoot());
     await appendEventAsync(manifest.eventsPath, {
       type: "async.failed",
       runId: manifest.runId,
@@ -57369,11 +57469,49 @@ async function spawnBackgroundTeamRun(manifest) {
     cwd: manifest.cwd,
     detached: true,
     setsid: true,
-    stdio: ["ignore", "pipe", "pipe"],
+    // F4 (2026-09-12 live battery): stdin is a PIPE — broker credentials
+    // travel heap → pipe → heap right after spawn (see below). Previously
+    // "ignore", which (together with the env allowlist and the missing
+    // runner-side issuer) left EVERY async worker broker-less: ask/message
+    // fell back to "proceed with best judgment" silently.
+    stdio: ["pipe", "pipe", "pipe"],
     env: childEnv,
     windowsHide: true
   };
   const child = spawn6(process.execPath, command.args, spawnOpts);
+  try {
+    let line4;
+    const { getActiveBrokerIssuer: getActiveBrokerIssuer2 } = await Promise.resolve().then(() => (init_broker_issuer(), broker_issuer_exports));
+    const issuer = getActiveBrokerIssuer2();
+    if (issuer) {
+      const { loadRunManifestByIdAsync: loadRunManifestByIdAsync2 } = await Promise.resolve().then(() => (init_state_store(), state_store_exports));
+      const loaded = await loadRunManifestByIdAsync2(manifest.cwd, manifest.runId);
+      const runTasks = loaded?.tasks ?? [];
+      const tasks = {};
+      let socketPath;
+      for (const task of runTasks) {
+        if (!task?.id) continue;
+        const creds = await issuer(manifest.runId, task.id);
+        if (creds) {
+          tasks[task.id] = creds.token;
+          socketPath ??= creds.socketPath;
+        }
+      }
+      if (socketPath && Object.keys(tasks).length > 0) {
+        line4 = buildBrokerStdinLine(manifest.runId, socketPath, tasks);
+        child.stdin?.write(line4);
+      } else {
+        child.stdin?.write("\n");
+      }
+    } else {
+      child.stdin?.write("\n");
+    }
+  } catch {
+  }
+  try {
+    child.stdin?.end();
+  } catch {
+  }
   child.stdout?.destroy();
   const STDERR_CAPTURE_LIMIT = 256 * 1024;
   const stderrChunks = [];
@@ -67218,7 +67356,7 @@ __export(team_runner_exports, {
 import { spawn as spawn7 } from "node:child_process";
 import * as fs104 from "node:fs";
 import * as path83 from "node:path";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 function startTeamRunHeartbeat(stateRoot, runId) {
   const heartbeatPath = path83.join(stateRoot, "heartbeat.json");
   const writeHeartbeat = () => {
@@ -67245,8 +67383,8 @@ function startTeamRunHeartbeat(stateRoot, runId) {
 function perfScriptPath(scriptName) {
   try {
     const candidates = [
-      fileURLToPath8(new URL(`../../scripts/${scriptName}`, import.meta.url)),
-      fileURLToPath8(new URL(`../scripts/${scriptName}`, import.meta.url))
+      fileURLToPath5(new URL(`../../scripts/${scriptName}`, import.meta.url)),
+      fileURLToPath5(new URL(`../scripts/${scriptName}`, import.meta.url))
     ];
     return candidates.find((p) => fs104.existsSync(p));
   } catch {
@@ -71699,6 +71837,7 @@ ${dwfResult.manifest.summary ?? ""}`,
   const executeWorkers = runtime.kind !== "scaffold";
   if (executeWorkers && ctx.startForegroundRun) {
     const fgDeadline = resolveRunDeadline(ctx, params, executedConfig);
+    registerRunPromise(updatedManifest.runId);
     ctx.onRunStarted?.(updatedManifest.runId);
     const fgSignal = fgDeadline.signal;
     let fgAbortListener;
@@ -71746,6 +71885,36 @@ ${dwfResult.manifest.summary ?? ""}`,
     }, updatedManifest.runId);
     try {
       const completed = await waitForRun(updatedManifest.runId, resolvedCtx.cwd, { timeoutMs: fgDeadline.deadlineMs });
+      if (completed.waiting) {
+        const w = completed.waiting;
+        const secondsLeft = Math.max(0, Math.round((w.deadline - Date.now()) / 1e3));
+        const lines = [
+          `pi-crew run WAITING for your answer: ${updatedManifest.runId}`,
+          `Team: ${team.name} \xB7 Workflow: ${workflow.name}`,
+          `Task ${w.taskId} (${w.questionId.substring(0, 8)}) parked on ask \u2014 ${secondsLeft}s until the deadline (then the worker proceeds with best judgment):`,
+          "",
+          `Q: ${w.question}`
+        ];
+        if (w.options?.length) {
+          lines.push("", "Options:", ...w.options.map((o, i) => `  ${i + 1}. ${o}`));
+        }
+        lines.push(
+          "",
+          "Answer now (run keeps executing):",
+          `  team action='respond' taskId='${w.taskId}' message='<your answer>'`,
+          "then re-block until the run finishes:",
+          `  team action='wait' runId='${updatedManifest.runId}'`
+        );
+        return result(lines.join("\n"), {
+          action: "run",
+          status: "ok",
+          runId: updatedManifest.runId,
+          artifactsRoot: updatedManifest.artifactsRoot,
+          taskId: w.taskId,
+          questionId: w.questionId,
+          waiting: true
+        });
+      }
       if (completed.detached) {
         return result(
           [
@@ -75309,6 +75478,41 @@ var init_settings_overlay = __esm({
         tab: "advanced",
         description: "Remove /tmp/pi-crew-* directories after reconciliation (1h age threshold)."
       },
+      {
+        id: "reliability.loopGuard",
+        label: "Tool Loop Guard",
+        type: "boolean",
+        tab: "advanced",
+        description: "Warn at 3 / block at 5 identical consecutive read-only tool results (ARCH-1)."
+      },
+      {
+        id: "reliability.perWriteValidation",
+        label: "Per-Write Validation",
+        type: "boolean",
+        tab: "advanced",
+        description: "Validate state writes as they are made (default on)."
+      },
+      {
+        id: "reliability.ambientStatusInjection",
+        label: "Ambient Status Injection",
+        type: "boolean",
+        tab: "advanced",
+        description: "Inject a compact crew-status note into context on every LLM call while runs are in-flight."
+      },
+      {
+        id: "reliability.forcePreflight",
+        label: "Force Preflight (audit override)",
+        type: "boolean",
+        tab: "advanced",
+        description: "Skip usage-threshold BLOCK/WARN preflight. Default false (enforce). Audit/debug only."
+      },
+      {
+        id: "reliability.scopeModels",
+        label: "Scope Models (F7)",
+        type: "boolean",
+        tab: "advanced",
+        description: "Enforce user enabledModels allowlist on subagent model choices. Default false."
+      },
       {
         id: "telemetry.enabled",
         label: "Telemetry",
@@ -75359,6 +75563,11 @@ var init_settings_overlay = __esm({
       "reliability.autoRetry": false,
       "reliability.autoRecover": false,
       "reliability.cleanupOrphanedTempDirs": true,
+      "reliability.loopGuard": true,
+      "reliability.perWriteValidation": true,
+      "reliability.ambientStatusInjection": true,
+      "reliability.forcePreflight": false,
+      "reliability.scopeModels": false,
       "telemetry.enabled": false,
       "notifications.enabled": false
     };
@@ -78475,6 +78684,8 @@ function startForegroundWatchdog(opts) {
   const maxMonitorMs = opts.maxMonitorMs ?? DEFAULT_MAX_MONITOR_MS;
   const startTime = Date.now();
   if (activeWatchdogs.has(runId)) return;
+  let consecutiveHungNotices = 0;
+  const HUNG_NOTICE_CAP = 2;
   const check = () => {
     if (Date.now() - startTime > maxMonitorMs) {
       activeWatchdogs.delete(runId);
@@ -78502,13 +78713,23 @@ function startForegroundWatchdog(opts) {
       const now = Date.now();
       if (isLikelyOrphanedActiveRun(manifest, agents, now)) {
         const detail = `status=${manifest.status}, updatedAt=${manifest.updatedAt}, agents=${agents.length}`;
+        consecutiveHungNotices += 1;
         try {
-          pi.sendUserMessage(
-            `pi-crew watchdog: run ${runId} appears hung (${detail}). Consider running team action='cancel' runId='${runId}' or team action='doctor'.`,
-            { deliverAs: "followUp" }
-          );
+          if (consecutiveHungNotices <= HUNG_NOTICE_CAP) {
+            pi.sendUserMessage(
+              `pi-crew watchdog: run ${runId} appears hung (${detail}). Consider running team action='cancel' runId='${runId}' or team action='doctor'.`,
+              { deliverAs: "followUp" }
+            );
+          } else if (consecutiveHungNotices === HUNG_NOTICE_CAP + 1) {
+            pi.sendUserMessage(
+              `pi-crew watchdog: run ${runId} is still hung after ${consecutiveHungNotices} checks \u2014 going quiet now. Intervene via team action='cancel' runId='${runId}', team action='doctor', or leave it; a completion notice will still fire.`,
+              { deliverAs: "followUp" }
+            );
+          }
         } catch {
         }
+      } else {
+        consecutiveHungNotices = 0;
       }
     } catch {
     }
@@ -82945,6 +83166,29 @@ function registerCrewMessageRenderers(pi) {
   pi.registerMessageRenderer?.("crew:resume-directive", renderResumeDirective);
 }
 
+// src/extension/post-init-skill-check.ts
+init_skill_instructions();
+async function runPostInitSkillCheck(cwd) {
+  const result4 = renderSkillInstructions({ cwd, role: "executor" });
+  const total = result4.names.length;
+  const missingMatches = result4.block.match(/Skill '([^']+)' was selected but no SKILL\.md file was found/g);
+  const missing = missingMatches ? missingMatches.map((m) => m.match(/'([^']+)'/)[1]) : [];
+  const resolved = total - missing.length;
+  let severity;
+  let message;
+  if (resolved === total) {
+    severity = "ok";
+    message = `All ${total} default skills resolved`;
+  } else if (resolved === 0) {
+    severity = "error";
+    message = `0/${total} default skills resolved \u2014 likely bundle stale. Run \`npm run build:bundle\`.`;
+  } else {
+    severity = "warn";
+    message = `${resolved}/${total} default skills resolved \u2014 degraded: ${missing.join(", ")}`;
+  }
+  return { total, resolved, missing, severity, message };
+}
+
 // src/extension/registration/command-registration.ts
 init_config();
 init_powerbar_publisher();
@@ -84551,7 +84795,6 @@ function startForegroundRunImpl(pi, ctx, extensionCtx, runner, runId) {
 init_config();
 import * as fs118 from "node:fs";
 import * as path94 from "node:path";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
 
 // src/runtime/per-write-validator.ts
 import { readFileSync as readFileSync92 } from "node:fs";
@@ -84622,6 +84865,7 @@ function buildValidationBlocker(filePath, error) {
 }
 
 // src/extension/registration/hook-registration.ts
+init_paths();
 init_safe_paths();
 
 // src/extension/team-tool/destructive-gate.ts
@@ -84643,18 +84887,177 @@ function shouldBlockDestructiveTeamAction(action, input) {
   return `Destructive action '${action}' requires confirm=true${action === "delete" ? " (or force=true to bypass reference checks)" : ""}.`;
 }
 
+// src/extension/registration/tool-loop-guard.ts
+var LOOP_GUARD_WARN_AT = 3;
+var LOOP_GUARD_BLOCK_AT = 5;
+var LOOP_GUARD_EXEMPT = {
+  team: true,
+  crew_agent: true,
+  Agent: true,
+  get_subagent_result: true
+};
+var LOOP_GUARD_BLOCK_TOOLS = {
+  read: true,
+  grep: true,
+  glob: true,
+  find: true,
+  ls: true
+};
+var WAIT_TOOL = "ask";
+var WAIT_GUARD_WARN_AT = 2;
+var WAIT_GUARD_BLOCK_AT = 2;
+var MAX_TRACKED_FINGERPRINTS = 512;
+var LOOP_GUARD_MARKER = "[REPEATED TOOL CALLS - STOP]";
+var WAIT_GUARD_MARKER = "[REPEATED WAIT TOOL - END TURN]";
+var LOOP_GUARD_WARNING = `
+${LOOP_GUARD_MARKER}
+
+You have issued the exact same tool call with identical arguments ${LOOP_GUARD_WARN_AT} times in a row and received identical results. This is an infinite loop and you are making no progress.
+
+STOP repeating this call. Instead:
+1. Reconsider what you are looking for \u2014 the result above already contains what this call can tell you.
+2. If you need different information, make a DIFFERENT call (different path, pattern, or tool).
+3. If the task is actually done, produce your final answer now instead of calling more tools.
+`;
+var WAIT_GUARD_WARNING = `
+${WAIT_GUARD_MARKER}
+
+You have called \`ask\` ${WAIT_GUARD_WARN_AT} times in this turn. Its contract is to stop and wait \u2014 do not call it again in the same turn.
+
+STOP calling tools that wait. Continue with what you can do, or produce your final answer; the reply arrives as a separate message later.
+`;
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === "object") {
+    const record = value;
+    const out = {};
+    for (const key of Object.keys(record).sort()) {
+      out[key] = sortValue(record[key]);
+    }
+    return out;
+  }
+  return value;
+}
+function fingerprint(tool, args) {
+  return `${tool.toLowerCase()}:${stableStringify(args ?? null)}`;
+}
+function createLoopGuardState() {
+  const runs = /* @__PURE__ */ new Map();
+  let lastFingerprint = null;
+  let waitRunCount = 0;
+  function evictIfNeeded() {
+    while (runs.size > MAX_TRACKED_FINGERPRINTS) {
+      const oldest = runs.keys().next().value;
+      if (oldest === void 0) break;
+      runs.delete(oldest);
+    }
+  }
+  function onToolResult(tool, args, output) {
+    const toolLower = tool.toLowerCase();
+    if (toolLower === WAIT_TOOL) {
+      waitRunCount += 1;
+      if (waitRunCount === WAIT_GUARD_WARN_AT) return [{ type: "text", text: WAIT_GUARD_WARNING }];
+      return [];
+    }
+    waitRunCount = 0;
+    if (LOOP_GUARD_EXEMPT[tool]) return [];
+    const fp = fingerprint(tool, args);
+    const outputKey = stableStringify(output);
+    const state2 = runs.get(fp) ?? { runCount: 0, lastOutput: null };
+    if (fp !== lastFingerprint) {
+      state2.runCount = 0;
+    }
+    if (state2.lastOutput === outputKey) {
+      state2.runCount += 1;
+    } else {
+      state2.runCount = 1;
+      state2.lastOutput = outputKey;
+    }
+    runs.set(fp, state2);
+    evictIfNeeded();
+    lastFingerprint = fp;
+    if (state2.runCount === LOOP_GUARD_WARN_AT) {
+      return [{ type: "text", text: LOOP_GUARD_WARNING }];
+    }
+    return [];
+  }
+  function onToolCall(tool, args) {
+    const toolLower = tool.toLowerCase();
+    if (toolLower === WAIT_TOOL) {
+      if (waitRunCount >= WAIT_GUARD_BLOCK_AT) {
+        return {
+          block: true,
+          reason: `pi-crew loop guard: \`ask\` called ${waitRunCount} times this turn \u2014 its contract is to wait. End your turn; the reply arrives as a separate message.`
+        };
+      }
+      return {};
+    }
+    if (LOOP_GUARD_EXEMPT[tool]) return {};
+    if (!LOOP_GUARD_BLOCK_TOOLS[toolLower]) return {};
+    const fp = fingerprint(tool, args);
+    const state2 = runs.get(fp);
+    if (state2 && state2.runCount >= LOOP_GUARD_BLOCK_AT) {
+      return {
+        block: true,
+        reason: `pi-crew loop guard: this exact ${tool} call (identical arguments) has returned identical results ${state2.runCount} times in a row. Make a DIFFERENT call (different path, pattern, or tool), or produce your final answer.`
+      };
+    }
+    return {};
+  }
+  function reset() {
+    runs.clear();
+    lastFingerprint = null;
+    waitRunCount = 0;
+  }
+  return { onToolResult, onToolCall, reset };
+}
+function installToolLoopGuard(pi) {
+  const state2 = createLoopGuardState();
+  try {
+    pi.on("tool_call", async (event) => {
+      const verdict = state2.onToolCall(event.toolName, event.input);
+      if (verdict.block) {
+        return { block: true, reason: verdict.reason };
+      }
+      return void 0;
+    });
+  } catch {
+  }
+  try {
+    pi.on("tool_result", (event) => {
+      const appends = state2.onToolResult(event.toolName, event.input, event.content);
+      if (appends.length === 0) return void 0;
+      const existing = Array.isArray(event.content) ? event.content : [];
+      return { content: [...existing, ...appends] };
+    });
+  } catch {
+  }
+}
+
 // src/extension/registration/hook-registration.ts
 function installPiHooks(pi, ctx) {
   installResourcesDiscoverHook(pi, ctx);
   installToolCallHook(pi, ctx);
   installToolResultHook(pi, ctx);
+  installToolLoopGuardIfEnabled(pi, ctx);
+}
+function installToolLoopGuardIfEnabled(pi, ctx) {
+  try {
+    const cwd = ctx.currentCtx?.cwd ?? process.cwd();
+    if (loadConfig(cwd).config.reliability?.loopGuard === false) return;
+  } catch {
+  }
+  installToolLoopGuard(pi);
 }
 function installResourcesDiscoverHook(pi, ctx) {
   try {
     pi.on("resources_discover", () => {
       const sessionCwd = ctx.currentCtx?.cwd ?? process.cwd();
       const skillDir = path94.resolve(sessionCwd, "skills");
-      const extSkillDir = path94.resolve(path94.dirname(fileURLToPath9(import.meta.url)), "..", "..", "skills");
+      const extSkillDir = path94.join(packageRoot(), "skills");
       const paths = [];
       if (fs118.existsSync(extSkillDir)) paths.push(extSkillDir);
       if (skillDir !== extSkillDir && fs118.existsSync(skillDir)) {
@@ -85244,7 +85647,7 @@ function safeStringify(value) {
   }
 }
 var WAIT_REQUEST_TIMEOUT_SEC_MAX = 3600;
-var WAIT_REQUEST_TIMEOUT_SEC_DEFAULT = 600;
+var WAIT_REQUEST_TIMEOUT_SEC_DEFAULT = 480;
 var WAIT_QUESTION_MAX_CHARS = 8192;
 var WAIT_OPTIONS_MAX = 16;
 var WAIT_OPTION_MAX_CHARS = 256;
@@ -85352,6 +85755,29 @@ function recordWaitPolicyRejection(manifest, taskId, method) {
   );
 }
 
+// src/runtime/broker/wait-push.ts
+init_state_store();
+async function pushWaitingToForegroundWaiter(params) {
+  try {
+    const { resolveRunPromise: resolveRunPromise2 } = await Promise.resolve().then(() => (init_run_tracker(), run_tracker_exports));
+    const freshPark = loadRunManifestById(params.cwd ?? process.cwd(), params.runId);
+    if (freshPark) {
+      resolveRunPromise2(params.runId, {
+        manifest: freshPark.manifest,
+        tasks: freshPark.tasks,
+        waiting: {
+          taskId: params.taskId,
+          questionId: params.questionId,
+          question: params.question,
+          deadline: params.deadline,
+          ...params.options ? { options: params.options } : {}
+        }
+      });
+    }
+  } catch {
+  }
+}
+
 // src/runtime/broker/wait-status-cache.ts
 init_state_store();
 import * as fs123 from "node:fs";
@@ -86309,22 +86735,13 @@ var CrewBroker = class {
     });
     await pollUntilDone();
   }
-  /**
-   * Phase 3: steer.push — push steering message to a running worker.
-   *
-   * Dual-write strategy for durability:
-   *  1. Mailbox append (appendMailboxMessageAsync) — feeds the live broker
-   *     fanout to connected subscribers AND persists to the mailbox inbox
-   *     JSONL for later read.
-   *  2. Steering-file append — writes the steer body to
-   *     ${artifactsRoot}/steering/${taskId}.jsonl, the same file the
-   *     child's pollSteering() polls via PI_CREW_STEERING_FILE. This is
-   *     the durable fallback: even if the recipient child's broker connection is down, the
-   *     child picks up the steer on its next poll tick.
-   *
-   * A steering-file write failure does NOT fail the steer push — the
-   * mailbox write (1) has already succeeded.
-   */
+  /** Phase 3: steer.push — push steering message to a running worker.
+   *  Dual-write for durability: (1) mailbox append feeds the live broker
+   *  fanout AND persists to the inbox JSONL; (2) steering-file append writes
+   *  ${artifactsRoot}/steering/${taskId}.jsonl — the durable fallback the
+   *  child's pollSteering() polls via PI_CREW_STEERING_FILE even when its
+   *  broker connection is down. A steering-file write failure does NOT fail
+   *  the push — the mailbox write has already succeeded. */
   async handleSteerPush(conn, id, params) {
     if (conn.role !== "orchestrator") {
       this.sendError(conn, id, "forbidden", "steer.push requires orchestrator role");
@@ -86879,6 +87296,15 @@ ${sanitizedText}
       timeoutSec: clampSec,
       clamped
     });
+    await pushWaitingToForegroundWaiter({
+      cwd: this.options.cwd,
+      runId,
+      taskId,
+      questionId,
+      question: parsed.question,
+      deadline,
+      ...parsed.options ? { options: parsed.options } : {}
+    });
   }
   /** WP-2/R2: terminal report of the parked `ask` tool — flips the task
    *  waiting→running and clears the park coordination state. Scoped to
@@ -86989,7 +87415,9 @@ init_child_pi();
 
 // src/runtime/detached-run-results.ts
 init_state_store();
+init_internal_error();
 init_process_status();
+var MAX_DELIVERY_ATTEMPTS = 3;
 var detachedRuns = /* @__PURE__ */ new Map();
 function hasDetachedRuns() {
   return detachedRuns.size > 0;
@@ -87025,6 +87453,17 @@ function peekFinishedDetachedRunResults(options = {}) {
       continue;
     }
     if (!isFinishedRunStatus(loaded.manifest.status)) continue;
+    entry.attempts += 1;
+    if (entry.attempts > MAX_DELIVERY_ATTEMPTS) {
+      detachedRuns.delete(entry.runId);
+      logInternalError(
+        "detached-run-results.delivery-gave-up",
+        new Error("delivery attempts exceeded"),
+        `runId=${entry.runId} attempts=${entry.attempts} \u2014 dropped after ${MAX_DELIVERY_ATTEMPTS} failed sends`,
+        "warn"
+      );
+      continue;
+    }
     ready.push({ runId: entry.runId, text: formatDetachedRunResult(loaded.manifest, loaded.tasks) });
   }
   return ready;
@@ -87500,10 +87939,10 @@ var CrewAgentPane = class {
       this.lastTranscriptReadAt = Date.now();
     }
     const items = this.lastItems;
-    const fingerprint = this.bodyFingerprint(items, width);
-    if (fingerprint !== this.bodyKey) {
+    const fingerprint2 = this.bodyFingerprint(items, width);
+    if (fingerprint2 !== this.bodyKey) {
       this.cachedBody = this.buildBody(items, width);
-      this.bodyKey = fingerprint;
+      this.bodyKey = fingerprint2;
     }
     const body = this.cachedBody;
     const header = this.headerLines(manifest, width);
@@ -90299,7 +90738,7 @@ function installCrossExtensionWiring(pi, ctx) {
 }
 
 // src/extension/register.ts
-function registerPiTeams(pi) {
+async function registerPiTeams(pi) {
   resetTimings();
   time("register:start");
   installChildProcessAbortShield();
@@ -90349,6 +90788,12 @@ function registerPiTeams(pi) {
   } catch (err2) {
     console.warn("[pi-crew] crew-vibes initialization failed:", err2 instanceof Error ? err2.message : err2);
   }
+  const skillCheck = await runPostInitSkillCheck(process.cwd());
+  if (skillCheck.severity === "error") {
+    console.error(`[pi-crew] ${skillCheck.message}`);
+  } else if (skillCheck.severity === "warn") {
+    console.warn(`[pi-crew] ${skillCheck.message}`);
+  }
 }
 
 // index.bundle.ts
@@ -90359,6 +90804,7 @@ function index_bundle_default(pi) {
 export {
   index_bundle_default as default,
   registerPiTeams,
+  runPostInitSkillCheck,
   waitForRun
 };
 //# sourceMappingURL=index.mjs.map