@coreplane/switchboard 1.240.0 → 1.241.0

package/dist/cli.js

@@ -1032,8 +1032,9 @@ function surfaceKeyFor(actorId) {
 function agentRunAction(agent) {
   return `agent:run:${agent}`;
 }
-function browserReadActions(commandGroups) {
-  return new Set(commandGroups.map((g) => `${g}:read`));
+function browserActions(commandGroups) {
+  if (commandGroups.length === 0) return /* @__PURE__ */ new Set();
+  return /* @__PURE__ */ new Set([...commandGroups.map((g) => `${g}:read`), ...BROWSER_WRITE_ACTIONS]);
 }
 function toSet(v) {
   if (v === "all") return "all";
@@ -1111,7 +1112,7 @@ function parseRestrictConfig(raw, agentNames) {
 }
 function namespaceBaseline(actorId, table) {
   if (actorId.startsWith("slack:")) return table.everyone;
-  if (actorId.startsWith("access:") && !actorId.startsWith("access:svc:")) return table.browserReads;
+  if (actorId.startsWith("access:") && !actorId.startsWith("access:svc:")) return table.browser;
   return NO_GRANTS;
 }
 function grantsTable(source2) {
@@ -1119,7 +1120,7 @@ function grantsTable(source2) {
   const openAgents = (source2.agentNames ?? []).filter((a) => !restrict.agents.has(a)).map(agentRunAction);
   const baselines = {
     everyone: { ...NO_GRANTS, actions: /* @__PURE__ */ new Set([...CHAT_OPEN_ACTIONS, ...openAgents]) },
-    browserReads: { ...NO_GRANTS, actions: browserReadActions(source2.commandGroups ?? []) }
+    browser: { ...NO_GRANTS, actions: browserActions(source2.commandGroups ?? []) }
   };
   const grants = /* @__PURE__ */ new Map();
   const surfaces = /* @__PURE__ */ new Map();
@@ -1164,7 +1165,7 @@ function unionGrants(a, b) {
 function isEmpty(g) {
   return g.actions !== "all" && g.actions.size === 0 && g.channels !== "all" && g.channels.size === 0 && g.repos !== "all" && g.repos.size === 0;
 }
-var ALL_GRANTS, GRANT_ACTOR_PREFIXES, SURFACE_GRANT_PREFIXES, CHAT_OPEN_ACTIONS, grantList, grantsEntrySchema, NO_RESTRICTION, REPO_SLUG_RE, restrictSchema;
+var ALL_GRANTS, GRANT_ACTOR_PREFIXES, SURFACE_GRANT_PREFIXES, CHAT_OPEN_ACTIONS, BROWSER_WRITE_ACTIONS, grantList, grantsEntrySchema, NO_RESTRICTION, REPO_SLUG_RE, restrictSchema;
 var init_grants = __esm({
   "../../src/core/authz/grants.ts"() {
     "use strict";
@@ -1185,6 +1186,7 @@ var init_grants = __esm({
       "memory:write",
       "mcp:write"
     ];
+    BROWSER_WRITE_ACTIONS = ["memory:write", "mcp:write"];
     grantList = z.union([z.literal("all"), z.array(z.string().min(1))]);
     grantsEntrySchema = z.object({ actions: grantList.optional(), channels: grantList.optional(), repos: grantList.optional() }).strict();
     NO_RESTRICTION = Object.freeze({ agents: /* @__PURE__ */ new Set(), repos: /* @__PURE__ */ new Set() });
@@ -1843,6 +1845,9 @@ function runawayTurnCap(maxMinutes) {
 function loopBudget(maxMinutes) {
   return { maxMinutes, maxTurns: runawayTurnCap(maxMinutes) };
 }
+function statusCardRule(examples = '"Implement the fix", "Run the test suite"') {
+  return `Maintain the user-facing status card with the update_status tool. Post your plan as a checklist (\u25CB pending) as soon as you have it, then keep it truthful at every moment: the markers are facts, not intentions. Mark an item \u2731 when you issue the first command that does it, and \u2713 only after you have read the result that proves it happened \u2014 never in the same turn as the command, never because you intend to run it next, never for a reporting or posting step you have not done. The order is: mark the item \u2731, run its commands, read the result, then mark it \u2713 and the next item \u2731. The card shows the command running right now beside your checklist, so a \u2713 item whose command is still running reads as a lie. Items are short outcomes (${examples}), never commands. This is the only progress the user sees while you work.`;
+}
 function conductorSystem(siblings) {
   const readers = siblings.filter((a) => a.identity !== "write");
   const writers = siblings.filter((a) => a.identity === "write");
@@ -1946,7 +1951,7 @@ ${SHOW_FILES}
 
 ${NOTEPAD}
 
-Maintain the user-facing status card with the update_status tool: right after you decide your plan, post it as a checklist (\u25CB pending items), then update it whenever an item starts (\u2731) or finishes (\u2713). Items are short outcomes ("Clone repo and read the diff", "Run the test suite"), never commands. Mark an item \u2713 only after it has actually happened \u2014 never pre-mark reporting/posting steps. This is the only progress the user sees while you work.
+${statusCardRule('"Clone repo and read the diff", "Run the test suite"')}
 
 If the request doesn't name a repository and you can't infer it, ask for it instead of guessing.
 Report outcomes faithfully: if tests fail or a step was skipped, say so plainly.
@@ -1983,7 +1988,7 @@ ${SHOW_FILES}
 
 ${NOTEPAD}
 
-Maintain the user-facing status card with the update_status tool: right after you decide your plan, post it as a checklist (\u25CB pending items), then update it whenever an item starts (\u2731) or finishes (\u2713). Items are short outcomes ("Implement the fix", "Run the test suite"), never commands. Mark an item \u2713 only after it has actually happened \u2014 never pre-mark reporting/posting steps. This is the only progress the user sees while you work.
+${statusCardRule()}
 
 Report outcomes faithfully: if tests fail or a step was skipped, say so plainly.
 ${FENCED_CONTENT_RULE}
@@ -2015,7 +2020,7 @@ ${SHOW_FILES}
 
 ${NOTEPAD}
 
-Maintain the user-facing status card with the update_status tool: right after you decide your plan, post it as a checklist (\u25CB pending items), then update it whenever an item starts (\u2731) or finishes (\u2713). Items are short outcomes ("Implement the fix", "Run the test suite"), never commands. Mark an item \u2713 only after it has actually happened \u2014 never pre-mark reporting/posting steps. This is the only progress the user sees while you work.
+${statusCardRule()}
 
 Report outcomes faithfully: if tests fail or a step was skipped, say so plainly.
 ${FENCED_CONTENT_RULE}
@@ -2050,7 +2055,7 @@ ${REVIEW_VERDICT_INSTRUCTION}
 
 ${NOTEPAD}
 
-Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending), update as items start (\u2731) and finish (\u2713 \u2014 only after they actually happened; never pre-mark reporting steps). Items are short outcomes, never commands.
+${statusCardRule('"Gather the diff and the files", "Analyze the change", "Post the verdict"')}
 
 ${FENCED_CONTENT_RULE}
 Your final message is posted to Slack. Lead with a one-line verdict, then the findings.`;
@@ -2079,7 +2084,7 @@ ${REVIEW_VERDICT_INSTRUCTION}
 
 ${NOTEPAD}
 
-Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending), update as items start (\u2731) and finish (\u2713 \u2014 only after they actually happened; never pre-mark reporting steps). Items are short outcomes, never commands.
+${statusCardRule('"Gather the diff and the files", "Analyze the change", "Post the verdict"')}
 
 ${FENCED_CONTENT_RULE}
 Your final message is posted to Slack. Lead with a one-line verdict, then the findings.`;
@@ -2108,7 +2113,7 @@ ${REVIEW_VERDICT_INSTRUCTION}
 
 ${NOTEPAD}
 
-Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending), update as items start (\u2731) and finish (\u2713 \u2014 only after they actually happened; never pre-mark reporting steps). Items are short outcomes, never commands.
+${statusCardRule('"Gather the diff and the files", "Analyze the change", "Post the verdict"')}
 
 ${FENCED_CONTENT_RULE}
 Your final message is posted to Slack. Lead with a one-line verdict, then the findings.`;
@@ -2121,7 +2126,7 @@ How to work:
 2. Prefer primary sources; corroborate a surprising claim with a second source.
 3. Answer concisely and cite the URLs (or repo paths) you used. If sources conflict or you couldn't verify something, say so plainly. If web search is unconfigured, use web_fetch / the GitHub tools on what you have and say search was unavailable.
 
-Maintain the user-facing status card with the update_status tool: post a short checklist (\u25CB pending) after you plan, and update items as they start (\u2731) and finish (\u2713 \u2014 only once they actually happened).
+${statusCardRule('"Search the sources", "Write the answer"')}
 
 ${FENCED_CONTENT_RULE}
 Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks). Your final message is posted to Slack \u2014 lead with the answer, then supporting detail and sources.`;
@@ -2131,6 +2136,8 @@ Answer directly and concisely. Use Slack-friendly formatting (no markdown header
 
 Your tools work without a workspace: the GitHub tools \u2014 \`github_repos\` (the org repositories you can reach), \`github_tree\` / \`github_file\` / \`github_search_code\` (browse, read, search their code and docs, private repos included), \`github_issue_list\` / \`github_issue_get\` (read issues), \`github_issue_create\` / \`github_issue_update\` / \`github_issue_comment\` / \`github_issue_delete\` (act on issues) \u2014 and \`web_fetch\` (read a public URL). Use them: when the user names a repo loosely ("the switchboard app"), resolve it with github_repos (or the thread) rather than asking; when asked about one of our repos, read it before answering. Report exactly what a tool did (issue number + URL) \u2014 never claim an action you did not perform, and never fabricate file contents, URLs, or command output.
 
+${statusCardRule('"Read the issue and its thread", "Post the comment"')} A one-step answer needs no checklist; post one when the request has steps the person would wait on.
+
 You cannot run commands, clone repositories, edit code, or review pull requests, and you cannot search the web. Other Switchboard agents can: for code changes or PRs tell the user to re-send with \`agent:coding\`; for a PR review, \`agent:review\`; for a web-research question, \`agent:research\` (e.g. "\`agent:coding fix the failing login test in acme/api\`", "\`agent:research compare X and Y\`"). Delete an issue only when the user explicitly asked to delete it (closing is an update).`;
     EXPLORE_SYSTEM = `You are Switchboard's explore agent: a long, read-only investigation of a repository, answering a request from Slack.
 
@@ -2144,7 +2151,7 @@ READ-ONLY: NEVER open a pull request, and never commit or push \u2014 no branch,
 
 You cannot attach or post files: your whole answer is text. Never say a file is attached or below \u2014 name its path in the workspace and describe it (what it shows, its size) instead; a person who needs the file itself asks \`agent:coding\`, which can attach.
 
-Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending) once you have it, and update items as they start (\u2731) and finish (\u2713 \u2014 only after they actually happened). Items are short outcomes ("Clone and install", "Time the full suite"), never commands.
+${statusCardRule('"Clone and install", "Time the full suite"')}
 
 ${NOTEPAD}
 
@@ -2843,7 +2850,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, SHIP_ROUND_RESERVE_MS, SHIP_LOOP_RESERVE_MS, SHIP_FIX_RESERVE_MS, SHIP_MIN_MAX_MINUTES, 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_POLL_MS, MERGE_WAIT_MAX_MS, BUSY_RETRY_MS;
+var MIN, SHIP_ROUND_RESERVE_MS, SHIP_LOOP_RESERVE_MS, SHIP_FIX_RESERVE_MS, SHIP_MIN_MAX_MINUTES, 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_MAX_MS, MERGE_WAIT_CHUNK_MS, BUSY_RETRY_MS;
 var init_coordinator = __esm({
   "../../src/core/ship/coordinator.ts"() {
     "use strict";
@@ -2865,8 +2872,8 @@ var init_coordinator = __esm({
     isAddressSeverity = (v) => ADDRESS_SEVERITIES.includes(v);
     WAIT_MARGIN_MS = 5 * MIN;
     WAIT_CHUNK_MS = 5 * MIN;
-    MERGE_POLL_MS = 5 * MIN;
     MERGE_WAIT_MAX_MS = 60 * MIN;
+    MERGE_WAIT_CHUNK_MS = 5 * MIN;
     BUSY_RETRY_MS = 2 * MIN;
   }
 });
@@ -2963,6 +2970,22 @@ var init_dashboardAuthConfig = __esm({
   }
 });
 
+// ../../src/core/harness/roster.ts
+function isHarnessName(word) {
+  return typeof word === "string" && HARNESS_NAMES.includes(word);
+}
+function harnessForPreset(roster, words, preset) {
+  return roster[words?.[preset] ?? DEFAULT_HARNESS];
+}
+var HARNESS_NAMES, DEFAULT_HARNESS;
+var init_roster = __esm({
+  "../../src/core/harness/roster.ts"() {
+    "use strict";
+    HARNESS_NAMES = ["pi", "opencode"];
+    DEFAULT_HARNESS = "pi";
+  }
+});
+
 // ../../src/tools/web.ts
 import { lookup as dnsLookup } from "node:dns/promises";
 import { Agent, fetch as undiciFetch } from "undici";
@@ -3578,6 +3601,7 @@ function validateConfig(cfg) {
   if (cfg.artifacts !== void 0) validateArtifacts(cfg.artifacts);
   if (cfg.harness !== void 0) validateHarness(cfg.harness);
   if (cfg.pi !== void 0) validatePi(cfg.pi);
+  if (cfg.opencode !== void 0) validateOpenCode(cfg.opencode);
   validateDashboardConfig(cfg.dashboard);
 }
 function validatePi(pi) {
@@ -3597,15 +3621,32 @@ function validatePi(pi) {
 }
 function validateHarness(harness) {
   if (typeof harness !== "object" || harness === null || Array.isArray(harness))
-    throw new Error("config.yaml: harness must be a mapping of preset to pi (a retired key; remove it)");
+    throw new Error(`config.yaml: harness must be a mapping of preset to a harness name (${harnessWords(" or ")})`);
   for (const [preset, value] of Object.entries(harness)) {
     if (!Object.hasOwn(AGENTS, preset)) throw new Error(`config.yaml: harness.${preset} is not a known agent`);
-    if (value !== "pi")
+    if (!isHarnessName(value))
       throw new Error(
-        `config.yaml: harness.${preset} must be pi \u2014 the native loop is deleted and every preset runs on pi; remove the harness block`
+        `config.yaml: harness.${preset}: ${typeof value === "string" ? value : JSON.stringify(value)} is not a harness; the harnesses are ${harnessWords(" and ")}`
       );
   }
 }
+function validateOpenCode(opencode) {
+  if (typeof opencode !== "object" || opencode === null || Array.isArray(opencode))
+    throw new Error("config.yaml: opencode must be a mapping");
+  for (const key of unknownKeys2(opencode, OPENCODE_KEYS))
+    throw new Error(`config.yaml: opencode.${key} is not a known key`);
+  const { compaction } = opencode;
+  if (compaction === void 0) return;
+  if (typeof compaction !== "object" || compaction === null || Array.isArray(compaction))
+    throw new Error("config.yaml: opencode.compaction must be a mapping");
+  for (const key of unknownKeys2(compaction, OPENCODE_COMPACTION_KEYS))
+    throw new Error(`config.yaml: opencode.compaction.${key} is not a known key`);
+  for (const key of Object.keys(OPENCODE_COMPACTION_KEYS)) {
+    const value = compaction[key];
+    if (value !== void 0 && (typeof value !== "number" || !Number.isInteger(value) || value <= 0))
+      throw new Error(`config.yaml: opencode.compaction.${key} must be a positive integer (tokens)`);
+  }
+}
 function validateReferences(references) {
   if (typeof references !== "object" || references === null || Array.isArray(references))
     throw new Error("config.yaml: references must be a mapping");
@@ -3729,7 +3770,7 @@ function validateRuntimeOverrides(ro) {
     }
   }
 }
-var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, PI_KEYS, PI_COMPACTION_KEYS, ROUTE_ANSWER_MODES, REFERENCES_KEYS, ROUTING_KEYS, SHIP_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, SPAWN_KEYS;
 var init_validate = __esm({
   "../../src/config/validate.ts"() {
     "use strict";
@@ -3740,6 +3781,7 @@ var init_validate = __esm({
     init_config();
     init_grants();
     init_registry();
+    init_roster();
     init_web();
     init_registry2();
     MAX_INSTRUCTIONS_LENGTH = 2e3;
@@ -3767,6 +3809,7 @@ var init_validate = __esm({
       references: true,
       harness: true,
       pi: true,
+      opencode: true,
       slack: true,
       runHistory: true,
       runtimeOverrides: true,
@@ -3783,6 +3826,9 @@ var init_validate = __esm({
     MIN_BOUNDARY_MINUTES = 2;
     PI_KEYS = { compaction: true };
     PI_COMPACTION_KEYS = { reserveTokens: true, keepRecentTokens: true };
+    harnessWords = (joiner) => HARNESS_NAMES.join(joiner);
+    OPENCODE_KEYS = { compaction: true };
+    OPENCODE_COMPACTION_KEYS = { buffer: true, keepTokens: true };
     ROUTE_ANSWER_MODES = ["tool", "text"];
     REFERENCES_KEYS = { enabled: true };
     ROUTING_KEYS = { auto: true, model: true, answer: true };
@@ -4284,15 +4330,15 @@ var init_config2 = __esm({
         const us = this.userScope(opts.userId);
         const [agentName, agentLayer] = opts.request.agent !== void 0 ? [opts.request.agent, "request"] : us.agent !== void 0 ? [us.agent, "user"] : ch.agent !== void 0 ? [ch.agent, "channel"] : [this.config.defaults.agent, "default"];
         const boundary = intersectBoundaries(this.boundaryLayers(ch, us));
-        const modelRef2 = opts.request.model ?? us.model ?? ch.model ?? us.models?.[agentName] ?? ch.models?.[agentName] ?? this.config.defaults.models[agentName] ?? this.config.defaults.models["general"];
-        if (!modelRef2) {
+        const modelRef3 = opts.request.model ?? us.model ?? ch.model ?? us.models?.[agentName] ?? ch.models?.[agentName] ?? this.config.defaults.models[agentName] ?? this.config.defaults.models["general"];
+        if (!modelRef3) {
           throw new Error(`No model configured for agent "${agentName}" \u2014 set defaults.models.${agentName} in config.yaml`);
         }
         const effort2 = opts.request.effort ?? us.effort ?? ch.effort ?? us.efforts?.[agentName] ?? ch.efforts?.[agentName] ?? this.config.defaults.efforts?.[agentName];
         return {
           agentName,
           agentLayer,
-          modelRef: modelRef2,
+          modelRef: modelRef3,
           ...effort2 !== void 0 ? { effort: effort2 } : {},
           ...boundary !== void 0 ? { boundary } : {}
         };
@@ -4339,8 +4385,9 @@ var init_config2 = __esm({
       }
       /** The one grants lookup: what `grants[<actorId>]` declares
        *  on top of its namespace's baseline (the chat `open` commands and every
-       *  unrestricted agent for a Slack user, every group's read for a browser
-       *  session), else that baseline alone, else nothing — unioned with the
+       *  unrestricted agent for a Slack user, every group's read and the two
+       *  personal chat writes for a browser session), else that baseline alone,
+       *  else nothing — unioned with the
        *  surface's `<ns>:*` entry when config has one. Attached to every
        *  `Caller.actor`: the ONLY thing `authorize` reads about a caller. */
       grantsFor(actorId) {
@@ -12420,7 +12467,7 @@ var init_costs = __esm({
     };
     DATED_RELEASE_SUFFIX = /^-\d{8}$/;
     DEFAULT_DAYS = 30;
-    MAX_DAYS = 90;
+    MAX_DAYS = 31;
     NullLlmCostSource = class {
       fetchDailyCost(_range) {
         return Promise.resolve(null);
@@ -13062,6 +13109,9 @@ function unitOfIdempotencyKey(key) {
   const head = step.split("/")[0];
   return UNIT_PATTERN.test(head) ? head : void 0;
 }
+function checksSettledEventType(headSha) {
+  return `${CHECKS_SETTLED_EVENT_PREFIX}${headSha}`;
+}
 function coordinatorFields(tag) {
   return tag ? { parentInstanceId: tag.parentInstanceId, idempotencyKey: tag.idempotencyKey } : {};
 }
@@ -13105,7 +13155,19 @@ function isCoordinatorUnit(v) {
   if (r.startedAt !== void 0 && !isFinite(r.startedAt)) return false;
   return true;
 }
-var COORDINATOR_IDENTITY, COORDINATOR_STEP_ACTION, PLAN_MERGE_ACTION, COORDINATOR_STEP_PATH_PREFIX, INSTANCE_ID_PATTERN, STEP_NAME_PATTERN, IDEMPOTENCY_KEY_PATTERN, UNIT_PATTERN, UNIT_KEY_PATTERN, REPO_SLUG2, MAX_TEXT, MAX_REPORT, MAX_ROUNDS, isText, isOptionalText, isFinite, isObject, isPr, isResume, isThread;
+async function sendChecksSettled(workflow, instance, headSha, settledAt) {
+  if (!workflow) return { kind: "no-binding", instance };
+  const type = checksSettledEventType(headSha);
+  const payload = { headSha, settledAt };
+  try {
+    const handle2 = await workflow.get(instance);
+    await handle2.sendEvent({ type, payload });
+    return { kind: "sent", instance, type };
+  } catch (err2) {
+    return { kind: "failed", instance, type, reason: err2 instanceof Error ? err2.message : String(err2) };
+  }
+}
+var COORDINATOR_IDENTITY, COORDINATOR_STEP_ACTION, PLAN_MERGE_ACTION, COORDINATOR_STEP_PATH_PREFIX, INSTANCE_ID_PATTERN, STEP_NAME_PATTERN, IDEMPOTENCY_KEY_PATTERN, UNIT_PATTERN, UNIT_KEY_PATTERN, CHECKS_SETTLED_EVENT_PREFIX, REPO_SLUG2, MAX_TEXT, MAX_REPORT, MAX_ROUNDS, isText, isOptionalText, isFinite, isObject, isPr, isResume, isThread;
 var init_contract2 = __esm({
   "../../src/core/coordinator/contract.ts"() {
     "use strict";
@@ -13118,6 +13180,7 @@ var init_contract2 = __esm({
     IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_-]{0,99}:[A-Za-z0-9_][A-Za-z0-9_./-]{0,119}$/;
     UNIT_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
     UNIT_KEY_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_-]{0,99}:[A-Za-z0-9_-]{1,32}$/;
+    CHECKS_SETTLED_EVENT_PREFIX = "checks-settled-";
     REPO_SLUG2 = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
     MAX_TEXT = 512;
     MAX_REPORT = 2e4;
@@ -16187,13 +16250,22 @@ var init_config4 = __esm({
       options: z6.object({ channel: channelOption }),
       action: "config:read",
       effect: "read",
-      describe: "The effective agent/model/effort for you in this channel, the defaults, both scopes, and what is restricted.",
+      describe: "The effective agent/model/effort for you in this channel, the defaults, both scopes, and what is restricted; without a channel (a browser, a token, the CLI), your settings outside any channel.",
       render: (output) => formatConfigDescription(output),
       handler: async ({ options, caller, deps }) => {
-        const channel = targetChannel(caller, options.channel);
+        const me = meIdOf(caller) ?? caller.id;
+        const channel = options.channel ?? caller.origin?.channelId;
+        if (!channel) {
+          const description2 = {
+            ...await deps.config.describeConfig(`none:${me}`, me),
+            channel: {},
+            channelConfigRestricted: true
+          };
+          return description2;
+        }
         await assertMayReadChannel(caller, channel, deps);
         const description = {
-          ...await deps.config.describeConfig(channel, meIdOf(caller) ?? caller.id),
+          ...await deps.config.describeConfig(channel, me),
           channelConfigRestricted: !mayEditChannel(caller, channel)
         };
         return description;
@@ -20961,7 +21033,7 @@ var init_stores = __esm({
 // ../../src/core/authz/channelDirectory.ts
 function visibilityOf(channelId) {
   if (channelId.startsWith("http:") || channelId.startsWith("mcp:")) return "machine";
-  if (channelId.startsWith("slack:D")) return "dm";
+  if (channelId.startsWith("slack:D") || channelId.startsWith("web:")) return "dm";
   if (channelId.startsWith("slack:G")) return "private";
   return "unknown";
 }
@@ -25607,7 +25679,12 @@ var init_actor = __esm({
       http: "http",
       mcp: "mcp",
       cli: "cli",
-      schedule: "schedule"
+      schedule: "schedule",
+      // The web chat (record 0043): a browser session speaks as text, so its
+      // `access:<sub>` is a chat credential too — the browser actor, its baseline
+      // and its entry. A service token never reaches the chat (the dashboard gate
+      // serves it `/api/*` only), so `access:svc:` is no chat surface.
+      access: "access-browser"
     };
   }
 });
@@ -26048,19 +26125,19 @@ function stagedFromInbox(v) {
 }
 function messageFromInbox(stored, fallbackAt) {
   const m = stored;
-  const str7 = (k) => typeof m[k] === "string" ? m[k] : void 0;
-  const text = str7("text");
-  const userId = str7("userId");
-  const threadKey = str7("threadKey");
-  const channelId = str7("channelId");
+  const str8 = (k) => typeof m[k] === "string" ? m[k] : void 0;
+  const text = str8("text");
+  const userId = str8("userId");
+  const threadKey = str8("threadKey");
+  const channelId = str8("channelId");
   if (text === void 0 || userId === void 0 || threadKey === void 0 || channelId === void 0)
     return void 0;
-  const userName = str7("userName");
-  const authenticatedAs = str7("authenticatedAs");
-  const sourceUrl = str7("sourceUrl");
-  const channelName = str7("channelName");
-  const messageId = str7("messageId");
-  const fromRunId = str7("fromRunId");
+  const userName = str8("userName");
+  const authenticatedAs = str8("authenticatedAs");
+  const sourceUrl = str8("sourceUrl");
+  const channelName = str8("channelName");
+  const messageId = str8("messageId");
+  const fromRunId = str8("fromRunId");
   const at = typeof m.at === "number" && Number.isFinite(m.at) ? m.at : fallbackAt;
   const images = attachmentsFromInbox(m.images);
   const documents = attachmentsFromInbox(m.documents);
@@ -29524,18 +29601,18 @@ var init_textTurns = __esm({
 function maxChildrenOf(cfg) {
   return cfg?.maxChildren ?? DEFAULT_MAX_CHILDREN;
 }
-function childRequestText(request) {
-  const directives = [`agent:${request.preset}`, ...request.budget !== void 0 ? [`budget:${request.budget}`] : []];
-  const branch2 = request.ref !== void 0 ? ` on branch ${request.ref}` : "";
-  const repo = request.repo !== void 0 ? ` in ${request.repo}${branch2}:` : "";
-  return `${directives.join(" ")}${repo} ${request.prompt}`;
+function childRequestText(request2) {
+  const directives = [`agent:${request2.preset}`, ...request2.budget !== void 0 ? [`budget:${request2.budget}`] : []];
+  const branch2 = request2.ref !== void 0 ? ` on branch ${request2.ref}` : "";
+  const repo = request2.repo !== void 0 ? ` in ${request2.repo}${branch2}:` : "";
+  return `${directives.join(" ")}${repo} ${request2.prompt}`;
 }
-function childThreadLead(parent, request) {
+function childThreadLead(parent, request2) {
   const who2 = parent.msg.userName ?? parent.msg.userId;
   const from = parent.msg.sourceUrl !== void 0 ? `[the *${parent.agentName}* run](${parent.msg.sourceUrl})` : `the *${parent.agentName}* run`;
-  const line3 = (request.prompt.split("\n")[0] ?? "").trim();
+  const line3 = (request2.prompt.split("\n")[0] ?? "").trim();
   const snippet = line3.length > 140 ? `${line3.slice(0, 137)}\u2026` : line3;
-  return `\u21B3 *${request.preset}* run for ${who2}, spawned by ${from}: ${snippet}`;
+  return `\u21B3 *${request2.preset}* run for ${who2}, spawned by ${from}: ${snippet}`;
 }
 function platformOf(channelId) {
   const colon = channelId.indexOf(":");
@@ -29561,7 +29638,7 @@ function watchedChild(io, on) {
   if (io.openThread) watched2.openThread = (lead) => io.openThread(lead);
   return watched2;
 }
-async function spawnChild(deps, parent, request) {
+async function spawnChild(deps, parent, request2) {
   const refused6 = (reason3, message4) => ({ kind: "refused", reason: reason3, message: message4 });
   if (parent.depth >= MAX_SPAWN_DEPTH) {
     return refused6(
@@ -29569,10 +29646,10 @@ async function spawnChild(deps, parent, request) {
       `a child run cannot spawn: this run is itself a child, and a tree is ${MAX_SPAWN_DEPTH} level deep \u2014 the run that started it is the one to ask`
     );
   }
-  if (AGENTS[request.preset]?.identity === "write") {
+  if (AGENTS[request2.preset]?.identity === "write") {
     return refused6(
       "spawn_identity",
-      `\`${request.preset}\` runs as a \`write\` identity \u2014 it pushes branches and opens pull requests \u2014 and a spawned child never writes: it reads this conversation and reports; the person who asked starts that work by hand with \`agent:${request.preset}\``
+      `\`${request2.preset}\` runs as a \`write\` identity \u2014 it pushes branches and opens pull requests \u2014 and a spawned child never writes: it reads this conversation and reports; the person who asked starts that work by hand with \`agent:${request2.preset}\``
     );
   }
   const minutesLeft = Math.floor(parent.remainingMs / 6e4);
@@ -29598,7 +29675,7 @@ async function spawnChild(deps, parent, request) {
   }
   let opened;
   try {
-    opened = await parent.io.openThread(childThreadLead(parent, request));
+    opened = await parent.io.openThread(childThreadLead(parent, request2));
   } catch (err2) {
     return refused6("spawn_failed", `the channel could not open the child's thread: ${describe3(err2)}`);
   }
@@ -29610,7 +29687,7 @@ async function spawnChild(deps, parent, request) {
     ...parent.msg.channelName !== void 0 ? { channelName: parent.msg.channelName } : {},
     threadKey: opened.thread.threadKey,
     ...opened.thread.sourceUrl !== void 0 ? { sourceUrl: opened.thread.sourceUrl } : {},
-    text: childRequestText(request),
+    text: childRequestText(request2),
     receivedAt: deps.clock()
   };
   let startedId;
@@ -29647,7 +29724,7 @@ async function spawnChild(deps, parent, request) {
   if (first.kind === "started" || startedId !== void 0) {
     const runId3 = first.kind === "started" ? first.id : startedId;
     console.log(
-      `[spawn] ${parent.msg.threadKey} run ${parent.runId} spawned ${request.preset} run ${runId3} in ${child.threadKey}`
+      `[spawn] ${parent.msg.threadKey} run ${parent.runId} spawned ${request2.preset} run ${runId3} in ${child.threadKey}`
     );
     return {
       kind: "spawned",
@@ -29658,7 +29735,7 @@ async function spawnChild(deps, parent, request) {
   }
   if (first.kind === "threw") return refused6("spawn_failed", describe3(first.err));
   const reason2 = first.outcome.refusal ?? "spawn_failed";
-  console.log(`[spawn] ${parent.msg.threadKey} run ${parent.runId}: ${request.preset} child not started (${reason2})`);
+  console.log(`[spawn] ${parent.msg.threadKey} run ${parent.runId}: ${request2.preset} child not started (${reason2})`);
   return refused6(reason2, lastReply ?? `the child ended (${first.outcome.status}) before it started`);
 }
 function spawnCapabilityFor(deps, parent) {
@@ -29672,8 +29749,8 @@ function spawnCapabilityFor(deps, parent) {
   };
   let previous = Promise.resolve();
   return {
-    spawn: (request, at) => {
-      const turn = previous.then(() => spawnChild(withHook, { ...parent, ...at }, request));
+    spawn: (request2, at) => {
+      const turn = previous.then(() => spawnChild(withHook, { ...parent, ...at }, request2));
       previous = turn.catch(() => {
       });
       return turn;
@@ -29898,6 +29975,14 @@ async function nextTick(wait, ids, ms, signal2) {
     signal2?.removeEventListener("abort", end);
   }
 }
+function endsAwaited(watch) {
+  return new Set(
+    watch.pending().map((id) => {
+      const state = watch.get(id);
+      return state?.kind === "running" && state.continuedBy !== void 0 ? state.continuedBy : id;
+    })
+  );
+}
 var UNAVAILABLE2, NOT_FOUND, CHILD_PRESETS, WRITE_PRESETS, REPO_PRESETS, CHILDREN_PAGES_MAX, spawnRunTool, sendToRunTool, AWAIT_IDS_MAX, awaitRunsTool, listRunsTool, getRunStatusTool, RUN_TOOLS;
 var init_runs2 = __esm({
   "../../src/tools/runs.ts"() {
@@ -29943,17 +30028,17 @@ var init_runs2 = __esm({
           return `error: unknown preset "${preset}" \u2014 one of ${CHILD_PRESETS().join(", ")}`;
         const prompt = String(input.prompt ?? "").trim();
         if (!prompt) return "error: prompt is required \u2014 what the child should do, after this conversation's text";
-        const request = { preset, prompt };
-        if (input.repo !== void 0 && String(input.repo).trim()) request.repo = String(input.repo).trim();
+        const request2 = { preset, prompt };
+        if (input.repo !== void 0 && String(input.repo).trim()) request2.repo = String(input.repo).trim();
         if (input.budget !== void 0) {
           const budget = input.budget;
           if (typeof budget !== "number" || !Number.isInteger(budget) || budget < MIN_BOUNDARY_MINUTES)
             return `error: budget takes a whole number of minutes, at least ${MIN_BOUNDARY_MINUTES}`;
-          request.budget = budget;
+          request2.budget = budget;
         }
         const spawn7 = ctx.spawn ?? nullSpawnCapability;
         const conversation = ctx.conversation ? await ctx.conversation() : void 0;
-        const out = await spawn7.spawn(request, {
+        const out = await spawn7.spawn(request2, {
           remainingMs: ctx.remainingMs?.() ?? Number.POSITIVE_INFINITY,
           ...conversation ? { conversation } : {}
         });
@@ -30063,7 +30148,7 @@ var init_runs2 = __esm({
             });
           }
           const ms = Math.min(AWAIT_POLL_MS, Math.max(0, decision.until - now));
-          await nextTick(wait, new Set(watch.pending()), ms, ctx.signal);
+          await nextTick(wait, endsAwaited(watch), ms, ctx.signal);
         }
       }
     };
@@ -30593,13 +30678,14 @@ ${skill.body}${footer}`;
 });
 
 // ../../src/tools/status.ts
-var updateStatusTool;
+var STATUS_RESULT, updateStatusTool;
 var init_status2 = __esm({
   "../../src/tools/status.ts"() {
     "use strict";
+    STATUS_RESULT = "status updated \u2014 keep it truthful: \u2713 only for items whose result you have already read, \u2731 on the item whose command runs next.";
     updateStatusTool = {
       name: "update_status",
-      description: "Update the short user-facing status checklist shown while you work. Call it right after planning (all items pending) and again whenever an item's state changes. Format: one item per line, prefixed with a state marker: \u2713 done, \u2731 in progress, \u25CB pending. Keep it to 3-6 short outcome-oriented items (what, not how \u2014 never raw commands).",
+      description: "Update the short user-facing status checklist shown while you work. Call it right after planning (all items pending) and again whenever an item's state changes. Format: one item per line, prefixed with a state marker: \u2713 done, \u2731 in progress, \u25CB pending. The markers are facts, not intentions: mark an item \u2731 when you issue the first command that does it, and \u2713 only after you have read its result \u2014 never in the same turn as the command, never because you plan to run it next. The card shows the command running right now beside this list, so the two must agree. Keep it to 3-6 short outcome-oriented items (what, not how \u2014 never raw commands).",
       inputSchema: {
         type: "object",
         properties: {
@@ -30612,7 +30698,7 @@ var init_status2 = __esm({
       },
       async run(input, ctx) {
         ctx.reportProgress?.(String(input.checklist ?? ""));
-        return "status updated";
+        return STATUS_RESULT;
       }
     };
   }
@@ -31185,7 +31271,7 @@ var init_submit = __esm({
           return "no run is recording a handoff here \u2014 it was not recorded (it applies to a coding run started for a plan unit)";
         ctx.onHandoff(parsed.handoff);
         const h = parsed.handoff;
-        const count = (n2, one, many) => `${n2} ${n2 === 1 ? one : many}`;
+        const count = (n2, one2, many) => `${n2} ${n2 === 1 ? one2 : many}`;
         return `handoff recorded: ${count(h.deviations.length, "deviation", "deviations")}, ${count(h.followUps.length, "follow-up", "follow-ups")}, ${h.unproven.length} unproven; a later call replaces this one`;
       }
     };
@@ -31690,8 +31776,8 @@ async function routeRequest(deps, ctx) {
     return { kind: "routed", resolved: resolveRouted(deps, msg, directives, sticky, carried.preset), route: carried };
   }
   if (!routingOn(cfg) || agentSource !== "default" || threadLive) return { kind: "unrouted" };
-  const modelRef2 = cfg.routing?.model ?? cfg.defaults.models["general"];
-  if (!modelRef2) {
+  const modelRef3 = cfg.routing?.model ?? cfg.defaults.models["general"];
+  if (!modelRef3) {
     console.log(`[route] ${msg.threadKey} not routed: no routing.model and no defaults.models.general`);
     return { kind: "unrouted" };
   }
@@ -31699,7 +31785,7 @@ async function routeRequest(deps, ctx) {
   try {
     if (deps.routeModel) model = deps.routeModel;
     else {
-      const ref = parseModelRef(modelRef2);
+      const ref = parseModelRef(modelRef3);
       model = providerRouteModel(deps.completions.get(ref.provider), ref.model, {
         ...cfg.routing?.answer ? { answer: cfg.routing.answer } : {}
       });
@@ -31741,15 +31827,15 @@ async function routeRequest(deps, ctx) {
     )
   );
   if (decision.preset === void 0 && decision.command && ctx.command && deps.commands)
-    return answerCommand(deps.commands, ctx.command, msg, decision.command, modelRef2, root);
+    return answerCommand(deps.commands, ctx.command, msg, decision.command, modelRef3, root);
   if (decision.preset === void 0) {
     console.log(`[route] ${msg.threadKey} not routed (${decision.reason}) \u2014 running ${cfg.defaults.agent}`);
-    return decision.compoundRejected ? { kind: "unrouted", rejected: { preset: cfg.defaults.agent, reason: decision.reason, model: modelRef2 } } : { kind: "unrouted" };
+    return decision.compoundRejected ? { kind: "unrouted", rejected: { preset: cfg.defaults.agent, reason: decision.reason, model: modelRef3 } } : { kind: "unrouted" };
   }
   const resolved = resolveRouted(deps, msg, directives, sticky, decision.preset);
   const { parts, collapsed } = decision;
   console.log(
-    `[route] ${msg.threadKey} routed to ${decision.preset} on ${modelRef2}${parts ? ` (${parts.length} parts)` : ""}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}: ${decision.reason}`
+    `[route] ${msg.threadKey} routed to ${decision.preset} on ${modelRef3}${parts ? ` (${parts.length} parts)` : ""}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}: ${decision.reason}`
   );
   return {
     kind: "routed",
@@ -31757,13 +31843,13 @@ async function routeRequest(deps, ctx) {
     route: {
       preset: decision.preset,
       reason: decision.reason,
-      model: modelRef2,
+      model: modelRef3,
       ...parts ? { parts } : {},
       ...collapsed ? { collapsed } : {}
     }
   };
 }
-async function answerCommand(commands, branch2, msg, decided, modelRef2, root) {
+async function answerCommand(commands, branch2, msg, decided, modelRef3, root) {
   const { deps, io, ending, trace } = branch2;
   const def = commands.get(decided.id);
   if (!def) {
@@ -31773,7 +31859,7 @@ async function answerCommand(commands, branch2, msg, decided, modelRef2, root) {
   const receipt = redactAndCap(chatInvocation(def, decided.input), ROUTE_RECEIPT_CAP);
   const receiptLine = `${ROUTED_RECEIPT_PREFIX} ${receipt}`;
   if (def.effect === "write") {
-    console.log(`[route] ${msg.threadKey} handed back ${def.id} on ${modelRef2}: ${receipt}`);
+    console.log(`[route] ${msg.threadKey} handed back ${def.id} on ${modelRef3}: ${receipt}`);
     await ending.sealAfterReply(
       async () => {
       },
@@ -31781,11 +31867,11 @@ async function answerCommand(commands, branch2, msg, decided, modelRef2, root) {
     );
     return { kind: "command", command: def.id, outcome: "hand_back" };
   }
-  console.log(`[route] ${msg.threadKey} routed to command ${def.id} on ${modelRef2}: ${receipt}`);
+  console.log(`[route] ${msg.threadKey} routed to command ${def.id} on ${modelRef3}: ${receipt}`);
   const route3 = {
     preset: COMMAND_RUN_AGENT,
     reason: `command ${def.id}`,
-    model: modelRef2,
+    model: modelRef3,
     command: def.id,
     input: redactedInput(decided.input),
     receipt
@@ -31814,13 +31900,13 @@ function redactedInput(input) {
     return v === void 0 ? null : text(JSON.stringify(v) ?? String(v));
   };
   const leafOrList = (v) => Array.isArray(v) ? v.map(leaf) : leaf(v);
-  const isRecord7 = (v) => typeof v === "object" && v !== null && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+  const isRecord9 = (v) => typeof v === "object" && v !== null && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
   const entries = (v, of) => Object.fromEntries(
     Object.entries(v).filter(([, x]) => x !== void 0).map(([k, x]) => [k, of(x)])
   );
   const object1 = (v) => entries(v, leafOrList);
-  const object2 = (v) => entries(v, (x) => isRecord7(x) ? object1(x) : leafOrList(x));
-  const object3 = (v) => entries(v, (x) => isRecord7(x) ? object2(x) : leafOrList(x));
+  const object2 = (v) => entries(v, (x) => isRecord9(x) ? object1(x) : leafOrList(x));
+  const object3 = (v) => entries(v, (x) => isRecord9(x) ? object2(x) : leafOrList(x));
   return {
     ...input.args ? { args: input.args.map(leaf) } : {},
     ...input.options ? { options: object3(input.options) } : {}
@@ -33443,10 +33529,12 @@ async function registerRun(deps, ctx) {
     agentSource,
     model: resolved.modelRef,
     traceId: root.traceId,
-    // The harness the run is driven by (harness.md item 8): the object's own
-    // name, so a record can be told from another harness's; none in a
-    // process that starts no run.
-    ...deps.harness ? { harness: deps.harness.harness.name } : {},
+    // The harness the run is driven by (harness.md items 8 and 10): the
+    // object the preset's configuration word picks off the roster, by its
+    // own name, so a record can be told from another harness's; none in a
+    // process that starts no run. A resumed run publishes no meta (above),
+    // and its harness is its row's, not the word's.
+    ...deps.harness ? { harness: harnessForPreset(deps.harness.harnesses, deps.config.config.harness, agent.name).name } : {},
     ...resolved.effort !== void 0 ? { effort: resolved.effort } : {},
     ...repoCtx2.repo !== void 0 ? { repo: repoCtx2.repo } : {},
     ...repoCtx2.ref !== void 0 ? { ref: repoCtx2.ref } : {},
@@ -33766,6 +33854,7 @@ var init_provision = __esm({
     init_reply();
     init_messages();
     init_route();
+    init_roster();
     STATUS_UPDATE_MIN_MS = 3e3;
   }
 });
@@ -35788,6 +35877,12 @@ function reachFor(identity2) {
   if (identity2 === "read") return READ_REACH;
   return NONE_REACH;
 }
+function openCodeToolWord(action) {
+  const mapped = OPENCODE_ACTION_TO_TOOL_WORD[action];
+  if (mapped !== void 0) return mapped;
+  const underscore = action.indexOf("_");
+  return underscore > 0 ? action.slice(underscore + 1) : action;
+}
 function judgeToolCall(tool, input, ctx) {
   const bundle = PI_TOOL_BUNDLES[tool];
   if (bundle === void 0) return outside(`${tool} is not in any bundle the ${ctx.identity} identity reaches`);
@@ -35851,7 +35946,7 @@ function judgePath(path, ctx) {
   if (rel.startsWith("..") || isAbsolute5(rel)) return refused3(`path \u2014 \`${path}\` resolves outside the checkout`);
   return allowed;
 }
-var PI_TOOL_BUNDLES, CODING_REACH, READ_REACH, NONE_REACH, allowed, refused3, outside, isRecord6, CREDENTIAL_FILE, ENV_DUMP, CREDENTIAL_VAR, MERGE_OR_APPROVE, GIT_THEN_PUSH, GIT_PUSH, ANY_PUSH, GH_WRITE_VERB, WRITE_METHOD, GH_API_WRITE, CURL_GITHUB_WRITE;
+var PI_TOOL_BUNDLES, CODING_REACH, READ_REACH, NONE_REACH, allowed, refused3, outside, isRecord6, CREDENTIAL_FILE, ENV_DUMP, CREDENTIAL_VAR, MERGE_OR_APPROVE, GIT_THEN_PUSH, GIT_PUSH, ANY_PUSH, GH_WRITE_VERB, WRITE_METHOD, GH_API_WRITE, CURL_GITHUB_WRITE, OPENCODE_ACTION_TO_TOOL_WORD;
 var init_toolRules = __esm({
   "../../src/core/harness/pi/toolRules.ts"() {
     "use strict";
@@ -35896,6 +35991,19 @@ var init_toolRules = __esm({
     CURL_GITHUB_WRITE = new RegExp(
       `\\bcurl\\b(?=[^;&|]*api\\.github\\.com)(?=[^;&|]*(?:\\s(?:-X|--request)[\\s=]*${WRITE_METHOD}\\b|\\s(?:-d|--data(?:-\\w+)?|--json|-T|--upload-file)[\\s=]))`
     );
+    OPENCODE_ACTION_TO_TOOL_WORD = {
+      shell: "bash",
+      edit: "edit",
+      // OpenCode's `write` and `patch` tools both assert the `edit` action (their
+      // `permission: "edit"`), so `write` is never an action here; a call to the
+      // write tool arrives as `edit`.
+      patch: "edit",
+      read: "read",
+      glob: "find",
+      grep: "grep",
+      webfetch: "web_fetch",
+      websearch: "web_search"
+    };
   }
 });
 
@@ -36667,7 +36775,7 @@ async function runPiHarnessOpen(deps, run2) {
     requeueUnechoed = () => {
       run2.inbox?.requeue(unechoed.splice(0).flatMap((u) => u.inputs));
     };
-    const drainFollowUps = () => {
+    const drainFollowUps2 = () => {
       const inputs = run2.inbox?.drain() ?? [];
       if (inputs.length === 0) return;
       const images = inputs.flatMap(
@@ -36749,7 +36857,7 @@ ${stagedLine}` : prompt;
         note("wrap_up", wrapUpNote(minutesLeft));
         transport.send({ type: "steer", message: wrapUpInstruction(minutesLeft) });
       }
-      drainFollowUps();
+      drainFollowUps2();
     };
     const iterator = transport.lines[Symbol.asyncIterator]();
     let pending2;
@@ -38118,6 +38226,16 @@ async function runLoop(deps, ctx) {
   const postedBefore = resume ? reviewPostedBefore(resume.events) : void 0;
   if (postedBefore) reviewHead = postedBefore.head;
   const facts2 = resume ? harnessFactsOf(resume.row.state.harness) : void 0;
+  const harnessOf = (roster) => facts2 ? roster.harnesses[facts2.harness] : harnessForPreset(roster.harnesses, deps.config.config.harness, agent.name);
+  const unknownWord = facts2 === void 0 ? unknownHarnessWordOf(resume?.row.state.harness) : void 0;
+  const noteUnknownWord = (ending2) => {
+    if (unknownWord === void 0) return;
+    onEvent({
+      type: "run_note",
+      kind: "resumed",
+      summary: `the row names the ${unknownWord.word} harness, which this build does not know; its process (pid ${unknownWord.pid} in container ${unknownWord.container}) was neither judged nor ended here; ${ending2}`
+    });
+  };
   let lastFacts = facts2;
   const saveFacts = (h) => {
     lastFacts = h;
@@ -38134,10 +38252,11 @@ async function runLoop(deps, ctx) {
       if (facts2) {
         if (!deps.harness)
           throw new Error(
-            `the ${agent.name} preset's run left ${facts2.harness} harness facts on its row, but this process has no harness deps to end that process with`
+            `the ${agent.name} preset's run left ${facts2.harness} harness facts on its row, but this process has no harness roster to end that process with`
           );
+        const judge3 = harnessOf(deps.harness);
         const container = deps.harness.containerFor?.(executor, profile.machine) ?? harnessContainerFor(executor, profile.machine);
-        const found = await deps.harness.harness.find(facts2, container).catch((err2) => {
+        const found = await judge3.find(facts2, container).catch((err2) => {
           if (!isContainerGone(err2)) throw err2;
           return "gone";
         });
@@ -38162,29 +38281,32 @@ async function runLoop(deps, ctx) {
             onEvent({
               type: "run_note",
               kind: "resumed",
-              summary: `the run's row carries ${facts2.harness} harness facts (pid ${facts2.pid}), and this run is driven by ${deps.harness.harness.name}: that process was neither judged nor ended here`
+              summary: `the run's row carries ${facts2.harness} harness facts (pid ${facts2.pid}) that the ${judge3.name} harness does not own: that process was neither judged nor ended here`
             });
             break;
           default:
-            await deps.harness.harness.end(facts2, container);
+            await judge3.end(facts2, container);
         }
-      }
+      } else noteUnknownWord("the run finished on the answer it already had");
       answer = answerUnderEnding(finish2.answer, loopEnding, agent.maxMinutes);
     } else {
       if (!deps.harness)
-        throw new Error(`the ${agent.name} preset runs on the pi harness, but this process has no harness deps`);
+        throw new Error(`the ${agent.name} preset runs on a harness, but this process has no harness roster`);
       const harnessDeps = deps.harness;
+      const harness = harnessOf(harnessDeps);
+      noteUnknownWord(`the run was rebuilt on ${harness.name}`);
       const onBotHost = profile.machine === "none";
       const harnessUrl = onBotHost ? deps.harness.loopbackUrl : deps.harness.harnessUrl;
       if (!harnessUrl)
         throw new Error(
-          onBotHost ? "the pi harness needs PORT: a run without a workspace runs pi on the bot host, which reaches the model proxy over loopback" : "the pi harness needs PUBLIC_BASE_URL: the run's container reaches the model proxy through it"
+          onBotHost ? `the ${harness.name} harness needs PORT: a run without a workspace runs its process on the bot host, which reaches the model proxy over loopback` : `the ${harness.name} harness needs PUBLIC_BASE_URL: the run's container reaches the model proxy through it`
         );
       if (ctx.bearer === void 0)
-        throw new Error("the pi harness needs the run's model-proxy bearer, and this process minted none");
+        throw new Error(`the ${harness.name} harness needs the run's model-proxy bearer, and this process minted none`);
       const { provider: providerName, model: modelId } = parseModelRef(resolved.modelRef);
       const providerCfg = deps.config.config.providers[providerName];
-      if (!providerCfg) throw new Error(`the pi harness found no provider named ${providerName} in the config`);
+      if (!providerCfg)
+        throw new Error(`the ${harness.name} harness found no provider named ${providerName} in the config`);
       const prBase = repoCtx.baseRef ?? await coordinatorBase;
       const ownBranch = prBase !== void 0 ? binding?.ref ?? repoCtx.ref : void 0;
       const protectedBranches = [
@@ -38205,7 +38327,7 @@ async function runLoop(deps, ctx) {
         ...facts2 ? { facts: facts2 } : {}
       } : void 0;
       const openRun = () => openThroughSeam(
-        harnessDeps.harness,
+        harness,
         {
           container: harnessDeps.containerFor?.(executor, profile.machine) ?? harnessContainerFor(executor, profile.machine),
           bearer,
@@ -38260,7 +38382,7 @@ async function runLoop(deps, ctx) {
               repoCtx,
               root,
               clock: clock4,
-              harness: harnessDeps.harness,
+              harness,
               replaced: err2,
               facts: lastFacts,
               binding: workspaceBinding,
@@ -38589,6 +38711,16 @@ function answerUnderEnding(text, ending, maxMinutes) {
 ${text}` : `\u26A0\uFE0F ${ending.summary}`;
   }
 }
+function unknownHarnessWordOf(state) {
+  if (typeof state !== "object" || state === null) return void 0;
+  const { harness, pid, container } = state;
+  if (typeof harness !== "string") return void 0;
+  return {
+    word: harness,
+    pid: typeof pid === "number" ? String(pid) : "unknown",
+    container: typeof container === "string" ? container : "unknown"
+  };
+}
 var init_runLoop = __esm({
   "../../src/core/dispatch/runLoop.ts"() {
     "use strict";
@@ -38598,6 +38730,7 @@ var init_runLoop = __esm({
     init_toolsets();
     init_contract4();
     init_relaunch();
+    init_roster();
     init_botHostContainer();
     init_factory();
     init_container();
@@ -38799,8 +38932,8 @@ async function plan(deps, input) {
     label: input.label
   };
   const taskText = shipTaskText(input.requestText, entry.repo);
-  const request = parseShipPlanRequest(taskText);
-  if (request === void 0) {
+  const request2 = parseShipPlanRequest(taskText);
+  if (request2 === void 0) {
     const text2 = taskText || "Implement the task this thread's ship request describes.";
     const planId2 = generatedPlanId(text2, msg.threadKey);
     const graph2 = {
@@ -38826,38 +38959,38 @@ async function plan(deps, input) {
   if (input.agentSource === "route")
     return {
       ok: false,
-      reply: `\u{1F6AB} A routed request never runs a seeded plan \u2014 its units would merge under the runner's grant. Type \`agent:ship plan ${request.planPath}\` to run it.`
+      reply: `\u{1F6AB} A routed request never runs a seeded plan \u2014 its units would merge under the runner's grant. Type \`agent:ship plan ${request2.planPath}\` to run it.`
     };
   let planId;
   try {
-    planId = planIdOf(request.planPath);
+    planId = planIdOf(request2.planPath);
   } catch (err2) {
     return { ok: false, reply: `\u{1F6AB} ${describe6(err2)}` };
   }
   let text;
   try {
-    text = (await deps.readFile(entry.repo, request.planPath, base)).content;
+    text = (await deps.readFile(entry.repo, request2.planPath, base)).content;
   } catch (err2) {
     return {
       ok: false,
-      reply: `\u{1F6AB} The plan \`${request.planPath}\` could not be read at \`${base}\` in ${entry.repo}: ${describe6(err2)}`
+      reply: `\u{1F6AB} The plan \`${request2.planPath}\` could not be read at \`${base}\` in ${entry.repo}: ${describe6(err2)}`
     };
   }
   const graph = parsePlanGraph(text, planId);
   if (graph.units.length === 0)
     return {
       ok: false,
-      reply: `\u{1F6AB} The plan \`${request.planPath}\` has no unit headings (\`### U<n>. <title>\`) \u2014 nothing to run.`
+      reply: `\u{1F6AB} The plan \`${request2.planPath}\` has no unit headings (\`### U<n>. <title>\`) \u2014 nothing to run.`
     };
   let selected;
   try {
-    selected = openPlanCursor(graph, request.units).order;
+    selected = openPlanCursor(graph, request2.units).order;
   } catch (err2) {
     return { ok: false, reply: `\u{1F6AB} ${describe6(err2)}` };
   }
   return {
     ok: true,
-    planned: { planId, path: request.planPath, base, graph, selected, identity: identity2, merge: "runner" }
+    planned: { planId, path: request2.planPath, base, graph, selected, identity: identity2, merge: "runner" }
   };
 }
 function rowsFor(p, selected, instanceId, lastPushOf) {
@@ -39046,6 +39179,19 @@ function readCreateInstanceAnswer(status3, text) {
   const detail = typeof body?.error === "string" ? body.error : text.slice(0, 200);
   return { kind: "unanswered", reason: `HTTP ${status3} \u2014 ${detail}` };
 }
+function readSendEventAnswer(status3, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = void 0;
+  }
+  const body = typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  if (status3 === 200 && body?.ok === true && body.sent === true) return { kind: "sent" };
+  if (status3 === 404 && body?.error === "no_instance") return { kind: "absent" };
+  const detail = typeof body?.error === "string" ? body.error : text.slice(0, 200);
+  return { kind: "unanswered", reason: `HTTP ${status3} \u2014 ${detail}` };
+}
 function readInstanceStatusAnswer(status3, text) {
   let parsed;
   try {
@@ -39060,13 +39206,14 @@ function readInstanceStatusAnswer(status3, text) {
   const detail = typeof body?.error === "string" ? body.error : text.slice(0, 200);
   return { kind: "unanswered", reason: `HTTP ${status3} \u2014 ${detail}` };
 }
-var COORDINATOR_INSTANCES_PATH, COORDINATOR_INSTANCE_STATUS_PREFIX;
+var COORDINATOR_INSTANCES_PATH, COORDINATOR_INSTANCE_STATUS_PREFIX, COORDINATOR_INSTANCE_EVENTS_SUFFIX;
 var init_instancesRoute = __esm({
   "../../src/core/coordinator/instancesRoute.ts"() {
     "use strict";
     init_contract2();
     COORDINATOR_INSTANCES_PATH = "/admin/coordinator/instances";
     COORDINATOR_INSTANCE_STATUS_PREFIX = `${COORDINATOR_INSTANCES_PATH}/`;
+    COORDINATOR_INSTANCE_EVENTS_SUFFIX = "/events";
   }
 });
 
@@ -39112,6 +39259,29 @@ async function fetchInstanceStatusViaShim(opts, id) {
     return { kind: "unanswered", reason: unreachable(err2) };
   }
 }
+function shimWorkflowSender(opts) {
+  return {
+    get: (id) => Promise.resolve({
+      async sendEvent(event) {
+        const at = shimAddress(opts);
+        if ("reason" in at) throw new Error(at.reason);
+        const fetchImpl = opts.fetch ?? fetch;
+        const res = await fetchImpl(
+          `${at.base}${COORDINATOR_INSTANCE_STATUS_PREFIX}${encodeURIComponent(id)}${COORDINATOR_INSTANCE_EVENTS_SUFFIX}`,
+          {
+            method: "POST",
+            headers: { authorization: `Bearer ${at.bearer}`, "content-type": "application/json" },
+            body: JSON.stringify(event),
+            signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+          }
+        );
+        const answer = readSendEventAnswer(res.status, await res.text().catch(() => ""));
+        if (answer.kind === "sent") return;
+        throw new Error(answer.kind === "absent" ? `no such instance: ${id}` : answer.reason);
+      }
+    })
+  };
+}
 var DEFAULT_TIMEOUT_MS, unreachable;
 var init_instancesClient = __esm({
   "../../src/core/coordinator/instancesClient.ts"() {
@@ -39201,10 +39371,10 @@ async function runShipBranch(deps, msg, io, ctx) {
     ...msg.channelName ? { channel: msg.channelName } : {},
     ...msg.userName ? { user: msg.userName } : {}
   };
-  const request = humanize ? humanizeMessageText(directives.text) : directives.text;
+  const request2 = humanize ? humanizeMessageText(directives.text) : directives.text;
   publishText(
     "input",
-    attachments ? `${request} ${attachments}` : request,
+    attachments ? `${request2} ${attachments}` : request2,
     Object.keys(source2).length > 0 ? source2 : void 0
   );
   registry.publish(run2.id, {
@@ -39527,18 +39697,18 @@ async function abandonLostWorkspace(ctx) {
   return restored?.msg;
 }
 function prepareRestartTurn(deps, ctx) {
-  const { request, pending: pending2, clock: clock4, restartOf } = ctx;
+  const { request: request2, pending: pending2, clock: clock4, restartOf } = ctx;
   const merged = mergeFollowUps(pending2);
   const receivedAt = clock4();
   const msg = {
-    ...request,
+    ...request2,
     ...merged ? {
-      text: `${request.text}
+      text: `${request2.text}
 
 ${merged.text}`,
-      ...merged.images || request.images ? { images: [...request.images ?? [], ...merged.images ?? []] } : {},
-      ...merged.documents || request.documents ? { documents: [...request.documents ?? [], ...merged.documents ?? []] } : {},
-      ...merged.staged || request.staged ? { staged: [...request.staged ?? [], ...merged.staged ?? []] } : {}
+      ...merged.images || request2.images ? { images: [...request2.images ?? [], ...merged.images ?? []] } : {},
+      ...merged.documents || request2.documents ? { documents: [...request2.documents ?? [], ...merged.documents ?? []] } : {},
+      ...merged.staged || request2.staged ? { staged: [...request2.staged ?? [], ...merged.staged ?? []] } : {}
     } : {},
     receivedAt,
     originAt: void 0
@@ -39675,7 +39845,7 @@ var init_thread = __esm({
 
 // ../../src/core/dispatch/seed.ts
 function sessionSeed(input) {
-  const { tail, previous, history, request, refusedRequests = [] } = input;
+  const { tail, previous, history, request: request2, refusedRequests = [] } = input;
   const { from, transcript } = tail;
   if (from === 0 && transcript.turns === 0) return void 0;
   const notes = [];
@@ -39750,7 +39920,7 @@ function sessionSeed(input) {
   }
   messages.push({
     role: "user",
-    content: requestContent(request.text, request.images, request.documents, request.references)
+    content: requestContent(request2.text, request2.images, request2.documents, request2.references)
   });
   return {
     messages,
@@ -40247,7 +40417,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     if (attach.kind === "refused") return ended;
     if (attach.kind === "reattach_refused") {
       if (resume) {
-        const request = await abandonLostWorkspace({
+        const request2 = await abandonLostWorkspace({
           msg,
           io,
           refuse: refuse3,
@@ -40261,7 +40431,7 @@ async function dispatch(deps, msg, io, opts = {}) {
           ledgerRun,
           why: attach.why
         });
-        if (request) restartRequest = { request, restartOf: resume.row.runId };
+        if (request2) restartRequest = { request: request2, restartOf: resume.row.runId };
         resumeRowClosed = true;
       }
       return ended;
@@ -40292,10 +40462,10 @@ async function dispatch(deps, msg, io, opts = {}) {
         workspaceFiles.record(pulled);
         line3 = attachmentsLine(pulled);
       } else line3 = noWorkspaceLine(staged);
-      const request = messages[messages.length - 1];
-      if (request && request.role === "user" && line3) {
-        request.content = Array.isArray(request.content) ? [...request.content, { type: "text", text: line3 }] : [
-          { type: "text", text: request.content },
+      const request2 = messages[messages.length - 1];
+      if (request2 && request2.role === "user" && line3) {
+        request2.content = Array.isArray(request2.content) ? [...request2.content, { type: "text", text: line3 }] : [
+          { type: "text", text: request2.content },
           { type: "text", text: line3 }
         ];
       }
@@ -41757,6 +41927,2214 @@ var init_piHarness = __esm({
   }
 });
 
+// ../../src/core/harness/opencode/dispositions.ts
+function openCodeDispositionOf(type) {
+  if (type.startsWith(OPENCODE_RPC_EVENT_PREFIX)) return "folded";
+  return OPENCODE_EVENT_DISPOSITION[type];
+}
+var OPENCODE_RPC_EVENT_PREFIX, OPENCODE_EVENT_DISPOSITION;
+var init_dispositions = __esm({
+  "../../src/core/harness/opencode/dispositions.ts"() {
+    "use strict";
+    init_toolRules();
+    OPENCODE_RPC_EVENT_PREFIX = "rpc.";
+    OPENCODE_EVENT_DISPOSITION = {
+      // The stream's own marker.
+      "server.connected": "structure",
+      // ── Session: the assistant's turn as the record speaks it ────────────────
+      // The tool call and its result, in pi's tool words (the per-call mirror).
+      "session.tool.called": "mapped",
+      "session.tool.success": "mapped",
+      "session.tool.failed": "mapped",
+      // The model's prose as it lands: the narration beside a call (the `assistant`
+      // event) or, for a text-only turn, the answer.
+      "session.text.ended": "mapped",
+      // The context OpenCode compacted, with the summary it wrote (the compaction row).
+      "session.compaction.ended": "mapped",
+      // ── Session: partial output the final record carries (folded) ────────────
+      "session.text.delta": "folded",
+      "session.reasoning.delta": "folded",
+      "session.compaction.delta": "folded",
+      "session.step.streamed": "folded",
+      "session.tool.progress": "folded",
+      "session.tool.input.started": "folded",
+      "session.tool.input.delta": "folded",
+      "session.tool.input.ended": "folded",
+      // ── Session: the notes (a `run_note`) ────────────────────────────────────
+      // The gate's ask and its answer; the bridge acts on these, and on the record
+      // they are the `tool_refused` note a refusal writes (never a second line).
+      "permission.asked": "note",
+      "permission.replied": "note",
+      "session.retry.scheduled": "note",
+      "session.compaction.failed": "note",
+      "session.execution.failed": "note",
+      "session.step.failed": "note",
+      // ── Session: the run's own shape, already recorded (structure) ───────────
+      // A narration's start writes nothing (its end does); the reasoning is
+      // dropped whole, as pi's mirror drops thinking blocks — the record carries
+      // what the model said and was told, never its private replay material.
+      "session.text.started": "structure",
+      "session.reasoning.started": "structure",
+      "session.reasoning.ended": "structure",
+      "session.step.started": "structure",
+      "session.step.ended": "structure",
+      "session.usage.updated": "structure",
+      "session.compaction.started": "structure",
+      "session.created": "structure",
+      "session.execution.started": "structure",
+      "session.execution.succeeded": "structure",
+      "session.execution.interrupted": "structure",
+      "session.idle": "structure",
+      "session.status": "structure",
+      "session.inbox.delivered": "structure",
+      "session.inbox.enqueued": "structure",
+      "session.inbox.cancelled": "structure",
+      "session.inbox.delivery.changed": "structure",
+      "session.instructions.updated": "structure",
+      "session.permissions.updated": "structure",
+      "session.synthetic": "structure",
+      "session.viewed": "structure",
+      // ── Session: the kinds this run never causes (impossible) ────────────────
+      // The custom agent is the one agent and the proxy the one model, chosen at
+      // create; a switch mid-run would be someone else driving the session.
+      "session.agent.selected": "impossible",
+      "session.model.selected": "impossible",
+      // The session is never moved, forked, renamed or deleted under the run.
+      "session.moved": "impossible",
+      "session.forked": "impossible",
+      "session.renamed": "impossible",
+      "session.deleted": "impossible",
+      // The checkout is Switchboard's; OpenCode never reverts it (`snapshots: false`).
+      "session.revert.staged": "impossible",
+      "session.revert.cleared": "impossible",
+      "session.revert.committed": "impossible",
+      // The persistent shell and the skill activation are features this config leaves off.
+      "session.shell.started": "impossible",
+      "session.shell.ended": "impossible",
+      "session.skill.activated": "impossible",
+      // ── The server's global catalogues and status (structure) ────────────────
+      "agent.updated": "structure",
+      "catalog.updated": "structure",
+      "command.updated": "structure",
+      "config.updated": "structure",
+      "filesystem.changed": "structure",
+      "integration.updated": "structure",
+      "mcp.resources.changed": "structure",
+      "mcp.status.changed": "structure",
+      "plugin.updated": "structure",
+      "project.updated": "structure",
+      "reference.updated": "structure",
+      "skill.updated": "structure",
+      "vcs.branch.updated": "structure",
+      "worktree.resolved": "structure",
+      "worktree.updated": "structure",
+      // ── The server's features this run turns off (impossible) ────────────────
+      "credential.switched": "impossible",
+      "credential.updated": "impossible",
+      "form.created": "impossible",
+      "form.cancelled": "impossible",
+      "form.replied": "impossible",
+      "installation.update-available": "impossible",
+      "installation.updated": "impossible",
+      "models-dev.refreshed": "impossible",
+      "persistent-pty.added": "impossible",
+      "persistent-pty.removed": "impossible",
+      "pty.created": "impossible",
+      "pty.deleted": "impossible",
+      "pty.exited": "impossible",
+      "pty.updated": "impossible",
+      "shell.created": "impossible",
+      "shell.deleted": "impossible",
+      "shell.exited": "impossible",
+      "tui.command.execute": "impossible",
+      "tui.prompt.append": "impossible",
+      "tui.session.select": "impossible",
+      "tui.toast.show": "impossible",
+      "websearch.updated": "impossible"
+    };
+  }
+});
+
+// ../../src/core/harness/opencode/client.ts
+function openCodeAuthHeader(password) {
+  return `Basic ${Buffer.from(`${OPENCODE_AUTH_USER}:${password}`).toString("base64")}`;
+}
+function parseFeedRecord(line3) {
+  let value;
+  try {
+    value = JSON.parse(line3);
+  } catch {
+    return void 0;
+  }
+  if (typeof value !== "object" || value === null || !("feed" in value)) return void 0;
+  const feed = value.feed;
+  return feed === "event" || feed === "permissions" || feed === "messages" || feed === "tailer" ? value : void 0;
+}
+function parseHealth(body) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof value !== "object" || value === null) return void 0;
+  const v = value;
+  if (v.healthy !== true || typeof v.version !== "string") return void 0;
+  return { healthy: true, version: v.version, pid: typeof v.pid === "number" ? v.pid : 0 };
+}
+function parseConfigEntries(body) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(value)) return void 0;
+  const entries = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null) return void 0;
+    const e = item;
+    if (typeof e.path !== "string") return void 0;
+    if (e.type === "directory") entries.push({ type: "directory", path: e.path });
+    else if (e.type === "document" && typeof e.info === "object" && e.info !== null)
+      entries.push({ type: "document", path: e.path, info: e.info });
+    else return void 0;
+  }
+  return entries;
+}
+var OPENCODE_VERSION, OPENCODE_VERSION_TEXT, OPENCODE_AUTH_USER, OPENCODE_ROUTES, openCodeSessionRoutes, openCodePermissionReplyRoute;
+var init_client2 = __esm({
+  "../../src/core/harness/opencode/client.ts"() {
+    "use strict";
+    OPENCODE_VERSION = "2.0.3";
+    OPENCODE_VERSION_TEXT = `opencode v${OPENCODE_VERSION}`;
+    OPENCODE_AUTH_USER = "opencode";
+    OPENCODE_ROUTES = {
+      /** `packages/protocol/src/groups/health.ts:16` — answers `Health`; behind the password like every route (`packages/server/src/process.ts:189-192`). */
+      "health.get": { method: "GET", path: "/api/health" },
+      /** `packages/protocol/src/groups/config.ts:9` — the loaded configuration entries, the readiness proof that the run's file took. */
+      "config.get": { method: "GET", path: "/api/config" },
+      /** `packages/protocol/src/groups/plugin.ts:24` — settles plugin activation (the relay plugin) before the first session; 204. */
+      "plugin.awaitActivation": { method: "POST", path: "/api/plugin/await-activation" },
+      /** `packages/protocol/src/groups/event.ts:43` — the SSE stream the tailer subscribes to; volatile by contract. */
+      "event.subscribe": { method: "GET", path: "/api/event" },
+      /** `packages/protocol/src/groups/session.ts:172`. */
+      "session.create": { method: "POST", path: "/api/session" },
+      /** `packages/protocol/src/groups/session.ts:192` — the authored session (the survival word). */
+      "session.import": { method: "POST", path: "/api/session/import" }
+    };
+    openCodeSessionRoutes = (sessionID) => ({
+      /** `packages/protocol/src/groups/session.ts:339` — admits one input; async: the answer is the inbox item, not the turn. */
+      "session.prompt": { method: "POST", path: `/api/session/${sessionID}/prompt` },
+      /** `packages/protocol/src/groups/session.ts:464` — BLOCKS until the agent loop is idle, then 204 (measured: a 239 s wait held open). */
+      "session.wait": { method: "POST", path: `/api/session/${sessionID}/wait` },
+      /** `packages/protocol/src/groups/session.ts:692` — `?continue=true|false`; answers `{ interrupted }`. */
+      "session.interrupt": { method: "POST", path: `/api/session/${sessionID}/interrupt` },
+      /** `packages/protocol/src/groups/message.ts:43` — `?order=asc|desc&limit=1..200&cursor=&type=`; the store, the record's truth. */
+      "session.messages": { method: "GET", path: `/api/session/${sessionID}/message` },
+      /** `packages/protocol/src/groups/permission.ts:85` — the pending asks the session owns. */
+      "session.permission.list": { method: "GET", path: `/api/session/${sessionID}/permission` }
+    });
+    openCodePermissionReplyRoute = (sessionID, requestID) => ({
+      method: "POST",
+      path: `/api/session/${sessionID}/permission/${requestID}/reply`
+    });
+  }
+});
+
+// ../../src/core/harness/opencode/session.ts
+function openCodeReplacedCallNote(tool) {
+  return `The container running OpenCode was replaced while this ${tool} call was in flight; its result was lost \u2014 re-check its effects before re-running it.`;
+}
+function openCodeSettlementNote(s) {
+  return s.action === "synthetic" ? s.text : openCodeReplacedCallNote(s.toolUse.name);
+}
+function openCodeSessionId(runId3) {
+  return `ses_${runId3.replace(/[^A-Za-z0-9]/g, "-")}`;
+}
+function tickingClock(at) {
+  let n2 = 0;
+  return () => at + n2++;
+}
+function textOf2(content) {
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n\n");
+}
+function openCodeToolContent(toolUse, resultText, at, isError = false) {
+  const input = isRecord7(toolUse.input) ? toolUse.input : {};
+  const content = [{ type: "text", text: resultText || "(no output)" }];
+  return {
+    type: "tool",
+    id: toolUse.id,
+    name: toolUse.name,
+    state: isError ? { status: "error", input, error: { message: resultText || "the call was interrupted" }, content } : { status: "completed", input, content },
+    time: { created: at, completed: at }
+  };
+}
+function openCodeCompactionMessage(id, entry, at) {
+  return {
+    id,
+    type: "compaction",
+    status: "completed",
+    reason: "auto",
+    summary: entry.summary,
+    recent: "",
+    time: { created: at }
+  };
+}
+function openCodeStoreMessages(messages, opts) {
+  const out = [];
+  const model = opts.model ?? { providerID: "switchboard", id: "model" };
+  const agent = opts.agent ?? "switchboard";
+  const at = opts.clock ?? tickingClock(opts.at);
+  const resultOf = (toolUseId, from) => {
+    for (let i = from; i < messages.length; i++) {
+      const turn = messages[i];
+      if (turn.role !== "user") break;
+      for (const part of turn.content) {
+        if (part.type === "tool_result" && part.toolUseId === toolUseId) {
+          const text = typeof part.content === "string" ? part.content : part.content.map((c) => c.type === "text" ? c.text : `[${c.type}]`).join("\n");
+          return { text, isError: part.isError === true };
+        }
+      }
+    }
+    return { text: opts.settlements?.get(toolUseId) ?? "", isError: true };
+  };
+  messages.forEach((message4, i) => {
+    if (message4.role === "user") {
+      const text = textOf2(message4.content);
+      const onlyResults = message4.content.length > 0 && message4.content.every((p) => p.type === "tool_result");
+      if (onlyResults) return;
+      out.push({ id: `msg_${opts.sessionID}_u${i}`, type: "user", text, time: { created: at() } });
+      return;
+    }
+    const content = [];
+    for (const part of message4.content) {
+      if (part.type === "text") content.push({ type: "text", text: part.text });
+      else if (part.type === "tool_use") {
+        const result = resultOf(part.id, i + 1);
+        content.push(openCodeToolContent(part, result.text, at(), result.isError));
+      }
+    }
+    if (content.length === 0) return;
+    const now = at();
+    out.push({
+      id: `msg_${opts.sessionID}_a${i}`,
+      type: "assistant",
+      agent,
+      model,
+      content,
+      time: { created: now, completed: now }
+    });
+  });
+  return out;
+}
+function openCodeImportBody(messages, opts) {
+  const clock4 = tickingClock(opts.at);
+  const storeMessages = openCodeStoreMessages(messages, { ...opts, clock: clock4 });
+  (opts.compactions ?? []).forEach(
+    (entry, i) => storeMessages.push(openCodeCompactionMessage(`msg_${opts.sessionID}_c${i}`, entry, clock4()))
+  );
+  const info = {
+    id: opts.sessionID,
+    projectID: "global",
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: { created: opts.at, updated: opts.at },
+    location: opts.location,
+    ...opts.agent ? { agent: opts.agent } : {},
+    ...opts.model ? { model: opts.model } : {}
+  };
+  return { info, messages: storeMessages, location: opts.location };
+}
+function openCodeSeedAndRequest(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      return { seed: messages.slice(0, i), request: textOf2(messages[i].content) };
+    }
+  }
+  return { seed: messages.slice(), request: "" };
+}
+var isRecord7;
+var init_session2 = __esm({
+  "../../src/core/harness/opencode/session.ts"() {
+    "use strict";
+    isRecord7 = (v) => typeof v === "object" && v !== null;
+  }
+});
+
+// ../../src/core/harness/opencode/pluginSource.ts
+var OC_BLOCKED_AT_DOOR_PREFIX, OC_BLOCKED_UNAVAILABLE_PREFIX, OPENCODE_PLUGIN_SOURCE;
+var init_pluginSource = __esm({
+  "../../src/core/harness/opencode/pluginSource.ts"() {
+    "use strict";
+    OC_BLOCKED_AT_DOOR_PREFIX = "authorization refused at the door: ";
+    OC_BLOCKED_UNAVAILABLE_PREFIX = "authorization unavailable: ";
+    OPENCODE_PLUGIN_SOURCE = `// Switchboard's OpenCode plugin. Written into the run's plugin directory by the
+// bot before \`opencode serve\` starts; loaded as \`./plugins/switchboard\`'s
+// \`index.js\`. Imports nothing.
+
+const BEARER_ENV = "SWITCHBOARD_RUN_BEARER";
+const URL_ENV = "SWITCHBOARD_HARNESS_URL";
+/** How long the door ask keeps retrying an unreachable bot before it blocks. */
+const AUTHORIZE_WAIT_MS = 90000;
+const AUTHORIZE_RETRY_MS = 2000;
+/** How long one request for a relayed tool's result may take before it is asked
+ *  again: over the bot's window (30 s, after which it answers the call is still
+ *  running), under this runtime's own header timeout, so a hung connection
+ *  costs a minute of the wait, not five. */
+const TOOL_REQUEST_TIMEOUT_MS = 60000;
+/** How long a relayed call keeps asking a bot it cannot reach before it fails. */
+const TOOL_WAIT_MS = 90000;
+/** A bot that says a call is still running is asked again no sooner than this,
+ *  so a misbehaving bot is never asked in a hot loop. */
+const TOOL_REASK_FLOOR_MS = 1000;
+
+function settings() {
+  const url = process.env[URL_ENV];
+  const bearer = process.env[BEARER_ENV];
+  if (!url || !bearer) throw new Error("switchboard plugin: " + URL_ENV + " and " + BEARER_ENV + " must be set");
+  return { base: url.replace(/\\/$/, ""), bearer };
+}
+
+/** The bot answered, and said no: the status rides along so a caller can tell a
+ *  verdict from a bot it could not reach. */
+class HarnessAnswerError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
+async function call(method, path, body, signal) {
+  const { base, bearer } = settings();
+  const res = await fetch(base + path, {
+    method,
+    headers: { authorization: "Bearer " + bearer, "content-type": "application/json", accept: "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal,
+  });
+  const status = res.status;
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    throw new HarnessAnswerError(
+      "switchboard plugin: " + method + " " + path + " answered " + status + " with a body that is not JSON",
+      status,
+    );
+  }
+  if (!res.ok && status !== 202) {
+    throw new HarnessAnswerError(
+      "switchboard plugin: " + method + " " + path + " answered " + status + ": " + (json.error || text),
+      status,
+    );
+  }
+  return { status, json };
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** The bot's verdict on one tool call at the door. A verdict answers at once,
+ *  and so does a refusal at the door (a 4xx: the bearer wrong, expired or
+ *  revoked, the run not on the harness). A bot that cannot be reached or is
+ *  failing (a network error, a 5xx, a body that is not JSON) is asked again
+ *  every two seconds until the wait is up, then the call is blocked naming why. */
+async function authorize(toolCallId, tool, input) {
+  const started = Date.now();
+  let lastError = "";
+  for (;;) {
+    try {
+      const { json } = await call("POST", "/harness/authorize", { toolCallId, tool, input });
+      return json;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+      const status = err instanceof HarnessAnswerError ? err.status : undefined;
+      if (status !== undefined && status >= 400 && status < 500) {
+        return { allow: false, reason: "${OC_BLOCKED_AT_DOOR_PREFIX}" + lastError };
+      }
+      if (Date.now() - started >= AUTHORIZE_WAIT_MS) {
+        return { allow: false, reason: "${OC_BLOCKED_UNAVAILABLE_PREFIX}the bot did not answer for 90 s (" + lastError + ")" };
+      }
+      await sleep(AUTHORIZE_RETRY_MS);
+    }
+  }
+}
+
+/** pi's abort signal for the call, with this request's own timeout beside it
+ *  where the runtime can combine the two; the timeout alone where it cannot. */
+function requestSignal(signal) {
+  const timeout = typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(TOOL_REQUEST_TIMEOUT_MS) : undefined;
+  if (!timeout) return signal;
+  if (!signal) return timeout;
+  return typeof AbortSignal.any === "function" ? AbortSignal.any([signal, timeout]) : signal;
+}
+
+/** A relayed tool's result. The call is posted with its id; a bot that answers
+ *  that the call is still running (a \`202 pending\`) is asked again with the
+ *  same id until it answers: the bot runs the call once and every later ask
+ *  joins it. A bot that cannot be reached or is failing (a network error, a
+ *  timed-out request, a 5xx) is asked again every two seconds until the wait is
+ *  up, then the call fails naming why; a refusal at the door (a 4xx) fails it
+ *  at once; an abort ends the asking. */
+async function relay(toolCallId, tool, input, signal) {
+  let lastAnswered = Date.now();
+  let lastError = "";
+  for (;;) {
+    if (signal && signal.aborted) throw new Error("switchboard plugin: " + tool + " was aborted before the bot answered");
+    const asked = Date.now();
+    let answer;
+    try {
+      answer = await call("POST", "/harness/tool", { toolCallId, tool, input }, requestSignal(signal));
+    } catch (err) {
+      if (signal && signal.aborted) throw err;
+      const status = err instanceof HarnessAnswerError ? err.status : undefined;
+      if (status !== undefined && status >= 400 && status < 500) throw err;
+      lastError = err instanceof Error ? err.message : String(err);
+      if (Date.now() - lastAnswered >= TOOL_WAIT_MS) {
+        throw new Error("switchboard plugin: the bot did not answer " + tool + " for 90 s (" + lastError + ")");
+      }
+      await sleep(AUTHORIZE_RETRY_MS);
+      continue;
+    }
+    lastAnswered = Date.now();
+    if (answer.status !== 202 && !answer.json.pending) return answer.json;
+    const held = Date.now() - asked;
+    if (held < TOOL_REASK_FLOOR_MS) await sleep(TOOL_REASK_FLOOR_MS - held);
+  }
+}
+
+/** One relayed tool's content in OpenCode's shape: pi's text parts joined into
+ *  one string, an image part named (OpenCode's tool content carries text or a
+ *  file URI, never inline image bytes); never empty. */
+function contentText(content) {
+  if (!Array.isArray(content)) return typeof content === "string" ? content : "";
+  const text = content
+    .map((c) => (c && c.type === "text" ? String(c.text) : c && c.type === "image" ? "[image " + (c.mimeType || "") + "]" : ""))
+    .filter((t) => t.length > 0)
+    .join("\\n");
+  return text;
+}
+
+/** One relayed tool as OpenCode's editor registers it: a DIRECT tool
+ *  (\`codemode: false\`) under its own name and JSON Schema, whose execute runs
+ *  the door and the relay with the model's call id. A refusal at the door or an
+ *  error from the tool becomes the call's error text \u2014 the model reads it. */
+function relayTool(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    input: def.inputSchema,
+    options: { codemode: false },
+    async execute(input, context) {
+      const callId = context && context.id;
+      const verdict = await authorize(callId, def.name, input);
+      if (verdict && verdict.allow === false) throw new Error(verdict.reason || "the bot refused this tool call");
+      const answer = await relay(callId, def.name, input, context && context.signal);
+      const text = contentText(answer.content);
+      if (answer.isError) throw new Error(text || "the tool failed");
+      return { content: text || "(no output)" };
+    },
+  };
+}
+
+export default {
+  id: "switchboard",
+  async setup(ctx) {
+    const { json } = await call("GET", "/harness/tools");
+    const tools = (json && json.tools) || [];
+    await ctx.tool.transform((editor) => {
+      for (const def of tools) editor.add(relayTool(def));
+    });
+    // The seam the harness watches for a call OpenCode is about to run; the gate
+    // itself rides \`permission.asked\` in the bot, never a decision here.
+    ctx.tool.hook("execute.before", () => {});
+  },
+};
+`;
+  }
+});
+
+// ../../src/core/harness/opencode/tailerSource.ts
+var OPENCODE_SERVE_PID_ENV, OPENCODE_TAILER_SOURCE;
+var init_tailerSource = __esm({
+  "../../src/core/harness/opencode/tailerSource.ts"() {
+    "use strict";
+    OPENCODE_SERVE_PID_ENV = "SWITCHBOARD_SERVE_PID";
+    OPENCODE_TAILER_SOURCE = `// Switchboard's OpenCode tailer. Written into the run's directory by the bot
+// and started beside \`opencode serve\`; its stdout is the run's feed. Requires
+// only Node's own modules.
+"use strict";
+const http = require("node:http");
+
+const port = Number(process.env.SWITCHBOARD_HARNESS_PORT);
+const password = process.env.OPENCODE_PASSWORD || "";
+const servePid = Number(process.env.SWITCHBOARD_SERVE_PID) || 0;
+const auth = "Basic " + Buffer.from("opencode:" + password).toString("base64");
+const REFILL_ON = new Set([
+  "session.step.ended",
+  "session.step.failed",
+  "session.execution.succeeded",
+  "session.execution.failed",
+  "session.execution.interrupted",
+]);
+const MIN_BACKOFF_MS = 250;
+const MAX_BACKOFF_MS = 5000;
+const REQUEST_TIMEOUT_MS = 30000;
+const PAGE_LIMIT = 200;
+
+/** sessionID -> Map(messageID -> the message as JSON text): the last list each refill saw. */
+const known = new Map();
+/** Refills run one at a time, in the order their step ends arrived, so the feed's records keep that order. */
+let pending = Promise.resolve();
+let backoffMs = MIN_BACKOFF_MS;
+let connections = 0;
+
+function emit(record) {
+  process.stdout.write(JSON.stringify(record) + "\\n");
+}
+
+function note(text, extra) {
+  emit(Object.assign({ feed: "tailer", at: Date.now(), note: text }, extra || {}));
+}
+
+function detailOf(err) {
+  return String((err && err.message) || err).slice(0, 300);
+}
+
+function request(method, path, accept) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      { host: "127.0.0.1", port, method, path, headers: { authorization: auth, accept } },
+      (res) => {
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => resolve({ status: res.statusCode || 0, body }));
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.setTimeout(REQUEST_TIMEOUT_MS, () => req.destroy(new Error("the request timed out")));
+    req.end();
+  });
+}
+
+async function getJson(path) {
+  const res = await request("GET", path, "application/json");
+  if (res.status !== 200) throw new Error("GET " + path + " answered " + res.status);
+  return JSON.parse(res.body);
+}
+
+/** The session's pending asks, whole; then its messages, the changed ones only. */
+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) });
+  }
+  try {
+    const all = [];
+    let cursor;
+    for (let page = 0; page < 10000; page++) {
+      const query = (cursor ? "cursor=" + encodeURIComponent(cursor) : "order=asc") + "&limit=" + PAGE_LIMIT;
+      const answer = await getJson("/api/session/" + sessionID + "/message?" + query);
+      for (const message of Array.isArray(answer.data) ? answer.data : []) all.push(message);
+      cursor = answer.cursor && answer.cursor.next;
+      if (!cursor) break;
+    }
+    const seen = known.get(sessionID) || new Map();
+    const changed = [];
+    for (const message of all) {
+      const text = JSON.stringify(message);
+      if (seen.get(message.id) !== text) {
+        seen.set(message.id, text);
+        changed.push(message);
+      }
+    }
+    known.set(sessionID, seen);
+    emit({ feed: "messages", at, sessionID, reason, data: changed });
+  } catch (err) {
+    // The session is known from here on even though its list is empty, so the
+    // reconnect sweep covers it: a session whose only refill failed would
+    // otherwise wait for its next step end.
+    if (!known.has(sessionID)) known.set(sessionID, new Map());
+    note("message refill failed", { sessionID, reason, detail: detailOf(err) });
+  }
+}
+
+function queueRefill(sessionID, reason) {
+  pending = pending.then(() => refill(sessionID, reason));
+}
+
+function onEvent(event) {
+  emit({ feed: "event", at: Date.now(), event });
+  if (REFILL_ON.has(event.type) && event.data && typeof event.data.sessionID === "string")
+    queueRefill(event.data.sessionID, event.type);
+}
+
+function connected() {
+  connections++;
+  backoffMs = MIN_BACKOFF_MS;
+  note(connections === 1 ? "connected" : "reconnected", { connections });
+  // A gap is possible only after a drop: refill what a step end during it would have.
+  if (connections > 1) for (const sessionID of known.keys()) queueRefill(sessionID, "reconnect");
+}
+
+/** One subscription; resolves with why it ended. Blocks are \`data:\` lines
+ *  ended by a blank line; a comment line (the heartbeat) has no data. */
+function subscribe() {
+  return new Promise((resolve) => {
+    const req = http.request(
+      { host: "127.0.0.1", port, method: "GET", path: "/api/event", headers: { authorization: auth, accept: "text/event-stream" } },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          res.on("end", () => resolve("the event stream answered " + res.statusCode));
+          return;
+        }
+        connected();
+        let buffer = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          buffer += chunk;
+          let cut;
+          while ((cut = buffer.indexOf("\\n\\n")) >= 0) {
+            const block = buffer.slice(0, cut);
+            buffer = buffer.slice(cut + 2);
+            const data = block
+              .split("\\n")
+              .filter((line) => line.startsWith("data:"))
+              .map((line) => line.slice(5).replace(/^ /, ""))
+              .join("\\n");
+            if (!data) continue;
+            try {
+              onEvent(JSON.parse(data));
+            } catch (err) {
+              note("an event was not JSON", { detail: data.slice(0, 200) });
+            }
+          }
+        });
+        res.on("end", () => resolve("the event stream ended"));
+        res.on("error", (err) => resolve("the event stream failed: " + detailOf(err)));
+      },
+    );
+    req.on("error", (err) => resolve("the event stream could not be opened: " + detailOf(err)));
+    req.end();
+  });
+}
+
+function serveAlive() {
+  if (!servePid) return true;
+  try {
+    process.kill(servePid, 0);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+async function main() {
+  note("started", { port, servePid });
+  for (;;) {
+    const why = await subscribe();
+    note("stream closed", { detail: why });
+    await pending.catch(() => {});
+    if (!serveAlive()) {
+      note("the server process is gone; exiting");
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, backoffMs));
+    backoffMs = Math.min(MAX_BACKOFF_MS, backoffMs * 2);
+  }
+}
+
+process.on("SIGTERM", () => process.exit(0));
+process.on("SIGINT", () => process.exit(0));
+main().then(
+  () => process.exit(0),
+  (err) => {
+    note("tailer failed", { detail: String((err && err.stack) || err).slice(0, 600) });
+    process.exit(1);
+  },
+);
+`;
+  }
+});
+
+// ../../src/core/harness/opencode/process.ts
+import { randomBytes as randomBytes5 } from "node:crypto";
+function openCodeRunPaths(runId3) {
+  return openCodeRunPathsAt(`/tmp/switchboard-oc-${runId3}`);
+}
+function openCodeRunPathsAt(dir) {
+  const xdg = {
+    data: `${dir}/xdg/data`,
+    config: `${dir}/xdg/config`,
+    cache: `${dir}/xdg/cache`,
+    state: `${dir}/xdg/state`
+  };
+  const pluginDir = `${dir}/plugins/switchboard`;
+  const commandDir = `${dir}/cmd`;
+  const feed = `${dir}/feed.jsonl`;
+  return {
+    dir,
+    // The directories the start makes at 700, the root first.
+    dirs: [dir, xdg.data, xdg.config, xdg.cache, xdg.state, pluginDir, commandDir],
+    fifo: `${dir}/serve.in`,
+    log: `${dir}/serve.log`,
+    errLog: `${dir}/serve.err`,
+    pidFile: `${dir}/pid`,
+    commandDir,
+    xdg,
+    config: `${dir}/opencode.json`,
+    pluginDir,
+    plugin: `${pluginDir}/index.js`,
+    feed,
+    tailerScript: `${dir}/tailer.js`,
+    tailer: {
+      dir,
+      dirs: [dir],
+      fifo: `${dir}/tailer.in`,
+      log: feed,
+      errLog: `${dir}/tailer.err`,
+      pidFile: `${dir}/tailer.pid`,
+      commandDir
+    }
+  };
+}
+function openCodeDeniedActions(identity2) {
+  if (identity2 === "write") return OPENCODE_ALWAYS_DENIED;
+  if (identity2 === "read") return [...OPENCODE_ALWAYS_DENIED, ...OPENCODE_READ_DENIED];
+  return [...OPENCODE_ALWAYS_DENIED, ...OPENCODE_NONE_DENIED];
+}
+function openCodePermissionRules(identity2) {
+  return [
+    ASK_ALL_RULE,
+    ...openCodeDeniedActions(identity2).map((action) => ({ action, resource: "*", effect: "deny" }))
+  ];
+}
+function openCodeBuiltinToolsFor(identity2) {
+  if (identity2 === "write") return OPENCODE_BUILTIN_TOOLS;
+  if (identity2 === "read") return OPENCODE_READ_TOOLS;
+  return OPENCODE_NO_TOOLS;
+}
+function openCodeProviderPackage(providerType) {
+  return providerType === "anthropic" ? "aisdk:@ai-sdk/anthropic" : "aisdk:@ai-sdk/openai-compatible";
+}
+function openCodeProviderBaseUrl(harnessUrl) {
+  return `${harnessUrl.replace(/\/$/, "")}/v1`;
+}
+function openCodePromptNote(relayTools, identity2) {
+  const named = relayTools.map((t) => `\`${t}\``).join(", ");
+  if (identity2 === "none") {
+    return [
+      "HARNESS NOTE: this run has no workspace, so none of OpenCode's own tools (`read`, `shell`, `edit`, `write`, `glob`, `grep` and `skill`) is available, and a call to any of them is refused.",
+      relayTools.length > 0 ? `This run's tools are exactly these, each under its own name: ${named}.` : "No tools are available in this run."
+    ].join(" ");
+  }
+  const write = identity2 === "write";
+  return [
+    write ? "HARNESS NOTE: this run's workspace tools are OpenCode's own \u2014 `read`, `shell`, `edit`, `write`, `glob`, `grep` and `skill`, all running in the worktree." : "HARNESS NOTE: this run's workspace tools are OpenCode's own \u2014 `read`, `shell`, `glob`, `grep` and `skill`, all running in the worktree; it has no `edit` and no `write`: the run is read-only, and a call to either is refused.",
+    write ? "Where these instructions say `read_file` use `read`; where they say `write_file` use `write` (a whole file) or `edit` (a targeted change); where they say `bash` use `shell`." : "Where these instructions say `read_file` use `read`; where they say `bash` use `shell`.",
+    relayTools.length > 0 ? `Every other tool named above is available under its own name: ${named}.` : "No other tools are available in this run."
+  ].join(" ");
+}
+function openCodeSystemPrompt(spec) {
+  return `${spec.system.trimEnd()}
+
+${openCodePromptNote(spec.relayTools, spec.identity)}
+`;
+}
+function openCodeConfig(spec) {
+  const { id, maxTokens, providerType, contextTokens } = spec.model;
+  const compaction = {
+    ...spec.compaction?.buffer !== void 0 ? { buffer: spec.compaction.buffer } : {},
+    ...spec.compaction?.keepTokens !== void 0 ? { keep: { tokens: spec.compaction.keepTokens } } : {}
+  };
+  return {
+    providers: {
+      [PROXY_PROVIDER]: {
+        name: "Switchboard model proxy",
+        package: openCodeProviderPackage(providerType),
+        settings: { baseURL: openCodeProviderBaseUrl(spec.harnessUrl), apiKey: `{env:${RUN_BEARER_ENV}}` },
+        models: {
+          [id]: {
+            name: id,
+            limit: { context: contextTokens ?? OPENCODE_DEFAULT_CONTEXT_TOKENS, output: maxTokens },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } }
+          }
+        }
+      }
+    },
+    model: `${PROXY_PROVIDER}/${id}`,
+    default_agent: OPENCODE_AGENT,
+    agents: {
+      [OPENCODE_AGENT]: {
+        mode: "primary",
+        system: openCodeSystemPrompt(spec),
+        permissions: openCodePermissionRules(spec.identity)
+      },
+      title: { disabled: true }
+    },
+    plugins: [OPENCODE_PLUGIN_REF],
+    update: "disable",
+    share: "disabled",
+    snapshots: false,
+    lsp: false,
+    formatter: false,
+    ...Object.keys(compaction).length > 0 ? { compaction } : {}
+  };
+}
+function openCodeConfigJson(spec) {
+  return JSON.stringify(openCodeConfig(spec), null, 2) + "\n";
+}
+function openCodeLaunchFiles(spec) {
+  return [
+    { path: spec.paths.config, content: openCodeConfigJson(spec) },
+    { path: spec.paths.plugin, content: OPENCODE_PLUGIN_SOURCE },
+    { path: spec.paths.tailerScript, content: OPENCODE_TAILER_SOURCE }
+  ];
+}
+function openCodeLaunchArgs() {
+  return ["serve", "--hostname", "127.0.0.1", "--port", PORT_ARG];
+}
+function openCodePassword(bearer) {
+  return bearerHashOf(bearer) ?? randomBytes5(24).toString("base64url");
+}
+function openCodeLaunchEnv(spec, bearer, password) {
+  const { paths } = spec;
+  return {
+    [RUN_BEARER_ENV]: bearer,
+    [HARNESS_URL_ENV]: spec.harnessUrl,
+    SWITCHBOARD_RUN_ID: spec.runId,
+    XDG_DATA_HOME: paths.xdg.data,
+    XDG_CONFIG_HOME: paths.xdg.config,
+    XDG_CACHE_HOME: paths.xdg.cache,
+    XDG_STATE_HOME: paths.xdg.state,
+    OPENCODE_CONFIG: paths.config,
+    OPENCODE_CONFIG_PROJECT_DISABLE: "1",
+    OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+    OPENCODE_DISABLE_MODELS_FETCH: "1",
+    OPENCODE_DISABLE_AUTOUPDATE: "1",
+    OPENCODE_DB: ":memory:",
+    [OPENCODE_PASSWORD_ENV]: password
+  };
+}
+function openCodeTailerEnv(password, servePid) {
+  return { [OPENCODE_PASSWORD_ENV]: password, [OPENCODE_SERVE_PID_ENV]: String(servePid) };
+}
+function configProblem(info, spec) {
+  const providers = info.providers;
+  const agents = info.agents;
+  if (typeof providers?.[PROXY_PROVIDER] !== "object") return `providers.${PROXY_PROVIDER} did not take`;
+  if (info.default_agent !== OPENCODE_AGENT) return `default_agent is not ${OPENCODE_AGENT}`;
+  if (typeof agents?.[OPENCODE_AGENT] !== "object") return `agents.${OPENCODE_AGENT} did not take`;
+  if (agents?.title?.disabled !== true) return "agents.title.disabled did not take";
+  if (!Array.isArray(info.plugins) || !info.plugins.includes(OPENCODE_PLUGIN_REF)) return "plugins did not take";
+  if (info.update !== "disable") return "update is not disable";
+  if (info.share !== "disabled") return "share is not disabled";
+  if (info.snapshots !== false) return "snapshots is not false";
+  if (info.lsp !== false) return "lsp is not false";
+  if (info.formatter !== false) return "formatter is not false";
+  if (spec.compaction && Object.keys(spec.compaction).length > 0 && typeof info.compaction !== "object")
+    return "compaction did not take";
+  return void 0;
+}
+function loadedDocument(entries, configPath) {
+  const document = entries.find((e) => e.type === "document" && e.path === configPath);
+  return document && document.type === "document" ? document.info : void 0;
+}
+async function launchOpenCode(deps, spec, bearer) {
+  const { container, clock: clock4, sleep: sleep2 } = deps;
+  const pollMs = deps.pollMs ?? OPENCODE_READY_POLL_MS;
+  const readyMs = deps.readyMs ?? OPENCODE_READY_MS;
+  const root = await container.makeRoot(spec.paths.dir);
+  const paths = root === spec.paths.dir ? spec.paths : openCodeRunPathsAt(root);
+  const placed = { ...spec, paths };
+  for (const file of openCodeLaunchFiles(placed)) await container.writeFile(file.path, file.content);
+  const password = openCodePassword(bearer);
+  const started = await container.start({
+    paths,
+    command: OPENCODE_BIN,
+    args: openCodeLaunchArgs(),
+    env: openCodeLaunchEnv(placed, bearer, password),
+    port: "free"
+  });
+  if (started.port === void 0)
+    throw new HarnessContainerError("start", "the start answered no port for opencode serve");
+  const { pid, port } = started;
+  const auth = { Authorization: openCodeAuthHeader(password) };
+  const request2 = (route3) => container.request(paths, { method: route3.method, port, path: route3.path, secretHeaders: auth });
+  const notReady = async (reason2, errLog = paths.errLog) => new OpenCodeNotReadyError(reason2, await container.tail(errLog, READY_TAIL_BYTES));
+  const startedAt = clock4();
+  const deadline = startedAt + readyMs;
+  let last = "no answer yet";
+  let version2;
+  let probePid = true;
+  let poll = pollMs;
+  while (version2 === void 0) {
+    if (probePid && !await container.alive(pid))
+      throw await notReady("the server exited before it answered its health");
+    let res;
+    try {
+      res = await request2(OPENCODE_ROUTES["health.get"]);
+      probePid = false;
+    } catch (err2) {
+      if (isContainerGone(err2)) throw err2;
+      last = err2 instanceof Error ? err2.message : String(err2);
+      probePid = true;
+    }
+    if (res) {
+      if (res.status === 401) throw await notReady("the server refused the run's password");
+      if (res.status === 500) throw await notReady("the server reported that its start failed (health answered 500)");
+      if (res.status === 200) {
+        const health = parseHealth(res.body);
+        if (!health) throw await notReady("the health answered something that is not the health shape");
+        if (health.version !== OPENCODE_VERSION)
+          throw await notReady(`the opencode on PATH is ${health.version}; this build drives ${OPENCODE_VERSION}`);
+        version2 = health.version;
+        break;
+      }
+      last = `the health answered ${res.status}`;
+    }
+    if (clock4() >= deadline)
+      throw await notReady(`the server did not answer its health within ${readyMs} ms (${last})`);
+    await sleep2(poll);
+    if (clock4() - startedAt >= 1e3) poll = Math.min(OPENCODE_READY_POLL_MAX_MS, poll * 2);
+  }
+  const config = await request2(OPENCODE_ROUTES["config.get"]);
+  if (config.status !== 200) throw await notReady(`the configuration route answered ${config.status}`);
+  const entries = parseConfigEntries(config.body);
+  if (!entries) throw await notReady("the configuration route answered something that is not the entry list");
+  const info = loadedDocument(entries, paths.config);
+  if (!info) throw await notReady("the server did not load the run's configuration file");
+  const problem = configProblem(info, placed);
+  if (problem) throw await notReady(`the run's configuration ${problem}`);
+  const activation = await request2(OPENCODE_ROUTES["plugin.awaitActivation"]);
+  if (activation.status < 200 || activation.status >= 300)
+    throw await notReady(`plugin activation answered ${activation.status}`);
+  const tailer = await container.start({
+    paths: paths.tailer,
+    command: TAILER_BIN,
+    args: [paths.tailerScript],
+    env: openCodeTailerEnv(password, pid),
+    port,
+    // The feed is read by offset and a later generation may restart the
+    // tailer over it: its log is never truncated by a start.
+    keepLog: true
+  });
+  let feedOffset;
+  poll = pollMs;
+  while (feedOffset === void 0) {
+    const text = Buffer.from(await container.readLog(paths.feed, 0, LOG_READ_BYTES)).toString("utf8");
+    let consumed = 0;
+    for (const line3 of text.split("\n").slice(0, -1)) {
+      consumed += Buffer.byteLength(line3, "utf8") + 1;
+      const record2 = parseFeedRecord(line3);
+      if (record2?.feed === "tailer" && record2.note === "connected") {
+        feedOffset = consumed;
+        break;
+      }
+    }
+    if (feedOffset !== void 0) break;
+    if (!await container.alive(tailer.pid))
+      throw await notReady("the tailer exited before it connected to the event stream", paths.tailer.errLog);
+    if (clock4() >= deadline)
+      throw await notReady(`the tailer did not connect to the event stream within ${readyMs} ms`, paths.tailer.errLog);
+    await sleep2(poll);
+    if (clock4() - startedAt >= 1e3) poll = Math.min(OPENCODE_READY_POLL_MAX_MS, poll * 2);
+  }
+  return { pid, port, tailerPid: tailer.pid, password, paths, version: version2, feedOffset };
+}
+function openCodeFacts(started, run2) {
+  const bearerHash = run2.bearer === void 0 ? void 0 : bearerHashOf(run2.bearer);
+  return {
+    harness: "opencode",
+    pid: started.pid,
+    port: started.port,
+    tailerPid: started.tailerPid,
+    logOffset: run2.logOffset,
+    sessionID: run2.sessionID,
+    root: started.paths.dir,
+    relaunches: run2.relaunches,
+    ...bearerHash === void 0 ? {} : { bearerHash },
+    ...run2.container === void 0 ? {} : { container: run2.container }
+  };
+}
+var OPENCODE_BIN, TAILER_BIN, OPENCODE_AGENT, OPENCODE_PLUGIN_REF, OPENCODE_PASSWORD_ENV, OPENCODE_READY_MS, OPENCODE_READY_POLL_MS, OPENCODE_READY_POLL_MAX_MS, OPENCODE_DEFAULT_CONTEXT_TOKENS, READY_TAIL_BYTES, OPENCODE_BUILTIN_TOOLS, OPENCODE_READ_TOOLS, OPENCODE_NO_TOOLS, ASK_ALL_RULE, OPENCODE_ALWAYS_DENIED, OPENCODE_NONE_DENIED, OPENCODE_READ_DENIED, OpenCodeNotReadyError;
+var init_process2 = __esm({
+  "../../src/core/harness/opencode/process.ts"() {
+    "use strict";
+    init_runBearers();
+    init_container();
+    init_process();
+    init_client2();
+    init_pluginSource();
+    init_tailerSource();
+    OPENCODE_BIN = "opencode";
+    TAILER_BIN = "node";
+    OPENCODE_AGENT = "switchboard";
+    OPENCODE_PLUGIN_REF = "./plugins/switchboard";
+    OPENCODE_PASSWORD_ENV = "OPENCODE_PASSWORD";
+    OPENCODE_READY_MS = 3e4;
+    OPENCODE_READY_POLL_MS = 250;
+    OPENCODE_READY_POLL_MAX_MS = 2e3;
+    OPENCODE_DEFAULT_CONTEXT_TOKENS = 2e5;
+    READY_TAIL_BYTES = 2e3;
+    OPENCODE_BUILTIN_TOOLS = ["read", "shell", "edit", "write", "glob", "grep", "skill"];
+    OPENCODE_READ_TOOLS = ["read", "shell", "glob", "grep", "skill"];
+    OPENCODE_NO_TOOLS = [];
+    ASK_ALL_RULE = { action: "*", resource: "*", effect: "ask" };
+    OPENCODE_ALWAYS_DENIED = ["question", "subagent", "execute", "webfetch", "websearch"];
+    OPENCODE_NONE_DENIED = [
+      "read",
+      "edit",
+      "shell",
+      "glob",
+      "grep",
+      "skill",
+      "external_directory"
+    ];
+    OPENCODE_READ_DENIED = ["edit"];
+    OpenCodeNotReadyError = class extends Error {
+      constructor(reason2, stderr) {
+        super(`opencode serve is not ready: ${reason2}${stderr.trim() ? ` (stderr: ${stderr.trim().slice(-600)})` : ""}`);
+        this.reason = reason2;
+        this.name = "OpenCodeNotReadyError";
+      }
+      reason;
+    };
+  }
+});
+
+// ../../src/core/harness/opencode/bridge.ts
+function openCodeToolNameWord(name) {
+  return TOOL_NAME_WORD[name] ?? name;
+}
+function contentText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((p) => isRecord8(p) && p.type === "text" && typeof p.text === "string").map((p) => String(p.text)).join("\n");
+}
+function isBudgetRefusal(error) {
+  if (error.status !== void 0 && error.status !== 403) return false;
+  return TURN_BUDGET_REFUSAL.test(error.message);
+}
+function judgeOpenCodeAsk(action, resources, rules, relayedToolNames) {
+  const word = openCodeToolWord(action);
+  const tool = TOOL_NAME_WORD[action] ?? word;
+  if (relayedToolNames.has(action) || relayedToolNames.has(word)) return { reply: "once", tool: action };
+  const refuse3 = (reason2) => ({ reply: "reject", message: reason2, tool });
+  if (action === "external_directory") {
+    for (const resource of resources) {
+      const verdict2 = judgeToolCall("read", { path: resource }, rules);
+      if (verdict2.verdict !== "allowed") return refuse3(verdict2.reason);
+    }
+    return { reply: "once", tool: "external_directory" };
+  }
+  if (word === "bash") {
+    for (const command2 of resources.length > 0 ? resources : [""]) {
+      const verdict2 = judgeToolCall("bash", { command: command2 }, rules);
+      if (verdict2.verdict !== "allowed") return refuse3(verdict2.reason);
+    }
+    return { reply: "once", tool };
+  }
+  const input = word === "read" || word === "edit" || word === "write" ? { path: resources[0] } : {};
+  const verdict = judgeToolCall(word, input, rules);
+  if (verdict.verdict !== "allowed") return refuse3(verdict.reason);
+  return { reply: "once", tool };
+}
+function assistantMessage2(turn) {
+  return {
+    role: "assistant",
+    content: turn.content.map(
+      (p) => p.type === "text" ? { type: "text", text: p.text } : p.type === "tool_use" ? { type: "toolCall", id: p.id, name: p.name, arguments: isRecord8(p.input) ? p.input : {} } : {}
+    )
+  };
+}
+function userMessage(turn) {
+  const results = turn.content.filter(
+    (p) => p.type === "tool_result"
+  );
+  if (results.length > 0) {
+    return {
+      role: "toolResult",
+      toolCallId: results[0].toolUseId,
+      content: [{ type: "text", text: typeof results[0].content === "string" ? results[0].content : "" }],
+      isError: results[0].isError === true
+    };
+  }
+  return {
+    role: "user",
+    content: turn.content.map((p) => p.type === "text" ? { type: "text", text: p.text } : {})
+  };
+}
+function projectStore(messages, seedLength) {
+  const turns = [];
+  messages.slice(seedLength).forEach((message4) => {
+    if (message4.type === "assistant") {
+      const assistant = message4;
+      const content = [];
+      const results = [];
+      for (const part of Array.isArray(assistant.content) ? assistant.content : []) {
+        if (!isRecord8(part)) continue;
+        if (part.type === "text" && typeof part.text === "string") content.push({ type: "text", text: part.text });
+        else if (part.type === "tool") {
+          const id = str6(part.id);
+          const name = openCodeToolNameWord(str6(part.name));
+          const state = isRecord8(part.state) ? part.state : {};
+          content.push({ type: "tool_use", id, name, input: isRecord8(state.input) ? state.input : {} });
+          if (state.status === "completed" || state.status === "error")
+            results.push({
+              type: "tool_result",
+              toolUseId: id,
+              content: contentText(state.content) || (state.status === "error" ? errorMessage(state.error) : ""),
+              ...state.status === "error" ? { isError: true } : {}
+            });
+        }
+      }
+      if (content.length > 0) turns.push({ role: "assistant", content });
+      for (const result of results) turns.push({ role: "user", content: [result] });
+    } else if (message4.type === "user") {
+      const text = str6(message4.text);
+      if (text) turns.push({ role: "user", content: [{ type: "text", text }] });
+    }
+  });
+  return turns;
+}
+function errorMessage(error) {
+  return isRecord8(error) && typeof error.message === "string" ? error.message : "";
+}
+function statusOf(error) {
+  return isRecord8(error) && typeof error.status === "number" ? error.status : void 0;
+}
+function openCodePromptText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message4 = messages[i];
+    if (message4.role === "user")
+      return message4.content.filter((p) => p.type === "text").map((p) => p.text).join("\n\n");
+  }
+  return "";
+}
+async function driveOpenCode(deps, run2, conn) {
+  const now = () => deps.clock();
+  const agentSpan = run2.span?.start("run.agent");
+  if (agentSpan) deps.bearers?.reparent(run2.runId, agentSpan);
+  const remainingMs = run2.resume?.remainingMs ?? run2.agent.maxMinutes * 6e4;
+  const deadline = now() + remainingMs;
+  const warnAt = deadline - Math.min(3 * 6e4, run2.agent.maxMinutes * 15e3);
+  const emit = (event) => run2.onEvent?.(event.at === void 0 ? { ...event, at: now() } : event);
+  const note = (kind, summary) => {
+    run2.onProgress?.(summary);
+    emit({ type: "run_note", kind, summary });
+  };
+  const bridge = new OpenCodeBridge({
+    emit,
+    ...run2.onProgress ? { onProgress: run2.onProgress } : {},
+    clock: deps.clock,
+    ...agentSpan ? { agentSpan } : {},
+    rules: { ...run2.rules, identity: run2.agent.identity },
+    relayedToolNames: new Set(run2.tools.map((t) => t.name)),
+    ...run2.onStep ? { onStep: run2.onStep } : {},
+    // The mirror skips the seed's rows: a fresh run's is the thread's turns plus
+    // the request (`run.messages`); a rebuild's is the record it imported (its
+    // transcript and every compaction row), which the store holds and the
+    // request-prompt appends past.
+    seedLength: run2.resume ? run2.resume.messages.length + (run2.resume.compactions?.length ?? 0) : run2.messages.length,
+    remainingMs: () => deadline - now(),
+    textFailing: new Set(run2.tools.filter((t) => t.failsInText).map((t) => t.name))
+  });
+  if (run2.resume && run2.resume.settlements.length > 0) {
+    bridge.prime(
+      run2.resume.settlements.map((s) => ({
+        type: "tool_result",
+        toolUseId: s.toolUse.id,
+        content: openCodeSettlementNote(s),
+        isError: true
+      }))
+    );
+  }
+  const auth = { Authorization: openCodeAuthHeader(conn.password) };
+  const sessionRoutes = openCodeSessionRoutes(conn.sessionID);
+  const request2 = (route3, body) => conn.container.request(conn.paths, {
+    method: route3.method,
+    port: conn.port,
+    path: route3.path,
+    secretHeaders: auth,
+    ...body !== void 0 ? { headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {}
+  });
+  const transport = new PiRpcTransport({
+    container: conn.container,
+    paths: { ...conn.paths.tailer, log: conn.paths.feed },
+    pid: conn.tailerPid,
+    pollMs: deps.pollMs ?? 250,
+    sleep: deps.sleep,
+    offset: conn.feedOffset
+  });
+  let writeUp;
+  let hardStopped = false;
+  let warned = false;
+  let bypass;
+  let replyFailed;
+  let providerError;
+  let settled = false;
+  let containerSaid;
+  const recordBase = {
+    messages: run2.resume?.messages ?? run2.messages,
+    compactions: run2.resume?.compactions ?? []
+  };
+  const startWriteUp = (w, instruction) => {
+    writeUp = w;
+    if (conn.writeUp)
+      conn.writeUp.blocked = w.kind === "time" ? "the run has reached its time budget: no more tool calls \u2014 the run is writing its final answer" : "the run has hit its turn guard: no more tool calls \u2014 the run is writing its final answer";
+    void request2(sessionRoutes["session.prompt"], { text: instruction, delivery: "steer" }).catch(() => {
+    });
+  };
+  const turnCount = () => deps.bearers?.grantOf(run2.runId)?.turns ?? bridge.turns;
+  const check = () => {
+    if (run2.control?.requested === "hard") {
+      if (!hardStopped) {
+        hardStopped = true;
+        run2.onProgress?.(hardStopNote());
+        emit({ type: "run_note", kind: "stopped", summary: hardStopNote(), mode: "hard" });
+        void request2(sessionRoutes["session.interrupt"]).catch(() => {
+        });
+      }
+      return;
+    }
+    if (writeUp) return;
+    if (now() >= deadline) {
+      note("time_budget_exhausted", timeBudgetNote());
+      startWriteUp({ kind: "time" }, timeBudgetInstruction());
+      return;
+    }
+    if (turnCount() >= run2.agent.maxTurns) {
+      const pace = turnGuardPace(turnCount(), run2.agent.maxMinutes * 6e4 - (deadline - now()));
+      note("turn_budget_exhausted", turnGuardNote(pace));
+      startWriteUp({ kind: "turns", pace }, turnGuardInstruction(pace));
+      return;
+    }
+    if (!warned && now() >= warnAt) {
+      warned = true;
+      const minutesLeft = Math.max(1, Math.round((deadline - now()) / 6e4));
+      note("wrap_up", wrapUpNote(minutesLeft));
+      void request2(sessionRoutes["session.prompt"], { text: wrapUpInstruction(minutesLeft), delivery: "steer" }).catch(
+        () => {
+        }
+      );
+    }
+  };
+  try {
+    await request2(sessionRoutes["session.prompt"], { text: openCodePromptText(run2.messages), delivery: "queue" });
+    check();
+    const iterator = transport.lines[Symbol.asyncIterator]();
+    let pending2;
+    for (; ; ) {
+      pending2 ??= iterator.next();
+      const tick = deps.sleep(deps.tickMs ?? 1e3).then(() => "tick");
+      let next;
+      try {
+        next = await Promise.race([pending2, tick]);
+      } catch (err2) {
+        if (!(err2 instanceof Error && saysContainerReplaced(err2))) throw err2;
+        containerSaid = err2;
+        break;
+      }
+      if (next === "tick") {
+        check();
+        if (hardStopped) break;
+        continue;
+      }
+      pending2 = void 0;
+      if (next.done) break;
+      const record2 = parseFeedRecord(next.value);
+      if (!record2) continue;
+      const obs = bridge.observe(record2);
+      for (const reply of obs.replies) {
+        let failure2;
+        try {
+          const res = await request2(openCodePermissionReplyRoute(conn.sessionID, reply.requestID), {
+            reply: reply.reply,
+            ...reply.message ? { message: reply.message } : {}
+          });
+          if (res.status < 200 || res.status >= 300) failure2 = { status: res.status };
+        } catch (err2) {
+          failure2 = err2 instanceof Error ? err2 : new Error(String(err2));
+        }
+        if (failure2 !== void 0) {
+          replyFailed = new OpenCodeReplyFailedError(reply.requestID, reply.callId, reply.reply, failure2);
+          note("harness_error", `${replyFailed.message} \u2014 the run is stopped`);
+          void request2(sessionRoutes["session.interrupt"]).catch(() => {
+          });
+          break;
+        }
+      }
+      if (replyFailed) break;
+      if (obs.bypass) {
+        bypass = obs.bypass;
+        void request2(sessionRoutes["session.interrupt"]).catch(() => {
+        });
+        break;
+      }
+      if (obs.budgetStop && !writeUp) {
+        const pace = turnGuardPace(turnCount(), run2.agent.maxMinutes * 6e4 - (deadline - now()));
+        note("turn_budget_exhausted", turnGuardNote(pace));
+        startWriteUp({ kind: "turns", pace }, turnGuardInstruction(pace));
+      }
+      if (obs.providerError !== void 0) providerError = obs.providerError;
+      if (obs.settled) {
+        settled = true;
+        break;
+      }
+      check();
+      if (hardStopped) break;
+    }
+  } finally {
+    transport.close();
+    agentSpan?.end(hardStopped || bypass || replyFailed || containerSaid ? "error" : "ok");
+  }
+  if (containerSaid !== void 0) {
+    const record2 = bridge.record(recordBase, deadline);
+    bridge.closeOpenSpans((open2) => openCodeReplacedCallNote(open2.tool));
+    const now2 = await conn.container.identity().catch(() => void 0);
+    const replaced = new OpenCodeContainerReplacedError(containerSaid.message, conn.containerWord, now2, record2);
+    note("sandbox_restarted", replaced.message);
+    throw replaced;
+  }
+  if (bypass) throw bypass;
+  if (replyFailed) throw replyFailed;
+  if (hardStopped) return { answer: HARD_STOP_MESSAGE };
+  if (providerError !== void 0) throw new Error(`the model call failed: ${providerError}`);
+  if (!settled) 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);
+  return { answer };
+}
+function writeUpAnswer(writeUp, text, maxMinutes) {
+  if (writeUp?.kind === "time") return timeBudgetAnswer(text, maxMinutes);
+  if (writeUp?.kind === "turns") return turnGuardAnswer(text, writeUp.pace);
+  return text || "_(no response)_";
+}
+var OpenCodeGateBypassedError, OpenCodeReplyFailedError, OpenCodeContainerReplacedError, TOOL_NAME_WORD, isRecord8, str6, TURN_BUDGET_CODE, TURN_BUDGET_REFUSAL, OpenCodeBridge;
+var init_bridge3 = __esm({
+  "../../src/core/harness/opencode/bridge.ts"() {
+    "use strict";
+    init_runEvents();
+    init_contract4();
+    init_harness();
+    init_bridge2();
+    init_mirror();
+    init_transport();
+    init_toolRules();
+    init_windDown();
+    init_client2();
+    init_dispositions();
+    init_session2();
+    init_process2();
+    OpenCodeGateBypassedError = class extends Error {
+      constructor(detail) {
+        super(`the gate was bypassed: ${detail}`);
+        this.detail = detail;
+        this.name = "OpenCodeGateBypassedError";
+      }
+      detail;
+    };
+    OpenCodeReplyFailedError = class extends Error {
+      constructor(requestID, callId, reply, cause) {
+        super(
+          `the gate's reply (${reply}) for request ${requestID}${callId ? ` (call ${callId})` : ""} could not be posted (${cause instanceof Error ? cause.message : `the server answered ${cause.status}`}): the ask stays unanswered, so the run stops rather than hang`
+        );
+        this.requestID = requestID;
+        this.callId = callId;
+        this.reply = reply;
+        this.cause = cause;
+        this.name = "OpenCodeReplyFailedError";
+      }
+      requestID;
+      callId;
+      reply;
+      cause;
+    };
+    OpenCodeContainerReplacedError = class extends HarnessContainerReplacedError {
+      constructor(said2, was, now, record2) {
+        super(
+          `the container running OpenCode was replaced (${was ?? "unknown"} \u2192 ${now ?? "unknown"}; the executor said: ${redactAndCap(said2.replace(/\s+/g, " ").trim(), 240)})`,
+          said2,
+          was,
+          now,
+          record2
+        );
+        this.name = "OpenCodeContainerReplacedError";
+      }
+    };
+    TOOL_NAME_WORD = { shell: "bash", glob: "find" };
+    isRecord8 = (v) => typeof v === "object" && v !== null;
+    str6 = (v) => typeof v === "string" ? v : String(v ?? "");
+    TURN_BUDGET_CODE = "turn_budget_exhausted";
+    TURN_BUDGET_REFUSAL = new RegExp(`\\b${TURN_BUDGET_CODE}\\b`);
+    OpenCodeBridge = class {
+      constructor(deps) {
+        this.deps = deps;
+        this.mirror = new PiMirror({
+          ...deps.onStep ? { onStep: deps.onStep } : {},
+          seedLength: deps.seedLength,
+          remainingMs: deps.remainingMs
+        });
+      }
+      deps;
+      /** Model turns that did work — the guard's count (an assistant turn per step). */
+      turns = 0;
+      toolCalls = 0;
+      answerText;
+      /** Narration text seen since the last turn's start, emitted beside its call. */
+      pendingNarration;
+      /** callId → the tool name the model gave it (from `session.tool.input.started`). */
+      toolNames = /* @__PURE__ */ new Map();
+      /** The open calls' spans, by callId. */
+      openTools = /* @__PURE__ */ new Map();
+      /** callId → the bot's decision for its ask, `once` or `reject`. A settled
+       *  call not among these ran with no decision; a success for a call the bot
+       *  rejected ran against the reject. Both are bypasses. */
+      answered = /* @__PURE__ */ new Map();
+      /** requestID → the reply the bot decided, and whether the server has echoed
+       *  it once. A `permission.replied` is the bot's own echo only when its
+       *  requestID is here, its effect equals the decided one, and it is the first;
+       *  anything else — an id never decided, another effect, a second reply — is a
+       *  reply the bot did not send (a forgery). */
+      decidedReplies = /* @__PURE__ */ new Map();
+      /** The store messages already mirrored, by count of the pi-shaped turns fed. */
+      fedTurns = 0;
+      mirror;
+      turnCounted = 0;
+      /** The mirror writes, serialized: a refill (or a compaction) chains behind
+       *  the last, so two refills that arrive in one poll never race the
+       *  high-water mark. `flush` awaits the chain, so a caller reads the answer
+       *  and the steps only once every refill it saw has landed. */
+      mirrorChain = Promise.resolve();
+      /** The run's answer as it stands: the last text-only assistant turn. */
+      answer() {
+        return this.answerText;
+      }
+      /** Awaits every mirror write chained so far. */
+      flush() {
+        return this.mirrorChain;
+      }
+      /** The settlement turn a rebuilt process's session starts on (the rebuild is
+       *  an import): the calls in flight at the death, each a tool result — the
+       *  settlement note — primed as the next step's pending user content, so the
+       *  ledger's first step after the rebuild is `[user(settlements), assistant]`
+       *  from the seed index, and OpenCode's store rows (the settlement is a
+       *  completed tool content in the imported record) project to the same turn.
+       *  The record then rebuilds a transcript with a result for every call. */
+      prime(parts) {
+        this.mirror.prime(parts);
+      }
+      /** 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) {
+        for (const [callId, open2] of this.openTools) {
+          open2.span?.end("error", { callId, ok: false });
+          this.emit({
+            type: "tool_result",
+            tool: open2.tool,
+            ok: false,
+            callId,
+            summary: redactAndCap(reason2({ callId, tool: open2.tool }), COMMAND_CAP)
+          });
+        }
+        this.openTools.clear();
+      }
+      /** The record as this generation holds it (`HarnessRecord`; harness.md item
+       *  6): the base — the seed with its request, or the resumed transcript — and
+       *  the mirror's rows, every call of the last turn settled with the replaced
+       *  note, so the run loop can relaunch OpenCode from it. Mirrors pi's
+       *  `recordNow`. */
+      record(base, deadline) {
+        const written = this.mirror.written;
+        const messages = [...base.messages, ...written.messages];
+        const last = messages.at(-1);
+        const calls = last?.role === "assistant" ? last.content.filter((p) => p.type === "tool_use") : [];
+        return {
+          messages,
+          compactions: [
+            ...base.compactions,
+            ...written.compactions.map((c) => ({ ...c, before: base.messages.length + c.before }))
+          ],
+          settlements: calls.map((toolUse) => ({
+            toolUse,
+            action: "synthetic",
+            text: openCodeReplacedCallNote(toolUse.name)
+          })),
+          turn: this.turns,
+          inboxConsumedSeq: this.mirror.inboxConsumedSeq,
+          deadline
+        };
+      }
+      note(kind, summary) {
+        this.deps.onProgress?.(summary);
+        this.emit({ type: "run_note", kind, summary });
+      }
+      emit(event) {
+        this.deps.emit(event.at === void 0 ? { ...event, at: this.deps.clock() } : event);
+      }
+      observe(record2) {
+        switch (record2.feed) {
+          case "event":
+            return this.onEvent(record2.event);
+          case "permissions":
+            return this.onPermissionsRefill(record2.data);
+          case "messages":
+            return this.onMessagesRefill(record2.data);
+          case "tailer":
+            if (record2.note === "stream closed" || record2.note.includes("failed"))
+              this.deps.onProgress?.(`opencode feed: ${redactAndCap(record2.note, 120)}`);
+            return { replies: [], settled: false };
+        }
+      }
+      onEvent(event) {
+        const out = { replies: [], settled: false };
+        const disposition = openCodeDispositionOf(event.type);
+        if (disposition === void 0) {
+          this.note(
+            "harness_error",
+            `OpenCode emitted an event kind this build does not know: ${redactAndCap(event.type, 80)}`
+          );
+          return out;
+        }
+        if (disposition === "impossible") {
+          this.note("harness_error", `OpenCode emitted ${event.type}, which this run's configuration turns off`);
+          return out;
+        }
+        const data = isRecord8(event.data) ? event.data : {};
+        switch (event.type) {
+          case "session.tool.input.started":
+            if (typeof data.id === "string" && typeof data.name === "string") this.toolNames.set(data.id, data.name);
+            break;
+          case "session.tool.called":
+            this.onToolCalled(data);
+            break;
+          case "session.text.ended":
+            if (typeof data.text === "string" && data.text.trim())
+              this.pendingNarration = this.pendingNarration ? `${this.pendingNarration}
+${data.text}` : data.text;
+            break;
+          case "session.step.ended":
+            this.pendingNarration = void 0;
+            break;
+          case "session.tool.success":
+            this.onToolSettled(data, true, out);
+            break;
+          case "session.tool.failed":
+            this.onToolSettled(data, false, out);
+            break;
+          case "permission.asked":
+            this.onPermissionAsked(data, out);
+            break;
+          case "permission.replied":
+            this.onPermissionReplied(data, out);
+            break;
+          case "session.compaction.ended":
+            this.onCompactionEnded(data);
+            break;
+          case "session.compaction.failed":
+            this.note("harness_error", `OpenCode's compaction failed: ${redactAndCap(errorMessage(data.error), 200)}`);
+            break;
+          case "session.retry.scheduled":
+            this.note("harness_error", `OpenCode scheduled a model retry (${redactAndCap(errorMessage(data.error), 200)})`);
+            break;
+          case "session.step.failed":
+            this.note("harness_error", `an OpenCode step failed: ${redactAndCap(errorMessage(data.error), 200)}`);
+            break;
+          case "session.execution.failed": {
+            const error = { status: statusOf(data.error), message: errorMessage(data.error) };
+            if (isBudgetRefusal(error)) out.budgetStop = true;
+            else out.providerError = redactAndCap(error.message, 400);
+            break;
+          }
+          case "session.execution.succeeded":
+          case "session.execution.interrupted":
+          case "session.idle":
+            out.settled = true;
+            break;
+          default:
+            break;
+        }
+        return out;
+      }
+      onToolCalled(data) {
+        const callId = str6(data.id);
+        const name = this.toolNames.get(callId) ?? "tool";
+        const tool = openCodeToolNameWord(name);
+        const span = this.deps.agentSpan?.start(`tool.${tool}`);
+        this.openTools.set(callId, { span, tool });
+        this.toolCalls++;
+        const input = isRecord8(data.input) ? data.input : void 0;
+        if (this.pendingNarration) {
+          this.emit({ type: "assistant", text: redactSecrets(this.pendingNarration) });
+          this.pendingNarration = void 0;
+        }
+        const command2 = tool === "bash" && typeof input?.command === "string" ? { command: redactAndCap(input.command, COMMAND_CAP) } : {};
+        this.emit({
+          type: "tool_call",
+          tool,
+          summary: redactAndCap(describePiToolCall(tool, input)),
+          callId,
+          ...command2,
+          ...span ? { spanId: span.id } : {}
+        });
+      }
+      onToolSettled(data, ok2, out) {
+        const callId = str6(data.id);
+        const open2 = this.openTools.get(callId);
+        this.openTools.delete(callId);
+        const tool = open2?.tool ?? openCodeToolNameWord(this.toolNames.get(callId) ?? "tool");
+        const text = ok2 ? contentText(data.content) : errorMessage(data.error) || contentText(data.content);
+        const failedInText = this.deps.textFailing?.has(tool) === true && toolTextFailed(text);
+        const exit = tool === "bash" ? piBashExit(text, !ok2) : { failed: !ok2 || failedInText };
+        const settledOk = !exit.failed;
+        this.emit({
+          type: "tool_result",
+          tool,
+          ok: settledOk,
+          callId,
+          ...exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {},
+          ...prepareToolResult(text),
+          ...open2?.span ? { spanId: open2.span.id } : {}
+        });
+        open2?.span?.end(settledOk ? "ok" : "error", { callId, ok: settledOk });
+        if (this.deps.relayedToolNames.has(this.toolNames.get(callId) ?? "")) return;
+        const executed = data.executed === true;
+        const decision = this.answered.get(callId);
+        if (decision === void 0 && !executed) {
+          const name = this.toolNames.get(callId);
+          const absent = name !== void 0 && !openCodeBuiltinToolsFor(this.deps.rules.identity).includes(name);
+          if (absent)
+            this.note(
+              "tool_refused",
+              `${tool} refused: the run's identity has no ${tool} tool (the deny rules removed it), so the call ran nothing`
+            );
+          else
+            this.note(
+              "harness_error",
+              `OpenCode settled ${tool} (call ${callId}) before it ran, with no ask the bot answered${text ? `: ${redactAndCap(text, 200)}` : ""}`
+            );
+        } else if (decision === void 0) {
+          this.bypass(out, `OpenCode ran ${tool} (call ${callId}) with no ask the bot answered \u2014 a call with no ask`);
+        } else if (decision === "reject" && ok2) {
+          this.bypass(
+            out,
+            `OpenCode ran ${tool} (call ${callId}) after the bot's reject \u2014 a success after the bot's refusal`
+          );
+        }
+      }
+      bypass(out, detail) {
+        out.bypass = new OpenCodeGateBypassedError(detail);
+        this.note("harness_error", `${out.bypass.message} \u2014 the run is stopped`);
+      }
+      onPermissionAsked(request2, out) {
+        const callId = request2.source?.id ?? request2.id;
+        if (this.answered.has(callId)) return;
+        const verdict = judgeOpenCodeAsk(
+          request2.action,
+          Array.isArray(request2.resources) ? request2.resources : [],
+          this.deps.rules,
+          this.deps.relayedToolNames
+        );
+        this.answered.set(callId, verdict.reply);
+        this.decidedReplies.set(request2.id, { reply: verdict.reply, echoed: false });
+        if (verdict.reply === "reject")
+          this.note("tool_refused", `${verdict.tool} refused: ${redactAndCap(verdict.message ?? "", 300)}`);
+        out.replies.push({
+          requestID: request2.id,
+          callId,
+          reply: verdict.reply,
+          ...verdict.message ? { message: verdict.message } : {}
+        });
+      }
+      onPermissionReplied(data, out) {
+        const requestID = str6(data.requestID);
+        const reply = str6(data.reply);
+        const decided = this.decidedReplies.get(requestID);
+        if (decided === void 0) {
+          this.bypass(
+            out,
+            `a permission.replied for request ${requestID}, which the bot never decided \u2014 a reply the bot did not send (it raced the bot, or answered an ask the bot never saw)`
+          );
+          return;
+        }
+        if (reply !== decided.reply) {
+          this.bypass(
+            out,
+            `a permission.replied answering \`${reply}\` where the bot decided \`${decided.reply}\` (request ${requestID}) \u2014 a reply that differs from the bot's decision, overriding it`
+          );
+          return;
+        }
+        if (decided.echoed) {
+          this.bypass(out, `a second permission.replied for request ${requestID} \u2014 a duplicate reply the bot did not send`);
+          return;
+        }
+        decided.echoed = true;
+      }
+      onPermissionsRefill(pending2) {
+        const out = { replies: [], settled: false };
+        for (const request2 of pending2) this.onPermissionAsked(request2, out);
+        return out;
+      }
+      onMessagesRefill(messages) {
+        this.mirrorChain = this.mirrorChain.then(() => this.syncMirror(messages));
+        return { replies: [], settled: false };
+      }
+      /** The store's messages as the ledger's steps: the pi-shaped turns projected
+       *  from the store (each assistant message split into its assistant turn and a
+       *  user turn for its tool results), fed to the mirror past the high-water mark
+       *  so a re-refill writes no step twice (an upsert by message id). */
+      async syncMirror(messages) {
+        if (!this.deps.onStep) return;
+        const turns = projectStore(messages, this.deps.seedLength);
+        for (let i = this.fedTurns; i < turns.length; i++) {
+          const turn = turns[i];
+          if (turn.role === "assistant") {
+            const hasTool = turn.content.some((p) => p.type === "tool_use");
+            const text = turn.content.filter((p) => p.type === "text").map((p) => p.text).join("\n").trim();
+            if (hasTool) {
+              this.turns++;
+            } else if (text) {
+              this.answerText = text;
+            }
+            await this.mirror.onMessage(assistantMessage2(turn), ++this.turnCounted);
+          } else {
+            await this.mirror.onMessage(userMessage(turn), this.turnCounted);
+          }
+        }
+        this.fedTurns = turns.length;
+      }
+      onCompactionEnded(data) {
+        const text = typeof data.text === "string" ? data.text : void 0;
+        if (!text) {
+          this.note("compacted", "OpenCode compacted the context; the transcript keeps the originals");
+          return;
+        }
+        const entry = { summary: text };
+        this.note("compacted", `OpenCode compacted the context (${str6(data.reason)}); the transcript keeps the originals`);
+        if (this.deps.onStep)
+          this.mirrorChain = this.mirrorChain.then(() => void this.mirror.onCompaction(entry, this.turnCounted));
+      }
+    };
+  }
+});
+
+// ../../src/core/harness/opencode/harness.ts
+function modelRef2(run2, variant) {
+  return { providerID: run2.model.provider, id: run2.model.id, ...variant ? { variant } : {} };
+}
+async function feedEnd(container, conn) {
+  let off = conn.feedOffset;
+  for (; ; ) {
+    const chunk = await container.readLog(conn.paths.feed, off, LOG_READ_BYTES);
+    off += chunk.length;
+    if (chunk.length < LOG_READ_BYTES) return off;
+  }
+}
+function resumeOpenCodeFacts(resume) {
+  const facts2 = resume?.facts;
+  return facts2 !== void 0 && facts2.harness === "opencode" ? facts2 : void 0;
+}
+async function openOpenCodeRun(deps, run2, settings) {
+  const now = () => deps.clock();
+  const emit = (event) => run2.onEvent?.(event.at === void 0 ? { ...event, at: now() } : event);
+  const note = (kind, summary) => {
+    run2.onProgress?.(summary);
+    emit({ type: "run_note", kind, summary });
+  };
+  const identity2 = run2.agent.identity;
+  const writeUp = {};
+  const live = {
+    runId: run2.runId,
+    tools: run2.tools,
+    toolContext: run2.toolContext,
+    ...run2.backend ? { backend: run2.backend } : {},
+    rules: { ...run2.rules, identity: identity2 },
+    emit,
+    toolSpan: () => void 0,
+    gateSaw: () => {
+    },
+    toolsBlocked: () => writeUp.blocked,
+    callSeen: async () => {
+    },
+    callEnded: async () => {
+    }
+  };
+  const resumeFacts = resumeOpenCodeFacts(run2.resume);
+  const relaunch = run2.resume?.relaunch !== void 0;
+  const forget = relaunch && deps.registry.get(run2.runId) !== void 0 ? deps.registry.replace(live) : deps.registry.register(live);
+  const relayCalls = deps.registry.calls(run2.runId);
+  for (const s of run2.resume?.settlements ?? [])
+    relayCalls?.settle(s.toolUse.id, { content: [{ type: "text", text: openCodeSettlementNote(s) }], isError: true });
+  const paths = openCodeRunPaths(run2.runId);
+  const spec = {
+    runId: run2.runId,
+    paths,
+    model: { id: run2.model.id, providerType: run2.model.providerType, maxTokens: run2.agent.maxTokens },
+    harnessUrl: deps.harnessUrl,
+    identity: identity2,
+    system: run2.system,
+    relayTools: run2.tools.map((t) => t.name),
+    ...settings.compaction ? { compaction: settings.compaction } : {}
+  };
+  let started;
+  let replaced = false;
+  const here = await deps.container.identity().catch(() => void 0);
+  const end = async () => {
+    forget();
+    if (replaced || started === void 0) return;
+    await deps.container.kill(started.pid).catch(() => {
+    });
+    await deps.container.kill(started.tailerPid).catch(() => {
+    });
+    await deps.container.remove(started.paths).catch(() => {
+    });
+  };
+  try {
+    if (relaunch) {
+      const rl = run2.resume?.relaunch;
+      note(
+        "resumed",
+        `relaunched after the container was replaced (${rl?.from ?? "unknown"} \u2192 ${rl?.to ?? here ?? "unknown"}); a fresh server was started on the record with ${Math.round((run2.resume?.remainingMs ?? 0) / 6e4)} min of budget left`
+      );
+    } else if (resumeFacts !== void 0) {
+      const elsewhere = resumeFacts.container !== void 0 && here !== void 0 && resumeFacts.container !== here;
+      if (elsewhere) {
+        note(
+          "resumed",
+          `resumed after a restart: the row's OpenCode (pid ${resumeFacts.pid}) ran in container ${resumeFacts.container}, not the one this run was handed (${here}); it was neither probed nor ended here, and a fresh server was started on the record`
+        );
+      } else if (await serverAnswers(deps.container, resumeFacts)) {
+        note(
+          "resumed",
+          `resumed after a restart: the row's OpenCode (pid ${resumeFacts.pid}) still answers in this container; ended it and its tailer before a fresh start on the record`
+        );
+        await deps.container.kill(resumeFacts.pid).catch(() => {
+        });
+        if (resumeFacts.tailerPid !== void 0) await deps.container.kill(resumeFacts.tailerPid).catch(() => {
+        });
+        await deps.container.remove(openCodeRunPathsAt(resumeFacts.root)).catch(() => {
+        });
+      } else {
+        if (resumeFacts.root !== paths.dir)
+          await deps.container.remove(openCodeRunPathsAt(resumeFacts.root)).catch(() => {
+          });
+        note(
+          "resumed",
+          `resumed after a restart: the row's OpenCode did not answer in this container; a fresh server was started on the record with ${Math.round((run2.resume?.remainingMs ?? 0) / 6e4)} min of budget left`
+        );
+      }
+    }
+    started = await launchOpenCode(
+      {
+        container: deps.container,
+        clock: deps.clock,
+        sleep: deps.sleep,
+        ...deps.pollMs !== void 0 ? { pollMs: deps.pollMs } : {}
+      },
+      spec,
+      deps.bearer
+    );
+    const auth = { Authorization: openCodeAuthHeader(started.password) };
+    const at = now();
+    const cwd = deps.container.cwd(started.paths, run2.rules.checkout);
+    let sessionID;
+    const importInto = async (messages, opts) => {
+      const body = openCodeImportBody(messages, opts);
+      const res = await request(deps.container, started, auth, OPENCODE_ROUTES["session.import"], body);
+      if (res.status < 200 || res.status >= 300)
+        throw new Error(`OpenCode refused the session import (${res.status}): ${redactAndCap(res.body, 200)}`);
+    };
+    if (run2.resume !== void 0 && run2.resume.messages.length > 0) {
+      sessionID = openCodeSessionId(run2.runId);
+      const settlements = new Map(run2.resume.settlements.map((s) => [s.toolUse.id, openCodeSettlementNote(s)]));
+      await importInto(run2.resume.messages, {
+        sessionID,
+        location: { directory: cwd },
+        model: modelRef2(run2, void 0),
+        agent: OPENCODE_AGENT,
+        at,
+        ...run2.resume.compactions ? { compactions: run2.resume.compactions.map((c) => c.entry) } : {},
+        settlements
+      });
+    } else {
+      const { seed } = openCodeSeedAndRequest(run2.messages);
+      if (seed.length > 0) {
+        sessionID = openCodeSessionId(run2.runId);
+        await importInto(seed, {
+          sessionID,
+          location: { directory: cwd },
+          model: modelRef2(run2, void 0),
+          agent: OPENCODE_AGENT,
+          at
+        });
+      } else {
+        sessionID = openCodeSessionId(run2.runId);
+        const res = await request(deps.container, started, auth, OPENCODE_ROUTES["session.create"], {
+          id: sessionID,
+          agent: OPENCODE_AGENT,
+          location: { directory: cwd },
+          model: modelRef2(run2, void 0)
+        });
+        if (res.status < 200 || res.status >= 300)
+          throw new Error(`OpenCode refused the session create (${res.status}): ${redactAndCap(res.body, 200)}`);
+        const created = parseSessionId(res.body);
+        if (created !== void 0) sessionID = created;
+      }
+    }
+    const conn = {
+      container: deps.container,
+      paths: started.paths,
+      port: started.port,
+      password: started.password,
+      sessionID,
+      feedOffset: started.feedOffset,
+      tailerPid: started.tailerPid,
+      ...here !== void 0 ? { containerWord: here } : {},
+      writeUp
+    };
+    run2.saveFacts?.(
+      openCodeFacts(
+        { pid: started.pid, port: started.port, paths: started.paths, tailerPid: started.tailerPid },
+        {
+          sessionID,
+          logOffset: started.feedOffset,
+          bearer: deps.bearer,
+          ...here !== void 0 ? { container: here } : {},
+          relaunches: resumeFacts?.relaunches ?? 0
+        }
+      )
+    );
+    let draining = true;
+    const drainer = drainFollowUps(deps, run2, conn, () => draining, emit, note);
+    let answer;
+    try {
+      ({ answer } = await driveOpenCode(deps, run2, conn));
+    } finally {
+      draining = false;
+      await drainer.catch(() => {
+      });
+    }
+    return {
+      answer,
+      followUp: async (input) => {
+        const turnEnd = await feedEnd(deps.container, conn);
+        const previous = live.toolContext;
+        live.toolContext = input.toolContext;
+        try {
+          const { answer: turnAnswer } = await driveOpenCode(
+            deps,
+            {
+              ...run2,
+              messages: [{ role: "user", content: [{ type: "text", text: input.text }] }],
+              agent: { ...run2.agent, maxTurns: input.maxTurns, maxMinutes: input.maxMinutes },
+              toolContext: input.toolContext,
+              ...input.span ? { span: input.span } : {},
+              resume: void 0,
+              inbox: void 0,
+              // The post-turn is not mirrored to the ledger — the loop's
+              // transcript is the record — but the bridge needs a step sink to
+              // read the answer, so a discard stands in.
+              onStep: async () => {
+              }
+            },
+            { ...conn, feedOffset: turnEnd }
+          );
+          return turnAnswer;
+        } finally {
+          live.toolContext = previous;
+        }
+      },
+      end
+    };
+  } catch (err2) {
+    if (err2 instanceof HarnessContainerReplacedError) replaced = true;
+    await end();
+    throw err2;
+  }
+}
+async function serverAnswers(container, facts2) {
+  try {
+    await container.request(openCodeRunPathsAt(facts2.root), {
+      method: "GET",
+      port: facts2.port,
+      path: OPENCODE_ROUTES["health.get"].path
+    });
+    return true;
+  } catch (err2) {
+    if (isContainerGone(err2)) throw err2;
+    return false;
+  }
+}
+function drainFollowUps(deps, run2, conn, running, emit, note) {
+  const auth = { Authorization: openCodeAuthHeader(conn.password) };
+  const routes = openCodeSessionRoutes(conn.sessionID);
+  return (async () => {
+    while (running()) {
+      const inputs = run2.inbox?.drain() ?? [];
+      for (const input of inputs) {
+        let stagedLine = "";
+        if (run2.stageFollowUps) {
+          try {
+            stagedLine = await run2.stageFollowUps([input]);
+          } catch (err2) {
+            stagedLine = `Attached files could not be staged: ${err2 instanceof Error ? err2.message : String(err2)}`;
+            note("follow_up", `staging the follow-up's files failed: ${redactSecrets(stagedLine)}`);
+          }
+        }
+        const prompt = followUpPrompt([input]);
+        const text = stagedLine ? `${prompt}
+
+${stagedLine}` : prompt;
+        let failure2;
+        try {
+          const res = await conn.container.request(conn.paths, {
+            method: routes["session.prompt"].method,
+            port: conn.port,
+            path: routes["session.prompt"].path,
+            secretHeaders: auth,
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ text, delivery: "steer" })
+          });
+          if (res.status < 200 || res.status >= 300) failure2 = `the server answered ${res.status}`;
+        } catch (err2) {
+          failure2 = err2 instanceof Error ? err2.message : String(err2);
+        }
+        if (failure2 !== void 0) {
+          note(
+            "follow_up",
+            `follow-up not delivered \u2014 the steer did not reach the session (${redactAndCap(failure2, 200)}); handed back to the inbox for a fresh turn: ${redactSecrets(followUpSnippet(input))}`
+          );
+          run2.inbox?.requeue(inputs.slice(inputs.indexOf(input)));
+          return;
+        }
+        const source2 = {
+          ...input.sourceUrl ? { url: input.sourceUrl } : {},
+          ...input.userName ? { user: input.userName } : {},
+          ...input.from ? { run: input.from.runId } : {}
+        };
+        emit({
+          type: "input",
+          text: redactSecrets(input.text),
+          messageId: followUpMessageId(input),
+          ...Object.keys(source2).length > 0 ? { source: source2 } : {}
+        });
+        note("follow_up", `follow-up folded in: ${redactSecrets(followUpSnippet(input))}`);
+      }
+      if (!running()) break;
+      await deps.sleep(deps.tickMs ?? 1e3);
+    }
+  })();
+}
+function request(container, started, auth, route3, body) {
+  return container.request(started.paths, {
+    method: route3.method,
+    port: started.port,
+    path: route3.path,
+    secretHeaders: auth,
+    ...body !== void 0 ? { headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {}
+  });
+}
+function parseSessionId(body) {
+  try {
+    const value = JSON.parse(body);
+    return typeof value.data?.id === "string" ? value.data.id : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var OpenCodeHarness;
+var init_harness2 = __esm({
+  "../../src/core/harness/opencode/harness.ts"() {
+    "use strict";
+    init_threadAdmission();
+    init_runEvents();
+    init_container();
+    init_contract4();
+    init_dispositions();
+    init_bridge3();
+    init_client2();
+    init_process2();
+    init_session2();
+    OpenCodeHarness = class {
+      constructor(settings = {}) {
+        this.settings = settings;
+      }
+      settings;
+      name = "opencode";
+      /** OpenCode accepts an imported session as its own history: a seed is
+       *  that history written for it, a rebuild a rewrite of it. */
+      history = "authored-session";
+      dispositions = OPENCODE_EVENT_DISPOSITION;
+      /** Switchboard's effort tier in OpenCode's word: the tier selects a model
+       *  `variant` on the session's model ref (item 11: variants are declared per
+       *  model and a session selects one by id). Stage A's configuration writer
+       *  declares no reasoning variants, so there is none to select and the tier is
+       *  left to OpenCode's default — the honest answer until a deployment declares
+       *  them (a follow-up to the configuration word). */
+      effort(_tier) {
+        return void 0;
+      }
+      /** OpenCode's own tools a run of this identity holds — what the deny rules
+       *  leave visible — in the record's shared vocabulary (`shell → bash`,
+       *  `glob → find`), so the conformance table, which reads the record, sees the
+       *  same words a tool call lands under and across harnesses. */
+      builtinTools(identity2) {
+        return openCodeBuiltinToolsFor(identity2).map(openCodeToolNameWord);
+      }
+      open(deps, run2) {
+        return openOpenCodeRun(deps, run2, this.settings);
+      }
+      /** Where the row's OpenCode is (the survival clause), before any pid is
+       *  probed: another harness's facts answer `another-harness` with no command;
+       *  a row naming another container than this run was handed is
+       *  `another-container` (a pid here is a stranger's); else the recorded port is
+       *  probed — any HTTP answer (even the 401 the password-guarded health returns
+       *  without the bearer, which `find` does not hold) means the server is up
+       *  (`alive-here`), a connection that reaches no server means `dead`. A
+       *  container gone under the probe is the typed error, as pi's `find` rethrows. */
+      async find(facts2, container) {
+        if (facts2.harness !== "opencode") return "another-harness";
+        const oc = facts2;
+        const here = await container.identity();
+        if (oc.container !== void 0 && here !== void 0 && oc.container !== here) return "another-container";
+        try {
+          const paths = openCodeRunPathsAt(oc.root);
+          await container.request(paths, { method: "GET", port: oc.port, path: OPENCODE_ROUTES["health.get"].path });
+          return "alive-here";
+        } catch (err2) {
+          if (isContainerGone(err2)) throw err2;
+          return "dead";
+        }
+      }
+      /** End the OpenCode a previous generation left behind — the server and its
+       *  tailer at the pids the facts name, the root removed — best-effort, like the
+       *  session's end; another harness's facts are left alone. */
+      async end(facts2, container) {
+        if (facts2.harness !== "opencode") return;
+        const oc = facts2;
+        await container.kill(oc.pid).catch(() => {
+        });
+        if (oc.tailerPid !== void 0) await container.kill(oc.tailerPid).catch(() => {
+        });
+        await container.remove(openCodeRunPathsAt(oc.root)).catch(() => {
+        });
+      }
+    };
+  }
+});
+
 // ../../src/core/runLedger/takeover.ts
 var LedgerTakeover;
 var init_takeover = __esm({
@@ -44894,8 +47272,8 @@ async function handleMcpMessage(identity2, rawBody, deps, options) {
     return { status: 202 };
   }
   const params = typeof msg.params === "object" && msg.params !== null && !Array.isArray(msg.params) ? msg.params : {};
-  const request = { id: readId(msg), method: msg.method, params };
-  const body = await route2(request, identity2, deps, options, lookup2);
+  const request2 = { id: readId(msg), method: msg.method, params };
+  const body = await route2(request2, identity2, deps, options, lookup2);
   return { status: 200, body };
 }
 function createMcpHandler(deps, options) {
@@ -45132,20 +47510,20 @@ function residentsFleetTone(records) {
   return tones.size === 1 && tones.has("green") ? "green" : "grey";
 }
 function residentSlug(record2) {
-  return str6(record2.resource).replace(/^repo:/, "");
+  return str7(record2.resource).replace(/^repo:/, "");
 }
 function residentLive(record2) {
   const live = rec(record2.live);
   if (typeof live.error === "string") return { ...live, state: "unreachable", reason: live.error };
-  return { ...live, state: str6(live.state) || "unknown", reason: str6(live.reason) };
+  return { ...live, state: str7(live.state) || "unknown", reason: str7(live.reason) };
 }
-var RESIDENT_SLUG_RE, str6, rec;
+var RESIDENT_SLUG_RE, str7, rec;
 var init_residentsModel = __esm({
   "../../src/channels/residentsModel.ts"() {
     "use strict";
     init_residentDiskBudget();
     RESIDENT_SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?\/[a-z0-9](?:[a-z0-9._-]{0,98}[a-z0-9])?$/;
-    str6 = (v) => typeof v === "string" ? v : typeof v === "number" ? String(v) : "";
+    str7 = (v) => typeof v === "string" ? v : typeof v === "number" ? String(v) : "";
     rec = (v) => v && typeof v === "object" ? v : {};
   }
 });
@@ -46200,6 +48578,707 @@ 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;
+  return {
+    ...actor,
+    self: [actor.id, person.id],
+    asUser: { id: person.id, ...person.name ? { name: person.name } : {} }
+  };
+}
+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;
+var init_commandHttp = __esm({
+  "../../src/channels/commandHttp.ts"() {
+    "use strict";
+    init_actor();
+    init_commandRegistry();
+    init_commandSurface();
+    init_accessAuth();
+    init_http();
+    API_ROOT = "/api";
+  }
+});
+
+// ../../src/channels/web.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
+function parseThreadsRoute(pathname) {
+  if (pathname === "/threads" || pathname === "/threads/") return { kind: "new" };
+  const m = /^\/threads\/([^/]+)(\/send)?\/?$/.exec(pathname);
+  if (!m) return null;
+  let id;
+  try {
+    id = decodeURIComponent(m[1]);
+  } catch {
+    return null;
+  }
+  if (!CONVERSATION_ID_RE.test(id) && !THREAD_KEY_RE.test(id)) return null;
+  return m[2] ? { kind: "send", id } : { kind: "thread", id };
+}
+function mintConversationId() {
+  return randomBytes6(CONVERSATION_ID_BYTES).toString("hex");
+}
+function threadKeyFor(sub, id) {
+  return id.includes(":") ? id : `${PLATFORM5}:${sub}:${id}`;
+}
+function ownLane(sub, threadKey) {
+  return threadKey.startsWith(`${PLATFORM5}:${sub}:`);
+}
+function conversationIdOf(sub, threadKey) {
+  return ownLane(sub, threadKey) ? threadKey.slice(`${PLATFORM5}:${sub}:`.length) : threadKey;
+}
+function requesterOf(actor, identity2) {
+  if (actor.asUser)
+    return {
+      userId: actor.asUser.id,
+      ...actor.asUser.name ? { userName: actor.asUser.name } : {},
+      authenticatedAs: actor.id
+    };
+  return { userId: actor.id, ...identity2.email ? { userName: identity2.email } : {} };
+}
+function threadTitle(firstRequest, max = TITLE_MAX2) {
+  const line3 = firstRequest.split(/\r?\n/).find((l) => l.trim() !== "")?.trim() ?? "";
+  if (line3.length <= max) return line3 || "New conversation";
+  return `${line3.slice(0, max - 1).trimEnd()}\u2026`;
+}
+function turnOf(view, token2) {
+  const { events, route: _route, ...rest } = view;
+  let request2 = "";
+  let answer;
+  let route3;
+  for (const e of events ?? []) {
+    if (e.type === "input") {
+      if (request2 === "") request2 = e.text;
+    } else if (e.type === "answer") answer = e.text;
+    else if (e.type === "route" && route3 === void 0) route3 = { preset: e.preset, reason: e.reason };
+  }
+  return {
+    ...rest,
+    ...token2 !== void 0 ? { token: token2 } : {},
+    request: request2,
+    ...answer !== void 0 ? { answer } : {},
+    ...route3 !== void 0 ? { route: route3 } : {}
+  };
+}
+function historyOf(turns) {
+  const items = [];
+  for (const t of turns) {
+    if (t.request) items.push({ role: "user", text: t.request, at: t.receivedAt ?? t.startedAt });
+    if (t.answer !== void 0 && t.finishedAt !== void 0)
+      items.push({ role: "assistant", text: t.answer, at: t.finishedAt });
+  }
+  return items;
+}
+function threadsOf(runs, limit = RAIL_THREADS) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const run2 of runs) {
+    if (!run2.threadKey) continue;
+    const at = run2.finishedAt ?? run2.startedAt;
+    const g = groups.get(run2.threadKey);
+    if (g) {
+      g.runs.push(run2);
+      g.lastAt = Math.max(g.lastAt, at);
+      g.live ||= !run2.finished;
+    } else {
+      groups.set(run2.threadKey, {
+        threadKey: run2.threadKey,
+        surface: platformOf2(run2.channelId ?? run2.threadKey),
+        runs: [run2],
+        lastAt: at,
+        live: !run2.finished
+      });
+    }
+  }
+  const out = [...groups.values()].sort((a, b) => b.lastAt - a.lastAt).slice(0, limit);
+  for (const g of out) g.runs.sort((a, b) => a.startedAt - b.startedAt);
+  return out;
+}
+function platformOf2(id) {
+  const colon = id.indexOf(":");
+  return colon > 0 ? id.slice(0, colon) : "unknown";
+}
+function paletteCommands(list, actor) {
+  return list.filter((cmd) => cmd.surfaces?.chat !== false).filter((cmd) => authorize(actor, cmd.action, { type: "command", id: cmd.id }).allow).map((cmd) => ({ chat: chatForm(cmd.id), describe: cmd.describe })).sort((a, b) => a.chat.localeCompare(b.chat));
+}
+function suggestionsFor(input) {
+  const repo = input.repos[0];
+  const chips = [];
+  if (repo) chips.push(`review the open PR on ${repo}`);
+  else if (input.capabilities.github) chips.push("review a pull request \u2014 paste its link");
+  if (input.failed) chips.push("why did my last run fail?");
+  else if (input.any) chips.push("what did my last run do?");
+  chips.push("what agent and model do I get here?");
+  if (input.capabilities.mcp) chips.push("connect an MCP server");
+  chips.push("What can Switchboard do?");
+  return chips;
+}
+function createWebChatHandler(deps) {
+  const now = deps.now ?? systemClock;
+  const mintId = deps.mintId ?? mintConversationId;
+  const warn = deps.warn ?? ((m) => console.warn(`[web] ${m}`));
+  const dispatchFn = deps.dispatch ?? dispatch;
+  const maxBytes = deps.maxBodyBytes ?? MAX_BODY_BYTES2;
+  const retentionDays = deps.retention ? deps.retention.retentionDays : null;
+  const subOf = (actor) => actor.id.replace(/^access:/, "");
+  const liveToken = (run2) => run2.finished ? void 0 : deps.registry.getById(run2.id)?.token;
+  async function turnsOf(threadKey, actor) {
+    const listed = await deps.service.listRuns({
+      status: "all",
+      visibleTo: readableRuns(actor),
+      threadKey,
+      limit: CONVERSATION_RUNS
+    });
+    if (listed.storeUnavailable) warn(`the run store is unavailable: ${threadKey} seeds its live runs only`);
+    const runs = [...listed.runs].sort((a, b) => a.startedAt - b.startedAt);
+    const turns = await Promise.all(
+      runs.map(async (run2) => {
+        const read = await deps.service.getRun(run2.id, { include: "messages" });
+        return turnOf(read.ok ? read.value : { ...run2 }, liveToken(run2));
+      })
+    );
+    return { turns, runs };
+  }
+  async function railOf(actor, sub) {
+    const listed = await deps.service.listRuns({
+      status: "all",
+      visibleTo: allOf([readableRuns(actor), ownedBy(actor)]),
+      limit: RAIL_RUNS
+    });
+    const groups = threadsOf(listed.runs);
+    const rows = await Promise.all(
+      groups.map(async (g) => {
+        const first = g.runs[0];
+        const read = await deps.service.getRun(first.id, { include: "messages" });
+        const request2 = read.ok ? turnOf(read.value).request : "";
+        return {
+          id: conversationIdOf(sub, g.threadKey),
+          title: threadTitle(request2 || first.label || first.id),
+          lastAt: g.lastAt,
+          runs: g.runs.length,
+          live: g.live,
+          surface: g.surface
+        };
+      })
+    );
+    return { rows, runs: listed.runs };
+  }
+  async function seedFor(ctx, conversation, threadKey, open2) {
+    const sub = subOf(ctx.actor);
+    const rail = await railOf(ctx.actor, sub);
+    const mine = rail.runs;
+    const repos = [...new Set(mine.map((r) => r.repo).filter((r) => r !== void 0))];
+    const foreign = !ownLane(sub, threadKey);
+    return {
+      page: "home",
+      conversation,
+      turns: open2.turns,
+      conversations: rail.rows,
+      viewer: { name: ctx.actor.asUser?.name ?? ctx.identity.email ?? sub },
+      sendUrl: `/threads/${encodeURIComponent(conversation)}/send`,
+      ...foreign ? {
+        elsewhere: {
+          surface: platformOf2(threadKey),
+          ...(() => {
+            const url = open2.runs.find((r) => r.sourceUrl)?.sourceUrl;
+            return url ? { url } : {};
+          })()
+        }
+      } : {},
+      now: now(),
+      retentionDays,
+      suggestions: suggestionsFor({
+        repos,
+        failed: mine.some((r) => r.status === "failed"),
+        any: mine.length > 0,
+        capabilities: deps.capabilities
+      }),
+      commands: paletteCommands(deps.commands.list(), ctx.actor)
+    };
+  }
+  async function send(req, res, ctx, id) {
+    const answer = (status3, body) => {
+      res.writeHead(status3, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+      res.end(JSON.stringify(body));
+    };
+    if (!originAllowed(req, { publicBaseUrl: deps.publicBaseUrl })) {
+      answer(403, { error: "forbidden_origin" });
+      req.destroy();
+      return;
+    }
+    const ct = (Array.isArray(req.headers["content-type"]) ? req.headers["content-type"][0] : req.headers["content-type"])?.split(";")[0].trim().toLowerCase();
+    if (ct !== "application/json") {
+      answer(415, { error: "unsupported_media_type" });
+      req.destroy();
+      return;
+    }
+    const sub = subOf(ctx.actor);
+    const threadKey = threadKeyFor(sub, id);
+    if (!ownLane(sub, threadKey)) {
+      answer(403, { error: "forbidden", detail: `this thread lives on ${platformOf2(threadKey)}; reply there` });
+      req.destroy();
+      return;
+    }
+    const read = await readBody(req, maxBytes);
+    if (!read.ok) {
+      answer(413, { error: "request body too large" });
+      req.destroy();
+      return;
+    }
+    let text;
+    try {
+      const parsed = JSON.parse(read.body);
+      if (typeof parsed !== "object" || parsed === null || typeof parsed.text !== "string" || parsed.text.trim() === "")
+        throw new Error("shape");
+      text = parsed.text;
+    } catch {
+      answer(400, { error: "`text` is required and must be a non-empty string" });
+      return;
+    }
+    const receivedAt = now();
+    const trace = startRequestRoot(deps.core, { channel: "web", receivedAt });
+    const msg = {
+      ...requesterOf(ctx.actor, ctx.identity),
+      channelId: `${PLATFORM5}:${sub}`,
+      threadKey,
+      text,
+      receivedAt
+    };
+    const io = new WebIO(
+      async (exceptRunId) => historyOf((await turnsOf(threadKey, ctx.actor)).turns.filter((t) => t.id !== exceptRunId))
+    );
+    const done = dispatchFn(deps.core, msg, io, { trace }).catch((err2) => {
+      warn(`dispatch: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    });
+    const started = await Promise.race([io.started, done.then(() => void 0)]);
+    const token2 = started ? deps.registry.getById(started.id)?.token : void 0;
+    if (started && token2 !== void 0) {
+      answer(202, {
+        runId: started.id,
+        viewPath: `/runs/${encodeURIComponent(started.id)}?t=${token2}`,
+        threadKey
+      });
+      return;
+    }
+    await done;
+    const run2 = io.run();
+    answer(200, { reply: io.collected(), ...run2 ? { run: run2 } : {} });
+  }
+  return (req, res, ctx) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const route3 = parseThreadsRoute(url.pathname);
+    if (!route3) return false;
+    const method = (req.method ?? "GET").toUpperCase();
+    const plain5 = (status3, body, extra = {}) => {
+      res.writeHead(status3, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store", ...extra });
+      res.end(body);
+    };
+    const failed = (err2) => {
+      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX2);
+      if (res.headersSent) {
+        warn(`render failed after the head was sent: ${reason2}`);
+        res.end();
+        return;
+      }
+      plain5(502, `threads unavailable: ${reason2}`);
+    };
+    if (route3.kind === "send") {
+      if (method !== "POST") {
+        plain5(405, "method not allowed", { allow: "POST" });
+        return true;
+      }
+      send(req, res, ctx, route3.id).catch(failed);
+      return true;
+    }
+    if (method !== "GET") {
+      plain5(405, "method not allowed", { allow: "GET" });
+      return true;
+    }
+    const render3 = (title, seed) => {
+      res.writeHead(200, WEB_HTML_HEADERS);
+      res.end(deps.shell(title, seed));
+    };
+    const sub = subOf(ctx.actor);
+    if (route3.kind === "new") {
+      const conversation = mintId();
+      seedFor(ctx, conversation, threadKeyFor(sub, conversation), { turns: [], runs: [] }).then((seed) => render3("Threads", seed)).catch(failed);
+      return true;
+    }
+    const threadKey = threadKeyFor(sub, route3.id);
+    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 }));
+        return;
+      }
+      const seed = await seedFor(ctx, route3.id, threadKey, open2);
+      const liveCount = open2.runs.filter((r) => !r.finished).length;
+      render3(`${liveCount > 0 ? `(${liveCount}) ` : ""}Threads`, seed);
+    }).catch(failed);
+    return true;
+  };
+}
+var PLATFORM5, CONVERSATION_ID_BYTES, CONVERSATION_ID_RE, THREAD_KEY_RE, RAIL_THREADS, CONVERSATION_RUNS, RAIL_RUNS, TITLE_MAX2, UPSTREAM_REASON_MAX2, WebIO;
+var init_web2 = __esm({
+  "../../src/channels/web.ts"() {
+    "use strict";
+    init_authz();
+    init_commandSurface();
+    init_dispatcher();
+    init_requestTrace();
+    init_clock();
+    init_commandHttp();
+    init_http();
+    init_viewer();
+    init_webShell();
+    PLATFORM5 = "web";
+    CONVERSATION_ID_BYTES = 10;
+    CONVERSATION_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+    THREAD_KEY_RE = /^[a-z]+:[A-Za-z0-9_.:@+-]{1,200}$/;
+    RAIL_THREADS = 20;
+    CONVERSATION_RUNS = 20;
+    RAIL_RUNS = 100;
+    TITLE_MAX2 = 60;
+    UPSTREAM_REASON_MAX2 = 400;
+    WebIO = class extends HttpIO {
+      constructor(turns) {
+        super();
+        this.turns = turns;
+      }
+      turns;
+      runId;
+      runStarted(started) {
+        this.runId = started.id;
+        super.runStarted(started);
+      }
+      history() {
+        return this.turns(this.runId);
+      }
+    };
+  }
+});
+
 // ../../src/channels/costsView.ts
 function parseCostsRoute(pathname, search = "") {
   const params = new URLSearchParams(search);
@@ -46269,7 +49348,7 @@ function createCostsViewHandler(service, shell) {
         plain2(res, 503, err2.message, { "retry-after": String(NO_SNAPSHOT_RETRY_AFTER_SECONDS) });
         return;
       }
-      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX2);
+      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX3);
       plain2(res, 502, `cost report unavailable: ${reason2}`);
     };
     if (route3.kind === "users-json") {
@@ -46299,7 +49378,7 @@ function createCostsViewHandler(service, shell) {
     return true;
   };
 }
-var GROUP_RE, SNAPSHOT_COMMAND, UPSTREAM_REASON_MAX2, NO_SNAPSHOT_RETRY_AFTER_SECONDS, orNone;
+var GROUP_RE, SNAPSHOT_COMMAND, UPSTREAM_REASON_MAX3, NO_SNAPSHOT_RETRY_AFTER_SECONDS, orNone;
 var init_costsView = __esm({
   "../../src/channels/costsView.ts"() {
     "use strict";
@@ -46309,7 +49388,7 @@ var init_costsView = __esm({
     init_webShell();
     GROUP_RE = /^[a-z0-9][a-z0-9-]{0,39}$/;
     SNAPSHOT_COMMAND = { type: "command", id: "costs.snapshot" };
-    UPSTREAM_REASON_MAX2 = 400;
+    UPSTREAM_REASON_MAX3 = 400;
     NO_SNAPSHOT_RETRY_AFTER_SECONDS = 60;
     orNone = (read) => read.catch((err2) => {
       if (err2 instanceof NoCostsSnapshotError) return null;
@@ -46383,13 +49462,13 @@ function createDeliveryViewHandler(deps, shell) {
       res.writeHead(200, WEB_HTML_HEADERS);
       res.end(html);
     }).catch((err2) => {
-      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX3);
+      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX4);
       plain3(res, 502, `delivery sources unavailable: ${reason2}`);
     });
     return true;
   };
 }
-var SEGMENT, DELIVERY_NO_REPOS_MESSAGE, UPSTREAM_REASON_MAX3;
+var SEGMENT, DELIVERY_NO_REPOS_MESSAGE, UPSTREAM_REASON_MAX4;
 var init_deliveryView = __esm({
   "../../src/channels/deliveryView.ts"() {
     "use strict";
@@ -46399,7 +49478,7 @@ var init_deliveryView = __esm({
     init_webShell();
     SEGMENT = /^(?!\.+$)[\w.-]{1,100}$/;
     DELIVERY_NO_REPOS_MESSAGE = "No repository to report on \u2014 name one or more `owner/name` under delivery.repos in config to enable this view (the `delivery report --repo` command needs no config).";
-    UPSTREAM_REASON_MAX3 = 400;
+    UPSTREAM_REASON_MAX4 = 400;
   }
 });
 
@@ -46435,6 +49514,20 @@ function plain4(res, status3, body, extra = {}) {
   res.writeHead(status3, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store", ...extra });
   res.end(body);
 }
+function viewerSettingsView(description) {
+  const strip = (s) => {
+    if (!s) return void 0;
+    const { mcpServers: _servers, ...kept } = s;
+    return kept;
+  };
+  return {
+    effective: description.effective,
+    defaults: description.defaults,
+    restrictedAgents: description.restrictedAgents,
+    user: strip(description.user) ?? {},
+    ...description.org ? { org: strip(description.org) } : {}
+  };
+}
 function channelScopeView(description) {
   const { user: _user, channel, org, ...rest } = description;
   const strip = (s) => {
@@ -46478,11 +49571,15 @@ function createSettingsViewHandler(deps, shell) {
     return { ...channel ? { channel } : {}, servers, canWrite: write };
   }
   async function channelsSeed(caller, channel) {
-    const [indexed, shown] = await Promise.all([
+    const [indexed, mine, shown] = await Promise.all([
       deps.commands.invoke("config.overrides", {}, caller),
+      // The viewer's own settings, always: a settings page never has "no data" (record 0041).
+      deps.commands.invoke("config.show", {}, caller),
       channel ? deps.commands.invoke("config.show", { options: { channel } }, caller) : Promise.resolve(void 0)
     ]);
     const out = indexed.ok ? { index: indexed.value.channels ?? [] } : { index: [], unavailable: failureText(indexed) };
+    if (mine.ok) out.viewer = viewerSettingsView(mine.value);
+    else out.viewerUnavailable = failureText(mine);
     if (channel && shown) {
       const write = canWrite(caller, "config:write", "channel", channel);
       out.selected = shown.ok ? { channelId: channel, scope: channelScopeView(shown.value), canWrite: write } : { channelId: channel, refused: failureText(shown), canWrite: write };
@@ -46499,7 +49596,7 @@ function createSettingsViewHandler(deps, shell) {
     }
     const tab = route3.tab === "home" ? homeTab(deps.capabilities) : route3.tab;
     const failed = (err2) => {
-      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX4);
+      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX5);
       if (res.headersSent) {
         console.error(`[settings] render failed after the head was sent: ${reason2}`);
         res.end();
@@ -46536,14 +49633,14 @@ function createSettingsViewHandler(deps, shell) {
     return true;
   };
 }
-var CHANNEL_ID_RE, UPSTREAM_REASON_MAX4, failureText;
+var CHANNEL_ID_RE, UPSTREAM_REASON_MAX5, failureText;
 var init_settingsView = __esm({
   "../../src/channels/settingsView.ts"() {
     "use strict";
     init_authorize();
     init_webShell();
     CHANNEL_ID_RE = /^[a-z]+:[A-Za-z0-9_.:-]{1,80}$/;
-    UPSTREAM_REASON_MAX4 = 400;
+    UPSTREAM_REASON_MAX5 = 400;
     failureText = (r) => r.message;
   }
 });
@@ -46821,184 +49918,9 @@ var init_installationSettings = __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/dashboardAuth.ts
 import { createHash as createHash5, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
-function header2(headers, name) {
+function header3(headers, name) {
   const raw = headers[name];
   return Array.isArray(raw) ? raw[0] : raw;
 }
@@ -47007,7 +49929,7 @@ function accessVerifier(config, deps) {
     mode: "access",
     describe: () => `access (Cloudflare Access SSO, ${config.teamDomain})`,
     async verify(req) {
-      const token2 = header2(req.headers, "cf-access-jwt-assertion");
+      const token2 = header3(req.headers, "cf-access-jwt-assertion");
       if (!token2) return FORBIDDEN;
       const identity2 = await verifyAccessJwt(token2, config, deps);
       return identity2 ? { ok: true, identity: identity2 } : FORBIDDEN;
@@ -47024,7 +49946,7 @@ function tokenVerifier(opts) {
     mode: "token",
     describe: () => `token (bearer from $${opts.env} \u2192 access:${opts.subject})`,
     async verify(req) {
-      const auth = header2(req.headers, "authorization");
+      const auth = header3(req.headers, "authorization");
       if (!auth) return FORBIDDEN;
       const m = /^Bearer\s+(\S+)\s*$/i.exec(auth);
       if (!m) return FORBIDDEN;
@@ -47205,7 +50127,7 @@ async function start2(svc, nonce, identity2, res) {
       );
     return page(res, statusFor(result.refusal.kind), "Connect link unavailable", `<p class="err">${esc(message4)}</p>`);
   }
-  const host = hostOf(result.redirectUrl);
+  const host = hostOf2(result.redirectUrl);
   page(
     res,
     200,
@@ -47316,12 +50238,12 @@ function readForm(req) {
 }
 function entryForm(server, nonce) {
   if (server.auth === "oauth") {
-    const host = hostOf(server.url);
+    const host = hostOf2(server.url);
     return `<p>Connect <strong>${esc(server.name)}</strong> (<code>${esc(server.url)}</code>) by signing in with ${esc(host)}. You will be sent to its sign-in page and back here; the resulting credential is encrypted and stored for your runs only \u2014 it never appears in Slack, logs, or run records.</p><form method="post" action="${MCP_CONNECT_PREFIX}${esc(nonce)}"><input type="hidden" name="action" value="start"><button type="submit">Continue to ${esc(host)}</button></form>`;
   }
   return `<p>Paste the API token for <strong>${esc(server.name)}</strong> (<code>${esc(server.url)}</code>). It is encrypted and stored for your runs only; it never appears in Slack, logs, or run records.</p><form method="post" action="${MCP_CONNECT_PREFIX}${esc(nonce)}"><label for="token">Token</label><input id="token" name="token" type="password" autocomplete="off" required maxlength="8192"><button type="submit">Connect</button></form>`;
 }
-function hostOf(url) {
+function hostOf2(url) {
   try {
     return new URL(url).host;
   } catch {
@@ -48078,8 +51000,8 @@ async function generatedUnitOf(instance, unit, readers) {
     const url = resume.url ?? `https://github.com/${instance.repo}/pull/${resume.pr}`;
     return generatedUnit(unit.unit, `Resume the review loop of ${url}`);
   }
-  const request = await readers.readShipRequest();
-  const task = request !== void 0 ? shipTaskText(parseDirectives(request).text, instance.repo) : "";
+  const request2 = await readers.readShipRequest();
+  const task = request2 !== void 0 ? shipTaskText(parseDirectives(request2).text, instance.repo) : "";
   return generatedUnit(unit.unit, task || "Implement the task this thread's ship request describes.");
 }
 async function contractFor(instance, unit, readers) {
@@ -49033,20 +51955,24 @@ async function merge(body, deps, subject2) {
       at
     });
   if (checks.failed.length > 0) return refused6(`CI is red at \`${headSha.slice(0, 7)}\`: ${checks.failed.join(", ")}`);
-  if (checks.total === 0)
+  if (checks.total === 0) {
+    deps.noteMergeWait?.(headSha, id.value, at);
     return json2(200, {
       ok: true,
       outcome: "pending",
       reason: `no check has reported at \`${headSha.slice(0, 7)}\` yet`,
       at
     });
-  if (checks.pending.length > 0)
+  }
+  if (checks.pending.length > 0) {
+    deps.noteMergeWait?.(headSha, id.value, at);
     return json2(200, {
       ok: true,
       outcome: "pending",
       reason: `${checks.pending.length} check(s) still running at \`${headSha.slice(0, 7)}\`: ${checks.pending.join(", ")}`,
       at
     });
+  }
   let merged;
   try {
     merged = await deps.mergePullRequest(pr, {
@@ -49309,6 +52235,109 @@ var init_adminCoordinator = __esm({
   }
 });
 
+// ../../src/core/coordinator/checksIntake.ts
+async function verifyWebhookSignature(secret2, rawBody, signature) {
+  const key = await crypto.subtle.importKey("raw", encoder2.encode(secret2), { name: "HMAC", hash: "SHA-256" }, false, [
+    "sign"
+  ]);
+  const digest = new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder2.encode(rawBody)));
+  const expected = `sha256=${toHex(digest)}`;
+  if (signature.length !== expected.length) return false;
+  let diff = 0;
+  for (let i = 0; i < expected.length; i++) diff |= expected.charCodeAt(i) ^ signature.charCodeAt(i);
+  return diff === 0;
+}
+function createMergeWaitRegistry(ttlMs = MERGE_WAIT_TTL_MS) {
+  const byHead = /* @__PURE__ */ new Map();
+  return {
+    note(headSha, instanceId, now) {
+      const entry = byHead.get(headSha) ?? /* @__PURE__ */ new Map();
+      entry.set(instanceId, now);
+      byHead.set(headSha, entry);
+    },
+    waitingAt(headSha, now) {
+      const entry = byHead.get(headSha);
+      if (!entry) return [];
+      const alive = [];
+      for (const [id, at] of entry) {
+        if (now - at > ttlMs) entry.delete(id);
+        else alive.push(id);
+      }
+      if (entry.size === 0) byHead.delete(headSha);
+      return alive;
+    }
+  };
+}
+async function handleCheckRunIntake(headers, rawBody, deps) {
+  if (deps.secret === void 0 || deps.secret === "") return { status: 503, body: { error: "disabled" } };
+  if (headers.signature === void 0 || !await verifyWebhookSignature(deps.secret, rawBody, headers.signature))
+    return { status: 401, body: { error: "unauthorized" } };
+  if (headers.event !== "check_run") return { status: 200, body: { ok: true, ignored: "event" } };
+  let payload;
+  try {
+    payload = JSON.parse(rawBody);
+  } catch {
+    return { status: 400, body: { error: "invalid_json" } };
+  }
+  if (typeof payload !== "object" || payload === null) return { status: 400, body: { error: "invalid_body" } };
+  const p = payload;
+  if (p.action !== "completed") return { status: 200, body: { ok: true, ignored: "action" } };
+  const headSha = p.check_run?.head_sha;
+  const repo = p.repository?.full_name;
+  if (typeof headSha !== "string" || headSha === "" || typeof repo !== "string" || repo === "")
+    return { status: 400, body: { error: "invalid_body" } };
+  if (!await deps.checksSettled(repo, headSha)) return { status: 200, body: { ok: true, settled: false } };
+  const instances = await deps.instancesWaitingAt(headSha);
+  const sends = [];
+  for (const instance of instances) sends.push(await sendChecksSettled(deps.workflow, instance, headSha, deps.now()));
+  return {
+    status: 200,
+    body: { ok: true, settled: true, sent: sends.filter((s) => s.kind === "sent").length, of: instances.length }
+  };
+}
+var GITHUB_SIGNATURE_HEADER, GITHUB_EVENT_HEADER, encoder2, toHex, MERGE_WAIT_TTL_MS;
+var init_checksIntake = __esm({
+  "../../src/core/coordinator/checksIntake.ts"() {
+    "use strict";
+    init_contract2();
+    GITHUB_SIGNATURE_HEADER = "x-hub-signature-256";
+    GITHUB_EVENT_HEADER = "x-github-event";
+    encoder2 = new TextEncoder();
+    toHex = (bytes) => [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    MERGE_WAIT_TTL_MS = 60 * 6e4;
+  }
+});
+
+// ../../src/channels/githubWebhook.ts
+function createGithubWebhookHandler(deps) {
+  return async (req, res) => {
+    const answer = (status3, body2) => {
+      res.writeHead(status3, { "content-type": "application/json" });
+      res.end(JSON.stringify(body2));
+    };
+    if (req.method !== "POST") return answer(405, { error: "method_not_allowed" });
+    const body = await readBody(req, MAX_BODY_BYTES4);
+    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]) },
+      body.body,
+      deps
+    );
+    answer(result.status, result.body);
+  };
+}
+var GITHUB_WEBHOOK_PATH, MAX_BODY_BYTES4, 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;
+    one = (v) => Array.isArray(v) ? v[0] : v;
+  }
+});
+
 // ../../src/core/scheduleStore.ts
 function buildScheduleStore(cfg, secrets, warn) {
   const worker = cfg?.worker;
@@ -49375,175 +52404,6 @@ var init_scheduleStore = __esm({
   }
 });
 
-// ../../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;
-  return {
-    ...actor,
-    self: [actor.id, person.id],
-    asUser: { id: person.id, ...person.name ? { name: person.name } : {} }
-  };
-}
-async function callerFor(identity2, opts) {
-  return {
-    kind: "access",
-    id: callerIdFor(identity2),
-    actor: await resolveAccessActor(identity2, opts),
-    ...identity2.email && !isServiceToken(identity2) ? { email: identity2.email } : {}
-  };
-}
-function hostOf2(url) {
-  if (!url) return void 0;
-  try {
-    return new URL(url).host.toLowerCase();
-  } catch {
-    return void 0;
-  }
-}
-function header3(req, name) {
-  const v = req.headers[name];
-  return Array.isArray(v) ? v[0] : v;
-}
-function originAllowed(req, opts) {
-  const site = header3(req, "sec-fetch-site");
-  if (site !== void 0 && site !== "same-origin" && site !== "none") return false;
-  const origin = header3(req, "origin");
-  if (origin === void 0) return true;
-  const expected = originOf(opts.publicBaseUrl);
-  if (expected !== void 0) return originOf(origin) === expected;
-  const host = header3(req, "host")?.toLowerCase();
-  const actual = hostOf2(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 = header3(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;
-var init_commandHttp = __esm({
-  "../../src/channels/commandHttp.ts"() {
-    "use strict";
-    init_actor();
-    init_commandRegistry();
-    init_commandSurface();
-    init_accessAuth();
-    init_http();
-    API_ROOT = "/api";
-  }
-});
-
 // ../../src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -49683,13 +52543,19 @@ async function runBot() {
   const residentFleet = fleetWatcher ?? NO_FLEET;
   const runBearers = new RunBearerStore({ clock: systemClock });
   const harnesses = new HarnessRegistry();
+  const roster = {
+    pi: new PiHarness(config.config.pi?.compaction ? { compaction: config.config.pi.compaction } : {}),
+    opencode: new OpenCodeHarness(
+      config.config.opencode?.compaction ? { compaction: config.config.opencode.compaction } : {}
+    )
+  };
   const deps = {
     config,
     completions,
     spanLog,
     runBearers,
     harness: {
-      harness: new PiHarness(config.config.pi?.compaction ? { compaction: config.config.pi.compaction } : {}),
+      harnesses: roster,
       registry: harnesses,
       ...process.env.PUBLIC_BASE_URL ? { harnessUrl: process.env.PUBLIC_BASE_URL } : {},
       ...process.env.PORT ? { loopbackUrl: `http://127.0.0.1:${process.env.PORT}` } : {}
@@ -49806,6 +52672,21 @@ async function runBot() {
       clock: systemClock
     });
     const harnessRoutes = createHarnessRoutesHandler({ bearers: runBearers, harnesses, takeover });
+    const mergeWaits = createMergeWaitRegistry();
+    const checksWorkflow = shimWorkflowSender({
+      baseUrl: process.env.PUBLIC_BASE_URL,
+      tokens: processSecrets.get("SWITCHBOARD_INGRESS_TOKENS")
+    });
+    const githubWebhook = createGithubWebhookHandler({
+      secret: processSecrets.get("GITHUB_WEBHOOK_SECRET")?.reveal(),
+      checksSettled: async (repo, headSha) => {
+        const checks = await fetchCommitChecks(repo, headSha);
+        return checks !== void 0 && checks.total > 0 && checks.pending.length === 0;
+      },
+      instancesWaitingAt: (headSha) => Promise.resolve(mergeWaits.waitingAt(headSha, systemClock())),
+      workflow: checksWorkflow,
+      now: systemClock
+    });
     const coordinatorAdmin = createAdminCoordinatorHandler({
       tokens: processSecrets.get("SWITCHBOARD_INGRESS_TOKENS"),
       grantsFor: (id) => config.grantsFor(id),
@@ -49830,7 +52711,8 @@ async function runBot() {
       mergePullRequest,
       selfIdentity: resolveGithubIdentity,
       runHistoryWriter,
-      channelVisibilityOf: (channelId) => channelVisibilityOf(deps, channelId)
+      channelVisibilityOf: (channelId) => channelVisibilityOf(deps, channelId),
+      noteMergeWait: (headSha, instanceId, at) => mergeWaits.note(headSha, instanceId, at)
     });
     const cronArmed = Object.values(auth.tokens).some((id) => id.subject === "cron");
     const schedulesState = `${SCHEDULES.length} schedule(s) on /runs (${capabilities.schedules ? `firings from ${config.config.schedules?.worker?.baseUrl}` : "no firing store"}; cron identity ${cronArmed ? "armed" : "NOT in SWITCHBOARD_INGRESS_TOKENS \u2014 scheduled runs fail closed"})`;
@@ -49861,6 +52743,16 @@ async function runBot() {
       },
       shell
     );
+    const webChat = createWebChatHandler({
+      core: deps,
+      service: runsService,
+      registry: defaultRunRegistry,
+      commands,
+      shell,
+      capabilities,
+      retention: capabilities.runHistory && runHistoryCfg ? { retentionDays: retentionPolicyOf(runHistoryCfg).retentionDays } : null,
+      publicBaseUrl: process.env.PUBLIC_BASE_URL
+    });
     const deliveryState = !capabilities.github ? "GET /delivery (503 \u2014 no GitHub credential)" : deliveryService.repos().length === 0 ? "GET /delivery (503 \u2014 no delivery.repos)" : `GET /delivery (${deliveryService.repos().join(",")}; snapshot every ${deliveryEveryMinutes} min)`;
     const tokenCount = Object.keys(auth.tokens).length;
     const liveViewState = process.env.PUBLIC_BASE_URL ? "GET /runs (index) + /runs/:id (live view)" : "GET /runs (index) + live view (no PUBLIC_BASE_URL \u2014 per-run links omitted)";
@@ -49915,6 +52807,10 @@ async function runBot() {
         ingress(req, res);
         return;
       }
+      if (path === GITHUB_WEBHOOK_PATH) {
+        void githubWebhook(req, res);
+        return;
+      }
       if (path === "/mcp") {
         mcp2(req, res);
         return;
@@ -49963,7 +52859,7 @@ async function runBot() {
         return;
       }
       if (webAssets.serve(req, res)) return;
-      if (isCommandPath(path) || isConnectPath(path) || path === "/runs" || path.startsWith("/runs/") || path === "/residents" || path.startsWith("/residents/") || path === "/costs" || path === "/costs.json" || path.startsWith("/costs/") || path === "/delivery" || path === "/delivery.json" || path.startsWith("/delivery/") || path === "/settings" || path.startsWith("/settings/")) {
+      if (isCommandPath(path) || isConnectPath(path) || path === "/runs" || path.startsWith("/runs/") || path === "/residents" || path.startsWith("/residents/") || path === "/costs" || path === "/costs.json" || path.startsWith("/costs/") || path === "/delivery" || path === "/delivery.json" || path.startsWith("/delivery/") || path === "/settings" || path.startsWith("/settings/") || path === "/threads" || path.startsWith("/threads/")) {
         dashboardAuth.verify(req).then(async (gate) => {
           if (!gate.ok) {
             res.writeHead(gate.status, { "content-type": "text/plain; charset=utf-8" });
@@ -49985,6 +52881,7 @@ async function runBot() {
             personByEmail
           });
           if (liveView2(req, res, { actor })) return;
+          if (webChat(req, res, { actor, identity: gate.identity })) return;
           if (mcpConnectView(req, res, gate.identity)) return;
           if (residentsView(req, res, { actor })) return;
           if (costsView(req, res, { identity: gate.identity, actor })) return;
@@ -50000,7 +52897,7 @@ async function runBot() {
         return;
       }
       if (path === "/") {
-        res.writeHead(302, { location: "/runs" });
+        res.writeHead(302, { location: "/threads" });
         res.end();
         return;
       }
@@ -50041,7 +52938,7 @@ async function runBot() {
     }).listen(Number(process.env.PORT), () => {
       httpListeningAt = systemClock();
       console.log(
-        `http server on :${process.env.PORT} (health + POST /ingress + POST /mcp + model proxy (POST ${ANTHROPIC_MESSAGES_PATH}, POST ${OPENAI_CHAT_COMPLETIONS_PATH}) + ${liveViewState} + ${schedulesState} + ${residentsState} + ${costsState} + ${deliveryState} + GET /settings + ${commandHttpState} + /docs \u2192 ${PROJECT_DOCS_URL}; ${tokenCount > 0 ? `${tokenCount} ingress token(s)` : "ingress + MCP DISABLED \u2014 no tokens configured"}; ${accessState})`
+        `http server on :${process.env.PORT} (health + POST /ingress + POST /mcp + model proxy (POST ${ANTHROPIC_MESSAGES_PATH}, POST ${OPENAI_CHAT_COMPLETIONS_PATH}) + ${liveViewState} + ${schedulesState} + ${residentsState} + ${costsState} + ${deliveryState} + GET /settings + GET /threads (+ POST /threads/<id>/send) + ${commandHttpState} + /docs \u2192 ${PROJECT_DOCS_URL}; ${tokenCount > 0 ? `${tokenCount} ingress token(s)` : "ingress + MCP DISABLED \u2014 no tokens configured"}; ${accessState})`
       );
     });
   }
@@ -50212,6 +53109,7 @@ var init_index = __esm({
     init_packageRoot();
     init_webShell();
     init_residentsView();
+    init_web2();
     init_costsView();
     init_deliveryView();
     init_settingsView();
@@ -50259,6 +53157,7 @@ var init_index = __esm({
     init_modelProxy();
     init_runBearers();
     init_piHarness();
+    init_harness2();
     init_relay();
     init_harnessRoutes();
     init_adminTraceLog();
@@ -50273,6 +53172,9 @@ var init_index = __esm({
     init_docsLink();
     init_dispatcher();
     init_adminCoordinator();
+    init_githubWebhook();
+    init_checksIntake();
+    init_instancesClient();
     init_instanceStore();
     init_githubPulls();
     init_githubApi();
@@ -50329,6 +53231,7 @@ init_residentFleet();
 init_statusCardFrame();
 init_piAi();
 init_piHarness();
+init_harness2();
 init_relay();
 init_takeover();
 init_runBearers();
@@ -50688,12 +53591,18 @@ async function main() {
   const runBearers = new RunBearerStore({ clock: systemClock });
   const harnesses = new HarnessRegistry();
   const loopback = await askLoopbackServer({ bearers: runBearers, harnesses, config });
+  const roster = {
+    pi: new PiHarness(config.config.pi?.compaction ? { compaction: config.config.pi.compaction } : {}),
+    opencode: new OpenCodeHarness(
+      config.config.opencode?.compaction ? { compaction: config.config.opencode.compaction } : {}
+    )
+  };
   const deps = {
     config,
     completions,
     runBearers,
     harness: {
-      harness: new PiHarness(config.config.pi?.compaction ? { compaction: config.config.pi.compaction } : {}),
+      harnesses: roster,
       registry: harnesses,
       harnessUrl: loopback.url,
       loopbackUrl: loopback.url