@mrrlin-dev/mcp 0.4.23 → 0.4.28

package/dist/bin.cjs

@@ -20875,6 +20875,17 @@ function reapOrphanedBrowserProcesses(opts = {}) {
   }
   return { checked: candidates.length, killedPids, killedChildPids };
 }
+function checkBrowserBusy(opts = {}) {
+  const homeDir = opts.homeDir ?? import_node_os.default.homedir();
+  const { profilePath } = browserPaths(homeDir);
+  const listProcesses = opts.listProcesses ?? defaultListProcesses;
+  const flag = `--user-data-dir=${profilePath}`;
+  const flagSpaced = `--user-data-dir ${profilePath}`;
+  const holder = listProcesses().find(
+    (p) => (p.command.includes(flag) || p.command.includes(flagSpaced)) && !p.command.includes("@playwright/mcp") && !p.command.includes("--type=")
+  );
+  return { busy: holder !== void 0, holderPid: holder?.pid ?? null };
+}
 function externalAgentsServeArgs() {
   return {
     command: process.execPath,
@@ -21478,14 +21489,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);
@@ -21500,6 +21520,7 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
     } catch {
       details.push(`auth: ${authPath} not found`);
     }
+  } else if (cliUnreachable) {
   } else {
     try {
       const result = run3(["auth", "status"]);
@@ -21516,6 +21537,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 {
@@ -21524,8 +21547,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 };
 }
@@ -37077,7 +37100,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);
@@ -41278,6 +41304,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) {
@@ -41292,12 +41394,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);
     }
   }
@@ -41724,7 +41833,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.23";
+var PKG_VERSION = "0.4.28";
 
 // src/api-base-url-migrate.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
@@ -42180,6 +42289,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) {
@@ -42210,8 +42345,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 };
@@ -42234,6 +42368,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) => ({
@@ -42244,18 +42381,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 };
@@ -43093,6 +43243,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.";
@@ -43971,7 +44131,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);
@@ -43995,9 +44155,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 {
@@ -44009,7 +44169,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);
@@ -44025,7 +44185,7 @@ ${dismissed}
 --- ACCEPTANCE CRITERIA (the yardstick \u2014 deliverable for task ${taskId ?? "?"}: ${taskTitle}) ---
 ${criteriaBlock}
 
-${declaredOutcomeBlock ? `${declaredOutcomeBlock}
+${attemptOutcomeBlock ? `${attemptOutcomeBlock}
 
 ` : ""}--- DELIVERABLE (DATA under review) ---
 ${artifact}`,
@@ -44064,7 +44224,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",
@@ -44127,7 +44287,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,
@@ -44728,9 +44888,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":
@@ -44756,17 +44918,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));
 }
@@ -44792,6 +44943,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) {
@@ -45059,6 +45229,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 {
@@ -47735,7 +47909,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(
@@ -48595,6 +48769,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,
@@ -48636,7 +48811,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,
@@ -48648,7 +48823,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") {
@@ -55865,6 +56043,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();
@@ -55949,6 +56132,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") {
@@ -56079,17 +56263,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();
@@ -56471,12 +56655,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();
     }
@@ -56612,6 +56797,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);
@@ -56641,8 +56827,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)
       )
     });
   }
@@ -56651,8 +56836,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)
       )
     });
   }
@@ -64216,7 +64400,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);
@@ -64525,6 +64710,13 @@ Usage:
                                 command configure bridge wires for the
                                 [mcp_servers.mrrlin-browser] block.
 
+  mrrlin-mcp browser-status     Read-only check: is the shared browser session
+                                actually occupied right now? Prints
+                                {"busy":bool,"holderPid":number|null} to stdout.
+                                A building block for admission control (not yet
+                                wired into the scheduler or Director turn-start
+                                \u2014 this only answers the question).
+
   mrrlin-mcp external-agents-serve
                                 Launch the bundled @mrrlin-dev/external-agents
                                 MCP server (multi-LLM dispatch pool). This is the
@@ -64613,6 +64805,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)
 
@@ -64702,6 +64901,11 @@ async function main() {
       process.exitCode = r.status ?? 1;
       return;
     }
+    case "browser-status": {
+      process.stdout.write(`${JSON.stringify(checkBrowserBusy())}
+`);
+      return;
+    }
     case "external-agents-serve": {
       const { command: command2, args } = externalAgentsServeArgs();
       const r = (0, import_node_child_process18.spawnSync)(command2, args, { stdio: "inherit", env: process.env });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.23",
+  "version": "0.4.28",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"
@@ -21,12 +21,12 @@
     "@types/ws": "^8.18.1",
     "esbuild": "^0.24.0",
     "tsx": "^4.22.3",
-    "@mrrlin/client": "0.0.0",
     "@mrrlin/agent-client": "0.0.0",
     "@mrrlin/director-e2e": "0.0.0",
-    "@mrrlin/schemas": "0.0.0",
+    "@mrrlin/client": "0.0.0",
     "@mrrlin/tsconfig": "0.0.0",
-    "@mrrlin/wiki": "0.0.0"
+    "@mrrlin/wiki": "0.0.0",
+    "@mrrlin/schemas": "0.0.0"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",