commandmate 0.26.1 → 0.27.1

package/dist/server/src/lib/hooks/sources/opencode/ingest.js

@@ -67,11 +67,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ingestOpencodeEvent = ingestOpencodeEvent;
 const logger_1 = require("../../../../lib/logger");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
+const permission_adjudication_1 = require("../../../../lib/hooks/permission-adjudication");
 const agent_event_state_1 = require("../../../../lib/session/agent-event-state");
 const structured_prompt_1 = require("../../../../lib/session/structured-prompt");
-const abstain_1 = require("../abstain");
 const event_mapper_1 = require("../event-mapper");
-const pending_decisions_1 = require("../pending-decisions");
 const registry_1 = require("../registry");
 const mappers_1 = require("./mappers");
 const payloads_1 = require("./payloads");
@@ -100,14 +99,22 @@ function describeNotification(event) {
     return null;
 }
 /**
- * Adjudicate one approval and answer it over REST (Auto-Yes v2).
+ * Adjudicate one approval, answer it over REST, and say whether anybody is
+ * still blocked (Auto-Yes v2, reordered by Issue #1898).
  *
  * The adjudication itself is `resolvePermissionRequest`, unchanged and shared
- * with every hook-based tool. What is opencode-specific is what silence means:
- * on Claude an abstention costs a dialog, here it costs the session, because
- * the agent waits with no timeout at all (#1758 §5.5.3). `describeAbstain` is
- * how that gets said out loud — nothing else will say it, since a blocked
- * opencode session looks exactly like one that is thinking.
+ * with every hook-based tool; `adjudicatePendingPermission` is the wrapper that
+ * delivers the verdict and reads the source's capabilities to decide what the
+ * delivery means. What is opencode-specific is what silence costs: on Claude an
+ * abstention costs a dialog, here it costs the session, because the agent waits
+ * with no timeout at all (#1758 §5.5.3).
+ *
+ * **This runs before the event is recorded, and that ordering is the fix.** See
+ * {@link ingestOpencodeEvent}.
+ *
+ * @returns Whether the dialog can be treated as closed — a verdict was
+ *   delivered and this source declares that a reply releases the prompt. False
+ *   for every abstain, and false for an allow whose POST was refused.
  */
 async function adjudicatePermission(target, event, instanceId) {
     const source = (0, registry_1.getAgentEventSource)(tool_id_1.OPENCODE_CLI_TOOL_ID);
@@ -117,39 +124,41 @@ async function adjudicatePermission(target, event, instanceId) {
             worktreeId: target.worktreeId,
             instanceId,
         });
-        return;
+        return false;
     }
-    const { resolvePermissionRequest } = await Promise.resolve().then(() => __importStar(require('../../../../lib/hooks/permission-decision-service')));
-    const payload = source.parsePermissionRequest(event.raw);
-    const decision = resolvePermissionRequest({ worktreeId: target.worktreeId, cliToolId: tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId }, payload);
-    const verdict = decision.behavior === 'allow' ? { kind: 'allowOnce' } : { kind: 'abstain' };
-    if (verdict.kind === 'abstain') {
-        const abstain = (0, abstain_1.describeAbstain)(source);
-        if (!abstain.safe) {
-            logger.warn('permission-request-abstain-blocks-agent', {
-                worktreeId: target.worktreeId,
-                cliToolId: tool_id_1.OPENCODE_CLI_TOOL_ID,
-                instanceId,
-                toolName: payload?.toolName ?? null,
-                decisionId: pending.id,
-                reason: decision.reason,
-                consequence: abstain.summary,
-                blocksForMs: abstain.blocksForMs,
-            });
-        }
-    }
-    // C2: for this source the verdict leaves over its own connection, and the
-    // `{}` that comes back is an acknowledgement rather than a reply body.
-    await (0, pending_decisions_1.answerPendingDecision)(source, { worktreeId: target.worktreeId, cliToolId: tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId }, pending, verdict);
+    const outcome = await (0, permission_adjudication_1.adjudicatePendingPermission)(source, target, pending, source.parsePermissionRequest(event.raw));
     logger.info('opencode-permission-decided', {
         worktreeId: target.worktreeId,
         instanceId,
         decisionId: pending.id,
-        toolName: payload?.toolName ?? null,
-        behavior: decision.behavior,
-        reason: decision.reason,
-        suppressedBy: decision.suppressedBy,
+        behavior: outcome.behavior,
+        reason: outcome.reason,
+        delivered: outcome.delivered,
+        settled: outcome.settled,
     });
+    return outcome.settled;
+}
+/**
+ * Whether a `permission.replied` frame retires the prompt-waiting record
+ * (Issue #1898).
+ *
+ * The capability read, not a tool check: `permissionReplyReleasesPrompt` is the
+ * declared value that says "a reply on this source's own stream is a positive
+ * statement that the dialog is gone" (#1924, §4 D3). Flipping opencode's
+ * declaration to false puts this frame back to deciding nothing, which is the
+ * pre-#1898 behaviour and is exactly what the mutation case in
+ * `tests/unit/hooks/sources/opencode-permission-1898.test.ts` asserts.
+ */
+function replyReleasesPrompt(target, instanceId) {
+    const source = (0, registry_1.getAgentEventSource)(tool_id_1.OPENCODE_CLI_TOOL_ID);
+    if (source.capabilities.permissionReplyReleasesPrompt)
+        return true;
+    logger.info('opencode-permission-reply-not-releasing', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        reason: 'capability-permissionReplyReleasesPrompt-false',
+    });
+    return false;
 }
 /**
  * Record a question so `capture --prompts` and the picker can show its options.
@@ -206,25 +215,65 @@ async function applyStop(target, instanceId) {
 /**
  * Apply one event from the stream.
  *
+ * ## Adjudicate, then record (Issue #1898)
+ *
+ * `recordAgentEvent` is what opens the prompt-waiting record — it keys off
+ * `notification(permission_prompt)` — so recording an approval before deciding
+ * it publishes "a human is blocked" for an approval Auto-Yes is about to
+ * answer in the same tick. Measured: `capture --json` read
+ * `waiting / hook_permission_prompt` from the instant the reply was delivered
+ * until `sleep 8` finished, `wait --on-prompt agent` exited 10 the whole time,
+ * and `send` was refused by the guard. The verdict now goes out first and the
+ * record carries {@link AgentEventRecord.promptSettled}, so the state the human
+ * would have had to wait out is never entered.
+ *
+ * The order must not be put back. Recording first and clearing afterwards looks
+ * equivalent — nothing reads the map in between — but it re-creates a window
+ * that only stays closed by accident, and the release would then have to be
+ * repeated at every future caller instead of being a property of the record.
+ *
  * @param target - The instance the subscription belongs to
  * @param event - Already normalised and already through the turn gate
  */
 async function ingestOpencodeEvent(target, event) {
     const instanceId = target.instanceId ?? tool_id_1.OPENCODE_CLI_TOOL_ID;
     try {
-        // The same guard the hook receiver applies. It cannot catch the abort
-        // double-idle on its own — see `./turn-gate`, which is what does — but it
-        // does cover a frame delivered twice by a re-sync racing the live stream.
-        if ((0, agent_event_state_1.isDuplicateAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, event.event, event.conversationId, event.receivedAt, event.detail)) {
+        // Inside the `try` on purpose: this module's contract is that nothing here
+        // throws, and a registry lookup is still a lookup.
+        const source = (0, registry_1.getAgentEventSource)(tool_id_1.OPENCODE_CLI_TOOL_ID);
+        // Issue #1899. The guard the hook receiver applies is the *time window*,
+        // and on this stream it was dropping real events: two approvals a second
+        // apart share `(event, detail, sessionID)`, so the second one was neither
+        // adjudicated nor recorded, and opencode blocks on an unanswered approval
+        // for as long as it takes (10m19s, measured in #1758 §5.5.3).
+        //
+        // The capability decides which rule applies — no tool name is read here.
+        // `eventIdentity: 'permission-id'` puts frames that carry an id on the id,
+        // and leaves `session.idle` (which carries none, and which `./turn-gate`
+        // has already counted) unsuppressed. Declaring `null` instead puts every
+        // frame back on the window.
+        const delivery = (0, agent_event_state_1.classifyAgentEventDelivery)({
+            worktreeId: target.worktreeId,
+            cliToolId: tool_id_1.OPENCODE_CLI_TOOL_ID,
+            instanceId,
+            event: event.event,
+            detail: event.detail,
+            sessionId: event.conversationId,
+            at: event.receivedAt,
+            identity: source.eventIdentityOf(event.raw),
+            identityKind: source.capabilities.eventIdentity,
+        });
+        if (delivery.duplicate) {
             logger.info('opencode-event-duplicate-dropped', {
                 worktreeId: target.worktreeId,
                 instanceId,
                 event: event.event,
                 detail: event.detail,
+                by: delivery.by,
             });
             return;
         }
-        (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, {
+        const record = {
             event: event.event,
             at: event.receivedAt,
             detail: event.detail?.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH) ?? null,
@@ -236,11 +285,40 @@ async function ingestOpencodeEvent(target, event) {
             // Already bounded by the normaliser; null on the frames that carry no
             // `properties.info.model` (every `session.idle`, every tool part).
             model: event.model,
-        });
+        };
+        // Issue #1903: the same declared value the hook receiver passes, from the
+        // same place. opencode declares `false` — `session.created` really does open
+        // a session here — so this changes nothing for this source today; it is
+        // wired because the two receiving paths must not disagree about which
+        // capabilities the state machine is being told about, which is the mistake
+        // #1783 records having made with `model`.
+        const options = {
+            sessionStartMayArriveLate: source.capabilities.sessionStartMayArriveLate,
+        };
         if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_PERMISSION_DETAIL) {
-            await adjudicatePermission(target, event, instanceId);
+            // Issue #1898: the verdict leaves BEFORE the record is written. See the
+            // docblock above for what recording first cost.
+            record.decisionId = (0, event_mapper_1.readStringField)((0, event_mapper_1.isPlainObject)(event.raw.properties) ? event.raw.properties : {}, 'id');
+            record.promptSettled = await adjudicatePermission(target, event, instanceId);
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, record, options);
+            return;
+        }
+        if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_PERMISSION_REPLIED_DETAIL) {
+            // Issue #1898: somebody answered — this server, another client, or a
+            // human at the terminal. The last of those is the one nothing else can
+            // see, and it is why this frame is mapped at all.
+            record.decisionId = (0, mappers_1.repliedPermissionId)(event.raw);
+            record.promptSettled = replyReleasesPrompt(target, instanceId);
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, record, options);
+            logger.info('opencode-permission-reply-observed', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                decisionId: record.decisionId,
+                released: record.promptSettled,
+            });
             return;
         }
+        (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, record, options);
         if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_QUESTION_DETAIL) {
             recordQuestion(target, event, instanceId);
             return;

package/dist/server/src/lib/hooks/sources/opencode/mappers.js

@@ -33,13 +33,16 @@
  * @module lib/hooks/sources/opencode/mappers
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_MAPPERS = exports.OPENCODE_ERROR_DETAIL = exports.OPENCODE_QUESTION_DETAIL = exports.OPENCODE_PERMISSION_DETAIL = void 0;
+exports.OPENCODE_MAPPERS = exports.OPENCODE_ERROR_DETAIL = exports.OPENCODE_PERMISSION_REPLIED_DETAIL = exports.OPENCODE_QUESTION_DETAIL = exports.OPENCODE_PERMISSION_DETAIL = void 0;
 exports.frameProperties = frameProperties;
 exports.frameSessionId = frameSessionId;
 exports.frameModel = frameModel;
 exports.partToolName = partToolName;
 exports.partCallId = partCallId;
+exports.repliedPermissionId = repliedPermissionId;
+exports.opencodeEventIdentity = opencodeEventIdentity;
 exports.withConversationId = withConversationId;
+const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const event_mapper_1 = require("../event-mapper");
 /**
  * Detail for `permission.asked`.
@@ -60,6 +63,17 @@ exports.OPENCODE_PERMISSION_DETAIL = 'permission_prompt';
  * sitting at the composer" — so that spelling never appears here.
  */
 exports.OPENCODE_QUESTION_DETAIL = 'question_prompt';
+/**
+ * Detail for `permission.replied` (Issue #1898).
+ *
+ * The shared spelling, not a new one: `agent-event-state` releases the
+ * prompt-waiting record on exactly this word, and the same word is used by the
+ * adjudicator when *this server* is the one that answered. opencode is the only
+ * source that publishes the frame today, which is why its
+ * `permissionReplyReleasesPrompt` capability is the only one set to true — but
+ * the vocabulary is not opencode's, so it is imported rather than declared.
+ */
+exports.OPENCODE_PERMISSION_REPLIED_DETAIL = agent_event_types_1.PERMISSION_REPLIED_DETAIL;
 /** Detail for `session.error`. */
 exports.OPENCODE_ERROR_DETAIL = 'error';
 /** The `properties` object of a frame, or an empty object. */
@@ -107,17 +121,94 @@ function partToolName(payload) {
 function partCallId(payload) {
     return (0, event_mapper_1.readNestedString)(frameProperties(payload), ['part', 'callID']);
 }
+/**
+ * `properties.requestID` — the approval a `permission.replied` frame answers
+ * (Issue #1898).
+ *
+ * Spelled differently from the `properties.id` an approval is *asked* under,
+ * and the difference is measured rather than assumed: `permission-replied.json`
+ * carries `{ sessionID, requestID, reply }` and no `id` at all. Reading `id`
+ * here would leave every reply anonymous, and an anonymous reply retires
+ * whichever dialog happens to be open.
+ */
+function repliedPermissionId(payload) {
+    return (0, event_mapper_1.readNestedString)(frameProperties(payload), ['requestID']);
+}
+/**
+ * The frame's own id, for identity de-duplication (Issue #1899).
+ *
+ * This is the extraction half of `capabilities.eventIdentity: 'permission-id'`:
+ * the capability names the id, this finds it. One function rather than a field
+ * on each mapper rule because the id is a property of the *frame*, and the
+ * frames that carry one are not the same set as the frames that map to a word.
+ *
+ * ## Where each id lives, and why the list is not one path
+ *
+ * | frame | id | note |
+ * |---|---|---|
+ * | `permission.asked` | `properties.id` | `per_…` |
+ * | `permission.replied` | `properties.requestID` | the **same** `per_…`, spelled differently (#1898) |
+ * | `question.asked` | `properties.id` | `que_…` |
+ * | `message.updated` | `properties.info.id` | `msg_…` |
+ * | `message.part.updated` | `properties.part.callID` | `toolu_…` |
+ *
+ * The first two rows are why the caller keys on `(event, detail, identity)`
+ * rather than on the identity alone: an approval and the reply that answers it
+ * carry **the same value**, and a key made of the id by itself would read the
+ * reply as a repeat of the ask and drop the only positive statement any source
+ * makes that a dialog is gone.
+ *
+ * ## The frames that answer null
+ *
+ * `session.idle` is `{ "sessionID": "ses_…" }` and nothing else — measured, and
+ * the reason `./turn-gate` exists. `session.created` / `session.deleted` /
+ * `session.error` publish no per-frame id either. Null is the honest answer for
+ * all of them, and `classifyAgentEventDelivery` is where "no id" is turned into
+ * a policy per event word.
+ *
+ * The envelope's own `id` (`evt_…`) is deliberately **not** used. The captured
+ * fixtures redact it to a single placeholder, so nothing in this repository
+ * establishes that it is unique per frame rather than per subscription or per
+ * aggregate — and a key built on an unverified uniqueness claim silently drops
+ * real events, which is the bug this Issue is fixing.
+ */
+function opencodeEventIdentity(payload) {
+    const properties = frameProperties(payload);
+    switch ((0, event_mapper_1.readNestedString)(payload, ['type'])) {
+        case 'permission.asked':
+        case 'question.asked':
+            return (0, event_mapper_1.readEventIdentity)((0, event_mapper_1.readNestedString)(properties, ['id']));
+        case 'permission.replied':
+            return (0, event_mapper_1.readEventIdentity)(repliedPermissionId(payload));
+        case 'message.updated':
+            return (0, event_mapper_1.readEventIdentity)((0, event_mapper_1.readNestedString)(properties, ['info', 'id']));
+        case 'message.part.updated':
+            return (0, event_mapper_1.readEventIdentity)(partCallId(payload));
+        default:
+            return null;
+    }
+}
 /** Statuses that mean the tool call is over, either way (#1758 §5.2.3). */
 const FINISHED_PART_STATUSES = ['completed', 'error'];
 /**
  * The ordered rules, first match wins.
  *
- * `session.status`, `server.connected`, `server.heartbeat`, `permission.replied`
- * and `question.replied` are deliberately absent. They are real frames that
+ * `session.status`, `server.connected`, `server.heartbeat` and
+ * `question.replied` are deliberately absent. They are real frames that
  * arrive on every healthy connection and they map to none of the seven words,
  * so they fall through, return null and are counted (C8) — which is what the
  * interface asks for and what stops a ten-second keepalive from throwing.
  *
+ * `permission.replied` was in that list until Issue #1898 and is now mapped,
+ * for a reason that took a live measurement to see: it is the *only* positive
+ * statement any of the six tools makes that an approval dialog is gone. Left
+ * unmapped, a dialog answered in the terminal went on reading `waiting` until
+ * the tool call it gated finished — eight seconds on `sleep 8; pwd`, and
+ * indefinitely for an approval whose tool emits nothing. It maps to
+ * `notification`, which is the bundle word, with a detail that decides no
+ * status of its own (`agentEventToSessionStatus` answers null for it, so the
+ * scraper keeps the frame): all it does is retire the record.
+ *
  * `session.status(idle)` in particular must NOT be mapped: it is emitted in the
  * same millisecond as `session.idle` and mapping both would report every turn's
  * completion twice (#1758 §5.3.2 rule 4).
@@ -157,6 +248,7 @@ const OPENCODE_BASE_MAPPERS = [
     (0, event_mapper_1.whenNamed)('permission.asked', 'notification', exports.OPENCODE_PERMISSION_DETAIL),
     (0, event_mapper_1.whenNamed)('question.asked', 'notification', exports.OPENCODE_QUESTION_DETAIL),
     (0, event_mapper_1.whenNamed)('session.error', 'notification', exports.OPENCODE_ERROR_DETAIL),
+    (0, event_mapper_1.whenNamed)('permission.replied', 'notification', exports.OPENCODE_PERMISSION_REPLIED_DETAIL),
 ];
 /**
  * Fill `conversationId` from the nested envelope.

package/dist/server/src/lib/hooks/sources/opencode/ports.js

@@ -43,7 +43,7 @@
  * @module lib/hooks/sources/opencode/ports
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_PORT_RANGE = void 0;
+exports.OPENCODE_PORT_PROBE_HOSTS = exports.OPENCODE_PORT_RANGE = void 0;
 exports.getOpencodePortFilePath = getOpencodePortFilePath;
 exports.readPersistedOpencodePorts = readPersistedOpencodePorts;
 exports.getAssignedOpencodePort = getAssignedOpencodePort;
@@ -158,21 +158,82 @@ function forgetOpencodePort(target) {
     }
 }
 /**
- * Whether nothing is listening on a port.
+ * The addresses a candidate port is probed on, loopback first (Issue #1900).
  *
- * Binds and immediately closes, which is the only answer that is true at the
- * moment it is given. `EADDRINUSE` — and anything else — reads as "not free".
+ * Loopback alone is not an answer on this platform. Node sets `SO_REUSEADDR` on
+ * every listener, and on macOS/BSD that flag lets a bind to a *specific*
+ * address succeed while another process holds the same port on a *wildcard*
+ * one. Measured on Darwin 25.6.0 with an occupant on `0.0.0.0:45217`:
+ *
+ * ```
+ * bind 127.0.0.1:45217 -> SUCCESS   <- the old probe: "free"
+ * bind 0.0.0.0:45217   -> EADDRINUSE
+ * bind :::45217        -> SUCCESS
+ * ```
+ *
+ * and with an occupant on `[::]:45218`, `0.0.0.0` and `::` both answered
+ * `EADDRINUSE` while loopback again said free. So the old probe called a port
+ * free that an Angular dev server (4200 is its default, and 4200-4299 is this
+ * range) was already serving on — and opencode, binding loopback with the same
+ * flag, would then win `http://localhost:4200` for the rest of the session.
+ * That is not a failed allocation, it is a hijacked one, which is why the
+ * wildcard addresses are probed even though opencode never binds them.
+ *
+ * `::` earns its place beyond `0.0.0.0` for a listener that set `IPV6_V6ONLY`;
+ * a probe on an address family this host does not have is inconclusive rather
+ * than occupied — see {@link probeBind}.
  */
-function isPortFree(port) {
+exports.OPENCODE_PORT_PROBE_HOSTS = [
+    client_1.OPENCODE_SERVER_HOST,
+    '0.0.0.0',
+    '::',
+];
+/** Error codes that mean the port is spoken for, rather than unreachable. */
+const OCCUPIED_BIND_CODES = ['EADDRINUSE', 'EACCES'];
+/**
+ * Bind one address for as long as it takes to learn whether it was free.
+ *
+ * The wildcard probes do expose the port to the network for the microseconds
+ * the socket is open. It carries no `connection` handler and is closed in the
+ * same tick, and there is no way to ask the kernel this question without
+ * asking it — the alternative is the mis-allocation documented above.
+ */
+function probeBind(port, host) {
     return new Promise((resolve) => {
         const server = (0, net_1.createServer)();
-        server.once('error', () => resolve(false));
-        // Bound on the loopback interface — the one opencode itself will bind.
-        server.listen(port, client_1.OPENCODE_SERVER_HOST, () => {
-            server.close(() => resolve(true));
+        server.once('error', (error) => {
+            resolve(OCCUPIED_BIND_CODES.includes(error.code ?? '') ? 'in-use' : 'unavailable');
+        });
+        server.listen(port, host, () => {
+            server.close(() => resolve('free'));
         });
     });
 }
+/**
+ * Whether nothing is listening on a port.
+ *
+ * Binds and immediately closes, which is the only answer that is true at the
+ * moment it is given — on every address in {@link OPENCODE_PORT_PROBE_HOSTS},
+ * because loopback alone answers the wrong question here (Issue #1900).
+ *
+ * The loopback probe is the strict one: anything other than a clean bind reads
+ * as "not free", which is the pre-#1900 behaviour and the conservative answer
+ * for the address opencode will actually take. The wildcard probes only ever
+ * *veto*, and only on a code that names an occupant — a host without IPv6 must
+ * not make every port in the range look taken.
+ */
+async function isPortFree(port) {
+    for (const [index, host] of exports.OPENCODE_PORT_PROBE_HOSTS.entries()) {
+        const probe = await probeBind(port, host);
+        if (probe === 'free')
+            continue;
+        if (index === 0 || probe === 'in-use') {
+            logger.debug('opencode-port-probe-occupied', { port, host, probe });
+            return false;
+        }
+    }
+    return true;
+}
 /**
  * Where a given instance starts scanning.
  *

package/dist/server/src/lib/hooks/sources/opencode/runtime.js

@@ -27,6 +27,7 @@
  * @module lib/hooks/sources/opencode/runtime
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_ATTACH_HEALTH_DELAYS_MS = void 0;
 exports.opencodeTarget = opencodeTarget;
 exports.reserveOpencodeServerPort = reserveOpencodeServerPort;
 exports.attachOpencodeEventStream = attachOpencodeEventStream;
@@ -65,15 +66,71 @@ async function reserveOpencodeServerPort(target, worktreePath) {
         return null;
     }
 }
+/**
+ * How long to keep asking `/global/health` before giving up on the attach.
+ *
+ * Delays *before* each attempt, so the first costs nothing: five probes over
+ * 7.5 s. Issue #1900 item 4 — the check used to be one shot, and one shot is a
+ * decision that lasts the whole session, because nothing re-attaches a pane
+ * that is already running. #1908 measured that opencode's HTTP server answers
+ * 1.3-1.8 s *before* the composer this call waits for, so the ordinary path
+ * still succeeds on the first probe; the retries are for the pane whose
+ * composer poll timed out (24.1 s launches under load were measured) and which
+ * would otherwise be scraper-only for the rest of its life.
+ *
+ * A short ceiling on purpose: this sits inside the HTTP request that started
+ * the session, and every second here is a second the caller is blocked.
+ */
+exports.OPENCODE_ATTACH_HEALTH_DELAYS_MS = [0, 500, 1_000, 2_000, 4_000];
+/**
+ * Probe until an opencode server answers, or until asking again cannot help.
+ *
+ * A `rejected` outcome ends the loop immediately: something *is* on the port and
+ * it is refusing CommandMate — `OPENCODE_SERVER_PASSWORD` in the pane's
+ * environment makes every request a 401 — and 7.5 s of re-asking would only
+ * delay the fall back to the scraper. It is logged with its status so the cause
+ * is visible rather than collapsed into "not reachable".
+ */
+async function awaitOpencodeHealth(target, port) {
+    for (const [attempt, waitMs] of exports.OPENCODE_ATTACH_HEALTH_DELAYS_MS.entries()) {
+        if (waitMs > 0)
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+        const outcome = await (0, client_1.probeOpencodeHealth)(port);
+        if (outcome.kind === 'healthy') {
+            if (attempt > 0) {
+                logger.info('opencode-server-reachable-after-retry', {
+                    worktreeId: target.worktreeId,
+                    instanceId: target.instanceId ?? target.cliToolId,
+                    port,
+                    attempt,
+                });
+            }
+            return outcome.health;
+        }
+        if (outcome.kind === 'rejected') {
+            logger.warn('opencode-server-refused-commandmate', {
+                worktreeId: target.worktreeId,
+                instanceId: target.instanceId ?? target.cliToolId,
+                port,
+                status: outcome.status,
+                consequence: 'structured events are off for this session; the scraper decides',
+            });
+            return null;
+        }
+    }
+    return null;
+}
 /**
  * Open the event stream for an instance whose pane has just started.
  *
  * Health-checked first, and this is not belt-and-braces: a user running an
  * opencode old enough not to accept `--port` gets a TUI with no server, and
  * subscribing to a port nothing is listening on would spend the rest of the
- * session reconnecting to it. One sub-millisecond probe (#1758 §5.7.2) is the
- * difference between "no structured events, scraper as before" and a reconnect
- * loop that never succeeds.
+ * session reconnecting to it. Probes are sub-millisecond when the port is
+ * closed (#1758 §5.7.2), which is what makes
+ * {@link OPENCODE_ATTACH_HEALTH_DELAYS_MS} affordable: the difference between
+ * "no structured events, scraper as before" and a reconnect loop that never
+ * succeeds is still one probe, it is just no longer *only* one.
  *
  * @returns Whether a stream was opened
  */
@@ -84,12 +141,13 @@ async function attachOpencodeEventStream(target) {
             return false;
         if ((0, subscription_1.isOpencodeSubscribed)(target))
             return true;
-        const health = await (0, client_1.fetchOpencodeHealth)(port);
+        const health = await awaitOpencodeHealth(target, port);
         if (!health) {
             logger.info('opencode-server-not-reachable', {
                 worktreeId: target.worktreeId,
                 instanceId: target.instanceId ?? target.cliToolId,
                 port,
+                attempts: exports.OPENCODE_ATTACH_HEALTH_DELAYS_MS.length,
             });
             return false;
         }