@wjarka/cezarion 0.15.1 → 0.16.0

package/dist/core/opencode-server-runner.js

@@ -1,18 +1,36 @@
+import { opencodeSkillWarning } from './opencode-session-error.js';
+import { summarizeRunnerStderr } from './runner-stderr.js';
+import { finished } from 'node:stream/promises';
+import { setTimeout as delay } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
-import { spawn as nodeSpawn } from 'node:child_process';
 import { parseEffort } from '../contract/index.js';
 import { request as httpRequest } from 'node:http';
 import { InputSubmissions } from './input-submissions.js';
-import { prependSystemPrompt, trackChildExit } from './agent-runner.js';
+import { isSignalTerminationExit, prependSystemPrompt, trackChildExit } from './agent-runner.js';
+import { signalSession, spawnSessionLeader } from './session-process.js';
 import { buildChildEnv } from './agent-env.js';
 import { ciOpenCodeEnv } from '../ci-wait/injection.js';
 import { parseAskRequest } from './ask.js';
-import { AUTO_END_DELAY_MS, DEFAULT_RUN_TIMEOUT_MS } from './runner-runtime.js';
+import { boundOutputDrainAfterExit, AUTO_END_DELAY_MS, DEFAULT_RUN_TIMEOUT_MS } from './runner-runtime.js';
 import { formatModelIdentity, parseModelIdentity } from './model-identity.js';
 import { V1TextCoalescer } from './v1-text-coalescer.js';
 import { createOpencodeUiState, mapOpencodeEvent, opencodeSessionStarted, opencodeTurnStarted, } from './opencode-ui-mapper.js';
 const SERVER_START_TIMEOUT_MS = 30_000;
+/**
+ * Pause before the one retry of a server that exited before listening (#872).
+ * opencode 1.18.33, started within ~2 s of SIGTERM to the previous server on
+ * the same DB, printed `ServeError` and exited; the next start succeeded. The
+ * failing start can die well inside that window, so the pause alone spans it;
+ * it is only ever paid by a start that already failed.
+ */
+export const SERVE_START_RETRY_DELAY_MS = 2_000;
+/** The URL wait saw the process exit before it printed a URL. */
+class ServeExitedBeforeListening extends Error {
+    constructor() {
+        super('opencode serve exited before it started listening');
+    }
+}
 /** Grace between the teardown SIGTERM and the SIGKILL that follows it. */
 export const KILL_GRACE_MS = 4_000;
 /**
@@ -20,8 +38,9 @@ export const KILL_GRACE_MS = 4_000;
  * the opencode TUI talks to) with an SSE event stream. One server per session,
  * bound to the run's `cwd` (worktree), gives OpenCode the same multi-turn shape
  * as the Claude runner: each `sendMessage` posts another prompt to the same
- * session (history is kept server-side), and `session/abort` cancels. The
- * current adapter opens a fresh session with the continuation prompt on Continue.
+ * session (history is kept server-side), and `session/abort` cancels.
+ * Continue and restart recovery GET /session/{id} and prompt that session; a 404
+ * falls back to one fresh session with the full system prompt.
  *
  * Auth = the host's opencode config/logins. The agent runs autonomously
  * (auto-approved permissions); this adapter does not map `spec.allowedTools`.
@@ -32,8 +51,8 @@ export const KILL_GRACE_MS = 4_000;
  * What `opencode serve` receives from each `AgentRunSpec` field (#284). The
  * server auto-approves permissions and this adapter maps no per-tool
  * allowlist, so `allowedTools`/`bashAllowlist` are declared dropped rather than
- * mapped (spec 2026-07-17-permission-modes); every start opens a fresh session,
- * so `sessionId`/`resume` never reach the wire. Held against the recorded HTTP
+ * mapped (spec 2026-07-17-permission-modes). Resume GETs `/session/{id}` and
+ * prompts it; a 404 opens one fresh session. Held against the recorded HTTP
  * requests by the harness parity matrix.
  */
 export const OPENCODE_SPEC_SUPPORT = {
@@ -43,32 +62,36 @@ export const OPENCODE_SPEC_SUPPORT = {
     images: { honored: false, reason: 'the adapter posts text parts only; image blocks are dropped' },
     cwd: { honored: true, via: 'opencode serve spawn cwd; the session is bound to it' },
     allowedTools: { honored: false, reason: 'permissions are auto-approved server-side and no per-tool allowlist is mapped' },
-    restrictNativeDelegation: { honored: true, via: 'POST /session permission rule denying task (D1)' },
+    restrictNativeDelegation: { honored: true, via: 'POST /session permission rule denying task (D1); PATCH /session/{id} permission on resume when the deny is absent — the deny persists on the session once added (a later unrestricted Continue cannot remove it; fails closed)' },
     bashAllowlist: { honored: false, reason: 'no per-tool allowlist is mapped, so no command-prefix restriction either' },
     additionalDirectories: { honored: false, reason: 'the server works from cwd; no extra-root mapping' },
     env: { honored: true, via: 'merged over the child env through buildChildEnv' },
     model: { honored: true, via: 'prompt_async model { providerID, modelID }, split from provider/model' },
     effort: { honored: true, via: 'prompt_async variant, canonical level' },
     timeoutMs: { honored: true, via: 'wall-clock kill switch on the child process' },
-    sessionId: { honored: false, reason: 'every start opens a fresh server session; the id is only reported back on the result' },
-    resume: { honored: false, reason: 'Continue opens a fresh session carrying the continuation prompt' },
+    sessionId: { honored: true, via: 'GET /session/{id} when resume is set; a fresh POST /session mints its own id' },
+    resume: { honored: true, via: 'GET /session/{id} in place of POST /session; 404 falls back to a fresh session' },
+    resumeFallbackSystemPrompt: { honored: true, via: 'opening prependSystemPrompt of a fresh POST /session when GET /session/{id} returns 404 on resume' },
 };
 /** How long an idle session may sit on steered input before it counts as a lost wake. */
 export const OPENCODE_LOST_WAKE_GRACE_MS = 2_000;
 export class OpencodeServerRunner {
     backend = 'opencode';
     specSupport = OPENCODE_SPEC_SUPPORT;
+    systemPromptOnResume = 'in-thread';
     inputDelivery = {
         mode: 'steer', consumption: 'observable',
         via: 'prompt_async while busy; assistant message.updated parentID at consumption',
     };
     bin;
     timeoutMs;
+    serverStartTimeoutMs;
     lastSession = null;
     constructor(opts = {}) {
         this.bin = opts.bin ?? process.env.CEZ_OPENCODE_BIN ?? (process.env.CEZ_DRY_RUN === '1'
             ? fileURLToPath(new URL('../../scripts/mock-opencode-serve.mjs', import.meta.url)) : 'opencode');
         this.timeoutMs = opts.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS;
+        this.serverStartTimeoutMs = opts.serverStartTimeoutMs ?? SERVER_START_TIMEOUT_MS;
     }
     run(spec, onEvent) {
         return this.startSession(spec, onEvent, { autoEndAfterFirstTurn: true }).result;
@@ -77,7 +100,7 @@ export class OpencodeServerRunner {
         this.lastSession?.interrupt();
     }
     startSession(spec, onEvent, opts = {}) {
-        const session = new OpencodeSession(this.bin, this.timeoutMs, spec, onEvent, opts);
+        const session = new OpencodeSession(this.bin, this.timeoutMs, this.serverStartTimeoutMs, spec, onEvent, opts);
         this.lastSession = session;
         return session;
     }
@@ -85,20 +108,27 @@ export class OpencodeServerRunner {
 /** One live `opencode serve` process driving a single session. */
 class OpencodeSession {
     bin;
+    serverStartTimeoutMs;
     spec;
     onEvent;
     opts;
     result;
-    child;
-    /** "Has the server actually terminated?" — never `child.killed`, which only
-     *  reports delivery and would disarm the escalation (#844/#858). */
-    hasExited;
+    /** The live server process. A start retry replaces it (#872), so every
+     *  liveness, pid, signal and stderr read goes through this field. */
+    serve;
+    /** The first start, once the retry spawned for it ALSO exited before
+     *  listening on its own (#872) — the one case that names both attempts. */
+    failedStart;
+    /** The retry's own spawn threw synchronously (EAGAIN, EMFILE…), so no second
+     *  process exists and the first start's exit alone would misname the failure. */
+    retrySpawnError;
+    /** Aborted by teardown; cancels a pending start retry. */
+    startRetry = new AbortController();
     serverOpen = true;
+    exitFailure;
     baseUrl;
     sessionId;
     ready;
-    resolveExit;
-    exited;
     sse = new AbortController();
     toolCalls = [];
     textChunks = [];
@@ -161,42 +191,20 @@ class OpencodeSession {
     /** Bumped by `discardQueuedMessages` so a `prompt()` waiter that captured
      * the previous generation returns instead of posting after idle. */
     queuedPromptGeneration = 0;
+    /** Human `prompt()` waiters in the current generation that have not posted yet (#486). */
+    humanPromptWaiters = 0;
     autoEndTimer;
-    spawnFailed = null;
     timedOut = false;
     openingPromptFailed = false;
-    /** One teardown per session — see `terminate()`. */
-    signalled = false;
-    constructor(bin, timeoutMs, spec, onEvent, opts) {
+    constructor(bin, timeoutMs, serverStartTimeoutMs, spec, onEvent, opts) {
         this.bin = bin;
+        this.serverStartTimeoutMs = serverStartTimeoutMs;
         this.spec = spec;
         this.onEvent = onEvent;
         this.opts = opts;
-        // Random high port; the actual bound URL is read back from stdout.
-        const port = 40000 + Math.floor(Math.random() * 20000);
-        try {
-            this.child = nodeSpawn(bin, ['serve', '--hostname', '127.0.0.1', '--port', String(port)], {
-                cwd: spec.cwd,
-                env: buildChildEnv({ backend: 'opencode', extraEnv: ciOpenCodeEnv(spec) }),
-            });
-        }
-        catch (err) {
-            throw wrapSpawnError(err, bin);
-        }
-        this.hasExited = trackChildExit(this.child);
-        this.child.on('error', (err) => {
-            this.spawnFailed = wrapSpawnError(err, bin);
-        });
-        this.exited = new Promise((resolve) => {
-            this.resolveExit = resolve;
-        });
-        this.child.once('exit', () => this.resolveExit());
-        this.child.once('close', () => this.resolveExit());
-        const stderrChunks = [];
-        this.child.stderr.setEncoding('utf8');
-        this.child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+        this.serve = this.spawnServe();
         // The server prints its URL on stdout once listening.
-        const urlReady = this.waitForServerUrl(port);
+        const urlReady = this.startServer();
         const limitMs = spec.timeoutMs ?? timeoutMs;
         let deadline;
         if (limitMs > 0) {
@@ -214,12 +222,12 @@ class OpencodeSession {
             try {
                 await this.ready;
                 // Live for the whole session; the SSE loop runs until end()/interrupt.
-                await this.exited;
+                await this.serve.exited;
             }
             catch (err) {
                 if (!this.timedOut && !this.openingPromptFailed) {
                     const message = err instanceof Error ? err.message : String(err);
-                    this.emit({ type: 'error', message: `opencode: ${message}` });
+                    this.exitFailure = `opencode: ${message}`;
                 }
             }
             finally {
@@ -232,9 +240,49 @@ class OpencodeSession {
                 this.agentRequest?.abort();
                 this.terminate();
             }
-            await this.exited;
-            if (this.spawnFailed)
-                throw this.spawnFailed;
+            const serve = this.serve;
+            await serve.exited;
+            await serve.outputDrained;
+            if (serve.spawnFailed) {
+                this.emit({ type: 'error', message: serve.spawnFailed.message });
+                throw serve.spawnFailed;
+            }
+            // SSE closure can precede the process exit event. Choose one authoritative
+            // error after settlement, before the synthetic turn-end, retaining the code.
+            const code = serve.child.exitCode;
+            const crashed = code !== null && code !== 0 && !(serve.signalled && isSignalTerminationExit(code));
+            if (!this.timedOut && (crashed || this.exitFailure)) {
+                const stderr = serve.stderrChunks.join('');
+                const detail = summarizeRunnerStderr(stderr);
+                if (this.retrySpawnError) {
+                    if (stderr.trim())
+                        this.emit({ type: 'note', message: `opencode serve stderr:\n${stderr}` });
+                    this.emit({
+                        type: 'error',
+                        message: `opencode serve exited before listening (${describeEarlyExit(serve)}) and its retry could not start: ${this.retrySpawnError.message}`,
+                    });
+                }
+                else if (this.failedStart) {
+                    // #872: the retry failed too — one error naming both attempts.
+                    const attempts = [this.failedStart, serve];
+                    const notes = attempts.map((attempt, i) => {
+                        const text = attempt.stderrChunks.join('');
+                        return text.trim() ? `opencode serve stderr (attempt ${i + 1}):\n${text}` : '';
+                    }).filter(Boolean);
+                    if (notes.length)
+                        this.emit({ type: 'note', message: notes.join('\n') });
+                    const described = attempts.map((attempt, i) => `attempt ${i + 1}: ${describeEarlyExit(attempt)}`);
+                    this.emit({ type: 'error', message: `opencode serve exited before listening on both attempts — ${described.join('; ')}` });
+                }
+                else {
+                    if (stderr.trim())
+                        this.emit({ type: 'note', message: `opencode serve stderr:\n${stderr}` });
+                    const message = crashed
+                        ? `opencode serve exited with code ${code}${detail ? ` — ${detail}` : ''}`
+                        : this.exitFailure;
+                    this.emit({ type: 'error', message });
+                }
+            }
             // Timeout/interrupt can cut the SSE feed before its `session.idle` —
             // close the turn (idempotent) so consumers still see the v1 boundary,
             // and recover prose buffered mid-part.
@@ -261,7 +309,7 @@ class OpencodeSession {
         return this.serverOpen;
     }
     get pid() {
-        return this.child.pid;
+        return this.serve.child.pid;
     }
     sendAgentMessage(content, inputIds = []) {
         // #505: a busy session is steered with prompt_async; only a pending native question,
@@ -333,6 +381,13 @@ class OpencodeSession {
     discardQueuedMessages() {
         this.queuedPromptGeneration += 1;
         this.queuedQuestionMessages.length = 0;
+        this.humanPromptWaiters = 0; // #486: must read false immediately, not when waiters resume
+    }
+    holdsHumanInput() {
+        return this.humanPromptWaiters > 0 || this.queuedQuestionMessages.length > 0;
+    }
+    heldHumanInputCount() {
+        return this.humanPromptWaiters + this.queuedQuestionMessages.length;
     }
     deliverPrompt(text) {
         this.pendingPromptRequests += 1;
@@ -399,35 +454,136 @@ class OpencodeSession {
      * server it was written for: one that installs its own SIGTERM handler stayed
      * alive with `killed = true` and `exitCode === null`, outliving the whole
      * window (#858, the same defect #844 fixed for the other two backends). Every
-     * caller here is followed by `await this.exited`, so a server that survived
+     * caller here is followed by `await serve.exited`, so a server that survived
      * SIGTERM did not just leak — it hung the session's result forever.
      *
      * One teardown per session: all three call sites can run for the same session
      * (`interrupt()` on the deadline, then the result promise's `finally`), and
      * once SIGTERM is out with SIGKILL armed there is nothing a second pass adds.
      * The old `!child.killed` test deduplicated this as a side effect of being
-     * wrong; `signalled` keeps that property on purpose.
+     * wrong; `signalled` keeps that property on purpose. It lives on the process,
+     * not the session: only the live one is ever signalled, and a start retry
+     * (#872) replaces it only after the first exited unsignalled.
+     *
+     * Teardown also cancels a pending start retry, so no second server spawns
+     * after `end()`, `interrupt()` or the deadline.
      */
     terminate() {
-        if (this.signalled || this.hasExited())
+        this.startRetry.abort();
+        const serve = this.serve;
+        if (serve.signalled || serve.hasExited())
             return;
-        this.signalled = true;
-        this.child.kill('SIGTERM');
+        serve.signalled = true;
+        signalSession(serve.child, 'SIGTERM');
         setTimeout(() => {
-            if (this.hasExited())
+            if (serve.hasExited())
                 return;
-            this.child.kill('SIGKILL');
+            signalSession(serve.child, 'SIGKILL');
         }, KILL_GRACE_MS).unref?.();
     }
     // ---- server lifecycle ---------------------------------------------------
-    waitForServerUrl(fallbackPort) {
+    /** Spawn one `opencode serve` on a random high port and wire its lifecycle.
+     *  A synchronous spawn throw is wrapped; an async spawn error is latched on
+     *  the process record. */
+    spawnServe() {
+        // Random high port; the actual bound URL is read back from stdout.
+        const port = 40000 + Math.floor(Math.random() * 20000);
+        let child;
+        try {
+            child = spawnSessionLeader(this.bin, ['serve', '--hostname', '127.0.0.1', '--port', String(port)], {
+                cwd: this.spec.cwd,
+                env: buildChildEnv({ backend: 'opencode', extraEnv: ciOpenCodeEnv(this.spec) }),
+            });
+        }
+        catch (err) {
+            throw wrapSpawnError(err, this.bin);
+        }
+        const hasExited = trackChildExit(child);
+        boundOutputDrainAfterExit(child);
+        // `exit` settles process liveness, not its pipes. The shared 250ms drain
+        // bound prevents an inherited descendant pipe from retaining this session.
+        const outputDrained = Promise.all([child.stdout, child.stderr].map(stream => finished(stream, { cleanup: true }).catch(() => undefined)));
+        const exited = new Promise((resolve) => {
+            child.once('exit', () => resolve());
+            child.once('close', () => resolve());
+        });
+        const serve = {
+            child, hasExited, exited, outputDrained, port,
+            stderrChunks: [], spawnFailed: null, signalled: false,
+        };
+        child.on('error', (err) => {
+            serve.spawnFailed = wrapSpawnError(err, this.bin);
+        });
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => serve.stderrChunks.push(chunk));
+        return serve;
+    }
+    /**
+     * Wait for the server URL, retrying once — after `SERVE_START_RETRY_DELAY_MS`,
+     * on a fresh port — when the process exited before it printed one (#872).
+     * Never retried: a spawn error (the process never ran), the no-URL timeout
+     * (it falls back to the requested port), and a session already torn down.
+     */
+    async startServer() {
+        try {
+            return await this.waitForServerUrl(this.serve);
+        }
+        catch (err) {
+            const first = this.serve;
+            if (!(err instanceof ServeExitedBeforeListening))
+                throw err;
+            // Settle the process first: an ENOENT `error` and late stderr both land
+            // around `exit`, and the retry decision and its note need them.
+            await first.exited;
+            await first.outputDrained;
+            if (first.spawnFailed || first.child.pid === undefined || !this.serverOpen || this.timedOut)
+                throw err;
+            const detail = summarizeRunnerStderr(first.stderrChunks.join(''));
+            this.emit({
+                type: 'note',
+                message: `opencode serve exited before listening (${describeExit(first)}); retrying once${detail ? ` — ${detail}` : ''}`,
+            });
+            try {
+                await delay(SERVE_START_RETRY_DELAY_MS, undefined, { signal: this.startRetry.signal });
+            }
+            catch {
+                // Torn down during the pause: report the first start's failure as before.
+                throw err;
+            }
+            if (this.startRetry.signal.aborted || !this.serverOpen || this.timedOut)
+                throw err;
+            let next;
+            try {
+                next = this.spawnServe();
+            }
+            catch (spawnErr) {
+                this.retrySpawnError = spawnErr instanceof Error ? spawnErr : new Error(String(spawnErr));
+                throw spawnErr;
+            }
+            this.serve = next;
+            if (next.child.pid !== undefined)
+                this.opts.onPidChange?.(next.child.pid);
+            try {
+                return await this.waitForServerUrl(next);
+            }
+            catch (retryErr) {
+                // Only an unprompted second early exit names both attempts; a retry
+                // torn down by the session reports through the ordinary paths.
+                if (retryErr instanceof ServeExitedBeforeListening && !next.signalled)
+                    this.failedStart = first;
+                throw retryErr;
+            }
+        }
+    }
+    waitForServerUrl(serve) {
+        const { child } = serve;
         return new Promise((resolve, reject) => {
             let buffer = '';
             const timer = setTimeout(() => {
                 cleanup();
                 // Nothing parsed — try the port we asked for.
-                resolve(`http://127.0.0.1:${fallbackPort}`);
-            }, SERVER_START_TIMEOUT_MS);
+                resolve(`http://127.0.0.1:${serve.port}`);
+            }, this.serverStartTimeoutMs);
             timer.unref?.();
             const onData = (chunk) => {
                 buffer += chunk;
@@ -439,36 +595,92 @@ class OpencodeSession {
             };
             const onExit = () => {
                 cleanup();
-                reject(new Error('opencode serve exited before it started listening'));
+                reject(new ServeExitedBeforeListening());
             };
             const cleanup = () => {
                 clearTimeout(timer);
-                this.child.stdout.off('data', onData);
-                this.child.off('exit', onExit);
+                child.stdout.off('data', onData);
+                child.off('exit', onExit);
             };
-            this.child.stdout.setEncoding('utf8');
-            this.child.stdout.on('data', onData);
-            this.child.once('exit', onExit);
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', onData);
+            child.once('exit', onExit);
         });
     }
+    nativeDelegationPermission() {
+        return { permission: [{ permission: 'task', pattern: '*', action: 'deny' }] };
+    }
+    /** 404 → `'missing'`. Any other non-OK status fails bootstrap (no fallback). */
+    async tryGetSession(id) {
+        if (!this.baseUrl)
+            throw new Error('opencode server not ready');
+        const res = await fetch(`${this.baseUrl}/session/${encodeURIComponent(id)}`, { method: 'GET' });
+        if (res.status === 404)
+            return 'missing';
+        if (!res.ok) {
+            const detail = await res.text().catch(() => '');
+            throw new Error(`GET /session/${id} → ${res.status} ${detail.slice(0, 200)}`);
+        }
+        const text = await res.text();
+        if (!text)
+            return { id };
+        try {
+            const parsed = JSON.parse(text);
+            return isRecord(parsed) ? parsed : { id };
+        }
+        catch {
+            return { id };
+        }
+    }
+    async attachSession(id, applyDelegationRule) {
+        this.sessionId = id;
+        this.emit({ type: 'session', sessionId: id });
+        this.emitUi((state) => opencodeSessionStarted(id, state));
+        if (applyDelegationRule) {
+            await this.http('PATCH', `/session/${encodeURIComponent(id)}`, this.nativeDelegationPermission());
+        }
+    }
     async bootstrap() {
-        const created = await this.http('POST', '/session', {
-            title: 'cezar task',
-            // OpenCode 1.18.29 /doc: session.create permission rules. The native task
-            // tool checks this permission; other agent/project permissions stay intact.
-            ...(this.spec.restrictNativeDelegation ? { permission: [{ permission: 'task', pattern: '*', action: 'deny' }] } : {}),
-        });
-        this.sessionId = stringField(created, 'id');
-        if (!this.sessionId)
-            throw new Error('opencode did not return a session id');
-        this.emit({ type: 'session', sessionId: this.sessionId });
-        const sessionId = this.sessionId;
-        this.emitUi((state) => opencodeSessionStarted(sessionId, state));
+        const requested = this.spec.resume ? this.spec.sessionId : undefined;
+        let resumed = false;
+        if (requested) {
+            const existing = await this.tryGetSession(requested);
+            if (existing === 'missing') {
+                this.emit({
+                    type: 'note',
+                    message: `OpenCode session ${requested} no longer exists; the continuation runs in a fresh session without the earlier conversation.`,
+                });
+            }
+            else {
+                const applyDelegationRule = Boolean(this.spec.restrictNativeDelegation)
+                    && !hasNativeDelegationDeny(existing.permission);
+                await this.attachSession(stringField(existing, 'id') ?? requested, applyDelegationRule);
+                resumed = true;
+            }
+        }
+        if (!resumed) {
+            const created = await this.http('POST', '/session', {
+                title: 'cezar task',
+                // OpenCode 1.18.33 /doc: session.create permission rules. The native task
+                // tool checks this permission; other agent/project permissions stay intact.
+                ...(this.spec.restrictNativeDelegation ? this.nativeDelegationPermission() : {}),
+            });
+            const sessionId = stringField(created, 'id');
+            if (!sessionId)
+                throw new Error('opencode did not return a session id');
+            await this.attachSession(sessionId, false);
+        }
         // The SSE subscription must be LIVE before the first prompt posts —
         // events the server emits while the POST is in flight would otherwise be
         // lost (a race this await closes; the bundled mock made it visible).
         await this.consumeEvents();
-        const first = prependSystemPrompt(this.spec.systemPrompt, this.spec.userPrompt);
+        // Lost-session fallback uses the full skill-inclusive prompt Continue
+        // stashed in resumeFallbackSystemPrompt; a true resume re-prepends only
+        // extra+handoff (the skill already lives in the thread).
+        const systemPrompt = !resumed && requested
+            ? (this.spec.resumeFallbackSystemPrompt ?? this.spec.systemPrompt)
+            : this.spec.systemPrompt;
+        const first = prependSystemPrompt(systemPrompt, this.spec.userPrompt);
         await this.prompt(first, 'opening');
         if (this.refusedBeforeOpening)
             queueMicrotask(() => {
@@ -485,8 +697,14 @@ class OpencodeSession {
         // resume in FIFO order; a teardown (`finishTurn` runs on every exit
         // path) releases them into the `serverOpen` check below.
         const generation = this.queuedPromptGeneration;
+        const humanWaiter = origin === 'human';
+        if (humanWaiter)
+            this.humanPromptWaiters += 1;
         while (this.turnActive)
             await this.turnFinished;
+        if (humanWaiter && generation === this.queuedPromptGeneration) {
+            this.humanPromptWaiters = Math.max(0, this.humanPromptWaiters - 1);
+        }
         if (generation !== this.queuedPromptGeneration)
             return;
         // A queued prompt may have started waiting before the preceding idle armed
@@ -524,21 +742,21 @@ class OpencodeSession {
                     this.interrupt();
                 }
             }
+            else if (origin === 'opening') {
+                this.emit({ type: 'note', message: `opencode: prompt failed: ${message}` });
+                // A dropped ACK can be the first sign of a process crash. Retain HTTP
+                // rejection details, but let settlement choose one error before turn-end.
+                this.openingPromptFailed = true;
+                this.exitFailure = `opencode: ${message}`;
+                this.interrupt();
+            }
             else {
                 this.emit({ type: 'note', message: `opencode: prompt failed: ${message}` });
-                if (origin === 'opening') {
-                    // Opening failure was always fatal. Report it before the synthetic
-                    // boundary, and do not emit it again from the bootstrap result catch.
-                    this.openingPromptFailed = true;
-                    if (!this.timedOut)
-                        this.emit({ type: 'error', message: `opencode: ${message}` });
-                    this.interrupt();
-                }
             }
-            if (!this.providerErrorPending)
+            if (!this.providerErrorPending && origin !== 'opening')
                 this.finishTurn();
-            // Bootstrap still rejects; its result catch suppresses the already
-            // reported opening error. Human follow-ups keep their nonfatal note.
+            // Bootstrap still rejects; its result path reports the latched opening
+            // failure. Human follow-ups keep their nonfatal note and turn boundary.
             throw err;
         }
     }
@@ -701,10 +919,9 @@ class OpencodeSession {
             // note: the turn's remaining output is lost, so the step must record a
             // failure (run.ts classifies from v1 `error` only), never pass as an
             // empty success. Then close the turn (flushing what did arrive) and end
-            // the session; "Continue" resumes it on a fresh server.
+            // the session; "Continue" GETs this session id on the next server.
             if (this.serverOpen && !this.sse.signal.aborted) {
-                this.emit({ type: 'error', message: 'opencode: event stream closed unexpectedly' });
-                this.finishTurn();
+                this.exitFailure = 'opencode: event stream closed unexpectedly';
                 this.end();
             }
         }
@@ -725,7 +942,7 @@ class OpencodeSession {
         }
         this.emitUi((state) => mapOpencodeEvent(evt, state));
         const sid = stringField(evt.properties ?? {}, 'sessionID');
-        if (evt.type === 'session.error' && (sid === undefined || sid === this.sessionId) && this.agentRequest) {
+        if (evt.type === 'session.error' && !opencodeSkillWarning(evt.properties ?? {}) && (sid === undefined || sid === this.sessionId) && this.agentRequest) {
             // HTTP and SSE are independent sockets: the error can overtake a positive
             // prompt ACK. Let that exact request settle before v1 makes RunManager
             // interrupt it. Keep later SSE idle frames behind the same barrier.
@@ -799,7 +1016,12 @@ class OpencodeSession {
                 this.finishTurn();
         }
         else if (type === 'session.error') {
-            // The wire's only failure signal, now that the prompt POST returns
+            const warning = opencodeSkillWarning(props);
+            if (warning) {
+                this.emit({ type: 'note', message: warning });
+                return;
+            }
+            // The wire's failure signal, now that the prompt POST returns
             // before the turn runs: forward it to v1, whose `error` events are what
             // run.ts records failed steps from — dropped, the terminal idle would
             // file a provider/auth failure as a successful step. The idle that
@@ -1125,6 +1347,15 @@ function clippedString(value, max) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/** OpenCode 1.18.33 PATCHes permission by append (no replace, no dedupe). */
+function hasNativeDelegationDeny(permission) {
+    if (!Array.isArray(permission))
+        return false;
+    return permission.some((rule) => isRecord(rule)
+        && rule.permission === 'task'
+        && rule.pattern === '*'
+        && rule.action === 'deny');
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1183,6 +1414,16 @@ function safeStringify(value) {
         return String(value);
     }
 }
+/** `code N` or `signal S` for a server process that exited. */
+function describeExit(serve) {
+    const { exitCode, signalCode } = serve.child;
+    return exitCode !== null ? `code ${exitCode}` : `signal ${signalCode}`;
+}
+/** `code N — <stderr summary>` for one start that exited before listening. */
+function describeEarlyExit(serve) {
+    const detail = summarizeRunnerStderr(serve.stderrChunks.join(''));
+    return `${describeExit(serve)}${detail ? ` — ${detail}` : ''}`;
+}
 function wrapSpawnError(err, bin) {
     const code = err?.code;
     if (code === 'ENOENT') {