@mrrlin-dev/mcp 0.3.60 → 0.3.64

package/dist/bin.cjs

@@ -6543,7 +6543,7 @@ var require_truncate = __commonJS({
     var parse5 = require_parse2();
     var constants = require_constants2();
     var SemVer = require_semver();
-    var truncate2 = (version2, truncation, options) => {
+    var truncate3 = (version2, truncation, options) => {
       if (!constants.RELEASE_TYPES.includes(truncation)) {
         return null;
       }
@@ -6573,7 +6573,7 @@ var require_truncate = __commonJS({
     var isPrerelease = (type) => {
       return type.startsWith("pre");
     };
-    module2.exports = truncate2;
+    module2.exports = truncate3;
   }
 });
 
@@ -7611,7 +7611,7 @@ var require_semver2 = __commonJS({
     var lte = require_lte();
     var cmp = require_cmp();
     var coerce = require_coerce();
-    var truncate2 = require_truncate();
+    var truncate3 = require_truncate();
     var Comparator = require_comparator();
     var Range = require_range();
     var satisfies = require_satisfies();
@@ -7650,7 +7650,7 @@ var require_semver2 = __commonJS({
       lte,
       cmp,
       coerce,
-      truncate: truncate2,
+      truncate: truncate3,
       Comparator,
       Range,
       satisfies,
@@ -36432,6 +36432,13 @@ var openApiOperationIds = {
   restartExecutionRun: "restartExecutionRun",
   resolveHandoff: "resolveHandoff",
   touchExecutionRun: "touchExecutionRun",
+  getTaskState: "getTaskState",
+  upsertTaskState: "upsertTaskState",
+  retireThread: "retireThread",
+  // Run-scoped, model-facing half of the resume contract (D8). Distinct from upsertTaskState:
+  // that one is the server's own write (whole record, explicit lastRunSeq), this one is the
+  // executor reporting narrative only, with the ordering value derived server-side from the run.
+  reportTaskState: "reportTaskState",
   issueAgentCredential: "issueAgentCredential",
   listAgentCredentials: "listAgentCredentials",
   revokeAgentCredential: "revokeAgentCredential",
@@ -37463,7 +37470,55 @@ var mrrlinExecutionRunSchema = external_exports.object({
   status: mrrlinExecutionRunStatusSchema,
   taskId: mrrlinTaskIdSchema,
   updatedAt: external_exports.string().datetime(),
-  worktreeId: external_exports.string().min(1).nullable()
+  worktreeId: external_exports.string().min(1).nullable(),
+  stateSeq: external_exports.number().int(),
+  promptBytes: external_exports.number().int().nullable(),
+  turnCount: external_exports.number().int().nullable(),
+  inputTokens: external_exports.number().int().nullable(),
+  cachedInputTokens: external_exports.number().int().nullable(),
+  outputTokens: external_exports.number().int().nullable(),
+  effort: external_exports.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable(),
+  effortEscalationReason: external_exports.string().min(1).nullable()
+});
+var mrrlinTaskStateSchema = external_exports.object({
+  projectSlug: mrrlinProjectSlugSchema,
+  taskId: mrrlinTaskIdSchema,
+  goal: external_exports.string().min(1).nullable(),
+  acceptedRequirements: external_exports.string().min(1).nullable(),
+  decisions: external_exports.string().min(1).nullable(),
+  relevantFiles: external_exports.string().min(1).nullable(),
+  filesChanged: external_exports.string().min(1).nullable(),
+  latestVerification: external_exports.string().min(1).nullable(),
+  openProblems: external_exports.string().min(1).nullable(),
+  nextActions: external_exports.string().min(1).nullable(),
+  lastRunSeq: external_exports.number().int(),
+  threadRunCount: external_exports.number().int(),
+  retiredThreadId: external_exports.string().min(1).nullable(),
+  updatedAt: external_exports.string().datetime()
+});
+var mrrlinTaskStateUpsertSchema = external_exports.object({
+  goal: external_exports.string().min(1).nullable(),
+  acceptedRequirements: external_exports.string().min(1).nullable(),
+  decisions: external_exports.string().min(1).nullable(),
+  relevantFiles: external_exports.string().min(1).nullable(),
+  filesChanged: external_exports.string().min(1).nullable(),
+  latestVerification: external_exports.string().min(1).nullable(),
+  openProblems: external_exports.string().min(1).nullable(),
+  nextActions: external_exports.string().min(1).nullable(),
+  lastRunSeq: external_exports.number().int()
+});
+var mrrlinTaskStateReportSchema = external_exports.object({
+  goal: external_exports.string().min(1).nullish(),
+  acceptedRequirements: external_exports.string().min(1).nullish(),
+  decisions: external_exports.string().min(1).nullish(),
+  openProblems: external_exports.string().min(1).nullish(),
+  nextActions: external_exports.string().min(1).nullish()
+});
+var taskStateResponseSchema = external_exports.object({
+  data: mrrlinTaskStateSchema.nullable()
+});
+var retireThreadResponseSchema = external_exports.object({
+  data: external_exports.object({ retiredThreadId: external_exports.string().min(1).nullable() })
 });
 var mrrlinExecutionRunCreateSchema = external_exports.object({
   actor: external_exports.string().min(1),
@@ -37495,7 +37550,18 @@ var mrrlinExecutionRunUpdateSchema = external_exports.object({
   prodWorkflowId: external_exports.number().int().positive().nullable().optional(),
   pullRequestUrl: external_exports.string().min(1).nullable().optional(),
   status: mrrlinExecutionRunStatusSchema.optional(),
-  worktreeId: external_exports.string().min(1).nullable().optional()
+  worktreeId: external_exports.string().min(1).nullable().optional(),
+  // Slice 6 (cost telemetry) + Slice 7 (effort). All nullable and optional: per D6, NULL means
+  // "not measured" and must never be confused with a measured zero, so a disabled slice omits its
+  // fields entirely rather than writing 0. `nonnegative` rather than `positive` because a real
+  // measured zero is legitimate here (a turn can genuinely produce 0 output tokens).
+  promptBytes: external_exports.number().int().nonnegative().nullable().optional(),
+  turnCount: external_exports.number().int().nonnegative().nullable().optional(),
+  inputTokens: external_exports.number().int().nonnegative().nullable().optional(),
+  cachedInputTokens: external_exports.number().int().nonnegative().nullable().optional(),
+  outputTokens: external_exports.number().int().nonnegative().nullable().optional(),
+  effort: external_exports.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
+  effortEscalationReason: external_exports.string().min(1).nullable().optional()
 }).refine((value) => Object.keys(value).length > 0, {
   message: "ExecutionRunUpdate requires at least one field"
 });
@@ -38274,6 +38340,117 @@ function applyHistoricalBudgetIfNeeded(input) {
     droppedHandles
   };
 }
+function renderTaskStateSection(state) {
+  const rows = [
+    ["goal", state.goal],
+    ["accepted requirements", state.acceptedRequirements],
+    ["decisions (and why)", state.decisions],
+    ["relevant files", state.relevantFiles],
+    ["files changed", state.filesChanged],
+    ["latest verification", state.latestVerification],
+    ["open problems", state.openProblems],
+    ["next actions", state.nextActions]
+  ];
+  const present = rows.filter(([, value]) => typeof value === "string" && value.trim().length > 0);
+  if (present.length === 0) {
+    return "## Task state (normative)\n(no state recorded yet \u2014 establish it before ending your turn)";
+  }
+  const lines2 = ["## Task state (normative)"];
+  for (const [label, value] of present) {
+    lines2.push(`${label}: ${value}`);
+  }
+  return lines2.join("\n");
+}
+function renderRunDelta(input) {
+  const sections = [
+    renderDeltaTaskStatus(input.task),
+    renderDeltaRuns(input.newlyFinishedRuns),
+    renderDeltaArtifacts(input.newArtifacts, input.omittedArtifactCount ?? 0)
+  ];
+  return sections.join("\n\n");
+}
+function renderDeltaArtifacts(artifacts, omittedCount) {
+  if (artifacts.length === 0 && omittedCount === 0)
+    return "## New artifacts since your last turn\n(none)";
+  const lines2 = ["## New artifacts since your last turn"];
+  if (omittedCount > 0) {
+    lines2.push(`(+${omittedCount} older artifact${omittedCount === 1 ? "" : "s"} omitted)`);
+  }
+  for (const artifact of artifacts) {
+    if (artifact.kind === "file") {
+      const p = artifact.payload;
+      if (p.filename && p.stableUrl) {
+        lines2.push(`- ${artifact.createdAt} [file] ${p.filename} (${p.class ?? "?"}, ${p.sizeBytes ?? "?"} bytes) ${p.stableUrl}`);
+        continue;
+      }
+    }
+    lines2.push(`- ${artifact.createdAt} [${artifact.kind}] run=${artifact.runId} ${JSON.stringify(artifact.payload)}`);
+  }
+  return lines2.join("\n");
+}
+function renderDeltaTaskStatus(task) {
+  const lines2 = ["## Since your last turn", `task ${task.id} status: ${task.status}`];
+  if (task.latestJudgement) {
+    lines2.push(`latest judgement (${task.latestJudgementKind ?? "unknown"}): ${task.latestJudgement}`);
+  }
+  return lines2.join("\n");
+}
+function renderDeltaRuns(runs) {
+  if (runs.length === 0)
+    return "## Runs completed since your last turn\n(none)";
+  const lines2 = ["## Runs completed since your last turn"];
+  for (const run3 of runs) {
+    lines2.push(`- ${run3.id} [${run3.status}] finished ${run3.finishedAt ?? run3.createdAt}`);
+  }
+  return lines2.join("\n");
+}
+
+// ../../packages/codex-client/dist/token-usage.js
+var TOKEN_USAGE_NOTIFICATION_METHOD = "thread/tokenUsage/updated";
+function readCount(source, key) {
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function extractTurnTokenUsage(method, params) {
+  if (method !== TOKEN_USAGE_NOTIFICATION_METHOD)
+    return null;
+  if (params === null || typeof params !== "object")
+    return null;
+  const usage = params.tokenUsage;
+  if (usage === null || typeof usage !== "object")
+    return null;
+  const last = usage.last;
+  if (last === null || typeof last !== "object")
+    return null;
+  const block = last;
+  const extracted = {
+    inputTokens: readCount(block, "inputTokens"),
+    cachedInputTokens: readCount(block, "cachedInputTokens"),
+    outputTokens: readCount(block, "outputTokens")
+  };
+  if (extracted.inputTokens === null && extracted.cachedInputTokens === null && extracted.outputTokens === null) {
+    return null;
+  }
+  return extracted;
+}
+function addTurnTokenUsage(total, turn) {
+  if (turn === null)
+    return total;
+  if (total === null)
+    return { ...turn };
+  const add2 = (a, b) => {
+    if (a === null)
+      return b;
+    if (b === null)
+      return a;
+    return a + b;
+  };
+  return {
+    inputTokens: add2(total.inputTokens, turn.inputTokens),
+    cachedInputTokens: add2(total.cachedInputTokens, turn.cachedInputTokens),
+    outputTokens: add2(total.outputTokens, turn.outputTokens)
+  };
+}
 
 // ../../packages/client/dist/agent-token-provider.js
 var AgentTokenProviderError = class extends Error {
@@ -38998,6 +39175,34 @@ function createMrrlinClient(config2) {
         throw error51;
       }
     },
+    async getTaskState(projectSlug, taskId) {
+      const body = await request(`${projectPath(projectSlug)}/tasks/${encodeURIComponent(taskId)}/state`);
+      return taskStateResponseSchema.parse(body).data;
+    },
+    async upsertTaskState(projectSlug, taskId, input) {
+      const body = await request(`${projectPath(projectSlug)}/tasks/${encodeURIComponent(taskId)}/state`, {
+        body: JSON.stringify(mrrlinTaskStateUpsertSchema.parse(input)),
+        headers: { "content-type": "application/json" },
+        method: "PUT"
+      });
+      return taskStateResponseSchema.parse(body).data;
+    },
+    async retireThread(projectSlug, taskId, newThreadId) {
+      const body = await request(`${projectPath(projectSlug)}/tasks/${encodeURIComponent(taskId)}/retire-thread`, {
+        body: JSON.stringify({ newThreadId }),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      });
+      return retireThreadResponseSchema.parse(body).data.retiredThreadId;
+    },
+    async reportTaskState(projectSlug, runId, report) {
+      const body = await request(`${projectPath(projectSlug)}/execution-runs/${encodeURIComponent(runId)}/task-state`, {
+        body: JSON.stringify(mrrlinTaskStateReportSchema.parse(report)),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      });
+      return taskStateResponseSchema.parse(body).data;
+    },
     async resolveHandoff(projectSlug, runId, input) {
       const body = await request(`${projectPath(projectSlug)}/execution-runs/${encodeURIComponent(runId)}/resolve-handoff`, {
         body: JSON.stringify(input),
@@ -39201,6 +39406,36 @@ function createMrrlinClient(config2) {
   };
 }
 
+// src/describe-error.ts
+var MAX_DETAIL_CHARS = 200;
+function truncate(value) {
+  return value.length > MAX_DETAIL_CHARS ? value.slice(0, MAX_DETAIL_CHARS) : value;
+}
+function codeAndMessage(value) {
+  if (!value || typeof value !== "object") return null;
+  const obj = value;
+  const code = typeof obj.code === "string" ? obj.code : null;
+  const message = typeof obj.message === "string" ? obj.message : null;
+  if (code) return message ? `${code}: ${message}` : code;
+  return message;
+}
+function detailFromCause(cause) {
+  if (!cause || typeof cause !== "object") return null;
+  const direct = codeAndMessage(cause);
+  const errors = cause.errors;
+  const hasCode = typeof cause.code === "string";
+  if (!hasCode && Array.isArray(errors) && errors.length > 0) {
+    const fromFirst = codeAndMessage(errors[0]);
+    if (fromFirst) return fromFirst;
+  }
+  return direct;
+}
+function describeError(error51) {
+  if (!(error51 instanceof Error)) return String(error51);
+  const detail = detailFromCause(error51.cause);
+  return detail ? `${error51.message} (${truncate(detail)})` : error51.message;
+}
+
 // src/token-refresher.ts
 function createTokenRefresher(opts) {
   const setIntervalFn = opts.setIntervalFn ?? setInterval;
@@ -39217,7 +39452,7 @@ function createTokenRefresher(opts) {
       opts.onOk?.();
     } catch (error51) {
       process.stderr.write(
-        `[mrrlin-mcp director-bridge] token refresh failed (will retry next tick): ${error51 instanceof Error ? error51.message : String(error51)}
+        `[mrrlin-mcp director-bridge] token refresh failed (will retry next tick): ${describeError(error51)}
 `
       );
       opts.onError?.(error51);
@@ -39256,29 +39491,117 @@ function createServiceHealth() {
 }
 
 // src/turn-lock.ts
+var CHAT_LIMIT = 5;
+var AUTONOMOUS_LIMIT = 10;
 function createTurnLock() {
-  let tail2 = Promise.resolve();
-  let active = 0;
-  return {
-    runExclusive(fn) {
-      active += 1;
-      const run3 = tail2.then(() => fn());
-      tail2 = run3.then(
-        () => void 0,
-        () => void 0
-      );
-      run3.then(
-        () => {
-          active -= 1;
-        },
-        () => {
-          active -= 1;
+  let chatTotalActive = 0;
+  let autonomousTotalActive = 0;
+  let chatRunning = 0;
+  let autonomousRunning = 0;
+  const chatQueue = [];
+  const execQueue = [];
+  const asyncQueue = [];
+  let lastServed = null;
+  let autonomousBound = false;
+  const logBound = (queued) => {
+    console.warn(
+      `[mrrlin-mcp director-bridge] warn autonomous_ceiling_bound {"limit":${AUTONOMOUS_LIMIT},"queued":${queued}}`
+    );
+  };
+  const maybeEnterBound = () => {
+    if (!autonomousBound && autonomousRunning === AUTONOMOUS_LIMIT && execQueue.length + asyncQueue.length > 0) {
+      autonomousBound = true;
+      logBound(execQueue.length + asyncQueue.length);
+    }
+  };
+  const maybeLeaveBound = () => {
+    if (autonomousBound && (autonomousRunning < AUTONOMOUS_LIMIT || execQueue.length + asyncQueue.length === 0)) {
+      autonomousBound = false;
+      logBound(execQueue.length + asyncQueue.length);
+    }
+  };
+  const acquire = (lane, startRunner) => {
+    if (lane === "chat") {
+      if (chatRunning < CHAT_LIMIT) {
+        chatRunning += 1;
+        startRunner();
+      } else {
+        chatQueue.push(startRunner);
+      }
+    } else {
+      if (autonomousRunning < AUTONOMOUS_LIMIT) {
+        autonomousRunning += 1;
+        startRunner();
+      } else {
+        if (lane === "exec") {
+          execQueue.push(startRunner);
+        } else {
+          asyncQueue.push(startRunner);
         }
-      );
-      return run3;
-    },
-    activeCount: () => active
+        maybeEnterBound();
+      }
+    }
+  };
+  const release = (lane) => {
+    if (lane === "chat") {
+      chatRunning -= 1;
+      const next = chatQueue.shift();
+      if (next) {
+        chatRunning += 1;
+        next();
+      }
+    } else {
+      autonomousRunning -= 1;
+      const execWait = execQueue.length > 0;
+      const asyncWait = asyncQueue.length > 0;
+      if (execWait || asyncWait) {
+        let serveLane;
+        if (execWait && !asyncWait) {
+          serveLane = "exec";
+        } else if (!execWait && asyncWait) {
+          serveLane = "async";
+        } else {
+          serveLane = lastServed === "exec" ? "async" : "exec";
+        }
+        const queue = serveLane === "exec" ? execQueue : asyncQueue;
+        const next = queue.shift();
+        if (next) {
+          autonomousRunning += 1;
+          lastServed = serveLane;
+          next();
+        }
+      }
+      maybeLeaveBound();
+    }
+  };
+  const run3 = async (lane, fn) => {
+    if (lane === "chat") {
+      chatTotalActive += 1;
+    } else {
+      autonomousTotalActive += 1;
+    }
+    return new Promise((resolve, reject) => {
+      const start = () => {
+        let bodyPromise;
+        try {
+          bodyPromise = fn();
+        } catch (e) {
+          bodyPromise = Promise.reject(e);
+        }
+        bodyPromise.then((v) => resolve(v)).catch((e) => reject(e)).finally(() => {
+          if (lane === "chat") {
+            chatTotalActive -= 1;
+          } else {
+            autonomousTotalActive -= 1;
+          }
+          release(lane);
+        });
+      };
+      acquire(lane, start);
+    });
   };
+  const activeCount = () => chatTotalActive + autonomousTotalActive;
+  return { run: run3, activeCount };
 }
 
 // src/self-update.ts
@@ -39642,7 +39965,7 @@ function startCodexProbe(deps = {}) {
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.60";
+var PKG_VERSION = "0.3.64";
 
 // src/api-base-url-migrate.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
@@ -40142,7 +40465,7 @@ async function attemptSchedulerTick(deps) {
     return { nextWakeAt: typeof data.nextWakeAt === "string" ? data.nextWakeAt : null, failed: false };
   } catch (error51) {
     process.stderr.write(
-      `[mrrlin-mcp director-bridge] scheduler tick failed: ${error51 instanceof Error ? error51.message : String(error51)}
+      `[mrrlin-mcp director-bridge] scheduler tick failed: ${describeError(error51)}
 `
     );
     bridgeHealth?.recordFailure("schedulerTick", error51);
@@ -41831,6 +42154,11 @@ function renderMilestone(m, ctx) {
       return "Autodeploy is enabled, but this task has nothing deployable \u2014 skipping";
     case "daily_limit_reached":
       return "Daily autonomous operations limit reached \u2014 I will continue tomorrow";
+    case "thread_retired": {
+      if (ctx.reason === "bounded_no_state")
+        return "Started a fresh conversation for this task \u2014 the previous one grew too long and no progress notes were saved, so some earlier reasoning may be lost";
+      return "Started a fresh conversation for this task \u2014 the previous one grew too long, so I carried the saved progress notes over";
+    }
   }
 }
 
@@ -41854,6 +42182,82 @@ async function postRunFeed(client, projectSlug, runId, taskId, milestone, ctx =
   }
 }
 
+// src/output-projection.ts
+var FAILURE_PATTERNS = [
+  /^\s*(?:E|FAIL|ERROR|ERR!)\b/i,
+  /\bTraceback \(most recent call last\)/,
+  /^\s*at\s+.+:\d+:\d+/,
+  // stack frames
+  /\bAssertionError\b|\bexpected\b.*\breceived\b|\bexpected:\b/i,
+  /\berror\b[:\s]|\bfailed\b[:\s]|\bfailure\b[:\s]/i,
+  /^\s*not ok\b/,
+  // TAP
+  /\b(?:SyntaxError|TypeError|ReferenceError|RangeError)\b/,
+  /^\s*✕|^\s*✗|^\s*×/,
+  /\bexit(?:ed)? (?:code|status)\s*[:=]?\s*[1-9]/i
+];
+var DEFAULT_OUTPUT_PROJECTION_MAX_CHARS = 2e3;
+function projectCommandOutput(output3, options = {}) {
+  const maxChars = options.maxChars ?? DEFAULT_OUTPUT_PROJECTION_MAX_CHARS;
+  const exitStatus = options.exitStatus ?? null;
+  const fullOutputRef = options.fullOutputRef ?? null;
+  const label = options.label ?? "command output";
+  const lines2 = output3.split(/\r?\n/);
+  const matched = [];
+  for (let index = 0; index < lines2.length; index += 1) {
+    const line = lines2[index] ?? "";
+    if (FAILURE_PATTERNS.some((pattern) => pattern.test(line))) matched.push(index);
+  }
+  const candidates = matched.length > 0 ? matched : lines2.map((_, index) => index);
+  const kept = [];
+  let used = 0;
+  for (let cursor = candidates.length - 1; cursor >= 0; cursor -= 1) {
+    const index = candidates[cursor];
+    if (index === void 0) continue;
+    let text = lines2[index] ?? "";
+    if (text.trim().length === 0) continue;
+    if (text.length > maxChars) {
+      text = `${text.slice(0, Math.max(0, maxChars - 14))}\u2026[line cut]`;
+    }
+    const cost = text.length + 1;
+    if (used + cost > maxChars) break;
+    kept.push({ index, text });
+    used += cost;
+  }
+  kept.sort((a, b) => a.index - b.index);
+  const failureLines = kept.map((entry) => entry.text);
+  const carried = failureLines.reduce((total, line) => total + line.length + 1, 0);
+  const omittedChars = Math.max(0, output3.length - carried);
+  const parts = [`${label}:`];
+  parts.push(exitStatus === null ? "exit status unknown" : `exit status ${exitStatus}`);
+  parts.push(
+    matched.length > 0 ? `${failureLines.length} of ${matched.length} failure-bearing line(s) shown` : `no failure markers found; showing the tail (${failureLines.length} line(s))`
+  );
+  if (omittedChars > 0) {
+    parts.push(
+      fullOutputRef ? `${omittedChars} chars omitted \u2014 retrieve ${fullOutputRef} for the full output` : `${omittedChars} chars omitted`
+    );
+  }
+  return {
+    exitStatus,
+    failureLines,
+    summary: parts.join(" "),
+    omittedChars,
+    fullOutputRef,
+    usedTailFallback: matched.length === 0
+  };
+}
+function renderOutputProjection(projection) {
+  const lines2 = [projection.summary];
+  if (projection.failureLines.length > 0) {
+    lines2.push(...projection.failureLines);
+  }
+  return lines2.join("\n");
+}
+function outputProjectionDisabled(env = process.env) {
+  return (env.MRRLIN_EXEC_OUTPUT_PROJECTION_DISABLE ?? "").trim() === "1";
+}
+
 // src/deploy-gate.ts
 var DEFAULT_DEPLOY_POLL_BUDGET_SECONDS = 1200;
 var DEFAULT_PROD_GRACE_SECONDS = 900;
@@ -42209,10 +42613,48 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     task,
     run: run3
   });
+  const verificationAttempt = attemptIndex(artifacts, env, "verification") + 1;
+  let outputRef = null;
+  if (verdict.fullOutput && !outputProjectionDisabled()) {
+    outputRef = `EA-veroutput-${env}-${verificationAttempt}`;
+    const stored = await deps.client.appendExecutionArtifact(projectSlug, run3.id, {
+      id: outputRef,
+      kind: "command_output",
+      payload: { env, source: "verification-turn", output: verdict.fullOutput }
+    }).then(() => true).catch(() => false);
+    if (!stored) outputRef = null;
+  }
+  const projection = verdict.fullOutput && !outputProjectionDisabled() ? projectCommandOutput(verdict.fullOutput, {
+    // A model turn reports no exit code; claiming 0 would assert a success never observed.
+    exitStatus: null,
+    fullOutputRef: outputRef,
+    label: `verification (${env})`
+  }) : null;
+  if (projection?.usedTailFallback) {
+    console.warn(
+      JSON.stringify({
+        event: "output_projection_tail_fallback",
+        projectSlug,
+        runId: run3.id,
+        env,
+        detail: "no failure marker matched; the projection carries the tail instead"
+      })
+    );
+  }
   await deps.client.appendExecutionArtifact(projectSlug, run3.id, {
-    id: `EA-verification-${env}-${attemptIndex(artifacts, env, "verification") + 1}`,
+    id: `EA-verification-${env}-${verificationAttempt}`,
     kind: "verification",
-    payload: { env, verdict: verdict.verdict, summary: verdict.summary, turnRef: verdict.turnRef }
+    payload: {
+      env,
+      verdict: verdict.verdict,
+      summary: verdict.summary,
+      turnRef: verdict.turnRef,
+      ...projection ? {
+        projection: renderOutputProjection(projection),
+        fullOutputArtifactId: projection.fullOutputRef,
+        omittedChars: projection.omittedChars
+      } : {}
+    }
   });
   if (verdict.verdict === "fail") {
     if (env === "prod" && task.autonomyLevel === "auto") {
@@ -42524,6 +42966,112 @@ function buildPullRequestBody(input) {
 ${lines2.join("\n")}`;
 }
 
+// src/context-compact/policy.ts
+var DEFAULT_THRESHOLD_CHARS = 12e3;
+var DEFAULT_MAX_ITEMS = 25;
+function readPositiveInt(value, fallback) {
+  const raw = (value ?? "").trim();
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function readCompactPolicy(env = process.env) {
+  const disabled = (env.MRRLIN_MCP_COMPACT_DISABLE ?? "").trim() === "1";
+  return {
+    enabled: !disabled,
+    thresholdChars: readPositiveInt(env.MRRLIN_MCP_COMPACT_THRESHOLD_CHARS, DEFAULT_THRESHOLD_CHARS),
+    maxItems: readPositiveInt(env.MRRLIN_MCP_COMPACT_MAX_ITEMS, DEFAULT_MAX_ITEMS),
+    debug: (env.MRRLIN_MCP_COMPACT_DEBUG ?? "").trim() === "1",
+    retrievalBudgetDisable: (env.MRRLIN_RETRIEVAL_BUDGET_DISABLE ?? "").trim() === "1"
+  };
+}
+function warmDeltaDisabled(env = process.env) {
+  return (env.MRRLIN_EXEC_WARM_DELTA_DISABLE ?? "").trim() === "1";
+}
+var DEFAULT_THREAD_MAX_RUNS = 12;
+var THREAD_MAX_RUNS_MIN = 4;
+var THREAD_MAX_RUNS_MAX = 50;
+var DEFAULT_THREAD_RETIRE_GRACE_RUNS = 6;
+var warnedOutOfRange = /* @__PURE__ */ new Set();
+function readBoundedInt(name, raw, fallback, min, max) {
+  const trimmed = (raw ?? "").trim();
+  if (!trimmed) return fallback;
+  const parsed = Number.parseInt(trimmed, 10);
+  if (Number.isInteger(parsed) && parsed >= min && parsed <= max) return parsed;
+  if (!warnedOutOfRange.has(name)) {
+    warnedOutOfRange.add(name);
+    console.warn(
+      JSON.stringify({
+        event: "thread_retirement_bound_out_of_range",
+        variable: name,
+        provided: trimmed,
+        accepted: `${min}-${max}`,
+        usingDefault: fallback
+      })
+    );
+  }
+  return fallback;
+}
+function threadMaxRuns(env = process.env) {
+  return readBoundedInt(
+    "MRRLIN_EXEC_THREAD_MAX_RUNS",
+    env.MRRLIN_EXEC_THREAD_MAX_RUNS,
+    DEFAULT_THREAD_MAX_RUNS,
+    THREAD_MAX_RUNS_MIN,
+    THREAD_MAX_RUNS_MAX
+  );
+}
+function threadRetireGraceRuns(env = process.env) {
+  return readBoundedInt(
+    "MRRLIN_EXEC_THREAD_RETIRE_GRACE_RUNS",
+    env.MRRLIN_EXEC_THREAD_RETIRE_GRACE_RUNS,
+    DEFAULT_THREAD_RETIRE_GRACE_RUNS,
+    0,
+    THREAD_MAX_RUNS_MAX
+  );
+}
+function threadRetireDisabled(env = process.env) {
+  return (env.MRRLIN_EXEC_THREAD_RETIRE_DISABLE ?? "").trim() === "1";
+}
+
+// src/thread-retirement.ts
+function decideThreadRetirement(input) {
+  if (input.disabled) return { retire: false };
+  if (input.threadRunCount < input.maxRuns) return { retire: false };
+  if (input.hasNarrative) return { retire: true, reason: "bounded_run_count" };
+  if (input.threadRunCount >= input.maxRuns + input.graceRuns) {
+    return { retire: true, reason: "bounded_no_state" };
+  }
+  return { retire: false };
+}
+function hasNarrativeContent(state) {
+  if (!state) return false;
+  return [state.goal, state.acceptedRequirements, state.decisions, state.openProblems, state.nextActions].some(
+    (field) => typeof field === "string" && field.trim().length > 0
+  );
+}
+
+// src/effort-tier.ts
+var DEFAULT_EFFORT_LEVEL = "medium";
+var MECHANICAL_EFFORT_LEVEL = "low";
+var ESCALATED_EFFORT_LEVEL = "high";
+function deriveEffort(input) {
+  if (input.disabled) return null;
+  if (input.impact === "high") {
+    return {
+      level: ESCALATED_EFFORT_LEVEL,
+      escalationReason: "task impact is high (operator-set)"
+    };
+  }
+  if (input.impact === "low") {
+    return { level: MECHANICAL_EFFORT_LEVEL, escalationReason: null };
+  }
+  return { level: DEFAULT_EFFORT_LEVEL, escalationReason: null };
+}
+function effortDisabled(env = process.env) {
+  return (env.MRRLIN_EXEC_EFFORT_DISABLE ?? "").trim() === "1";
+}
+
 // src/execution-consumer.ts
 var DEFAULT_STALE_SECONDS = 300;
 var DEFAULT_MAX_LEASE_RECLAIMS = 3;
@@ -42654,6 +43202,9 @@ var BASE_INSTRUCTIONS_PREFIX = [
   "  if you are blocked and a human must decide before the work can continue, leave it at `handoff_needed`.",
   "",
   "File artifacts:",
+  "- Decide BEFORE writing your result whether the operator will scan it, compare across it,",
+  "  re-read it later, keep it, or share it. If so it is a file, not inline text \u2014 judge by use,",
+  "  not by topic, domain, or data type.",
   "- When your output is a file (markdown report, HTML, screenshot), upload it with",
   "  `upload_artifact` and embed the returned markdown link \u2014 never inline large blobs",
   "  into chat, spec, or note text.",
@@ -42661,8 +43212,28 @@ var BASE_INSTRUCTIONS_PREFIX = [
   "  or evidence page will reference (180 days). Always pass taskId/runId when known.",
   "- Anything user-facing delivered as a file MUST be uploaded. Files are capped at 5MB \u2014",
   "  split or summarize larger outputs.",
+  "- `upload_artifact` needs a real local file path, so it presupposes you can write one. When this",
+  "  run path CAN write files, produce the artifact normally \u2014 that is the default. ONLY when it",
+  "  cannot write, do NOT attempt the file: put the summary in your result text and state what a",
+  "  file would have held. Never fake a path you did not write.",
+  "",
+  "Produced URLs \u2014 the operator's per-page links come only from you:",
+  "- Call `record_produced_url` after publishing EACH web page this task produced, so the task UI",
+  "  links the page itself instead of the deployed site root. One call per page, not per run.",
+  "- Pass either a full external https URL, or a path starting with `/` to resolve against the",
+  "  run's deployed env URL. An optional `label` (<=40 chars) replaces the default page title.",
+  "- Never record the site root or a bare domain \u2014 the point is a link that opens the page itself.",
+  "  If a published page is not serving yet, record it once the deploy completes; never skip it.",
+  "  Nothing else populates these links, so a page you do not record has none at all.",
   "",
   "Browser tools (when the run needs to drive a browser):",
+  "- Choose the browser FIRST when the target is a rendered UI, the question is inherently visual,",
+  "  the content sits behind a logged-in session, or reconstructing the answer would take many",
+  "  chained fetches. A single cheap fetch is still right for a plain one-shot HTTP/HTML check.",
+  "- Escalate from a fetch to the browser in the same run on 401/403, a bot/consent/CAPTCHA wall,",
+  "  an empty JS-only shell, or a login gate. A 429 is rate limiting, not a wall \u2014 back off and",
+  "  retry once, escalating only if it persists. A failed fetch is a signal to change tool, not",
+  "  a finding \u2014 never conclude a public target is unverifiable without having tried the browser.",
   "- Use tools from the `mrrlin-browser` MCP server ONLY \u2014 browser_navigate, browser_click,",
   "  browser_snapshot, browser_type, etc. Never invoke the same-named tools from any other",
   "  browser MCP (`playwright`, `chrome-devtools`, `puppeteer`, ...) that may also be connected.",
@@ -42688,6 +43259,18 @@ var BASE_INSTRUCTIONS_PREFIX = [
   "    ## Result \u2014 what was accomplished, key findings or metrics, follow-up tasks created.",
   "    Do NOT remove earlier sections \u2014 they remain useful for context.",
   "  Adapt depth to the task: a one-line fix needs one sentence, not four headings.",
+  "",
+  // Slice 4 of token-efficient-execution-runs (D8). This is the ONLY way the reasoning behind a
+  // decision survives past this conversation: a thread is retired once it has accumulated too many
+  // runs, and the next run then starts from this record plus the repository. Everything else the
+  // next run receives (spec, run history, artifacts) is reconstructed from the database anyway —
+  // what only the model holds is why it chose what it chose, and what it intended to do next.
+  "BEFORE you end your turn, call `update_task_state` to record where this task now stands: the",
+  "goal as you understand it, decisions you made AND WHY, problems still open, and the next",
+  "concrete actions. A later run may start from a FRESH conversation that has none of this turn's",
+  "context \u2014 that record is what it will read. A decision without its reason is the thing most",
+  "often lost, so state the reason. Omit any field you learned nothing new about; an omitted field",
+  "keeps its previous value. Do not restate the spec or the file list \u2014 the next run gets those.",
   ""
 ];
 var CONSUMER_BASE_INSTRUCTIONS = [
@@ -42923,13 +43506,15 @@ async function runHasLease(deps, projectSlug, runId, leaseId) {
     return false;
   }
 }
-async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inputText, overallMs, phase) {
+async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inputText, overallMs, phase, effort) {
   const mapper = new CodexBridgeEventMapper();
   mapper.reset();
   let turnError = null;
   let interruptFailed = false;
   let touch = () => {
   };
+  let turnUsage = null;
+  const promptBytes = Buffer.byteLength(inputText, "utf8");
   const turnStartedAt = Date.now();
   let lastActivityAt = turnStartedAt;
   const persist = async (event) => {
@@ -42945,7 +43530,7 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
     } catch {
     }
   };
-  return deps.runExclusive(async () => {
+  return deps.run("exec", async () => {
     const pending = [];
     let resolveTurnEnded = null;
     const turnEnded = new Promise((resolve) => {
@@ -42958,6 +43543,8 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
         lastActivityAt = Date.now();
         touch();
       }
+      const usage = !notifThreadId || notifThreadId === threadId ? extractTurnTokenUsage(method, params) : null;
+      if (usage) turnUsage = usage;
       const events = mapper.mapNotification(
         { method, params },
         threadId
@@ -42983,7 +43570,8 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
           touch = activity.touch;
           const accepted = await codex.turn.start({
             threadId,
-            input: [{ type: "text", text: inputText }]
+            input: [{ type: "text", text: inputText }],
+            ...effort === void 0 ? {} : { effort }
           });
           acceptedTurnId = accepted?.turn?.id ?? null;
           await turnEnded;
@@ -43018,7 +43606,8 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
       clearInterval(touchTimer);
       unsub();
     }
-    return turnError ? { ok: false, error: turnError, interruptFailed } : { ok: true };
+    const telemetry = { promptBytes, usage: turnUsage };
+    return turnError ? { ok: false, error: turnError, interruptFailed, telemetry } : { ok: true, telemetry };
   });
 }
 async function driveRun(deps, projectSlug, runId) {
@@ -43088,6 +43677,47 @@ async function driveRun(deps, projectSlug, runId) {
     } : context
   );
   bundle += await deployWorkflowReverifyNotice(deps.client, projectSlug);
+  const runTelemetry = {
+    promptBytes: 0,
+    turnCount: 0,
+    usage: null
+  };
+  const recordTurn = (outcome) => {
+    runTelemetry.promptBytes += outcome.telemetry.promptBytes;
+    runTelemetry.turnCount += 1;
+    runTelemetry.usage = addTurnTokenUsage(runTelemetry.usage, outcome.telemetry.usage);
+    return outcome;
+  };
+  const effortDecision = deriveEffort({
+    impact: task.impact,
+    type: task.type,
+    disabled: effortDisabled()
+  });
+  const taskState = await deps.client.getTaskState(projectSlug, task.id).catch(() => null);
+  const retirement = decideThreadRetirement({
+    threadRunCount: taskState?.threadRunCount ?? 0,
+    hasNarrative: hasNarrativeContent(taskState),
+    disabled: threadRetireDisabled(),
+    maxRuns: threadMaxRuns(),
+    graceRuns: threadRetireGraceRuns()
+  });
+  const threadIdForAcquire = retirement.retire ? null : task.directorThreadId;
+  if (retirement.retire) {
+    console.warn(
+      JSON.stringify({
+        event: "thread_retirement_triggered",
+        projectSlug,
+        runId,
+        taskId: task.id,
+        reason: retirement.reason,
+        threadRunCount: taskState?.threadRunCount ?? 0,
+        retiringThreadId: task.directorThreadId
+      })
+    );
+  }
+  if (taskState) bundle += `
+
+${renderTaskStateSection(taskState)}`;
   const checkout = deps.checkoutRegistry?.get(projectSlug) ?? null;
   let sandbox = "read-only";
   let turnCwd = deps.codexCwd ?? null;
@@ -43163,7 +43793,7 @@ async function driveRun(deps, projectSlug, runId) {
   const pushFn = deps.pushRunBranch ?? pushRunBranch;
   try {
     const { threadId, resumed } = await acquireThread(codex, {
-      threadId: task.directorThreadId,
+      threadId: threadIdForAcquire,
       startParams: {
         cwd: turnCwd,
         approvalPolicy: "never",
@@ -43179,9 +43809,36 @@ async function driveRun(deps, projectSlug, runId) {
       },
       onThreadIdChanged: async (newId) => {
         if (!await runHasLease(deps, projectSlug, runId, leaseId)) return;
+        if (retirement.retire) return;
         await deps.client.updateTask(projectSlug, task.id, { directorThreadId: newId });
       }
     });
+    if (retirement.retire && await runHasLease(deps, projectSlug, runId, leaseId)) {
+      let persisted = true;
+      const retiredThreadId = await deps.client.retireThread(projectSlug, task.id, threadId).catch(() => {
+        persisted = false;
+        return null;
+      });
+      if (persisted) {
+        await postRunFeed(deps.client, projectSlug, runId, task.id, "thread_retired", {
+          reason: retirement.reason
+        });
+      }
+      console.warn(
+        JSON.stringify({
+          event: persisted ? "thread_retired" : "thread_retirement_write_failed",
+          projectSlug,
+          runId,
+          taskId: task.id,
+          reason: retirement.reason,
+          retiredThreadId,
+          newThreadId: threadId,
+          // Says out loud what an unpersisted retirement costs, so the log line is actionable
+          // rather than merely present.
+          ...persisted ? {} : { impact: "counter not reset and task still on the old thread; later runs will re-retire until this write succeeds" }
+        })
+      );
+    }
     if (!resumed) {
       const primingBudgetMs = remainingTurnBudgetMs();
       if (primingBudgetMs <= 0) {
@@ -43196,14 +43853,52 @@ async function driveRun(deps, projectSlug, runId) {
         );
         return;
       }
-      const primed = await driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, bundle, primingBudgetMs, "priming");
+      const primed = recordTurn(
+        await driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, bundle, primingBudgetMs, "priming", effortDecision?.level)
+      );
       if (!primed.ok) {
+        if (retirement.retire && task.directorThreadId) {
+          await deps.client.updateTask(projectSlug, task.id, { directorThreadId: task.directorThreadId }).catch(() => {
+          });
+          console.warn(
+            JSON.stringify({
+              event: "thread_retirement_reverted",
+              projectSlug,
+              runId,
+              taskId: task.id,
+              reason: retirement.reason,
+              restoredThreadId: task.directorThreadId,
+              detail: "re-prime failed; predecessor thread restored"
+            })
+          );
+        }
         await resetWedgedThread(deps, projectSlug, task.id, primed.interruptFailed);
         await failRun(deps, projectSlug, task, runId, leaseId, primed.error);
         return;
       }
     }
-    const executionPrompt = resumed ? `${bundle}
+    const priorRuns = context.runs.filter((r) => r.id !== runId);
+    const priorRun = priorRuns[priorRuns.length - 1] ?? null;
+    const useDelta = resumed && !warmDeltaDisabled() && priorRun !== null;
+    let resumeContent;
+    if (useDelta) {
+      const cutoffTime = priorRun.finishedAt ?? priorRun.createdAt;
+      const newArtifacts = context.artifacts.filter((a) => a.createdAt > cutoffTime);
+      resumeContent = renderRunDelta({
+        task: {
+          id: task.id,
+          status: task.status,
+          latestJudgement: task.latestJudgement,
+          latestJudgementKind: task.latestJudgementKind
+        },
+        newlyFinishedRuns: [priorRun],
+        newArtifacts,
+        omittedArtifactCount: context.omittedArtifactCount
+      });
+    } else {
+      resumeContent = bundle;
+    }
+    const executionPrompt = resumed ? `${resumeContent}
 
 Continue executing task ${task.id}. Make the next concrete increment of progress and record artifacts/judgements via MCP tools.` : `Continue executing task ${task.id}. Make the next concrete increment of progress and record artifacts/judgements via MCP tools.`;
     const workBudgetMs = remainingTurnBudgetMs();
@@ -43219,7 +43914,9 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
       );
       return;
     }
-    const outcome = await driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, executionPrompt, workBudgetMs, "work");
+    const outcome = recordTurn(
+      await driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, executionPrompt, workBudgetMs, "work", effortDecision?.level)
+    );
     if (!outcome.ok) {
       await resetWedgedThread(deps, projectSlug, task.id, outcome.interruptFailed);
       await failRun(deps, projectSlug, task, runId, leaseId, outcome.error);
@@ -43243,16 +43940,19 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
         })
       );
       const completionPrompt = buildCompletionTurnPrompt(task.id, readiness.task.status);
-      const completionOutcome = await driveTurn(
-        deps,
-        codex,
-        projectSlug,
-        runId,
-        leaseId,
-        threadId,
-        completionPrompt,
-        completionBudget,
-        "completion"
+      const completionOutcome = recordTurn(
+        await driveTurn(
+          deps,
+          codex,
+          projectSlug,
+          runId,
+          leaseId,
+          threadId,
+          completionPrompt,
+          completionBudget,
+          "completion",
+          effortDecision?.level
+        )
       );
       if (!completionOutcome.ok) {
         await resetWedgedThread(deps, projectSlug, task.id, completionOutcome.interruptFailed);
@@ -43431,9 +44131,97 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
       error51 instanceof Error ? error51.message : String(error51)
     );
   } finally {
+    await deps.client.updateExecutionRun(projectSlug, runId, {
+      promptBytes: runTelemetry.promptBytes,
+      turnCount: runTelemetry.turnCount,
+      inputTokens: runTelemetry.usage?.inputTokens ?? null,
+      cachedInputTokens: runTelemetry.usage?.cachedInputTokens ?? null,
+      outputTokens: runTelemetry.usage?.outputTokens ?? null,
+      // Slice 7 (7.4): record the level actually used and, when it was an escalation, what caused
+      // it — so "why did this run cost that much?" is answerable after the fact. NULL when the
+      // slice is disabled, which per D6 reads as "not set" rather than a level we chose.
+      effort: effortDecision?.level ?? null,
+      effortEscalationReason: effortDecision?.escalationReason ?? null
+    }).catch((error51) => {
+      console.warn(
+        JSON.stringify({
+          event: "run_telemetry_write_failed",
+          projectSlug,
+          runId,
+          detail: error51 instanceof Error ? error51.message : String(error51)
+        })
+      );
+    });
+    await writeServerOwnedTaskState(deps, projectSlug, task.id, runId, leaseId).catch((error51) => {
+      console.warn(
+        JSON.stringify({
+          event: "task_state_server_write_failed",
+          projectSlug,
+          runId,
+          taskId: task.id,
+          detail: error51 instanceof Error ? error51.message : String(error51)
+        })
+      );
+    });
     disposeCodex();
   }
 }
+async function writeServerOwnedTaskState(deps, projectSlug, taskId, runId, leaseId) {
+  const run3 = await deps.client.getExecutionRun(projectSlug, runId).catch(() => null);
+  if (!run3) {
+    console.warn(
+      JSON.stringify({
+        event: "task_state_server_write_skipped",
+        projectSlug,
+        runId,
+        taskId,
+        detail: "could not read the run's state_seq; skipped rather than writing a defaulted ordering value"
+      })
+    );
+    return;
+  }
+  if (run3.leaseId !== null && run3.leaseId !== leaseId) {
+    console.warn(
+      JSON.stringify({
+        event: "task_state_server_write_skipped",
+        projectSlug,
+        runId,
+        taskId,
+        detail: "the run is held by another lease (reclaimed); refusing to write state for a run we no longer own"
+      })
+    );
+    return;
+  }
+  let artifacts = null;
+  try {
+    artifacts = await deps.client.listExecutionArtifacts(projectSlug, runId);
+  } catch {
+    artifacts = null;
+  }
+  let changed = null;
+  if (artifacts !== null) {
+    const summaries = artifacts.filter((artifact) => artifact.kind === "diff_summary").map((artifact) => JSON.stringify(artifact.payload));
+    changed = summaries.length > 0 ? summaries.join("\n") : NO_FILE_CHANGES_THIS_RUN;
+  }
+  let latestVerification = null;
+  if (artifacts !== null) {
+    const verifications = artifacts.filter((artifact) => artifact.kind === "verification").map((artifact) => JSON.stringify(artifact.payload));
+    latestVerification = verifications[verifications.length - 1] ?? NO_VERIFICATION_THIS_RUN;
+  }
+  await deps.client.upsertTaskState(projectSlug, taskId, {
+    goal: null,
+    acceptedRequirements: null,
+    decisions: null,
+    openProblems: null,
+    nextActions: null,
+    relevantFiles: null,
+    filesChanged: changed,
+    latestVerification,
+    lastRunSeq: run3.stateSeq
+  });
+}
+var NO_FILE_CHANGES_THIS_RUN = "no file changes recorded in this run";
+var NO_VERIFICATION_THIS_RUN = "not run in this run";
 function buildDeliverableAuthorPrompt(task, specMarkdown) {
   return [
     `Produce the deliverable for the task below. Write the FULL deliverable content as markdown.`,
@@ -43963,7 +44751,8 @@ async function driveAsyncJob(deps, projectSlug, jobId) {
         break;
       }
       try {
-        outcome = await deps.runExclusive(
+        outcome = await deps.run(
+          "async",
           () => descriptor2.run(
             { client: deps.client, cwd: deps.cwd, codexExecutable: deps.codexExecutable },
             input
@@ -44038,7 +44827,7 @@ async function runAsyncBackstopSweep(deps, drive = (slug, jobId) => driveAsyncJo
     } catch {
       queued = [];
     }
-    for (const job of queued) await drive(slug, job.id);
+    await Promise.all(queued.map((job) => drive(slug, job.id)));
   }
 }
 
@@ -44506,13 +45295,16 @@ function createInactivityWatchdog(opts) {
   const clearT = opts.clearTimeoutFn ?? clearTimeout;
   const now = opts.now ?? Date.now;
   const suspended = opts.suspendedMs ?? (() => 0);
+  const excluded = opts.idleExcludedMs ?? (() => 0);
   let idleTimer = null;
   let maxTimer = null;
   let done = false;
   const startAt = now();
   const suspendedAtStart = suspended();
+  const excludedAtStart = excluded();
   let lastPokeAt = startAt;
   let suspendedAtLastPoke = suspendedAtStart;
+  let excludedAtLastPoke = excludedAtStart;
   const expire = (reason) => {
     if (done) return;
     done = true;
@@ -44530,7 +45322,7 @@ function createInactivityWatchdog(opts) {
   };
   const onIdleDeadline = () => {
     if (done) return;
-    const awakeSilence = now() - lastPokeAt - (suspended() - suspendedAtLastPoke);
+    const awakeSilence = now() - lastPokeAt - (suspended() - suspendedAtLastPoke) - (excluded() - excludedAtLastPoke);
     if (awakeSilence < opts.idleMs) {
       armIdle(opts.idleMs - awakeSilence);
       return;
@@ -44554,6 +45346,7 @@ function createInactivityWatchdog(opts) {
       if (idleTimer) clearT(idleTimer);
       lastPokeAt = now();
       suspendedAtLastPoke = suspended();
+      excludedAtLastPoke = excluded();
       armIdle(opts.idleMs);
     },
     cancel: () => {
@@ -44563,8 +45356,8 @@ function createInactivityWatchdog(opts) {
     }
   };
 }
-var DEFAULT_CHAT_TURN_IDLE_SECONDS = 180;
-var DEFAULT_CHAT_TURN_MAX_SECONDS = 1800;
+var DEFAULT_CHAT_TURN_IDLE_SECONDS = 300;
+var DEFAULT_CHAT_TURN_MAX_SECONDS = 2700;
 function readPositiveSeconds(name, fallback) {
   const raw = (process.env[name] ?? "").trim();
   const parsed = Number.parseInt(raw, 10);
@@ -44577,6 +45370,64 @@ function chatTurnMaxMs() {
   return readPositiveSeconds("MRRLIN_DIRECTOR_BRIDGE_CHAT_TURN_MAX_SECONDS", DEFAULT_CHAT_TURN_MAX_SECONDS) * 1e3;
 }
 
+// src/tool-busy.ts
+function createToolBusyClock(opts) {
+  const now = opts?.now ?? Date.now;
+  const open = /* @__PURE__ */ new Set();
+  let total = 0;
+  let segmentStart = null;
+  function start(itemId) {
+    if (!open.has(itemId)) {
+      open.add(itemId);
+      if (open.size === 1) {
+        segmentStart = now();
+      }
+    }
+  }
+  function end(itemId) {
+    if (open.has(itemId)) {
+      open.delete(itemId);
+      if (open.size === 0) {
+        const nowVal = now();
+        if (segmentStart !== null) {
+          total += nowVal - segmentStart;
+          segmentStart = null;
+        }
+      }
+    }
+  }
+  function endAll() {
+    if (open.size > 0) {
+      const nowVal = now();
+      if (segmentStart !== null) {
+        total += nowVal - segmentStart;
+        segmentStart = null;
+      }
+      open.clear();
+    }
+  }
+  function ms() {
+    const nowVal = now();
+    if (open.size > 0 && segmentStart !== null) {
+      return total + (nowVal - segmentStart);
+    }
+    return total;
+  }
+  return { start, end, endAll, ms };
+}
+var TOOL_ITEM_TYPES = /* @__PURE__ */ new Set(["commandExecution", "mcpToolCall", "fileChange"]);
+function applyToolBusyNotification(clock, method, params) {
+  if (method !== "item/started" && method !== "item/completed") return;
+  if (typeof params !== "object" || params === null) return;
+  const p = params;
+  const item = typeof p.item === "object" && p.item !== null ? p.item : void 0;
+  if (typeof item?.type !== "string" || !TOOL_ITEM_TYPES.has(item.type)) return;
+  const id = typeof item.id === "string" ? item.id : typeof p.itemId === "string" ? p.itemId : void 0;
+  if (id === void 0) return;
+  if (method === "item/started") clock.start(id);
+  else clock.end(id);
+}
+
 // src/worker-token.ts
 var import_node_crypto7 = require("node:crypto");
 var import_node_fs9 = require("node:fs");
@@ -48581,11 +49432,16 @@ function parseVerdict2(text) {
   let last = null;
   while ((match = re.exec(text)) !== null) last = match;
   if (!last) {
-    return { verdict: "fail", summary: "no parseable VERDICT line in verification output", turnRef: null };
+    return {
+      verdict: "fail",
+      summary: "no parseable VERDICT line in verification output",
+      turnRef: null,
+      fullOutput: text
+    };
   }
   const verdict = (last[1] ?? "").toLowerCase() === "pass" ? "pass" : "fail";
   const summary = (last[2] ?? "").trim() || `verification ${verdict}`;
-  return { verdict, summary, turnRef: null };
+  return { verdict, summary, turnRef: null, fullOutput: text };
 }
 function isBlockedVerificationHost(hostname3) {
   const h = hostname3.toLowerCase().replace(/^\[|\]$/g, "");
@@ -49482,7 +50338,9 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "- For public/third-party HTTP/HTML verification through `commandExecution`, prefer built-in",
     "  tooling such as `curl`, `python3` stdlib `urllib.request`, and `html.parser`; do not assume",
     "  third-party Python packages such as `requests` or `bs4` are installed. This permission covers",
-    "  third-party sites ONLY \u2014 never call the Mrrlin API from `commandExecution`.",
+    "  third-party sites ONLY \u2014 never call the Mrrlin API from `commandExecution`. A cheap fetch is",
+    "  the default, not the only option: see the browser-vs-fetch contract below for when a fetch is",
+    "  the wrong tool outright and when a failed fetch must be escalated to `mrrlin-browser`.",
     "",
     "Handoff contract \u2014 durable operator action MUST NOT live only in chat:",
     "- If you conclude that a specific task needs human input, account access, manual evidence,",
@@ -49515,11 +50373,49 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "  if it did not (that state REQUIRES a linked Evidence wiki page); or, if the effect still",
     "  is not measurable, re-set `verificationDueAt` to a new date with a reason.",
     "",
-    "File artifacts: when you produce a file for the operator (report, HTML, screenshot),",
-    "upload it with `upload_artifact` (class=temp for one-off downloads, class=durable when a",
-    "spec/evidence page references it; pass taskId when known) and paste the returned markdown",
-    "link into your reply. For images, embed as an image (`![name](url)`) so the chat previews",
-    "it inline. Never inline file contents into chat. 5MB max per file.",
+    "File artifacts contract \u2014 decide the delivery medium BEFORE you compose the reply:",
+    "- First ask what the operator will DO with this output. If they will scan it, compare across",
+    "  it, re-read it later, keep it, or share it, it belongs in a FILE. If they need to know one",
+    "  thing right now, chat alone is right. Judge by use, not by topic, domain, or data type.",
+    "- When it is a file: write it (`.md` for linear prose, `.html` when structure or layout",
+    "  carries meaning), upload with `upload_artifact` (class=temp for one-off downloads,",
+    "  class=durable when a spec/evidence page references it; pass taskId when known), and paste",
+    "  the returned markdown link into your reply.",
+    "- The chat reply must still stand alone as a complete answer even if the file is never opened:",
+    "  the headline finding, the few points that matter, then the link. Never reduce it to",
+    '  "see attached" or "details in the report".',
+    "- For images, embed as an image (`![name](url)`) so the chat previews it inline.",
+    "- Never inline file contents into chat. 5MB max per file.",
+    "",
+    "Browser-vs-fetch contract \u2014 pick whatever reaches ground truth in the fewest steps:",
+    "- Reach for `mrrlin-browser` FIRST, without trying a fetch at all, when the target is a",
+    "  rendered UI, the question is inherently visual, the content sits behind a logged-in session,",
+    "  or reconstructing the answer would take many chained fetches.",
+    "- A single cheap `curl`/`python3 urllib` fetch stays the right default for a plain one-shot",
+    "  HTTP/HTML check. Do not launch a browser for something one fetch already answers.",
+    "- Escalate to `mrrlin-browser` in the SAME turn whenever a fetch cannot establish ground",
+    "  truth: 401/403, a bot/consent/CAPTCHA wall, an empty JS-only shell, or a login gate. A 429",
+    "  is rate limiting, not a wall \u2014 back off and retry the fetch once, and escalate only if it",
+    "  persists (bot detection does sometimes answer 429 to non-browser clients).",
+    "- 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.",
+    "",
+    "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",
+    '  report the result. Do not end a reply with "if you want, I can also ..." for work you',
+    "  could have finished in the time it took to offer.",
+    "- This never overrides the turn-lifecycle rules above: still split a large batch UP FRONT and",
+    "  still end at a clean boundary with an explicit request to continue. Ask when the work is",
+    "  genuinely big, needs an operator decision, or would change scope \u2014 never to dodge cheap work.",
+    "",
+    "Context-handle contract \u2014 a `mrrlin://` handle is a pointer, not an answer:",
+    "- When tool output carries a `mrrlin://` handle and your answer depends on detail the compact",
+    "  envelope does not contain, call `retrieve_context` on that handle BEFORE answering.",
+    "- Before any irreversible action on a handled record \u2014 closing a task, dispatching a deploy,",
+    "  writing a spec \u2014 call `retrieve_context` first. Never act on a compact envelope alone.",
+    "- Never guess the missing detail, and never report a field as absent when it is merely",
+    "  un-rehydrated. Do not echo a raw handle to the operator as if it were data.",
     "",
     "Clarifying-question contract \u2014 ask early, never lose the question:",
     "- During a live chat turn, when a SPECIFIC task is ambiguous and the ambiguity affects",
@@ -50685,7 +51581,7 @@ function createBridgeMessageHandler(deps) {
         }
       };
       try {
-        await deps.runExclusive(async () => {
+        await deps.run("chat", async () => {
           if (currentReplayBuf.state === "interrupted" || currentReplayBuf.state === "completed") {
             logCtx?.logger.logOut({
               spanId,
@@ -50714,7 +51610,9 @@ function createBridgeMessageHandler(deps) {
             outputEvents += 1;
             sendInTurn({ type: "event", directorSessionId, event });
           };
+          const toolBusy = createToolBusyClock();
           const unsub = codexClient.onNotification((method, params) => {
+            applyToolBusyNotification(toolBusy, method, params);
             pokeActivity();
             if (method === "account/rateLimits/updated") {
               const snapshot = params?.rateLimits ?? null;
@@ -50742,6 +51640,7 @@ function createBridgeMessageHandler(deps) {
             idleMs,
             maxMs,
             ...deps.suspendedMs ? { suspendedMs: deps.suspendedMs } : {},
+            idleExcludedMs: () => toolBusy.ms(),
             onExpire: (reason) => {
               rejectWatchdog?.(
                 new Error(
@@ -50845,6 +51744,7 @@ ${effectiveText}` : effectiveText;
             }
             watchdog.cancel();
             unsub();
+            toolBusy.endAll();
             thread.cancel = null;
           }
         });
@@ -50964,8 +51864,8 @@ async function startDirectorBridge() {
   const turnLock = createTurnLock();
   let lastTurnEndedAt = Date.now();
   const wrappedTurnLock = {
-    runExclusive(fn) {
-      return turnLock.runExclusive(async () => {
+    run(lane, fn) {
+      return turnLock.run(lane, async () => {
         try {
           return await fn();
         } finally {
@@ -51008,7 +51908,11 @@ async function startDirectorBridge() {
     }
   });
   const codexProbeHandle = startCodexProbe();
-  const consumerState = { inFlightRunId: null, lastClaimAt: null };
+  const consumerState = {
+    inFlightRunIds: /* @__PURE__ */ new Set(),
+    lastClaimedRunId: null,
+    lastClaimAt: null
+  };
   const health = createServiceHealth();
   try {
     migrateRetiredApiBaseUrls();
@@ -51087,7 +51991,7 @@ async function startDirectorBridge() {
     // handle returned by acquireExecutorCodex (Fix A + G), so there is no shared
     // mutable `activeExecutorClient` slot to race a concurrent chat/bootstrap turn.
     releaseCodex: () => codexKeepalive.release(),
-    runExclusive: wrappedTurnLock.runExclusive,
+    run: wrappedTurnLock.run,
     staleSeconds,
     touchIntervalMs: Math.min(DEFAULT_TOUCH_INTERVAL_MS, Math.floor(staleSeconds * 1e3 / 2)),
     codexCwd: config2.codexCwd,
@@ -51114,7 +52018,7 @@ async function startDirectorBridge() {
     // ADR 0007 self-review: critique the committed diff on the executor's own client before
     // push/PR. Reuses the verification turn-runner (acquireThread + collect assistant text).
     selfReviewTurn: createSelfReviewTurn({
-      runTurn: (codexClient, cwd, prompt) => runCollectedCodexTurn(codexClient, prompt, cwd, SELF_REVIEW_BASE_INSTRUCTIONS)
+      runTurn: (codexClient, cwd, prompt) => wrappedTurnLock.run("chat", () => runCollectedCodexTurn(codexClient, prompt, cwd, SELF_REVIEW_BASE_INSTRUCTIONS))
     }),
     // ADR 0015 deploy gate: after a pushed run reaches dev_deploy/prod_deploy, the backstop sweep
     // dispatches the deploy + polls + runs a verification turn against the deployed env URL in a
@@ -51153,7 +52057,7 @@ async function startDirectorBridge() {
             }
           };
         },
-        runTurn: (codexClient, prompt, cwd) => runCollectedCodexTurn(codexClient, prompt, cwd, VERIFICATION_BASE_INSTRUCTIONS)
+        runTurn: (codexClient, prompt, cwd) => wrappedTurnLock.run("chat", () => runCollectedCodexTurn(codexClient, prompt, cwd, VERIFICATION_BASE_INSTRUCTIONS))
       }),
       budgetSeconds: deployPollBudgetSeconds()
     },
@@ -51178,7 +52082,7 @@ async function startDirectorBridge() {
   const bridgeInstanceId = (0, import_node_crypto8.randomUUID)();
   const asyncConsumerDeps = {
     client,
-    runExclusive: wrappedTurnLock.runExclusive,
+    run: wrappedTurnLock.run,
     cwd: config2.codexCwd ?? process.cwd(),
     codexExecutable: config2.codexExecutable,
     staleSeconds,
@@ -51194,40 +52098,34 @@ async function startDirectorBridge() {
       sink({ type: "async-result", directorSessionId, projectSlug: slug, deliveryKind, body });
     }
   };
-  let execChain = Promise.resolve();
-  const enqueueRun = (job) => {
-    execChain = execChain.then(job, job);
-  };
-  const driveTracked = (slug, runId) => enqueueRun(async () => {
-    consumerState.inFlightRunId = runId;
+  const driveTracked = (slug, runId) => {
+    consumerState.inFlightRunIds.add(runId);
+    consumerState.lastClaimedRunId = runId;
     consumerState.lastClaimAt = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      await driveRun(consumerDeps, slug, runId);
-    } catch (error51) {
+    void driveRun(consumerDeps, slug, runId).catch((error51) => {
       process.stderr.write(`[mrrlin-mcp director-bridge] drive failed for ${slug}/${runId}: ${error51 instanceof Error ? error51.message : String(error51)}
 `);
-    } finally {
-      consumerState.inFlightRunId = null;
-    }
-  });
+    }).finally(() => {
+      consumerState.inFlightRunIds.delete(runId);
+    });
+  };
   const driveRunNow = (slug, runId) => {
-    consumerState.inFlightRunId = runId;
+    consumerState.inFlightRunIds.add(runId);
+    consumerState.lastClaimedRunId = runId;
     consumerState.lastClaimAt = (/* @__PURE__ */ new Date()).toISOString();
     void driveRun(consumerDeps, slug, runId).catch((error51) => {
       process.stderr.write(`[mrrlin-mcp director-bridge] drive failed for ${slug}/${runId}: ${error51 instanceof Error ? error51.message : String(error51)}
 `);
     }).finally(() => {
-      consumerState.inFlightRunId = null;
+      consumerState.inFlightRunIds.delete(runId);
     });
   };
-  const driveAsyncTracked = (slug, jobId) => enqueueRun(async () => {
-    try {
-      await driveAsyncJob(asyncConsumerDeps, slug, jobId);
-    } catch (error51) {
+  const driveAsyncTracked = (slug, jobId) => {
+    void driveAsyncJob(asyncConsumerDeps, slug, jobId).catch((error51) => {
       process.stderr.write(`[mrrlin-mcp director-bridge] async drive failed for ${slug}/${jobId}: ${error51 instanceof Error ? error51.message : String(error51)}
 `);
-    }
-  });
+    });
+  };
   const driveAsyncNow = (slug, jobId) => {
     void driveAsyncJob(asyncConsumerDeps, slug, jobId).catch((error51) => {
       process.stderr.write(`[mrrlin-mcp director-bridge] async drive failed for ${slug}/${jobId}: ${error51 instanceof Error ? error51.message : String(error51)}
@@ -51240,7 +52138,15 @@ async function startDirectorBridge() {
       port: config2.port,
       token: config2.token,
       allowedOrigins: config2.allowedOrigins,
-      getHealth: () => ({ ok: true, inFlightRunId: consumerState.inFlightRunId, lastClaimAt: consumerState.lastClaimAt, service: health.snapshot() })
+      getHealth: () => ({
+        ok: true,
+        // Most recently claimed run, or null once nothing is in flight — kept for existing consumers.
+        inFlightRunId: consumerState.inFlightRunIds.size > 0 ? consumerState.lastClaimedRunId : null,
+        inFlightRunIds: Array.from(consumerState.inFlightRunIds),
+        inFlightCount: consumerState.inFlightRunIds.size,
+        lastClaimAt: consumerState.lastClaimAt,
+        service: health.snapshot()
+      })
     })
   );
   const threads = /* @__PURE__ */ new Map();
@@ -51303,7 +52209,7 @@ async function startDirectorBridge() {
   const sharedHandlerDeps = {
     acquireCodex: () => codexKeepalive.acquire(),
     releaseCodex: () => codexKeepalive.release(),
-    runExclusive: wrappedTurnLock.runExclusive,
+    run: wrappedTurnLock.run,
     suspendedMs: () => suspensionDetector.suspendedMs(),
     buildStartParams: (msg, desiredModel) => buildThreadStartParams(msg, config2, desiredModel),
     turnInactivity: () => ({ idleMs: chatTurnIdleMs(), maxMs: chatTurnMaxMs() }),
@@ -51449,7 +52355,7 @@ async function startDirectorBridge() {
       await bridgeHealth.recordSuccess();
     } catch (error51) {
       process.stderr.write(
-        `[mrrlin-mcp director-bridge] ${label} failed: ${error51 instanceof Error ? error51.message : String(error51)}
+        `[mrrlin-mcp director-bridge] ${label} failed: ${describeError(error51)}
 `
       );
       bridgeHealth.recordFailure(id, error51);
@@ -51461,34 +52367,28 @@ async function startDirectorBridge() {
   const scheduleClaimLoop = () => {
     if (claimLoopStopped) return;
     claimTimer = setTimeout(() => {
-      enqueueRun(
-        () => runTrackedSweep(
-          "claimSweep",
-          "claim sweep",
-          () => runBackstopSweep(consumerDeps, (slug, runId) => {
-            driveTracked(slug, runId);
-            return Promise.resolve();
-          })
-        )
-      );
-      enqueueRun(
-        () => runTrackedSweep(
-          "asyncSweep",
-          "async sweep",
-          () => runAsyncBackstopSweep(asyncConsumerDeps, (slug, jobId) => {
-            driveAsyncTracked(slug, jobId);
-            return Promise.resolve();
-          })
-        )
+      void runTrackedSweep(
+        "claimSweep",
+        "claim sweep",
+        () => runBackstopSweep(consumerDeps, (slug, runId) => {
+          driveTracked(slug, runId);
+          return Promise.resolve();
+        })
       );
-      enqueueRun(
-        () => runOrphanWorktreeSweep(client, {
-          checkoutRegistry,
-          worktreeRoot: import_node_path18.default.join(config2.stateDir, "worktrees"),
-          locksDir: import_node_path18.default.join(config2.stateDir, "locks")
+      void runTrackedSweep(
+        "asyncSweep",
+        "async sweep",
+        () => runAsyncBackstopSweep(asyncConsumerDeps, (slug, jobId) => {
+          driveAsyncTracked(slug, jobId);
+          return Promise.resolve();
         })
       );
-      enqueueRun(async () => {
+      void runOrphanWorktreeSweep(client, {
+        checkoutRegistry,
+        worktreeRoot: import_node_path18.default.join(config2.stateDir, "worktrees"),
+        locksDir: import_node_path18.default.join(config2.stateDir, "locks")
+      });
+      {
         const { retainedBuffers, retainedBytes, tombstonesRemoved } = sweepReplayBuffers(threads, tombstones, {
           now: Date.now(),
           suspendedMs: () => suspensionDetector.suspendedMs(),
@@ -51526,7 +52426,7 @@ async function startDirectorBridge() {
             payload: { removed: tombstonesRemoved }
           });
         }
-      });
+      }
       scheduleClaimLoop();
     }, claimIntervalMs());
     claimTimer.unref?.();
@@ -51564,7 +52464,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: ${err instanceof Error ? err.message : String(err)}
+        `[mrrlin-mcp director-bridge] agent-pool snapshot push failed: ${describeError(err)}
 `
       )
     });
@@ -56500,31 +57400,12 @@ var mcpToolNames = {
   restartExecutionRun: "restart_execution_run",
   resolveHandoff: "resolve_handoff",
   recordProducedUrl: "record_produced_url",
+  updateTaskState: "update_task_state",
   registerLocalCheckout: "register_local_checkout",
   /** Compact-context retrieval: rehydrate a mrrlin:// handle into the canonical full record. */
   retrieveContext: "retrieve_context"
 };
 
-// src/context-compact/policy.ts
-var DEFAULT_THRESHOLD_CHARS = 12e3;
-var DEFAULT_MAX_ITEMS = 25;
-function readPositiveInt(value, fallback) {
-  const raw = (value ?? "").trim();
-  if (!raw) return fallback;
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-function readCompactPolicy(env = process.env) {
-  const disabled = (env.MRRLIN_MCP_COMPACT_DISABLE ?? "").trim() === "1";
-  return {
-    enabled: !disabled,
-    thresholdChars: readPositiveInt(env.MRRLIN_MCP_COMPACT_THRESHOLD_CHARS, DEFAULT_THRESHOLD_CHARS),
-    maxItems: readPositiveInt(env.MRRLIN_MCP_COMPACT_MAX_ITEMS, DEFAULT_MAX_ITEMS),
-    debug: (env.MRRLIN_MCP_COMPACT_DEBUG ?? "").trim() === "1",
-    retrievalBudgetDisable: (env.MRRLIN_RETRIEVAL_BUDGET_DISABLE ?? "").trim() === "1"
-  };
-}
-
 // src/context-compact/handles.ts
 var MRRLIN_HANDLE_SCHEME = "mrrlin://";
 var SLUG_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
@@ -56599,7 +57480,7 @@ function parseMrrlinHandle(value) {
 var NOTES_EXCERPT_CHARS = 200;
 var TITLE_TRUNCATE_CHARS = 160;
 var EXCERPT_TRUNCATE_CHARS = 240;
-function truncate(value, maxChars) {
+function truncate2(value, maxChars) {
   if (value.length <= maxChars) return value;
   return `${value.slice(0, Math.max(0, maxChars - 1))}\u2026`;
 }
@@ -56615,7 +57496,7 @@ function compactTaskList(projectSlug, tasks, maxItems) {
   const slice = tasks.slice(0, included);
   const items = slice.map((t) => ({
     id: t.id,
-    title: truncate(t.title, TITLE_TRUNCATE_CHARS),
+    title: truncate2(t.title, TITLE_TRUNCATE_CHARS),
     status: t.status,
     type: t.type,
     category: t.category,
@@ -56626,8 +57507,8 @@ function compactTaskList(projectSlug, tasks, maxItems) {
     assignee: t.assignee,
     planId: t.planId,
     specWikiPageId: t.specWikiPageId,
-    notesExcerpt: t.notes ? truncate(t.notes, NOTES_EXCERPT_CHARS) : null,
-    latestJudgementExcerpt: t.latestJudgement ? truncate(t.latestJudgement, NOTES_EXCERPT_CHARS) : null,
+    notesExcerpt: t.notes ? truncate2(t.notes, NOTES_EXCERPT_CHARS) : null,
+    latestJudgementExcerpt: t.latestJudgement ? truncate2(t.latestJudgement, NOTES_EXCERPT_CHARS) : null,
     handle: formatTaskHandle(projectSlug, t.id)
   }));
   const handles = slice.map((t) => ({
@@ -56648,7 +57529,7 @@ function compactWikiPageList(projectSlug, pages, maxItems) {
   const slice = pages.slice(0, included);
   const items = slice.map((p) => ({
     id: p.id,
-    title: truncate(p.title, TITLE_TRUNCATE_CHARS),
+    title: truncate2(p.title, TITLE_TRUNCATE_CHARS),
     folder: p.folder,
     path: p.path,
     updatedAt: p.updatedAt,
@@ -56675,7 +57556,7 @@ function compactWikiSearch(projectSlug, results, maxItems) {
   const slice = results.slice(0, included);
   const items = slice.map((r) => ({
     pageId: r.id,
-    title: truncate(r.title, TITLE_TRUNCATE_CHARS),
+    title: truncate2(r.title, TITLE_TRUNCATE_CHARS),
     folder: r.folder,
     path: r.path,
     rank: r.rank,
@@ -56683,7 +57564,7 @@ function compactWikiSearch(projectSlug, results, maxItems) {
     ageDays: r.ageDays,
     memoryClass: r.memoryClass,
     precedence: r.precedence,
-    snippet: truncate(r.snippet, EXCERPT_TRUNCATE_CHARS),
+    snippet: truncate2(r.snippet, EXCERPT_TRUNCATE_CHARS),
     handle: formatWikiHandle(projectSlug, r.id)
   }));
   const handles = slice.map((r) => ({
@@ -56712,7 +57593,7 @@ function compactProjectSnapshot(projectSlug, snapshot, maxItems) {
   }
   const compactPlans = snapshot.plans.map((p) => ({
     id: p.id,
-    name: truncate(p.name, TITLE_TRUNCATE_CHARS),
+    name: truncate2(p.name, TITLE_TRUNCATE_CHARS),
     status: p.status,
     taskCount: p.taskCount,
     closedTaskCount: p.closedTaskCount,
@@ -56784,7 +57665,7 @@ function compactArtifactPayload(artifact) {
         cwd,
         exitCode,
         firstError,
-        tail: truncate(tail2, ARTIFACT_PAYLOAD_BUDGET),
+        tail: truncate2(tail2, ARTIFACT_PAYLOAD_BUDGET),
         totalLines: lines2.length
       };
     }
@@ -56792,7 +57673,7 @@ function compactArtifactPayload(artifact) {
       return {
         status: payload.status ?? null,
         command: payload.command ?? null,
-        summary: typeof payload.summary === "string" ? truncate(payload.summary, ARTIFACT_PAYLOAD_BUDGET) : null,
+        summary: typeof payload.summary === "string" ? truncate2(payload.summary, ARTIFACT_PAYLOAD_BUDGET) : null,
         failed: Array.isArray(payload.failedTests) ? payload.failedTests.slice(0, 25) : null
       };
     }
@@ -56810,7 +57691,7 @@ function compactArtifactPayload(artifact) {
     case "checkpoint":
     default: {
       const flattened = JSON.stringify(payload);
-      return { excerpt: truncate(flattened, ARTIFACT_PAYLOAD_BUDGET) };
+      return { excerpt: truncate2(flattened, ARTIFACT_PAYLOAD_BUDGET) };
     }
   }
 }
@@ -56849,7 +57730,7 @@ function compactTaskEvents(projectSlug, taskId, events, maxItems) {
     createdAt: e.createdAt,
     autonomyLevel: e.autonomyLevel,
     autonomyReason: e.autonomyReason,
-    bodyExcerpt: e.body ? truncate(e.body, NOTES_EXCERPT_CHARS) : null
+    bodyExcerpt: e.body ? truncate2(e.body, NOTES_EXCERPT_CHARS) : null
   }));
   const handles = [
     {
@@ -56871,7 +57752,7 @@ function compactGeneric(value, maxItems, projectSlug) {
     const included = Math.min(total, maxItems);
     const slice = value.slice(0, included).map((entry) => {
       const text2 = typeof entry === "string" ? entry : JSON.stringify(entry);
-      return truncate(text2, ARTIFACT_PAYLOAD_BUDGET);
+      return truncate2(text2, ARTIFACT_PAYLOAD_BUDGET);
     });
     return {
       summary: `Compact array view: ${total} entries, ${included} included.`,
@@ -56902,7 +57783,7 @@ function compactGeneric(value, maxItems, projectSlug) {
   const text = typeof value === "string" ? value : JSON.stringify(value);
   return {
     summary: "Compact scalar view.",
-    items: [truncate(text, ARTIFACT_PAYLOAD_BUDGET)],
+    items: [truncate2(text, ARTIFACT_PAYLOAD_BUDGET)],
     handles: [],
     counts: { total: 1, included: 1, omitted: 0 }
   };
@@ -57072,6 +57953,7 @@ var updateExecutionRunInputSchema = runScopedSchema.merge(mrrlinExecutionRunUpda
 var listExecutionArtifactsInputSchema = runScopedSchema;
 var appendExecutionArtifactInputSchema = runScopedSchema.merge(mrrlinExecutionArtifactCreateSchema);
 var recordProducedUrlInputSchema = runScopedSchema.merge(mrrlinProducedUrlPayloadSchema);
+var updateTaskStateInputSchema = runScopedSchema.merge(mrrlinTaskStateReportSchema);
 var getProjectSchedulerPolicyInputSchema = projectScopedSchema;
 var upsertProjectSchedulerPolicyInputSchema = projectScopedSchema.merge(mrrlinProjectSchedulerPolicyUpsertSchema);
 var recordDeployWorkflowInputSchema = projectScopedSchema.extend({
@@ -57184,6 +58066,7 @@ var mcpToolInputSchemas = {
   [mcpToolNames.restartExecutionRun]: restartExecutionRunInputSchema,
   [mcpToolNames.resolveHandoff]: resolveHandoffInputSchema,
   [mcpToolNames.recordProducedUrl]: recordProducedUrlInputSchema,
+  [mcpToolNames.updateTaskState]: updateTaskStateInputSchema,
   [mcpToolNames.registerLocalCheckout]: registerLocalCheckoutInputSchema,
   [mcpToolNames.retrieveContext]: retrieveContextInputSchema
 };
@@ -57235,6 +58118,7 @@ var mcpToolOperationIds = {
   [mcpToolNames.recordDeployWorkflow]: openApiOperationIds.upsertProjectDeployWorkflow,
   [mcpToolNames.updatePlan]: openApiOperationIds.updatePlan,
   [mcpToolNames.updateTask]: openApiOperationIds.updateTask,
+  [mcpToolNames.updateTaskState]: openApiOperationIds.reportTaskState,
   [mcpToolNames.resetDirectorThread]: openApiOperationIds.resetDirectorThread,
   [mcpToolNames.archiveTask]: openApiOperationIds.archiveTask,
   [mcpToolNames.unarchiveTask]: openApiOperationIds.unarchiveTask,
@@ -57295,6 +58179,7 @@ var mcpToolDescriptions = {
   [mcpToolNames.runCodeReviewerGate]: `Review the current branch's code diff (vs baseRef) with a Code Reviewer gate \u2014 independent reviewers iterate review\u2192fix\u2192re-check (checkpoint, scope-limited reviser edits, typecheck/build fast-gate, rollback) until the diff converges or is blocked. Run before opening a PR. Pass extraHeads: ["security-analyst"] for sensitive diffs (auth, secrets, input handling, new endpoints).`,
   [mcpToolNames.appendExecutionArtifact]: "Append a durable artifact (plan, checkpoint, command output, test result, diff summary, self-review, error, deploy attempt, or handoff judgement) to an execution run.",
   [mcpToolNames.recordProducedUrl]: 'Call this after publishing each web page produced by the task, so the UI link opens the page itself instead of the deployed site root. Pass the page\'s full https URL (for external pages, e.g. "https://dev.to/<slug>") OR a path starting with "/" for the deploy environment (e.g. "/blog/<slug>") \u2014 paths are resolved against the run\'s deployed env URL at render time. Optional `label` (\u226440 chars) is shown next to the link; omit and the UI defaults to the page title. Call once per page; multiple calls dedupe by resolved URL in the UI.',
+  [mcpToolNames.updateTaskState]: "Record where this task actually stands, in your own words, BEFORE you end your turn. This is the handoff the next run reads: it survives even when this conversation does not, because a thread is retired once it has accumulated too many runs and the next run then starts from this record plus the repository. Report what only you know \u2014 the goal as you now understand it, decisions you made AND WHY (a decision without its reason is the thing most often lost), problems still open, and the next concrete actions. Omit any field you learned nothing new about; an omitted field keeps its previous value rather than being cleared. Use one entry per line for decisions/next actions. Do not restate the spec or the file list \u2014 the next run gets those anyway.",
   [mcpToolNames.createExecutionRun]: 'Create a durable Director execution run for a task. Persists status, branch/SHA, workflow ids, and checkpoint cursor outside the chat transcript. For tasks that require a browser (login flows, UI verification, scraping), set prerequisites:[{mcp:"mrrlin-browser",reason:"<why a browser is needed>"}] so any resulting handoff offers a one-click "Launch browser & resume". When actually driving the browser inside the run, invoke tools from the `mrrlin-browser` MCP server ONLY (browser_navigate/browser_click/browser_snapshot/browser_type/etc.) \u2014 never from `playwright`, `chrome-devtools`, `puppeteer`, or any other browser MCP that may also be connected on the operator\'s box. Only `mrrlin-browser` uses the dedicated Chromium + persistent operator profile.',
   [mcpToolNames.getExecutionRun]: "Fetch a single execution run by id.",
   [mcpToolNames.listExecutionArtifacts]: "List artifacts captured during an execution run, in chronological order.",
@@ -57892,6 +58777,13 @@ function createMrrlinTools(options) {
       "Unable to append execution artifact.",
       async (c, { projectSlug, runId, ...input }) => await c.appendExecutionArtifact(projectSlug, runId, input)
     ),
+    [mcpToolNames.updateTaskState]: makeTool(
+      client,
+      mcpToolNames.updateTaskState,
+      "TASK_STATE_REPORT_FAILED",
+      "Unable to record task state.",
+      async (c, { projectSlug, runId, ...report }) => await c.reportTaskState(projectSlug, runId, report)
+    ),
     [mcpToolNames.recordProducedUrl]: makeTool(
       client,
       mcpToolNames.recordProducedUrl,
@@ -58553,11 +59445,13 @@ Usage:
                                 - MRRLIN_WORKER_PORT (dispatch listener, default 8792)
                                 - MRRLIN_DIRECTOR_BRIDGE_CLAIM_INTERVAL_SECONDS (default 30)
                                 - MRRLIN_DIRECTOR_BRIDGE_STALE_SECONDS (default 300)
-                                - MRRLIN_DIRECTOR_BRIDGE_CHAT_TURN_IDLE_SECONDS (default 180;
+                                - MRRLIN_DIRECTOR_BRIDGE_CHAT_TURN_IDLE_SECONDS (default 300;
                                   a chat turn is cut only after this long with NO codex
-                                  signal at all \u2014 long-but-active turns keep running)
-                                - MRRLIN_DIRECTOR_BRIDGE_CHAT_TURN_MAX_SECONDS (default 1800;
-                                  absolute ceiling for one chat turn regardless of activity)
+                                  signal at all AND no tool call in flight \u2014 long-but-active
+                                  turns, and long single tool calls, keep running)
+                                - MRRLIN_DIRECTOR_BRIDGE_CHAT_TURN_MAX_SECONDS (default 2700;
+                                  absolute ceiling for one chat turn regardless of activity;
+                                  the only guard against a genuinely hung tool call)
                                 - MRRLIN_DIRECTOR_BRIDGE_CODEX_IDLE_SECONDS (default 300;
                                   how long the warm codex app-server is kept alive
                                   between turns before it is released)