@coreplane/switchboard 1.244.0 → 1.245.0

package/dist/cli.js

@@ -1501,6 +1501,9 @@ function postStepLease(preset, remainingMs) {
   if (remainingMs === void 0) return allowance;
   return Math.min(allowance, Math.max(1, remainingMs / MINUTE_MS));
 }
+function leaseMinimum(preset) {
+  return ALLOWANCES.writeUp + postStepMinutes(preset) + 1;
+}
 function turnLeaseMs(askMinutes, remainingMs) {
   return Math.min(askMinutes * MINUTE_MS, Math.max(MINUTE_MS, remainingMs));
 }
@@ -1547,13 +1550,14 @@ function fit(pipeline) {
   const need = ALLOWANCES.provision + ASKS.coding + reserveMinutes({ kind: "coding", index: 0 }, pipeline);
   return { ok: pipeline.maxMinutes >= need, need, have: pipeline.maxMinutes };
 }
-var MINUTE_MS, DAY_MS, CONFIRMATION_TTL_MS, LOOP_PRESETS, ASKS, PRESET_FLOORS, FLOORS, SHIP_WAIT, ALLOWANCES, POST_STEP_MINUTES, WRAP_UP_WARNING, BASH_COMMAND, RUNAWAY_TURNS_PER_MINUTE, DEFAULT_GRANT, GRANT_RENEWALS_MAX;
+var MINUTE_MS, DAY_MS, CONFIRMATION_TTL_MS, FIRST_ATTACH_WAIT_MS, LOOP_PRESETS, ASKS, PRESET_FLOORS, FLOORS, SHIP_WAIT, ALLOWANCES, POST_STEP_MINUTES, WRAP_UP_WARNING, BASH_COMMAND, RUNAWAY_TURNS_PER_MINUTE, DEFAULT_GRANT, GRANT_RENEWALS_MAX;
 var init_budgets = __esm({
   "../../src/core/budgets.ts"() {
     "use strict";
     MINUTE_MS = 6e4;
     DAY_MS = 24 * 60 * MINUTE_MS;
     CONFIRMATION_TTL_MS = 10 * MINUTE_MS;
+    FIRST_ATTACH_WAIT_MS = MINUTE_MS;
     LOOP_PRESETS = ["general", "coding", "review", "research", "explore", "conductor"];
     ASKS = {
       general: 5,
@@ -2017,7 +2021,7 @@ var init_registry = __esm({
     IDENTITIES = ["none", "read", "write"];
     PR_DESCRIPTION_TEMPLATE = `PR description \u2014 submit it with the submit_pr_description tool for EVERY PR (this is the default, not something to wait to be asked for). Switchboard renders the GitHub body from the object you submit, so never author PR-body markdown yourself. Before submitting, judge your title with the ${PR_TITLE_GUARD} gate \u2014 \`npm run check:pr-title -- "<title>"\` \u2014 and submit only a title it accepts; the same gate refuses the PR in CI. The body is a fixed-size MAP for the reader with everything for agents collapsed under it; every field is capped in visible characters (a link's URL is not counted) and the tool refuses an object over a cap naming the field and the count \u2014 cut and resubmit. Prose is unwrapped \u2014 no hard line breaks inside a paragraph. Always hyperlink the triggering issue/request. Never fabricate validation \u2014 state exactly what you ran and the real result. BEFORE authoring the pointers, load the \`pr-description\` skill with use_skill \u2014 it defines how to choose at most seven pointers, the mechanical anchor rules and what goes below the fold; follow it for every PR.
 EVERY PR includes one that already exists when you push \u2014 opened by a person, by dependabot, or by an earlier run. After EVERY push to such a PR: read its current title and body (\`github_issue_get\` with the PR number works for pull requests; \`gh pr view\` where gh exists), judge them against the change as it now stands at the pushed head, and submit the object that describes the PR as it is NOW \u2014 carry forward what the existing body says that is still true (a dependency bump's release notes belong in why), add what you changed, and anchor the pointers at the new head. Switchboard replaces the PR's title and body with your rendering. A description that describes an earlier state of its branch is a bug; "it is someone else's PR" is never a reason to leave it.
-- **title**: the PR title \u2014 one line naming the change, specific enough to pick out of a PR list.
+- **title** (\u226472 characters in all): the changelog line \u2014 \`type(scope): what a reader can now do or expect\`, one change, one clause, present tense. The type and the scope spend the same budget as the description, so the description is short; the body carries the rest. The tool refuses a longer title naming the count, and so does the gate in CI.
 - **TL;DR** (\`tldr\`, rendered first, \u2264300): two sentences for a reader with zero context \u2014 what this PR does and why it matters.
 - **Why** (\`why\`, \u2264400): the problem and the motivation, with the triggering issue/request, the record and the stack position hyperlinked. Why, never what: the diff shows what.
 - **Where to look** (\`pointers\`, 1 to 7): the files a reviewer would open first, in reading order, each { label \u226460, text \u2264160, optional risk \u2264100, anchor } with the anchor a { path, from, to } line range at your pushed head, rendered as a link (never embedded code). One pointer per idea, never per file; when the change has more ideas than seven, keep the seven whose mistake would cost most.
@@ -2157,7 +2161,7 @@ ${statusCardRule()}
 Report outcomes faithfully: if tests fail or a step was skipped, say so plainly.
 ${FENCED_CONTENT_RULE}
 Your final message is posted to Slack \u2014 keep it readable, lead with the outcome.`;
-    REVIEW_VERDICT_INSTRUCTION = `VERDICT: before your final message, call the submit_verdict tool exactly once with \`approve\` (no blocking issues \u2014 nits alone are not blocking) or \`request_changes\`, a one-line summary, \`head\` = the output of \`git rev-parse HEAD\` in the checkout you reviewed, and \`findings\` \u2014 every issue you report as a structured entry with a stable id you assign in order (F1, F2, \u2026), a severity of exactly blocking|major|minor|nit, the file (plus line when it points at one), and a one-line title. The findings array is the index of your review: the full explanation of each finding stays in your prose, keyed by the same ids. Switchboard writes the verdict as the first line of the GitHub comment itself and lists the findings under it; a review with no submitted verdict is posted as not approving, so never skip it. An \`approve\` carrying a blocking finding is downgraded to \`request_changes\` \u2014 approve only when nothing blocking remains. Do not write "LGTM" in your own text \u2014 the verdict line carries it.`;
+    REVIEW_VERDICT_INSTRUCTION = `VERDICT: before your final message, call the submit_verdict tool exactly once with \`approve\` (no finding at or above the severity to address remains \u2014 the level in force for this run, \`minor\` by default: a major or a minor finding means \`request_changes\`; nits alone never block) or \`request_changes\`, a one-line summary, \`head\` = the output of \`git rev-parse HEAD\` in the checkout you reviewed, and \`findings\` \u2014 every issue you report as a structured entry with a stable id you assign in order (F1, F2, \u2026), a severity of exactly blocking|major|minor|nit, the file (plus line when it points at one), and a one-line title. The findings array is the index of your review: the full explanation of each finding stays in your prose, keyed by the same ids. Switchboard writes the verdict as the first line of the GitHub comment itself and lists the findings under it; a review with no submitted verdict is posted as not approving, so never skip it. An \`approve\` carrying a finding at or above the severity to address is downgraded to \`request_changes\` and the tool's ack says so \u2014 approve only when every finding sits below the level. Do not write "LGTM" in your own text \u2014 the verdict line carries it.`;
     REVIEW_SPEC_CHECK = `3. SPEC CONTRADICTION CHECK, when the repository has \`docs/reference/specs/\`: list the specs the change touches \u2014 \`npm run --silent specs:coverage -- --changed origin/<base>...HEAD\` (\`<base>\` is the PR's base branch) when the repository's package.json has that script, otherwise match the changed paths against each spec's \`- **Code**:\` / \`- **Tests**:\` header lines (a header path covers itself and everything beneath it). If the command fails for any reason \u2014 dependencies not installed, tsx missing, a cold checkout \u2014 fall back to matching the header lines by hand; never install dependencies or build to make it run. Then read ONLY those specs, never the whole specs tree \u2014 fold the reads into your gather batch where you can. For each touched spec, judge whether the diff contradicts a numbered behavior statement or a validation criterion: code that now does what the spec says it does not, a criterion whose named test the diff removed or retitled, a behavior the diff deleted that the spec still promises. A contradiction is a finding of severity \`minor\` or higher titled \`Spec contradiction \u2014 <spec file> item <n>: <what the code now does vs what the spec says>\`; a spec updated in the same diff to match the code is not a finding. A repository with no \`docs/reference/specs/\` has nothing to check \u2014 skip this step silently.
    3a. TEST GUARD, in the same repositories: run \`npm run --silent specs:coverage -- --changed origin/<base>...HEAD --test-guard\` (fold it into the same batch). It compares every test file the diff touches at the base and at the head and prints one line per thing lost, in two classes. A \`test-guard: <file> \u2014 removed: \u2026\` line is deterministic \u2014 the test file deleted, an it/test/describe title gone with no new title to pair with, a skip/only/todo marker (\`.skip(\`, \`.only(\`, \`xit(\`, \`xdescribe(\`, \`it.todo(\`, \`test.todo(\`) on a test the base ran \u2014 and each one is a finding of severity \`minor\` or higher titled \`Test removed \u2014 <file>: <what>\` whose explanation quotes the guard's line exactly as printed. A \`test-guard: <file> \u2014 check: \u2026\` line is a heuristic \u2014 fewer \`expect(\` calls in the file, a title gone while another arrived (a rename or a split) \u2014 and you dispose of every one of them explicitly in your review, never silently: either "weakened", which makes it a finding at \`minor\`, or "refactor, verification intact" with one clause saying why. A line ending \`\u2014 allowed by <spec>\` is licensed by a spec change in the same diff and is neither; \`test-guard ok\` is nothing to report. If the command fails for any reason, judge the same facts from the diff by hand \u2014 a deleted test file, a removed title, a new skip marker, fewer assertions \u2014 and file each one the diff does not license the same way; never install or build to make it run.`;
     REVIEW_UNIT_CONTRACT = `   3b. UNIT CONTRACT, when this prompt carries a \`${CONTRACT_HEADING}\` block after the REVIEW TARGET block (its sub-headings, in order: ${CONTRACT_HEADINGS_LIST}): it is what the coding child was handed for this plan unit, rendered by Switchboard from the plan, and the diff is judged against it. Read the unit's Test scenarios and find each one in the diff: a test scenario the unit listed and the diff did not add is a finding of severity \`minor\` titled \`Contract \u2014 test scenario missing: <the scenario>\` \u2014 the same severity as a spec contradiction. For each spec row the block names, check its proof binding resolves in the diff; a named row the diff leaves untouched is disposed of out loud, as in 3a: one clause on why it needed no change, or a finding at \`minor\` titled \`Contract \u2014 spec row not updated: <spec> item <n>\`. A guard the block names that the diff weakens is the guard's own finding (3a). No \`${CONTRACT_HEADING}\` block in this prompt \u2192 nothing to check; skip this step silently.`;
@@ -2598,33 +2602,45 @@ var init_redact = __esm({
 });
 
 // ../../src/core/reviewVerdict.ts
-function parseVerdictInput(input) {
+function severityAtOrAbove(severity, level) {
+  return isAddressSeverity(severity) && severityRank(severity) <= severityRank(level);
+}
+function resolveAddressSeverity(layers) {
+  if (layers.run !== void 0) return { level: layers.run, source: "run" };
+  if (layers.user !== void 0) return { level: layers.user, source: "user" };
+  if (layers.channel !== void 0) return { level: layers.channel, source: "channel" };
+  return { level: layers.org ?? DEFAULT_ADDRESS_SEVERITY, source: "org" };
+}
+function downgradeNote(d) {
+  return `finding${d.findings.length === 1 ? "" : "s"} ${d.findings.join(", ")} at or above ${d.level}, the severity to address`;
+}
+function parseVerdictInput(input, opts = {}) {
   const verdict = input.verdict;
   if (verdict !== "approve" && verdict !== "request_changes") return null;
+  const level = opts.addressSeverity ?? DEFAULT_ADDRESS_SEVERITY;
   const summary = typeof input.summary === "string" ? oneLine2(input.summary) : "";
   const head = normalizeHead(input.head);
   const out = { verdict, summary };
   if (head) out.head = head;
   if (input.findings !== void 0) {
-    const parsed = parseFindings(input.findings);
+    const parsed = parseFindings(input.findings, level);
     if (parsed.findings) out.findings = parsed.findings;
     if (parsed.dropped.length) out.droppedFindings = parsed.dropped;
-    if (out.verdict === "approve" && parsed.blocking.length > 0) {
+    if (out.verdict === "approve" && parsed.gated.length > 0) {
       out.verdict = "request_changes";
-      out.summary = oneLine2(
-        `${out.summary} [downgraded from approve: blocking finding${parsed.blocking.length === 1 ? "" : "s"} ${parsed.blocking.join(", ")}]`
-      );
+      out.downgraded = { findings: parsed.gated, level };
+      out.summary = oneLine2(`${out.summary} [downgraded from approve: ${downgradeNote(out.downgraded)}]`);
     }
   }
   return out;
 }
-function parseFindings(value) {
+function parseFindings(value, level) {
   if (!Array.isArray(value)) {
-    return { dropped: ["findings: dropped \u2014 not an array"], blocking: [] };
+    return { dropped: ["findings: dropped \u2014 not an array"], gated: [] };
   }
   const findings = [];
   const dropped = [];
-  const blocking = [];
+  const gated = [];
   value.forEach((raw, i) => {
     const parsed = parseFinding(raw);
     if (parsed.finding) {
@@ -2634,9 +2650,9 @@ function parseFindings(value) {
     }
     const label = parsed.finding?.id ?? parsed.id ?? `findings[${i}]`;
     const r = typeof raw === "object" && raw !== null ? raw : void 0;
-    if (r?.severity === "blocking") blocking.push(label);
+    if (severityAtOrAbove(r?.severity, level)) gated.push(`${label} (${r?.severity})`);
   });
-  return { findings, dropped, blocking };
+  return { findings, dropped, gated };
 }
 function parseFinding(raw) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { reason: "not an object" };
@@ -2745,13 +2761,17 @@ function redactVerdict(v, redact = redactSecrets) {
 function redactDispositions(dispositions, redact = redactSecrets) {
   return dispositions.map((d) => ({ findingId: d.findingId, disposition: d.disposition, note: redact(d.note) }));
 }
-var FINDING_SEVERITIES, LGTM_TOKEN, CHANGES_TOKEN, NO_VERDICT_LINE, VERDICT_KINDS, DISPOSITION_KINDS, isRecordLike, REVIEW_POST_HEAD;
+var FINDING_SEVERITIES, ADDRESS_SEVERITIES, DEFAULT_ADDRESS_SEVERITY, isAddressSeverity, severityRank, LGTM_TOKEN, CHANGES_TOKEN, NO_VERDICT_LINE, VERDICT_KINDS, DISPOSITION_KINDS, isRecordLike, REVIEW_POST_HEAD;
 var init_reviewVerdict = __esm({
   "../../src/core/reviewVerdict.ts"() {
     "use strict";
     init_reviewedHead();
     init_redact();
     FINDING_SEVERITIES = ["blocking", "major", "minor", "nit"];
+    ADDRESS_SEVERITIES = FINDING_SEVERITIES;
+    DEFAULT_ADDRESS_SEVERITY = "minor";
+    isAddressSeverity = (v) => ADDRESS_SEVERITIES.includes(v);
+    severityRank = (s) => ADDRESS_SEVERITIES.indexOf(s);
     LGTM_TOKEN = "LGTM:";
     CHANGES_TOKEN = "Changes requested:";
     NO_VERDICT_LINE = "No verdict submitted \u2014 not approving.";
@@ -2993,7 +3013,7 @@ function matchDispositions(findings, dispositions) {
   const dropped = [...new Set(dispositions.filter((d) => !issued.has(d.findingId)).map((d) => d.findingId))];
   return { matched, dropped };
 }
-var MIN, PLAN_ID_PATTERN, PLAN_BRANCH, UNIT_REF, SLUG_MAX, INSTANCE_ID_MAX, ADDRESS_SEVERITIES, DEFAULT_ADDRESS_SEVERITY, isAddressSeverity, WAIT_MARGIN_MS, WAIT_CHUNK_MS, MERGE_WAIT_CHUNK_MS, BUSY_RETRY_MS;
+var MIN, PLAN_ID_PATTERN, PLAN_BRANCH, UNIT_REF, SLUG_MAX, INSTANCE_ID_MAX, WAIT_MARGIN_MS, WAIT_CHUNK_MS, MERGE_WAIT_CHUNK_MS, BUSY_RETRY_MS;
 var init_coordinator = __esm({
   "../../src/core/ship/coordinator.ts"() {
     "use strict";
@@ -3008,9 +3028,6 @@ var init_coordinator = __esm({
     UNIT_REF = /\bU(\d+)\s+to\s+U(\d+)\b|\bU\d+\b/g;
     SLUG_MAX = 24;
     INSTANCE_ID_MAX = 100;
-    ADDRESS_SEVERITIES = ["blocking", "major", "minor", "nit"];
-    DEFAULT_ADDRESS_SEVERITY = "minor";
-    isAddressSeverity = (v) => ADDRESS_SEVERITIES.includes(v);
     WAIT_MARGIN_MS = SHIP_WAIT.marginMinutes * MIN;
     WAIT_CHUNK_MS = SHIP_WAIT.chunkMinutes * MIN;
     MERGE_WAIT_CHUNK_MS = SHIP_WAIT.mergeChunkMinutes * MIN;
@@ -3019,12 +3036,6 @@ var init_coordinator = __esm({
 });
 
 // ../../src/core/shipPipeline.ts
-function resolveAddressSeverity(layers) {
-  if (layers.run !== void 0) return { level: layers.run, source: "run" };
-  if (layers.user !== void 0) return { level: layers.user, source: "user" };
-  if (layers.channel !== void 0) return { level: layers.channel, source: "channel" };
-  return { level: layers.org ?? DEFAULT_ADDRESS_SEVERITY, source: "org" };
-}
 function resolveGrant2(layers) {
   const scoped = layers.user !== void 0 ? { grant: layers.user, source: "user" } : layers.channel !== void 0 ? { grant: layers.channel, source: "channel" } : { grant: layers.org ?? DEFAULT_GRANT, source: "org" };
   if (layers.run === void 0) return scoped;
@@ -3052,7 +3063,7 @@ var init_shipPipeline = __esm({
     init_registry();
     init_budgets();
     init_coordinator();
-    init_coordinator();
+    init_reviewVerdict();
     SHIP_DEFAULT_MAX_ROUNDS = 3;
     SHIP_DEFAULT_MAX_MINUTES = AGENTS.ship.maxMinutes;
   }
@@ -3189,7 +3200,7 @@ function boundedByParent(boundary, parentRemainingMs) {
   if (boundary?.maxMinutes && boundary.maxMinutes.value <= minutes) return boundary;
   return { ...boundary, maxMinutes: { value: minutes, scope: "parent" } };
 }
-function effectiveProfile(preset, directives, boundary) {
+function effectiveProfile(preset, directives, boundary, minimum) {
   if (boundary?.maxIdentity && !identityWithin(preset.identity, boundary.maxIdentity.value)) {
     return {
       kind: "refused",
@@ -3222,6 +3233,12 @@ function effectiveProfile(preset, directives, boundary) {
     minutes = boundary.maxMinutes.value;
     boundedBy = boundary.maxMinutes.scope;
   }
+  if (minimum !== void 0 && minutes < minimum) {
+    return {
+      kind: "refused",
+      refusal: { axis: "minutes", needs: minimum, have: minutes, scope: boundedBy ?? "defaults" }
+    };
+  }
   return {
     kind: "profile",
     profile: {
@@ -3838,7 +3855,7 @@ function validateConfig(cfg) {
   for (const key of unknownKeys2(cfg, CONFIG_KEYS)) throw new Error(`config.yaml: unknown key \`${key}\``);
   validateScopeEfforts(cfg, "config.yaml");
   validateBoundaries(cfg, "config.yaml");
-  validateShipScopes(cfg, "config.yaml");
+  validateScopeBlocks(cfg, "config.yaml");
   validateHarnessWords(cfg, "config.yaml");
   validateMcpServers(cfg, "config.yaml");
   if (typeof cfg.organization !== "string" || cfg.organization.trim() === "") {
@@ -3862,6 +3879,7 @@ function validateConfig(cfg) {
   if (cfg.runHistory !== void 0) validateRunHistory(cfg.runHistory);
   if (cfg.tracing !== void 0) validateTracing(cfg.tracing);
   validateRuntimeOverrides(cfg.runtimeOverrides);
+  if (cfg.review !== void 0) validateReview(cfg.review);
   if (cfg.ship !== void 0) validateShip(cfg.ship);
   if (cfg.spawn !== void 0) validateSpawn(cfg.spawn);
   if (cfg.routing !== void 0) validateRouting(cfg.routing, cfg.providers);
@@ -3978,12 +3996,23 @@ function grantProblem(path, raw) {
     return `${path}.costCapUsd must be a positive number of dollars`;
   return void 0;
 }
-function validateShipScopes(layer, source2) {
+function addressSeverityProblem(path, value) {
+  return value !== void 0 && !isAddressSeverity(value) ? `${path} must be one of ${ADDRESS_SEVERITIES.join(", ")} (docs/reference/specs/agent-review.md item 5a)` : void 0;
+}
+function validateReview(review) {
+  const problem = addressSeverityProblem("review.addressSeverity", review.addressSeverity);
+  if (problem) throw new Error(`config.yaml: ${problem}`);
+}
+function validateScopeBlocks(layer, source2) {
   for (const [kind, scopes] of [
     ["channels", layer.channels],
     ["users", layer.users]
   ]) {
     for (const [id, scope] of Object.entries(scopes ?? {})) {
+      const level = addressSeverityProblem(`${kind}.${id}.review.addressSeverity`, scope.review?.addressSeverity);
+      if (level) throw new Error(`${source2}: ${level}`);
+      if (scope.ship !== void 0 && "addressSeverity" in scope.ship)
+        throw new Error(`${source2}: ${ADDRESS_SEVERITY_MOVED(`${kind}.${id}.ship.addressSeverity`)}`);
       const grant2 = scope.ship?.grant;
       if (grant2 === void 0) continue;
       const problem = grantProblem(`${kind}.${id}.ship.grant`, grant2);
@@ -3998,6 +4027,7 @@ function validateShip(ship) {
       throw new Error(
         "config.yaml: ship.coordinator is no longer a key \u2014 every agent:ship request runs on the plan runner; remove it (docs/reference/migrations.md)"
       );
+    if (key === "addressSeverity") throw new Error(`config.yaml: ${ADDRESS_SEVERITY_MOVED("ship.addressSeverity")}`);
     throw new Error(`config.yaml: ship.${key} is not a known key`);
   }
   const rounds = ship.maxRounds;
@@ -4015,10 +4045,6 @@ function validateShip(ship) {
     throw new Error(
       `config.yaml: ship.maxMinutes ${pipeline.maxMinutes} cannot hold the loop ship.maxRounds ${pipeline.maxRounds} allows \u2014 ${held2.need} minutes are needed (${ALLOWANCES.provision} to provision, the coding child's ${ASKS.coding}, and the reserve for ${pipeline.maxRounds} review rounds at their floors); raise ship.maxMinutes or lower ship.maxRounds (docs/reference/specs/agent-ship.md item 8)`
     );
-  if (ship.addressSeverity !== void 0 && !isAddressSeverity(ship.addressSeverity))
-    throw new Error(
-      `config.yaml: ship.addressSeverity must be one of ${ADDRESS_SEVERITIES.join(", ")} (docs/reference/specs/agent-ship.md item 9)`
-    );
   if (ship.grant !== void 0) {
     const problem = grantProblem("ship.grant", ship.grant);
     if (problem) throw new Error(`config.yaml: ${problem}`);
@@ -4089,7 +4115,7 @@ function validateRuntimeOverrides(ro) {
     }
   }
 }
-var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, PI_KEYS, PI_COMPACTION_KEYS, harnessWords, OPENCODE_KEYS, OPENCODE_COMPACTION_KEYS, ROUTE_ANSWER_MODES, REFERENCES_KEYS, ROUTING_KEYS, SHIP_KEYS, GRANT_KEYS, SPAWN_KEYS;
+var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, PI_KEYS, PI_COMPACTION_KEYS, harnessWords, OPENCODE_KEYS, OPENCODE_COMPACTION_KEYS, ROUTE_ANSWER_MODES, REFERENCES_KEYS, ROUTING_KEYS, SHIP_KEYS, GRANT_KEYS, ADDRESS_SEVERITY_MOVED, SPAWN_KEYS;
 var init_validate = __esm({
   "../../src/config/validate.ts"() {
     "use strict";
@@ -4161,10 +4187,10 @@ var init_validate = __esm({
     SHIP_KEYS = {
       maxRounds: true,
       maxMinutes: true,
-      addressSeverity: true,
       grant: true
     };
     GRANT_KEYS = { renewals: true, costCapUsd: true };
+    ADDRESS_SEVERITY_MOVED = (path) => `${path} moved to ${path.replace(/ship\.addressSeverity$/, "review.addressSeverity")} \u2014 the severity to address now gates every review's verdict, not ship alone (docs/reference/migrations.md)`;
     SPAWN_KEYS = { maxChildren: true };
   }
 });
@@ -4443,7 +4469,7 @@ var init_config2 = __esm({
         validateInstructions(doc, `overrides (${this.backing.describe()})`);
         validateScopeEfforts(doc, `overrides (${this.backing.describe()})`);
         validateBoundaries(doc, `overrides (${this.backing.describe()})`);
-        validateShipScopes(doc, `overrides (${this.backing.describe()})`);
+        validateScopeBlocks(doc, `overrides (${this.backing.describe()})`);
         validateHarnessWords(doc, `overrides (${this.backing.describe()})`);
         validateMcpServers(
           { channels: doc.channels, users: doc.users, defaults: doc.org },
@@ -9159,6 +9185,7 @@ var init_runEvents = __esm({
     RUN_NOTE_KINDS = [
       "wrap_up",
       "time_budget_exhausted",
+      "tool_cut",
       "turn_budget_exhausted",
       "sandbox_dead",
       "fleet_busy",
@@ -9177,6 +9204,7 @@ var init_runEvents = __esm({
       "cold_sandbox",
       "rebind_refused",
       "work_left_behind",
+      "workspace_torn_down",
       "pr_not_opened",
       "review_not_posted",
       "compacted",
@@ -9185,6 +9213,7 @@ var init_runEvents = __esm({
       "tool_refused",
       "settle_set_aside",
       "tool_unnamed",
+      "directory_reached",
       "budget_salvage",
       "stuck_loop"
     ];
@@ -9595,6 +9624,9 @@ function execDeadline(timeoutMs, signal2) {
   signal2.addEventListener("abort", onStop, { once: true });
   return AbortSignal.any([deadline.signal, signal2]);
 }
+function isRunStopError(err2) {
+  return err2 instanceof ExecInfraError && err2.reason === "aborted";
+}
 function infraMayClear(err2) {
   return EXEC_INFRA_WAITABLE.has(err2.reason);
 }
@@ -10433,7 +10465,7 @@ var init_residentRefresh = __esm({
     "use strict";
     init_residentDisk();
     RUNTIME_MOVED_WORDING = /previous runtime incarnation|interrupted because the runtime changed|runtime identity is no longer active|sandbox lifetime is no longer current|platform was updating the sandbox runtime|no longer identifies pid/i;
-    STOPPED_CONTAINER_WORDING = /process supervisor is closed|container is not running, consider calling start/i;
+    STOPPED_CONTAINER_WORDING = /process supervisor is closed|container is not running, consider calling start|the container just exited/i;
     RUNTIME_REPLACEMENT_WORDING = new RegExp(
       `${RUNTIME_MOVED_WORDING.source}|${STOPPED_CONTAINER_WORDING.source}`,
       "i"
@@ -10655,34 +10687,45 @@ function residentAnswerReason(status3, data) {
 function answeredStatus(httpStatus, data) {
   return httpStatus === 200 && typeof data.error === "string" && typeof data.status === "number" ? data.status : httpStatus;
 }
+function isTransientRefusal(answer) {
+  return answer.status >= 500 && answer.status <= 599 && answer.data.transient === true;
+}
 function lifecycleReasonOf(data) {
   if (typeof data.stateReason === "string") return data.stateReason;
   if (typeof data.reason === "string" && !ANSWER_OWN_WORDS.has(data.reason)) return data.reason;
   return "";
 }
-function wakeStrikeReason(last) {
+function wakeStrikeReason(last, transient = false) {
+  if (transient && isUnansweredProbe(last)) return "worker-unavailable";
   return last.kind === "status" && isWakeable(last.state, last.reason) ? "worker-unavailable" : "refused";
 }
-function residentWakeBudgetStrike(route3, refusal, spentMs, last) {
+function isUnansweredProbe(view) {
+  return view.kind === "unreachable" && (view.transport || view.status !== void 0 && view.status >= 500);
+}
+function residentWakeBudgetStrike(route3, refusal, spentMs, last, wait = {}) {
+  const origin = wait.origin ?? "container-exited";
+  const transient = wait.transient ?? origin === "transient-refusal";
+  const waitedFor = origin === "container-exited" ? "to wake" : "to come back";
   return residentWakeStrike(
     route3,
     refusal,
-    `waited ${Math.round(spentMs / 1e3)}s for the resident to wake (last seen ${describeProbe(last)}) and gave up`,
-    wakeStrikeReason(last)
+    `waited ${Math.round(spentMs / 1e3)}s for the resident ${waitedFor} (last seen ${describeProbe(last)}) and gave up`,
+    wakeStrikeReason(last, transient),
+    origin
   );
 }
-function residentWakeStrike(route3, refusal, why, reason2) {
+function residentWakeStrike(route3, refusal, why, reason2, origin = "container-exited") {
   return classifyError(new ExecInfraError(`resident ${route3}: ${refusal}; ${why}`, reason2), {
     kind: "infra",
-    code: "container-exited"
+    code: origin
   });
 }
-function wakePause(ms, signal2) {
+function wakePause(ms, signal2, route3) {
   return new Promise((resolve13, reject) => {
-    if (signal2?.aborted) return reject(wakeStopped());
+    if (signal2?.aborted) return reject(wakeStopped(route3));
     const onAbort = () => {
       clearTimeout(timer);
-      reject(wakeStopped());
+      reject(wakeStopped(route3));
     };
     const timer = setTimeout(() => {
       signal2?.removeEventListener("abort", onAbort);
@@ -10756,7 +10799,10 @@ var init_resident = __esm({
     init_executor();
     DETACH_TIMEOUT_MS = 1e4;
     ANSWER_OWN_WORDS = /* @__PURE__ */ new Set(["mirror-busy", DISK_PRESSURE_REASON, "image-stale"]);
-    wakeStopped = () => new Error("stopped waiting for the resident to wake: the run was stopped");
+    wakeStopped = (route3) => classifyError(
+      new ExecInfraError(`resident ${route3}: stopped waiting for the resident to wake: the run was stopped`, "aborted"),
+      { kind: "transport" }
+    );
     ResidentNeedsRefError = class extends Error {
       /** The resident's default branch when the Worker names one in the 409 body:
        *  the factory binds the thread to it (loudly) instead of asking. Undefined
@@ -10772,6 +10818,11 @@ var init_resident = __esm({
       resource;
       defaultRef;
       needs = "ref";
+      /** How long the wake wait ran before this refusal, when the attach met one
+       *  (a transient refusal cleared, then the resident asked for a ref): the
+       *  factory's retry by default draws on one budget across both attaches and
+       *  the card names the total. */
+      wokeAfterMs;
     };
     ResidentReuseRefusedError = class extends Error {
       constructor(resource, why) {
@@ -10817,7 +10868,13 @@ var init_resident = __esm({
         const data = await parseResidentBody(res);
         const err2 = typeof data.error === "string" ? data.error : "";
         if (err2.startsWith("op-refused")) return { kind: "refused", reason: err2 };
-        if (err2) return { kind: "error", message: `resident /op: ${err2}` };
+        if (err2) {
+          return {
+            kind: "error",
+            message: `resident /op: ${err2}`,
+            ...data.transient === true ? { transient: true } : {}
+          };
+        }
         if (!res.ok) return { kind: "error", message: `resident /op HTTP ${res.status}` };
         const ok2 = data.ok === true;
         const summary = typeof data.summary === "string" && data.summary ? data.summary : `${op} ${ok2 ? "succeeded" : "failed"}`;
@@ -10888,7 +10945,13 @@ var init_resident = __esm({
         }
         const data = sanitizeResidentBody(await res.json().catch(() => ({})));
         if (!res.ok) {
-          return { kind: "unreachable", error: `probe HTTP ${res.status}: ${String(data.error ?? "")}`, transport: false };
+          return {
+            kind: "unreachable",
+            error: `probe HTTP ${res.status}: ${String(data.error ?? "")}`,
+            transport: false,
+            status: res.status,
+            ...res.status >= 500 && data.transient === true ? { transient: true } : {}
+          };
         }
         const seed = seedHandleOf(data.snapshot);
         return {
@@ -10898,6 +10961,31 @@ var init_resident = __esm({
           ...seed ? { seed } : {}
         };
       }
+      /** The selection probe, waited through a blip the Worker typed transient
+       *  (execution.md item 9): a 5xx carrying `transient: true` — the Durable
+       *  Object reset or lost under the probe, which the attach's own wait would
+       *  have waited through a moment later — is re-probed every `WAKE_POLL_MS`
+       *  under `budgetMs`, the run's stop ending the wait at once with its typed
+       *  error. Starts from the view the caller already has (`first`), re-probes
+       *  at once — a blip the Durable Object has already recovered from costs no
+       *  pause, as the wake wait's first view costs none — then every poll; answers
+       *  the last view and how long was waited. A transport failure or any other
+       *  answer is returned at once — untyped, it is the caller's outage breaker's
+       *  case, never a wait. */
+      static async probeStatusThroughBlip(baseUrl, token2, resource, timeoutMs, first, wait) {
+        const t0 = systemClock();
+        let probe = first;
+        let reprobed = false;
+        for (; ; ) {
+          if (probe.kind !== "unreachable" || !probe.transient) return { probe, waitedMs: systemClock() - t0 };
+          const spent = systemClock() - t0;
+          if (spent >= wait.budgetMs) return { probe, waitedMs: spent };
+          if (reprobed) await wakePause(Math.min(WAKE_POLL_MS, wait.budgetMs - spent), wait.signal, "/status");
+          reprobed = true;
+          probe = await _ResidentExecutor.probeStatus(baseUrl, token2, resource, timeoutMs, wait.span, wait.signal);
+          if (wait.signal?.aborted) throw wakeStopped("/status");
+        }
+      }
       /** The one held request while the resident restores (item 27): POST
        *  /await-restore, which the resident's Durable Object holds until its state
        *  leaves `restoring` and the transition publishes — event-driven, no
@@ -10972,10 +11060,32 @@ var init_resident = __esm({
        *  request and the resident moves a default-bound thread onto it (item 16;
        *  `rebound` / `rebindRefused` say which) — and the sha the worktree is at. A
        *  200 without both fields is a malformed resident (the attach contract
-       *  always carries them) and is an error, never a half-bound executor. */
-      async attach(span) {
-        const answer = await this.attachOnce(span);
+       *  always carries them) and is an error, never a half-bound executor. A
+       *  refusal the Worker typed as the platform's transient (`isTransientRefusal`:
+       *  the Durable Object reset or lost under the attach) is waited through
+       *  here, for the run's first attach and every re-attach alike: the wake wait
+       *  (item 65) probes `/status`, re-attaches as soon as the engine says it
+       *  serves, and is bounded by `opts.budgetMs` under the wake ceiling; past the
+       *  budget it throws the wake's strike (`worker-unavailable`), so a caller
+       *  with a longer clock may still wait and the factory falls back cold naming
+       *  the wait. A deterministic refusal is judged at once, with no probe.
+       *  `attachTimeoutMs` is how long one attach request may take — the exec
+       *  default when absent (a first attach or a head move may clone and install
+       *  deps); an operation passes its own call bound, so its recovery never
+       *  waits past the operation's wall clock. */
+      async attach(span, opts = {}) {
+        const answer = await this.attachOnce(span, opts.attachTimeoutMs, opts.signal);
         if (answer.ok) return answer.binding;
+        if (isTransientRefusal(answer)) {
+          const woke = await this.awaitWake("/attach", String(answer.data.error), {
+            origin: "transient-refusal",
+            signal: opts.signal,
+            budgetMs: opts.budgetMs,
+            attachTimeoutMs: opts.attachTimeoutMs,
+            span
+          });
+          return { ...woke.binding, wokeAfterMs: woke.waitedMs };
+        }
         throw this.attachRefusal(answer);
       }
       /** One `/attach`, answered rather than thrown: the binding on a 200, else
@@ -11036,7 +11146,7 @@ var init_resident = __esm({
         if (status3 === 409 && data.needs === "recreate")
           return traced(new ResidentReuseRefusedError(this.opts.resource, err2));
         if (status3 === 404) return traced(new Error(`resident attach: ${this.opts.resource} is not onboarded (${err2})`));
-        if (status3 >= 500 && status3 <= 599 && data.transient === true) {
+        if (isTransientRefusal(answer)) {
           return traced(
             classifyError(
               new ExecInfraError(`resident attach failed for ${this.opts.resource}: ${err2}`, "worker-unavailable"),
@@ -11052,11 +11162,13 @@ var init_resident = __esm({
        *  mechanism a re-review after a push uses, applied mid-run. The move's own
        *  attach carries the new sha; a later recovery re-attach names none (item
        *  51: the run's own pushes may move the tip). Answers the sha the worktree
-       *  is at; throws like attach() on a refusal. */
+       *  is at; throws like attach() on a refusal. The run's stop (`opts.signal`)
+       *  rides into the attach and the wake wait a transient refusal begins, so a
+       *  stopped round never sits out the wake ceiling. */
       async moveTo(sha, opts) {
         this.opts = { ...this.opts, sha };
         this.shaPending = true;
-        const binding = await this.attach(opts?.span);
+        const binding = await this.attach(opts?.span, { signal: opts?.signal });
         return { sha: binding.sha };
       }
       /** POST /detach: return this thread's pool user (and remove its worktree)
@@ -11125,10 +11237,27 @@ var init_resident = __esm({
           if (!CONTROL_RESET_REISSUE_ROUTES.has(route3) && saysControlReset(data))
             throw new ExecControlResetError(String(data.error).trim());
         };
+        let waitStarted;
+        const waitBudget = wakeWaitBudget(opts.waitBudgetMs);
+        const waitLeft = () => {
+          waitStarted ??= systemClock();
+          return Math.max(0, waitBudget - (systemClock() - waitStarted));
+        };
+        const recoveryAttachTimeoutMs = Math.max(callTimeoutMs, BASH_TIMEOUT_MS);
         let r = await this.call(route3, body, callTimeoutMs, signal2, span);
         if (isContainerRolling(r.data.error)) {
-          const woke = await this.awaitWake(route3, String(r.data.error), { signal: signal2, budgetMs: opts.waitBudgetMs, span });
-          if (route3 === "/exec") throw new ExecSandboxRestartedError(sandboxRestartedMessage(woke), woke.waitedMs);
+          const woke = await this.awaitWake(route3, String(r.data.error), {
+            origin: "container-exited",
+            signal: signal2,
+            budgetMs: waitLeft(),
+            attachTimeoutMs: callTimeoutMs,
+            span
+          });
+          if (route3 === "/exec")
+            throw new ExecSandboxRestartedError(
+              sandboxRestartedMessage({ waitedMs: woke.waitedMs, ref: woke.binding.ref, sha: woke.binding.sha }),
+              woke.waitedMs
+            );
           r = await this.call(route3, body, callTimeoutMs, signal2, span);
           if (isContainerRolling(r.data.error)) {
             throw classifyError(
@@ -11143,21 +11272,21 @@ var init_resident = __esm({
         goneUnderThread(r.data);
         controlResetUnderThread(r.data);
         if (r.data.needs === "attach") {
-          await this.attach(span);
+          await this.attach(span, { signal: signal2, budgetMs: waitLeft(), attachTimeoutMs: recoveryAttachTimeoutMs });
           r = await this.call(route3, body, callTimeoutMs, signal2, span);
           goneUnderThread(r.data);
           controlResetUnderThread(r.data);
           if (r.data.needs === "attach") throw stillGone(r.data);
         }
         if (saysControlReset(r.data)) {
-          await this.attach(span);
+          await this.attach(span, { signal: signal2, budgetMs: waitLeft(), attachTimeoutMs: recoveryAttachTimeoutMs });
           r = await this.call(route3, body, callTimeoutMs, signal2, span);
           if (saysControlReset(r.data)) throw new ExecControlResetError(String(r.data.error).trim());
           if (r.data.needs === "attach") throw stillGone(r.data);
         }
         if (r.data.reason === "runtime-replaced") {
           this.noteRuntimeReplaced(route3, r.data);
-          await this.attach(span);
+          await this.attach(span, { signal: signal2, budgetMs: waitLeft(), attachTimeoutMs: recoveryAttachTimeoutMs });
           r = await this.call(route3, body, callTimeoutMs, signal2, span);
           if (r.data.reason === "runtime-replaced") this.noteRuntimeReplaced(route3, r.data);
           if (r.data.needs === "attach") throw stillGone(r.data);
@@ -11185,13 +11314,28 @@ var init_resident = __esm({
        *  the wait going). Answers the wait and the fresh binding. Throws the
        *  strike (an `ExecInfraError` the tracker counts) when nothing is
        *  recovering, when the resident goes down mid-wait, when a re-attach does
-       *  not answer, or when the budget is spent; a hard stop rejects at once
-       *  with a plain error the runner unwinds; any other attach refusal is the
-       *  attach's own legible error. */
+       *  not answer, or when the budget is spent; a hard stop rejects at once with
+       *  the stop's one typed shape (`wakeStopped`: `aborted`, the transport) from
+       *  every stop point — the pause, the probe, the re-attach's own call; any
+       *  other attach refusal is the attach's own legible error.
+       *
+       *  A wait a TRANSIENT refusal began (`opts.transient`, or a re-attach's
+       *  transient 500 met inside it) reads an unreachable Worker differently: the
+       *  Durable Object that reset or lost its connection under the attach loses
+       *  `/status` too, so an unanswered probe is the same blip, waited through
+       *  under the budget — never the definite "nothing says the container is
+       *  coming back" a container's exit is judged by — and a wait spent with the
+       *  Worker unreachable throughout ends in `worker-unavailable`, never
+       *  `refused`. */
       async awaitWake(route3, refusal, opts) {
         const t0 = systemClock();
         const waited = () => systemClock() - t0;
-        const definite = (why) => residentWakeStrike(route3, refusal, why, "refused");
+        let transient = opts.origin === "transient-refusal";
+        const definite = (why) => residentWakeStrike(route3, refusal, why, "refused", opts.origin);
+        const decide = (view) => transient && isUnansweredProbe(view) ? {
+          wait: true,
+          why: `the resident Worker did not answer /status (${view.error}) after a transient refusal: the same blip, waited through`
+        } : wakeDecision(view);
         const probe = async () => {
           const seen2 = await _ResidentExecutor.probeStatus(
             this.opts.baseUrl,
@@ -11201,37 +11345,47 @@ var init_resident = __esm({
             opts.span,
             opts.signal
           );
-          if (opts.signal?.aborted) throw wakeStopped();
+          if (opts.signal?.aborted) throw wakeStopped(route3);
           return seen2;
         };
         let seen = await probe();
-        const decision = wakeDecision(seen);
+        const decision = decide(seen);
         if (!decision.wait) throw definite(decision.why);
         const budget = wakeWaitBudget(opts.budgetMs);
+        let firstView = true;
         for (; ; ) {
+          if (seen.kind === "status" && isServiceable(seen.state, seen.reason) && (transient || !firstView)) {
+            let answer;
+            try {
+              const bound = opts.attachTimeoutMs === void 0 ? Math.max(budget - waited(), BASH_TIMEOUT_MS) : Math.min(WAKE_WAIT_MAX_MS, Math.max(budget - waited(), opts.attachTimeoutMs));
+              answer = await this.attachOnce(opts.span, bound, opts.signal);
+            } catch (err2) {
+              if (!(err2 instanceof ExecInfraError)) throw err2;
+              if (err2.reason === "aborted") throw err2;
+              throw residentWakeStrike(
+                route3,
+                refusal,
+                `the re-attach after ${Math.round(waited() / 1e3)}s did not answer (${err2.message})`,
+                wakeStrikeReason(seen, transient),
+                opts.origin
+              );
+            }
+            if (answer.ok) return { waitedMs: waited(), binding: answer.binding };
+            if (isTransientRefusal(answer)) transient = true;
+            else if (!isContainerRolling(answer.data.error)) {
+              const refused7 = this.attachRefusal(answer);
+              if (refused7 instanceof ResidentNeedsRefError) refused7.wokeAfterMs = waited();
+              throw refused7;
+            }
+          }
+          firstView = false;
           const spent = waited();
-          if (spent >= budget) throw residentWakeBudgetStrike(route3, refusal, spent, seen);
-          await wakePause(Math.min(WAKE_POLL_MS, budget - spent), opts.signal);
+          if (spent >= budget)
+            throw residentWakeBudgetStrike(route3, refusal, spent, seen, { origin: opts.origin, transient });
+          await wakePause(Math.min(WAKE_POLL_MS, budget - spent), opts.signal, route3);
           seen = await probe();
-          const again = wakeDecision(seen);
+          const again = decide(seen);
           if (!again.wait) throw definite(again.why);
-          if (seen.kind !== "status" || !isServiceable(seen.state, seen.reason)) continue;
-          let answer;
-          try {
-            answer = await this.attachOnce(opts.span, Math.max(budget - waited(), 1e3), opts.signal);
-          } catch (err2) {
-            if (!(err2 instanceof ExecInfraError)) throw err2;
-            if (err2.reason === "aborted") throw err2;
-            throw residentWakeStrike(
-              route3,
-              refusal,
-              `the re-attach after ${Math.round(waited() / 1e3)}s did not answer (${err2.message})`,
-              wakeStrikeReason(seen)
-            );
-          }
-          if (answer.ok) return { waitedMs: waited(), ref: answer.binding.ref, sha: answer.binding.sha };
-          if (answer.data.transient === true) continue;
-          if (!isContainerRolling(answer.data.error)) throw this.attachRefusal(answer);
         }
       }
       async exec(command2, opts) {
@@ -11489,6 +11643,19 @@ async function makeExecutor(opts, ctx, span) {
     if (!token2) throw new Error(`execution.resident is configured but ${tokenEnv} is not set`);
     const resource = repoResourceId(ctx.repo);
     let probe = await probeResident(resident, token2, resource, span);
+    let probeWaitMs = 0;
+    if (probe.kind === "unreachable" && probe.transient) {
+      const through = await ResidentExecutor.probeStatusThroughBlip(
+        resident.baseUrl,
+        token2.reveal(),
+        resource,
+        resident.probeTimeoutMs ?? 2e3,
+        probe,
+        { budgetMs: FIRST_ATTACH_WAIT_MS, signal: ctx.stopSignal, span }
+      );
+      probe = through.probe;
+      probeWaitMs = through.waitedMs;
+    }
     let waitedForRestore = false;
     if (probe.kind === "status" && probe.state === "restoring") {
       const wait = await ResidentExecutor.awaitRestore(
@@ -11526,7 +11693,15 @@ async function makeExecutor(opts, ctx, span) {
             ...ctx.ownPr !== void 0 ? { ownPr: ctx.ownPr } : {}
           },
           nonWarm,
-          span
+          span,
+          // A refusal the Worker typed transient is waited through here, under
+          // what the probe's wait left of the factory's own budget and the
+          // run's stop (item 9); the card names both waits' total.
+          {
+            signal: ctx.stopSignal,
+            budgetMs: Math.max(0, FIRST_ATTACH_WAIT_MS - probeWaitMs),
+            waitedMs: probeWaitMs
+          }
         );
         return waitedForRestore ? {
           ...selection,
@@ -11534,12 +11709,14 @@ async function makeExecutor(opts, ctx, span) {
         } : selection;
       } catch (err2) {
         if (err2 instanceof ResidentNeedsRefError) throw err2;
+        if (isRunStopError(err2)) throw err2;
         failedAttach = residentTraceOf(err2);
         const wait = waitedForRestore ? " after waiting for the resident's restore" : "";
         reason2 = oneLine(`resident attach failed (${err2 instanceof Error ? err2.message : String(err2)})${wait}`);
       }
     } else if (probe.kind === "unreachable") {
-      reason2 = oneLine(`resident unreachable (${probe.error})`);
+      const waited = probeWaitMs > 0 ? ` after waiting ${Math.round(probeWaitMs / 1e3)}s` : "";
+      reason2 = oneLine(`resident unreachable (${probe.error})${waited}`);
     } else if (probe.state !== "not-onboarded") {
       const wait = waitedForRestore ? " after waiting for the resident's restore" : "";
       reason2 = oneLine(`resident ${probe.state}${probe.reason ? ` (${probe.reason})` : ""}${wait}`);
@@ -11623,10 +11800,24 @@ async function reattachWorkspace(opts, ctx, recorded, span) {
   const token2 = processSecrets.named(tokenEnv);
   if (!token2) throw new Error(`execution.resident is configured but ${tokenEnv} is not set`);
   const resource = repoResourceId(ctx.repo);
-  const probe = await probeResident(resident, token2, resource, span);
-  if (probe.kind === "unreachable") throw refuse3(`resident unreachable (${probe.error})`);
+  let probe = await probeResident(resident, token2, resource, span);
+  let probeWaitMs = 0;
+  if (probe.kind === "unreachable" && probe.transient) {
+    const through = await ResidentExecutor.probeStatusThroughBlip(
+      resident.baseUrl,
+      token2.reveal(),
+      resource,
+      resident.probeTimeoutMs ?? 2e3,
+      probe,
+      { budgetMs: FIRST_ATTACH_WAIT_MS, signal: ctx.stopSignal, span }
+    );
+    probe = through.probe;
+    probeWaitMs = through.waitedMs;
+  }
+  const waitedNote = probeWaitMs > 0 ? ` after waiting ${Math.round(probeWaitMs / 1e3)}s` : "";
+  if (probe.kind === "unreachable") throw refuse3(`resident unreachable (${probe.error})${waitedNote}`);
   if (!isServiceable(probe.state, probe.reason))
-    throw refuse3(`resident ${probe.state}${probe.reason ? ` (${probe.reason})` : ""}`);
+    throw refuse3(`resident ${probe.state}${probe.reason ? ` (${probe.reason})` : ""}${waitedNote}`);
   const nonWarm = probe.state === "warm" ? void 0 : oneLine(`${probe.state}${probe.reason ? ` (${probe.reason})` : ""}`);
   const executor = new ResidentExecutor({
     baseUrl: resident.baseUrl,
@@ -11640,8 +11831,12 @@ async function reattachWorkspace(opts, ctx, recorded, span) {
   });
   let binding;
   try {
-    binding = await executor.attach(span);
+    binding = await executor.attach(span, {
+      signal: ctx.stopSignal,
+      budgetMs: Math.max(0, FIRST_ATTACH_WAIT_MS - probeWaitMs)
+    });
   } catch (err2) {
+    if (isRunStopError(err2)) throw err2;
     throw refuse3(err2 instanceof Error ? err2.message : String(err2));
   }
   const same = (recordedValue, answered) => recordedValue === void 0 || answered === void 0 || recordedValue === answered;
@@ -11652,6 +11847,8 @@ async function reattachWorkspace(opts, ctx, recorded, span) {
     );
   }
   const where = `${resource.replace(/^repo:/, "")} \xB7 ${binding.ref}@${binding.sha.slice(0, 7)}`;
+  const wokeSeconds = Math.round((probeWaitMs + (binding.wokeAfterMs ?? 0)) / 1e3);
+  const woke = wokeSeconds > 0 ? ` \xB7 after waiting ${wokeSeconds}s for the resident` : "";
   return {
     executor,
     resident: true,
@@ -11659,21 +11856,25 @@ async function reattachWorkspace(opts, ctx, recorded, span) {
     ...binding.trace ? { trace: binding.trace } : {},
     ...binding.attachMs !== void 0 ? { attachMs: binding.attachMs } : {},
     binding,
-    note: nonWarm ? `resident ${nonWarm} \xB7 ${where} \xB7 re-attached to the run's worktree` : `resident \xB7 ${where} \xB7 re-attached to the run's worktree`
+    note: nonWarm ? `resident ${nonWarm} \xB7 ${where} \xB7 re-attached to the run's worktree${woke}` : `resident \xB7 ${where} \xB7 re-attached to the run's worktree${woke}`
   };
 }
-async function openResident(opts, nonWarm, span) {
+async function openResident(opts, nonWarm, span, wait = {}) {
   let executor = new ResidentExecutor(opts);
   let binding;
   let byDefault = false;
   try {
-    binding = await executor.attach(span);
+    binding = await executor.attach(span, wait);
   } catch (err2) {
     if (!(err2 instanceof ResidentNeedsRefError) || !err2.defaultRef) throw err2;
     byDefault = true;
+    const firstWaitMs = err2.wokeAfterMs ?? 0;
+    const budgetLeft = wait.budgetMs === void 0 ? void 0 : Math.max(0, wait.budgetMs - firstWaitMs);
     executor = new ResidentExecutor({ ...opts, refHint: err2.defaultRef, refByDefault: true });
     try {
-      binding = await executor.attach(span);
+      binding = await executor.attach(span, { ...wait, budgetMs: budgetLeft });
+      const totalWaitMs = firstWaitMs + (binding.wokeAfterMs ?? 0);
+      if (totalWaitMs > 0) binding = { ...binding, wokeAfterMs: totalWaitMs };
     } catch (again) {
       if (again instanceof ResidentNeedsRefError) {
         throw new Error(
@@ -11687,6 +11888,8 @@ async function openResident(opts, nonWarm, span) {
   const where = `${opts.resource.replace(/^repo:/, "")} \xB7 ${binding.ref}@${binding.sha.slice(0, 7)}`;
   const why = byDefault ? " (repo default \u2014 no branch named)" : "";
   const moved = rebindLabel(binding);
+  const wokeSeconds = Math.round(((wait.waitedMs ?? 0) + (binding.wokeAfterMs ?? 0)) / 1e3);
+  const woke = wokeSeconds > 0 ? ` \xB7 after waiting ${wokeSeconds}s for the resident` : "";
   return {
     executor,
     resident: true,
@@ -11694,7 +11897,7 @@ async function openResident(opts, nonWarm, span) {
     ...binding.trace ? { trace: binding.trace } : {},
     ...binding.attachMs !== void 0 ? { attachMs: binding.attachMs } : {},
     binding,
-    note: nonWarm ? `resident ${nonWarm} \xB7 ${where}${why}${moved} \u2014 attached to the last snapshot` : `resident \xB7 ${where}${why}${moved}`
+    note: nonWarm ? `resident ${nonWarm} \xB7 ${where}${why}${moved} \u2014 attached to the last snapshot${woke}` : `resident \xB7 ${where}${why}${moved}${woke}`
   };
 }
 function rebindLabel(binding) {
@@ -11829,6 +12032,7 @@ var BACKENDS, WorkspaceReattachRefusedError, PROBE_OUTAGE_WINDOW_MS, AWAIT_RESTO
 var init_factory = __esm({
   "../../src/execution/factory.ts"() {
     "use strict";
+    init_budgets();
     init_redact();
     init_residentTrace();
     init_executor();
@@ -14707,6 +14911,19 @@ function pushedBranchesOf(events) {
   }
   return [...byRef].map(([ref, pr]) => ({ ref, pr }));
 }
+function callsInFlight(events, status3) {
+  const calls = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.type === "tool_call" && e.callId !== void 0) {
+      if (calls.get(e.callId)?.state !== "cut") calls.set(e.callId, { call: e, state: "open" });
+    } else if (e.type === "tool_result" && e.callId !== void 0) {
+      const seen = calls.get(e.callId);
+      if (seen !== void 0 && seen.state !== "cut") seen.state = e.cut === true ? "cut" : "settled";
+    }
+  }
+  const orderly = status3 === "completed" || status3 === "stopped_soft";
+  return [...calls.values()].filter((c) => c.state === "cut" || c.state === "open" && !orderly).map((c) => c.call);
+}
 function routeOfEvents(events) {
   const meta = events.find((e) => e.type === "run_meta");
   if (meta?.type !== "run_meta" || meta.agentSource !== "route") return void 0;
@@ -16354,6 +16571,22 @@ var init_runDuration = __esm({
   }
 });
 
+// ../../src/core/authz/viewAs.ts
+function holdsAll(actor) {
+  return actor.grants.actions === "all" && actor.grants.channels === "all" && actor.grants.repos === "all";
+}
+function isViewablePerson(id) {
+  return /^slack:U[A-Z0-9]+$/.test(id);
+}
+function viewingRefusal(person) {
+  return `You are viewing as ${person.name ?? person.id}; writes are your own to make \u2014 exit view-as to write.`;
+}
+var init_viewAs = __esm({
+  "../../src/core/authz/viewAs.ts"() {
+    "use strict";
+  }
+});
+
 // ../../src/mcp/config.ts
 function parseMcpSettings(raw) {
   if (raw === void 0 || raw === null) return void 0;
@@ -16661,6 +16894,7 @@ var init_commandRegistry = __esm({
     init_clock();
     init_formatDuration();
     init_authorize();
+    init_viewAs();
     init_capabilities();
     init_untrusted();
     COMMAND_ID = /^[a-z][a-z0-9]*\.[a-z][a-z0-9]*$/;
@@ -16753,6 +16987,7 @@ var init_commandRegistry = __esm({
             callerKind: caller.kind,
             callerId: caller.id,
             ...caller.actor.asUser ? { asUser: caller.actor.asUser.id } : {},
+            ...caller.actor.viewingAs ? { viewingAs: caller.actor.viewingAs.id } : {},
             effect: cmd.effect,
             outcome: res.ok ? "ok" : res.error,
             ...reason2 === void 0 ? {} : { reason: reason2 },
@@ -16760,6 +16995,8 @@ var init_commandRegistry = __esm({
           });
           return res;
         };
+        if (caller.actor.viewingAs && cmd.effect !== "read")
+          return done(fail("unauthorized", viewingRefusal(caller.actor.viewingAs)), "viewing");
         const decision = authorize(caller.actor, cmd.action, resourceOf(cmd, input, caller));
         if (!decision.allow)
           return done(fail("unauthorized", `${caller.id} is not allowed to run ${cmd.id}`), decision.reason);
@@ -17119,8 +17356,10 @@ var init_config4 = __esm({
           `per-agent harness: --harness.<agent> ${harnessWords2} \u2014 which process drives that agent's runs (under me, your own runs only)`
         ),
         boundary: boundaryOption,
-        ship: z6.object({
-          addressSeverity: z6.enum(ADDRESS_SEVERITIES).optional().describe("the severity agent:ship addresses before an approve stands (--ship.addressSeverity <level>)")
+        review: z6.object({
+          addressSeverity: z6.enum(ADDRESS_SEVERITIES).optional().describe(
+            "the severity to address: a review's approve carrying a finding at or above it is a request_changes, and ship's rounds are held to it (--review.addressSeverity <level>)"
+          )
         }).optional(),
         channel: channelOption
       }),
@@ -17159,7 +17398,8 @@ var init_config4 = __esm({
         if (options.effort !== void 0) patch.effort = options.effort;
         if (options.efforts) patch.efforts = options.efforts;
         if (options.harness) patch.harness = options.harness;
-        if (options.ship?.addressSeverity !== void 0) patch.ship = { addressSeverity: options.ship.addressSeverity };
+        if (options.review?.addressSeverity !== void 0)
+          patch.review = { addressSeverity: options.review.addressSeverity };
         if (options.boundary) {
           const { machines, ...fields } = options.boundary;
           const raw = { ...fields };
@@ -19520,7 +19760,7 @@ var init_help = __esm({
     init_docsLink();
     defineCommand10 = commandDefiner();
     COMMANDS_REFERENCE_URL = `${PROJECT_DOCS_URL}/reference/slack-commands`;
-    DIRECTIVES_HELP = "`agent:review model:anthropic/claude-opus-5 effort:low budget:20 look at PR 42` (effort: low | medium | high \u2014 lower = faster turns; budget: whole minutes, at least 2 \u2014 narrows this run's wall clock, never widens it)";
+    DIRECTIVES_HELP = "`agent:review model:anthropic/claude-opus-5 effort:low budget:20 look at PR 42` (effort: low | medium | high \u2014 lower = faster turns; budget: whole minutes \u2014 narrows this run's wall clock, never widens it; a budget too short for a turn plus the write-up is refused by name)";
     helpShow = defineCommand10({
       id: "help.show",
       action: "help:read",
@@ -23029,7 +23269,10 @@ function defineOp(op) {
             `\`${args.slug}\` is not onboarded as a resident, so \`repo ${op}\` has nothing to run against \u2014 \`repo onboard ${args.slug}\` first, or ask the coding agent directly.`
           );
         case "error":
-          throw new CommandError("unavailable", result.message);
+          throw new CommandError(
+            "unavailable",
+            result.transient === true ? `${result.message} \u2014 the resident was unavailable for a moment; re-run the command` : result.message
+          );
       }
     }
   });
@@ -27585,10 +27828,10 @@ async function closeRestartRow(adopted, restart, why) {
     );
   }
 }
-async function closeResumedRow(adopted, resume, why) {
+async function closeResumedRow(adopted, resume, why, status3 = "interrupted") {
   try {
     await adopted.sink.put(
-      reclaimedRunRecord({ row: resume.row, events: resume.events, status: "interrupted", finishedAt: systemClock() })
+      reclaimedRunRecord({ row: resume.row, events: resume.events, status: status3, finishedAt: systemClock() })
     );
   } catch (err2) {
     console.warn(
@@ -31527,6 +31770,12 @@ function capped2(base, max) {
     if (n2 > max) ctx.addIssue({ code: z21.ZodIssueCode.custom, message: `at most ${max} visible characters (got ${n2})` });
   });
 }
+function cappedRaw(base, max) {
+  return base.superRefine((s, ctx) => {
+    const n2 = s.length;
+    if (n2 > max) ctx.addIssue({ code: z21.ZodIssueCode.custom, message: `at most ${max} characters (got ${n2})` });
+  });
+}
 function boundedArray(item, min, max, what) {
   return z21.array(item).superRefine((arr, ctx) => {
     if (arr.length < min)
@@ -31933,6 +32182,10 @@ var init_prDescription = __esm({
     "use strict";
     init_redact();
     PR_DESCRIPTION_CAPS = {
+      /** The squash subject and the changelog line, the whole line counted: the
+       *  number the title gate (`scripts/check-pr-title.mjs`, `TITLE_MAX_LENGTH`)
+       *  holds it to; a test keeps the two equal. */
+      title: 72,
       tldr: 300,
       why: 400,
       pointers: 7,
@@ -31971,8 +32224,9 @@ var init_prDescription = __esm({
     });
     PrDescriptionSchema = z21.object({
       /** The PR title's single source. Metadata for the PR's own title field —
-       *  never rendered into the body (GitHub shows the title itself). */
-      title: line2,
+       *  never rendered into the body (GitHub shows the title itself) — and the
+       *  squash subject, so it is capped like every other field. */
+      title: cappedRaw(line2, PR_DESCRIPTION_CAPS.title),
       tldr: capped2(prose, PR_DESCRIPTION_CAPS.tldr),
       why: capped2(prose, PR_DESCRIPTION_CAPS.why),
       pointers: boundedArray(PointerSchema, 1, PR_DESCRIPTION_CAPS.pointers, "pointers"),
@@ -32054,7 +32308,7 @@ var init_submit = __esm({
     submitVerdictTool = {
       name: "submit_verdict",
       failsInText: true,
-      description: "Record your review verdict. REQUIRED before your final message when reviewing a PR: `approve` when there are no blocking issues (nits alone are not blocking), `request_changes` otherwise. Switchboard writes the verdict as the first line of the GitHub comment itself (`LGTM:` only for approve); a review with no submitted verdict is posted as NOT approving. Call it once, after your analysis; a later call replaces the earlier one. `head` is the commit you reviewed \u2014 run `git rev-parse HEAD` in the checkout you read and tested and pass its output; Switchboard posts to the PR only if that commit IS the PR's head, so a review of the wrong branch can never land on a PR. Enumerate EVERY issue you report in `findings` with STABLE ids assigned in order (F1, F2, \u2026) \u2014 a fix round references findings by these ids, so never renumber them. Severity is exactly one of blocking|major|minor|nit; the entry carries the file (plus line when it points at one) and a one-line title, while the full explanation stays in your review text keyed by the same ids. An `approve` carrying a `blocking` finding is downgraded to `request_changes` \u2014 approve only when nothing blocking remains.",
+      description: "Record your review verdict. REQUIRED before your final message when reviewing a PR: `approve` when no finding at or above the severity to address remains (the level in force for this run, `minor` by default: a major or minor finding means `request_changes`; nits alone never block), `request_changes` otherwise. Switchboard writes the verdict as the first line of the GitHub comment itself (`LGTM:` only for approve); a review with no submitted verdict is posted as NOT approving. Call it once, after your analysis; a later call replaces the earlier one. `head` is the commit you reviewed \u2014 run `git rev-parse HEAD` in the checkout you read and tested and pass its output; Switchboard posts to the PR only if that commit IS the PR's head, so a review of the wrong branch can never land on a PR. Enumerate EVERY issue you report in `findings` with STABLE ids assigned in order (F1, F2, \u2026) \u2014 a fix round references findings by these ids, so never renumber them. Severity is exactly one of blocking|major|minor|nit; the entry carries the file (plus line when it points at one) and a one-line title, while the full explanation stays in your review text keyed by the same ids. An `approve` carrying a finding at or above the severity to address is downgraded to `request_changes` and the ack names the finding and the level \u2014 approve only when every finding sits below it.",
       inputSchema: {
         type: "object",
         properties: {
@@ -32093,10 +32347,13 @@ var init_submit = __esm({
         required: ["verdict", "summary", "head"]
       },
       async run(input, ctx) {
-        const verdict = parseVerdictInput(input);
+        const verdict = parseVerdictInput(input, {
+          ...ctx.addressSeverity !== void 0 ? { addressSeverity: ctx.addressSeverity } : {}
+        });
         if (!verdict) return "error: verdict must be exactly `approve` or `request_changes`";
         ctx.onVerdict?.(verdict);
         const notes = [];
+        if (verdict.downgraded) notes.push(`downgraded from approve: ${downgradeNote(verdict.downgraded)}`);
         if (verdict.findings) notes.push(`${verdict.findings.length} finding${verdict.findings.length === 1 ? "" : "s"}`);
         if (verdict.droppedFindings?.length) notes.push(`dropped: ${verdict.droppedFindings.join("; ")}`);
         return notes.length ? `verdict recorded: ${verdict.verdict} (${notes.join("; ")})` : `verdict recorded: ${verdict.verdict}`;
@@ -32141,7 +32398,10 @@ var init_submit = __esm({
       inputSchema: {
         type: "object",
         properties: {
-          title: { type: "string", description: "The PR title \u2014 one line naming the change" },
+          title: {
+            type: "string",
+            description: "The PR title \u2014 one line naming the change, `type(scope): what a reader can now do or expect`, at most 72 characters in all"
+          },
           tldr: {
             type: "string",
             description: "Two sentences for a reader with zero context: what this PR does and why it matters (\u2264300 visible chars)"
@@ -33597,7 +33857,7 @@ function parseDirectives(input) {
     } else if (f.key === "severity") {
       if (!isAddressSeverity(f.value)) {
         throw new Error(
-          `Unknown severity "${f.value}". severity:<level> takes one of ${ADDRESS_SEVERITIES.join(", ")} \u2014 the level agent:ship addresses before an approve stands.`
+          `Unknown severity "${f.value}". severity:<level> takes one of ${ADDRESS_SEVERITIES.join(", ")} \u2014 the severity to address: a review's approve carrying a finding at or above it is a request_changes.`
         );
       }
       out.severity = f.value;
@@ -33693,7 +33953,12 @@ function resolveProfile(ctx) {
   const carried = ctx.resume?.row.meta.profile;
   const declared = carried ? { machine: carried.machine, identity: carried.identity, maxMinutes: carried.minutes } : ctx.agent;
   const boundary = ctx.parentRemainingMs !== void 0 ? boundedByParent(ctx.resolved.boundary, ctx.parentRemainingMs) : ctx.resolved.boundary;
-  const resolution = effectiveProfile(declared, ctx.budget !== void 0 ? { budget: ctx.budget } : {}, boundary);
+  const resolution = effectiveProfile(
+    declared,
+    ctx.budget !== void 0 ? { budget: ctx.budget } : {},
+    boundary,
+    leaseMinimum(ctx.agent.name)
+  );
   if (resolution.kind === "profile" && carried?.boundedBy && !resolution.profile.boundedBy) {
     return { kind: "profile", profile: { ...resolution.profile, boundedBy: carried.boundedBy } };
   }
@@ -33730,6 +33995,7 @@ function repoVetFor(profile, resident) {
 var init_resolve = __esm({
   "../../src/core/dispatch/resolve.ts"() {
     "use strict";
+    init_budgets();
     init_registry();
     init_profile();
     init_directives();
@@ -33953,7 +34219,7 @@ var init_digestCoverage = __esm({
 
 // ../../src/core/reviewRound.ts
 function releaseModeFor(identity2, opts) {
-  return identity2 === "read" || opts.hardStopped ? "always" : "if-idle";
+  return identity2 === "read" || opts.hardStopped || opts.commandInFlight === true || opts.gateBypassed === true ? "always" : "if-idle";
 }
 async function attachRoundWorkspace(input) {
   const { agent, profile } = input.round;
@@ -33967,7 +34233,8 @@ async function attachRoundWorkspace(input) {
       ref: input.round.ref,
       headSha: input.round.headSha,
       ...input.round.ownPr !== void 0 ? { ownPr: input.round.ownPr } : {},
-      ...input.round.reattach !== void 0 ? { reattach: input.round.reattach } : {}
+      ...input.round.reattach !== void 0 ? { reattach: input.round.reattach } : {},
+      ...input.round.stopSignal !== void 0 ? { stopSignal: input.round.stopSignal } : {}
     },
     input.span
   );
@@ -34109,7 +34376,8 @@ async function settle(input, span) {
         let worktreeMoved = false;
         if (executor.moveTo) {
           try {
-            const at = normalizeHead((await executor.moveTo(current, trace)).sha);
+            const moved = await executor.moveTo(current, { ...trace, signal: turn.control.hardSignal });
+            const at = normalizeHead(moved.sha);
             worktreeMoved = at !== void 0 && sameCommit(at, current);
             console.log(
               `[review] ${logKey} worktree moved to ${at?.slice(0, 7) ?? "?"}${worktreeMoved ? "" : " (not the expected head)"}`
@@ -34313,7 +34581,14 @@ async function authorizeProfile(deps, ctx) {
   return { kind: "refused", reason: "profile_bounded" };
 }
 function refusalSummary(refusal) {
-  return refusal.axis === "identity" ? `identity ${refusal.needs} > ${refusal.cap} (${refusal.scope})` : `machine ${refusal.needs} not in ${refusal.allowed.join(",")} (${refusal.scopes.join(",")})`;
+  switch (refusal.axis) {
+    case "identity":
+      return `identity ${refusal.needs} > ${refusal.cap} (${refusal.scope})`;
+    case "machine":
+      return `machine ${refusal.needs} not in ${refusal.allowed.join(",")} (${refusal.scopes.join(",")})`;
+    case "minutes":
+      return `minutes ${refusal.have} < ${refusal.needs} (${refusal.scope})`;
+  }
 }
 function boundaryOf(scope) {
   switch (scope) {
@@ -34340,7 +34615,21 @@ function wayForward(scope, axis, needs, adminsHint) {
     case "directive":
       return "send the message again without the budget directive";
     case "parent":
-      return "spawn it from a run with more time left";
+      return `spawn it from a run with at least ${needs} left`;
+  }
+}
+function minutesWayForward(scope, needs, adminsHint) {
+  switch (scope) {
+    case "directive":
+      return `send the message again with \`budget:${needs}\` or more`;
+    case "user":
+      return `raise your own boundary with \`config set me --boundary.maxMinutes ${needs}\`, or drop your overrides with \`config clear me\``;
+    case "channel":
+      return `run it in a channel whose boundary allows ${needs} minutes, or ask ${adminsHint} to raise this channel's boundary`;
+    case "defaults":
+      return `ask ${adminsHint} to raise \`defaults.boundary\` in the configuration`;
+    case "parent":
+      return `spawn it from a run with at least ${needs} minutes left`;
   }
 }
 function profileRefusalReply(agentName, refusal, adminsHint) {
@@ -34349,6 +34638,10 @@ function profileRefusalReply(agentName, refusal, adminsHint) {
     const how2 = wayForward(refusal.scope, "maxIdentity", refusal.needs, adminsHint);
     return `\u{1F6AB} \`${agentName}\` needs a \`${refusal.needs}\` credential; ${boundaryOf(refusal.scope)} caps runs at \`${refusal.cap}\`. ${capitalize(how2)}.`;
   }
+  if (refusal.axis === "minutes") {
+    const how2 = minutesWayForward(refusal.scope, refusal.needs, adminsHint);
+    return `\u{1F6AB} \`${agentName}\` needs at least ${refusal.needs} minutes \u2014 a turn, then its write-up and post-step \u2014 and ${boundaryOf(refusal.scope)} gives it ${refusal.have}. ${capitalize(how2)}.`;
+  }
   const scopes = refusal.scopes.map(boundaryOf);
   const who2 = scopes.length > 1 ? `${scopes.join(" and ")} allow` : `${scopes[0] ?? "the boundary"} allows`;
   const allowed2 = refusal.allowed.map((m) => `\`${m}\``).join(", ");
@@ -35225,7 +35518,7 @@ async function reserveRun(deps, ctx) {
   return void 0;
 }
 async function attachRound(deps, ctx) {
-  const { threadKey, agent, profile, repoCtx, root, clock: clock4, reattach } = ctx;
+  const { threadKey, agent, profile, repoCtx, root, clock: clock4, reattach, stopSignal } = ctx;
   const ownPr = ownPrOf(repoCtx);
   return root.span("dispatch.workspace.attach", async (span) => {
     const graft = (steps, residentTotalMs) => graftResidentSteps(steps, {
@@ -35253,7 +35546,8 @@ async function attachRound(deps, ctx) {
           // The thread's own pull request, when the ref is its head (resident-
           // repos item 16): the one reason the resident may move a binding.
           ...ownPr !== void 0 ? { ownPr } : {},
-          ...reattach !== void 0 ? { reattach } : {}
+          ...reattach !== void 0 ? { reattach } : {},
+          ...stopSignal !== void 0 ? { stopSignal } : {}
         },
         logKey: threadKey,
         span
@@ -35273,11 +35567,12 @@ async function reattachWorkspace2(deps, ctx) {
     return { kind: "attached", round: await attachRound(deps, ctx) };
   } catch (err2) {
     if (err2 instanceof WorkspaceReattachRefusedError) return { kind: "reattach_refused", why: err2.why };
+    if (isRunStopError(err2)) return { kind: "stopped" };
     throw err2;
   }
 }
 async function attachWorkspace(deps, ctx) {
-  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock4, agent, profile, repoCtx, root, reattach } = ctx;
+  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock4, agent, profile, repoCtx, root, reattach, stopSignal } = ctx;
   let round2;
   try {
     round2 = await attachRound(deps, {
@@ -35287,7 +35582,8 @@ async function attachWorkspace(deps, ctx) {
       repoCtx,
       root,
       clock: clock4,
-      ...reattach !== void 0 ? { reattach } : {}
+      ...reattach !== void 0 ? { reattach } : {},
+      ...stopSignal !== void 0 ? { stopSignal } : {}
     });
   } catch (err2) {
     if (err2 instanceof ResidentNeedsRefError) {
@@ -35303,6 +35599,7 @@ async function attachWorkspace(deps, ctx) {
       return { kind: "refused", reason: "which_branch" };
     }
     if (err2 instanceof WorkspaceReattachRefusedError) return { kind: "reattach_refused", why: err2.why };
+    if (isRunStopError(err2)) return { kind: "stopped" };
     throw err2;
   }
   return { kind: "attached", round: round2 };
@@ -35449,6 +35746,7 @@ var init_provision = __esm({
     init_actor();
     init_profile();
     init_factory();
+    init_executor();
     init_residentTrace();
     init_resident();
     init_memory();
@@ -35679,7 +35977,7 @@ function openThroughSeam(harness, deps, run2) {
   }
   return harness.open(deps, run2);
 }
-var isRecord4, relaunchesOf, isPiFacts, HarnessInterruptedError, HarnessMismatchError, RELAUNCH_CEILING, HarnessContainerReplacedError;
+var isRecord4, relaunchesOf, isPiFacts, HarnessInterruptedError, HarnessMismatchError, HarnessGateBypassedError, RELAUNCH_CEILING, HarnessContainerReplacedError;
 var init_contract4 = __esm({
   "../../src/core/harness/contract.ts"() {
     "use strict";
@@ -35710,6 +36008,12 @@ var init_contract4 = __esm({
       expected;
       found;
     };
+    HarnessGateBypassedError = class extends Error {
+      constructor(message4) {
+        super(message4);
+        this.name = "HarnessGateBypassedError";
+      }
+    };
     RELAUNCH_CEILING = 2;
     HarnessContainerReplacedError = class extends HarnessInterruptedError {
       constructor(message4, said2, was, now, record2, condition = "word") {
@@ -35766,8 +36070,10 @@ async function prepareRelaunch(deps, ctx) {
       repoCtx: ctx.repoCtx,
       root: ctx.root,
       clock: ctx.clock,
-      reattach: ctx.binding
+      reattach: ctx.binding,
+      ...ctx.stopSignal !== void 0 ? { stopSignal: ctx.stopSignal } : {}
     });
+    if (reattached.kind === "stopped") return { kind: "stopped" };
     if (reattached.kind === "reattach_refused")
       return refuse3(
         `the run's workspace could not be re-attached in the replacement container (${reattached.why}); the run restarts from its request as a new run in this thread`,
@@ -35976,9 +36282,25 @@ async function identityOrNothing(container) {
 function saysContainerDown(err2) {
   return err2 instanceof Error && !isContainerGone(err2) && !RUNTIME_WORD.test(err2.message) && CONTAINER_DOWN_WORDING.test(err2.message);
 }
+function* selfAndCauses(err2) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let e = err2; e !== void 0 && e !== null && !seen.has(e); e = e.cause) {
+    seen.add(e);
+    yield e;
+  }
+}
+function infraErrorOf(err2) {
+  for (const e of selfAndCauses(err2)) if (e instanceof ExecInfraError) return e;
+  return void 0;
+}
 function saysTransportLost(err2) {
   if (!(err2 instanceof Error) || isContainerGone(err2) || RUNTIME_WORD.test(err2.message)) return false;
   if (err2 instanceof HarnessControlFileLostError) return false;
+  const typed = infraErrorOf(err2);
+  if (typed !== void 0) {
+    if (infraMayClear(typed)) return true;
+    if (typed.reason !== "answered") return false;
+  }
   return err2 instanceof HarnessContainerDownError || CONTAINER_DOWN_WORDING.test(err2.message);
 }
 function isControlReset(err2) {
@@ -36141,7 +36463,7 @@ var init_container = __esm({
       }
     };
     CONTAINER_DOWN_WORDING = new RegExp(
-      `${STOPPED_CONTAINER_WORDING.source}|${CONTAINER_GONE_WORDING.source}|peer closed websocket|without sending close frame|\\bECONNRESET\\b|connection reset|socket hang up`,
+      `${STOPPED_CONTAINER_WORDING.source}|${CONTAINER_GONE_WORDING.source}|peer closed websocket|without sending close frame|\\bECONNRESET\\b|connection reset|socket hang up|network connection lost`,
       "i"
     );
     HarnessContainerDownError = class extends HarnessContainerError {
@@ -36683,7 +37005,7 @@ function elapsedMinutes(ms) {
   if (minutes < 1) return "under a minute";
   return `${minutes} minute${minutes === 1 ? "" : "s"}`;
 }
-var HARD_STOP_MESSAGE, CONTINUE_PROMPT, wrapUpNote, wrapUpInstruction, WRITE_UP_REQUEST, timeBudgetInstruction, turnGuardInstruction, SOFT_STOP_INSTRUCTION, turnGuardPace, MODEL_CALL_IN_FLIGHT, timeBudgetNote, turnGuardNote, softStopNote, hardStopNote, windDownFailureNote, finaleTimedOutNote, wrapUpUndeliveredNote, wrapUpWriteFailedNote, wrapUpName, finaleAbortReason, noWriteUp, timeBudgetAnswer, turnGuardAnswer, softStopAnswer;
+var HARD_STOP_MESSAGE, CONTINUE_PROMPT, wrapUpNote, wrapUpInstruction, WRITE_UP_REQUEST, timeBudgetInstruction, turnGuardInstruction, SOFT_STOP_INSTRUCTION, turnGuardPace, MODEL_CALL_IN_FLIGHT, timeBudgetNote, toolCutNote, turnGuardNote, softStopNote, hardStopNote, windDownFailureNote, finaleTimedOutNote, wrapUpUndeliveredNote, wrapUpWriteFailedNote, wrapUpName, finaleAbortReason, noWriteUp, timeBudgetAnswer, turnGuardAnswer, softStopAnswer;
 var init_windDown = __esm({
   "../../src/core/harness/windDown.ts"() {
     "use strict";
@@ -36698,6 +37020,7 @@ var init_windDown = __esm({
     turnGuardPace = (turns, elapsedMs) => `${turns} model turn${turns === 1 ? "" : "s"} in ${elapsedMinutes(elapsedMs)}`;
     MODEL_CALL_IN_FLIGHT = "a model call was in flight";
     timeBudgetNote = (doing) => doing ? `the loop's time is up while ${doing} \u2014 writing up findings so far inside the lease` : "the loop's time is up \u2014 writing up findings so far inside the lease";
+    toolCutNote = (doing) => `the loop's end cut the command in flight (${doing}) so the write-up keeps its allowance`;
     turnGuardNote = (pace) => `turn guard fired: ${pace}, a pace that looks like a loop \u2014 writing up findings so far`;
     softStopNote = () => "soft stop \u2014 no further steps, writing up findings so far";
     hardStopNote = () => "hard stop \u2014 run aborted, no summary written";
@@ -37205,6 +37528,10 @@ var init_bridge2 = __esm({
       /** The calls under way: their span, their tool, and whether their end is
        *  judged against the gate (harness-pi item 7). */
       openTools = /* @__PURE__ */ new Map();
+      /** The open calls an abort was sent for (`markOpenCallsCut`): their end, when
+       *  pi answers it, is the abort's cut and not a settle — the result is marked
+       *  `cut`, and the workspace's release reads the command as one that may run on. */
+      cutCalls = /* @__PURE__ */ new Set();
       /** The calls the gate saw — the extension asked `/harness/authorize` for
        *  them (`gateSaw`) — not yet ended. */
       vetted = /* @__PURE__ */ new Set();
@@ -37364,6 +37691,7 @@ var init_bridge2 = __esm({
         const callId = str5(event.toolCallId);
         const open2 = this.openTools.get(callId);
         this.openTools.delete(callId);
+        const cut = this.cutCalls.delete(callId);
         const tool = open2?.tool ?? str5(event.toolName);
         const isError = event.isError === true;
         const text = piResultText(event.result);
@@ -37376,7 +37704,8 @@ var init_bridge2 = __esm({
           callId,
           ...exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {},
           ...prepareToolResult(text),
-          ...open2?.span ? { spanId: open2.span.id } : {}
+          ...open2?.span ? { spanId: open2.span.id } : {},
+          ...cut ? { cut: true } : {}
         });
         open2?.span?.end(ok2 ? "ok" : "error", {
           callId,
@@ -37452,17 +37781,35 @@ var init_bridge2 = __esm({
         if (open2.length > 0) return `running ${open2.join(", ")}`;
         return this.modelCallOpen ? MODEL_CALL_IN_FLIGHT : void 0;
       }
+      /** An abort is being sent to pi: every call open now is cut by it, not
+       *  settled — its end, when pi answers, lands marked `cut` (harness.md item 13:
+       *  the command behind it may run on, and the workspace's release reads it so). */
+      markOpenCallsCut() {
+        for (const callId of this.openTools.keys()) this.cutCalls.add(callId);
+      }
       /** End whatever tool spans a stopped pi left open, so no span outlives the
        *  run; `reason` is each call's result summary — one for all, or the note
        *  each call is settled with (harness-pi item 16: the restart note, said of
-       *  the container). */
-      closeOpenSpans(reason2) {
+       *  the container). `cut` marks each result when the caller is the session's
+       *  end, where pi is gone but its tree persists and a relayed command may run
+       *  on — the workspace's release reads it as in flight (harness.md item 13);
+       *  the container-replaced verdict leaves it unmarked, the old container's
+       *  calls gone and the relayed ones taken over by the relaunch. */
+      closeOpenSpans(reason2, opts = {}) {
         for (const [callId, open2] of this.openTools) {
           open2.span?.end("error", { callId, ok: false });
           const summary = typeof reason2 === "string" ? reason2 : reason2({ callId, tool: open2.tool });
-          this.emit({ type: "tool_result", tool: open2.tool, ok: false, callId, summary: redactAndCap(summary) });
+          this.emit({
+            type: "tool_result",
+            tool: open2.tool,
+            ok: false,
+            callId,
+            summary: redactAndCap(summary),
+            ...opts.cut ? { cut: true } : {}
+          });
         }
         this.openTools.clear();
+        this.cutCalls.clear();
         this.vetted.clear();
       }
     };
@@ -37529,54 +37876,48 @@ var init_transport = __esm({
       send(command2) {
         void this.write(command2);
       }
-      /** Send, and say how the write came out once the chain reaches it (harness-pi
-       *  item 16): `landed` on pi's FIFO; `failed` — the reset's, the command kept
-       *  as `pendingSend` for the re-attach to resolve; `held` — never attempted
-       *  here, kept for `takeUnsent` and the fresh transport. What the gate's
-       *  `onLanded` waits on: a clock stamped at the landing (the finale's) starts
-       *  when pi has the steer, not when a chain that only held it was handed it. */
+      /** Send, and say how the write came out once the chain reaches it (`Landing`,
+       *  harness-pi item 16). What the gate's `onLanded` waits on: a clock stamped
+       *  at the landing (the finale's) starts when pi has the steer, not when a
+       *  chain that only held it was handed it. A write to a closed transport is
+       *  `dropped`: nothing keeps it, so nothing will re-send it.
+       *
+       *  An abort takes the same step with three differences (the one way in: the
+       *  gate passes it by type, `HeldSends.send`). It is never queued, so no
+       *  re-attach can replay it from `takeUnsent`; a spent chain does not stop it
+       *  — the reset that failed a prompt a moment after the abort was asked for
+       *  must not swallow the stop, and a teardown's abort still reaches pi past
+       *  an earlier failure; and its own failure is nobody's — the transport is
+       *  being left and the process ended by `kill`. Behind whatever is in flight,
+       *  never a second writer: a line is a separate exec into the FIFO and a line
+       *  over PIPE_BUF is several `write(2)`s. On a transport abandoned to a
+       *  re-attach by the time its step runs it is `dropped`, not held: never
+       *  queued, nothing re-sends it, and its sender is told — the pi harness
+       *  notes a dropped abort as its own error, so a stop swallowed there is
+       *  seen, never assumed. Nothing chains one there today: every abort's
+       *  sender in the pi harness is the loop or the turn, both suspended in the
+       *  recovery that abandons, and the OpenCode bridge never writes on its
+       *  transport. */
       write(command2) {
-        if (this.closed) return Promise.resolve("held");
-        if (command2.type === "abort") {
-          this.sendAbort();
-          return this.sending.then(() => "landed");
-        }
+        if (this.closed) return Promise.resolve("dropped");
+        const abort = command2.type === "abort";
         const line3 = JSON.stringify(command2);
-        this.queued.push(command2);
+        if (!abort) this.queued.push(command2);
         const step = this.sending.then(() => {
-          if (this.sendError !== void 0 || this.heldForReattach) return "held";
-          this.queued.shift();
+          if (this.heldForReattach) return abort ? "dropped" : "held";
+          if (!abort && this.sendError !== void 0) return "held";
+          if (!abort) this.queued.shift();
           return this.deps.container.writeLine(this.deps.paths, line3).then(() => "landed");
         }).catch((err2) => {
-          this.sendError ??= err2 instanceof Error ? err2 : new Error(String(err2));
-          this.pendingSend ??= command2;
+          if (!abort) {
+            this.sendError ??= err2 instanceof Error ? err2 : new Error(String(err2));
+            this.pendingSend ??= command2;
+          }
           return "failed";
         });
         this.sending = step.then(() => void 0);
         return step;
       }
-      /** The abort — a hard stop's, the finale's, a gate bypass's — the one write
-       *  that never waits for the gate and never waits for a re-attach (harness-pi
-       *  item 16): ONE step on the transport's chain that a spent chain does not
-       *  stop. Nothing in flight — an idle chain, or one a failure already spent —
-       *  and the step runs at once: that is the direct write. A write in flight or
-       *  queued on a live chain, and the abort follows it: whichever prompt the
-       *  stop was asked for during, pi has the prompt first and the abort after,
-       *  never an idle session aborted and then handed the prompt to run unwatched.
-       *  Never two writers: a line is a separate exec into the FIFO and a line over
-       *  PIPE_BUF is several `write(2)`s, so a direct write beside an in-flight one
-       *  could land inside pi's line and cost both. The step writes even when the
-       *  write before it spent the chain (the reset that failed a prompt a moment
-       *  after the abort was asked for must not swallow the stop), and skips only
-       *  on a transport abandoned to a re-attach — its fresh transport is the one
-       *  writer then; never queued for `takeUnsent`, so no re-attach replays it; a
-       *  failed write is nobody's — the transport is being left, the process
-       *  ended by `kill`. */
-      sendAbort() {
-        if (this.closed) return;
-        const line3 = JSON.stringify({ type: "abort" });
-        this.sending = this.sending.then(() => this.heldForReattach ? void 0 : this.deps.container.writeLine(this.deps.paths, line3)).catch(() => void 0);
-      }
       /** Whether the reader is at the log's end as far as it knows: every record
        *  read has been handed out and the last read was short. The gate reads its
        *  clock only then (`HeldSends.quiet`): a catch-up burst still being handed
@@ -37608,7 +37949,7 @@ var init_transport = __esm({
       /** Close for teardown: a write already queued still lands — unless an
        *  earlier write failed, when it is held (`takeUnsent`) and this transport
        *  delivers nothing more of the chain. An abort is the one exception: its
-       *  step ignores the spent chain (`sendAbort`), so a teardown's abort still
+       *  step ignores the spent chain (`write`'s abort step), so a teardown's abort still
        *  reaches pi even then; the process is ended by `kill` regardless, so
        *  teardown owes nothing to a held write. */
       close() {
@@ -37716,7 +38057,7 @@ function resolveControlResetWrite(command2, echoed = () => false) {
     message: `a ${type} command was in flight when the resident's control plane reset under the run; its outcome is unknown and it has no echo to resolve it by, so the run cannot continue safely`
   };
 }
-var MAX_INPLACE_REATTACHES, PROMPT_ECHO_WAIT_MS, WORD_ALIVE_REATTACH_NOTE, CONTROL_RESET_RESUMED_NOTE, RESEND_AS_IS, HeldSends;
+var MAX_INPLACE_REATTACHES, PROMPT_ECHO_WAIT_MS, WORD_ALIVE_REATTACH_NOTE, CONTROL_RESET_RESUMED_NOTE, RESEND_AS_IS, PASSES_HOLD, HeldSends;
 var init_reattach = __esm({
   "../../src/core/harness/reattach.ts"() {
     "use strict";
@@ -37727,6 +38068,7 @@ var init_reattach = __esm({
     WORD_ALIVE_REATTACH_NOTE = "the executor said replaced; the row's pi answers alive in this container; re-attached";
     CONTROL_RESET_RESUMED_NOTE = "the resident's control plane reset under the run (a deploy); the container and pi are unchanged; re-attached";
     RESEND_AS_IS = /* @__PURE__ */ new Set(["set_auto_retry", "get_state", "extension_ui_response"]);
+    PASSES_HOLD = /* @__PURE__ */ new Set(["extension_ui_response", "abort"]);
     HeldSends = class {
       constructor(deliver) {
         this.deliver = deliver;
@@ -37747,13 +38089,14 @@ var init_reattach = __esm({
         return this.queue.length > 0;
       }
       /** Send now — or, while a prompt in doubt holds the gate, hold behind it in
-       *  order. A gate reply never holds: the rule lives here, by the command's
-       *  type, so no caller can get it wrong. `onLanded` runs when the write has
-       *  settled at the transport — told `landed`, or `failed` with the reset —
-       *  never at the hand-off to a chain that only holds it. */
+       *  order. A gate reply and an abort never hold (`PASSES_HOLD`): the rule
+       *  lives here, by the command's type, so no caller can get it wrong.
+       *  `onLanded` runs when the write has settled at the transport — told
+       *  `landed`, or `failed` with the reset — never at the hand-off to a chain
+       *  that only holds it, and never for a write nothing kept. */
       send(command2, onLanded) {
         if (onLanded) this.onLanded.set(command2, onLanded);
-        if (this.holding && command2.type !== "extension_ui_response") {
+        if (this.holding && !PASSES_HOLD.has(String(command2.type))) {
           this.queue.push({ command: command2, state: "send" });
           return;
         }
@@ -37814,7 +38157,11 @@ var init_reattach = __esm({
       }
       /** Hand a write to the transport; its `onLanded`, if any, runs once the write
        *  settled there. A `held` landing leaves the callback in place: the fresh
-       *  transport's re-send of the same object (through `send`) runs it. */
+       *  transport's re-send of the same object (through `send`) runs it. Every
+       *  other landing is the write's end and the callback is told which —
+       *  `dropped` included: a closed transport kept nothing, no re-send will come,
+       *  and a clock or a label waiting on the write must give up now rather than
+       *  wait for ever. */
       dispatch(command2) {
         void this.deliver(command2).then((landing) => {
           if (landing === "held") return;
@@ -38314,7 +38661,8 @@ var init_tracingExecutor = __esm({
         const innerRelease = inner.release?.bind(inner);
         if (innerRelease) this.release = (mode) => this.timed("exec.release", (s) => innerRelease(mode, { span: s }));
         const innerMoveTo = inner.moveTo?.bind(inner);
-        if (innerMoveTo) this.moveTo = (sha) => this.timed("exec.move_to", (s) => innerMoveTo(sha, { span: s }));
+        if (innerMoveTo)
+          this.moveTo = (sha, opts) => this.timed("exec.move_to", (s) => innerMoveTo(sha, { ...opts, span: s }));
         const innerReadBytes = inner.readBytes?.bind(inner);
         if (innerReadBytes)
           this.readBytes = (path) => this.timed("exec.read_bytes", (s) => innerReadBytes(path, { span: s }));
@@ -38906,6 +39254,8 @@ async function runPiHarnessOpen(deps, run2) {
   let windingDown = "run";
   let hardStopped = false;
   let bypass;
+  let abortSent = false;
+  let settled = false;
   let replaced;
   const toolsBlocked = () => {
     if (!writeUp) return void 0;
@@ -38990,7 +39340,8 @@ async function runPiHarnessOpen(deps, run2) {
     sessionEnded = true;
     transport?.close();
     bridge.closeOpenSpans(
-      hardStopped ? "the run was hard-stopped" : bypass ? "the run was stopped: a tool call bypassed the gate" : "the run ended"
+      hardStopped ? "the run was hard-stopped" : bypass ? "the run was stopped: a tool call bypassed the gate" : "the run ended",
+      { cut: abortSent || !settled }
     );
     save();
     if (replaced !== void 0) return;
@@ -39168,14 +39519,21 @@ async function runPiHarnessOpen(deps, run2) {
     else if (run2.resume) sends.send({ id: ids.prompt, type: "prompt", message: CONTINUE_PROMPT });
     else sends.send({ id: ids.prompt, type: "prompt", ...promptOf(run2.messages) });
     let warned = false;
-    let settled = false;
     let stopMode;
     let finaleAborted = false;
     let writeUpFailed;
+    const abortPi = () => {
+      abortSent = true;
+      bridge.markOpenCallsCut();
+      sends.send({ type: "abort" }, (landing) => {
+        if (landing === "dropped")
+          note("harness_error", "the abort was dropped: no transport kept it, so pi was never told to stop");
+      });
+    };
     const hardStop = () => {
       if (hardStopped) return;
       hardStopped = true;
-      transport?.sendAbort();
+      abortPi();
     };
     const startWriteUp = (kind, instruction) => {
       writeUp = kind;
@@ -39185,20 +39543,26 @@ async function runPiHarnessOpen(deps, run2) {
         const steer = { type: "steer", message: instruction };
         writeUpSteer = steer;
         sends.send(steer, (landing) => {
+          if (writeUpSteer !== steer) return;
           if (landing === "landed") {
             writeUpAt = now();
             return;
           }
-          note("wrap_up", wrapUpWriteFailedNote(kind.kind, windingDown));
-          ask();
+          if (landing === "failed") {
+            note("wrap_up", wrapUpWriteFailedNote(kind.kind, windingDown));
+            ask();
+            return;
+          }
         });
       };
       ask();
     };
     const dropHeld = (closes) => {
       const dropped = sends.dropHeld();
-      if (writeUp === void 0 || writeUpSteer === void 0 || !dropped.includes(writeUpSteer)) return;
-      note("wrap_up", wrapUpUndeliveredNote(writeUp.kind, closes));
+      const undelivered = writeUp !== void 0 && writeUpSteer !== void 0 && dropped.includes(writeUpSteer) ? writeUp : void 0;
+      writeUpSteer = void 0;
+      if (undelivered === void 0) return;
+      note("wrap_up", wrapUpUndeliveredNote(undelivered.kind, closes));
       clearWriteUp();
     };
     let steers = Promise.resolve();
@@ -39232,7 +39596,7 @@ async function runPiHarnessOpen(deps, run2) {
             note("follow_up", `staging the follow-up's files failed: ${redactSecrets(stagedLine)}`);
           }
         }
-        if (settled || loopEnded) {
+        if (loopEnded) {
           run2.inbox?.requeue(inputs);
           return;
         }
@@ -39269,7 +39633,7 @@ ${stagedLine}` : prompt;
           writeUpAt = void 0;
           finaleAborted = true;
           run2.onProgress?.(finaleTimedOutNote());
-          transport.sendAbort();
+          abortPi();
         }
         return;
       }
@@ -39280,8 +39644,13 @@ ${stagedLine}` : prompt;
         return;
       }
       if (now() >= loopEnd) {
-        note("time_budget_exhausted", timeBudgetNote(bridge.doingNow()));
+        const doing = bridge.doingNow();
+        note("time_budget_exhausted", timeBudgetNote(doing));
         startWriteUp({ kind: "time" }, timeBudgetInstruction());
+        if (doing !== void 0 && doing.startsWith("running ")) {
+          note("tool_cut", toolCutNote(doing));
+          abortPi();
+        }
         return;
       }
       if (bridge.turns >= run2.agent.maxTurns) {
@@ -39350,7 +39719,7 @@ ${stagedLine}` : prompt;
         if (now() >= until) {
           const msg = "the write in flight when the resident's control plane reset did not settle before the deadline; the run cannot continue";
           note("harness_error", msg);
-          transport.sendAbort();
+          abortPi();
           throw new Error(msg, { cause: err2 });
         }
       }
@@ -39426,7 +39795,7 @@ ${stagedLine}` : prompt;
       if (obs.gateBypassed) {
         bypass = new GateBypassed(obs.gateBypassed.tool, obs.gateBypassed.callId);
         note("harness_error", `${bypass.message} \u2014 the run is stopped`);
-        transport.sendAbort();
+        abortPi();
         break;
       }
       if (obs.response) {
@@ -39598,7 +39967,7 @@ ${stagedLine}` : prompt;
             writeUpAt = void 0;
             finaleAborted = true;
             run2.onProgress?.(finaleTimedOutNote("turn"));
-            transport.sendAbort();
+            abortPi();
           }
           return;
         }
@@ -39666,7 +40035,7 @@ ${stagedLine}` : prompt;
           if (obs.gateBypassed) {
             bypass = new GateBypassed(obs.gateBypassed.tool, obs.gateBypassed.callId);
             note("harness_error", `${bypass.message} \u2014 the turn is stopped`);
-            transport.sendAbort();
+            abortPi();
             break;
           }
           if (obs.response) noteEcho(obs.response);
@@ -39784,7 +40153,7 @@ var init_harness = __esm({
         this.name = "PromptRefused";
       }
     };
-    GateBypassed = class extends Error {
+    GateBypassed = class extends HarnessGateBypassedError {
       constructor(tool, callId) {
         super(`the gate was bypassed: pi ran ${tool} (call ${callId}) without asking the bot`);
         this.name = "GateBypassed";
@@ -40824,7 +41193,9 @@ async function runLoop(deps, ctx) {
     });
   }
   let answer;
-  let verdict = typeof restored.verdict === "object" && restored.verdict !== null ? parseVerdictInput(restored.verdict) ?? void 0 : void 0;
+  let verdict = typeof restored.verdict === "object" && restored.verdict !== null ? parseVerdictInput(restored.verdict, {
+    addressSeverity: ctx.addressSeverity.level
+  }) ?? void 0 : void 0;
   const onVerdict = (v) => {
     verdict = v;
     ledgerRun?.setState({ verdict: v });
@@ -40863,14 +41234,38 @@ async function runLoop(deps, ctx) {
   let reviewPost;
   let carried;
   let runFailed = false;
+  let gateBypassed = false;
+  let commandInFlight = false;
+  const recordEvents = () => registry.snapshot(run2.id, run2.token)?.events ?? [];
   let failure2;
   let interrupted;
+  const statusNow = () => {
+    const stopped = run2.control.requested;
+    return interrupted ? "interrupted" : runFailed ? "failed" : stopped === "hard" ? "stopped_hard" : stopped === "soft" ? "stopped_soft" : "completed";
+  };
+  const readCallsInFlight = () => {
+    const calls = callsInFlight(recordEvents(), statusNow());
+    commandInFlight = calls.length > 0;
+    if (commandInFlight)
+      registry.publish(run2.id, {
+        type: "run_note",
+        kind: "workspace_torn_down",
+        summary: redactAndCap(
+          `a command may still be running in the workspace, so it is torn down rather than paired: ${calls.map((c) => c.summary).join("; ")}`,
+          ENDING_NOTE_MAX
+        ),
+        at: clock4()
+      });
+  };
   let runDiagnosis;
   let harnessSession;
   const releaseWorkspace = (span) => {
-    const pushed = pushedBranchesOf(registry.snapshot(run2.id, run2.token)?.events ?? []);
+    const events = recordEvents();
+    const pushed = pushedBranchesOf(events);
     return round2.release({
       hardStopped: run2.control.requested === "hard",
+      commandInFlight,
+      gateBypassed,
       ...span ? { span } : {},
       ...pushed.length > 0 ? { pushed } : {}
     });
@@ -40916,6 +41311,7 @@ async function runLoop(deps, ctx) {
     ...wait ? { wait } : {},
     ...session ? { session } : {},
     onVerdict,
+    addressSeverity: ctx.addressSeverity.level,
     onDigest,
     onPrDescription,
     onHandoff,
@@ -41088,6 +41484,7 @@ async function runLoop(deps, ctx) {
               replaced: err2,
               facts: lastFacts,
               binding: workspaceBinding,
+              stopSignal: run2.control.hardSignal,
               saveFacts
             });
           } catch (failed) {
@@ -41099,6 +41496,15 @@ async function runLoop(deps, ctx) {
             onEvent({ type: "run_note", kind: "sandbox_restarted", summary: decision.interruption.message });
             throw decision.interruption;
           }
+          if (decision.kind === "stopped") {
+            harnessDeps.registry.forget(run2.id);
+            onEvent({
+              type: "run_note",
+              kind: "sandbox_restarted",
+              summary: "the container was replaced under the run, and the run was stopped while its workspace was being re-attached in the replacement"
+            });
+            break;
+          }
           if (decision.round !== void 0) {
             executor = decision.round.selection.executor;
             toolContext.executor = executor;
@@ -41112,7 +41518,7 @@ async function runLoop(deps, ctx) {
           harnessResume = decision.resume;
         }
       }
-      answer = harnessSession.answer;
+      answer = harnessSession?.answer ?? HARD_STOP_MESSAGE;
     }
     if (isPrReview && repoCtx.repo && repoCtx.pr !== void 0 && run2.control.requested !== "hard" && postedBefore === void 0) {
       const settled = await settleReviewedHead({
@@ -41255,6 +41661,7 @@ async function runLoop(deps, ctx) {
       }
     }
     await harnessSession?.end();
+    readCallsInFlight();
     const leftBehind = isCodingPrRun && run2.control.requested !== "hard" ? workLeftBehindOf({ uncommittedChanges: observedUncommitted, unpushedCommits: observedUnpushed }) : void 0;
     if (leftBehind) {
       registry.publish(run2.id, {
@@ -41328,14 +41735,16 @@ async function runLoop(deps, ctx) {
     if (err2 instanceof HarnessInterruptedError) interrupted = err2;
     else {
       runFailed = true;
+      gateBypassed = err2 instanceof HarnessGateBypassedError;
       if (err2 instanceof ModelPolicyRefusedError) failure2 = { kind: "policy_refusal" };
       registry.publish(run2.id, {
         type: "run_note",
         kind: "run_failed",
-        summary: redactAndCap(err2 instanceof Error ? err2.message : String(err2), RUN_FAILED_NOTE_MAX)
+        summary: redactAndCap(err2 instanceof Error ? err2.message : String(err2), ENDING_NOTE_MAX)
       });
     }
     await harnessSession?.end();
+    readCallsInFlight();
     await root.span("post.workspace_release", (span) => releaseWorkspace(span));
     if (!interrupted) throw err2;
     return {
@@ -41347,8 +41756,7 @@ async function runLoop(deps, ctx) {
     };
   } finally {
     clearInterval(heartbeat);
-    const stopped = run2.control.requested;
-    const status3 = interrupted ? "interrupted" : runFailed ? "failed" : stopped === "hard" ? "stopped_hard" : stopped === "soft" ? "stopped_soft" : "completed";
+    const status3 = statusNow();
     registry.finish(run2.id, status3);
     const snap = registry.snapshot(run2.id, run2.token);
     const events = snap?.events ?? [];
@@ -41447,7 +41855,7 @@ function unknownHarnessWordOf(state) {
     container: typeof container === "string" ? container : "unknown"
   };
 }
-var RUN_FAILED_NOTE_MAX;
+var ENDING_NOTE_MAX;
 var init_runLoop = __esm({
   "../../src/core/dispatch/runLoop.ts"() {
     "use strict";
@@ -41490,7 +41898,7 @@ var init_runLoop = __esm({
     init_reply();
     init_staging();
     init_run2();
-    RUN_FAILED_NOTE_MAX = 500;
+    ENDING_NOTE_MAX = 500;
   }
 });
 
@@ -42207,9 +42615,9 @@ async function runShipBranch(deps, msg, io, ctx) {
   }
   const scopes = deps.config.scopes(msg.channelId, msg.userId);
   const addressSeverity = resolveAddressSeverity({
-    org: deps.config.config.ship?.addressSeverity,
-    channel: scopes.channel.ship?.addressSeverity,
-    user: scopes.user.ship?.addressSeverity,
+    org: deps.config.config.review?.addressSeverity,
+    channel: scopes.channel.review?.addressSeverity,
+    user: scopes.user.review?.addressSeverity,
     run: directives.severity
   });
   const grant2 = resolveGrant2({
@@ -42341,14 +42749,14 @@ var init_codingChild = __esm({
 
 // ../../src/core/dispatch/settle.ts
 function settleThread(deps, ctx) {
-  const { msg, admitted, runLoopStarted, control } = ctx;
+  const { msg, admitted, stopCounts, control } = ctx;
   const admission = deps.admission ?? defaultAdmission;
   const released = admitted ? admission.release(msg.threadKey, admitted) : [];
   const pending2 = released.filter(fromPerson);
   const fromRuns = released.length - pending2.length;
   if (fromRuns > 0)
     console.log(`[dispatch] ${msg.threadKey} ${fromRuns} steer(s) from a parent run never read \u2014 not run fresh`);
-  const stopMode = runLoopStarted ? control?.requested : void 0;
+  const stopMode = stopCounts ? control?.requested : void 0;
   if (pending2.length > 0 && stopMode) {
     console.log(`[dispatch] ${msg.threadKey} ${pending2.length} follow-up(s) dropped: run stopped (${stopMode})`);
     return { kind: "dropped", stopMode, pending: pending2 };
@@ -43007,6 +43415,7 @@ async function dispatch(deps, msg, io, opts = {}) {
   let reserved;
   let requestRow;
   let fencedWhileAttaching = false;
+  let stoppedWhileAttaching;
   let resumeRowClosed = false;
   let restartRequest;
   const reservationHooks = {
@@ -43321,9 +43730,30 @@ async function dispatch(deps, msg, io, opts = {}) {
       profile,
       repoCtx,
       root,
-      ...reattach !== void 0 ? { reattach } : {}
+      ...reattach !== void 0 ? { reattach } : {},
+      // The run's control exists from the registry row above: a stop relayed
+      // during the attach ends its wake wait at once (execution.md item 9).
+      ...registered ? { stopSignal: registered.control.hardSignal } : {}
     });
     if (attach.kind === "refused") return ended;
+    if (attach.kind === "stopped") {
+      if (!fencedWhileAttaching) {
+        stoppedWhileAttaching = registered?.control.requested ?? "hard";
+        await root.span(
+          "dispatch.stop",
+          () => card.done(
+            shell.close({
+              kind: "not_started",
+              icon: "\u26D4",
+              reason: "stopped before the run started",
+              ...closeLines(clock4(), false)
+            })
+          ),
+          { attrs: { outcome: "stopped_while_attaching" } }
+        );
+      }
+      return ended;
+    }
     if (attach.kind === "reattach_refused") {
       if (resume) {
         const request2 = await abandonLostWorkspace({
@@ -43520,9 +43950,17 @@ async function dispatch(deps, msg, io, opts = {}) {
         inbox: admitted.inbox
       }
     );
+    const scopes = deps.config.scopes(msg.channelId, msg.userId);
+    const addressSeverity = resolveAddressSeverity({
+      org: deps.config.config.review?.addressSeverity,
+      channel: scopes.channel.review?.addressSeverity,
+      user: scopes.user.review?.addressSeverity,
+      run: directives.severity
+    });
     const ran = await runLoop(deps, {
       msg,
       io,
+      addressSeverity,
       agent,
       profile,
       resolved,
@@ -43644,17 +44082,21 @@ async function dispatch(deps, msg, io, opts = {}) {
     if (registered) deps.runBearers?.revoke(registered.id);
     if (resume && ledgerRun && !runLoopStarted && !resumeRowClosed) {
       const adopted = ledgerRun;
-      await root.span(
-        "post.history_write",
-        () => closeResumedRow(adopted, resume, "the resumed dispatch ended before the run started")
-      );
-      console.log(
-        `[resume] ${msg.threadKey} run ${resume.row.runId} closed interrupted: the resumed dispatch ended before the run started`
-      );
+      const why = stoppedWhileAttaching !== void 0 ? "the resumed run was stopped before it started" : "the resumed dispatch ended before the run started";
+      const status3 = stoppedWhileAttaching === "hard" ? "stopped_hard" : stoppedWhileAttaching === "soft" ? "stopped_soft" : "interrupted";
+      await root.span("post.history_write", () => closeResumedRow(adopted, resume, why, status3));
+      console.log(`[resume] ${msg.threadKey} run ${resume.row.runId} closed ${status3}: ${why}`);
     }
-    const settled = settleThread(deps, { msg, admitted, runLoopStarted, control: registered?.control });
+    const settled = settleThread(deps, {
+      msg,
+      admitted,
+      // A stop that ended the attach counts as the loop's stop would: the
+      // request ends `stopped`, and a follow-up queued during the wait is told.
+      stopCounts: runLoopStarted || stoppedWhileAttaching !== void 0,
+      control: registered?.control
+    });
     if (settled.kind === "dropped") await tellDropped(root, settled.pending);
-    const stopMode = settled.kind === "handed-on" ? void 0 : settled.stopMode;
+    const stopMode = (settled.kind === "handed-on" ? void 0 : settled.stopMode) ?? stoppedWhileAttaching;
     ended.status = caught ? "failed" : refused7 ? "refused" : stopMode ? "stopped" : "completed";
     root.end(caught ? "error" : "ok", { status: ended.status });
     if (restartRequest) {
@@ -43787,6 +44229,7 @@ var init_dispatcher = __esm({
     init_record();
     init_ship();
     init_shipPipeline();
+    init_reviewVerdict();
     init_contract();
     init_codingChild();
     init_settle();
@@ -45565,6 +46008,38 @@ let pending = Promise.resolve();
 let backoffMs = MIN_BACKOFF_MS;
 let connections = 0;
 
+// A write the feed refuses is not thrown from the write: node reports it on the
+// stream's error event \u2014 for the file the seam appends the feed to (EBADF: a
+// descriptor opened without write) as for a pipe whose reader is gone (EPIPE)
+// \u2014 and an error event nobody listens for is an uncaught exception that kills
+// the tailer with no note anywhere. The listener is the guard: the refused
+// record is lost to the feed and said on stderr. A feed gone for good \u2014 its
+// descriptor bad (EBADF), its reader gone (EPIPE): every later write fails the
+// same way and the stream is not destroyed \u2014 ends the tailer non-zero once the
+// note is out, so its death is visible to the seam and a re-attach restarts it
+// (a mute tailer alive at its pid would be waited on to the run's silence
+// bound): the exit code is set first, the exit follows the note's write or a
+// short unref'd timer, whichever comes first, so a stderr that never drains
+// cannot keep the mute tailer alive either. Any other refusal \u2014 a full disk
+// (ENOSPC), which space can cure \u2014 is noted and the tailer goes on. A write on
+// stderr that fails has nothing left to say it to.
+const FEED_GONE = new Set(["EBADF", "EPIPE"]);
+const FEED_GONE_EXIT_MS = 1000;
+process.stdout.on("error", (err) => {
+  const gone = FEED_GONE.has(err && err.code);
+  if (gone) {
+    process.exitCode = 1;
+    setTimeout(() => process.exit(1), FEED_GONE_EXIT_MS).unref();
+  }
+  process.stderr.write(
+    "tailer: a record could not be written" + (gone ? "; the feed is gone, exiting" : "") + ": " + detailOf(err) + "\\n",
+    () => {
+      if (gone) process.exit(1);
+    },
+  );
+});
+process.stderr.on("error", () => {});
+
 function emit(record) {
   process.stdout.write(JSON.stringify(record) + "\\n");
 }
@@ -45601,15 +46076,21 @@ async function getJson(path) {
   return JSON.parse(res.body);
 }
 
-/** The session's pending asks, whole; then its messages, the changed ones only. */
+/** The session's pending asks, whole, emitted the moment their read answers;
+ *  its messages, the changed ones only, after the store's pages. Both reads go
+ *  out at once: an unanswered ask holds the server's turn, so it waits on
+ *  nothing \u2014 least of all a long store's pagination. An ask read ahead of the
+ *  rows that name its call is the bridge's to hold until they come. */
 async function refill(sessionID, reason) {
   const at = Date.now();
-  try {
-    const answer = await getJson("/api/session/" + sessionID + "/permission");
-    emit({ feed: "permissions", at, sessionID, reason, data: Array.isArray(answer.data) ? answer.data : [] });
-  } catch (err) {
-    note("permission refill failed", { sessionID, reason, detail: detailOf(err) });
-  }
+  // Neither read nor what is done with its answer can reject out of here: the
+  // asks' chain catches its read's refusal and a malformed answer alike (null
+  // is JSON with no data), the messages' try its pages and its record \u2014 so
+  // refill never rejects and the queue below never ends (a write cannot throw:
+  // emit).
+  const asks = getJson("/api/session/" + sessionID + "/permission")
+    .then((answer) => emit({ feed: "permissions", at, sessionID, reason, data: Array.isArray(answer.data) ? answer.data : [] }))
+    .catch((err) => note("permission refill failed", { sessionID, reason, detail: detailOf(err) }));
   try {
     const all = [];
     let cursor;
@@ -45638,10 +46119,16 @@ async function refill(sessionID, reason) {
     if (!known.has(sessionID)) known.set(sessionID, new Map());
     note("message refill failed", { sessionID, reason, detail: detailOf(err) });
   }
+  await asks;
 }
 
+// One refill after another; a refill that still managed to reject is noted
+// and the chain goes on \u2014 a rejected chain would skip every later refill for
+// every session, silently, for the rest of the tailer's life.
 function queueRefill(sessionID, reason) {
-  pending = pending.then(() => refill(sessionID, reason));
+  pending = pending
+    .then(() => refill(sessionID, reason))
+    .catch((err) => note("refill failed", { sessionID, reason, detail: detailOf(err) }));
 }
 
 function onEvent(event) {
@@ -46105,6 +46592,12 @@ function isBudgetRefusal(error) {
   return TURN_BUDGET_REFUSAL.test(error.message);
 }
 function judgeOpenCodeAsk(action, resources, rules, relayedToolNames) {
+  if (action === "doom_loop")
+    return {
+      reply: "reject",
+      tool: "doom_loop",
+      message: "OpenCode's repeat guard tripped: the same call has been made over and over, and the run does not go on looping \u2014 change approach, or write up what stands"
+    };
   const word = openCodeToolWord(action);
   const tool = TOOL_NAME_WORD[action] ?? word;
   if (relayedToolNames.has(action) || relayedToolNames.has(word)) return { reply: "once", tool: action };
@@ -46128,14 +46621,42 @@ function judgeOpenCodeAsk(action, resources, rules, relayedToolNames) {
   if (verdict.verdict !== "allowed") return refuse3(verdict.reason);
   return { reply: "once", tool };
 }
-function askInput(request2) {
+function foldInputs(asks, own) {
+  let input = own;
+  for (const ask of asks) input = openInput(ask, input);
+  return input;
+}
+function openInput(request2, own) {
   const resources = Array.isArray(request2.resources) ? request2.resources.filter((r) => typeof r === "string") : [];
-  if (resources.length === 0) return void 0;
+  if (request2.action === "doom_loop") return own;
+  if (resources.length === 0) return own;
+  if (request2.action === "external_directory") {
+    const ownPath = typeof own?.path === "string" ? own.path : typeof own?.filePath === "string" ? own.filePath : void 0;
+    const before = Array.isArray(own?.directories) ? own.directories.filter((d) => typeof d === "string") : [];
+    const directories = [.../* @__PURE__ */ new Set([...before, ...resources])];
+    return { ...own ?? {}, path: ownPath ?? directories[0], directory: directories[0], directories };
+  }
   return openCodeToolNameWord(request2.action) === "bash" ? { command: resources.join(" ") } : { path: resources[0] };
 }
+function describeOpenCodeToolCall(tool, input) {
+  const line3 = describePiToolCall(tool, input);
+  const reached = Array.isArray(input?.directories) ? input.directories.filter((d) => typeof d === "string" && d !== input.path) : [];
+  return reached.length === 0 ? line3 : `${line3} (reaching ${reached.join(", ")})`;
+}
 function unattributableDetail(tool, callId) {
   return `${tool} (call ${callId}): an ask pending at the bot's death was answered while the bot was away; the run cannot tell by whom`;
 }
+function toolPartsOf(message4) {
+  if (message4.type !== "assistant") return [];
+  const content = message4.content;
+  const parts = [];
+  for (const part of Array.isArray(content) ? content : []) {
+    if (!isRecord9(part) || part.type !== "tool") continue;
+    const input = isRecord9(part.state) && isRecord9(part.state.input) ? part.state.input : void 0;
+    parts.push({ id: str6(part.id), name: str6(part.name), ...input ? { input } : {} });
+  }
+  return parts;
+}
 function ledgerTurnCount(ledger) {
   let turns = 0;
   for (const row2 of ledger) {
@@ -46307,6 +46828,7 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
   let providerError;
   let writeUpFailed;
   let settled = false;
+  let interruptPosted = false;
   let replacedBy;
   let transportLost;
   const probe = {
@@ -46352,13 +46874,24 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
     post("the write-up steer", sessionRoutes["session.prompt"], { text: instruction, delivery: "steer" });
   };
   const turnCount = () => deps.bearers?.grantOf(run2.runId)?.turns ?? bridge.turns;
+  const interrupt = () => {
+    interruptPosted = true;
+    post("the interrupt", sessionRoutes["session.interrupt"]);
+  };
   const check = () => {
     const requested = run2.control?.requested;
     if (requested === "hard") {
       if (ended === void 0) {
         ended = "hard";
         note("stopped", hardStopNote(), "hard");
-        post("the interrupt", sessionRoutes["session.interrupt"]);
+        interrupt();
+      }
+      return;
+    }
+    if (conn.failure.error !== void 0) {
+      if (ended === void 0) {
+        ended = "failed";
+        interrupt();
       }
       return;
     }
@@ -46374,7 +46907,7 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
         writeUpFailed ??= reason2;
         run2.onProgress?.(finaleTimedOutNote());
         note("harness_error", windDownFailureNote(reason2));
-        post("the interrupt", sessionRoutes["session.interrupt"]);
+        interrupt();
       }
       return;
     }
@@ -46480,7 +47013,7 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
       if (failure2 !== void 0) {
         replyFailed = new OpenCodeReplyFailedError(reply.requestID, reply.callId, reply.reply, failure2);
         note("harness_error", `${replyFailed.message} \u2014 the run is stopped`);
-        post("the interrupt", sessionRoutes["session.interrupt"]);
+        interrupt();
         return replyFailed;
       }
     }
@@ -46607,7 +47140,7 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
       if (await postReplies(obs) !== void 0) break;
       if (obs.bypass) {
         bypass = obs.bypass;
-        post("the interrupt", sessionRoutes["session.interrupt"]);
+        interrupt();
         break;
       }
       if (bridge.observing === "catching-up") {
@@ -46636,7 +47169,7 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
     conn.boundaries?.left();
     transport.close();
     agentSpan?.end(
-      ended === "hard" || ended === "silent" || bypass || replyFailed || replacedBy || transportLost || refused7 || providerError !== void 0 ? "error" : "ok"
+      ended === "hard" || ended === "silent" || ended === "failed" || bypass || replyFailed || replacedBy || transportLost || refused7 || providerError !== void 0 ? "error" : "ok"
     );
   }
   if (replacedBy !== void 0) {
@@ -46651,6 +47184,11 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
     note("sandbox_restarted", replaced.message);
     throw replaced;
   }
+  if (interruptPosted)
+    bridge.closeOpenSpans(
+      (open2) => `${open2.tool} was still running when the loop left on its interrupt; its outcome never reached the record`,
+      { cut: true }
+    );
   if (transportLost !== void 0 && ended !== "hard") {
     note(
       "harness_error",
@@ -46674,18 +47212,19 @@ async function driveOpenCode(deps, run2, conn, kind = "loop") {
       boundMs: FIRST_EVENT_BOUND_MS
     });
     note("harness_error", `${silent.message} \u2014 the run is stopped`);
-    post("the interrupt", sessionRoutes["session.interrupt"]);
+    interrupt();
     throw silent;
   }
   const remaining = () => deadline - now();
   const handOver = () => ({ storeIds: bridge.storeIds() });
-  if (ended === "hard") return { answer: HARD_STOP_MESSAGE, remainingMs: remaining, ...handOver() };
+  if (ended === "failed" && conn.failure.error !== void 0) throw conn.failure.error;
+  if (ended === "hard") return { answer: HARD_STOP_MESSAGE, remainingMs: remaining, hardStopped: true, ...handOver() };
   if (providerError !== void 0) throw new Error(`the model call failed: ${providerError}`);
   if (!settled && ended !== "finale") throw new Error("the OpenCode run ended before its execution settled");
   await bridge.flush();
   const text = bridge.answer() ?? "";
   const answer = writeUpAnswer(writeUp, text, run2.agent.maxMinutes, writeUpFailed);
-  return { answer, remainingMs: remaining, ...handOver() };
+  return { answer, remainingMs: remaining, hardStopped: false, ...handOver() };
 }
 function writeUpAnswer(writeUp, text, maxMinutes, writeUpFailed) {
   if (writeUp?.kind === "time") return timeBudgetAnswer(text, maxMinutes, writeUpFailed);
@@ -46711,7 +47250,7 @@ var init_bridge3 = __esm({
     init_dispositions();
     init_session2();
     init_process2();
-    OpenCodeGateBypassedError = class extends Error {
+    OpenCodeGateBypassedError = class extends HarnessGateBypassedError {
       constructor(detail) {
         super(`the gate was bypassed: ${detail}`);
         this.detail = detail;
@@ -46845,10 +47384,17 @@ var init_bridge3 = __esm({
        *  the fake sends the whole store — and the projection reads the whole map,
        *  so a turn lands once whichever shape a refill has (the join by message id). */
       store = /* @__PURE__ */ new Map();
-      /** The store's rows as the last refill showed them, by id — set the moment a
-       *  refill is read, ahead of the mirror's chain, for what must be named at
-       *  once: the tool of a call a permission's `source` points at (`toolOfPart`). */
-      latest = /* @__PURE__ */ new Map();
+      /** Every tool part the store has shown, by the part's id (the call id): the
+       *  tool's name and its own input — filled the moment a refill is read, ahead
+       *  of the mirror's chain, for what must be named at once: the call a
+       *  permission's `source` points at. */
+      partTools = /* @__PURE__ */ new Map();
+      /** Resource permissions answered for a call the store has not named yet, by
+       *  call id, each call's asks in the order they came — two can name one call
+       *  (`external_directory`, then `doom_loop`) and each is kept: the call is
+       *  opened once, when a refill names its part, with every held ask's input
+       *  folded in, or at its settle under the first ask's own name if none did. */
+      unnamedAsks = /* @__PURE__ */ new Map();
       /** How many store messages the projection skips: the seed and the request's
        *  echo on a fresh run, the import on a rebuild; none on a re-attach, where
        *  the ledger's rows are skipped by turn instead (`adoptStore`). */
@@ -46934,18 +47480,14 @@ var init_bridge3 = __esm({
         const pendingCalls = new Set(pending2.map((r) => r.source?.id ?? r.id));
         for (const row2 of ledger)
           for (const part of row2.content) if (part.type === "tool_result") this.ledgerResults.add(part.toolUseId);
-        for (const message4 of messages) {
-          if (message4.type !== "assistant") continue;
-          const content = message4.content;
-          for (const part of Array.isArray(content) ? content : []) {
-            if (!isRecord9(part) || part.type !== "tool") continue;
-            const id = str6(part.id);
-            const name = str6(part.name);
+        for (const message4 of messages)
+          for (const part of toolPartsOf(message4)) {
+            const { id, name } = part;
             this.toolNames.set(id, name);
+            this.partTools.set(id, part);
             if (this.ledgerResults.has(id) || pendingCalls.has(id) || this.deps.relayedToolNames.has(name)) continue;
             this.unattributableCalls.add(id);
           }
-        }
         this.storeSeed = 0;
         this.fedTurns = Math.min(ledgerTurnCount(ledger), projectStore(messages, 0).length);
         this.mirrorChain = this.mirrorChain.then(() => this.syncMirror(messages));
@@ -46966,12 +47508,17 @@ var init_bridge3 = __esm({
       storeIds() {
         return [...this.store.keys()];
       }
-      /** Settle every call still open when the container went under a running call
-       *  (the replaced verdict): each open span ends `error` and its call is put on
-       *  the record as a failed `tool_result` carrying `reason` — the restart note,
-       *  said of the container — so no span outlives the run and the record holds a
-       *  result for every call at the death, exactly as pi's `closeOpenSpans` does. */
-      closeOpenSpans(reason2) {
+      /** Settle every call still open when the loop is done with the session: each
+       *  open span ends `error` and its call is put on the record as a failed
+       *  `tool_result` carrying `reason`, so no span outlives the run and the record
+       *  holds a result for every call, exactly as pi's `closeOpenSpans` does. On
+       *  the container-replaced verdict (the restart note, said of the container)
+       *  the results are unmarked: the old container's calls are gone and the
+       *  relaunch takes the relayed ones over, nothing the workspace's release must
+       *  hold for. At every other exit the loop left the calls interrupted or
+       *  unread, and `cut` marks each result as a call ended and not settled, whose
+       *  command may still be running (harness.md item 13). */
+      closeOpenSpans(reason2, opts = {}) {
         for (const [callId, open2] of this.openTools) {
           open2.span?.end("error", { callId, ok: false });
           this.emit({
@@ -46979,7 +47526,8 @@ var init_bridge3 = __esm({
             tool: open2.tool,
             ok: false,
             callId,
-            summary: redactAndCap(reason2({ callId, tool: open2.tool }), COMMAND_CAP)
+            summary: redactAndCap(reason2({ callId, tool: open2.tool }), COMMAND_CAP),
+            ...opts.cut ? { cut: true } : {}
           });
         }
         this.openTools.clear();
@@ -47141,6 +47689,7 @@ ${data.text}` : data.text;
       }
       onToolCalled(data) {
         const callId = str6(data.id);
+        if (this.openTools.has(callId)) return;
         this.openCall(callId, this.toolNames.get(callId) ?? "tool", isRecord9(data.input) ? data.input : void 0);
       }
       /** The call opened on the record — its span, its `tool_call` with the
@@ -47161,7 +47710,7 @@ ${data.text}` : data.text;
         this.emit({
           type: "tool_call",
           tool,
-          summary: redactAndCap(describePiToolCall(tool, input)),
+          summary: redactAndCap(describeOpenCodeToolCall(tool, input)),
           callId,
           ...command2,
           ...span ? { spanId: span.id } : {}
@@ -47179,6 +47728,16 @@ ${data.text}` : data.text;
           );
           return;
         }
+        const held2 = this.takeHeldAsks(callId);
+        const first = held2[0];
+        if (first !== void 0 && !this.openTools.has(callId) && !this.toolNames.has(callId)) {
+          this.note(
+            "tool_unnamed",
+            `OpenCode asked ${redactAndCap(held2.map((h) => h.action).join(", "), 60)} for call ${callId} of step ${redactAndCap(first.source?.messageID ?? "", 80)}, and the store showed no part naming the call's tool before it settled; the record opens the call under the permission's name`
+          );
+          this.toolNames.set(callId, first.action);
+          this.openCall(callId, first.action, foldInputs(held2, void 0));
+        }
         const open2 = this.openTools.get(callId);
         this.openTools.delete(callId);
         const tool = open2?.tool ?? openCodeToolNameWord(this.toolNames.get(callId) ?? "tool");
@@ -47225,16 +47784,45 @@ ${data.text}` : data.text;
           );
         }
       }
-      /** The tool of the call a permission's `source` names, read from the store's
-       *  rows as last refilled: the assistant message's tool part with that id —
-       *  its `name` — or nothing when the store holds no such part yet. */
-      toolOfPart(messageID, partId) {
-        const message4 = this.latest.get(messageID);
-        if (message4 === void 0 || message4.type !== "assistant") return void 0;
-        const content = message4.content;
-        if (!Array.isArray(content)) return void 0;
-        const part = content.find((p) => isRecord9(p) && p.type === "tool" && p.id === partId);
-        return typeof part?.name === "string" ? part.name : void 0;
+      /** Take the resource permissions held for a call, in the order they came:
+       *  the hold is over once they are read, whoever reads them. */
+      takeHeldAsks(callId) {
+        const held2 = this.unnamedAsks.get(callId) ?? [];
+        this.unnamedAsks.delete(callId);
+        return held2;
+      }
+      /** An `external_directory` ask answered once the call's line is already on
+       *  the record: the line cannot be amended, so the directory the call reached
+       *  is said in a note naming the call (harness.md item 13) rather than lost. */
+      noteDirectoryReached(callId, asks) {
+        const directories = [
+          ...new Set(
+            asks.filter((ask) => ask.action === "external_directory").flatMap((ask) => Array.isArray(ask.resources) ? ask.resources : []).filter((r) => typeof r === "string")
+          )
+        ];
+        if (directories.length === 0) return;
+        const tool = openCodeToolNameWord(this.toolNames.get(callId) ?? "tool");
+        this.note(
+          "directory_reached",
+          `${tool} (call ${callId}) reached ${redactAndCap(directories.join(", "), 200)} after its line was written; the line does not name it`
+        );
+      }
+      /** A resource permission's call, opened once the store names its part: under
+       *  the tool's word, with the tool's own input and the resources of every ask
+       *  held before the open — and of `ask`, one arriving with the part already in
+       *  hand — folded in (every directory the `external_directory` asks named, the
+       *  first as `directory`, all in `directories`); an ask that arrives after the
+       *  call opened is answered but cannot amend the `tool_call` already on the
+       *  record — the directory it named is said in a `directory_reached` note. */
+      openNamedCall(callId, part, ask) {
+        const held2 = this.takeHeldAsks(callId);
+        if (ask !== void 0) held2.push(ask);
+        if (this.openTools.has(callId) || this.toolNames.has(callId)) {
+          this.noteDirectoryReached(callId, held2);
+          return;
+        }
+        this.toolNames.set(callId, part.name);
+        this.openCall(callId, part.name, foldInputs(held2, part.input));
       }
       bypass(out, detail) {
         out.bypass = new OpenCodeGateBypassedError(detail);
@@ -47243,20 +47831,24 @@ ${data.text}` : data.text;
       onPermissionAsked(request2, out) {
         const callId = request2.source?.id ?? request2.id;
         if (typeof request2.source?.messageID === "string") this.ownSteps.add(request2.source.messageID);
-        if (this.answered.has(callId)) return;
         if (this.decidedReplies.has(request2.id)) return;
         const source2 = request2.source;
         if (source2?.type === "tool" && this.observing === "own" && !this.openTools.has(callId) && !this.toolNames.has(callId)) {
-          const resource = RESOURCE_PERMISSIONS.has(request2.action);
-          const named = resource ? this.toolOfPart(source2.messageID, source2.id) : void 0;
-          if (resource && named === void 0)
-            this.note(
-              "tool_unnamed",
-              `OpenCode asked ${redactAndCap(request2.action, 40)} for call ${callId} of step ${redactAndCap(source2.messageID, 80)}, and the store holds no part naming the call's tool yet; the record opens the call under the permission's name`
-            );
-          const word = named !== void 0 ? openCodeToolNameWord(named) : resource ? request2.action : openCodeToolWord(request2.action);
-          this.toolNames.set(callId, word);
-          this.openCall(callId, word, resource ? void 0 : askInput(request2));
+          if (RESOURCE_PERMISSIONS.has(request2.action)) {
+            const part = this.partTools.get(source2.id);
+            if (part !== void 0) this.openNamedCall(callId, part, request2);
+            else {
+              const held2 = this.unnamedAsks.get(callId);
+              if (held2 === void 0) this.unnamedAsks.set(callId, [request2]);
+              else held2.push(request2);
+            }
+          } else {
+            const raw = OPENCODE_ACTION_TO_TOOL_WORD[request2.action] !== void 0 ? request2.action : openCodeToolWord(request2.action);
+            this.toolNames.set(callId, raw);
+            this.openCall(callId, raw, openInput(request2, void 0));
+          }
+        } else if (source2?.type === "tool" && this.observing === "own" && request2.action === "external_directory") {
+          this.noteDirectoryReached(callId, [request2]);
         }
         if (this.observing === "catching-up" && !this.pendingAtReattach.has(request2.id)) {
           const name = this.toolNames.get(callId) ?? request2.action;
@@ -47271,7 +47863,7 @@ ${data.text}` : data.text;
           this.deps.rules,
           this.deps.relayedToolNames
         );
-        this.answered.set(callId, verdict.reply);
+        if (this.answered.get(callId) !== "reject") this.answered.set(callId, verdict.reply);
         this.decidedReplies.set(request2.id, { reply: verdict.reply, callId, echoed: false });
         if (verdict.reply === "reject")
           this.note("tool_refused", `${verdict.tool} refused: ${redactAndCap(verdict.message ?? "", 300)}`);
@@ -47326,7 +47918,11 @@ ${data.text}` : data.text;
         return out;
       }
       onMessagesRefill(messages) {
-        for (const message4 of messages) this.latest.set(message4.id, message4);
+        for (const message4 of messages)
+          for (const part of toolPartsOf(message4)) {
+            this.partTools.set(part.id, part);
+            if (this.unnamedAsks.has(part.id)) this.openNamedCall(part.id, part);
+          }
         this.mirrorChain = this.mirrorChain.then(() => this.syncMirror(messages));
         return { replies: [], settled: false };
       }
@@ -47618,6 +48214,7 @@ async function openOpenCodeRun(deps, run2, settings) {
       knownMessageIds: known,
       writes: { seq: 0, ownPrompts: /* @__PURE__ */ new Map(), imported },
       boundaries: new StepBoundaries(),
+      failure: {},
       paths: server.paths,
       port: server.port,
       password: server.password,
@@ -47641,16 +48238,17 @@ async function openOpenCodeRun(deps, run2, settings) {
     );
     let answer;
     let remainingMs;
+    let hardStopped;
     let drained;
     try {
       let storeIds;
-      ({ answer, remainingMs, storeIds } = await driveOpenCode(deps, run2, conn));
+      ({ answer, remainingMs, storeIds, hardStopped } = await driveOpenCode(deps, run2, conn));
       for (const id of storeIds) known.add(id);
     } finally {
       draining = false;
       drained = await drainer;
     }
-    if (drained instanceof OpenCodeWriteUnresolvedError) throw drained;
+    if (drained instanceof OpenCodeWriteUnresolvedError && !hardStopped) throw drained;
     return {
       answer,
       followUp: async (input) => {
@@ -47788,9 +48386,18 @@ function drainFollowUps(deps, run2, conn, running, emit, note) {
   const routes = openCodeSessionRoutes(conn.sessionID);
   return (async () => {
     const deferred = [];
+    const senderOf = (input) => input.from !== void 0 ? `run:${input.from.runId}` : `user:${input.userId}`;
     while (running()) {
       const inputs = run2.inbox?.drain() ?? [];
       for (const input of inputs) {
+        if (input.from === void 0 && deferred.some((held2) => senderOf(held2) === senderOf(input))) {
+          deferred.push(input);
+          note(
+            "follow_up",
+            `follow-up held for a fresh turn behind an earlier one from the same sender the server did not take: ${redactSecrets(followUpSnippet(input))}`
+          );
+          continue;
+        }
         let stagedLine = "";
         if (run2.stageFollowUps) {
           try {
@@ -47891,8 +48498,8 @@ ${stagedLine}` : prompt;
         } catch (err2) {
           if (err2 instanceof OpenCodeWriteUnresolvedError) {
             note("harness_error", `${err2.message} \u2014 the run is stopped`);
-            run2.control?.requestStop("hard");
-            run2.inbox?.requeue([...deferred.splice(0), ...inputs.slice(inputs.indexOf(input) + 1)]);
+            conn.failure.error = err2;
+            run2.inbox?.requeue([...deferred.splice(0), ...inputs.slice(inputs.indexOf(input))]);
           }
           throw err2;
         }
@@ -47906,8 +48513,8 @@ ${stagedLine}` : prompt;
             run2.inbox?.requeue([...deferred.splice(0), ...rest]);
             return;
           }
-          deferred.push(...rest);
-          break;
+          deferred.push(input);
+          continue;
         }
         const source2 = {
           ...input.sourceUrl ? { url: input.sourceUrl } : {},
@@ -50623,6 +51230,17 @@ function clickSlackIO(client, click, opts = {}) {
     { ...opts, offerMessage: click.offer }
   );
 }
+function takenOfferNote(kind, userId) {
+  const button = kind === "confirm" ? "Run" : "Cancel";
+  const doing = kind === "confirm" ? "running\u2026" : "cancelling\u2026";
+  return { mrkdwn: `*${button}* clicked by <@${userId}> \xB7 ${doing}`, plain: `${button} clicked \xB7 ${doing}` };
+}
+function takenOfferBlocks(blocks, kind, userId) {
+  return [
+    ...blocks.filter((b) => b.type !== "actions"),
+    { type: "context", elements: [{ type: "mrkdwn", text: takenOfferNote(kind, userId).mrkdwn }] }
+  ];
+}
 async function handleConfirmClick(deps, { client, statusClient }, { ack, body, action }, botUserId) {
   await ack();
   const kind = action.action_id === "confirm.run" ? "confirm" : action.action_id === "confirm.cancel" ? "cancel" : void 0;
@@ -50637,6 +51255,19 @@ async function handleConfirmClick(deps, { client, statusClient }, { ack, body, a
     return;
   }
   const threadTs = message4.thread_ts ?? container?.thread_ts ?? message4.ts;
+  try {
+    await client.chat.update({
+      channel,
+      ts: message4.ts,
+      text: `${message4.text ?? ""}
+${takenOfferNote(kind, body.user.id).plain}`,
+      blocks: takenOfferBlocks(message4.blocks ?? [], kind, body.user.id)
+    });
+  } catch (err2) {
+    console.error(
+      `[confirm] ${kind} click on ${id} in ${channel}:${message4.ts}: the buttons could not be taken down \u2014 ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+  }
   let io;
   try {
     const requester = await resolveSlackRequester(client, {
@@ -51683,6 +52314,500 @@ var init_scheduledPanel = __esm({
   }
 });
 
+// ../../src/channels/accessAuth.ts
+import { createPublicKey, verify as cryptoVerify } from "node:crypto";
+function isServiceToken(identity2) {
+  return identity2.sub === "" && typeof identity2.commonName === "string" && identity2.commonName !== "";
+}
+function decodeBase64Url(part) {
+  if (part === "" || /[^A-Za-z0-9_-]/.test(part)) return null;
+  return Buffer.from(part, "base64url");
+}
+function decodeJsonSegment(part) {
+  const buf2 = decodeBase64Url(part);
+  if (!buf2) return null;
+  try {
+    const parsed = JSON.parse(buf2.toString("utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function resolveKey(kid, config, deps) {
+  const cache2 = deps.cache ?? new JwksCache();
+  const cached = cache2.get(kid, deps.now());
+  if (cached) return cached;
+  const ttlMs = (deps.ttlSeconds ?? DEFAULT_JWKS_TTL_SECONDS) * 1e3;
+  const minRefetchIntervalMs = deps.minRefetchIntervalMs ?? DEFAULT_MIN_REFETCH_INTERVAL_MS;
+  const certsUrl = `https://${config.teamDomain}${CERTS_PATH}`;
+  await cache2.refresh(() => deps.fetchJwks(certsUrl), deps.now, ttlMs, minRefetchIntervalMs);
+  return cache2.get(kid, deps.now());
+}
+function claimsValid(claims, config, now) {
+  const nowSec = Math.floor(now / 1e3);
+  if (claims.iss !== `https://${config.teamDomain}`) return false;
+  const aud = claims.aud;
+  const audOk = typeof aud === "string" ? aud === config.aud : Array.isArray(aud) && aud.includes(config.aud);
+  if (!audOk) return false;
+  if (typeof claims.exp !== "number" || claims.exp <= nowSec) return false;
+  if (typeof claims.nbf === "number" && claims.nbf > nowSec + SKEW_SECONDS) return false;
+  if (typeof claims.iat === "number" && claims.iat > nowSec + SKEW_SECONDS) return false;
+  return hasSubject(claims);
+}
+function hasSubject(claims) {
+  if (typeof claims.sub === "string" && claims.sub !== "") return true;
+  const subEmpty = claims.sub === void 0 || claims.sub === "";
+  return subEmpty && typeof claims.common_name === "string" && claims.common_name !== "";
+}
+async function verifyAccessJwt(token2, config, deps) {
+  if (typeof token2 !== "string") return null;
+  const parts = token2.split(".");
+  if (parts.length !== 3) return null;
+  const [rawHeader, rawPayload, rawSignature] = parts;
+  const header4 = decodeJsonSegment(rawHeader);
+  const payload = decodeJsonSegment(rawPayload);
+  if (!header4 || !payload) return null;
+  if (header4.alg !== "RS256") return null;
+  if (typeof header4.kid !== "string" || header4.kid === "") return null;
+  const signature = decodeBase64Url(rawSignature);
+  if (!signature) return null;
+  const jwk = await resolveKey(header4.kid, config, deps);
+  if (!jwk) return null;
+  let signatureOk;
+  try {
+    const key = createPublicKey({ format: "jwk", key: jwk });
+    signatureOk = cryptoVerify("RSA-SHA256", Buffer.from(`${rawHeader}.${rawPayload}`), key, signature);
+  } catch {
+    return null;
+  }
+  if (!signatureOk) return null;
+  if (!claimsValid(payload, config, deps.now())) return null;
+  if (typeof payload.sub !== "string" || payload.sub === "") {
+    return { sub: "", commonName: payload.common_name };
+  }
+  return {
+    sub: payload.sub,
+    email: typeof payload.email === "string" ? payload.email : void 0
+  };
+}
+function normalizeTeamDomain(raw) {
+  return raw.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+}
+function parseAccessConfig(env) {
+  const teamDomain = normalizeTeamDomain(env.ACCESS_TEAM_DOMAIN ?? "");
+  const aud = (env.ACCESS_AUD ?? "").trim();
+  if (teamDomain === "" || aud === "") return null;
+  return { teamDomain, aud };
+}
+var CERTS_PATH, DEFAULT_JWKS_TTL_SECONDS, DEFAULT_MIN_REFETCH_INTERVAL_MS, SKEW_SECONDS, httpJwksFetcher, JwksCache;
+var init_accessAuth = __esm({
+  "../../src/channels/accessAuth.ts"() {
+    "use strict";
+    CERTS_PATH = "/cdn-cgi/access/certs";
+    DEFAULT_JWKS_TTL_SECONDS = 3600;
+    DEFAULT_MIN_REFETCH_INTERVAL_MS = 3e4;
+    SKEW_SECONDS = 60;
+    httpJwksFetcher = async (certsUrl) => {
+      const res = await fetch(certsUrl);
+      if (!res.ok) throw new Error(`JWKS fetch failed: HTTP ${res.status}`);
+      const body = await res.json();
+      const keys = body?.keys;
+      if (!Array.isArray(keys)) throw new Error("JWKS response missing keys[]");
+      return keys;
+    };
+    JwksCache = class {
+      entries = /* @__PURE__ */ new Map();
+      /** Ms of the last SUCCESSFUL JWKS fetch, or null before the first one. Drives
+       *  the negative-cache interval in `refresh`; a failed fetch does not set it. */
+      lastFetchAt = null;
+      /** The in-flight refresh shared by concurrent callers (single-flight); null
+       *  when no fetch is running. It never rejects — `runFetch` swallows failures to
+       *  fail closed — so both the owner and any joiners resolve cleanly. */
+      inFlight = null;
+      /** The fresh JWK for `kid`, or null if absent/expired (expired entries are
+       *  evicted lazily). `now` is milliseconds. */
+      get(kid, now) {
+        const hit = this.entries.get(kid);
+        if (!hit) return null;
+        if (hit.expiresAt <= now) {
+          this.entries.delete(kid);
+          return null;
+        }
+        return hit.jwk;
+      }
+      /** Store every kid'd key from a freshly fetched JWKS with the given absolute
+       *  expiry (ms). Keyless entries are skipped. */
+      put(keys, expiresAt) {
+        for (const jwk of keys) {
+          if (typeof jwk.kid === "string" && jwk.kid !== "") {
+            this.entries.set(jwk.kid, { jwk, expiresAt });
+          }
+        }
+      }
+      /**
+       * Refresh the JWKS to (try to) learn an unknown kid, with two guards against
+       * the unknown-kid amplification vector:
+       *   - single-flight: if a refresh is already running, join it instead of
+       *     firing another — N concurrent unknown kids ⇒ at most one `fetch` call.
+       *   - negative cache: once a fetch has succeeded, another is suppressed until
+       *     `minRefetchIntervalMs` has elapsed, so an unknown kid resolves to null
+       *     WITHOUT a network round-trip inside that window. A genuinely rotated kid
+       *     is still picked up on the first refresh after the interval.
+       * Fail-closed: a fetch failure leaves the store unchanged and does not advance
+       * the last-fetch time. `now` is read lazily (ms) so the injected clock can move
+       * across the await.
+       */
+      async refresh(fetch2, now, ttlMs, minRefetchIntervalMs) {
+        if (this.inFlight) {
+          await this.inFlight;
+          return;
+        }
+        if (this.lastFetchAt !== null && now() - this.lastFetchAt < minRefetchIntervalMs) {
+          return;
+        }
+        this.inFlight = this.runFetch(fetch2, now, ttlMs);
+        try {
+          await this.inFlight;
+        } finally {
+          this.inFlight = null;
+        }
+      }
+      /** Perform one JWKS fetch and fold the result into the store. Never rejects:
+       *  on any failure the store is left unchanged (fail closed) and `lastFetchAt`
+       *  is not advanced, so `resolveKey` returns null and a later verify may retry. */
+      async runFetch(fetch2, now, ttlMs) {
+        try {
+          const keys = await fetch2();
+          const fetchedAt = now();
+          this.put(keys, fetchedAt + ttlMs);
+          this.lastFetchAt = fetchedAt;
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// ../../src/channels/commandHttp.ts
+function normalizePath2(pathname) {
+  let decoded = pathname;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+  }
+  return decoded.replace(/\/{2,}/g, "/");
+}
+function isCommandPath(pathname) {
+  const p = normalizePath2(pathname).toLowerCase();
+  return p === API_ROOT || p === `${API_ROOT}/` || p.startsWith(`${API_ROOT}/`);
+}
+function commandIdFromPath(pathname) {
+  const p = normalizePath2(pathname);
+  if (!p.startsWith(`${API_ROOT}/`)) return void 0;
+  const rest = p.slice(API_ROOT.length + 1);
+  return COMMAND_ID.test(rest) ? rest : void 0;
+}
+function callerIdFor(identity2) {
+  return isServiceToken(identity2) ? `access:svc:${identity2.commonName}` : `access:${identity2.sub}`;
+}
+function accessActor(identity2, grantsFor) {
+  return isServiceToken(identity2) ? resolveActor({ surface: "access-service", subjectId: identity2.commonName }, grantsFor) : resolveActor({ surface: "access-browser", subjectId: identity2.sub }, grantsFor);
+}
+function serviceTokenAllowed(pathname, identity2) {
+  return !isServiceToken(identity2) || isCommandPath(pathname);
+}
+async function resolveAccessActor(identity2, opts) {
+  const actor = accessActor(identity2, opts.grantsFor);
+  if (isServiceToken(identity2)) return actor;
+  if (identity2.viewAs !== void 0 && holdsAll(actor) && isViewablePerson(identity2.viewAs))
+    return viewingAs(actor, identity2.viewAs, opts);
+  if (!identity2.email || !opts.personByEmail) return actor;
+  const person = await opts.personByEmail(identity2.email).catch(() => void 0);
+  if (!person || !person.id.startsWith("slack:")) return actor;
+  const memberOf = opts.channelsOf ? await boundedChannels(opts.channelsOf(person.id), opts.channelsOfTimeoutMs ?? CHANNEL_DIRECTORY_TIMEOUT_MS) : "unknown";
+  return {
+    ...actor,
+    self: [actor.id, person.id],
+    asUser: { id: person.id, ...person.name ? { name: person.name } : {} },
+    ...memberOf === "unknown" ? {} : { memberOf }
+  };
+}
+async function viewingAs(admin, personId, opts) {
+  const [memberOf, name] = await Promise.all([
+    opts.channelsOf ? boundedChannels(opts.channelsOf(personId), opts.channelsOfTimeoutMs ?? CHANNEL_DIRECTORY_TIMEOUT_MS) : Promise.resolve("unknown"),
+    opts.personName ? opts.personName(personId).catch(() => void 0) : Promise.resolve(void 0)
+  ]);
+  const person = {
+    kind: "user",
+    id: personId,
+    // The browser baseline under a subject no config names — what the person's own session
+    // holds, whose `sub` this process does not know (an entry keyed to that sub is the one
+    // thing view-as cannot see; record 0053 names the boundary).
+    grants: opts.grantsFor(`access:${personId}`),
+    self: [personId],
+    asUser: { id: personId, ...name ? { name } : {} },
+    ...memberOf === "unknown" ? {} : { memberOf }
+  };
+  return {
+    ...admin,
+    onBehalfOf: person,
+    asUser: person.asUser,
+    viewingAs: { id: personId, ...name ? { name } : {} }
+  };
+}
+async function boundedChannels(lookup2, timeoutMs) {
+  let timer;
+  try {
+    const answer = await Promise.race([
+      lookup2.catch(() => "unknown"),
+      new Promise((resolve13) => {
+        timer = setTimeout(() => resolve13(LOOKUP_TIMED_OUT), timeoutMs);
+      })
+    ]);
+    return answer === LOOKUP_TIMED_OUT ? "unknown" : answer;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function callerFor(identity2, opts) {
+  return {
+    kind: "access",
+    id: callerIdFor(identity2),
+    actor: await resolveAccessActor(identity2, opts),
+    ...identity2.email && !isServiceToken(identity2) ? { email: identity2.email } : {}
+  };
+}
+function hostOf(url) {
+  if (!url) return void 0;
+  try {
+    return new URL(url).host.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function header2(req, name) {
+  const v = req.headers[name];
+  return Array.isArray(v) ? v[0] : v;
+}
+function originAllowed(req, opts) {
+  const site = header2(req, "sec-fetch-site");
+  if (site !== void 0 && site !== "same-origin" && site !== "none") return false;
+  const origin = header2(req, "origin");
+  if (origin === void 0) return true;
+  const expected = originOf(opts.publicBaseUrl);
+  if (expected !== void 0) return originOf(origin) === expected;
+  const host = header2(req, "host")?.toLowerCase();
+  const actual = hostOf(origin);
+  return host !== void 0 && actual !== void 0 && actual === host;
+}
+function originOf(url) {
+  if (!url) return void 0;
+  try {
+    const o = new URL(url).origin;
+    return o === "null" ? void 0 : o.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function isJsonContentType(req) {
+  const ct = header2(req, "content-type");
+  return ct !== void 0 && ct.split(";")[0].trim().toLowerCase() === "application/json";
+}
+function createCommandHttpHandler(commands, opts) {
+  const maxBytes = opts.maxBodyBytes ?? MAX_BODY_BYTES2;
+  const send = (res, status3, body, extra = {}) => {
+    res.writeHead(status3, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...extra });
+    res.end(JSON.stringify(body));
+  };
+  const refuse3 = (res, status3, code, error, extra = {}) => send(res, status3, { error, code }, extra);
+  return async (req, res, identity2) => {
+    const url = new URL(req.url ?? "/", "http://placeholder.invalid");
+    const id = commandIdFromPath(url.pathname);
+    const cmd = id === void 0 ? void 0 : commands.get(id);
+    if (!cmd || !CommandRegistry.exposedTo(cmd, "access")) {
+      refuse3(res, 404, "not_found", "unknown command");
+      return;
+    }
+    const method = (req.method ?? "GET").toUpperCase();
+    const allow = cmd.effect === "write" ? "POST" : "GET, POST";
+    if (method !== "POST" && (cmd.effect === "write" || method !== "GET")) {
+      refuse3(res, 405, "method_not_allowed", `${cmd.id} accepts ${allow}`, { allow });
+      return;
+    }
+    if (method === "POST" && !isJsonContentType(req)) {
+      refuse3(res, 415, "unsupported_media_type", "content-type must be application/json");
+      return;
+    }
+    if (cmd.effect === "write" && !originAllowed(req, opts)) {
+      refuse3(res, 403, "forbidden_origin", "cross-origin writes are refused");
+      return;
+    }
+    const caller = await callerFor(identity2, opts);
+    if (CommandRegistry.refuses(cmd, caller)) {
+      refuse3(res, ERROR_STATUS.unauthorized, "unauthorized", `${caller.id} is not allowed to run ${cmd.id}`);
+      return;
+    }
+    let named;
+    let keys;
+    if (method === "GET") {
+      named = Object.fromEntries(url.searchParams);
+      keys = "kebab";
+    } else {
+      const read = await readBody(req, maxBytes);
+      if (!read.ok) {
+        refuse3(res, 413, "payload_too_large", "request body too large");
+        req.destroy();
+        return;
+      }
+      let body;
+      try {
+        body = read.body.trim() === "" ? {} : JSON.parse(read.body);
+      } catch {
+        refuse3(res, ERROR_STATUS.invalid_input, "invalid_input", "body must be a JSON object");
+        return;
+      }
+      if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        refuse3(res, ERROR_STATUS.invalid_input, "invalid_input", "body must be a JSON object");
+        return;
+      }
+      named = body;
+      keys = "camel";
+    }
+    const input = namedToInput(cmd, named, keys);
+    if ("error" in input) {
+      refuse3(res, ERROR_STATUS.invalid_input, "invalid_input", input.error);
+      return;
+    }
+    const result = await commands.invoke(cmd.id, input, caller);
+    if (!result.ok) {
+      refuse3(res, result.status, result.error, result.message);
+      return;
+    }
+    send(res, 200, result.value);
+  };
+}
+var API_ROOT, LOOKUP_TIMED_OUT;
+var init_commandHttp = __esm({
+  "../../src/channels/commandHttp.ts"() {
+    "use strict";
+    init_actor();
+    init_commandRegistry();
+    init_commandSurface();
+    init_record();
+    init_accessAuth();
+    init_viewAs();
+    init_http();
+    API_ROOT = "/api";
+    LOOKUP_TIMED_OUT = /* @__PURE__ */ Symbol("channelsOf timed out");
+  }
+});
+
+// ../../src/channels/viewAs.ts
+function viewAsFromCookie(header4) {
+  const raw = Array.isArray(header4) ? header4.join("; ") : header4;
+  if (!raw) return void 0;
+  for (const part of raw.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    if (part.slice(0, eq).trim() !== VIEW_AS_COOKIE) continue;
+    try {
+      const value = decodeURIComponent(part.slice(eq + 1).trim());
+      if (value !== "") return value;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function isViewAsPath(pathname) {
+  return pathname === VIEW_AS_PATH || pathname === VIEW_AS_EXIT_PATH;
+}
+function requestersOf(rows) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (!r.userId || !isViewablePerson(r.userId) || seen.has(r.userId)) continue;
+    seen.set(r.userId, { id: r.userId, ...r.userName ? { name: r.userName } : {} });
+  }
+  return [...seen.values()].sort((a, b) => (a.name ?? a.id).localeCompare(b.name ?? b.id));
+}
+function refuseWhileViewing(res, person) {
+  res.writeHead(403, JSON_NO_STORE);
+  res.end(JSON.stringify({ error: "unauthorized", message: viewingRefusal(person) }));
+  return true;
+}
+function cookieHeader(value, deps, clear) {
+  const attrs = [
+    "Path=/",
+    "HttpOnly",
+    "SameSite=Strict",
+    ...deps.secure ? ["Secure"] : [],
+    ...clear ? ["Max-Age=0"] : []
+  ];
+  return `${VIEW_AS_COOKIE}=${encodeURIComponent(value)}; ${attrs.join("; ")}`;
+}
+function createViewAsHandler(deps) {
+  const json3 = (res, status3, body, extra = {}) => {
+    res.writeHead(status3, { ...JSON_NO_STORE, ...extra });
+    res.end(JSON.stringify(body));
+  };
+  return (req, res, ctx) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (!isViewAsPath(url.pathname)) return false;
+    if ((req.method ?? "GET").toUpperCase() !== "POST") {
+      json3(res, 405, { error: "method_not_allowed" }, { allow: "POST" });
+      return true;
+    }
+    if (!originAllowed(req, { publicBaseUrl: deps.publicBaseUrl })) {
+      json3(res, 403, { error: "forbidden_origin" });
+      req.destroy();
+      return true;
+    }
+    if (!holdsAll(ctx.actor)) {
+      json3(res, 403, { error: "unauthorized", message: "Only a session holding every grant may view as a person." });
+      req.destroy();
+      return true;
+    }
+    if (url.pathname === VIEW_AS_EXIT_PATH) {
+      res.writeHead(204, { "set-cookie": cookieHeader("", deps, true), "cache-control": "no-store" });
+      res.end();
+      return true;
+    }
+    readBody(req, MAX_BODY_BYTES3).then((read) => {
+      if (!read.ok) {
+        json3(res, 413, { error: "invalid_input", message: "body too large" });
+        return;
+      }
+      let person;
+      try {
+        person = JSON.parse(read.body).person;
+      } catch {
+        person = void 0;
+      }
+      if (typeof person !== "string" || !isViewablePerson(person)) {
+        json3(res, 400, { error: "invalid_input", message: "person must be a Slack person id" });
+        return;
+      }
+      res.writeHead(204, { "set-cookie": cookieHeader(person, deps, false), "cache-control": "no-store" });
+      res.end();
+    }).catch(() => json3(res, 400, { error: "invalid_input", message: "body unreadable" }));
+    return true;
+  };
+}
+var VIEW_AS_COOKIE, VIEW_AS_PATH, VIEW_AS_EXIT_PATH, MAX_BODY_BYTES3, JSON_NO_STORE;
+var init_viewAs2 = __esm({
+  "../../src/channels/viewAs.ts"() {
+    "use strict";
+    init_viewAs();
+    init_commandHttp();
+    init_http();
+    VIEW_AS_COOKIE = "sb-view-as";
+    VIEW_AS_PATH = "/runs/view-as";
+    VIEW_AS_EXIT_PATH = "/runs/view-as/exit";
+    MAX_BODY_BYTES3 = 1024;
+    JSON_NO_STORE = { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" };
+  }
+});
+
 // ../../src/channels/liveView/html.ts
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -51808,7 +52933,11 @@ function pageFavicon(seed) {
   }
 }
 function makeShellRenderer(assets, capabilities) {
-  return (title, seed) => renderShell(title, { ...seed, capabilities }, assets);
+  return (viewer, title, seed) => renderShell(
+    title,
+    { ...seed, capabilities, ...viewer?.viewingAs ? { viewingAs: viewer.viewingAs } : {} },
+    assets
+  );
 }
 var PAGE_CSP, FORM_PAGE_CSP, WEB_HTML_HEADERS;
 var init_webShell = __esm({
@@ -52166,10 +53295,10 @@ function createLiveViewHandler(deps) {
     return token2 === void 0 ? v : { ...v, token: token2 };
   };
   const liveTokens = () => new Map(index.listActive().map((s) => [s.id, s.token]));
-  const notFoundPage = (res) => {
+  const notFoundPage = (res, viewer) => {
     res.writeHead(404, WEB_HTML_HEADERS);
     res.end(
-      deps.shell("Run not found", {
+      deps.shell(viewer, "Run not found", {
         page: "runNotFound",
         retentionDays: deps.retention ? deps.retention.retentionDays : null
       })
@@ -52224,6 +53353,9 @@ function createLiveViewHandler(deps) {
           all,
           mine,
           ...ctx.actor.asUser ? { asUser: ctx.actor.asUser } : {},
+          // A session holding `all` may view the dashboard as a person (record 0053): the
+          // picker offers the requesters this page names; the seed says nothing to anyone else.
+          ...holdsAll(ctx.actor) ? { viewAs: { people: requestersOf(page2.rows) } } : {},
           retentionDays: deps.retention ? deps.retention.retentionDays : null,
           now: now(),
           rows: [...page2.rows],
@@ -52232,7 +53364,7 @@ function createLiveViewHandler(deps) {
           ...page2.olderThan !== void 0 ? { olderThan: page2.olderThan } : {}
         };
         res.writeHead(200, WEB_HTML_HEADERS);
-        res.end(deps.shell(title, seed));
+        res.end(deps.shell(ctx.actor, title, seed));
       };
       if (!all) {
         run2(
@@ -52248,7 +53380,7 @@ function createLiveViewHandler(deps) {
       const scheduled = deps.scheduled;
       if (!scheduled) {
         res.writeHead(200, WEB_HTML_HEADERS);
-        res.end(deps.shell("Scheduled runs", { page: "scheduled", now: now(), rows: null }));
+        res.end(deps.shell(ctx.actor, "Scheduled runs", { page: "scheduled", now: now(), rows: null }));
         return true;
       }
       const visibleTo = readableRuns(ctx.actor);
@@ -52262,7 +53394,7 @@ function createLiveViewHandler(deps) {
           ...firings.ok ? {} : { firingsUnavailable: firings.reason }
         };
         res.writeHead(200, WEB_HTML_HEADERS);
-        res.end(deps.shell("Scheduled runs", seed));
+        res.end(deps.shell(ctx.actor, "Scheduled runs", seed));
       };
       if (!scheduled.store) {
         render3({ ok: false, reason: NO_STORE_REASON });
@@ -52276,7 +53408,7 @@ function createLiveViewHandler(deps) {
       run2(res, async () => {
         const found = await service.listUnitRuns(route3.key, visibleTo);
         if (!found.ok) {
-          notFoundPage(res);
+          notFoundPage(res, ctx.actor);
           return;
         }
         const findings = found.value.pr ? await service.listFindings({ repo: found.value.instance.repo, number: found.value.pr.number }, visibleTo) : void 0;
@@ -52292,7 +53424,7 @@ function createLiveViewHandler(deps) {
           retentionDays: deps.retention ? deps.retention.retentionDays : null
         };
         res.writeHead(200, WEB_HTML_HEADERS);
-        res.end(deps.shell(`Unit ${found.value.id}`, seed));
+        res.end(deps.shell(ctx.actor, `Unit ${found.value.id}`, seed));
       });
       return true;
     }
@@ -52307,7 +53439,7 @@ function createLiveViewHandler(deps) {
         });
         res.writeHead(200, WEB_HTML_HEADERS);
         res.end(
-          deps.shell("Live run", {
+          deps.shell(ctx.actor, "Live run", {
             page: "run",
             mode: "live",
             id: route3.id,
@@ -52349,11 +53481,12 @@ function createLiveViewHandler(deps) {
           finished: snap.finished,
           window: { start: snap.receivedAt ?? snap.startedAt, end: snap.finishedAt ?? now() }
         });
-        res.writeHead(200, JSON_NO_STORE);
+        res.writeHead(200, JSON_NO_STORE2);
         res.end(JSON.stringify({ id: route3.id, finished: snap.finished, diagnosis }));
         return true;
       }
       if (route3.kind === "stop") {
+        if (ctx.actor.viewingAs) return refuseWhileViewing(res, ctx.actor.viewingAs);
         const mode = parseStopMode(url.searchParams.get("mode"));
         if (!mode) {
           text(res, 400, "mode must be soft or hard");
@@ -52365,7 +53498,7 @@ function createLiveViewHandler(deps) {
           else text(res, 404, NOT_FOUND2);
           return true;
         }
-        res.writeHead(200, JSON_NO_STORE);
+        res.writeHead(200, JSON_NO_STORE2);
         res.end(JSON.stringify({ id: route3.id, mode: result.mode, state: "stopping" }));
         return true;
       }
@@ -52380,6 +53513,7 @@ function createLiveViewHandler(deps) {
     const actor = ctx.actor;
     const servable = (view) => view.finished || view.ownerGen !== void 0;
     if (route3.kind === "stop") {
+      if (ctx.actor.viewingAs) return refuseWhileViewing(res, ctx.actor.viewingAs);
       const mode = parseStopMode(url.searchParams.get("mode"));
       if (!mode) {
         text(res, 400, "mode must be soft or hard");
@@ -52401,7 +53535,7 @@ function createLiveViewHandler(deps) {
           else text(res, 404, NOT_FOUND2);
           return;
         }
-        res.writeHead(200, JSON_NO_STORE);
+        res.writeHead(200, JSON_NO_STORE2);
         res.end(JSON.stringify(stopped.value));
       });
       return true;
@@ -52414,7 +53548,7 @@ function createLiveViewHandler(deps) {
           text(res, 404, NOT_FOUND2);
           return;
         }
-        res.writeHead(200, JSON_NO_STORE);
+        res.writeHead(200, JSON_NO_STORE2);
         res.end(JSON.stringify(friction.value));
       });
       return true;
@@ -52428,7 +53562,7 @@ function createLiveViewHandler(deps) {
           sink.write(NOT_FOUND2);
           sink.end();
         } else if (route3.kind === "page") {
-          notFoundPage(res);
+          notFoundPage(res, ctx.actor);
         } else text(res, 404, NOT_FOUND2);
         return;
       }
@@ -52456,7 +53590,7 @@ function createLiveViewHandler(deps) {
         const tokens = liveTokens();
         res.writeHead(200, WEB_HTML_HEADERS);
         res.end(
-          deps.shell("Run", {
+          deps.shell(ctx.actor, "Run", {
             page: "run",
             mode: "history",
             id: route3.id,
@@ -52492,7 +53626,7 @@ function createLiveViewHandler(deps) {
     return true;
   };
 }
-var RESERVED_IDS, INDEX_PAGE_SIZE, RUNS_GET, RUNS_STOP, NOT_FOUND2, TEXT, JSON_NO_STORE, NO_STORE_REASON;
+var RESERVED_IDS, INDEX_PAGE_SIZE, RUNS_GET, RUNS_STOP, NOT_FOUND2, TEXT, JSON_NO_STORE2, NO_STORE_REASON;
 var init_liveView = __esm({
   "../../src/channels/liveView.ts"() {
     "use strict";
@@ -52508,19 +53642,21 @@ var init_liveView = __esm({
     init_runsService();
     init_commandRegistry();
     init_scheduledPanel();
+    init_viewAs();
+    init_viewAs2();
     init_webShell();
     init_favicon();
     init_sse();
     init_html();
     init_sse();
     init_webSeed();
-    RESERVED_IDS = /* @__PURE__ */ new Set(["scheduled", "artifacts", "unit"]);
+    RESERVED_IDS = /* @__PURE__ */ new Set(["scheduled", "artifacts", "unit", "view-as"]);
     INDEX_PAGE_SIZE = 25;
     RUNS_GET = { type: "command", id: "runs.get" };
     RUNS_STOP = { type: "command", id: "runs.stop" };
     NOT_FOUND2 = "run not found";
     TEXT = { "content-type": "text/plain; charset=utf-8" };
-    JSON_NO_STORE = { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" };
+    JSON_NO_STORE2 = { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" };
     NO_STORE_REASON = "schedules.worker is not configured";
   }
 });
@@ -52792,7 +53928,7 @@ function createResidentsViewHandler(deps) {
           runs: live
         };
         res.writeHead(200, WEB_HTML_HEADERS);
-        res.end(shell("Resident repos", seed));
+        res.end(shell(ctx.actor, "Resident repos", seed));
         finish2(200);
         return;
       }
@@ -52802,7 +53938,7 @@ function createResidentsViewHandler(deps) {
         return;
       }
       res.writeHead(200, WEB_HTML_HEADERS);
-      res.end(shell(route3.slug, { page: "resident", slug: route3.slug, record: record2 }));
+      res.end(shell(ctx.actor, route3.slug, { page: "resident", slug: route3.slug, record: record2 }));
       finish2(200);
     });
     return true;
@@ -52827,368 +53963,6 @@ var init_residentsView = __esm({
   }
 });
 
-// ../../src/channels/accessAuth.ts
-import { createPublicKey, verify as cryptoVerify } from "node:crypto";
-function isServiceToken(identity2) {
-  return identity2.sub === "" && typeof identity2.commonName === "string" && identity2.commonName !== "";
-}
-function decodeBase64Url(part) {
-  if (part === "" || /[^A-Za-z0-9_-]/.test(part)) return null;
-  return Buffer.from(part, "base64url");
-}
-function decodeJsonSegment(part) {
-  const buf2 = decodeBase64Url(part);
-  if (!buf2) return null;
-  try {
-    const parsed = JSON.parse(buf2.toString("utf8"));
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function resolveKey(kid, config, deps) {
-  const cache2 = deps.cache ?? new JwksCache();
-  const cached = cache2.get(kid, deps.now());
-  if (cached) return cached;
-  const ttlMs = (deps.ttlSeconds ?? DEFAULT_JWKS_TTL_SECONDS) * 1e3;
-  const minRefetchIntervalMs = deps.minRefetchIntervalMs ?? DEFAULT_MIN_REFETCH_INTERVAL_MS;
-  const certsUrl = `https://${config.teamDomain}${CERTS_PATH}`;
-  await cache2.refresh(() => deps.fetchJwks(certsUrl), deps.now, ttlMs, minRefetchIntervalMs);
-  return cache2.get(kid, deps.now());
-}
-function claimsValid(claims, config, now) {
-  const nowSec = Math.floor(now / 1e3);
-  if (claims.iss !== `https://${config.teamDomain}`) return false;
-  const aud = claims.aud;
-  const audOk = typeof aud === "string" ? aud === config.aud : Array.isArray(aud) && aud.includes(config.aud);
-  if (!audOk) return false;
-  if (typeof claims.exp !== "number" || claims.exp <= nowSec) return false;
-  if (typeof claims.nbf === "number" && claims.nbf > nowSec + SKEW_SECONDS) return false;
-  if (typeof claims.iat === "number" && claims.iat > nowSec + SKEW_SECONDS) return false;
-  return hasSubject(claims);
-}
-function hasSubject(claims) {
-  if (typeof claims.sub === "string" && claims.sub !== "") return true;
-  const subEmpty = claims.sub === void 0 || claims.sub === "";
-  return subEmpty && typeof claims.common_name === "string" && claims.common_name !== "";
-}
-async function verifyAccessJwt(token2, config, deps) {
-  if (typeof token2 !== "string") return null;
-  const parts = token2.split(".");
-  if (parts.length !== 3) return null;
-  const [rawHeader, rawPayload, rawSignature] = parts;
-  const header4 = decodeJsonSegment(rawHeader);
-  const payload = decodeJsonSegment(rawPayload);
-  if (!header4 || !payload) return null;
-  if (header4.alg !== "RS256") return null;
-  if (typeof header4.kid !== "string" || header4.kid === "") return null;
-  const signature = decodeBase64Url(rawSignature);
-  if (!signature) return null;
-  const jwk = await resolveKey(header4.kid, config, deps);
-  if (!jwk) return null;
-  let signatureOk;
-  try {
-    const key = createPublicKey({ format: "jwk", key: jwk });
-    signatureOk = cryptoVerify("RSA-SHA256", Buffer.from(`${rawHeader}.${rawPayload}`), key, signature);
-  } catch {
-    return null;
-  }
-  if (!signatureOk) return null;
-  if (!claimsValid(payload, config, deps.now())) return null;
-  if (typeof payload.sub !== "string" || payload.sub === "") {
-    return { sub: "", commonName: payload.common_name };
-  }
-  return {
-    sub: payload.sub,
-    email: typeof payload.email === "string" ? payload.email : void 0
-  };
-}
-function normalizeTeamDomain(raw) {
-  return raw.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "");
-}
-function parseAccessConfig(env) {
-  const teamDomain = normalizeTeamDomain(env.ACCESS_TEAM_DOMAIN ?? "");
-  const aud = (env.ACCESS_AUD ?? "").trim();
-  if (teamDomain === "" || aud === "") return null;
-  return { teamDomain, aud };
-}
-var CERTS_PATH, DEFAULT_JWKS_TTL_SECONDS, DEFAULT_MIN_REFETCH_INTERVAL_MS, SKEW_SECONDS, httpJwksFetcher, JwksCache;
-var init_accessAuth = __esm({
-  "../../src/channels/accessAuth.ts"() {
-    "use strict";
-    CERTS_PATH = "/cdn-cgi/access/certs";
-    DEFAULT_JWKS_TTL_SECONDS = 3600;
-    DEFAULT_MIN_REFETCH_INTERVAL_MS = 3e4;
-    SKEW_SECONDS = 60;
-    httpJwksFetcher = async (certsUrl) => {
-      const res = await fetch(certsUrl);
-      if (!res.ok) throw new Error(`JWKS fetch failed: HTTP ${res.status}`);
-      const body = await res.json();
-      const keys = body?.keys;
-      if (!Array.isArray(keys)) throw new Error("JWKS response missing keys[]");
-      return keys;
-    };
-    JwksCache = class {
-      entries = /* @__PURE__ */ new Map();
-      /** Ms of the last SUCCESSFUL JWKS fetch, or null before the first one. Drives
-       *  the negative-cache interval in `refresh`; a failed fetch does not set it. */
-      lastFetchAt = null;
-      /** The in-flight refresh shared by concurrent callers (single-flight); null
-       *  when no fetch is running. It never rejects — `runFetch` swallows failures to
-       *  fail closed — so both the owner and any joiners resolve cleanly. */
-      inFlight = null;
-      /** The fresh JWK for `kid`, or null if absent/expired (expired entries are
-       *  evicted lazily). `now` is milliseconds. */
-      get(kid, now) {
-        const hit = this.entries.get(kid);
-        if (!hit) return null;
-        if (hit.expiresAt <= now) {
-          this.entries.delete(kid);
-          return null;
-        }
-        return hit.jwk;
-      }
-      /** Store every kid'd key from a freshly fetched JWKS with the given absolute
-       *  expiry (ms). Keyless entries are skipped. */
-      put(keys, expiresAt) {
-        for (const jwk of keys) {
-          if (typeof jwk.kid === "string" && jwk.kid !== "") {
-            this.entries.set(jwk.kid, { jwk, expiresAt });
-          }
-        }
-      }
-      /**
-       * Refresh the JWKS to (try to) learn an unknown kid, with two guards against
-       * the unknown-kid amplification vector:
-       *   - single-flight: if a refresh is already running, join it instead of
-       *     firing another — N concurrent unknown kids ⇒ at most one `fetch` call.
-       *   - negative cache: once a fetch has succeeded, another is suppressed until
-       *     `minRefetchIntervalMs` has elapsed, so an unknown kid resolves to null
-       *     WITHOUT a network round-trip inside that window. A genuinely rotated kid
-       *     is still picked up on the first refresh after the interval.
-       * Fail-closed: a fetch failure leaves the store unchanged and does not advance
-       * the last-fetch time. `now` is read lazily (ms) so the injected clock can move
-       * across the await.
-       */
-      async refresh(fetch2, now, ttlMs, minRefetchIntervalMs) {
-        if (this.inFlight) {
-          await this.inFlight;
-          return;
-        }
-        if (this.lastFetchAt !== null && now() - this.lastFetchAt < minRefetchIntervalMs) {
-          return;
-        }
-        this.inFlight = this.runFetch(fetch2, now, ttlMs);
-        try {
-          await this.inFlight;
-        } finally {
-          this.inFlight = null;
-        }
-      }
-      /** Perform one JWKS fetch and fold the result into the store. Never rejects:
-       *  on any failure the store is left unchanged (fail closed) and `lastFetchAt`
-       *  is not advanced, so `resolveKey` returns null and a later verify may retry. */
-      async runFetch(fetch2, now, ttlMs) {
-        try {
-          const keys = await fetch2();
-          const fetchedAt = now();
-          this.put(keys, fetchedAt + ttlMs);
-          this.lastFetchAt = fetchedAt;
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// ../../src/channels/commandHttp.ts
-function normalizePath2(pathname) {
-  let decoded = pathname;
-  try {
-    decoded = decodeURIComponent(pathname);
-  } catch {
-  }
-  return decoded.replace(/\/{2,}/g, "/");
-}
-function isCommandPath(pathname) {
-  const p = normalizePath2(pathname).toLowerCase();
-  return p === API_ROOT || p === `${API_ROOT}/` || p.startsWith(`${API_ROOT}/`);
-}
-function commandIdFromPath(pathname) {
-  const p = normalizePath2(pathname);
-  if (!p.startsWith(`${API_ROOT}/`)) return void 0;
-  const rest = p.slice(API_ROOT.length + 1);
-  return COMMAND_ID.test(rest) ? rest : void 0;
-}
-function callerIdFor(identity2) {
-  return isServiceToken(identity2) ? `access:svc:${identity2.commonName}` : `access:${identity2.sub}`;
-}
-function accessActor(identity2, grantsFor) {
-  return isServiceToken(identity2) ? resolveActor({ surface: "access-service", subjectId: identity2.commonName }, grantsFor) : resolveActor({ surface: "access-browser", subjectId: identity2.sub }, grantsFor);
-}
-function serviceTokenAllowed(pathname, identity2) {
-  return !isServiceToken(identity2) || isCommandPath(pathname);
-}
-async function resolveAccessActor(identity2, opts) {
-  const actor = accessActor(identity2, opts.grantsFor);
-  if (isServiceToken(identity2) || !identity2.email || !opts.personByEmail) return actor;
-  const person = await opts.personByEmail(identity2.email).catch(() => void 0);
-  if (!person || !person.id.startsWith("slack:")) return actor;
-  const memberOf = opts.channelsOf ? await boundedChannels(opts.channelsOf(person.id), opts.channelsOfTimeoutMs ?? CHANNEL_DIRECTORY_TIMEOUT_MS) : "unknown";
-  return {
-    ...actor,
-    self: [actor.id, person.id],
-    asUser: { id: person.id, ...person.name ? { name: person.name } : {} },
-    ...memberOf === "unknown" ? {} : { memberOf }
-  };
-}
-async function boundedChannels(lookup2, timeoutMs) {
-  let timer;
-  try {
-    const answer = await Promise.race([
-      lookup2.catch(() => "unknown"),
-      new Promise((resolve13) => {
-        timer = setTimeout(() => resolve13(LOOKUP_TIMED_OUT), timeoutMs);
-      })
-    ]);
-    return answer === LOOKUP_TIMED_OUT ? "unknown" : answer;
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-async function callerFor(identity2, opts) {
-  return {
-    kind: "access",
-    id: callerIdFor(identity2),
-    actor: await resolveAccessActor(identity2, opts),
-    ...identity2.email && !isServiceToken(identity2) ? { email: identity2.email } : {}
-  };
-}
-function hostOf(url) {
-  if (!url) return void 0;
-  try {
-    return new URL(url).host.toLowerCase();
-  } catch {
-    return void 0;
-  }
-}
-function header2(req, name) {
-  const v = req.headers[name];
-  return Array.isArray(v) ? v[0] : v;
-}
-function originAllowed(req, opts) {
-  const site = header2(req, "sec-fetch-site");
-  if (site !== void 0 && site !== "same-origin" && site !== "none") return false;
-  const origin = header2(req, "origin");
-  if (origin === void 0) return true;
-  const expected = originOf(opts.publicBaseUrl);
-  if (expected !== void 0) return originOf(origin) === expected;
-  const host = header2(req, "host")?.toLowerCase();
-  const actual = hostOf(origin);
-  return host !== void 0 && actual !== void 0 && actual === host;
-}
-function originOf(url) {
-  if (!url) return void 0;
-  try {
-    const o = new URL(url).origin;
-    return o === "null" ? void 0 : o.toLowerCase();
-  } catch {
-    return void 0;
-  }
-}
-function isJsonContentType(req) {
-  const ct = header2(req, "content-type");
-  return ct !== void 0 && ct.split(";")[0].trim().toLowerCase() === "application/json";
-}
-function createCommandHttpHandler(commands, opts) {
-  const maxBytes = opts.maxBodyBytes ?? MAX_BODY_BYTES2;
-  const send = (res, status3, body, extra = {}) => {
-    res.writeHead(status3, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...extra });
-    res.end(JSON.stringify(body));
-  };
-  const refuse3 = (res, status3, code, error, extra = {}) => send(res, status3, { error, code }, extra);
-  return async (req, res, identity2) => {
-    const url = new URL(req.url ?? "/", "http://placeholder.invalid");
-    const id = commandIdFromPath(url.pathname);
-    const cmd = id === void 0 ? void 0 : commands.get(id);
-    if (!cmd || !CommandRegistry.exposedTo(cmd, "access")) {
-      refuse3(res, 404, "not_found", "unknown command");
-      return;
-    }
-    const method = (req.method ?? "GET").toUpperCase();
-    const allow = cmd.effect === "write" ? "POST" : "GET, POST";
-    if (method !== "POST" && (cmd.effect === "write" || method !== "GET")) {
-      refuse3(res, 405, "method_not_allowed", `${cmd.id} accepts ${allow}`, { allow });
-      return;
-    }
-    if (method === "POST" && !isJsonContentType(req)) {
-      refuse3(res, 415, "unsupported_media_type", "content-type must be application/json");
-      return;
-    }
-    if (cmd.effect === "write" && !originAllowed(req, opts)) {
-      refuse3(res, 403, "forbidden_origin", "cross-origin writes are refused");
-      return;
-    }
-    const caller = await callerFor(identity2, opts);
-    if (CommandRegistry.refuses(cmd, caller)) {
-      refuse3(res, ERROR_STATUS.unauthorized, "unauthorized", `${caller.id} is not allowed to run ${cmd.id}`);
-      return;
-    }
-    let named;
-    let keys;
-    if (method === "GET") {
-      named = Object.fromEntries(url.searchParams);
-      keys = "kebab";
-    } else {
-      const read = await readBody(req, maxBytes);
-      if (!read.ok) {
-        refuse3(res, 413, "payload_too_large", "request body too large");
-        req.destroy();
-        return;
-      }
-      let body;
-      try {
-        body = read.body.trim() === "" ? {} : JSON.parse(read.body);
-      } catch {
-        refuse3(res, ERROR_STATUS.invalid_input, "invalid_input", "body must be a JSON object");
-        return;
-      }
-      if (typeof body !== "object" || body === null || Array.isArray(body)) {
-        refuse3(res, ERROR_STATUS.invalid_input, "invalid_input", "body must be a JSON object");
-        return;
-      }
-      named = body;
-      keys = "camel";
-    }
-    const input = namedToInput(cmd, named, keys);
-    if ("error" in input) {
-      refuse3(res, ERROR_STATUS.invalid_input, "invalid_input", input.error);
-      return;
-    }
-    const result = await commands.invoke(cmd.id, input, caller);
-    if (!result.ok) {
-      refuse3(res, result.status, result.error, result.message);
-      return;
-    }
-    send(res, 200, result.value);
-  };
-}
-var API_ROOT, LOOKUP_TIMED_OUT;
-var init_commandHttp = __esm({
-  "../../src/channels/commandHttp.ts"() {
-    "use strict";
-    init_actor();
-    init_commandRegistry();
-    init_commandSurface();
-    init_record();
-    init_accessAuth();
-    init_http();
-    API_ROOT = "/api";
-    LOOKUP_TIMED_OUT = /* @__PURE__ */ Symbol("channelsOf timed out");
-  }
-});
-
 // ../../src/channels/web.ts
 import { randomBytes as randomBytes6 } from "node:crypto";
 function parseThreadsRoute(pathname) {
@@ -53428,6 +54202,11 @@ function createWebChatHandler(deps) {
       req.destroy();
       return;
     }
+    if (ctx.actor.viewingAs) {
+      answer(403, { error: "unauthorized", message: viewingRefusal(ctx.actor.viewingAs) });
+      req.destroy();
+      return;
+    }
     const sub = subOf(ctx.actor);
     const threadKey = threadKeyFor(sub, id);
     if (!ownLane(sub, threadKey)) {
@@ -53512,7 +54291,7 @@ function createWebChatHandler(deps) {
     }
     const render3 = (title, seed) => {
       res.writeHead(200, WEB_HTML_HEADERS);
-      res.end(deps.shell(title, seed));
+      res.end(deps.shell(ctx.actor, title, seed));
     };
     const sub = subOf(ctx.actor);
     if (route3.kind === "new") {
@@ -53524,7 +54303,7 @@ function createWebChatHandler(deps) {
     turnsOf(threadKey, ctx.actor).then(async (open2) => {
       if (open2.runs.length === 0 && !ownLane(sub, threadKey)) {
         res.writeHead(404, WEB_HTML_HEADERS);
-        res.end(deps.shell("Run not found", { page: "runNotFound", retentionDays }));
+        res.end(deps.shell(ctx.actor, "Run not found", { page: "runNotFound", retentionDays }));
         return;
       }
       const seed = await seedFor(ctx, route3.id, threadKey, open2);
@@ -53549,6 +54328,7 @@ var init_web2 = __esm({
     init_http();
     init_viewer();
     init_webShell();
+    init_viewAs();
     PLATFORM5 = "web";
     CONVERSATION_ID_BYTES = 10;
     CONVERSATION_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
@@ -53681,7 +54461,7 @@ function createCostsViewHandler(service, shell, opts = {}) {
     Promise.all([orNone(service.report(group, days)), by]).then(([report2, byReport2]) => {
       res.writeHead(200, WEB_HTML_HEADERS);
       res.end(
-        shell(`${report2?.label ?? group} spend`, {
+        shell(ctx.actor, `${report2?.label ?? group} spend`, {
           page: "costs",
           group,
           report: report2,
@@ -53786,7 +54566,7 @@ function createDeliveryViewHandler(deps, shell) {
         res.end(body);
         return;
       }
-      const html = shell(`${report2.repo} delivery`, { page: "delivery", report: report2, repos });
+      const html = shell(ctx.actor, `${report2.repo} delivery`, { page: "delivery", report: report2, repos });
       res.writeHead(200, WEB_HTML_HEADERS);
       res.end(html);
     }).catch((err2) => {
@@ -53963,9 +54743,9 @@ function createSettingsViewHandler(deps, shell) {
       }
       plain4(res, 502, `settings unavailable: ${reason2}`);
     };
-    const render3 = (seed) => {
+    const render3 = (viewer, seed) => {
       res.writeHead(200, WEB_HTML_HEADERS);
-      res.end(shell("Settings", seed));
+      res.end(shell(viewer, "Settings", seed));
     };
     const channel = "channel" in route3 ? route3.channel : void 0;
     deps.callerFor(ctx.identity).then(async (caller) => {
@@ -53981,11 +54761,12 @@ function createSettingsViewHandler(deps, shell) {
           plain4(res, 403, "forbidden");
           return;
         }
-        render3({ ...base, installation: deps.installation() });
+        render3(caller.actor, { ...base, installation: deps.installation() });
         return;
       }
       const part = tab === "mcps" ? await mcpsSeed(caller, channel) : await channelsSeed(caller, channel);
       render3(
+        caller.actor,
         tab === "mcps" ? { ...base, mcps: part } : { ...base, channels: part }
       );
     }).catch(failed);
@@ -55148,7 +55929,7 @@ function handleAdminModelProxyBearer(req, res, deps) {
       req.destroy();
       return;
     }
-    const read = await readBody(req, MAX_BODY_BYTES3);
+    const read = await readBody(req, MAX_BODY_BYTES4);
     if (!read.ok) {
       json3(413, { ok: false, error: "request body too large" });
       return;
@@ -55189,7 +55970,7 @@ function handleAdminModelProxyBearer(req, res, deps) {
     });
   })();
 }
-var MODEL_PROXY_BEARER_PATH, MODEL_PROXY_BEARER_SCOPE, MAX_BODY_BYTES3;
+var MODEL_PROXY_BEARER_PATH, MODEL_PROXY_BEARER_SCOPE, MAX_BODY_BYTES4;
 var init_adminModelProxy = __esm({
   "../../src/channels/adminModelProxy.ts"() {
     "use strict";
@@ -55199,7 +55980,7 @@ var init_adminModelProxy = __esm({
     init_modelProxy();
     MODEL_PROXY_BEARER_PATH = "/admin/model-proxy/bearer";
     MODEL_PROXY_BEARER_SCOPE = "deploy:write";
-    MAX_BODY_BYTES3 = 4096;
+    MAX_BODY_BYTES4 = 4096;
   }
 });
 
@@ -55473,7 +56254,8 @@ ${task}` : task;
         ...prior ? { prior } : {}
       });
       const contract = await contractFor(instance, unit, readers);
-      return { preset: "review", prompt: `${prUrl(instance.repo, brief.pr)}
+      const severity = `severity:${instance.addressSeverity ?? DEFAULT_ADDRESS_SEVERITY}`;
+      return { preset: "review", prompt: `${prUrl(instance.repo, brief.pr)} ${severity}
 
 ${turn}`, contract };
     }
@@ -56758,7 +57540,7 @@ function createGithubWebhookHandler(deps) {
       res.end(JSON.stringify(body2));
     };
     if (req.method !== "POST") return answer(405, { error: "method_not_allowed" });
-    const body = await readBody(req, MAX_BODY_BYTES4);
+    const body = await readBody(req, MAX_BODY_BYTES5);
     if (!body.ok) return answer(413, { error: "too_large" });
     const result = await handleCheckRunIntake(
       { event: one(req.headers[GITHUB_EVENT_HEADER]), signature: one(req.headers[GITHUB_SIGNATURE_HEADER]) },
@@ -56768,14 +57550,14 @@ function createGithubWebhookHandler(deps) {
     answer(result.status, result.body);
   };
 }
-var GITHUB_WEBHOOK_PATH, MAX_BODY_BYTES4, one;
+var GITHUB_WEBHOOK_PATH, MAX_BODY_BYTES5, one;
 var init_githubWebhook = __esm({
   "../../src/channels/githubWebhook.ts"() {
     "use strict";
     init_checksIntake();
     init_http();
     GITHUB_WEBHOOK_PATH = "/webhooks/github";
-    MAX_BODY_BYTES4 = 1024 * 1024;
+    MAX_BODY_BYTES5 = 1024 * 1024;
     one = (v) => Array.isArray(v) ? v[0] : v;
   }
 });
@@ -56892,6 +57674,7 @@ async function runBot() {
   };
   let slackChannelsOf;
   const channelsOf = (actorId) => slackChannelsOf ? slackChannelsOf(actorId) : Promise.resolve("unknown");
+  const personName = (personId) => names.person(personId);
   const mcpWiring = buildMcp(config, processSecrets, {
     publicBaseUrl: process.env.PUBLIC_BASE_URL,
     resolveEmail: (userId) => slackEmailLookup ? slackEmailLookup(userId) : Promise.resolve(void 0),
@@ -57228,7 +58011,7 @@ async function runBot() {
       {
         commands,
         names,
-        callerFor: (identity2) => callerFor(identity2, { grantsFor: (id) => config.grantsFor(id), personByEmail, channelsOf }),
+        callerFor: (identity2) => callerFor(identity2, { grantsFor: (id) => config.grantsFor(id), personByEmail, channelsOf, personName }),
         installation: () => installationSettings(config.config, capabilities),
         vocabulary: {
           agents: Object.keys(AGENTS),
@@ -57292,8 +58075,10 @@ async function runBot() {
       grantsFor: (id) => config.grantsFor(id),
       personByEmail,
       channelsOf,
+      personName,
       publicBaseUrl
     });
+    const viewAsRoutes = createViewAsHandler({ publicBaseUrl, secure: publicBaseUrl?.startsWith("https://") ?? false });
     const commandHttpState = `GET|POST /api/<group>.<verb> (${commands.list().length} commands)`;
     const mcpConnectView = createMcpConnectViewHandler({
       registry: () => mcpWiring.service,
@@ -57374,19 +58159,23 @@ async function runBot() {
             res.end("forbidden");
             return;
           }
-          if (isCommandPath(path)) return commandHttp(req, res, gate.identity);
-          const actor = await resolveAccessActor(gate.identity, {
+          const viewAs = viewAsFromCookie(req.headers.cookie);
+          const identity2 = viewAs !== void 0 ? { ...gate.identity, viewAs } : gate.identity;
+          if (isCommandPath(path)) return commandHttp(req, res, identity2);
+          const actor = await resolveAccessActor(identity2, {
             grantsFor: (id) => config.grantsFor(id),
             personByEmail,
-            channelsOf
+            channelsOf,
+            personName
           });
+          if (viewAsRoutes(req, res, { actor })) return;
           if (liveView2(req, res, { actor })) return;
-          if (webChat(req, res, { actor, identity: gate.identity })) return;
+          if (webChat(req, res, { actor, identity: identity2 })) return;
           if (mcpConnectView(req, res, gate.identity)) return;
           if (residentsView(req, res, { actor })) return;
-          if (costsView(req, res, { identity: gate.identity, actor })) return;
+          if (costsView(req, res, { identity: identity2, actor })) return;
           if (deliveryView(req, res, { actor })) return;
-          if (settingsView(req, res, { identity: gate.identity })) return;
+          if (settingsView(req, res, { identity: identity2 })) return;
           res.writeHead(200, { "content-type": "text/plain" });
           res.end("ok");
         }).catch((err2) => {
@@ -57629,6 +58418,7 @@ var init_index = __esm({
     init_source();
     init_confirmations();
     init_mcpConnectView();
+    init_viewAs2();
     init_lookups();
     init_slackNames();
     init_names();