@mrrlin-dev/mcp 0.3.59 → 0.3.62

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,
@@ -21833,136 +21833,6 @@ async function acquireThread(codex, opts) {
   return { threadId: newId, resumed: false };
 }
 
-// ../../packages/codex-client/dist/render-context-bundle.js
-var DEFAULT_SPEC_BUDGET_CHARS = 6e3;
-var DEFAULT_ARTIFACT_PAYLOAD_BUDGET_CHARS = 400;
-function renderContextBundle(input) {
-  const sections = [];
-  sections.push(renderTaskSummary(input.task));
-  sections.push(renderSpec(input.specMarkdown, input.compact));
-  sections.push(renderRunHistory(input.runs, input.openRunId));
-  sections.push(renderOpenRun(input.openRunId));
-  sections.push(renderArtifacts(input.artifacts, input.omittedArtifactCount ?? 0, input.compact));
-  sections.push(renderAutonomyEvents(input.autonomyEvents));
-  return sections.join("\n\n");
-}
-function renderTaskSummary(task) {
-  const lines2 = [
-    "## Task",
-    `id: ${task.id}`,
-    `title: ${task.title}`,
-    `autonomy: ${task.autonomyLevel} (${task.autonomyReason})`
-  ];
-  if (task.notes)
-    lines2.push(`description: ${task.notes}`);
-  if (task.latestJudgement) {
-    lines2.push(`latest judgement (${task.latestJudgementKind ?? "unknown"}): ${task.latestJudgement}`);
-  }
-  return lines2.join("\n");
-}
-function renderSpec(specMarkdown, compact) {
-  if (!specMarkdown)
-    return "## Spec\n(none)";
-  if (!compact)
-    return `## Spec
-${specMarkdown}`;
-  const budget = compact.specBudgetChars ?? DEFAULT_SPEC_BUDGET_CHARS;
-  if (specMarkdown.length <= budget)
-    return `## Spec
-${specMarkdown}`;
-  return `## Spec
-${compactSpecMarkdown(specMarkdown, budget, compact.projectSlug ?? null, compact.specWikiPageId ?? null)}`;
-}
-function compactSpecMarkdown(markdown, totalBudget, projectSlug, specWikiPageId) {
-  const lines2 = markdown.split(/\r?\n/);
-  const sections = [{ heading: "", body: [] }];
-  for (const line of lines2) {
-    if (/^#{1,6}\s/.test(line)) {
-      sections.push({ heading: line, body: [] });
-    } else {
-      sections[sections.length - 1]?.body.push(line);
-    }
-  }
-  const sectionCount = Math.max(1, sections.length);
-  const perSectionBudget = Math.max(120, Math.floor(totalBudget / sectionCount));
-  const out = [];
-  for (const section of sections) {
-    const bodyText = section.body.join("\n").replace(/^\s+|\s+$/g, "");
-    if (section.heading)
-      out.push(section.heading);
-    if (!bodyText)
-      continue;
-    if (bodyText.length <= perSectionBudget) {
-      out.push(bodyText);
-    } else {
-      const kept = bodyText.slice(0, perSectionBudget);
-      const omitted = bodyText.length - perSectionBudget;
-      out.push(`${kept}
-\u2026(${omitted} chars omitted; retrieve full spec for the rest)`);
-    }
-  }
-  if (projectSlug && specWikiPageId) {
-    out.push("");
-    out.push(`> Compact spec. Source: mrrlin://wiki/${projectSlug}/${specWikiPageId} \u2014 call retrieve_context with this handle before any irreversible decision.`);
-  } else {
-    out.push("");
-    out.push("> Compact spec. Retrieve the Specs/{id} wiki page via get_wiki_page before any irreversible decision.");
-  }
-  return out.join("\n");
-}
-function renderRunHistory(runs, openRunId) {
-  if (runs.length === 0)
-    return "## Execution-run history\n(none)";
-  const lines2 = ["## Execution-run history"];
-  for (const run3 of runs) {
-    const marker = run3.id === openRunId ? " (open)" : "";
-    lines2.push(`- ${run3.id} [${run3.status}] created ${run3.createdAt}${marker}`);
-  }
-  return lines2.join("\n");
-}
-function renderOpenRun(openRunId) {
-  return `## Open run
-${openRunId ?? "(none)"}`;
-}
-function renderArtifacts(artifacts, omittedCount, compact) {
-  if (artifacts.length === 0 && omittedCount === 0)
-    return "## Artifacts\n(none)";
-  const lines2 = ["## Artifacts"];
-  if (omittedCount > 0) {
-    lines2.push(`(+${omittedCount} older artifact${omittedCount === 1 ? "" : "s"} omitted)`);
-  }
-  let truncatedAny = false;
-  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;
-      }
-    }
-    const payloadText = JSON.stringify(artifact.payload);
-    const budget = compact?.artifactPayloadBudgetChars ?? DEFAULT_ARTIFACT_PAYLOAD_BUDGET_CHARS;
-    const willTruncate = !!compact && payloadText.length > budget;
-    const rendered = willTruncate ? `${payloadText.slice(0, budget)}\u2026(${payloadText.length - budget} chars omitted)` : payloadText;
-    if (willTruncate)
-      truncatedAny = true;
-    lines2.push(`- ${artifact.createdAt} [${artifact.kind}] run=${artifact.runId} ${rendered}`);
-  }
-  if (compact && (omittedCount > 0 || truncatedAny)) {
-    lines2.push("> Compact artifacts. Use retrieve_context with a `mrrlin://run/{projectSlug}/{runId}/artifacts` handle (substitute the slug and run id from the lines above) to load a run's full artifact history.");
-  }
-  return lines2.join("\n");
-}
-function renderAutonomyEvents(events) {
-  if (events.length === 0)
-    return "## Autonomy history\n(none)";
-  const lines2 = ["## Autonomy history"];
-  for (const event of events) {
-    lines2.push(`- ${event.createdAt} ${event.autonomyLevel ?? "?"} (${event.autonomyReason ?? ""})`);
-  }
-  return lines2.join("\n");
-}
-
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -36562,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",
@@ -36662,19 +36539,22 @@ var agentPoolResponseSchema = external_exports.object({
 });
 
 // ../../packages/schemas/dist/specConsensusReview.js
+var mrrlinSpecConsensusSuppressionEvidenceSchema = external_exports.record(external_exports.string(), external_exports.unknown()).nullable();
 var mrrlinSpecConsensusReviewSchema = external_exports.object({
   projectSlug: external_exports.string().min(1),
   specPageId: external_exports.string().min(1),
   contentHash: external_exports.string().min(1),
   outcome: external_exports.string().min(1),
   rounds: external_exports.number().int().nonnegative(),
+  suppressionEvidence: mrrlinSpecConsensusSuppressionEvidenceSchema.default(null),
   createdAt: external_exports.string().datetime()
 });
 var mrrlinSpecConsensusReviewCreateSchema = external_exports.object({
   specPageId: external_exports.string().min(1),
   contentHash: external_exports.string().min(1),
   outcome: external_exports.string().min(1),
-  rounds: external_exports.number().int().nonnegative()
+  rounds: external_exports.number().int().nonnegative(),
+  suppressionEvidence: mrrlinSpecConsensusSuppressionEvidenceSchema.optional()
 }).strict();
 var specConsensusReviewResponseSchema = external_exports.object({ data: mrrlinSpecConsensusReviewSchema });
 var specConsensusReviewMaybeResponseSchema = external_exports.object({ data: mrrlinSpecConsensusReviewSchema.nullable() });
@@ -36750,6 +36630,97 @@ var mrrlinAsyncJobRequeueSchema = external_exports.object({
   staleSeconds: external_exports.number().int().min(60).max(86400).default(300)
 });
 
+// ../../packages/schemas/dist/memory-budget.js
+function evictionKey(item, idx) {
+  const memClass = item.memoryClass === "historical" ? 0 : 1;
+  const prec = item.precedence === null ? -4 : -item.precedence;
+  const score = item.score ?? 0;
+  return { memClass, prec, score, idx };
+}
+function compareEvictionKeys(a, b) {
+  if (a.memClass !== b.memClass)
+    return a.memClass - b.memClass;
+  if (a.prec !== b.prec)
+    return a.prec - b.prec;
+  if (a.score !== b.score)
+    return a.score - b.score;
+  return a.idx - b.idx;
+}
+function sortByEvictionOrder(items) {
+  const indexed = items.map((item, idx) => ({ item, key: evictionKey(item, idx) }));
+  indexed.sort((a, b) => compareEvictionKeys(a.key, b.key));
+  return indexed.map((x) => x.item);
+}
+function keepUnderCap(sorted, cap) {
+  const kept = [];
+  let used = 0;
+  let i = sorted.length - 1;
+  for (; i >= 0; i--) {
+    const item = sorted[i];
+    if (item === void 0)
+      break;
+    if (used + item.size <= cap) {
+      kept.unshift(item);
+      used += item.size;
+    } else {
+      break;
+    }
+  }
+  const dropped = sorted.slice(0, i + 1);
+  return { kept, dropped };
+}
+function applyBudget(items, spec) {
+  const prec0Items = [];
+  const restItems = [];
+  for (const item of items) {
+    if (item.precedence === 0) {
+      prec0Items.push(item);
+    } else {
+      restItems.push(item);
+    }
+  }
+  const sourceCaps = spec.sourceCaps ?? {};
+  const sourceMap = /* @__PURE__ */ new Map();
+  for (const item of restItems) {
+    const list = sourceMap.get(item.source);
+    if (list)
+      list.push(item);
+    else
+      sourceMap.set(item.source, [item]);
+  }
+  const keptAfterSourceCap = [];
+  const droppedAfterSourceCap = [];
+  for (const [source, sourceItems] of sourceMap) {
+    const cap = sourceCaps[source];
+    if (cap === void 0) {
+      keptAfterSourceCap.push(...sourceItems);
+    } else {
+      const sorted = sortByEvictionOrder(sourceItems);
+      const { kept, dropped } = keepUnderCap(sorted, cap);
+      keptAfterSourceCap.push(...kept);
+      droppedAfterSourceCap.push(...dropped);
+    }
+  }
+  const allEligible = keptAfterSourceCap;
+  const sortedGlobal = sortByEvictionOrder(allEligible);
+  const { kept: keptGlobal, dropped: droppedGlobal } = keepUnderCap(sortedGlobal, spec.totalBytes - totalSize(prec0Items));
+  const finalKept = [...prec0Items, ...keptGlobal];
+  const finalDropped = [...droppedAfterSourceCap, ...droppedGlobal];
+  const trimmed = finalDropped.length > 0;
+  const keptSize = totalSize(finalKept);
+  const overflowBy = Math.max(0, keptSize - spec.totalBytes);
+  const handles = [];
+  for (const item of finalDropped) {
+    if (item.handle && item.handle.trim() !== "") {
+      handles.push(item.handle);
+    }
+  }
+  return { kept: finalKept, dropped: finalDropped, handles, trimmed, overflowBy };
+}
+function totalSize(items) {
+  return items.reduce((sum, i) => sum + i.size, 0);
+}
+
 // ../../packages/schemas/dist/index.js
 var mrrlinTaskStatusSchema = external_exports.enum([
   "todo",
@@ -36981,6 +36952,7 @@ var mrrlinTaskEventSchema = external_exports.object({
 });
 var mrrlinWikiPageSchema = external_exports.object({
   contentHash: external_exports.string().default(""),
+  createdAt: external_exports.string().datetime().nullable().default(null),
   folder: external_exports.string().min(1),
   id: mrrlinWikiPageIdSchema,
   markdownBody: external_exports.string().min(1),
@@ -36988,7 +36960,8 @@ var mrrlinWikiPageSchema = external_exports.object({
   preview: external_exports.string(),
   specReady: external_exports.boolean().default(false),
   taskId: mrrlinTaskIdSchema.nullable().default(null),
-  title: external_exports.string().min(1)
+  title: external_exports.string().min(1),
+  updatedAt: external_exports.string().datetime().nullable().default(null)
 });
 var mrrlinMarkSpecReadyRequestSchema = external_exports.object({
   ready: external_exports.boolean()
@@ -37112,14 +37085,12 @@ var mrrlinProjectSnapshotSchema = external_exports.object({
   taxonomy: external_exports.array(mrrlinTaxonomyEntrySchema).default([]),
   wikiPages: external_exports.array(mrrlinWikiPageSchema).default([])
 });
-var mrrlinTaskCreateSchema = external_exports.object({
+var mrrlinTaskCreateShapeSchema = external_exports.object({
   // Auto-deploy design Part B: input-optional (NOT .default("off")) so createTask can tell
   // "caller omitted this" apart from "caller explicitly chose off" -- omitted falls through to
   // the project's default_auto_deploy; the tasks column itself still defaults to 'off' at the
   // SQL level for any direct-insert path that bypasses createTask entirely.
   autoDeploy: mrrlinAutoDeploySchema.optional(),
-  // Input-optional so existing createTask call sites need no churn; createTask fills 'code' for the
-  // INSERT (the pg column is NOT NULL, so a concrete value is required, not undefined→NULL).
   domain: mrrlinTaskDomainSchema.optional(),
   autonomyLevel: mrrlinAutonomyLevelSchema.default("human_review"),
   autonomyReason: external_exports.string().min(1).max(240).default("Needs human review before automation."),
@@ -37141,6 +37112,17 @@ var mrrlinTaskCreateSchema = external_exports.object({
   type: mrrlinTaskTypeSchema.default("task"),
   verificationDueAt: external_exports.string().datetime().nullable().optional()
 });
+function refineTaskCreateDomain(data, ctx) {
+  if (data.domain === void 0 && data.parentTaskId == null) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["domain"],
+      message: "domain is required unless parentTaskId is set (a follow-up inherits its parent's domain)"
+    });
+  }
+}
+var mrrlinTaskCreateSchema = mrrlinTaskCreateShapeSchema.superRefine(refineTaskCreateDomain);
+var mrrlinTaskCreateWithoutIdSchema = mrrlinTaskCreateShapeSchema.omit({ id: true }).superRefine(refineTaskCreateDomain);
 var mrrlinTaskUpdateSchema = external_exports.object({
   actor: external_exports.string().min(1).optional(),
   assignee: mrrlinTaskAssigneeSchema.optional(),
@@ -37258,13 +37240,19 @@ var mrrlinWikiPageSearchQuerySchema = external_exports.object({
   q: external_exports.string().min(2)
 });
 var mrrlinWikiPageSearchResultSchema = external_exports.object({
+  ageDays: external_exports.number().nullable(),
   folder: external_exports.string().min(1),
   id: mrrlinWikiPageIdSchema,
+  // Task-relative; always null from a generic (non-task-scoped) search — resolved only where
+  // a caller has task context (director-loop retrieve()), never at this layer or in the API (D14).
+  memoryClass: external_exports.enum(["normative", "historical"]),
   path: external_exports.string().min(1),
+  precedence: external_exports.union([external_exports.literal(0), external_exports.literal(1), external_exports.literal(2), external_exports.literal(3)]).nullable(),
   preview: external_exports.string(),
   rank: external_exports.number(),
   snippet: external_exports.string(),
-  title: external_exports.string().min(1)
+  title: external_exports.string().min(1),
+  updatedAt: external_exports.string().datetime().nullable()
 });
 var wikiKnowledgeChunkSchema = external_exports.object({
   chunk_text: external_exports.string().min(1),
@@ -37482,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),
@@ -37514,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"
 });
@@ -38090,6 +38137,321 @@ var inboxItemsMarkReadResponseSchema = external_exports.object({
 var inboxItemResponseSchema = external_exports.object({ data: mrrlinInboxItemSchema });
 var inboxItemListResponseSchema = external_exports.object({ data: external_exports.array(mrrlinInboxItemSchema) });
 
+// ../../packages/codex-client/dist/render-context-bundle.js
+var DEFAULT_SPEC_BUDGET_CHARS = 6e3;
+var DEFAULT_ARTIFACT_PAYLOAD_BUDGET_CHARS = 400;
+function renderContextBundle(input) {
+  const sections = [];
+  sections.push(renderTaskSummary(input.task));
+  sections.push(renderSpec(input.specMarkdown, input.compact));
+  const { keptRuns, keptArtifacts, keptAutonomy, anyHistoricalDropped, droppedHandles } = applyHistoricalBudgetIfNeeded(input);
+  sections.push(renderRunHistory(keptRuns, input.openRunId, input.compact, anyHistoricalDropped));
+  sections.push(renderOpenRun(input.openRunId));
+  sections.push(renderArtifacts(keptArtifacts, input.omittedArtifactCount ?? 0, input.compact, anyHistoricalDropped, droppedHandles));
+  sections.push(renderAutonomyEvents(keptAutonomy, input.compact, anyHistoricalDropped));
+  return sections.join("\n\n");
+}
+function renderTaskSummary(task) {
+  const lines2 = [
+    "## Task (normative)",
+    `id: ${task.id}`,
+    `title: ${task.title}`,
+    `autonomy: ${task.autonomyLevel} (${task.autonomyReason})`
+  ];
+  if (task.notes)
+    lines2.push(`description: ${task.notes}`);
+  if (task.latestJudgement) {
+    lines2.push(`latest judgement (${task.latestJudgementKind ?? "unknown"}): ${task.latestJudgement}`);
+  }
+  return lines2.join("\n");
+}
+function renderSpec(specMarkdown, compact) {
+  if (!specMarkdown)
+    return "## Spec (normative)\n(none)";
+  if (!compact)
+    return `## Spec (normative)
+${specMarkdown}`;
+  const budget = compact.specBudgetChars ?? DEFAULT_SPEC_BUDGET_CHARS;
+  if (specMarkdown.length <= budget)
+    return `## Spec (normative)
+${specMarkdown}`;
+  return `## Spec (normative)
+${compactSpecMarkdown(specMarkdown, budget, compact.projectSlug ?? null, compact.specWikiPageId ?? null)}`;
+}
+function compactSpecMarkdown(markdown, totalBudget, projectSlug, specWikiPageId) {
+  const lines2 = markdown.split(/\r?\n/);
+  const sections = [{ heading: "", body: [] }];
+  for (const line of lines2) {
+    if (/^#{1,6}\s/.test(line)) {
+      sections.push({ heading: line, body: [] });
+    } else {
+      sections[sections.length - 1]?.body.push(line);
+    }
+  }
+  const sectionCount = Math.max(1, sections.length);
+  const perSectionBudget = Math.max(120, Math.floor(totalBudget / sectionCount));
+  const out = [];
+  for (const section of sections) {
+    const bodyText = section.body.join("\n").replace(/^\s+|\s+$/g, "");
+    if (section.heading)
+      out.push(section.heading);
+    if (!bodyText)
+      continue;
+    if (bodyText.length <= perSectionBudget) {
+      out.push(bodyText);
+    } else {
+      const kept = bodyText.slice(0, perSectionBudget);
+      const omitted = bodyText.length - perSectionBudget;
+      out.push(`${kept}
+\u2026(${omitted} chars omitted; retrieve full spec for the rest)`);
+    }
+  }
+  if (projectSlug && specWikiPageId) {
+    out.push("");
+    out.push(`> Compact spec. Source: mrrlin://wiki/${projectSlug}/${specWikiPageId} \u2014 call retrieve_context with this handle before any irreversible decision.`);
+  } else {
+    out.push("");
+    out.push("> Compact spec. Retrieve the Specs/{id} wiki page via get_wiki_page before any irreversible decision.");
+  }
+  return out.join("\n");
+}
+function renderRunHistory(runs, openRunId, compact, anyHistoricalDropped) {
+  if (runs.length === 0)
+    return "## Execution-run history (historical)\n(none)";
+  const lines2 = ["## Execution-run history (historical)"];
+  for (const run3 of runs) {
+    const marker = run3.id === openRunId ? " (open)" : "";
+    lines2.push(`- ${run3.id} [${run3.status}] created ${run3.createdAt}${marker}`);
+  }
+  if (compact && anyHistoricalDropped) {
+    lines2.push("> Compact execution-run history. Use retrieve_context with a `mrrlin://run/{projectSlug}/{runId}/artifacts` handle (substitute the slug and run id from the lines above) to load a run's full artifact history.");
+  }
+  return lines2.join("\n");
+}
+function renderOpenRun(openRunId) {
+  return `## Open run (normative)
+${openRunId ?? "(none)"}`;
+}
+function renderArtifacts(artifacts, omittedCount, compact, anyHistoricalDropped, droppedHandles) {
+  if (artifacts.length === 0 && omittedCount === 0)
+    return "## Artifacts (historical)\n(none)";
+  const lines2 = ["## Artifacts (historical)"];
+  if (omittedCount > 0) {
+    lines2.push(`(+${omittedCount} older artifact${omittedCount === 1 ? "" : "s"} omitted)`);
+  }
+  let truncatedAny = false;
+  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;
+      }
+    }
+    const payloadText = JSON.stringify(artifact.payload);
+    const budget = compact?.artifactPayloadBudgetChars ?? DEFAULT_ARTIFACT_PAYLOAD_BUDGET_CHARS;
+    const willTruncate = !!compact && payloadText.length > budget;
+    const rendered = willTruncate ? `${payloadText.slice(0, budget)}\u2026(${payloadText.length - budget} chars omitted)` : payloadText;
+    if (willTruncate)
+      truncatedAny = true;
+    lines2.push(`- ${artifact.createdAt} [${artifact.kind}] run=${artifact.runId} ${rendered}`);
+  }
+  if (compact && (omittedCount > 0 || truncatedAny || anyHistoricalDropped)) {
+    lines2.push("> Compact artifacts. Use retrieve_context with a `mrrlin://run/{projectSlug}/{runId}/artifacts` handle (substitute the slug and run id from the lines above) to load a run's full artifact history.");
+  }
+  if (compact && droppedHandles.length > 0) {
+    lines2.push(`> Dropped by budget, retrievable via: ${droppedHandles.map((h) => `\`${h}\``).join(", ")}`);
+  }
+  return lines2.join("\n");
+}
+function renderAutonomyEvents(events, compact, anyHistoricalDropped) {
+  if (events.length === 0)
+    return "## Autonomy history (historical)\n(none)";
+  const lines2 = ["## Autonomy history (historical)"];
+  for (const event of events) {
+    lines2.push(`- ${event.createdAt} ${event.autonomyLevel ?? "?"} (${event.autonomyReason ?? ""})`);
+  }
+  if (compact && anyHistoricalDropped) {
+    lines2.push("> Compact autonomy history. Use retrieve_context with a `mrrlin://run/{projectSlug}/{runId}/artifacts` handle (substitute the slug and run id from the lines above) to load a run's full artifact history.");
+  }
+  return lines2.join("\n");
+}
+function applyHistoricalBudgetIfNeeded(input) {
+  if (!input.compact?.budget) {
+    return {
+      keptRuns: input.runs,
+      keptArtifacts: input.artifacts,
+      keptAutonomy: input.autonomyEvents,
+      anyHistoricalDropped: false,
+      droppedHandles: []
+    };
+  }
+  const candidates = [];
+  for (const run3 of input.runs) {
+    const line = `- ${run3.id} [${run3.status}] created ${run3.createdAt}`;
+    candidates.push({
+      kind: "run",
+      runId: run3.id,
+      size: line.length,
+      memoryClass: "historical",
+      precedence: 3,
+      handle: input.compact.projectSlug ? `mrrlin://run/${input.compact.projectSlug}/${run3.id}/artifacts` : null,
+      source: "run_history"
+    });
+  }
+  for (const artifact of input.artifacts) {
+    const line = `- ${artifact.createdAt} [${artifact.kind}] run=${artifact.runId} ${JSON.stringify(artifact.payload)}`;
+    candidates.push({
+      kind: "artifact",
+      artifactId: artifact.id,
+      size: line.length,
+      memoryClass: "historical",
+      precedence: 3,
+      handle: input.compact.projectSlug ? `mrrlin://run/${input.compact.projectSlug}/${artifact.runId}/artifacts` : null,
+      source: "artifacts"
+    });
+  }
+  for (const event of input.autonomyEvents) {
+    const line = `- ${event.createdAt} ${event.autonomyLevel ?? "?"} (${event.autonomyReason ?? ""})`;
+    candidates.push({
+      kind: "autonomy",
+      autonomyEventId: event.id,
+      size: line.length,
+      memoryClass: "historical",
+      precedence: 3,
+      handle: null,
+      source: "autonomy"
+    });
+  }
+  const { kept, dropped } = applyBudget(candidates, input.compact.budget);
+  const keptRunIds = new Set(kept.filter((c) => c.kind === "run").map((c) => c.runId));
+  const keptArtifactIds = new Set(kept.filter((c) => c.kind === "artifact").map((c) => c.artifactId));
+  const keptAutonomyIds = new Set(kept.filter((c) => c.kind === "autonomy").map((c) => c.autonomyEventId));
+  const droppedHandles = [];
+  for (const item of dropped) {
+    if (item.handle)
+      droppedHandles.push(item.handle);
+  }
+  return {
+    keptRuns: input.runs.filter((r) => keptRunIds.has(r.id)),
+    keptArtifacts: input.artifacts.filter((a) => keptArtifactIds.has(a.id)),
+    keptAutonomy: input.autonomyEvents.filter((e) => keptAutonomyIds.has(e.id)),
+    anyHistoricalDropped: dropped.length > 0,
+    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 {
   code;
@@ -38813,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),
@@ -39016,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;
@@ -39032,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);
@@ -39071,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
@@ -39457,7 +39965,7 @@ function startCodexProbe(deps = {}) {
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.59";
+var PKG_VERSION = "0.3.62";
 
 // src/api-base-url-migrate.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
@@ -39957,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);
@@ -40273,13 +40781,26 @@ var HEADS_BY_DOMAIN = {
   content: ["plan-reviewer", "scope-analyst", "content-editor", "compliance-reviewer"]
 };
 var SPEC_HEADS = HEADS_BY_DOMAIN.code;
+var CODE_HEADS_BY_IMPACT = {
+  high: HEADS_BY_DOMAIN.code,
+  medium: ["plan-reviewer", "security-analyst", "scope-analyst"],
+  low: ["plan-reviewer", "scope-analyst"]
+};
 function normalizeDomain(value) {
   if (typeof value !== "string") return DEFAULT_DOMAIN;
   const v = value.trim().toLowerCase();
   return DOMAINS.includes(v) ? v : DEFAULT_DOMAIN;
 }
-function resolveHeads(domain2) {
-  return [...HEADS_BY_DOMAIN[normalizeDomain(domain2)]];
+function normalizeImpact(value) {
+  if (typeof value !== "string") return null;
+  const v = value.trim().toLowerCase();
+  return v === "low" || v === "medium" || v === "high" ? v : null;
+}
+function resolveHeads(domain2, impact) {
+  const d = normalizeDomain(domain2);
+  if (d !== "code") return [...HEADS_BY_DOMAIN[d]];
+  const i = normalizeImpact(impact) ?? "high";
+  return [...CODE_HEADS_BY_IMPACT[i]];
 }
 var PERSONAS_BY_DOMAIN = {
   seo: "seo-writer",
@@ -40726,7 +41247,7 @@ function loadPersona(name) {
   personaCache.set(name, content);
   return content;
 }
-function specHeadIntentBlock(taskId, title, seed) {
+function specHeadIntentBlock(taskId, title, seed, impact, adjudicated) {
   const identity = taskId ? `--- TASK IDENTITY (the spec MUST be about THIS task; if its scope or direction contradicts this identity, raise a \`scope\` issue instead of steering the spec elsewhere) ---
 TASK ${taskId}: ${title ?? ""}
 
@@ -40735,7 +41256,15 @@ TASK ${taskId}: ${title ?? ""}
 ${seed}
 
 ` : "";
-  return `${identity}${intent}`;
+  const impactLine = impact ? `--- IMPACT: ${impact} ---
+
+` : "";
+  const adjudicatedBlock = adjudicated && adjudicated.length > 0 ? `--- ADJUDICATED \u2014 the operator already decided these; do not re-raise without new information ---
+${adjudicated.map((q) => `- Q: ${q.body}
+  ${q.status === "rejected" ? "(rejected" + (q.answer ? `: ${q.answer}` : "") + ")" : `A: ${q.answer ?? "(acknowledged, no answer recorded)"}`}`).join("\n")}
+
+` : "";
+  return `${identity}${intent}${impactLine}${adjudicatedBlock}`;
 }
 function reviserIdentityInstructions(taskId, title) {
   const lock = taskId ? `This spec gates task ${taskId}${title ? ` ("${title}")` : ""}. You MUST NOT change the spec's task identity or heading, retarget it to a different task id, or invert its direction (e.g. live-submission vs preparation-only). Preserve the leading \`task: ${taskId}\` frontmatter EXACTLY; never change it to another task id. Address ONLY the accepted issues.
@@ -40774,7 +41303,21 @@ function buildSpecGateDeps(args) {
             resolvedSeed = "(No operator statement on record for this task. Derived from the task's own notes \u2014 the following acceptance criteria were extracted verbatim:)\n\n" + parsed.items.map((c) => `- ${c}`).join("\n");
           }
         }
-        return { taskId, seed: resolvedSeed, title: task.title ?? "", domain: task.domain, notes };
+        const taskInboxItems = await client.listInboxItems(projectSlug, { taskId });
+        const adjudicated = taskInboxItems.filter((item) => item.origin === "gate" && (item.status === "acknowledged" || item.status === "rejected")).map((item) => ({
+          body: item.body,
+          answer: item.answer,
+          status: item.status
+        }));
+        return {
+          taskId,
+          seed: resolvedSeed,
+          title: task.title ?? "",
+          domain: task.domain,
+          notes,
+          impact: task.impact,
+          adjudicated
+        };
       })();
     }
     return intentPromise;
@@ -40799,8 +41342,8 @@ function buildSpecGateDeps(args) {
     },
     async runHead(personaName, artifact, dismissed) {
       const persona = loadPersona(personaName);
-      const { taskId, title, seed } = await loadIntent();
-      const intentBlock = specHeadIntentBlock(taskId, title, seed);
+      const { taskId, title, seed, impact, adjudicated } = await loadIntent();
+      const intentBlock = specHeadIntentBlock(taskId, title, seed, impact, adjudicated);
       return runCodexExec(
         {
           prompt: `Review this spec against the operator's intent.
@@ -40994,12 +41537,14 @@ async function buildDeliverableGateDeps(args) {
   const page = await client.getWikiPage(projectSlug, deliverablePageId);
   const taskId = page.taskId ?? null;
   let domain2 = "code";
+  let impact;
   let taskTitle = "";
   let specPageId = null;
   let criteria = [];
   if (taskId) {
     const task = await client.getTask(projectSlug, taskId);
     domain2 = normalizeDomain(task?.domain);
+    impact = task?.impact;
     taskTitle = task?.title ?? "";
     if (task?.specWikiPageId) {
       specPageId = task.specWikiPageId;
@@ -41007,7 +41552,7 @@ async function buildDeliverableGateDeps(args) {
       criteria = parseAcceptanceCriteria(specPage.markdownBody)?.items ?? [];
     }
   }
-  const heads = resolveHeads(domain2);
+  const heads = resolveHeads(domain2, impact);
   const maxHeadCalls = 2 * rounds * (heads.length + 1);
   const criteriaBlock = renderCriteriaBlock(criteria);
   return {
@@ -41250,6 +41795,17 @@ 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));
 }
@@ -41262,7 +41818,7 @@ function enforceSpecOutputContract(markdown, taskId, title) {
 ${body}`;
   }
   let tldrChars = 0;
-  const tldrMatch = body.match(/(^## Summary\s*\n)([\s\S]*?)(?=\n## |$)/im);
+  const tldrMatch = body.match(/(^## TL;DR\s*\n)([\s\S]*?)(?=\n## |$)/im);
   if (tldrMatch && tldrMatch.index !== void 0) {
     const heading = tldrMatch[1] ?? "";
     const section = (tldrMatch[2] ?? "").trim();
@@ -41286,6 +41842,7 @@ function nextWikiPageId(pages) {
   return `WK-${max + 1}`;
 }
 function buildDraftSpecPrompt(task, constitution) {
+  const budget = resolveSpecBudget(task.impact);
   const lines2 = [
     `Write a complete implementation spec for the task below.`,
     ``,
@@ -41307,11 +41864,19 @@ function buildDraftSpecPrompt(task, constitution) {
   }
   lines2.push(
     `--- OUTPUT CONTRACT (strict) ---`,
-    `Return ONLY the full spec markdown, no commentary. Required structure:`,
+    `Return ONLY the full spec markdown, no commentary. Required structure, in this order:`,
     `- First line heading: \`# ${task.id} \u2014 ${task.title}\``,
-    `- Sections: Problem, Scope, Non-goals, Acceptance criteria, Verification.`,
-    `- Final section \`## Summary\`: a plain-English TL;DR of what will be done and how it`,
-    `  will be verified, at most ${DRAFT_SPEC_TLDR_MAX_CHARS} characters.`
+    `- \`## TL;DR\``,
+    `- One or more \`### Requirement: <name>\` sections, each stating what the change SHALL do.`,
+    `  Each requirement has one or more \`#### Scenario: <name>\` sub-sections using WHEN/THEN`,
+    `  (optionally AND) to describe a concrete situation and its expected outcome.`,
+    `- \`## Acceptance criteria\`: a markdown checklist (\`- [ ] ...\`) of concrete, verifiable`,
+    `  conditions \u2014 this is the machine-usable yardstick the review scores against.`,
+    `- \`## Verification\`: the exact tests, commands, or manual checks that prove each`,
+    `  acceptance criterion holds.`,
+    ``,
+    `The \`## TL;DR\` section MUST be at most ${DRAFT_SPEC_TLDR_MAX_CHARS} characters.`,
+    `The spec MUST contain at most ${budget.maxRequirements} acceptance-criteria items and no more than ${budget.maxChars} characters total.`
   );
   return lines2.join("\n");
 }
@@ -41589,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";
+    }
   }
 }
 
@@ -41612,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;
@@ -41967,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") {
@@ -42282,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;
@@ -42313,6 +43103,13 @@ function readPositiveIntEnv(name, fallback) {
 function delayMs(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function executionBundleBudget() {
+  if ((process.env.MRRLIN_RETRIEVAL_BUDGET_DISABLE ?? "").trim() === "1") return void 0;
+  return {
+    totalBytes: readPositiveIntEnv("MRRLIN_RETRIEVAL_BUDGET_BUNDLE_CHARS", 15500),
+    roundTripCap: 0
+  };
+}
 function execTurnIdleTimeoutMs() {
   return readPositiveIntEnv("MRRLIN_DIRECTOR_BRIDGE_EXEC_TURN_IDLE_TIMEOUT_SECONDS", DEFAULT_EXEC_TURN_IDLE_TIMEOUT_SECONDS) * 1e3;
 }
@@ -42439,6 +43236,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 = [
@@ -42674,13 +43483,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) => {
@@ -42696,7 +43507,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) => {
@@ -42709,6 +43520,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
@@ -42734,7 +43547,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;
@@ -42769,7 +43583,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) {
@@ -42833,11 +43648,53 @@ async function driveRun(deps, projectSlug, runId) {
       ...context,
       compact: {
         projectSlug,
-        specWikiPageId: task.specWikiPageId ?? null
+        specWikiPageId: task.specWikiPageId ?? null,
+        budget: executionBundleBudget()
       }
     } : 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;
@@ -42913,7 +43770,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",
@@ -42929,9 +43786,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) {
@@ -42946,14 +43830,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();
@@ -42969,7 +43891,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);
@@ -42993,16 +43917,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);
@@ -43181,9 +44108,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.`,
@@ -43713,7 +44728,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
@@ -43788,7 +44804,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)));
   }
 }
 
@@ -44256,13 +45272,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;
@@ -44280,7 +45299,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;
@@ -44304,6 +45323,7 @@ function createInactivityWatchdog(opts) {
       if (idleTimer) clearT(idleTimer);
       lastPokeAt = now();
       suspendedAtLastPoke = suspended();
+      excludedAtLastPoke = excluded();
       armIdle(opts.idleMs);
     },
     cancel: () => {
@@ -44313,8 +45333,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);
@@ -44327,6 +45347,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");
@@ -48331,11 +49409,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, "");
@@ -49208,6 +50291,7 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "- Keep behavior contracts in the spec; implementation details belong in `## Implementation Plan`.",
     "- Apply this format ONLY to Specs/{id} pages; do not retro-fit it onto other wiki page types.",
     "- Spec consensus runs ASYNCHRONOUSLY. Call `run_spec_consensus` for a `Specs/{id}` page; it returns IMMEDIATELY. On `already_converged`, the spec is already marked ready \u2014 proceed straight to `create_execution_run`; do NOT call `mark_spec_ready` and do NOT re-run consensus. On `queued` or `already_running`, tell the user it was launched and END your turn \u2014 do NOT poll or call it again; the result arrives in the inbox (an `info` item on CONVERGED, a `handoff` item if it was blocked/failed). When a consensus `info` item says CONVERGED, proceed to `create_execution_run`. When a `handoff` says it was blocked, address the recorded issues in the spec (any edit re-arms the gate) and call `run_spec_consensus` once more. For a NON-code task (domain seo/marketing/content, ADR 0020): the low-risk lanes `seo`, `marketing`, and `content` proceed to `create_execution_run` after consensus converges, using the same flow as code tasks. Report the spec's review outcome to the operator.",
+    "- When creating a task, classify and supply the `domain` field explicitly based on the nature of the work: pass `domain:'code'` for software engineering work, `domain:'seo'` for SEO/optimization, `domain:'marketing'` for marketing/growth, or `domain:'content'` for content creation/writing \u2014 the same way you select category/subcategory. A follow-up task spawned with `parentTaskId` inherits its parent's domain automatically and requires no explicit domain.",
     '- When a task needs a browser (login flows, UI verification/clicks, scraping), pass `prerequisites:[{mcp:"mrrlin-browser",reason:"..."}]` to `create_execution_run`. If that run later fails into a handoff, the operator gets a one-click "Launch browser & resume" that brings up the dedicated browser as the turn starts.',
     "- When you actually drive a browser (calling `browser_navigate`, `browser_click`, `browser_snapshot`, `browser_type`, etc.), invoke those tools from the **`mrrlin-browser`** MCP server ONLY. Do NOT use tools from any other browser MCP (`playwright`, `chrome-devtools`, `puppeteer`, etc.) even if they are also connected on this operator's box \u2014 those use a shared/default Playwright profile that is fragile across runs. Only `mrrlin-browser` uses this project's dedicated Chromium + persistent operator profile (`~/.mrrlin/browser/profile`). If your host exposes multiple browser MCPs with overlapping tool names, prefer the `mrrlin-browser` server unconditionally.",
     "",
@@ -50434,7 +51518,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,
@@ -50463,7 +51547,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;
@@ -50491,6 +51577,7 @@ function createBridgeMessageHandler(deps) {
             idleMs,
             maxMs,
             ...deps.suspendedMs ? { suspendedMs: deps.suspendedMs } : {},
+            idleExcludedMs: () => toolBusy.ms(),
             onExpire: (reason) => {
               rejectWatchdog?.(
                 new Error(
@@ -50594,6 +51681,7 @@ ${effectiveText}` : effectiveText;
             }
             watchdog.cancel();
             unsub();
+            toolBusy.endAll();
             thread.cancel = null;
           }
         });
@@ -50713,8 +51801,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 {
@@ -50757,7 +51845,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();
@@ -50836,7 +51928,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,
@@ -50863,7 +51955,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
@@ -50902,7 +51994,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()
     },
@@ -50927,7 +52019,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,
@@ -50943,40 +52035,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)}
@@ -50989,7 +52075,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();
@@ -51052,7 +52146,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() }),
@@ -51198,7 +52292,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);
@@ -51210,34 +52304,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(),
@@ -51275,7 +52363,7 @@ async function startDirectorBridge() {
             payload: { removed: tombstonesRemoved }
           });
         }
-      });
+      }
       scheduleClaimLoop();
     }, claimIntervalMs());
     claimTimer.unref?.();
@@ -51313,7 +52401,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)}
 `
       )
     });
@@ -55164,6 +56252,44 @@ function mapAcceptedIssueToClarification(issue2) {
     category: issue2.category
   };
 }
+var CLARIFICATION_CAP_BY_IMPACT = { low: 2, medium: 3, high: 5 };
+function resolveClarificationCap(impact) {
+  const tier = impact?.trim().toLowerCase();
+  if (tier === "medium") return CLARIFICATION_CAP_BY_IMPACT.medium;
+  if (tier === "high") return CLARIFICATION_CAP_BY_IMPACT.high;
+  return CLARIFICATION_CAP_BY_IMPACT.low;
+}
+function headIndexOf(id) {
+  const match = /^r\d+-h(\d+)-\d+$/.exec(id);
+  return match?.[1] !== void 0 ? Number(match[1]) : null;
+}
+function orderClarificationIssues(issues) {
+  const distinctHeadsByKey = /* @__PURE__ */ new Map();
+  for (const issue2 of issues) {
+    const key = `${issue2.category} ${issue2.text}`;
+    const heads = distinctHeadsByKey.get(key) ?? /* @__PURE__ */ new Set();
+    const headIdx = headIndexOf(issue2.id);
+    if (headIdx !== null) heads.add(headIdx);
+    distinctHeadsByKey.set(key, heads);
+  }
+  const categoryRank = (category) => category === "scope" ? 0 : category === "ambiguity" ? 1 : 2;
+  return issues.map((issue2, index) => ({ issue: issue2, index })).sort((a, b) => {
+    const rankDiff = categoryRank(a.issue.category) - categoryRank(b.issue.category);
+    if (rankDiff !== 0) return rankDiff;
+    const headCountA = distinctHeadsByKey.get(`${a.issue.category} ${a.issue.text}`)?.size ?? 0;
+    const headCountB = distinctHeadsByKey.get(`${b.issue.category} ${b.issue.text}`)?.size ?? 0;
+    if (headCountA !== headCountB) return headCountB - headCountA;
+    return a.index - b.index;
+  }).map(({ issue: issue2 }) => issue2);
+}
+function applyClarificationCap(issues, impact) {
+  const ordered = orderClarificationIssues(issues);
+  const cap = resolveClarificationCap(impact);
+  return {
+    kept: ordered.slice(0, cap).map(mapAcceptedIssueToClarification),
+    dropped: ordered.slice(cap).map(mapAcceptedIssueToClarification)
+  };
+}
 async function runSpecGate(_target, deps, opts) {
   if (!await deps.consensusEnabled()) return { outcome: "SKIPPED" };
   const intent = await deps.readIntent();
@@ -55181,11 +56307,11 @@ async function runSpecGate(_target, deps, opts) {
       ]
     };
   }
-  const baseHeads = resolveHeads(intent.domain);
+  const baseHeads = resolveHeads(intent.domain, intent.impact);
   const extraHeads = opts?.extraHeads ?? [];
   const heads = [...baseHeads, ...extraHeads.filter((h) => !baseHeads.includes(h))];
   const spec = await deps.readSpec();
-  if (normalizeDomain(intent.domain) !== "code" && parseAcceptanceCriteria(spec.markdownBody) === null) {
+  if (parseAcceptanceCriteria(spec.markdownBody) === null) {
     return {
       outcome: "CONSENSUS_BLOCKED",
       operatorClarifications: [
@@ -55253,23 +56379,32 @@ async function runSpecGate(_target, deps, opts) {
       ]
     };
   }
+  let keptClarifications = [];
+  let droppedByCap = [];
+  if (result.outcome === "CONSENSUS_BLOCKED") {
+    const accepted = result.history.at(-1)?.accepted ?? [];
+    const materialIssues = accepted.filter((issue2) => issue2.category === "ambiguity" || issue2.category === "scope");
+    const capped = applyClarificationCap(materialIssues, intent.impact);
+    keptClarifications = capped.kept;
+    droppedByCap = capped.dropped;
+  }
   await deps.writeEvidence({
     specPageId: spec.pageId,
     outcome: result.outcome,
     rounds: result.rounds,
     history: result.history,
-    contentHash: currentHash
+    contentHash: currentHash,
+    ...droppedByCap.length > 0 ? { droppedByCap } : {}
   });
   if (result.outcome === "CONVERGED") {
     await deps.promoteSpecReady(currentHash);
     return { outcome: "CONVERGED" };
   }
   if (result.outcome === "CONSENSUS_BLOCKED") {
-    const accepted = result.history.at(-1)?.accepted ?? [];
-    const operatorClarifications = accepted.filter((issue2) => issue2.category === "ambiguity" || issue2.category === "scope").map((issue2) => mapAcceptedIssueToClarification(issue2));
     return {
       outcome: "CONSENSUS_BLOCKED",
-      ...operatorClarifications.length > 0 ? { operatorClarifications } : {},
+      ...keptClarifications.length > 0 ? { operatorClarifications: keptClarifications } : {},
+      ...droppedByCap.length > 0 ? { droppedByCap } : {},
       ...result.escalation ? { escalation: result.escalation } : {}
     };
   }
@@ -55550,7 +56685,7 @@ async function maybeRunShadow(input, deps, logger) {
   const productionVerdict = productionVerdictFromOutcome(input.outcome);
   if (productionVerdict === null) return false;
   try {
-    const heads = input.heads ?? [...resolveHeads(input.domain), ...input.extraHeads ?? []];
+    const heads = input.heads ?? [...resolveHeads(input.domain, input.impact), ...input.extraHeads ?? []];
     const personaInstructions = {};
     for (const name of heads) {
       try {
@@ -55592,7 +56727,7 @@ function multiLlmActive(env = process.env) {
 async function resolveActiveRunHead(input, deps) {
   if (!multiLlmActive(input.env ?? process.env)) return null;
   try {
-    const heads = input.heads ?? [...resolveHeads(input.domain), ...input.extraHeads ?? []];
+    const heads = input.heads ?? [...resolveHeads(input.domain, input.impact), ...input.extraHeads ?? []];
     if (heads.length === 0) return null;
     const personaInstructions = {};
     for (const name of heads) {
@@ -55622,6 +56757,35 @@ async function resolveActiveRunHead(input, deps) {
 
 // src/async-tools/consensus.ts
 var import_node_crypto9 = require("node:crypto");
+
+// src/consensus/question-similarity.ts
+var SUPPRESSION_SIMILARITY_THRESHOLD = 0.6;
+function tokenSet(text) {
+  const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").trim();
+  if (!normalized) return /* @__PURE__ */ new Set();
+  return new Set(normalized.split(/\s+/));
+}
+function jaccardSimilarity(a, b) {
+  const setA = tokenSet(a);
+  const setB = tokenSet(b);
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection2 = 0;
+  for (const token of setA) {
+    if (setB.has(token)) intersection2 += 1;
+  }
+  const union2 = setA.size + setB.size - intersection2;
+  return union2 === 0 ? 0 : intersection2 / union2;
+}
+function isCoveredByAdjudicated(rawQuestion, adjudicated) {
+  for (const item of adjudicated) {
+    if (jaccardSimilarity(rawQuestion, item.body) >= SUPPRESSION_SIMILARITY_THRESHOLD) {
+      return item;
+    }
+  }
+  return null;
+}
+
+// src/async-tools/consensus.ts
 function normalizeClarificationQuestion(question) {
   return question.replace(/\s+/g, " ").trim().replace(/[?.!]+$/, "").trim();
 }
@@ -55752,35 +56916,43 @@ async function cachedResult(client, input) {
   }
   return null;
 }
+function stripHumanizeOpener(body) {
+  for (const prefix of Object.values(HUMANIZE_TEMPLATE_BY_KIND)) {
+    if (body.startsWith(prefix)) return body.slice(prefix.length).trim();
+  }
+  return body;
+}
 async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
   const operatorClarifications = result.operatorClarifications ?? [];
   const diagnostics = result.diagnostics ?? [];
-  if (operatorClarifications.length > 0) {
+  const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+  const taskId = page?.taskId ?? null;
+  if (!resolvedTaskId && taskId) resolvedTaskId = taskId;
+  const adjudicated = [];
+  if (taskId) {
     try {
-      const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
-      if (page) {
-        const domain2 = await resolveSpecDomain(ctx.client, input.projectSlug, {
-          id: page.id,
-          taskId: page.taskId ?? null
-        });
-        await ctx.client.recordSpecConsensusReview(input.projectSlug, input.pageId, {
-          contentHash: domainScopedReviewHash(page.contentHash, domain2),
-          outcome: "CONSENSUS_BLOCKED_CLARIFICATION",
-          rounds: 0
-        });
+      const taskInboxItems = await ctx.client.listInboxItems(input.projectSlug, { taskId });
+      for (const item of taskInboxItems) {
+        if (item.origin === "gate" && (item.status === "acknowledged" || item.status === "rejected")) {
+          adjudicated.push({ body: stripHumanizeOpener(item.body), answer: item.answer, status: item.status });
+        }
       }
     } catch (error52) {
       process.stderr.write(
-        `[mrrlin-mcp consensus] clarification verdict write failed for ${input.projectSlug}/${input.pageId}: ${error52 instanceof Error ? error52.message : String(error52)}
+        `[mrrlin-mcp consensus] adjudicated-questions read failed for ${input.projectSlug}/${input.pageId}: ${error52 instanceof Error ? error52.message : String(error52)}
 `
       );
     }
   }
+  const suppressedAsAdjudicated = [];
+  const toFile = operatorClarifications.filter((clarification) => {
+    const covering = isCoveredByAdjudicated(clarification.rawQuestion, adjudicated);
+    if (!covering) return true;
+    suppressedAsAdjudicated.push({ rawQuestion: clarification.rawQuestion, coveredByAnswer: covering.answer });
+    return false;
+  });
   let filedQuestionCount = 0;
-  if (operatorClarifications.length > 0) {
-    const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
-    const taskId = page?.taskId ?? null;
-    if (!resolvedTaskId && taskId) resolvedTaskId = taskId;
+  if (toFile.length > 0) {
     let planId = null;
     if (!taskId) {
       const plans = await ctx.client.listPlans(input.projectSlug);
@@ -55788,8 +56960,8 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
     }
     if (taskId) {
       const scopeId = taskId;
-      const groupId = operatorClarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(operatorClarifications.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
-      for (const clarification of operatorClarifications) {
+      const groupId = toFile.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(toFile.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+      for (const clarification of toFile) {
         const id = `II-${scopeId}-gate-${(0, import_node_crypto9.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
         try {
           const questionOptions = buildGateQuestionOptions(clarification.rawQuestion, clarification.category);
@@ -55805,11 +56977,11 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
         } catch {
         }
       }
-      filedQuestionCount = operatorClarifications.length;
+      filedQuestionCount = toFile.length;
     } else if (planId) {
       const scopeId = planId;
-      const groupId = operatorClarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(operatorClarifications.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
-      for (const clarification of operatorClarifications) {
+      const groupId = toFile.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(toFile.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+      for (const clarification of toFile) {
         const id = `II-${scopeId}-gate-${(0, import_node_crypto9.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
         try {
           const questionOptions = buildGateQuestionOptions(clarification.rawQuestion, clarification.category);
@@ -55825,7 +56997,32 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
         } catch {
         }
       }
-      filedQuestionCount = operatorClarifications.length;
+      filedQuestionCount = toFile.length;
+    }
+  }
+  if (operatorClarifications.length > 0) {
+    try {
+      if (page) {
+        const domain2 = await resolveSpecDomain(ctx.client, input.projectSlug, {
+          id: page.id,
+          taskId: page.taskId ?? null
+        });
+        const suppressionEvidence = (result.droppedByCap?.length ?? 0) > 0 || suppressedAsAdjudicated.length > 0 ? {
+          ...result.droppedByCap?.length ? { droppedByCap: result.droppedByCap } : {},
+          ...suppressedAsAdjudicated.length ? { suppressedAsAdjudicated } : {}
+        } : void 0;
+        await ctx.client.recordSpecConsensusReview(input.projectSlug, input.pageId, {
+          contentHash: domainScopedReviewHash(page.contentHash, domain2),
+          outcome: "CONSENSUS_BLOCKED_CLARIFICATION",
+          rounds: 0,
+          ...suppressionEvidence ? { suppressionEvidence } : {}
+        });
+      }
+    } catch (error52) {
+      process.stderr.write(
+        `[mrrlin-mcp consensus] clarification verdict write failed for ${input.projectSlug}/${input.pageId}: ${error52 instanceof Error ? error52.message : String(error52)}
+`
+      );
     }
   }
   let error51;
@@ -55833,6 +57030,8 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
     error51 = `Consensus blocked on ${filedQuestionCount} clarification(s); filed as operator question(s).`;
   } else if (diagnostics.length > 0 && operatorClarifications.length === 0) {
     error51 = "Consensus blocked: the spec content does not match its linked task. This requires fixing the spec/task relationship directly, not an inbox answer.";
+  } else if (operatorClarifications.length > 0 && toFile.length === 0 && suppressedAsAdjudicated.length > 0) {
+    error51 = `Consensus blocked, but all ${suppressedAsAdjudicated.length} clarification(s) were reworded repeats of already-adjudicated questions \u2014 nothing new filed.`;
   } else if (operatorClarifications.length > 0) {
     error51 = `Consensus blocked on ${operatorClarifications.length} clarification(s), but the spec page is not linked to a task or plan, so none could be filed as questions.`;
   } else {
@@ -56138,30 +57337,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"
-  };
-}
-
 // 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]$/;
@@ -56236,7 +57417,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`;
 }
@@ -56252,7 +57433,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,
@@ -56263,8 +57444,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) => ({
@@ -56285,9 +57466,10 @@ 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,
     taskId: p.taskId,
     specReady: p.specReady,
     firstHeading: firstHeadingLine(p.markdownBody),
@@ -56311,11 +57493,15 @@ 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,
-    snippet: truncate(r.snippet, EXCERPT_TRUNCATE_CHARS),
+    updatedAt: r.updatedAt,
+    ageDays: r.ageDays,
+    memoryClass: r.memoryClass,
+    precedence: r.precedence,
+    snippet: truncate2(r.snippet, EXCERPT_TRUNCATE_CHARS),
     handle: formatWikiHandle(projectSlug, r.id)
   }));
   const handles = slice.map((r) => ({
@@ -56344,7 +57530,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,
@@ -56416,7 +57602,7 @@ function compactArtifactPayload(artifact) {
         cwd,
         exitCode,
         firstError,
-        tail: truncate(tail2, ARTIFACT_PAYLOAD_BUDGET),
+        tail: truncate2(tail2, ARTIFACT_PAYLOAD_BUDGET),
         totalLines: lines2.length
       };
     }
@@ -56424,7 +57610,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
       };
     }
@@ -56442,7 +57628,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) };
     }
   }
 }
@@ -56481,7 +57667,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 = [
     {
@@ -56503,7 +57689,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.`,
@@ -56534,7 +57720,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 }
   };
@@ -56704,6 +57890,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({
@@ -56816,6 +58003,7 @@ var mcpToolInputSchemas = {
   [mcpToolNames.restartExecutionRun]: restartExecutionRunInputSchema,
   [mcpToolNames.resolveHandoff]: resolveHandoffInputSchema,
   [mcpToolNames.recordProducedUrl]: recordProducedUrlInputSchema,
+  [mcpToolNames.updateTaskState]: updateTaskStateInputSchema,
   [mcpToolNames.registerLocalCheckout]: registerLocalCheckoutInputSchema,
   [mcpToolNames.retrieveContext]: retrieveContextInputSchema
 };
@@ -56867,6 +58055,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,
@@ -56897,7 +58086,7 @@ var mcpToolDescriptions = {
   [mcpToolNames.appendTaskEvent]: "Append an operator note to a task's activity timeline.",
   [mcpToolNames.createWikiPage]: "Create a markdown Wiki page.",
   [mcpToolNames.deleteTaskDependency]: "Delete a blocked-by relationship.",
-  [mcpToolNames.createTask]: "Create a new task in a project. Always starts as status='todo' with a blank assignee. Pass parentTaskId when spawning a follow-up task to continue work from an existing task \u2014 its operator_seed_request is inherited automatically if you don't supply your own.",
+  [mcpToolNames.createTask]: "Create a new task in a project. Always starts as status='todo' with a blank assignee. Pass parentTaskId when spawning a follow-up task to continue work from an existing task \u2014 its operator_seed_request is inherited automatically if you don't supply your own. Domain is required UNLESS parentTaskId is supplied (a follow-up inherits its parent's domain automatically). Domain selects which reviewer roster judges the task's spec. Valid values: code, seo, marketing, content.",
   [mcpToolNames.getProject]: "Fetch a single project summary by slug.",
   [mcpToolNames.getProjectSnapshot]: "Fetch the full project snapshot: GitHub binding, tasks, plans, and wiki pages.",
   [mcpToolNames.getTask]: "Fetch a single task by project slug and task id.",
@@ -56927,6 +58116,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.",
@@ -57524,6 +58714,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,
@@ -58185,11 +59382,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)