@mrrlin-dev/mcp 0.4.22 → 0.4.27

package/dist/bin.cjs

@@ -20815,6 +20815,66 @@ function browserServeArgs(homeDir = import_node_os.default.homedir()) {
     env: { PLAYWRIGHT_BROWSERS_PATH: browsersPath }
   };
 }
+function defaultListProcesses() {
+  const r = (0, import_node_child_process.spawnSync)("ps", ["-ww", "-eo", "pid,ppid,command"], { encoding: "utf8" });
+  const lines2 = (r.stdout ?? "").split("\n").slice(1);
+  const out = [];
+  for (const line of lines2) {
+    const m = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+    if (!m || m[1] === void 0 || m[2] === void 0 || m[3] === void 0) continue;
+    out.push({ pid: Number(m[1]), ppid: Number(m[2]), command: m[3] });
+  }
+  return out;
+}
+function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function defaultKill(pid, signal) {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch (err) {
+    if (err.code === "ESRCH") return true;
+    return false;
+  }
+}
+function safeKill(kill, pid, signal) {
+  try {
+    return kill(pid, signal);
+  } catch {
+    return false;
+  }
+}
+function reapOrphanedBrowserProcesses(opts = {}) {
+  const homeDir = opts.homeDir ?? import_node_os.default.homedir();
+  const { profilePath } = browserPaths(homeDir);
+  const listProcesses = opts.listProcesses ?? defaultListProcesses;
+  const isAlive = opts.isAlive ?? defaultIsAlive;
+  const kill = opts.kill ?? defaultKill;
+  const selfPid = opts.selfPid ?? process.pid;
+  const allProcesses = listProcesses();
+  const candidates = allProcesses.filter(
+    (p) => p.pid !== selfPid && p.command.includes("@playwright/mcp") && p.command.includes(profilePath)
+  );
+  const killedPids = [];
+  const killedChildPids = [];
+  for (const proc of candidates) {
+    if (!isAlive(proc.ppid)) {
+      for (const child of allProcesses) {
+        if (child.ppid === proc.pid) {
+          if (safeKill(kill, child.pid, "SIGKILL")) killedChildPids.push(child.pid);
+        }
+      }
+      if (safeKill(kill, proc.pid, "SIGTERM")) killedPids.push(proc.pid);
+    }
+  }
+  return { checked: candidates.length, killedPids, killedChildPids };
+}
 function externalAgentsServeArgs() {
   return {
     command: process.execPath,
@@ -21418,14 +21478,23 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
   const checks = { cli: false, version: false, auth: false, mcpReachable: false };
   const details = [];
   let cliResult;
+  let cliUnreachable = false;
   try {
     cliResult = run3(["--version"]);
     checks.cli = cliResult.status === 0;
+    if (!checks.cli) {
+      cliUnreachable = cliResult.status === null;
+      details.push(
+        cliUnreachable ? `cli: \`${provider}\` binary not found on PATH` : `cli: \`${provider} --version\` exited with code ${cliResult.status}`
+      );
+    }
   } catch {
+    cliUnreachable = true;
+    details.push(`cli: \`${provider}\` binary not found on PATH`);
   }
-  if (!checks.cli) details.push("cli: binary not available or exited non-zero");
   if (provider === "codex") {
     checks.version = true;
+  } else if (cliUnreachable) {
   } else {
     const raw = (cliResult?.stdout || cliResult?.stderr) ?? "";
     const version2 = parseCodexVersion(raw);
@@ -21440,6 +21509,7 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
     } catch {
       details.push(`auth: ${authPath} not found`);
     }
+  } else if (cliUnreachable) {
   } else {
     try {
       const result = run3(["auth", "status"]);
@@ -21456,6 +21526,8 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
       checks.mcpReachable = isExternalAgentsWrapper(parsed.mcp_servers?.["external-agents"]);
     } catch {
     }
+    if (!checks.mcpReachable) details.push("mcpReachable: external-agents server entry missing or invalid");
+  } else if (cliUnreachable) {
   } else {
     const configPath = resolveClaudeConfigPath2(opts);
     try {
@@ -21464,8 +21536,8 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
       checks.mcpReachable = isExternalAgentsWrapper(parsed.mcpServers?.["external-agents"]);
     } catch {
     }
+    if (!checks.mcpReachable) details.push("mcpReachable: external-agents server entry missing or invalid");
   }
-  if (!checks.mcpReachable) details.push("mcpReachable: external-agents server entry missing or invalid");
   const ready = checks.cli && checks.version && checks.auth && checks.mcpReachable;
   return { ready, checks, details };
 }
@@ -37017,7 +37089,10 @@ var ASYNC_JOB_FAILURE_REASONS = [
   "provider_unavailable",
   "spec_changed",
   "stale_lease",
-  "consensus_blocked"
+  "consensus_blocked",
+  // async-flow-throughput Slice 1: the spec drafter rejected its own output for exceeding the
+  // per-impact acceptance-criteria / character budget. Retryable via the normal async-job path.
+  "spec_over_budget"
 ];
 var mrrlinAsyncJobStatusSchema = external_exports.enum(ASYNC_JOB_STATUSES);
 var mrrlinAsyncJobFailureReasonSchema = external_exports.enum(ASYNC_JOB_FAILURE_REASONS);
@@ -41218,6 +41293,82 @@ function describeError(error51) {
   const detail = detailFromCause(error51.cause);
   return detail ? `${error51.message} (${truncate(detail)})` : error51.message;
 }
+function errorKind(error51) {
+  if (!(error51 instanceof Error)) return null;
+  const cause = error51.cause;
+  if (!cause || typeof cause !== "object") return null;
+  const direct = cause.code;
+  if (typeof direct === "string") return direct;
+  const errors = cause.errors;
+  if (Array.isArray(errors) && errors.length > 0) {
+    const first = errors[0]?.code;
+    if (typeof first === "string") return first;
+  }
+  return null;
+}
+var DEFAULT_FAILURE_LOG_WINDOW_SECONDS = 60;
+function failureLogWindowMs(env = process.env) {
+  const raw = (env.MRRLIN_BRIDGE_FAILURE_LOG_WINDOW_SECONDS ?? "").trim();
+  const parsed = Number.parseInt(raw, 10);
+  const seconds = Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_FAILURE_LOG_WINDOW_SECONDS;
+  return seconds * 1e3;
+}
+function createFailureLog(opts = {}) {
+  const windowMs = opts.windowMs ?? failureLogWindowMs();
+  const now = opts.now ?? Date.now;
+  const lastEmit = /* @__PURE__ */ new Map();
+  const counts = /* @__PURE__ */ new Map();
+  let windowStartedAt = null;
+  return {
+    /** Decide whether this failure should be printed. Returns the suppressed count to include in
+     *  the line when it is. */
+    shouldEmit(operation, kind) {
+      const prev = lastEmit.get(operation);
+      const sameKind = prev != null && prev.kind === kind;
+      const withinWindow = prev != null && now() - prev.at < windowMs;
+      if (sameKind && withinWindow) {
+        prev.suppressed += 1;
+        return { emit: false, suppressed: prev.suppressed };
+      }
+      const suppressed = sameKind ? prev?.suppressed ?? 0 : 0;
+      lastEmit.set(operation, { kind, at: now(), suppressed: 0 });
+      return { emit: true, suppressed };
+    },
+    /** A success resets the operation's suppression state, so the next failure always prints. */
+    noteSuccess(operation) {
+      lastEmit.delete(operation);
+    },
+    /** Count a failure for the degraded report. Only the breaker-tracked operations are counted. */
+    recordFailure(operation, kind) {
+      if (windowStartedAt == null) windowStartedAt = now();
+      const entry = counts.get(operation) ?? { failures: 0, lastErrorKind: null };
+      entry.failures += 1;
+      entry.lastErrorKind = kind;
+      counts.set(operation, entry);
+    },
+    /** Snapshot the window and start a fresh one. Always returns all three operations, reporting
+     *  zeros for a clean window — it never fabricates a degraded state and never omits the key. */
+    drainWindow() {
+      const startedAt = windowStartedAt;
+      const report = {
+        windowStartedAt: startedAt == null ? null : new Date(startedAt).toISOString(),
+        operations: {
+          schedulerTick: counts.get("schedulerTick") ?? { failures: 0, lastErrorKind: null },
+          claimSweep: counts.get("claimSweep") ?? { failures: 0, lastErrorKind: null },
+          asyncSweep: counts.get("asyncSweep") ?? { failures: 0, lastErrorKind: null }
+        }
+      };
+      counts.clear();
+      windowStartedAt = null;
+      return report;
+    }
+  };
+}
+function failureLogLine(label, error51, suppressed) {
+  const tail2 = suppressed > 0 ? ` (${suppressed} identical suppressed since the last line)` : "";
+  return `[mrrlin-mcp director-bridge] ${label} failed: ${describeError(error51)}${tail2}
+`;
+}
 
 // src/token-refresher.ts
 function createTokenRefresher(opts) {
@@ -41232,12 +41383,19 @@ function createTokenRefresher(opts) {
         opts.persist(token);
         last = token;
       }
+      opts.failureLog?.noteSuccess("tokenRefresh");
       opts.onOk?.();
     } catch (error51) {
-      process.stderr.write(
-        `[mrrlin-mcp director-bridge] token refresh failed (will retry next tick): ${describeError(error51)}
+      const label = "token refresh (will retry next tick)";
+      if (opts.failureLog) {
+        const { emit, suppressed } = opts.failureLog.shouldEmit("tokenRefresh", errorKind(error51));
+        if (emit) process.stderr.write(failureLogLine(label, error51, suppressed));
+      } else {
+        process.stderr.write(
+          `[mrrlin-mcp director-bridge] token refresh failed (will retry next tick): ${describeError(error51)}
 `
-      );
+        );
+      }
       opts.onError?.(error51);
     }
   }
@@ -41664,7 +41822,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.22";
+var PKG_VERSION = "0.4.27";
 
 // src/api-base-url-migrate.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
@@ -42120,6 +42278,32 @@ function computeNextTickDelayMs(nextWakeAt, nowMs, opts = {}) {
 function count(value) {
   return Array.isArray(value) ? value.length : 0;
 }
+var KNOWN_STOP_REASONS = new Set(mrrlinStopReasonSchema.options);
+function tallyReasons(value) {
+  const out = {};
+  if (!Array.isArray(value)) return out;
+  for (const entry of value) {
+    const raw = entry?.reason;
+    const trimmed = typeof raw === "string" ? raw.trim() : "";
+    const key = KNOWN_STOP_REASONS.has(trimmed) ? trimmed : "unknown";
+    out[key] = (out[key] ?? 0) + 1;
+  }
+  return out;
+}
+function mergeReasons(parts) {
+  const out = {};
+  for (const part of parts) {
+    for (const [key, n] of Object.entries(part)) out[key] = (out[key] ?? 0) + n;
+  }
+  return out;
+}
+function schedulerTickFailureLine(deps, error51) {
+  const kind = errorKind(error51);
+  deps.failureLog?.recordFailure("schedulerTick", kind);
+  if (!deps.failureLog) return failureLogLine("scheduler tick", error51, 0);
+  const { emit, suppressed } = deps.failureLog.shouldEmit("schedulerTick", kind);
+  return emit ? failureLogLine("scheduler tick", error51, suppressed) : "";
+}
 function dispatchTickWork(deps, results) {
   if (!deps.dispatchEnqueued) return;
   for (const result of results) {
@@ -42150,8 +42334,7 @@ async function attemptSchedulerTick(deps) {
     const { response, parsedBody } = bridgeHealth ? await withTimeout(parseTick) : await parseTick(new AbortController().signal);
     if (!response.ok) {
       process.stderr.write(
-        `[mrrlin-mcp director-bridge] scheduler tick failed: HTTP ${response.status} from /internal/scheduler/run
-`
+        schedulerTickFailureLine(deps, new Error(`HTTP ${response.status} from /internal/scheduler/run`))
       );
       bridgeHealth?.recordFailure("schedulerTick", new Error(`HTTP ${response.status}`));
       return { nextWakeAt: null, failed: true };
@@ -42174,6 +42357,9 @@ async function attemptSchedulerTick(deps) {
           enqueuedSpecDrafts: results.reduce((sum, r) => sum + count(r.enqueuedSpecDrafts), 0),
           autoApprovedSpecs: results.reduce((sum, r) => sum + count(r.autoApprovedSpecs), 0),
           skippedTasks: results.reduce((sum, r) => sum + count(r.skippedTasks), 0),
+          // Slice 4: always present. A tick with no skips emits `{}`, never an absent key and never
+          // null, so a consumer never has to distinguish "no skips" from "this bridge is too old".
+          skippedReasons: mergeReasons(results.map((r) => tallyReasons(r.skippedTasks))),
           failures: results.reduce((sum, r) => sum + count(r.failures), 0)
         },
         perProject: results.map((r) => ({
@@ -42184,18 +42370,31 @@ async function attemptSchedulerTick(deps) {
           enqueuedSpecDrafts: count(r.enqueuedSpecDrafts),
           autoApprovedSpecs: count(r.autoApprovedSpecs),
           skippedTasks: count(r.skippedTasks),
+          skippedReasons: tallyReasons(r.skippedTasks),
           failures: count(r.failures)
         })),
-        nextWakeAt: typeof data.nextWakeAt === "string" ? data.nextWakeAt : null
+        nextWakeAt: typeof data.nextWakeAt === "string" ? data.nextWakeAt : null,
+        // Slice 3: partial degradation had no signal — the breaker only trips on TOTAL failure, so
+        // ~2 800 connect timeouts a day were invisible outside raw stderr. This rides a payload the
+        // operator already reads. Always present, always all three tracked operations, zeros for a
+        // clean window: it never fabricates a degraded state and never omits the key.
+        degraded: deps.failureLog?.drainWindow() ?? {
+          windowStartedAt: null,
+          operations: {
+            schedulerTick: { failures: 0, lastErrorKind: null },
+            claimSweep: { failures: 0, lastErrorKind: null },
+            asyncSweep: { failures: 0, lastErrorKind: null }
+          }
+        }
       }
     });
     dispatchTickWork(deps, results);
+    deps.failureLog?.noteSuccess("schedulerTick");
     await bridgeHealth?.recordSuccess();
     return { nextWakeAt: typeof data.nextWakeAt === "string" ? data.nextWakeAt : null, failed: false };
   } catch (error51) {
     process.stderr.write(
-      `[mrrlin-mcp director-bridge] scheduler tick failed: ${describeError(error51)}
-`
+      schedulerTickFailureLine(deps, error51)
     );
     bridgeHealth?.recordFailure("schedulerTick", error51);
     return { nextWakeAt: null, failed: true };
@@ -43033,6 +43232,16 @@ function parseAcceptanceCriteria(markdown) {
   }
   return items.length > 0 ? { items } : null;
 }
+function resolveSpecBudget(impact) {
+  switch (impact?.toLowerCase()) {
+    case "high":
+      return { maxRequirements: 12, maxChars: 25e3 };
+    case "medium":
+      return { maxRequirements: 6, maxChars: 12e3 };
+    default:
+      return { maxRequirements: 3, maxChars: 6e3 };
+  }
+}
 
 // src/consensus/spec-gate.ts
 var SEED_ABSENCE_QUESTION = "What are the requirements for this task? There is no operator request on record, so the spec cannot be validated against your intent \u2014 please state what this task must do.";
@@ -43911,7 +44120,7 @@ function renderCriteriaBlock(criteria) {
   return criteria.map((c, i) => `${i + 1}. [ ] ${c}`).join("\n");
 }
 async function buildDeliverableGateDeps(args) {
-  const { client, projectSlug, deliverablePageId, declaredOutcome, cwd, codexExecutable, runId, seat } = args;
+  const { client, projectSlug, deliverablePageId, attemptOutcome, cwd, codexExecutable, runId, seat } = args;
   const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 5);
   const timeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
   const page = await client.getWikiPage(projectSlug, deliverablePageId);
@@ -43935,9 +44144,9 @@ async function buildDeliverableGateDeps(args) {
   const heads = resolveHeads(domain2, impact);
   const maxHeadCalls = 2 * rounds * (heads.length + 1);
   const criteriaBlock = renderCriteriaBlock(criteria);
-  const declaredOutcomeBlock = declaredOutcome ? [
+  const attemptOutcomeBlock = attemptOutcome ? [
     `--- DECLARED ATTEMPT OUTCOME (review consistency; do NOT rewrite or choose it) ---`,
-    `outcome: ${declaredOutcome}`,
+    `outcome: ${attemptOutcome}`,
     `Meaning: completed = positive result achieved; blocked_missing_input = required input/evidence unavailable; negative_result = real attempt showed the requested positive result did not materialize.`
   ].join("\n") : "";
   return {
@@ -43949,7 +44158,7 @@ async function buildDeliverableGateDeps(args) {
       return config2.consensusEnabled;
     },
     async readAcceptanceCriteria() {
-      return { specPageId, criteria };
+      return { specPageId, criteria, maxCriteria: resolveSpecBudget(impact).maxRequirements };
     },
     async readDeliverable() {
       const p = await client.getWikiPage(projectSlug, deliverablePageId);
@@ -43965,7 +44174,7 @@ ${dismissed}
 --- ACCEPTANCE CRITERIA (the yardstick \u2014 deliverable for task ${taskId ?? "?"}: ${taskTitle}) ---
 ${criteriaBlock}
 
-${declaredOutcomeBlock ? `${declaredOutcomeBlock}
+${attemptOutcomeBlock ? `${attemptOutcomeBlock}
 
 ` : ""}--- DELIVERABLE (DATA under review) ---
 ${artifact}`,
@@ -44004,7 +44213,7 @@ ${criteriaBlock}
 ${artifact}`,
         developerInstructions: `${DELIVERABLE_ANTIINJECTION_INSTRUCTION}
 
-You revise a deliverable to address the accepted issues so it satisfies the acceptance criteria and stays consistent with the declared outcome${declaredOutcome ? ` (${declaredOutcome})` : ""}. Return ONLY the full revised markdown, no commentary. Do not invent facts; keep the deliverable's format and do not change the declared outcome.`,
+You revise a deliverable to address the accepted issues so it satisfies the acceptance criteria and stays consistent with the declared outcome${attemptOutcome ? ` (${attemptOutcome})` : ""}. Return ONLY the full revised markdown, no commentary. Do not invent facts; keep the deliverable's format and do not change the declared outcome.`,
         cwd,
         timeoutMs,
         sandbox: "read-only",
@@ -44067,7 +44276,7 @@ You revise a deliverable to address the accepted issues so it satisfies the acce
             payload: {
               source: "deliverable-gate",
               outcome,
-              ...declaredOutcome ? { declaredOutcome } : {},
+              ...attemptOutcome ? { attemptOutcome } : {},
               runId,
               taskId,
               deliverablePageId,
@@ -44668,9 +44877,11 @@ function mapDeliverableGateResult(result) {
         reason: "reviewers were unavailable (provider/quota) during the deliverable review (CONSENSUS_UNAVAILABLE)"
       };
     case "CONSENSUS_BLOCKED": {
+      const over = result.yardstickOverBudget;
+      const yardstick = over ? ` The yardstick is over budget: spec ${over.specPageId ?? "(unknown page)"} carries ${over.criteria} acceptance criteria against a maximum of ${over.maxCriteria} for this task's impact, so re-draft the spec rather than re-running the work.` : "";
       return {
         action: "handoff",
-        reason: `reviewers did not converge; ${formatDeliverableGateDiagnostics(result.diagnostics ?? [])} (CONSENSUS_BLOCKED)`
+        reason: `reviewers did not converge; ${formatDeliverableGateDiagnostics(result.diagnostics ?? [])} (CONSENSUS_BLOCKED)${yardstick}`
       };
     }
     case "MISSING_ACCEPTANCE_CRITERIA":
@@ -44696,17 +44907,6 @@ var SPECS_FOLDER = "Specs";
 var DRAFT_SPEC_TLDR_MAX_CHARS = 300;
 var DRAFT_SPEC_PERSONA = "spec-author";
 var PAGE_ID_MAX_ATTEMPTS = 5;
-function resolveSpecBudget(impact) {
-  const tier = impact?.toLowerCase();
-  switch (tier) {
-    case "high":
-      return { maxRequirements: 12, maxChars: 25e3 };
-    case "medium":
-      return { maxRequirements: 6, maxChars: 12e3 };
-    default:
-      return { maxRequirements: 3, maxChars: 6e3 };
-  }
-}
 function defaultSleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -44732,6 +44932,25 @@ ${body}`;
   }
   return { markdown: body, tldrChars };
 }
+function checkSpecBudget(markdown, impact) {
+  const budget = resolveSpecBudget(impact);
+  const parsed = parseAcceptanceCriteria(markdown);
+  const criteria = parsed?.items.length ?? 0;
+  const chars = markdown.length;
+  const overCriteria = parsed != null && criteria > budget.maxRequirements;
+  const overChars = chars > budget.maxChars;
+  if (!overCriteria && !overChars) return null;
+  const faults = [];
+  if (overCriteria) faults.push(`${criteria} acceptance-criteria items (maximum ${budget.maxRequirements})`);
+  if (overChars) faults.push(`${chars} characters (maximum ${budget.maxChars})`);
+  return {
+    criteria,
+    chars,
+    maxCriteria: budget.maxRequirements,
+    maxChars: budget.maxChars,
+    message: `spec draft is over budget: ${faults.join(" and ")}`
+  };
+}
 function extractDeployTarget(markdown) {
   const section = /(## Deploy Target\s*\n)([\s\S]*?)(?=\n## |$)/i.exec(markdown);
   if (!section || section.index === void 0) {
@@ -44999,6 +45218,10 @@ async function runDraftSpec(ctx, input, deps) {
   }
   const { markdown: specMarkdown, deployTarget: parsedDeployTarget } = extractDeployTarget(exec.text);
   const { markdown, tldrChars } = enforceSpecOutputContract(specMarkdown, taskId, task.title);
+  const overBudget = checkSpecBudget(markdown, task.impact);
+  if (overBudget) {
+    return { kind: "retry", failureReason: "spec_over_budget", error: overBudget.message };
+  }
   let pageId;
   if (adoptedId) {
     try {
@@ -47675,7 +47898,7 @@ async function driveNonCodeRun(deps, projectSlug, runId, leaseId, task, domain2)
       taskId: task.id,
       runId,
       deliverablePageId: pageId,
-      declaredOutcome: parsedResult.outcome
+      attemptOutcome: parsedResult.outcome
     });
   } catch (error51) {
     await failRun(
@@ -48535,6 +48758,7 @@ async function runDeliverableGate(target, deps) {
   const deliverable = await deps.readDeliverable();
   let currentHash = deliverable.contentHash;
   let conflicted = false;
+  const yardstickOverBudget = ac.maxCriteria != null && ac.criteria.length > ac.maxCriteria ? { specPageId: ac.specPageId, criteria: ac.criteria.length, maxCriteria: ac.maxCriteria } : void 0;
   const result = await runConsensus({
     artifact: deliverable.markdownBody,
     heads: deps.heads,
@@ -48576,7 +48800,7 @@ async function runDeliverableGate(target, deps) {
   }
   await deps.writeEvidence({
     deliverablePageId: deliverable.pageId,
-    ...target.declaredOutcome ? { declaredOutcome: target.declaredOutcome } : {},
+    ...target.attemptOutcome ? { attemptOutcome: target.attemptOutcome } : {},
     outcome: result.outcome,
     rounds: result.rounds,
     history: result.history,
@@ -48588,7 +48812,10 @@ async function runDeliverableGate(target, deps) {
       outcome: "CONSENSUS_BLOCKED",
       rounds: result.rounds,
       diagnostics: diagnostics ?? [],
-      ...result.escalation ? { escalation: result.escalation } : {}
+      ...result.escalation ? { escalation: result.escalation } : {},
+      // Slice 2: attached ONLY on the blocked path. A converged review needs no explanation, and a
+      // transient outcome (changed-during-review, reviewers unavailable) is not about the yardstick.
+      ...yardstickOverBudget ? { yardstickOverBudget } : {}
     };
   }
   if (result.outcome === "CONVERGED") {
@@ -54052,6 +54279,7 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "- When creating a task, classify and supply the `domain` field explicitly based on the nature of the work: pass `domain:'code'` for software engineering work, `domain:'seo'` for SEO/optimization, `domain:'marketing'` for marketing/growth, or `domain:'content'` for content creation/writing \u2014 the same way you select category/subcategory. A follow-up task spawned with `parentTaskId` inherits its parent's domain automatically and requires no explicit domain.",
     '- When a task needs a browser (login flows, UI verification/clicks, scraping), pass `prerequisites:[{mcp:"mrrlin-browser",reason:"..."}]` to `create_execution_run`. If that run later fails into a handoff, the operator gets a one-click "Launch browser & resume" that brings up the dedicated browser as the turn starts.',
     "- When you actually drive a browser (calling `browser_navigate`, `browser_click`, `browser_snapshot`, `browser_type`, etc.), invoke those tools from the **`mrrlin-browser`** MCP server ONLY. Do NOT use tools from any other browser MCP (`playwright`, `chrome-devtools`, `puppeteer`, etc.) even if they are also connected on this operator's box \u2014 those use a shared/default Playwright profile that is fragile across runs. Only `mrrlin-browser` uses this project's dedicated Chromium + persistent operator profile (`~/.mrrlin/browser/profile`). If your host exposes multiple browser MCPs with overlapping tool names, prefer the `mrrlin-browser` server unconditionally.",
+    "- Exactly one browser session exists for this operator, shared across every concurrent chat and task on their box \u2014 a deliberate tradeoff, not a bug, so a second concurrent user of the browser is expected, not exceptional. If a `mrrlin-browser` call fails with `Browser is already in use for ...`, that means another one of the operator's own chats or tasks is driving the browser RIGHT NOW. Do not present this as a broken tool or a mysterious error: tell the operator plainly that the browser is busy with another task, ask them to wait for it to finish (or close it), and offer to retry shortly. Never retry-loop this silently.",
     "",
     'Research playbook \u2014 when the user asks about a topic, an area, or "what do we have on X":',
     "- Tasks are the source of truth. Start with `list_tasks` using `q=<keyword>`; the filter is a",
@@ -54146,6 +54374,14 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "- A failed fetch is a signal to change tool, never a finding. NEVER report that you could not",
     "  check, verify, or reach a publicly reachable target until you have actually tried the",
     "  browser on it in this turn.",
+    "- An internal Mrrlin route (`/deliverables/...`, `/wiki/...`, `/specs/...`, `/items/...`,",
+    "  `/memory/...`) is NEVER a browser target, even when it appears as a literal URL/path in a",
+    "  message or a screenshot. Resolve it through the typed tools instead: `list_wiki_pages` (by",
+    "  `folder`/`q`) or `search_wiki_pages` to find the page, then `get_wiki_page` for its content;",
+    "  `get_task`/`list_tasks` for `/items/<id>`. Opening these in `mrrlin-browser` is slower, can",
+    "  hit an operator login/consent wall the automation cannot clear on its own, and needlessly",
+    "  occupies the one shared browser session. Only reach for the browser on a Mrrlin route after a",
+    "  typed tool call for it has actually failed.",
     "",
     "Initiative contract \u2014 do the obvious next step instead of offering it:",
     "- When a next step is cheap, clearly wanted, and finishable in this turn, just do it and",
@@ -55796,6 +56032,11 @@ function checkTelemetryDefaultProject(env, warn) {
 }
 async function startDirectorBridge() {
   const config2 = parseConfig();
+  const failureLog = createFailureLog();
+  const suppressedPushLine = (label, error51) => {
+    const { emit, suppressed } = failureLog.shouldEmit(label, errorKind(error51));
+    return emit ? failureLogLine(label, error51, suppressed) : "";
+  };
   let telemetryPipelineRunning = false;
   checkTelemetryDefaultProject(process.env, (m) => console.error(m));
   const turnLock = createTurnLock();
@@ -55880,6 +56121,7 @@ async function startDirectorBridge() {
       provider: tokenProvider,
       persist: persistOperatorToken,
       intervalMs: tokenRefreshIntervalMs(),
+      failureLog,
       onOk: () => health.setApiAuth("ok"),
       onError: (e) => {
         if (e instanceof AgentTokenProviderError && e.code === "REVOKED_OR_EXPIRED") {
@@ -56010,17 +56252,17 @@ async function startDirectorBridge() {
     // Builds the gate deps (resolving domain/heads/criteria from the page's task + spec) and runs the
     // same convergence loop the spec-gate uses. runId is threaded for verdict provenance (decision 10).
     // Authoring uses the defaults (runAgentExec + loadPersona) — no extra wiring needed for those.
-    runDeliverableGate: async ({ projectSlug, runId, deliverablePageId, declaredOutcome }) => {
+    runDeliverableGate: async ({ projectSlug, runId, deliverablePageId, attemptOutcome }) => {
       const gateDeps = await buildDeliverableGateDeps({
         client,
         projectSlug,
         deliverablePageId,
-        declaredOutcome,
+        attemptOutcome,
         cwd: config2.codexCwd ?? process.cwd(),
         codexExecutable: config2.codexExecutable,
         runId
       });
-      return runDeliverableGate({ projectSlug, deliverablePageId, declaredOutcome }, gateDeps);
+      return runDeliverableGate({ projectSlug, deliverablePageId, attemptOutcome }, gateDeps);
     }
   };
   const sessionSinks = createSessionSinkRegistry();
@@ -56402,12 +56644,13 @@ async function startDirectorBridge() {
   const runTrackedSweep = async (id, label, fn) => {
     try {
       await fn();
+      failureLog.noteSuccess(id);
       await bridgeHealth.recordSuccess();
     } catch (error51) {
-      process.stderr.write(
-        `[mrrlin-mcp director-bridge] ${label} failed: ${describeError(error51)}
-`
-      );
+      const kind = errorKind(error51);
+      failureLog.recordFailure(id, kind);
+      const { emit, suppressed } = failureLog.shouldEmit(id, kind);
+      if (emit) process.stderr.write(failureLogLine(label, error51, suppressed));
       bridgeHealth.recordFailure(id, error51);
       await bridgeHealth.maybeCrash();
     }
@@ -56543,6 +56786,7 @@ async function startDirectorBridge() {
       fetchImpl: authedFetch,
       logger: bridgeLogger,
       bridgeHealth,
+      failureLog,
       dispatchEnqueued: (projectSlug, work) => {
         if (work.kind === "execution_run") driveRunNow(projectSlug, work.runId);
         else driveAsyncNow(projectSlug, work.jobId);
@@ -56572,8 +56816,7 @@ async function startDirectorBridge() {
     agentPoolLoopHandle = startAgentPoolLoop({
       push: (snapshot) => client.putOperatorAgentPool(snapshot),
       onError: (err) => process.stderr.write(
-        `[mrrlin-mcp director-bridge] agent-pool snapshot push failed: ${describeError(err)}
-`
+        suppressedPushLine("agent-pool snapshot push", err)
       )
     });
   }
@@ -56582,8 +56825,7 @@ async function startDirectorBridge() {
     providerReadinessLoopHandle = startProviderReadinessLoop({
       push: (readiness) => client.putOperatorProviderReadiness(readiness),
       onError: (err) => process.stderr.write(
-        `[mrrlin-mcp director-bridge] provider-readiness push failed: ${describeError(err)}
-`
+        suppressedPushLine("provider-readiness push", err)
       )
     });
   }
@@ -64147,7 +64389,8 @@ function installService(deps) {
     deps.log("pm2 not found on PATH. Install it first: npm i -g pm2");
     return { ok: false };
   }
-  const resolvedBins = bins.filter((b) => b !== null);
+  const claudeBin = deps.which("claude");
+  const resolvedBins = [...bins, claudeBin].filter((b) => b !== null);
   const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path28.default.dirname(b)))).join(":");
   const apiBaseUrl = deps.env.MRRLIN_API_BASE_URL?.trim() || void 0;
   const staging = deps.env.MRRLIN_STAGING === "1" || !apiBaseUrl && bridgeUrlImpliesStaging(deps.env.MRRLIN_BRIDGE_URL);
@@ -64544,6 +64787,13 @@ Usage:
                                 - MRRLIN_DIRECTOR_BRIDGE_EXEC_TURN_TIMEOUT_SECONDS (DEPRECATED;
                                   unset by default. When set, an extra per-turn hard cap: the
                                   effective turn deadline becomes min(this, remaining run budget))
+                                - MRRLIN_BRIDGE_FAILURE_LOG_WINDOW_SECONDS (default 60;
+                                  how long an IDENTICAL failure of the same periodic operation
+                                  is suppressed on stderr before it prints again, carrying the
+                                  count it swallowed. A changed error kind, a different
+                                  operation, or the first failure after a success always
+                                  prints immediately. Failures are counted for the tick's
+                                  scheduler-tick degraded block whether or not the line prints)
                                 - MRRLIN_DIRECTOR_BRIDGE_CONTEXT_MAX_ARTIFACTS (default 50;
                                   most-recent artifacts kept in the execution context bundle)
 
@@ -64620,6 +64870,14 @@ async function main() {
       return;
     }
     case "browser-serve": {
+      const reaped = reapOrphanedBrowserProcesses();
+      if (reaped.killedPids.length > 0) {
+        const childNote = reaped.killedChildPids.length > 0 ? ` (plus ${reaped.killedChildPids.length} browser child process(es) they had already opened: ${reaped.killedChildPids.join(", ")})` : "";
+        process.stderr.write(
+          `[mrrlin-mcp browser-serve] reaped ${reaped.killedPids.length} orphaned browser process(es) with a dead parent: ${reaped.killedPids.join(", ")}${childNote}
+`
+        );
+      }
       const { command: command2, args, env } = browserServeArgs();
       const r = (0, import_node_child_process18.spawnSync)(command2, args, { stdio: "inherit", env: { ...process.env, ...env } });
       process.exitCode = r.status ?? 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.22",
+  "version": "0.4.27",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"
@@ -24,9 +24,9 @@
     "@mrrlin/client": "0.0.0",
     "@mrrlin/agent-client": "0.0.0",
     "@mrrlin/director-e2e": "0.0.0",
+    "@mrrlin/wiki": "0.0.0",
     "@mrrlin/schemas": "0.0.0",
-    "@mrrlin/tsconfig": "0.0.0",
-    "@mrrlin/wiki": "0.0.0"
+    "@mrrlin/tsconfig": "0.0.0"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",