borgmcp 4.3.0 → 4.5.0

package/dist/opencode-drone.js

@@ -1,17 +1,114 @@
-import { appendFileSync, existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'fs';
-import { createHash } from 'crypto';
+import { closeSync, constants, existsSync, fchmodSync, fstatSync, openSync, readFileSync, readSync, renameSync, unlinkSync, writeFileSync, writeSync, } from 'fs';
+import { createHash, randomUUID } from 'crypto';
 import { createServer } from 'node:net';
 import { join } from 'path';
 import { tmpdir } from 'os';
+import { borgConfigRoot, ensurePrivateBorgConfigRoot, ensurePrivateBorgConfigRootSync, } from './private-root.js';
 import { OPENCODE_INJECTED_ENTRY_METADATA_KEY, OPENCODE_WAKE_IDENTITY_METADATA_KEY, OPENCODE_LAUNCH_CORRELATION_METADATA_KEY, } from './opencode-plugin.js';
 import { createOpenCodeLaunchTrust, isOpenCode256BitIdentity, OPENCODE_SERVER_USERNAME, } from './opencode-launch-trust.js';
-const LOG_FILE = join(tmpdir(), 'borg-opencode-drone.log');
-function log(msg) {
+import { OpenCodeAuthenticationError, OpenCodeHttpError, OpenCodeResponseError, OpenCodeUnreachableError, } from './server-errors.js';
+const OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES = 64 * 1024;
+const diagnosticLogPathsForTests = new Set();
+function stateIdentityDigest(current) {
+    const key = [current.serverUrl, current.directory, current.cubeName, current.droneLabel].join('\0');
+    return createHash('sha256').update(key).digest('hex').slice(0, 24);
+}
+export function openCodeStartupDiagnosticLogPath() {
+    return join(borgConfigRoot(), 'opencode-drone-startup.log');
+}
+function diagnosticLogPath(owner) {
+    const root = borgConfigRoot();
+    const path = owner
+        ? join(root, `opencode-drone-${stateIdentityDigest(owner)}.log`)
+        : openCodeStartupDiagnosticLogPath();
+    diagnosticLogPathsForTests.add(path);
+    return path;
+}
+function log(msg, owner = state, throwOnFailure = false) {
     const line = `[${new Date().toISOString()}] ${msg}\n`;
+    let descriptor = null;
+    let temporaryDescriptor = null;
+    let temporary = null;
     try {
-        appendFileSync(LOG_FILE, line);
+        ensurePrivateBorgConfigRootSync(borgConfigRoot());
+        const path = diagnosticLogPath(owner);
+        // The private root is the primary boundary. Where available, no-follow also
+        // closes the final replacement gap between root verification and this open.
+        const noFollow = constants.O_NOFOLLOW ?? 0;
+        descriptor = openSync(path, constants.O_RDWR |
+            constants.O_APPEND |
+            constants.O_CREAT |
+            noFollow, 0o600);
+        if (!fstatSync(descriptor).isFile()) {
+            throw Object.assign(new Error('OpenCode diagnostic log is not a regular file'), { code: 'EINVAL' });
+        }
+        fchmodSync(descriptor, 0o600);
+        writeSync(descriptor, line, null, 'utf8');
+        const size = fstatSync(descriptor).size;
+        if (size <= OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES)
+            return;
+        const tail = Buffer.allocUnsafe(OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES);
+        let bytesRead = 0;
+        while (bytesRead < tail.length) {
+            const count = readSync(descriptor, tail, bytesRead, tail.length - bytesRead, size - tail.length + bytesRead);
+            if (count === 0)
+                break;
+            bytesRead += count;
+        }
+        const completeTail = tail.subarray(0, bytesRead);
+        const firstNewline = completeTail.indexOf(0x0a);
+        const bounded = firstNewline >= 0 ? completeTail.subarray(firstNewline + 1) : completeTail;
+        temporary = `${path}.${randomUUID()}.tmp`;
+        temporaryDescriptor = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow, 0o600);
+        if (!fstatSync(temporaryDescriptor).isFile()) {
+            throw Object.assign(new Error('OpenCode diagnostic temporary is not a regular file'), { code: 'EINVAL' });
+        }
+        fchmodSync(temporaryDescriptor, 0o600);
+        let bytesWritten = 0;
+        while (bytesWritten < bounded.length) {
+            const count = writeSync(temporaryDescriptor, bounded, bytesWritten, bounded.length - bytesWritten);
+            if (count === 0)
+                throw Object.assign(new Error('OpenCode diagnostic temporary write stalled'), { code: 'EIO' });
+            bytesWritten += count;
+        }
+        closeSync(temporaryDescriptor);
+        temporaryDescriptor = null;
+        closeSync(descriptor);
+        descriptor = null;
+        renameSync(temporary, path);
+        temporary = null;
+    }
+    catch (error) {
+        const code = error?.code ?? 'unknown';
+        process.stderr.write(`OpenCode diagnostic log write failed (${code})\n`);
+        if (throwOnFailure)
+            throw error;
+    }
+    finally {
+        if (temporaryDescriptor !== null) {
+            try {
+                closeSync(temporaryDescriptor);
+            }
+            catch { /* The primary write error is already reported. */ }
+        }
+        if (descriptor !== null) {
+            try {
+                closeSync(descriptor);
+            }
+            catch { /* The primary write error is already reported. */ }
+        }
+        if (temporary !== null) {
+            try {
+                unlinkSync(temporary);
+            }
+            catch {
+                // Already absent or inaccessible; the randomized name cannot be reused.
+            }
+        }
     }
-    catch { }
+}
+export function writeOpenCodeStartupDiagnostic(message) {
+    log(message, null, true);
 }
 let state = null;
 const OPEN_CODE_DELIVERY_RETRY_DELAYS_MS = [0, 250, 1_000, 3_000];
@@ -46,8 +143,9 @@ function abandonOpenCodeDeliveries(current) {
 }
 export async function connectOpenCodeDrone(deps) {
     if (!isOpenCode256BitIdentity(deps.apiPassword)) {
-        throw new Error('OpenCode API password is missing or unverifiable');
+        throw new OpenCodeAuthenticationError('OpenCode API password is missing or unverifiable');
     }
+    await ensurePrivateBorgConfigRoot(borgConfigRoot());
     abandonOpenCodeDeliveries(state);
     state = {
         serverUrl: deps.serverUrl,
@@ -69,8 +167,18 @@ export async function connectOpenCodeDrone(deps) {
         pendingSubmissions: new Map(),
         reconcilingEntryIds: new Set(),
         processingDeliveries: false,
+        nextObservationSequence: 0,
+        lastObservation: {
+            injectionSequence: 0,
+            acceptedSequence: 0,
+            failureSequence: 0,
+            lastInjectionAt: null,
+            lastInjectionResult: null,
+            lastAcceptedEntryId: null,
+            lastFailureCode: null,
+        },
     };
-    log(`connected url=${deps.serverUrl} dir=${deps.directory}`);
+    log(`connected url=${deps.serverUrl} dir=${deps.directory}`, state);
 }
 // ---------------------------------------------------------------------------
 // Raw fetch wrappers
@@ -82,7 +190,7 @@ function apiUrl(path) {
 function authenticatedHeaders(headers = {}) {
     const password = state?.apiPassword;
     if (!isOpenCode256BitIdentity(password)) {
-        throw new Error('OpenCode API password is missing or unverifiable');
+        throw new OpenCodeAuthenticationError('OpenCode API password is missing or unverifiable');
     }
     return {
         ...headers,
@@ -99,6 +207,11 @@ async function rawGet(path) {
         const body = await res.text();
         return { status: res.status, body };
     }
+    catch (error) {
+        if (error instanceof OpenCodeAuthenticationError)
+            throw error;
+        throw new OpenCodeUnreachableError(controller.signal.aborted ? 'timeout' : 'transient', controller.signal.aborted ? 'OpenCode request timed out' : 'OpenCode request failed', { cause: error });
+    }
     finally {
         clearTimeout(timer);
     }
@@ -117,29 +230,100 @@ async function rawPost(path, bodyObj) {
         const body = await res.text();
         return { status: res.status, body };
     }
+    catch (error) {
+        if (error instanceof OpenCodeAuthenticationError)
+            throw error;
+        throw new OpenCodeUnreachableError(controller.signal.aborted ? 'timeout' : 'transient', controller.signal.aborted ? 'OpenCode request timed out' : 'OpenCode request failed', { cause: error });
+    }
     finally {
         clearTimeout(timer);
     }
 }
+function openCodeHttpError(status, operation) {
+    const code = status === 401
+        ? 'unauthorized'
+        : status === 404
+            ? 'not-found'
+            : status >= 500 || status === 429
+                ? 'transient'
+                : 'incompatible-api';
+    return new OpenCodeHttpError(status, code, `OpenCode ${operation} request failed (${status})`);
+}
+function parseOpenCodeJson(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch (error) {
+        throw new OpenCodeResponseError('OpenCode returned malformed JSON', { cause: error });
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function decodeSession(value) {
+    if (!isRecord(value)
+        || typeof value.id !== 'string'
+        || value.id.length === 0
+        || typeof value.directory !== 'string'
+        || !isRecord(value.time)
+        || typeof value.time.created !== 'number'
+        || !Number.isFinite(value.time.created)
+        || (value.parentID !== undefined && typeof value.parentID !== 'string')
+        || (value.agent !== undefined && typeof value.agent !== 'string')
+        || (value.model !== undefined && (!isRecord(value.model)
+            || typeof value.model.providerID !== 'string'
+            || typeof value.model.modelID !== 'string'))) {
+        throw new OpenCodeResponseError();
+    }
+    return value;
+}
+function decodeSessions(body) {
+    const value = parseOpenCodeJson(body);
+    if (!Array.isArray(value))
+        throw new OpenCodeResponseError();
+    return value.map(decodeSession);
+}
+function decodeMessages(body) {
+    const value = parseOpenCodeJson(body);
+    if (!Array.isArray(value))
+        throw new OpenCodeResponseError();
+    return value.map((message) => {
+        if (!isRecord(message))
+            throw new OpenCodeResponseError();
+        if (!isRecord(message.info)
+            || typeof message.info.role !== 'string'
+            || (message.info.id !== undefined && typeof message.info.id !== 'string')
+            || (message.info.time !== undefined && (!isRecord(message.info.time)
+                || (message.info.time.created !== undefined && typeof message.info.time.created !== 'number'))))
+            throw new OpenCodeResponseError();
+        if (!Array.isArray(message.parts)
+            || message.parts.some((part) => !isRecord(part)
+                || (part.type !== undefined && typeof part.type !== 'string')
+                || (part.text !== undefined && typeof part.text !== 'string')
+                || (part.metadata !== undefined && !isRecord(part.metadata))))
+            throw new OpenCodeResponseError();
+        return message;
+    });
+}
 async function listSessions() {
     const { status, body } = await rawGet('/session');
     if (status !== 200)
-        throw new Error(`OpenCode sessions request failed (${status})`);
-    return JSON.parse(body);
+        throw openCodeHttpError(status, 'sessions');
+    return decodeSessions(body);
 }
 async function getSession(id) {
     const { status, body } = await rawGet(`/session/${id}`);
     if (status === 404)
         return null;
     if (status !== 200)
-        throw new Error(`OpenCode session request failed (${status})`);
-    return JSON.parse(body);
+        throw openCodeHttpError(status, 'session');
+    return decodeSession(parseOpenCodeJson(body));
 }
 async function listSessionMessages(id) {
     const { status, body } = await rawGet(`/session/${id}/message`);
     if (status !== 200)
-        throw new Error(`OpenCode session messages request failed (${status})`);
-    return JSON.parse(body);
+        throw openCodeHttpError(status, 'session messages');
+    return decodeMessages(body);
 }
 async function findInjectedMessage(sessionId, expectedWakeIdentity) {
     const messages = await listSessionMessages(sessionId);
@@ -165,9 +349,7 @@ async function promptSession(id, bodyObj) {
 // ---------------------------------------------------------------------------
 function bindingPath() {
     const current = state;
-    const key = [current.serverUrl, current.directory, current.cubeName, current.droneLabel].join('\0');
-    const digest = createHash('sha256').update(key).digest('hex').slice(0, 24);
-    const path = join(tmpdir(), `borg-opencode-session-${digest}.json`);
+    const path = join(tmpdir(), `borg-opencode-session-${stateIdentityDigest(current)}.json`);
     bindingPathsForTests.add(path);
     return path;
 }
@@ -310,25 +492,20 @@ function restoreBinding() {
     return binding;
 }
 function isBoundSession(session, binding) {
-    return session.id === binding.sessionId && session.directory === state.directory;
+    return session.id === binding.sessionId && session.directory === binding.directory;
 }
 function isTopLevelSession(session) {
     return !session.parentID;
 }
-async function findUnseenTopLevelSession(knownRootSessionIds) {
-    try {
-        const sessions = await listSessions();
-        const roots = sessions.filter((session) => session.directory === state.directory
-            && isTopLevelSession(session));
-        const matched = roots.filter((session) => !knownRootSessionIds.includes(session.id));
-        if (matched.length === 0)
-            return null;
-        const best = matched.reduce((a, b) => a.time.created > b.time.created ? a : b);
-        return { session: best, knownRootSessionIds: roots.map((session) => session.id) };
-    }
-    catch {
+async function findUnseenTopLevelSession(knownRootSessionIds, directory) {
+    const sessions = await listSessions();
+    const roots = sessions.filter((session) => session.directory === directory
+        && isTopLevelSession(session));
+    const matched = roots.filter((session) => !knownRootSessionIds.includes(session.id));
+    if (matched.length === 0)
         return null;
-    }
+    const best = matched.reduce((a, b) => a.time.created > b.time.created ? a : b);
+    return { session: best, knownRootSessionIds: roots.map((session) => session.id) };
 }
 function launchCorrelationMatchCount(messages, correlationIdentity) {
     let count = 0;
@@ -351,8 +528,13 @@ function launchCorrelationMatchCount(messages, correlationIdentity) {
  * therefore allowed only when it received this launch's correlation metadata.
  */
 async function findLaunchSession(correlationIdentity) {
+    const owner = state;
+    const observationSequence = ++owner.nextObservationSequence;
     try {
-        const sessions = (await listSessions()).filter((session) => session.directory === state.directory);
+        const listedSessions = await listSessions();
+        if (state !== owner)
+            return null;
+        const sessions = listedSessions.filter((session) => session.directory === owner.directory);
         const knownRootSessionIds = sessions
             .filter(isTopLevelSession)
             .map((session) => session.id);
@@ -360,24 +542,34 @@ async function findLaunchSession(correlationIdentity) {
             session,
             matchCount: launchCorrelationMatchCount(await listSessionMessages(session.id), correlationIdentity),
         })));
+        if (state !== owner)
+            return null;
         const totalMatches = candidates.reduce((total, candidate) => total + candidate.matchCount, 0);
         if (totalMatches !== 1)
             return null;
         const matched = candidates.find((candidate) => candidate.matchCount === 1);
         return matched ? { session: matched.session, knownRootSessionIds } : null;
     }
-    catch {
+    catch (error) {
+        if (state === owner)
+            recordOpenCodeFailure(owner, error, observationSequence);
         return null;
     }
 }
-async function resolveInjectionSession() {
+async function resolveInjectionSession(owner, observationSequence) {
+    if (state !== owner)
+        return null;
     const binding = restoreBinding();
     if (!binding)
         return null;
     const bound = await getSession(binding.sessionId);
+    if (state !== owner)
+        return null;
     if (!bound || !isBoundSession(bound, binding)) {
         clearBinding();
-        const replacement = await findUnseenTopLevelSession(binding.knownRootSessionIds);
+        const replacement = await findUnseenTopLevelSession(binding.knownRootSessionIds, owner.directory);
+        if (state !== owner)
+            return null;
         if (!replacement)
             return null;
         saveBinding(replacement.session, replacement.knownRootSessionIds);
@@ -386,7 +578,15 @@ async function resolveInjectionSession() {
     // `/new` creates an unseen top-level session. Keep the launch-time root
     // snapshot so an old, unrelated root is never mistaken for a user switch.
     // Children never supersede the bound root.
-    const switched = await findUnseenTopLevelSession(binding.knownRootSessionIds);
+    let switched = null;
+    try {
+        switched = await findUnseenTopLevelSession(binding.knownRootSessionIds, owner.directory);
+    }
+    catch (error) {
+        recordOpenCodeFailure(owner, error, observationSequence);
+    }
+    if (state !== owner)
+        return null;
     if (switched) {
         saveBinding(switched.session, switched.knownRootSessionIds);
         return switched.session;
@@ -403,6 +603,50 @@ function rememberBounded(entries, entryId, text, sourceEntryId) {
         entries.delete(oldest);
     }
 }
+function openCodeFailureCode(error) {
+    const code = error?.code;
+    if (typeof code === 'string' && code.length > 0)
+        return code;
+    return error instanceof Error && error.name ? error.name : 'unknown';
+}
+function updateLastOpenCodeObservation(owner, sequence, update) {
+    // Attempts, acceptances, and failures resolve independently; an observation
+    // may be stale for one field without being stale for the others.
+    const current = owner.lastObservation;
+    const updatesInjection = 'lastInjectionAt' in update || 'lastInjectionResult' in update;
+    const updatesAccepted = 'lastAcceptedEntryId' in update;
+    const updatesFailure = 'lastFailureCode' in update;
+    owner.lastObservation = {
+        ...current,
+        ...(updatesInjection && sequence >= current.injectionSequence
+            ? {
+                injectionSequence: sequence,
+                ...('lastInjectionAt' in update
+                    ? { lastInjectionAt: update.lastInjectionAt }
+                    : {}),
+                ...('lastInjectionResult' in update
+                    ? { lastInjectionResult: update.lastInjectionResult }
+                    : {}),
+            }
+            : {}),
+        ...(updatesAccepted && sequence >= current.acceptedSequence
+            ? { acceptedSequence: sequence, lastAcceptedEntryId: update.lastAcceptedEntryId }
+            : {}),
+        ...(updatesFailure && sequence >= current.failureSequence
+            ? { failureSequence: sequence, lastFailureCode: update.lastFailureCode }
+            : {}),
+    };
+}
+function recordOpenCodeFailure(owner, error, observationSequence) {
+    updateLastOpenCodeObservation(owner, observationSequence, {
+        lastFailureCode: openCodeFailureCode(error),
+    });
+}
+function recordOpenCodeAcceptance(owner, delivery) {
+    updateLastOpenCodeObservation(owner, delivery.sequence, {
+        lastAcceptedEntryId: delivery.entryId,
+    });
+}
 function clearPendingSubmission(owner, entryId) {
     if (!owner.pendingSubmissions.delete(entryId))
         return;
@@ -418,6 +662,11 @@ function confirmOpenCodeDelivery(owner, delivery) {
     clearPendingSubmission(owner, delivery.entryId);
     rememberBounded(owner.deliveredEntries, delivery.entryId, delivery.text, delivery.sourceEntryId);
     owner.totalEntriesInjected++;
+    updateLastOpenCodeObservation(owner, delivery.sequence, {
+        lastAcceptedEntryId: delivery.entryId,
+        lastInjectionResult: 'delivered',
+        lastFailureCode: null,
+    });
 }
 function scheduleOpenCodeReconciliation(owner, delivery) {
     if (!delivery.sessionId || owner.reconcilingEntryIds.has(delivery.entryId))
@@ -443,7 +692,8 @@ function scheduleOpenCodeReconciliation(owner, delivery) {
                     }
                 }
                 catch (err) {
-                    log(`entry ${delivery.entryId} reconciliation unavailable: ${err}`);
+                    recordOpenCodeFailure(owner, err, delivery.sequence);
+                    log(`entry ${delivery.entryId} reconciliation unavailable: ${err}`, owner);
                 }
             }
         }
@@ -492,14 +742,16 @@ async function deliverOpenCodeEntry(owner, delivery) {
         }
         if (!target) {
             try {
-                target = await resolveInjectionSession();
+                target = await resolveInjectionSession(owner, delivery.sequence);
             }
             catch (err) {
-                log(`entry ${delivery.entryId} target unavailable: ${err}`);
+                recordOpenCodeFailure(owner, err, delivery.sequence);
+                log(`entry ${delivery.entryId} target unavailable: ${err}`, owner);
                 continue;
             }
             if (!target) {
-                log(`entry ${delivery.entryId} target unavailable: no bound session`);
+                recordOpenCodeFailure(owner, openCodeHttpError(404, 'session'), delivery.sequence);
+                log(`entry ${delivery.entryId} target unavailable: no bound session`, owner);
                 return 'failed';
             }
             delivery.sessionId = target.id;
@@ -512,13 +764,14 @@ async function deliverOpenCodeEntry(owner, delivery) {
                 ? null
                 : await findInjectedMessage(confirmationSessionId, delivery.sourceEntryId));
             if (deliveredIdentity) {
-                log(`entry ${delivery.entryId} already present in session ${confirmationSessionId}`);
+                log(`entry ${delivery.entryId} already present in session ${confirmationSessionId}`, owner);
                 clearPendingSubmission(owner, delivery.entryId);
                 return 'delivered';
             }
         }
         catch (err) {
-            log(`entry ${delivery.entryId} confirmation unavailable: ${err}`);
+            recordOpenCodeFailure(owner, err, delivery.sequence);
+            log(`entry ${delivery.entryId} confirmation unavailable: ${err}`, owner);
             continue;
         }
         const submittedBefore = pendingSubmission !== undefined;
@@ -540,7 +793,7 @@ async function deliverOpenCodeEntry(owner, delivery) {
             });
             if (!persistCurrentBinding()) {
                 owner.pendingSubmissions.delete(delivery.entryId);
-                log(`entry ${delivery.entryId} submission skipped: pending intent was not durable`);
+                log(`entry ${delivery.entryId} submission skipped: pending intent was not durable`, owner);
                 return 'failed';
             }
             // prompt_async is not idempotent. Persist the intent before the one POST;
@@ -559,16 +812,20 @@ async function deliverOpenCodeEntry(owner, delivery) {
                 });
             }
             catch (err) {
-                log(`entry ${delivery.entryId} submission outcome unavailable: ${err}`);
+                recordOpenCodeFailure(owner, err, delivery.sequence);
+                log(`entry ${delivery.entryId} submission outcome unavailable: ${err}`, owner);
             }
             delivery.state = 'delivered-unconfirmed';
             if (status !== null && status !== 200 && status !== 204) {
+                recordOpenCodeFailure(owner, openCodeHttpError(status, 'prompt'), delivery.sequence);
                 clearPendingSubmission(owner, delivery.entryId);
                 if (status === 404)
                     clearBinding();
                 return 'failed';
             }
             delivery.acceptedSubmission = true;
+            if (status === 200 || status === 204)
+                recordOpenCodeAcceptance(owner, delivery);
         }
         for (let confirmationAttempt = 0; confirmationAttempt < OPEN_CODE_DELIVERY_RETRY_DELAYS_MS.length; confirmationAttempt++) {
             if (confirmationAttempt > 0) {
@@ -588,7 +845,8 @@ async function deliverOpenCodeEntry(owner, delivery) {
                 }
             }
             catch (err) {
-                log(`entry ${delivery.entryId} post-acceptance confirmation unavailable: ${err}`);
+                recordOpenCodeFailure(owner, err, delivery.sequence);
+                log(`entry ${delivery.entryId} post-acceptance confirmation unavailable: ${err}`, owner);
             }
         }
         return 'delivered-unconfirmed';
@@ -605,13 +863,27 @@ async function processOpenCodeDeliveries(owner) {
     try {
         while (state === owner && owner.deliveryQueue.length > 0) {
             const delivery = owner.deliveryQueue.shift();
+            updateLastOpenCodeObservation(owner, delivery.sequence, {
+                lastInjectionAt: Date.now(),
+                lastInjectionResult: null,
+                lastFailureCode: null,
+            });
             let outcome = 'failed';
             try {
                 outcome = await deliverOpenCodeEntry(owner, delivery);
             }
             catch (err) {
-                log(`entry ${delivery.entryId} delivery error: ${err}`);
+                recordOpenCodeFailure(owner, err, delivery.sequence);
+                log(`entry ${delivery.entryId} delivery error: ${err}`, owner);
             }
+            updateLastOpenCodeObservation(owner, delivery.sequence, {
+                lastInjectionResult: outcome,
+                lastFailureCode: outcome === 'delivered'
+                    ? null
+                    : outcome === 'failed'
+                        ? (owner.lastObservation.lastFailureCode ?? 'unknown')
+                        : owner.lastObservation.lastFailureCode,
+            });
             owner.activeDeliveries.delete(delivery.entryId);
             if (delivery.settled) {
                 delivery.resolve(true);
@@ -647,12 +919,13 @@ async function processOpenCodeDeliveries(owner) {
  * the separate MCP-child process, which must never fall back to a newest-session heuristic.
  */
 export async function injectInitialKickoff(launch) {
-    if (!state?.connected) {
-        log('kickoff: not connected');
+    const owner = state;
+    if (!owner?.connected) {
+        log('kickoff: not connected', owner);
         return false;
     }
     if (!isOpenCode256BitIdentity(launch.correlationIdentity)) {
-        log('kickoff: correlation identity missing or unverifiable');
+        log('kickoff: correlation identity missing or unverifiable', owner);
         return false;
     }
     try {
@@ -660,7 +933,7 @@ export async function injectInitialKickoff(launch) {
         for (let i = 0; i < 30; i++) {
             try {
                 await listSessions();
-                log(`kickoff: server ready (attempt ${i + 1})`);
+                log(`kickoff: server ready (attempt ${i + 1})`, owner);
                 break;
             }
             catch {
@@ -673,17 +946,19 @@ export async function injectInitialKickoff(launch) {
         for (let i = 0; i < 30; i++) {
             const binding = await findLaunchSession(launch.correlationIdentity);
             if (binding) {
+                if (state !== owner)
+                    return false;
                 saveBinding(binding.session, binding.knownRootSessionIds);
-                log(`kickoff: bound session ${binding.session.id.slice(0, 8)}…`);
+                log(`kickoff: bound session ${binding.session.id.slice(0, 8)}…`, owner);
                 return true;
             }
             await new Promise((r) => setTimeout(r, 1000));
         }
-        log('kickoff: no session found');
+        log('kickoff: no session found', owner);
         return false;
     }
     catch (err) {
-        log(`kickoff error: ${err}`);
+        log(`kickoff error: ${err}`, owner);
         return false;
     }
 }
@@ -698,7 +973,7 @@ export async function injectInitialKickoff(launch) {
 export function injectOpenCodeEntry(text, entryId = createHash('sha256').update(text).digest('hex'), allowSubmit = true, sourceEntryId = entryId, isSourcePending) {
     const owner = state;
     if (!owner?.connected) {
-        log(`entry ${entryId} rejected: OpenCode is not connected`);
+        log(`entry ${entryId} rejected: OpenCode is not connected`, owner);
         return Promise.resolve(false);
     }
     // Rehydrate durable source markers before source-level deduplication. A
@@ -708,14 +983,14 @@ export function injectOpenCodeEntry(text, entryId = createHash('sha256').update(
     restoreBinding();
     const pendingSource = [...owner.pendingSubmissions].find(([pendingEntryId, pending]) => pendingEntryId !== entryId && pending.sourceEntryId === sourceEntryId);
     if (pendingSource) {
-        log(`entry ${entryId} reconciles pending source ${sourceEntryId}`);
+        log(`entry ${entryId} reconciles pending source ${sourceEntryId}`, owner);
         return injectOpenCodeEntry(text, pendingSource[0], false, sourceEntryId, isSourcePending);
     }
     for (const [deliveredEntryId, record] of owner.deliveredEntries) {
         if (deliveredEntryId !== entryId && record.sourceEntryId === sourceEntryId) {
             if (record.text !== text)
                 return Promise.resolve(false);
-            log(`entry ${entryId} source ${sourceEntryId} already delivered`);
+            log(`entry ${entryId} source ${sourceEntryId} already delivered`, owner);
             return Promise.resolve(true);
         }
     }
@@ -723,7 +998,7 @@ export function injectOpenCodeEntry(text, entryId = createHash('sha256').update(
         if (unconfirmedEntryId !== entryId && record.sourceEntryId === sourceEntryId) {
             if (record.text !== text)
                 return Promise.resolve(false);
-            log(`entry ${entryId} source ${sourceEntryId} remains unconfirmed`);
+            log(`entry ${entryId} source ${sourceEntryId} remains unconfirmed`, owner);
             return Promise.resolve(true);
         }
     }
@@ -731,32 +1006,33 @@ export function injectOpenCodeEntry(text, entryId = createHash('sha256').update(
         if (active.entryId !== entryId && active.sourceEntryId === sourceEntryId) {
             if (active.text !== text)
                 return Promise.resolve(false);
-            log(`entry ${entryId} joined active source ${sourceEntryId}`);
+            log(`entry ${entryId} joined active source ${sourceEntryId}`, owner);
             return active.promise;
         }
     }
     const delivered = owner.deliveredEntries.get(entryId);
     if (delivered !== undefined) {
         if (delivered.text !== text || delivered.sourceEntryId !== sourceEntryId) {
-            log(`entry ${entryId} replay text mismatch`);
+            log(`entry ${entryId} replay text mismatch`, owner);
             rememberBounded(owner.failedEntries, entryId, text, sourceEntryId);
             return Promise.resolve(false);
         }
-        log(`entry ${entryId} replay already delivered`);
+        log(`entry ${entryId} replay already delivered`, owner);
         return Promise.resolve(true);
     }
     const unconfirmed = owner.unconfirmedEntries.get(entryId);
     if (unconfirmed !== undefined) {
         if (unconfirmed.text !== text || unconfirmed.sourceEntryId !== sourceEntryId) {
-            log(`entry ${entryId} unconfirmed replay text mismatch`);
+            log(`entry ${entryId} unconfirmed replay text mismatch`, owner);
             rememberBounded(owner.failedEntries, entryId, text, sourceEntryId);
             return Promise.resolve(false);
         }
-        log(`entry ${entryId} replay remains unconfirmed`);
+        log(`entry ${entryId} replay remains unconfirmed`, owner);
         const pending = owner.pendingSubmissions.get(entryId);
         const accepted = pending !== undefined;
         if (pending) {
             scheduleOpenCodeReconciliation(owner, {
+                sequence: ++owner.nextObservationSequence,
                 entryId,
                 sourceEntryId,
                 text,
@@ -774,11 +1050,11 @@ export function injectOpenCodeEntry(text, entryId = createHash('sha256').update(
     const active = owner.activeDeliveries.get(entryId);
     if (active) {
         if (active.text !== text || active.sourceEntryId !== sourceEntryId) {
-            log(`entry ${entryId} active text mismatch`);
+            log(`entry ${entryId} active text mismatch`, owner);
             rememberBounded(owner.failedEntries, entryId, text, sourceEntryId);
             return Promise.resolve(false);
         }
-        log(`entry ${entryId} replay joined active delivery`);
+        log(`entry ${entryId} replay joined active delivery`, owner);
         return active.promise;
     }
     let resolveDelivery;
@@ -786,6 +1062,7 @@ export function injectOpenCodeEntry(text, entryId = createHash('sha256').update(
         resolveDelivery = resolve;
     });
     const delivery = {
+        sequence: ++owner.nextObservationSequence,
         entryId,
         sourceEntryId,
         text,
@@ -833,19 +1110,26 @@ export function settleOpenCodeEntry(sourceEntryId) {
         persistCurrentBinding();
 }
 export async function probeOpenCodeDroneArmed() {
-    if (!state?.connected)
+    const owner = state;
+    if (!owner?.connected)
         return null;
+    const observationSequence = ++owner.nextObservationSequence;
     const binding = restoreBinding();
     if (!binding)
         return false;
     try {
         const session = await getSession(binding.sessionId);
+        if (state !== owner)
+            return null;
         if (session && isBoundSession(session, binding))
             return true;
+        recordOpenCodeFailure(owner, openCodeHttpError(404, 'session'), observationSequence);
         clearBinding();
         return false;
     }
-    catch {
+    catch (error) {
+        if (state === owner)
+            recordOpenCodeFailure(owner, error, observationSequence);
         return false;
     }
 }
@@ -868,9 +1152,23 @@ export function getOpenCodeConnectionState() {
         sessionId: state?.sessionId ?? null,
         totalEntriesInjected: state?.totalEntriesInjected ?? 0,
         totalEntriesRetried: state?.totalEntriesRetried ?? 0,
+        lastInjectionAt: state?.lastObservation.lastInjectionAt ?? null,
+        lastInjectionResult: state?.lastObservation.lastInjectionResult ?? null,
+        lastAcceptedEntryId: state?.lastObservation.lastAcceptedEntryId ?? null,
+        lastFailureCode: state?.lastObservation.lastFailureCode ?? null,
         deliveryStates,
     };
 }
+export function __getOpenCodeDiagnosticLogPathForTests() {
+    if (!state)
+        throw new Error('OpenCode drone is not connected');
+    return diagnosticLogPath(state);
+}
+export function __getOpenCodeLastObservationForTests() {
+    if (!state)
+        throw new Error('OpenCode drone is not connected');
+    return { ...state.lastObservation };
+}
 export function computeOpenCodePort(droneId, base = 14096) {
     let hash = 0;
     for (let i = 0; i < droneId.length; i++) {
@@ -938,5 +1236,14 @@ export function __resetOpenCodeDroneForTests() {
         }
     }
     bindingPathsForTests.clear();
+    for (const path of diagnosticLogPathsForTests) {
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            // Already removed.
+        }
+    }
+    diagnosticLogPathsForTests.clear();
 }
 //# sourceMappingURL=opencode-drone.js.map