@mrrlin-dev/mcp 0.3.64 → 0.3.68

package/dist/bin.cjs

@@ -20658,14 +20658,17 @@ var toml = __toESM(require_toml(), 1);
 
 // src/api-base-url.ts
 var DEFAULT_API_BASE_URL = "http://127.0.0.1:8787";
-var STAGING_API_BASE_URL = "https://mrrlin-api-mrrlin3.vercel.app";
+var STAGING_API_BASE_URL = "https://api-staging.mrrlin.com";
 function normalizeUrl(value) {
   return value.replace(/\/$/, "");
 }
 var RETIRED_API_BASE_URLS = {
   // Retired 2026-07-28 when staging moved to the mrrlin2 Vercel team; serves a decommissioned
   // Supabase project and now answers `GET /health` with 402 DEPLOYMENT_DISABLED. Added in 0.3.50.
-  "mrrlin-api-fnnzzz-fnnzzzs-projects.vercel.app": STAGING_API_BASE_URL
+  "mrrlin-api-fnnzzz-fnnzzzs-projects.vercel.app": STAGING_API_BASE_URL,
+  // Retired 2026-08-14 when staging decoupled onto the stable custom domain api-staging.mrrlin.com.
+  // A persisted operator configuration may still pin the mrrlin3 Vercel alias; retarget it in one hop.
+  "mrrlin-api-mrrlin3.vercel.app": STAGING_API_BASE_URL
 };
 function isSameApiHost(a, b) {
   const origin = (value) => {
@@ -36387,6 +36390,9 @@ var openApiOperationIds = {
   getExecutionRun: "getExecutionRun",
   getProjectSchedulerPolicy: "getProjectSchedulerPolicy",
   getProjectDeployWorkflow: "getProjectDeployWorkflow",
+  getDeployTopology: "getDeployTopology",
+  writeDeployTopology: "writeDeployTopology",
+  getTaskDeployTarget: "getTaskDeployTarget",
   getSchedulerPendingTasks: "getSchedulerPendingTasks",
   wakeDirector: "wakeDirector",
   getGithubInstallationRepositories: "getGithubInstallationRepositories",
@@ -36742,6 +36748,16 @@ var mrrlinTaskEventAutonomyLevelSchema = external_exports.enum([
 ]);
 var mrrlinAutoDeploySchema = external_exports.enum(["off", "dev", "prod"]);
 var mrrlinTaskDomainSchema = external_exports.enum(["code", "seo", "marketing", "content"]);
+function normalizeTaskDomain(value) {
+  if (typeof value !== "string")
+    return "code";
+  const v = value.trim().toLowerCase();
+  return mrrlinTaskDomainSchema.options.includes(v) ? v : "code";
+}
+function domainScopedReviewHash(rawHash, domain2) {
+  const d = normalizeTaskDomain(domain2);
+  return d === "code" ? rawHash : `${rawHash}@${d}`;
+}
 var mrrlinSpecApprovedSchema = external_exports.enum(["pending", "approved", "skipped", "skipped_legacy"]);
 var mrrlinTaskSourceSchema = external_exports.enum(["fixture-import", "api"]);
 var mrrlinPlanStatusSchema = external_exports.enum(["active", "paused", "done", "archived"]);
@@ -37123,6 +37139,47 @@ function refineTaskCreateDomain(data, ctx) {
 }
 var mrrlinTaskCreateSchema = mrrlinTaskCreateShapeSchema.superRefine(refineTaskCreateDomain);
 var mrrlinTaskCreateWithoutIdSchema = mrrlinTaskCreateShapeSchema.omit({ id: true }).superRefine(refineTaskCreateDomain);
+var mrrlinDeployWorkflowEnvSchema = external_exports.enum(["dev", "prod"]);
+var mrrlinTaskDeployTargetInputSchema = external_exports.object({
+  env: mrrlinDeployWorkflowEnvSchema,
+  targetLabel: external_exports.string().min(1),
+  workflowId: external_exports.number().int().positive(),
+  workflowPath: external_exports.string().min(1),
+  workflowSha: external_exports.string().min(1),
+  topologyFingerprint: external_exports.string().min(1)
+});
+var deployTopologyResponseSchema = external_exports.object({
+  data: external_exports.object({
+    fingerprint: external_exports.string().nullable(),
+    snapshot: external_exports.array(external_exports.object({ id: external_exports.number(), path: external_exports.string(), sha: external_exports.string(), state: external_exports.string() })).nullable(),
+    entries: external_exports.array(external_exports.object({
+      label: external_exports.string(),
+      env: mrrlinDeployWorkflowEnvSchema,
+      workflowId: external_exports.number(),
+      workflowPath: external_exports.string(),
+      workflowSha: external_exports.string()
+    }))
+  })
+});
+var mrrlinDeployTopologyWriteSchema = external_exports.object({
+  fingerprint: external_exports.string().min(1),
+  entries: external_exports.array(external_exports.object({
+    label: external_exports.string().min(1),
+    env: mrrlinDeployWorkflowEnvSchema,
+    workflowId: external_exports.number().int().positive(),
+    workflowPath: external_exports.string().min(1),
+    workflowSha: external_exports.string().min(1)
+  }))
+});
+var taskDeployTargetResponseSchema = external_exports.object({
+  data: external_exports.object({
+    targetLabel: external_exports.string(),
+    workflowId: external_exports.number(),
+    workflowPath: external_exports.string(),
+    workflowSha: external_exports.string(),
+    topologyFingerprint: external_exports.string()
+  })
+});
 var mrrlinTaskUpdateSchema = external_exports.object({
   actor: external_exports.string().min(1).optional(),
   assignee: mrrlinTaskAssigneeSchema.optional(),
@@ -37145,8 +37202,13 @@ var mrrlinTaskUpdateSchema = external_exports.object({
   title: external_exports.string().min(1).optional(),
   type: mrrlinTaskTypeSchema.optional(),
   followUpAt: external_exports.string().datetime().nullable().optional(),
-  verificationDueAt: external_exports.string().datetime().nullable().optional()
-}).refine((value) => value.assignee !== void 0 || value.autoDeploy !== void 0 || value.domain !== void 0 || value.autonomyLevel !== void 0 || value.autonomyReason !== void 0 || value.category !== void 0 || value.directorThreadId !== void 0 || value.dueDate !== void 0 || value.followUpAt !== void 0 || value.impact !== void 0 || value.notes !== void 0 || value.planId !== void 0 || value.specApproved !== void 0 || value.specWikiPageId !== void 0 || value.status !== void 0 || value.subcategory !== void 0 || value.tags !== void 0 || value.title !== void 0 || value.type !== void 0 || value.verificationDueAt !== void 0, { message: "TaskUpdate requires at least one field" }).superRefine((value, context) => {
+  verificationDueAt: external_exports.string().datetime().nullable().optional(),
+  deployTargets: external_exports.array(mrrlinTaskDeployTargetInputSchema).optional(),
+  // design.md D5 step 6 hint (task 3.16): the deploy gate's own bookkeeping write when the
+  // fingerprint moved but the topology still maps the label to the same workflow. Never sent
+  // by any other caller.
+  reverifyRequested: external_exports.boolean().optional()
+}).refine((value) => value.assignee !== void 0 || value.autoDeploy !== void 0 || value.domain !== void 0 || value.autonomyLevel !== void 0 || value.autonomyReason !== void 0 || value.category !== void 0 || value.directorThreadId !== void 0 || value.dueDate !== void 0 || value.followUpAt !== void 0 || value.impact !== void 0 || value.notes !== void 0 || value.planId !== void 0 || value.specApproved !== void 0 || value.specWikiPageId !== void 0 || value.status !== void 0 || value.subcategory !== void 0 || value.tags !== void 0 || value.title !== void 0 || value.type !== void 0 || value.verificationDueAt !== void 0 || value.deployTargets !== void 0 || value.reverifyRequested !== void 0, { message: "TaskUpdate requires at least one field" }).superRefine((value, context) => {
   if (value.autonomyLevel !== void 0 && value.autonomyReason === void 0) {
     context.addIssue({
       code: external_exports.ZodIssueCode.custom,
@@ -37230,6 +37292,7 @@ var mrrlinWikiPageUpdateSchema = external_exports.object({
 }).refine((value) => Object.keys(value).length > 0, { message: "WikiPageUpdate requires at least one field" });
 var mrrlinWikiPageListFiltersSchema = external_exports.object({
   folder: external_exports.string().min(1).optional(),
+  id: mrrlinWikiPageIdSchema.optional(),
   q: external_exports.string().min(1).optional(),
   taskId: mrrlinTaskIdSchema.optional()
 });
@@ -37806,7 +37869,6 @@ var mrrlinProjectSchedulerPolicyUpsertSchema = external_exports.object({
 var projectSchedulerPolicyResponseSchema = external_exports.object({
   data: mrrlinProjectSchedulerPolicySchema
 });
-var mrrlinDeployWorkflowEnvSchema = external_exports.enum(["dev", "prod"]);
 var mrrlinDeployWorkflowSourceSchema = external_exports.enum(["agent", "operator"]);
 var mrrlinDeployWorkflowStateSchema = external_exports.enum(["resolved", "ambiguous"]);
 var mrrlinProjectDeployWorkflowSchema = external_exports.object({
@@ -39291,6 +39353,29 @@ function createMrrlinClient(config2) {
         throw error51;
       }
     },
+    async getDeployTopology(projectSlug) {
+      const body = await request(`${projectPath(projectSlug)}/deploy-topology`);
+      return deployTopologyResponseSchema.parse(body).data;
+    },
+    async writeDeployTopology(projectSlug, input) {
+      const body = await request(`${projectPath(projectSlug)}/deploy-topology`, {
+        body: JSON.stringify(mrrlinDeployTopologyWriteSchema.parse(input)),
+        headers: { "content-type": "application/json" },
+        method: "PUT"
+      });
+      return deployTopologyResponseSchema.parse(body).data;
+    },
+    async getTaskDeployTarget(projectSlug, taskId, env) {
+      try {
+        const body = await request(`${projectPath(projectSlug)}/tasks/${taskId}/deploy-target/${env}`);
+        return taskDeployTargetResponseSchema.parse(body).data;
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError && error51.status === 404 && error51.code === "DEPLOY_TARGET_UNSET") {
+          return null;
+        }
+        throw error51;
+      }
+    },
     async upsertProjectDeployWorkflow(projectSlug, env, input) {
       const body = await request(`${projectPath(projectSlug)}/deploy-workflows/${env}`, {
         body: JSON.stringify(input),
@@ -39965,7 +40050,7 @@ function startCodexProbe(deps = {}) {
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.64";
+var PKG_VERSION = "0.3.68";
 
 // src/api-base-url-migrate.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
@@ -40936,41 +41021,303 @@ function errMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/consensus/resolve-gated-task.ts
-async function resolveGatedTaskId(client, projectSlug, page) {
-  const tasks = await client.listTasks(projectSlug);
-  const linking = tasks.find((t) => t.specWikiPageId === page.id);
-  if (linking) {
-    if (page.taskId !== linking.id) {
-      throw new Error(
-        `spec page ${page.id} is linked by task ${linking.id} (tasks.spec_wiki_page_id) but its wiki_pages.task_id back-pointer is ${page.taskId === null ? "null" : page.taskId} \u2014 refusing to gate with a drifted identity`
-      );
+// src/consensus/verdict.ts
+var CATEGORIES = [
+  "correctness",
+  "security",
+  "scope",
+  "ambiguity",
+  "performance",
+  "ops"
+];
+var CAT_SET = new Set(CATEGORIES);
+function parseVerdict(raw) {
+  const verdictMatch = raw.match(/\*\*Verdict\*\*:\s*(APPROVE|REQUEST_CHANGES|REJECT)\b/i);
+  const parsedVerdict = verdictMatch?.[1]?.toUpperCase();
+  const verdict = parsedVerdict === "APPROVE" || parsedVerdict === "REQUEST_CHANGES" || parsedVerdict === "REJECT" ? parsedVerdict : "REQUEST_CHANGES";
+  const afterCritical = raw.split(/\*\*Critical issues\*\*/i)[1];
+  const block = afterCritical?.split(/\n\*\*/)[0] ?? "";
+  const issues = [];
+  const parseFallbacks = [];
+  for (const line of block.split(/\r?\n/)) {
+    const bulletMatch = line.match(/^\s*-\s+(.*\S)\s*$/);
+    if (!bulletMatch) continue;
+    const body = bulletMatch[1] ?? "";
+    if (/^\(?(empty list|none)\b/i.test(body)) continue;
+    if (!body) continue;
+    const catMatch = body.match(/`?\[(\w+)\]`?/);
+    const catToken = catMatch?.[1]?.toLowerCase() ?? "";
+    const isKnownCat = catToken !== "" && CAT_SET.has(catToken);
+    const category = isKnownCat ? catToken : "ambiguity";
+    if (!catMatch || !isKnownCat) {
+      parseFallbacks.push(body);
     }
-    return linking.id;
+    const text = body.replace(/`?\[\w+\]`?\s*/, "").trim();
+    issues.push({ category, text });
   }
-  return page.taskId;
+  return { verdict, issues, parseFallbacks };
+}
+function parseArbiterDecisions(raw) {
+  const decisions = [];
+  const afterDecisions = raw.split(/\*\*Decisions\*\*/i)[1];
+  const block = afterDecisions?.split(/\n\*\*Adjudicated/i)[0] ?? "";
+  for (const line of block.split(/\r?\n/)) {
+    const m = line.match(
+      /^\s*-\s+`?\[([^\]]+)\]`?\s+(accept|dismiss|defer)\b(?:\s*[—-]\s*(.*\S))?\s*$/i
+    );
+    if (!m) continue;
+    const id = m[1] ?? "";
+    const decision = (m[2] ?? "accept").toLowerCase();
+    const reason = (m[3] ?? "").trim();
+    decisions.push({ id, decision, reason });
+  }
+  return { decisions };
 }
 
-// src/consensus/review-identity.ts
-function domainScopedReviewHash(rawHash, domain2) {
-  const d = normalizeDomain(domain2);
-  return d === "code" ? rawHash : `${rawHash}@${d}`;
+// src/consensus/arbiter.ts
+function buildArbiterPrompt(issues) {
+  const list = issues.map((i) => `- [${i.id}] (${i.category}) ${i.text}`).join("\n");
+  return `Adjudicate each issue below.
+
+ISSUES:
+${list}`;
 }
-async function resolveSpecDomain(client, projectSlug, page) {
-  try {
-    const taskId = await resolveGatedTaskId(client, projectSlug, page);
-    if (taskId !== null) {
-      const task = await client.getTask(projectSlug, taskId);
-      return normalizeDomain(task?.domain);
+async function adjudicate(issues, deps) {
+  if (issues.length === 0) return { adjudicatedVerdict: "APPROVE", accepted: [], dismissed: [] };
+  const byId = new Map(issues.map((i) => [i.id, i]));
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await deps.runArbiter(buildArbiterPrompt(issues));
+    if (!res.ok) continue;
+    const { decisions } = parseArbiterDecisions(res.text);
+    const seen = new Set(decisions.map((d) => d.id));
+    const everyDecided = issues.every((i) => seen.has(i.id));
+    const missingReason = decisions.some((d) => d.decision !== "accept" && !d.reason);
+    if (!everyDecided || missingReason && attempt === 0) continue;
+    const accepted = [];
+    const dismissed = [];
+    for (const i of issues) {
+      const d = decisions.find((x) => x.id === i.id);
+      if (!d || d.decision !== "accept" && !d.reason) {
+        accepted.push(i);
+        continue;
+      }
+      if (d.decision === "accept") accepted.push(i);
+      else dismissed.push({ id: i.id, decision: d.decision, reason: d.reason });
     }
-    const plans = await client.listPlans(projectSlug);
-    const plan = plans.find((p) => p.specWikiPageId === page.id);
-    if (plan?.domain != null) return normalizeDomain(plan.domain);
-    const project = await client.getProject(projectSlug);
-    return normalizeDomain(project?.defaultDomain);
-  } catch {
-    return "code";
+    return { adjudicatedVerdict: accepted.length === 0 ? "APPROVE" : "REQUEST_CHANGES", accepted, dismissed };
   }
+  return { adjudicatedVerdict: "REQUEST_CHANGES", accepted: [...byId.values()], dismissed: [] };
+}
+
+// src/consensus/semaphore.ts
+function createBoundedSemaphore(slots) {
+  let available = slots;
+  const queue = [];
+  return {
+    acquire: () => available > 0 ? (available -= 1, Promise.resolve()) : new Promise((resolve) => queue.push(resolve)),
+    release: () => {
+      const next = queue.shift();
+      if (next) next();
+      else available += 1;
+    }
+  };
+}
+
+// src/consensus/escalation.ts
+function diagnoseStall(history, configuredRounds) {
+  const n = history.length;
+  const nonRespPerRound = history.map((h) => h.headOutcomes.filter((o) => !o.responded).length);
+  const infraRoundCount = nonRespPerRound.filter((c) => c >= 2).length;
+  const infraQualifies = infraRoundCount > n / 2;
+  if (infraQualifies) {
+    const roundIndices = [];
+    nonRespPerRound.forEach((c, i) => {
+      if (c >= 2) roundIndices.push(i + 1);
+    });
+    const evidence2 = `INFRA basis: \u22652 non\u2011responding heads in ${infraRoundCount} of ${n} rounds (rounds ${roundIndices.join(",")})`;
+    let grant = 3;
+    const headroom = 2 * configuredRounds - n;
+    grant = Math.max(1, Math.min(grant, headroom));
+    return { diagnosis: "INFRA", grantedRounds: grant, evidence: evidence2 };
+  }
+  if (n >= 2) {
+    const counts = history.map((h) => h.accepted.length);
+    const last = counts[n - 1];
+    const secondLast = counts[n - 2];
+    const lastFall = last < secondLast;
+    if (lastFall) {
+      let falls = 1;
+      if (n >= 3 && secondLast < counts[n - 3]) {
+        falls++;
+      }
+      let grant = 2 + falls;
+      if (grant > 5) grant = 5;
+      const headroom = 2 * configuredRounds - n;
+      grant = Math.max(1, Math.min(grant, headroom));
+      const seqDesc = counts.map((c, i) => `round${i + 1}:${c}`).join(" \u2192 ");
+      const evidence2 = `SUBSTANCE basis: accepted count fell (${seqDesc})`;
+      return { diagnosis: "SUBSTANCE", grantedRounds: grant, evidence: evidence2 };
+    }
+  }
+  const evidence = n === 0 ? "empty history" : `no infra or substance basis found in ${n} rounds`;
+  return { diagnosis: "AMBIGUITY", grantedRounds: 0, evidence };
+}
+
+// src/consensus/loop.ts
+async function runConsensus(input) {
+  const sem = createBoundedSemaphore(input.concurrency ?? input.heads.length);
+  const history = [];
+  let artifact = input.artifact;
+  let calls = 0;
+  const dismissedFwd = [];
+  let effectiveRounds = input.rounds;
+  let escalated = false;
+  let decision;
+  for (let round = 1; round <= effectiveRounds; round++) {
+    if (calls + input.heads.length > input.maxHeadCalls) {
+      return { outcome: "CONSENSUS_BLOCKED", rounds: round - 1, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
+    }
+    const dismissedBlock = dismissedFwd.length ? `PREVIOUSLY DISMISSED (do not re-raise unless new information):
+${dismissedFwd.slice(-20).join("\n")}` : "";
+    const results = await Promise.all(
+      input.heads.map(async (persona, idx) => {
+        await sem.acquire();
+        try {
+          calls++;
+          const res = await input.runHead(persona, artifact, dismissedBlock);
+          return { idx, res };
+        } catch (e) {
+          return { idx, res: { ok: false, error: String(e) } };
+        } finally {
+          sem.release();
+        }
+      })
+    );
+    const responding = results.filter(
+      (r) => r.res.ok
+    );
+    if (responding.length === 0) {
+      return { outcome: "CONSENSUS_UNAVAILABLE", rounds: round, finalArtifact: artifact, history };
+    }
+    const headOutcomes = input.heads.map((persona) => ({
+      persona,
+      responded: false
+    }));
+    const issues = [];
+    for (const { idx, res } of responding) {
+      const parsed = parseVerdict(res.text);
+      parsed.issues.forEach((iss, n) => issues.push({ ...iss, id: `r${round}-h${idx}-${n}` }));
+      const outcome = headOutcomes[idx];
+      if (outcome) {
+        outcome.responded = true;
+        outcome.verdict = parsed.verdict;
+      }
+      if (parsed.verdict !== "APPROVE" && parsed.issues.length === 0 && parsed.parseFallbacks.length === 0) {
+        issues.push({
+          category: "ambiguity",
+          text: `head ${input.heads[idx] ?? idx}/${idx} returned ${parsed.verdict} but no parseable critical issues (possible malformed/blocked review)`,
+          id: `r${round}-h${idx}-0`
+        });
+      }
+    }
+    let adj;
+    if (issues.length > 0) {
+      if (calls + 1 > input.maxHeadCalls) {
+        return { outcome: "CONSENSUS_BLOCKED", rounds: round, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
+      }
+      calls++;
+      try {
+        adj = await adjudicate(issues, { runArbiter: input.runArbiter });
+      } catch {
+        adj = { adjudicatedVerdict: "REQUEST_CHANGES", accepted: issues, dismissed: [] };
+      }
+    } else {
+      adj = { adjudicatedVerdict: "APPROVE", accepted: [], dismissed: [] };
+    }
+    history.push({ round, accepted: adj.accepted, dismissed: adj.dismissed, headOutcomes });
+    adj.dismissed.forEach((d) => dismissedFwd.push(`- ${d.id}: ${d.reason}`));
+    if (adj.accepted.length === 0) {
+      return { outcome: "CONVERGED", rounds: round, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
+    }
+    if (round === effectiveRounds) {
+      if (!decision) {
+        decision = diagnoseStall(history, input.rounds);
+      }
+      if (decision.grantedRounds > 0 && !escalated) {
+        escalated = true;
+        effectiveRounds = Math.min(effectiveRounds + decision.grantedRounds, input.rounds * 2);
+      } else {
+        return { outcome: "CONSENSUS_BLOCKED", rounds: round, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
+      }
+    }
+    artifact = await input.revise(artifact, adj.accepted);
+  }
+  return { outcome: "CONSENSUS_BLOCKED", rounds: effectiveRounds, finalArtifact: artifact, history };
+}
+
+// src/consensus/spec-identity.ts
+function validateSpecIdentity(markdown, taskId) {
+  const target = taskId.toUpperCase();
+  const fieldToken = frontmatterTaskToken(markdown);
+  if (fieldToken !== null && fieldToken.toUpperCase() !== target) return false;
+  const headingToken = firstHeadingToken(markdown);
+  if (headingToken !== null && headingToken.toUpperCase() !== target) return false;
+  return true;
+}
+var TASK_ID_TOKEN = /\b[A-Za-z]{1,12}-\d{1,10}\b/;
+var ATX_HEADING = /^ {0,3}#{1,6}\s+(.*)$/;
+var FRONTMATTER_TASK = /^task(?:_id)?:\s*(.+)$/i;
+function frontmatterTaskToken(markdown) {
+  const lines2 = markdown.split("\n");
+  const firstContent = lines2.findIndex((l) => l.trim() !== "");
+  if (firstContent === -1 || lines2[firstContent]?.trim() !== "---") return null;
+  for (let i = firstContent + 1; i < lines2.length; i++) {
+    const trimmed = (lines2[i] ?? "").trim();
+    if (trimmed === "---") break;
+    const m = FRONTMATTER_TASK.exec(trimmed);
+    if (m) return firstTaskIdToken(m[1] ?? "");
+  }
+  return null;
+}
+function firstHeadingToken(markdown) {
+  const heading = firstHeading(markdown);
+  return heading === null ? null : firstTaskIdToken(heading);
+}
+function firstHeading(markdown) {
+  const lines2 = markdown.split("\n");
+  let i = 0;
+  const firstContent = lines2.findIndex((l) => l.trim() !== "");
+  if (firstContent !== -1 && lines2[firstContent]?.trim() === "---") {
+    i = firstContent + 1;
+    while (i < lines2.length && lines2[i]?.trim() !== "---") i++;
+    i++;
+  }
+  let inFence = false;
+  let inComment = false;
+  for (; i < lines2.length; i++) {
+    const line = lines2[i] ?? "";
+    const trimmed = line.trim();
+    if (inComment) {
+      if (trimmed.includes("-->")) inComment = false;
+      continue;
+    }
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (trimmed.startsWith("<!--")) {
+      if (!trimmed.includes("-->")) inComment = true;
+      continue;
+    }
+    const m = ATX_HEADING.exec(line);
+    if (m) return m[1] ?? "";
+  }
+  return null;
+}
+function firstTaskIdToken(text) {
+  const m = TASK_ID_TOKEN.exec(text);
+  return m ? m[0] : null;
 }
 
 // src/consensus/acceptance-criteria.ts
@@ -41003,6 +41350,249 @@ function parseAcceptanceCriteria(markdown) {
   return items.length > 0 ? { items } : null;
 }
 
+// src/consensus/spec-gate.ts
+var SEED_ABSENCE_QUESTION = "What are the requirements for this task? There is no operator request on record, so the spec cannot be validated against your intent \u2014 please state what this task must do.";
+var SEED_ABSENCE_MARKER = "There is no operator request on record";
+function mapAcceptedIssueToClarification(issue2) {
+  const text = issue2.text.toLowerCase();
+  let kind;
+  if (issue2.category === "scope") {
+    const directionCues = ["only", "or also", "narrower", "broader", "include", "exclude", "versus", "vs"];
+    kind = directionCues.some((cue) => text.includes(cue)) ? "scope_direction" : "missing_requirement";
+  } else {
+    const acceptanceCues = ["acceptance", "done", "success", "criteria", "satisfy"];
+    kind = acceptanceCues.some((cue) => text.includes(cue)) ? "acceptance_criteria_detail" : "default_choice";
+  }
+  return {
+    kind,
+    diagnostic: false,
+    rawQuestion: issue2.text,
+    whyBlocking: `reviewer raised a ${issue2.category} issue`,
+    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();
+  if (intent.taskId !== null && (intent.seed === null || intent.seed.trim() === "")) {
+    return {
+      outcome: "CONSENSUS_BLOCKED",
+      operatorClarifications: [
+        {
+          kind: "missing_requirement",
+          diagnostic: false,
+          // Filed byte-for-byte from the shared constant so `loadIntent` can later recognise its
+          // answered form and lift the answer into the seed (GT-1005). Extracting the constant must
+          // not change the filed text; the wiring.test.ts marker-substring assertion locks that.
+          rawQuestion: SEED_ABSENCE_QUESTION,
+          whyBlocking: "operator_seed_request is empty",
+          category: "scope"
+        }
+      ]
+    };
+  }
+  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();
+  let currentHash = spec.contentHash;
+  let currentMarkdown = spec.markdownBody;
+  let conflicted = false;
+  if (parseAcceptanceCriteria(currentMarkdown) === null) {
+    const bootstrapIssue = {
+      id: "acceptance-criteria-bootstrap",
+      category: "scope",
+      text: "This spec has no `## Acceptance criteria` section. Add one, written as a markdown checklist (`- [ ] \u2026` items), derived from this spec's OWN requirements and the operator's stated intent. Each item must be concretely verifiable \u2014 a check the finished deliverable either passes or fails. Change NOTHING ELSE about the spec."
+    };
+    const revised = await deps.runReviser(currentMarkdown, [bootstrapIssue]);
+    const bootstrapFailed = (why) => {
+      process.stderr.write(`[spec-gate] acceptance-criteria bootstrap failed for ${spec.pageId}: ${why}
+`);
+      return {
+        outcome: "CONSENSUS_BLOCKED",
+        diagnostics: [
+          {
+            kind: "acceptance_criteria_unauthorable",
+            diagnostic: true,
+            rawQuestion: "This spec has no machine-usable acceptance criteria and the reviser could not add them automatically. A human needs to write an `## Acceptance criteria` section as a markdown checklist (`- [ ] \u2026` items) describing exactly what the finished deliverable must satisfy \u2014 the review of the produced work is scored against it.",
+            whyBlocking: "spec is missing a parseable `## Acceptance criteria` checklist and self-authoring failed",
+            category: "scope"
+          }
+        ]
+      };
+    };
+    if (!revised.ok) return bootstrapFailed("reviser unavailable");
+    if (intent.taskId !== null && !validateSpecIdentity(revised.text, intent.taskId)) {
+      return bootstrapFailed(`revision heading does not identify ${intent.taskId}`);
+    }
+    if (parseAcceptanceCriteria(revised.text) === null) {
+      return bootstrapFailed("revised spec still has no parseable `## Acceptance criteria` checklist");
+    }
+    const cas = await deps.casUpdateSpec(revised.text, currentHash);
+    if (!cas.ok) {
+      await deps.writeEvidence({ specPageId: spec.pageId, outcome: "SPEC_CHANGED_DURING_REVIEW" });
+      return { outcome: "SPEC_CHANGED_DURING_REVIEW" };
+    }
+    currentHash = cas.contentHash;
+    currentMarkdown = revised.text;
+  }
+  const result = await runConsensus({
+    artifact: currentMarkdown,
+    heads,
+    rounds: deps.rounds,
+    maxHeadCalls: deps.maxHeadCalls,
+    runHead: deps.runHead,
+    runArbiter: deps.runArbiter,
+    revise: async (artifact, accepted) => {
+      const revised = await deps.runReviser(artifact, accepted);
+      if (!revised.ok) return artifact;
+      if (intent.taskId !== null && !validateSpecIdentity(revised.text, intent.taskId)) {
+        process.stderr.write(
+          `[spec-gate] discarding drifted revision for ${spec.pageId}: heading does not identify ${intent.taskId}
+`
+        );
+        return artifact;
+      }
+      const cas = await deps.casUpdateSpec(revised.text, currentHash);
+      if (!cas.ok) {
+        conflicted = true;
+        throw new Error("SPEC_CHANGED_DURING_REVIEW");
+      }
+      currentHash = cas.contentHash;
+      currentMarkdown = revised.text;
+      return revised.text;
+    }
+    // Only OUR conflict throw is swallowed (→ null). Anything else is a real
+    // error and must propagate so it is not silently masked as a conflict.
+  }).catch((e) => conflicted ? null : Promise.reject(e));
+  if (conflicted || result === null) {
+    await deps.writeEvidence({ specPageId: spec.pageId, outcome: "SPEC_CHANGED_DURING_REVIEW" });
+    return { outcome: "SPEC_CHANGED_DURING_REVIEW" };
+  }
+  if (result.outcome === "CONVERGED" && intent.taskId !== null && !validateSpecIdentity(currentMarkdown, intent.taskId)) {
+    process.stderr.write(
+      `[spec-gate] blocking promotion for ${spec.pageId}: converged spec heading does not identify ${intent.taskId}
+`
+    );
+    return {
+      outcome: "CONSENSUS_BLOCKED",
+      diagnostics: [
+        {
+          kind: "spec_identity_mismatch",
+          diagnostic: true,
+          rawQuestion: `SPEC_IDENTITY_MISMATCH: this spec page gates ${intent.taskId}, but its heading identifies a different task \u2014 rewrite the spec heading and content for ${intent.taskId}, or re-link the task.`,
+          whyBlocking: "converged spec content belongs to a different task than the one it gates",
+          category: "scope"
+        }
+      ]
+    };
+  }
+  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,
+    ...droppedByCap.length > 0 ? { droppedByCap } : {}
+  });
+  if (result.outcome === "CONVERGED") {
+    await deps.promoteSpecReady(currentHash);
+    return { outcome: "CONVERGED" };
+  }
+  if (result.outcome === "CONSENSUS_BLOCKED") {
+    return {
+      outcome: "CONSENSUS_BLOCKED",
+      ...keptClarifications.length > 0 ? { operatorClarifications: keptClarifications } : {},
+      ...droppedByCap.length > 0 ? { droppedByCap } : {},
+      ...result.escalation ? { escalation: result.escalation } : {}
+    };
+  }
+  return { outcome: result.outcome };
+}
+
+// src/consensus/resolve-gated-task.ts
+async function resolveGatedTaskId(client, projectSlug, page) {
+  const tasks = await client.listTasks(projectSlug);
+  const linking = tasks.find((t) => t.specWikiPageId === page.id);
+  if (linking) {
+    if (page.taskId !== linking.id) {
+      throw new Error(
+        `spec page ${page.id} is linked by task ${linking.id} (tasks.spec_wiki_page_id) but its wiki_pages.task_id back-pointer is ${page.taskId === null ? "null" : page.taskId} \u2014 refusing to gate with a drifted identity`
+      );
+    }
+    return linking.id;
+  }
+  return page.taskId;
+}
+
+// src/consensus/review-identity.ts
+function domainScopedReviewHash2(rawHash, domain2) {
+  return domainScopedReviewHash(rawHash, domain2);
+}
+async function resolveSpecDomain(client, projectSlug, page) {
+  try {
+    const taskId = await resolveGatedTaskId(client, projectSlug, page);
+    if (taskId !== null) {
+      const task = await client.getTask(projectSlug, taskId);
+      return normalizeDomain(task?.domain);
+    }
+    const plans = await client.listPlans(projectSlug);
+    const plan = plans.find((p) => p.specWikiPageId === page.id);
+    if (plan?.domain != null) return normalizeDomain(plan.domain);
+    const project = await client.getProject(projectSlug);
+    return normalizeDomain(project?.defaultDomain);
+  } catch {
+    return "code";
+  }
+}
+
 // src/consensus/code-gate-git.ts
 var import_node_child_process7 = require("node:child_process");
 var DIFF_MAX_BYTES = 2e5;
@@ -41295,16 +41885,25 @@ function buildSpecGateDeps(args) {
           throw new Error(`gated task ${projectSlug}/${taskId} not found for spec ${specPageId} \u2014 cannot gate`);
         }
         const notes = task.notes ?? null;
+        const taskInboxItems = await client.listInboxItems(projectSlug, { taskId });
         const rawSeed = task.operatorSeedRequest ?? null;
         let resolvedSeed = rawSeed;
         if (rawSeed === null || rawSeed.trim() === "") {
-          const parsed = notes ? parseAcceptanceCriteria(notes) : null;
-          if (parsed !== null && parsed.items.length > 0) {
-            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");
+          const answered = taskInboxItems.find(
+            (item) => item.origin === "gate" && item.status === "acknowledged" && item.answer !== null && item.answer.trim() !== "" && item.body.includes(SEED_ABSENCE_MARKER)
+          );
+          if (answered && answered.answer) {
+            resolvedSeed = "(No operator statement was recorded when this task was created. Derived from the operator's answer to the gate's requirements question:)\n\n" + answered.answer;
+          } else {
+            const parsed = notes ? parseAcceptanceCriteria(notes) : null;
+            if (parsed !== null && parsed.items.length > 0) {
+              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");
+            }
           }
         }
-        const taskInboxItems = await client.listInboxItems(projectSlug, { taskId });
-        const adjudicated = taskInboxItems.filter((item) => item.origin === "gate" && (item.status === "acknowledged" || item.status === "rejected")).map((item) => ({
+        const adjudicated = taskInboxItems.filter(
+          (item) => item.origin === "gate" && (item.status === "acknowledged" || item.status === "rejected") && item.decidedBy !== "gate"
+        ).map((item) => ({
           body: item.body,
           answer: item.answer,
           status: item.status
@@ -41436,7 +42035,7 @@ ${artifact}`,
       const { domain: domain2 } = await loadIntent();
       try {
         await client.recordSpecConsensusReview(projectSlug, specPageId, {
-          contentHash: domainScopedReviewHash(contentHash, domain2),
+          contentHash: domainScopedReviewHash2(contentHash, domain2),
           outcome: String(outcome),
           rounds: typeof rounds2 === "number" ? rounds2 : 0
         });
@@ -41648,7 +42247,7 @@ You revise a deliverable to address the accepted issues so it satisfies the acce
       const rounds2 = typeof r["rounds"] === "number" ? r["rounds"] : 0;
       try {
         await client.recordSpecConsensusReview(projectSlug, deliverablePageId, {
-          contentHash: domainScopedReviewHash(contentHash, domain2),
+          contentHash: domainScopedReviewHash2(contentHash, domain2),
           outcome,
           rounds: rounds2
         });
@@ -41831,6 +42430,111 @@ ${body}`;
   }
   return { markdown: body, tldrChars };
 }
+function extractDeployTarget(markdown) {
+  const section = /(## Deploy Target\s*\n)([\s\S]*?)(?=\n## |$)/i.exec(markdown);
+  if (!section || section.index === void 0) {
+    return { markdown, deployTarget: null };
+  }
+  const remaining = markdown.slice(0, section.index) + markdown.slice(section.index + section[0].length);
+  const fenced = /```(?:json)?\s*\n([\s\S]*?)```/m.exec(section[2] ?? "");
+  let deployTarget = null;
+  if (fenced) {
+    try {
+      const raw = JSON.parse(fenced[1] ?? "");
+      if (raw !== null && typeof raw === "object" && typeof raw.label === "string") {
+        const parsed = { label: raw.label };
+        if (Array.isArray(raw.derive)) {
+          const derive = raw.derive.filter(isDeployTopologyEntry);
+          if (derive.length === raw.derive.length) parsed.derive = derive;
+        }
+        deployTarget = parsed;
+      }
+    } catch {
+      deployTarget = null;
+    }
+  }
+  return { markdown: remaining, deployTarget };
+}
+function isDeployTopologyEntry(value) {
+  if (value === null || typeof value !== "object") return false;
+  const e = value;
+  return typeof e.label === "string" && e.label.length > 0 && (e.env === "dev" || e.env === "prod") && typeof e.workflowId === "number" && Number.isInteger(e.workflowId) && e.workflowId > 0 && typeof e.workflowPath === "string" && e.workflowPath.length > 0 && typeof e.workflowSha === "string" && e.workflowSha.length > 0;
+}
+function buildDeployTargetPromptSection(ctx) {
+  if (ctx.kind === "closed_menu") {
+    const labels = [...new Set(ctx.entries.map((entry) => entry.label))];
+    return [
+      ``,
+      `--- DEPLOY TARGET (required final section) ---`,
+      `This project's deploy topology is already resolved for its current workflow inventory. Pick the ONE label this task deploys under from this CLOSED menu \u2014 never invent a new label:`,
+      ...labels.map((label) => `- ${label}`),
+      ``,
+      `Append a final section \`## Deploy Target\` whose ONLY content is a single fenced json block of exactly this shape:`,
+      "```json",
+      `{"label": "<one of the menu labels above>"}`,
+      "```"
+    ].join("\n");
+  }
+  return [
+    ``,
+    `--- DEPLOY TARGET (required final section) ---`,
+    `This project's deploy topology is NOT yet resolved for its current workflow inventory. Below is the raw GitHub workflow list (workflowId / path / blob sha / state); every value used below must be copied VERBATIM from it \u2014 never invented:`,
+    ``,
+    JSON.stringify(ctx.snapshot, null, 2),
+    ``,
+    `First derive the FULL label map: identify every deploy target in the snapshot, give each a short kebab-case \`label\`, and classify each workflow into an \`env\` of exactly "dev" or "prod".`,
+    `Heuristic for dev vs prod (there is no fixed naming rule): prefer an explicit \`dev-\`/\`prod-\` filename prefix, then a \`/dev/\` or \`/prod/\` directory segment; if neither applies, group the workflows serving the same target and classify from the pair's context.`,
+    `Then pick the ONE \`label\` this task deploys under, from among the labels you just derived.`,
+    ``,
+    `Append a final section \`## Deploy Target\` whose ONLY content is a single fenced json block of exactly this shape:`,
+    "```json",
+    `{"label": "<label this task deploys under>", "derive": [{"label":"<target label>","env":"dev"|"prod","workflowId":N,"workflowPath":"<path>","workflowSha":"<blob sha>"}, ...]}`,
+    "```",
+    ``,
+    `\`derive\` is the FULL map of every deploy target you can identify in the snapshot (not just this task's pick), so later tasks reuse this derivation instead of re-deriving. \`env\` must be exactly "dev" or "prod". \`workflowId\`/\`workflowPath\`/\`workflowSha\` must be copied verbatim from the snapshot above.`
+  ].join("\n");
+}
+function resolveDeployTargetRows(canonical, deployTarget, autoDeploy, fingerprint) {
+  if (autoDeploy === "off") return {};
+  const filtered = canonical.filter((entry) => entry.label === deployTarget.label);
+  const requiredEnvs = autoDeploy === "prod" ? ["dev", "prod"] : ["dev"];
+  const missingEnvs = [];
+  const deployTargets = [];
+  for (const env of requiredEnvs) {
+    const match = filtered.find((entry) => entry.env === env);
+    if (!match) {
+      missingEnvs.push(env);
+      continue;
+    }
+    deployTargets.push({
+      env,
+      targetLabel: deployTarget.label,
+      workflowId: match.workflowId,
+      workflowPath: match.workflowPath,
+      workflowSha: match.workflowSha,
+      topologyFingerprint: fingerprint
+    });
+  }
+  if (missingEnvs.length > 0) return { skippedReason: "incomplete_label", missingEnvs };
+  return { deployTargets };
+}
+function findDuplicateLabelEnvPairs(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const key = `${entry.label}\0${entry.env}`;
+    if (seen.has(key)) duplicateKeys.add(key);
+    seen.add(key);
+  }
+  const pairs = [];
+  for (const key of duplicateKeys) {
+    const parts = key.split("\0");
+    const label = parts[0] ?? "";
+    const env = parts[1] === "prod" ? "prod" : "dev";
+    pairs.push({ label, env });
+  }
+  return pairs;
+}
 function nextWikiPageId(pages) {
   let max = 0;
   for (const page of pages) {
@@ -41841,7 +42545,7 @@ function nextWikiPageId(pages) {
   }
   return `WK-${max + 1}`;
 }
-function buildDraftSpecPrompt(task, constitution) {
+function buildDraftSpecPrompt(task, constitution, deployTarget = null) {
   const budget = resolveSpecBudget(task.impact);
   const lines2 = [
     `Write a complete implementation spec for the task below.`,
@@ -41878,6 +42582,7 @@ function buildDraftSpecPrompt(task, constitution) {
     `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.`
   );
+  if (deployTarget) lines2.push(buildDeployTargetPromptSection(deployTarget));
   return lines2.join("\n");
 }
 function skipped(reason, extra = {}) {
@@ -41926,6 +42631,22 @@ async function runDraftSpec(ctx, input, deps) {
     }
     if (getActiveBlockedByIds(task.blockedBy, blockers).length > 0) return skipped("blocked_by_active");
   }
+  const autoDeploy = task.autoDeploy ?? "off";
+  let topology = null;
+  let deploySkippedReason = null;
+  let deploySkippedDetail = null;
+  if (autoDeploy !== "off") {
+    try {
+      topology = await client.getDeployTopology(projectSlug);
+    } catch {
+      deploySkippedReason = "topology_unavailable";
+      topology = null;
+    }
+  }
+  if (topology && (topology.fingerprint === null || topology.entries.length === 0 && topology.snapshot === null)) {
+    deploySkippedReason = topology.fingerprint === null ? "no_bound_deploy_target" : "topology_snapshot_unavailable";
+    topology = null;
+  }
   let persona;
   try {
     persona = loadPersonaFn(DRAFT_SPEC_PERSONA);
@@ -41954,7 +42675,8 @@ async function runDraftSpec(ctx, input, deps) {
   } catch {
     constitution = null;
   }
-  const prompt = buildDraftSpecPrompt(task, constitution);
+  const deployPromptContext = autoDeploy !== "off" && topology ? topology.entries.length > 0 ? { kind: "closed_menu", entries: topology.entries } : { kind: "derive", snapshot: topology.snapshot ?? [] } : null;
+  const prompt = buildDraftSpecPrompt(task, constitution, deployPromptContext);
   const exec = await runExec({
     prompt,
     developerInstructions: persona,
@@ -41969,7 +42691,8 @@ async function runDraftSpec(ctx, input, deps) {
   if (exec.text.trim().length === 0) {
     return { kind: "retry", failureReason: "zero_output", error: "spec authoring produced empty output" };
   }
-  const { markdown, tldrChars } = enforceSpecOutputContract(exec.text, taskId, task.title);
+  const { markdown: specMarkdown, deployTarget: parsedDeployTarget } = extractDeployTarget(exec.text);
+  const { markdown, tldrChars } = enforceSpecOutputContract(specMarkdown, taskId, task.title);
   let pageId;
   if (adoptedId) {
     try {
@@ -42029,6 +42752,45 @@ async function runDraftSpec(ctx, input, deps) {
     }
     pageId = created;
   }
+  let deployTargets;
+  if (topology && parsedDeployTarget) {
+    const fingerprint = topology.fingerprint;
+    if (fingerprint === null) {
+      deploySkippedReason = deploySkippedReason ?? "no_bound_deploy_target";
+    } else if (topology.entries.length > 0) {
+      const resolved = resolveDeployTargetRows(topology.entries, parsedDeployTarget, autoDeploy, fingerprint);
+      deployTargets = resolved.deployTargets;
+      if (resolved.skippedReason) {
+        deploySkippedReason = resolved.skippedReason;
+        if (resolved.skippedReason === "incomplete_label") {
+          deploySkippedDetail = `label "${parsedDeployTarget.label}" has no entry for: ${(resolved.missingEnvs ?? []).join(", ")}`;
+        }
+      }
+    } else {
+      const derive = parsedDeployTarget.derive ?? [];
+      const duplicateLabelEnvPairs = findDuplicateLabelEnvPairs(derive);
+      if (derive.length === 0) {
+        deploySkippedReason = "no_derivation";
+      } else if (duplicateLabelEnvPairs.length > 0) {
+        deploySkippedReason = "ambiguous_derivation";
+        deploySkippedDetail = `duplicate label/env pair(s): ${duplicateLabelEnvPairs.map((pair) => `${pair.label}/${pair.env}`).join(", ")}`;
+      } else {
+        try {
+          const written = await client.writeDeployTopology(projectSlug, { fingerprint, entries: derive });
+          const resolved = resolveDeployTargetRows(written.entries, parsedDeployTarget, autoDeploy, fingerprint);
+          deployTargets = resolved.deployTargets;
+          if (resolved.skippedReason) {
+            deploySkippedReason = resolved.skippedReason;
+            if (resolved.skippedReason === "incomplete_label") {
+              deploySkippedDetail = `label "${parsedDeployTarget.label}" has no entry for: ${(resolved.missingEnvs ?? []).join(", ")}`;
+            }
+          }
+        } catch {
+          deploySkippedReason = "topology_write_failed";
+        }
+      }
+    }
+  }
   let fresh;
   try {
     fresh = await client.getTask(projectSlug, taskId);
@@ -42045,8 +42807,12 @@ async function runDraftSpec(ctx, input, deps) {
   if (fresh.specWikiPageId) {
     return skipped("lost_link_race", { pageId, linkedPageId: fresh.specWikiPageId });
   }
+  const linkPatch = { specWikiPageId: pageId };
+  if (deployTargets !== void 0 && deployTargets.length > 0) {
+    linkPatch.deployTargets = deployTargets;
+  }
   try {
-    await client.updateTask(projectSlug, taskId, { specWikiPageId: pageId });
+    await client.updateTask(projectSlug, taskId, linkPatch);
   } catch (error51) {
     return {
       kind: "retry",
@@ -42054,16 +42820,20 @@ async function runDraftSpec(ctx, input, deps) {
       error: `failed to link spec page ${pageId} to task ${taskId}: ${errMessage2(error51)}`
     };
   }
+  const drafted = {
+    outcome: "DRAFTED",
+    pageId,
+    adopted: adoptedId !== null,
+    constitution: constitution !== null ? "included" : "missing",
+    tldrChars,
+    relatedContext: "skipped_no_client_method"
+  };
+  if (deploySkippedReason !== null) drafted.deployTargetSkippedReason = deploySkippedReason;
+  if (deploySkippedDetail !== null) drafted.deployTargetSkippedDetail = deploySkippedDetail;
+  drafted.taskTitle = task.title;
   return {
     kind: "done",
-    resultJson: JSON.stringify({
-      outcome: "DRAFTED",
-      pageId,
-      adopted: adoptedId !== null,
-      constitution: constitution !== null ? "included" : "missing",
-      tldrChars,
-      relatedContext: "skipped_no_client_method"
-    }),
+    resultJson: JSON.stringify(drafted),
     finalReviewedHash: null
   };
 }
@@ -42077,12 +42847,23 @@ function onComplete(outcome, input) {
     if (parsed.outcome === "SKIPPED") {
       return {
         kind: "info",
+        taskId: input.taskId,
         body: `Spec draft for ${input.taskId} skipped (${parsed.reason ?? "unknown"}); nothing changed.`
       };
     }
+    if (parsed.deployTargetSkippedReason === "ambiguous_derivation" || parsed.deployTargetSkippedReason === "incomplete_label") {
+      return {
+        kind: "handoff",
+        taskId: input.taskId,
+        id: `II-deploy-target-${parsed.deployTargetSkippedReason}-${input.taskId}`,
+        body: `Spec for ${input.taskId} was drafted (page ${parsed.pageId ?? "?"} in Specs/), but its deploy target needs a human: ${parsed.deployTargetSkippedDetail ?? parsed.deployTargetSkippedReason}. The spec itself proceeds to the normal consensus review; the deploy target stays unresolved until this is fixed.`
+      };
+    }
+    const taskRef = parsed.taskTitle ? `${input.taskId} \u2014 ${parsed.taskTitle}` : input.taskId;
     return {
       kind: "info",
-      body: `Spec for ${input.taskId} was drafted automatically \u2014 page ${parsed.pageId ?? "?"} in Specs/. The next scheduler tick will run the consensus review.`
+      taskId: input.taskId,
+      body: `Spec drafted automatically for ${taskRef} \u2014 page ${parsed.pageId ?? "?"} in Specs/. The next scheduler tick will run the consensus review.`
     };
   }
   const summary = outcome.error;
@@ -42451,34 +43232,42 @@ async function tryProdAutoRevert(deps, projectSlug, run3, task) {
     return null;
   }
 }
-function computeActiveSetFingerprint(workflows) {
-  return workflows.map((workflow) => `${workflow.id}:${workflow.path}`).sort().join(",");
-}
-async function resolveWorkflowId(deps, projectSlug, run3, env) {
+async function resolveWorkflowId(deps, projectSlug, run3, task, env) {
   const pinned = env === "dev" ? run3.devWorkflowId : run3.prodWorkflowId;
-  if (pinned) return { workflowId: pinned, source: null, resolvedFromStore: false };
-  const row = await deps.client.getProjectDeployWorkflow(projectSlug, env);
-  if (!row || row.state !== "resolved" || row.workflowId === null) {
-    return { workflowId: null, source: null, resolvedFromStore: false };
-  }
-  if (row.source !== "operator") {
-    const liveWorkflows = await deps.client.listGithubWorkflows(projectSlug);
-    const activeWorkflows = liveWorkflows.filter((workflow) => workflow.state === "active");
-    const isLive = activeWorkflows.some((workflow) => String(workflow.id) === String(row.workflowId));
-    if (!isLive) return { workflowId: null, source: null, resolvedFromStore: false };
-    const liveFingerprint = computeActiveSetFingerprint(activeWorkflows);
-    if (!row.reverifyRequested && row.activeSetFingerprint !== null && liveFingerprint !== row.activeSetFingerprint) {
-      await deps.client.upsertProjectDeployWorkflow(projectSlug, env, {
-        workflowId: row.workflowId,
-        workflowPath: row.workflowPath,
-        reason: row.reason,
-        state: row.state,
-        activeSetFingerprint: row.activeSetFingerprint,
-        reverifyRequested: true
-      });
-    }
+  if (pinned) {
+    return { workflowId: pinned, workflowPath: null, blockReason: null, pinned: true, reverifyRequested: false };
+  }
+  const target = await deps.getTaskDeployTarget(projectSlug, task.id, env);
+  if (!target) {
+    return { workflowId: null, workflowPath: null, blockReason: "deploy_target_unset", pinned: false, reverifyRequested: false };
+  }
+  const snapshot = await deps.getRepoSnapshot(projectSlug);
+  const activeWorkflows = (snapshot?.lastSnapshot ?? []).filter((w) => w.state === "active");
+  const liveMatch = activeWorkflows.find((w) => w.id === target.workflowId);
+  if (!liveMatch || liveMatch.path !== target.workflowPath) {
+    return { workflowId: null, workflowPath: null, blockReason: "deploy_target_inactive", pinned: false, reverifyRequested: false };
+  }
+  if (liveMatch.sha !== target.workflowSha) {
+    return { workflowId: null, workflowPath: null, blockReason: "deploy_target_modified", pinned: false, reverifyRequested: false };
+  }
+  const currentFingerprint = snapshot?.lastFingerprint ?? null;
+  if (currentFingerprint !== null && currentFingerprint === target.topologyFingerprint) {
+    return { workflowId: target.workflowId, workflowPath: target.workflowPath, blockReason: null, pinned: false, reverifyRequested: false };
+  }
+  if (currentFingerprint === null) {
+    deps.recordDeployTargetTelemetry("deploy_target_cache_missing");
+    return { workflowId: null, workflowPath: null, blockReason: "deploy_target_cache_missing", pinned: false, reverifyRequested: false };
+  }
+  const entry = await deps.lookupTopologyEntry(projectSlug, currentFingerprint, target.targetLabel, env);
+  if (!entry) {
+    deps.recordDeployTargetTelemetry("deploy_target_cache_missing");
+    return { workflowId: null, workflowPath: null, blockReason: "deploy_target_cache_missing", pinned: false, reverifyRequested: false };
   }
-  return { workflowId: row.workflowId, source: row.source, resolvedFromStore: true };
+  if (entry.workflowId !== target.workflowId) {
+    deps.recordDeployTargetTelemetry("deploy_target_reassigned");
+    return { workflowId: null, workflowPath: null, blockReason: "deploy_target_reassigned", pinned: false, reverifyRequested: false };
+  }
+  return { workflowId: target.workflowId, workflowPath: target.workflowPath, blockReason: null, pinned: false, reverifyRequested: true };
 }
 async function runDeployGateTick(deps, projectSlug, run3, task) {
   const artifacts = await deps.client.listExecutionArtifacts(projectSlug, run3.id);
@@ -42500,7 +43289,10 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     return { kind: "done" };
   }
   const env = activeEnv;
-  const resolution = await resolveWorkflowId(deps, projectSlug, run3, env);
+  const resolution = await resolveWorkflowId(deps, projectSlug, run3, task, env);
+  if (resolution.reverifyRequested) {
+    await deps.setTaskReverifyRequested(projectSlug, task.id);
+  }
   const workflowId = resolution.workflowId;
   const attempt = latestByEnv(artifacts, "deploy_attempt", env, { realAttemptsOnly: true });
   if (!attempt) {
@@ -42527,9 +43319,13 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
       await deps.handoff(projectSlug, task, run3, "verification_steps_missing");
       return { kind: "handoff", reason: "verification_steps_missing" };
     }
+    if (resolution.blockReason) {
+      await deps.handoff(projectSlug, task, run3, `${resolution.blockReason}:${env}`);
+      return { kind: "handoff", reason: `${resolution.blockReason}:${env}` };
+    }
     if (!workflowId) {
-      await deps.handoff(projectSlug, task, run3, `workflow_id_missing:${env}`);
-      return { kind: "handoff", reason: `workflow_id_missing:${env}` };
+      await deps.handoff(projectSlug, task, run3, `deploy_target_unset:${env}`);
+      return { kind: "handoff", reason: `deploy_target_unset:${env}` };
     }
     if (!run3.branch) {
       await deps.handoff(projectSlug, task, run3, "run_branch_missing");
@@ -42547,19 +43343,13 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     try {
       await deps.client.dispatchTaskDeploy(projectSlug, task.id, { env, ref: run3.branch, workflowId: String(workflowId) });
     } catch (error51) {
-      if (resolution.source === "operator") {
-        await deps.handoff(
-          projectSlug,
-          task,
-          run3,
-          `deploy_workflow_operator_choice_stale:${env}:${String(error51).slice(0, 120)}`
-        );
-        return { kind: "handoff", reason: `deploy_workflow_operator_choice_stale:${env}` };
+      if (!resolution.pinned && !resolution.reverifyRequested) {
+        deps.recordDeployTargetTelemetry("deploy_dispatch_failed_fingerprint_unchanged");
       }
       await deps.handoff(projectSlug, task, run3, `workflow_dispatch_failed:${env}:${String(error51).slice(0, 120)}`);
       return { kind: "handoff", reason: `workflow_dispatch_failed:${env}` };
     }
-    if (resolution.resolvedFromStore) {
+    if (!resolution.pinned) {
       await deps.client.updateExecutionRun(projectSlug, run3.id, {
         [env === "dev" ? "devWorkflowId" : "prodWorkflowId"]: workflowId
       });
@@ -44651,7 +45441,35 @@ async function runBackstopSweep(deps, drive = (slug, id) => driveRun(deps, slug,
                 await deployGateHandoff(deps, projectSlug, t, r.id, reason, r.leaseId);
               },
               budgetSeconds: deps.deployGate.budgetSeconds ?? deployPollBudgetSeconds(),
-              now: () => /* @__PURE__ */ new Date()
+              now: () => /* @__PURE__ */ new Date(),
+              getTaskDeployTarget: async (projectSlug, taskId, env) => deps.client.getTaskDeployTarget(projectSlug, taskId, env),
+              getRepoSnapshot: async (projectSlug) => {
+                try {
+                  const topology = await deps.client.getDeployTopology(projectSlug);
+                  return { lastFingerprint: topology.fingerprint, lastSnapshot: topology.snapshot };
+                } catch {
+                  return null;
+                }
+              },
+              lookupTopologyEntry: async (projectSlug, fingerprint, label, env) => {
+                try {
+                  const topology = await deps.client.getDeployTopology(projectSlug);
+                  if (topology.fingerprint !== fingerprint) return null;
+                  const entry = topology.entries.find((e) => e.label === label && e.env === env);
+                  return entry ? { workflowId: entry.workflowId, workflowPath: entry.workflowPath, workflowSha: entry.workflowSha } : null;
+                } catch {
+                  return null;
+                }
+              },
+              setTaskReverifyRequested: async (projectSlug, taskId) => {
+                await deps.client.updateTask(projectSlug, taskId, { reverifyRequested: true }).catch(() => {
+                });
+              },
+              recordDeployTargetTelemetry: (counter) => {
+                console.log(
+                  JSON.stringify({ event: "deploy_target_telemetry", counter, projectSlug: slug, taskId: task.id })
+                );
+              }
             };
             await runDeployGateTick(gateDeps, slug, run3, task);
           } catch {
@@ -44831,240 +45649,6 @@ async function runAsyncBackstopSweep(deps, drive = (slug, jobId) => driveAsyncJo
   }
 }
 
-// src/consensus/verdict.ts
-var CATEGORIES = [
-  "correctness",
-  "security",
-  "scope",
-  "ambiguity",
-  "performance",
-  "ops"
-];
-var CAT_SET = new Set(CATEGORIES);
-function parseVerdict(raw) {
-  const verdictMatch = raw.match(/\*\*Verdict\*\*:\s*(APPROVE|REQUEST_CHANGES|REJECT)\b/i);
-  const parsedVerdict = verdictMatch?.[1]?.toUpperCase();
-  const verdict = parsedVerdict === "APPROVE" || parsedVerdict === "REQUEST_CHANGES" || parsedVerdict === "REJECT" ? parsedVerdict : "REQUEST_CHANGES";
-  const afterCritical = raw.split(/\*\*Critical issues\*\*/i)[1];
-  const block = afterCritical?.split(/\n\*\*/)[0] ?? "";
-  const issues = [];
-  const parseFallbacks = [];
-  for (const line of block.split(/\r?\n/)) {
-    const bulletMatch = line.match(/^\s*-\s+(.*\S)\s*$/);
-    if (!bulletMatch) continue;
-    const body = bulletMatch[1] ?? "";
-    if (/^\(?(empty list|none)\b/i.test(body)) continue;
-    if (!body) continue;
-    const catMatch = body.match(/`?\[(\w+)\]`?/);
-    const catToken = catMatch?.[1]?.toLowerCase() ?? "";
-    const isKnownCat = catToken !== "" && CAT_SET.has(catToken);
-    const category = isKnownCat ? catToken : "ambiguity";
-    if (!catMatch || !isKnownCat) {
-      parseFallbacks.push(body);
-    }
-    const text = body.replace(/`?\[\w+\]`?\s*/, "").trim();
-    issues.push({ category, text });
-  }
-  return { verdict, issues, parseFallbacks };
-}
-function parseArbiterDecisions(raw) {
-  const decisions = [];
-  const afterDecisions = raw.split(/\*\*Decisions\*\*/i)[1];
-  const block = afterDecisions?.split(/\n\*\*Adjudicated/i)[0] ?? "";
-  for (const line of block.split(/\r?\n/)) {
-    const m = line.match(
-      /^\s*-\s+`?\[([^\]]+)\]`?\s+(accept|dismiss|defer)\b(?:\s*[—-]\s*(.*\S))?\s*$/i
-    );
-    if (!m) continue;
-    const id = m[1] ?? "";
-    const decision = (m[2] ?? "accept").toLowerCase();
-    const reason = (m[3] ?? "").trim();
-    decisions.push({ id, decision, reason });
-  }
-  return { decisions };
-}
-
-// src/consensus/arbiter.ts
-function buildArbiterPrompt(issues) {
-  const list = issues.map((i) => `- [${i.id}] (${i.category}) ${i.text}`).join("\n");
-  return `Adjudicate each issue below.
-
-ISSUES:
-${list}`;
-}
-async function adjudicate(issues, deps) {
-  if (issues.length === 0) return { adjudicatedVerdict: "APPROVE", accepted: [], dismissed: [] };
-  const byId = new Map(issues.map((i) => [i.id, i]));
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const res = await deps.runArbiter(buildArbiterPrompt(issues));
-    if (!res.ok) continue;
-    const { decisions } = parseArbiterDecisions(res.text);
-    const seen = new Set(decisions.map((d) => d.id));
-    const everyDecided = issues.every((i) => seen.has(i.id));
-    const missingReason = decisions.some((d) => d.decision !== "accept" && !d.reason);
-    if (!everyDecided || missingReason && attempt === 0) continue;
-    const accepted = [];
-    const dismissed = [];
-    for (const i of issues) {
-      const d = decisions.find((x) => x.id === i.id);
-      if (!d || d.decision !== "accept" && !d.reason) {
-        accepted.push(i);
-        continue;
-      }
-      if (d.decision === "accept") accepted.push(i);
-      else dismissed.push({ id: i.id, decision: d.decision, reason: d.reason });
-    }
-    return { adjudicatedVerdict: accepted.length === 0 ? "APPROVE" : "REQUEST_CHANGES", accepted, dismissed };
-  }
-  return { adjudicatedVerdict: "REQUEST_CHANGES", accepted: [...byId.values()], dismissed: [] };
-}
-
-// src/consensus/semaphore.ts
-function createBoundedSemaphore(slots) {
-  let available = slots;
-  const queue = [];
-  return {
-    acquire: () => available > 0 ? (available -= 1, Promise.resolve()) : new Promise((resolve) => queue.push(resolve)),
-    release: () => {
-      const next = queue.shift();
-      if (next) next();
-      else available += 1;
-    }
-  };
-}
-
-// src/consensus/escalation.ts
-function diagnoseStall(history, configuredRounds) {
-  const n = history.length;
-  const nonRespPerRound = history.map((h) => h.headOutcomes.filter((o) => !o.responded).length);
-  const infraRoundCount = nonRespPerRound.filter((c) => c >= 2).length;
-  const infraQualifies = infraRoundCount > n / 2;
-  if (infraQualifies) {
-    const roundIndices = [];
-    nonRespPerRound.forEach((c, i) => {
-      if (c >= 2) roundIndices.push(i + 1);
-    });
-    const evidence2 = `INFRA basis: \u22652 non\u2011responding heads in ${infraRoundCount} of ${n} rounds (rounds ${roundIndices.join(",")})`;
-    let grant = 3;
-    const headroom = 2 * configuredRounds - n;
-    grant = Math.max(1, Math.min(grant, headroom));
-    return { diagnosis: "INFRA", grantedRounds: grant, evidence: evidence2 };
-  }
-  if (n >= 2) {
-    const counts = history.map((h) => h.accepted.length);
-    const last = counts[n - 1];
-    const secondLast = counts[n - 2];
-    const lastFall = last < secondLast;
-    if (lastFall) {
-      let falls = 1;
-      if (n >= 3 && secondLast < counts[n - 3]) {
-        falls++;
-      }
-      let grant = 2 + falls;
-      if (grant > 5) grant = 5;
-      const headroom = 2 * configuredRounds - n;
-      grant = Math.max(1, Math.min(grant, headroom));
-      const seqDesc = counts.map((c, i) => `round${i + 1}:${c}`).join(" \u2192 ");
-      const evidence2 = `SUBSTANCE basis: accepted count fell (${seqDesc})`;
-      return { diagnosis: "SUBSTANCE", grantedRounds: grant, evidence: evidence2 };
-    }
-  }
-  const evidence = n === 0 ? "empty history" : `no infra or substance basis found in ${n} rounds`;
-  return { diagnosis: "AMBIGUITY", grantedRounds: 0, evidence };
-}
-
-// src/consensus/loop.ts
-async function runConsensus(input) {
-  const sem = createBoundedSemaphore(input.concurrency ?? input.heads.length);
-  const history = [];
-  let artifact = input.artifact;
-  let calls = 0;
-  const dismissedFwd = [];
-  let effectiveRounds = input.rounds;
-  let escalated = false;
-  let decision;
-  for (let round = 1; round <= effectiveRounds; round++) {
-    if (calls + input.heads.length > input.maxHeadCalls) {
-      return { outcome: "CONSENSUS_BLOCKED", rounds: round - 1, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
-    }
-    const dismissedBlock = dismissedFwd.length ? `PREVIOUSLY DISMISSED (do not re-raise unless new information):
-${dismissedFwd.slice(-20).join("\n")}` : "";
-    const results = await Promise.all(
-      input.heads.map(async (persona, idx) => {
-        await sem.acquire();
-        try {
-          calls++;
-          const res = await input.runHead(persona, artifact, dismissedBlock);
-          return { idx, res };
-        } catch (e) {
-          return { idx, res: { ok: false, error: String(e) } };
-        } finally {
-          sem.release();
-        }
-      })
-    );
-    const responding = results.filter(
-      (r) => r.res.ok
-    );
-    if (responding.length === 0) {
-      return { outcome: "CONSENSUS_UNAVAILABLE", rounds: round, finalArtifact: artifact, history };
-    }
-    const headOutcomes = input.heads.map((persona) => ({
-      persona,
-      responded: false
-    }));
-    const issues = [];
-    for (const { idx, res } of responding) {
-      const parsed = parseVerdict(res.text);
-      parsed.issues.forEach((iss, n) => issues.push({ ...iss, id: `r${round}-h${idx}-${n}` }));
-      const outcome = headOutcomes[idx];
-      if (outcome) {
-        outcome.responded = true;
-        outcome.verdict = parsed.verdict;
-      }
-      if (parsed.verdict !== "APPROVE" && parsed.issues.length === 0 && parsed.parseFallbacks.length === 0) {
-        issues.push({
-          category: "ambiguity",
-          text: `head ${input.heads[idx] ?? idx}/${idx} returned ${parsed.verdict} but no parseable critical issues (possible malformed/blocked review)`,
-          id: `r${round}-h${idx}-0`
-        });
-      }
-    }
-    let adj;
-    if (issues.length > 0) {
-      if (calls + 1 > input.maxHeadCalls) {
-        return { outcome: "CONSENSUS_BLOCKED", rounds: round, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
-      }
-      calls++;
-      try {
-        adj = await adjudicate(issues, { runArbiter: input.runArbiter });
-      } catch {
-        adj = { adjudicatedVerdict: "REQUEST_CHANGES", accepted: issues, dismissed: [] };
-      }
-    } else {
-      adj = { adjudicatedVerdict: "APPROVE", accepted: [], dismissed: [] };
-    }
-    history.push({ round, accepted: adj.accepted, dismissed: adj.dismissed, headOutcomes });
-    adj.dismissed.forEach((d) => dismissedFwd.push(`- ${d.id}: ${d.reason}`));
-    if (adj.accepted.length === 0) {
-      return { outcome: "CONVERGED", rounds: round, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
-    }
-    if (round === effectiveRounds) {
-      if (!decision) {
-        decision = diagnoseStall(history, input.rounds);
-      }
-      if (decision.grantedRounds > 0 && !escalated) {
-        escalated = true;
-        effectiveRounds = Math.min(effectiveRounds + decision.grantedRounds, input.rounds * 2);
-      } else {
-        return { outcome: "CONSENSUS_BLOCKED", rounds: round, finalArtifact: artifact, history, ...decision ? { escalation: decision } : {} };
-      }
-    }
-    artifact = await input.revise(artifact, adj.accepted);
-  }
-  return { outcome: "CONSENSUS_BLOCKED", rounds: effectiveRounds, finalArtifact: artifact, history };
-}
-
 // src/consensus/deliverable-gate.ts
 async function runDeliverableGate(_target, deps) {
   if (!await deps.consensusEnabled()) return { outcome: "SKIPPED" };
@@ -50071,12 +50655,13 @@ var DEFAULT_DIRECTOR_BRIDGE_ALLOWED_ORIGINS = [
   "http://localhost:*",
   "http://127.0.0.1:*",
   "http://[::1]:*",
-  // Staging Vercel team migrated 2026-07-28 (see docs/reference/deployments.md). The prior
-  // fnnzzz-fnnzzzs-projects web alias was dropped once no operator was left on an old build.
-  // mrrlin2 hit usage limits and was replaced by mrrlin3 on 2026-08-11; the mrrlin2 web alias
-  // was dropped the same day since no operator was left on that build either.
-  "https://mrrlin-web-mrrlin3.vercel.app",
-  "https://app.mrrlin.dev",
+  // Staging decoupled onto the stable custom domain staging.mrrlin.com on 2026-08-14 (Cloudflare DNS
+  // in front of the mrrlin3 Vercel project). The Vercel-owned web alias (mrrlin-web-mrrlin3.vercel.app)
+  // and the old app.mrrlin.dev origin are dropped from the defaults: the browser now reaches the
+  // bridge from the owned domain, which is stable across future Vercel project/team moves.
+  // See docs/reference/deployments.md.
+  "https://staging.mrrlin.com",
+  // Production web (unchanged).
   "https://mrrlin-web.vercel.app"
 ];
 function normalizeReasoningEffort(value) {
@@ -56231,249 +56816,6 @@ async function searchKnowledge(query, options = {}) {
   return searchKnowledgeIndex(index, query, options.limit ?? 5);
 }
 
-// src/consensus/spec-identity.ts
-function validateSpecIdentity(markdown, taskId) {
-  const target = taskId.toUpperCase();
-  const fieldToken = frontmatterTaskToken(markdown);
-  if (fieldToken !== null && fieldToken.toUpperCase() !== target) return false;
-  const headingToken = firstHeadingToken(markdown);
-  if (headingToken !== null && headingToken.toUpperCase() !== target) return false;
-  return true;
-}
-var TASK_ID_TOKEN = /\b[A-Za-z]{1,12}-\d{1,10}\b/;
-var ATX_HEADING = /^ {0,3}#{1,6}\s+(.*)$/;
-var FRONTMATTER_TASK = /^task(?:_id)?:\s*(.+)$/i;
-function frontmatterTaskToken(markdown) {
-  const lines2 = markdown.split("\n");
-  const firstContent = lines2.findIndex((l) => l.trim() !== "");
-  if (firstContent === -1 || lines2[firstContent]?.trim() !== "---") return null;
-  for (let i = firstContent + 1; i < lines2.length; i++) {
-    const trimmed = (lines2[i] ?? "").trim();
-    if (trimmed === "---") break;
-    const m = FRONTMATTER_TASK.exec(trimmed);
-    if (m) return firstTaskIdToken(m[1] ?? "");
-  }
-  return null;
-}
-function firstHeadingToken(markdown) {
-  const heading = firstHeading(markdown);
-  return heading === null ? null : firstTaskIdToken(heading);
-}
-function firstHeading(markdown) {
-  const lines2 = markdown.split("\n");
-  let i = 0;
-  const firstContent = lines2.findIndex((l) => l.trim() !== "");
-  if (firstContent !== -1 && lines2[firstContent]?.trim() === "---") {
-    i = firstContent + 1;
-    while (i < lines2.length && lines2[i]?.trim() !== "---") i++;
-    i++;
-  }
-  let inFence = false;
-  let inComment = false;
-  for (; i < lines2.length; i++) {
-    const line = lines2[i] ?? "";
-    const trimmed = line.trim();
-    if (inComment) {
-      if (trimmed.includes("-->")) inComment = false;
-      continue;
-    }
-    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence) continue;
-    if (trimmed.startsWith("<!--")) {
-      if (!trimmed.includes("-->")) inComment = true;
-      continue;
-    }
-    const m = ATX_HEADING.exec(line);
-    if (m) return m[1] ?? "";
-  }
-  return null;
-}
-function firstTaskIdToken(text) {
-  const m = TASK_ID_TOKEN.exec(text);
-  return m ? m[0] : null;
-}
-
-// src/consensus/spec-gate.ts
-function mapAcceptedIssueToClarification(issue2) {
-  const text = issue2.text.toLowerCase();
-  let kind;
-  if (issue2.category === "scope") {
-    const directionCues = ["only", "or also", "narrower", "broader", "include", "exclude", "versus", "vs"];
-    kind = directionCues.some((cue) => text.includes(cue)) ? "scope_direction" : "missing_requirement";
-  } else {
-    const acceptanceCues = ["acceptance", "done", "success", "criteria", "satisfy"];
-    kind = acceptanceCues.some((cue) => text.includes(cue)) ? "acceptance_criteria_detail" : "default_choice";
-  }
-  return {
-    kind,
-    diagnostic: false,
-    rawQuestion: issue2.text,
-    whyBlocking: `reviewer raised a ${issue2.category} issue`,
-    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();
-  if (intent.taskId !== null && (intent.seed === null || intent.seed.trim() === "")) {
-    return {
-      outcome: "CONSENSUS_BLOCKED",
-      operatorClarifications: [
-        {
-          kind: "missing_requirement",
-          diagnostic: false,
-          rawQuestion: "What are the requirements for this task? There is no operator request on record, so the spec cannot be validated against your intent \u2014 please state what this task must do.",
-          whyBlocking: "operator_seed_request is empty",
-          category: "scope"
-        }
-      ]
-    };
-  }
-  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 (parseAcceptanceCriteria(spec.markdownBody) === null) {
-    return {
-      outcome: "CONSENSUS_BLOCKED",
-      operatorClarifications: [
-        {
-          kind: "acceptance_criteria_detail",
-          diagnostic: false,
-          rawQuestion: "This spec has no machine-usable acceptance criteria. Add an `## Acceptance criteria` section written as a markdown checklist (`- [ ] \u2026` items) describing exactly what the finished deliverable must satisfy \u2014 the review of the produced work is scored against it.",
-          whyBlocking: "non-code spec is missing a parseable `## Acceptance criteria` checklist",
-          category: "scope"
-        }
-      ]
-    };
-  }
-  let currentHash = spec.contentHash;
-  let currentMarkdown = spec.markdownBody;
-  let conflicted = false;
-  const result = await runConsensus({
-    artifact: spec.markdownBody,
-    heads,
-    rounds: deps.rounds,
-    maxHeadCalls: deps.maxHeadCalls,
-    runHead: deps.runHead,
-    runArbiter: deps.runArbiter,
-    revise: async (artifact, accepted) => {
-      const revised = await deps.runReviser(artifact, accepted);
-      if (!revised.ok) return artifact;
-      if (intent.taskId !== null && !validateSpecIdentity(revised.text, intent.taskId)) {
-        process.stderr.write(
-          `[spec-gate] discarding drifted revision for ${spec.pageId}: heading does not identify ${intent.taskId}
-`
-        );
-        return artifact;
-      }
-      const cas = await deps.casUpdateSpec(revised.text, currentHash);
-      if (!cas.ok) {
-        conflicted = true;
-        throw new Error("SPEC_CHANGED_DURING_REVIEW");
-      }
-      currentHash = cas.contentHash;
-      currentMarkdown = revised.text;
-      return revised.text;
-    }
-    // Only OUR conflict throw is swallowed (→ null). Anything else is a real
-    // error and must propagate so it is not silently masked as a conflict.
-  }).catch((e) => conflicted ? null : Promise.reject(e));
-  if (conflicted || result === null) {
-    await deps.writeEvidence({ specPageId: spec.pageId, outcome: "SPEC_CHANGED_DURING_REVIEW" });
-    return { outcome: "SPEC_CHANGED_DURING_REVIEW" };
-  }
-  if (result.outcome === "CONVERGED" && intent.taskId !== null && !validateSpecIdentity(currentMarkdown, intent.taskId)) {
-    process.stderr.write(
-      `[spec-gate] blocking promotion for ${spec.pageId}: converged spec heading does not identify ${intent.taskId}
-`
-    );
-    return {
-      outcome: "CONSENSUS_BLOCKED",
-      diagnostics: [
-        {
-          kind: "spec_identity_mismatch",
-          diagnostic: true,
-          rawQuestion: `SPEC_IDENTITY_MISMATCH: this spec page gates ${intent.taskId}, but its heading identifies a different task \u2014 rewrite the spec heading and content for ${intent.taskId}, or re-link the task.`,
-          whyBlocking: "converged spec content belongs to a different task than the one it gates",
-          category: "scope"
-        }
-      ]
-    };
-  }
-  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,
-    ...droppedByCap.length > 0 ? { droppedByCap } : {}
-  });
-  if (result.outcome === "CONVERGED") {
-    await deps.promoteSpecReady(currentHash);
-    return { outcome: "CONVERGED" };
-  }
-  if (result.outcome === "CONSENSUS_BLOCKED") {
-    return {
-      outcome: "CONSENSUS_BLOCKED",
-      ...keptClarifications.length > 0 ? { operatorClarifications: keptClarifications } : {},
-      ...droppedByCap.length > 0 ? { droppedByCap } : {},
-      ...result.escalation ? { escalation: result.escalation } : {}
-    };
-  }
-  return { outcome: result.outcome };
-}
-
 // src/consensus/code-gate.ts
 var CODE_HEADS = ["code-reviewer"];
 var CodeGateUnfixableError = class extends Error {
@@ -56930,13 +57272,29 @@ var HUMANIZE_TEMPLATE_BY_KIND = {
   acceptance_criteria_detail: "The direction is clear, but the spec still needs a sharper success check. What should count as done?"
 };
 var HUMANIZE_CONTEXT_CAP = 200;
+function truncateToSentenceBoundary(text, cap) {
+  if (text.length <= cap) return text;
+  const sentences = text.match(/.+?[.!?](?=\s|$)/g);
+  if (sentences) {
+    let kept = "";
+    let keptCount = 0;
+    for (const sentence of sentences) {
+      const candidate = kept ? `${kept} ${sentence.trim()}` : sentence.trim();
+      if (candidate.length > cap) break;
+      kept = candidate;
+      keptCount++;
+    }
+    if (kept) return keptCount < sentences.length ? `${kept} \u2026` : kept;
+  }
+  const cutIdx = text.lastIndexOf(" ", cap);
+  return text.slice(0, cutIdx > 0 ? cutIdx : cap).trim() + "\u2026";
+}
 function humanizeClarificationBody(clarification) {
   const prefix = HUMANIZE_TEMPLATE_BY_KIND[clarification.kind];
-  let context = clarification.rawQuestion.replace(/\b(?:parseable|SPEC_IDENTITY_MISMATCH|machine-usable)\b/gi, "").replace(/\s+/g, " ").trim();
-  if (context.length > HUMANIZE_CONTEXT_CAP) {
-    const cutIdx = context.lastIndexOf(" ", HUMANIZE_CONTEXT_CAP);
-    context = context.slice(0, cutIdx > 0 ? cutIdx : HUMANIZE_CONTEXT_CAP).trim() + "\u2026";
-  }
+  const context = truncateToSentenceBoundary(
+    clarification.rawQuestion.replace(/\b(?:parseable|SPEC_IDENTITY_MISMATCH|machine-usable)\b/gi, "").replace(/\s+/g, " ").trim(),
+    HUMANIZE_CONTEXT_CAP
+  );
   return context ? `${prefix} ${context}` : prefix;
 }
 var defaultNativeSpecGateBuilders = { buildSpecGateDeps, runSpecGate };
@@ -56962,7 +57320,7 @@ async function cachedResult(client, input) {
   const review = await client.getSpecConsensusReview(
     input.projectSlug,
     input.pageId,
-    domainScopedReviewHash(page.contentHash, domain2)
+    domainScopedReviewHash2(page.contentHash, domain2)
   );
   if (review?.outcome === "CONVERGED") {
     const gatedTaskId = await resolveGatedTaskId(client, input.projectSlug, {
@@ -57075,7 +57433,7 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
           ...suppressedAsAdjudicated.length ? { suppressedAsAdjudicated } : {}
         } : void 0;
         await ctx.client.recordSpecConsensusReview(input.projectSlug, input.pageId, {
-          contentHash: domainScopedReviewHash(page.contentHash, domain2),
+          contentHash: domainScopedReviewHash2(page.contentHash, domain2),
           outcome: "CONSENSUS_BLOCKED_CLARIFICATION",
           rounds: 0,
           ...suppressionEvidence ? { suppressionEvidence } : {}
@@ -57092,7 +57450,12 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
   if (filedQuestionCount > 0) {
     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.";
+    const diagnosticKinds = new Set(diagnostics.map((d) => d.kind));
+    if (diagnosticKinds.has("acceptance_criteria_unauthorable")) {
+      error51 = "Consensus blocked: the spec has no machine-usable acceptance criteria and the reviser could not add them automatically. A human needs to write the `## Acceptance criteria` section directly, not an inbox answer.";
+    } else {
+      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) {
@@ -57111,8 +57474,41 @@ async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
     ...resolvedTaskId ? { taskId: resolvedTaskId } : {}
   };
 }
-async function run(ctx, input) {
-  const result = await runNativeSpecGate(ctx, input);
+function shouldRetireGateQuestions(outcome) {
+  return outcome === "CONVERGED";
+}
+async function retireGateQuestionsOnConverge(ctx, input, resolvedTaskId) {
+  if (resolvedTaskId === null) return;
+  try {
+    const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+    const contentHash = page?.contentHash ?? null;
+    const inboxItems = await ctx.client.listInboxItems(input.projectSlug, { taskId: resolvedTaskId });
+    for (const item of inboxItems) {
+      if (item.origin !== "gate" || item.status !== "pending" || item.kind !== "question" || item.taskId != null && item.taskId !== resolvedTaskId) {
+        continue;
+      }
+      try {
+        await ctx.client.decideInboxItem(input.projectSlug, item.id, {
+          verdict: "rejected",
+          decidedBy: "gate",
+          reason: `Superseded by converged spec Specs/${input.pageId} (contentHash: ${contentHash ?? "unknown"})`
+        });
+      } catch (itemError) {
+        process.stderr.write(
+          `[mrrlin-mcp consensus] gate-question retirement failed for ${input.projectSlug}/${input.pageId} item ${item.id}: ${itemError instanceof Error ? itemError.message : String(itemError)}
+`
+        );
+      }
+    }
+  } catch (error51) {
+    process.stderr.write(
+      `[mrrlin-mcp consensus] gate-question retirement failed for ${input.projectSlug}/${input.pageId}: ${error51 instanceof Error ? error51.message : String(error51)}
+`
+    );
+  }
+}
+async function run(ctx, input, builders = defaultNativeSpecGateBuilders) {
+  const result = await runNativeSpecGate(ctx, input, builders);
   if (process.env[SHADOW_ENV_FLAG]) {
     try {
       const specPage = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
@@ -57133,22 +57529,40 @@ async function run(ctx, input) {
     }
   }
   let resolvedTaskId = null;
+  let resolvedTaskTitle = null;
   try {
     const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
     resolvedTaskId = page?.taskId ?? null;
   } catch {
   }
+  const resolveTitle = async () => {
+    if (!resolvedTaskId) return;
+    try {
+      resolvedTaskTitle = (await ctx.client.getTask(input.projectSlug, resolvedTaskId)).title;
+    } catch {
+    }
+  };
   if (result.outcome === "CONSENSUS_BLOCKED") {
     return handleConsensusBlocked(result, ctx, input, resolvedTaskId);
   }
+  if (shouldRetireGateQuestions(result.outcome)) {
+    await retireGateQuestionsOnConverge(ctx, input, resolvedTaskId);
+  }
   switch (result.outcome) {
     case "CONVERGED":
     case "SKIPPED":
-      return { kind: "done", resultJson: JSON.stringify(result), finalReviewedHash: null };
+      await resolveTitle();
+      return {
+        kind: "done",
+        resultJson: JSON.stringify(result),
+        finalReviewedHash: null,
+        ...resolvedTaskId ? { taskId: resolvedTaskId } : {},
+        ...resolvedTaskTitle ? { taskTitle: resolvedTaskTitle } : {}
+      };
     case "CONSENSUS_UNAVAILABLE":
-      return { kind: "retry", failureReason: "provider_unavailable", error: "Consensus unavailable (provider/quota)." };
+      return { kind: "retry", failureReason: "provider_unavailable", error: "Consensus unavailable (provider/quota).", ...resolvedTaskId ? { taskId: resolvedTaskId } : {} };
     case "SPEC_CHANGED_DURING_REVIEW":
-      return { kind: "retry", failureReason: "spec_changed", error: "Spec changed during review." };
+      return { kind: "retry", failureReason: "spec_changed", error: "Spec changed during review.", ...resolvedTaskId ? { taskId: resolvedTaskId } : {} };
     default:
       return {
         kind: "failed",
@@ -57159,7 +57573,8 @@ async function run(ctx, input) {
   }
 }
 function onComplete2(outcome, input) {
-  const taskId = outcome.kind === "failed" ? outcome.taskId : void 0;
+  const taskId = "taskId" in outcome ? outcome.taskId : void 0;
+  const taskRef = taskId ? outcome.kind === "done" && outcome.taskTitle ? `${taskId} \u2014 ${outcome.taskTitle}` : taskId : null;
   if (outcome.kind === "done") {
     let specOutcome = "CONVERGED";
     try {
@@ -57169,12 +57584,14 @@ function onComplete2(outcome, input) {
     if (specOutcome === "SKIPPED") {
       return {
         kind: "info",
-        body: `Consensus is disabled for this project; Specs/${input.pageId} was not gated and spec_ready is unchanged.`
+        ...taskId ? { taskId } : {},
+        body: taskRef ? `Consensus is disabled for this project; the spec for ${taskRef} (Specs/${input.pageId}) was not gated and spec_ready is unchanged.` : `Consensus is disabled for this project; Specs/${input.pageId} was not gated and spec_ready is unchanged.`
       };
     }
     return {
       kind: "info",
-      body: `Consensus CONVERGED for Specs/${input.pageId}; spec_ready set. Ready to create an execution run.`
+      ...taskId ? { taskId } : {},
+      body: taskRef ? `Consensus CONVERGED for ${taskRef} (spec Specs/${input.pageId}); spec_ready set. Ready to create an execution run.` : `Consensus CONVERGED for Specs/${input.pageId}; spec_ready set. Ready to create an execution run.`
     };
   }
   if (outcome.kind === "failed" && (outcome.filedQuestionCount ?? 0) > 0) {
@@ -57183,14 +57600,14 @@ function onComplete2(outcome, input) {
       kind: "info",
       suppressInbox: true,
       ...taskId ? { taskId } : {},
-      body: `Consensus blocked on Specs/${input.pageId}; filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.`
+      body: taskRef ? `Consensus blocked on ${taskRef} (Specs/${input.pageId}); filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.` : `Consensus blocked on Specs/${input.pageId}; filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.`
     };
   }
-  const taskRef = taskId ? ` (${taskId})` : "";
+  const handoffTaskRef = taskRef ? ` (${taskRef})` : "";
   return {
     kind: "handoff",
     ...taskId ? { taskId } : {},
-    body: `The spec review stopped for Specs/${input.pageId}${taskRef}. ${outcome.error} Review the item, consult the Director if needed, then continue in Codex or handle it manually.`
+    body: `The spec review stopped for Specs/${input.pageId}${handoffTaskRef}. ${outcome.error} Review the item, consult the Director if needed, then continue in Codex or handle it manually.`
   };
 }
 var consensusDescriptor = {
@@ -57214,7 +57631,7 @@ async function cachedResult2(client, input) {
   const review = await client.getSpecConsensusReview(
     input.projectSlug,
     input.pageId,
-    domainScopedReviewHash(page.contentHash, domain2)
+    domainScopedReviewHash2(page.contentHash, domain2)
   );
   if (review?.outcome === "CONVERGED") {
     return { status: "already_converged", payload: { outcome: "CONVERGED", contentHash: page.contentHash } };
@@ -57224,6 +57641,22 @@ async function cachedResult2(client, input) {
   }
   return null;
 }
+async function resolveTaskScope(ctx, input, { withTitle }) {
+  let taskId = null;
+  let taskTitle = null;
+  try {
+    const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+    taskId = page?.taskId ?? null;
+  } catch {
+  }
+  if (taskId && withTitle) {
+    try {
+      taskTitle = (await ctx.client.getTask(input.projectSlug, taskId)).title;
+    } catch {
+    }
+  }
+  return { taskId, taskTitle };
+}
 async function run2(ctx, input) {
   const deps = await buildDeliverableGateDeps({
     client: ctx.client,
@@ -57237,7 +57670,14 @@ async function run2(ctx, input) {
     deps
   );
   if (result.outcome === "CONVERGED" || result.outcome === "SKIPPED") {
-    return { kind: "done", resultJson: JSON.stringify(result), finalReviewedHash: null };
+    const { taskId: taskId2, taskTitle } = await resolveTaskScope(ctx, input, { withTitle: true });
+    return {
+      kind: "done",
+      resultJson: JSON.stringify(result),
+      finalReviewedHash: null,
+      ...taskId2 ? { taskId: taskId2 } : {},
+      ...taskTitle ? { taskTitle } : {}
+    };
   }
   const mapped = mapDeliverableGateResult(result);
   if (mapped.action === "retry") {
@@ -57247,10 +57687,9 @@ async function run2(ctx, input) {
       error: mapped.reason
     };
   }
+  const { taskId } = await resolveTaskScope(ctx, input, { withTitle: false });
   let filedQuestionCount = 0;
   if (mapped.action === "questions") {
-    const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
-    const taskId = page?.taskId ?? null;
     if (taskId) {
       filedQuestionCount = await fileDeliverableGateQuestions(ctx.client, input.projectSlug, taskId, mapped.clarifications);
     }
@@ -57260,10 +57699,13 @@ async function run2(ctx, input) {
     kind: "failed",
     failureReason: "consensus_blocked",
     error: error51,
-    filedQuestionCount
+    filedQuestionCount,
+    ...taskId ? { taskId } : {}
   };
 }
 function onComplete3(outcome, input) {
+  const taskId = outcome.kind === "failed" || outcome.kind === "done" ? outcome.taskId : void 0;
+  const taskRef = taskId ? outcome.kind === "done" && outcome.taskTitle ? `${taskId} \u2014 ${outcome.taskTitle}` : taskId : null;
   if (outcome.kind === "done") {
     let specOutcome = "CONVERGED";
     try {
@@ -57273,12 +57715,14 @@ function onComplete3(outcome, input) {
     if (specOutcome === "SKIPPED") {
       return {
         kind: "info",
-        body: `Consensus is disabled for this project; Deliverables/${input.pageId} was not gated.`
+        ...taskId ? { taskId } : {},
+        body: taskRef ? `Consensus is disabled for this project; the deliverable for ${taskRef} (Deliverables/${input.pageId}) was not gated.` : `Consensus is disabled for this project; Deliverables/${input.pageId} was not gated.`
       };
     }
     return {
       kind: "info",
-      body: `Deliverable consensus CONVERGED for Deliverables/${input.pageId}; it meets the acceptance criteria.`
+      ...taskId ? { taskId } : {},
+      body: taskRef ? `Deliverable consensus CONVERGED for ${taskRef} (Deliverables/${input.pageId}); it meets the acceptance criteria.` : `Deliverable consensus CONVERGED for Deliverables/${input.pageId}; it meets the acceptance criteria.`
     };
   }
   if (outcome.kind === "failed" && (outcome.filedQuestionCount ?? 0) > 0) {
@@ -57286,12 +57730,14 @@ function onComplete3(outcome, input) {
     return {
       kind: "info",
       suppressInbox: true,
-      body: `Deliverable consensus blocked on Deliverables/${input.pageId}; filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.`
+      ...taskId ? { taskId } : {},
+      body: taskRef ? `Deliverable consensus blocked on ${taskRef} (Deliverables/${input.pageId}); filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.` : `Deliverable consensus blocked on Deliverables/${input.pageId}; filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.`
     };
   }
   return {
     kind: "handoff",
-    body: `Deliverable consensus could not complete for Deliverables/${input.pageId}: ${outcome.error} Needs operator attention.`
+    ...taskId ? { taskId } : {},
+    body: taskRef ? `Deliverable consensus could not complete for ${taskRef} (Deliverables/${input.pageId}): ${outcome.error} Needs operator attention.` : `Deliverable consensus could not complete for Deliverables/${input.pageId}: ${outcome.error} Needs operator attention.`
   };
 }
 var deliverableConsensusDescriptor = {
@@ -58654,7 +59100,7 @@ function createMrrlinTools(options) {
         const review = await c.getSpecConsensusReview(
           projectSlug,
           pageId,
-          domainScopedReviewHash(page.contentHash, reviewDomain)
+          domainScopedReviewHash2(page.contentHash, reviewDomain)
         );
         if (review && review.outcome === "CONVERGED") {
           try {