borgmcp 3.9.0 → 3.11.0

package/src/opencode-drone.ts

@@ -27,9 +27,11 @@ interface OpenCodeDroneState {
   totalEntriesRetried: number;
   deliveryQueue: OpenCodeDelivery[];
   activeDeliveries: Map<string, OpenCodeDelivery>;
-  deliveredEntries: Map<string, string>;
-  unconfirmedEntries: Map<string, string>;
-  failedEntries: Map<string, string>;
+  deliveredEntries: Map<string, OpenCodeDeliveryRecord>;
+  unconfirmedEntries: Map<string, OpenCodeDeliveryRecord>;
+  failedEntries: Map<string, OpenCodeDeliveryRecord>;
+  pendingSubmissions: Map<string, PendingOpenCodeSubmission>;
+  reconcilingEntryIds: Set<string>;
   processingDeliveries: boolean;
 }
 
@@ -72,20 +74,40 @@ export type OpenCodeDeliveryState =
 
 interface OpenCodeDelivery {
   entryId: string;
+  sourceEntryId: string;
   text: string;
   allowSubmit: boolean;
+  acceptedSubmission: boolean;
+  sessionId: string | null;
+  settled: boolean;
   state: Exclude<OpenCodeDeliveryState, 'failed'>;
   resolve: (delivered: boolean) => void;
   promise: Promise<boolean>;
 }
 
+interface OpenCodeDeliveryRecord {
+  text: string;
+  sourceEntryId: string;
+}
+
+interface PendingOpenCodeSubmission {
+  sourceEntryId: string;
+  /** Session that received the one allowed prompt_async submission. */
+  sessionId: string;
+}
+
 type OpenCodeDeliveryOutcome = 'delivered' | 'delivered-unconfirmed' | 'failed';
 
 const OPEN_CODE_DELIVERY_RETRY_DELAYS_MS = [0, 250, 1_000, 3_000] as const;
+const OPEN_CODE_RECONCILIATION_DELAY_MS = 3_000;
+// Keep one accepted-but-unconfirmed prompt from holding timers forever. It
+// remains pending (never failed or resubmitted), and any later wake retry
+// re-arms another confirmation-only window.
+const OPEN_CODE_RECONCILIATION_ATTEMPTS = 20;
 const OPEN_CODE_DELIVERY_HISTORY_LIMIT = 256;
 
 interface SessionBinding {
-  version: 2;
+  version: 4;
   sessionId: string;
   sessionCreatedAt: number;
   knownRootSessionIds: string[];
@@ -93,6 +115,11 @@ interface SessionBinding {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  pendingSubmissions: Array<{
+    entryId: string;
+    sourceEntryId: string;
+    sessionId: string;
+  }>;
 }
 
 export interface OpenCodeLaunchKickoff {
@@ -151,6 +178,8 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
     deliveredEntries: new Map(),
     unconfirmedEntries: new Map(),
     failedEntries: new Map(),
+    pendingSubmissions: new Map(),
+    reconcilingEntryIds: new Set(),
     processingDeliveries: false,
   };
   log(`connected url=${deps.serverUrl} dir=${deps.directory}`);
@@ -257,7 +286,7 @@ function bindingPath(): string {
 
 function bindingMatchesState(binding: SessionBinding): boolean {
   const current = state!;
-  return binding.version === 2
+  return binding.version === 4
     && binding.serverUrl === current.serverUrl
     && binding.directory === current.directory
     && binding.droneLabel === current.droneLabel
@@ -265,7 +294,13 @@ function bindingMatchesState(binding: SessionBinding): boolean {
     && typeof binding.sessionId === 'string'
     && typeof binding.sessionCreatedAt === 'number'
     && Array.isArray(binding.knownRootSessionIds)
-    && binding.knownRootSessionIds.every((id) => typeof id === 'string');
+    && binding.knownRootSessionIds.every((id) => typeof id === 'string')
+    && Array.isArray(binding.pendingSubmissions)
+    && binding.pendingSubmissions.every((pending) =>
+      typeof pending?.entryId === 'string'
+        && typeof pending?.sourceEntryId === 'string'
+        && typeof pending.sessionId === 'string'
+    );
 }
 
 function readBinding(): SessionBinding | null {
@@ -285,6 +320,10 @@ function clearBinding(): void {
   state.sessionId = null;
   state.sessionCreatedAt = null;
   state.knownRootSessionIds = [];
+  // A missing/replaced target does not prove that an earlier prompt_async was
+  // rejected. Keep its durable submission marker (and origin session) so a
+  // replacement binding and later MCP-child reconnect remain confirmation-only.
+  if (state.pendingSubmissions.size > 0) return;
   try {
     unlinkSync(path);
   } catch {
@@ -292,18 +331,8 @@ function clearBinding(): void {
   }
 }
 
-function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
+function writeBinding(binding: SessionBinding): boolean {
   const current = state!;
-  const binding: SessionBinding = {
-    version: 2,
-    sessionId: session.id,
-    sessionCreatedAt: session.time.created,
-    knownRootSessionIds,
-    serverUrl: current.serverUrl,
-    directory: current.directory,
-    droneLabel: current.droneLabel,
-    cubeName: current.cubeName,
-  };
   current.sessionId = binding.sessionId;
   current.sessionCreatedAt = binding.sessionCreatedAt;
   current.knownRootSessionIds = binding.knownRootSessionIds;
@@ -313,16 +342,58 @@ function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
     const temporary = `${path}.${process.pid}.tmp`;
     writeFileSync(temporary, JSON.stringify(binding), { mode: 0o600 });
     renameSync(temporary, path);
+    return true;
   } catch (err) {
     log(`session binding write failed: ${err}`);
+    return false;
   }
 }
 
+function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
+  const current = state!;
+  const binding: SessionBinding = {
+    version: 4,
+    sessionId: session.id,
+    sessionCreatedAt: session.time.created,
+    knownRootSessionIds,
+    serverUrl: current.serverUrl,
+    directory: current.directory,
+    droneLabel: current.droneLabel,
+    cubeName: current.cubeName,
+    pendingSubmissions: [...current.pendingSubmissions].map(([entryId, pending]) => ({
+      entryId,
+      sourceEntryId: pending.sourceEntryId,
+      sessionId: pending.sessionId,
+    })),
+  };
+  writeBinding(binding);
+}
+
+function persistCurrentBinding(): boolean {
+  const current = state;
+  if (!current?.sessionId || current.sessionCreatedAt === null) return false;
+  return writeBinding({
+    version: 4,
+    sessionId: current.sessionId,
+    sessionCreatedAt: current.sessionCreatedAt,
+    knownRootSessionIds: current.knownRootSessionIds,
+    serverUrl: current.serverUrl,
+    directory: current.directory,
+    droneLabel: current.droneLabel,
+    cubeName: current.cubeName,
+    pendingSubmissions: [...current.pendingSubmissions].map(([entryId, pending]) => ({
+      entryId,
+      sourceEntryId: pending.sourceEntryId,
+      sessionId: pending.sessionId,
+    })),
+  });
+}
+
 function restoreBinding(): SessionBinding | null {
   if (!state) return null;
   if (state.sessionId && state.sessionCreatedAt !== null) {
     return {
-      version: 2,
+      version: 4,
       sessionId: state.sessionId,
       sessionCreatedAt: state.sessionCreatedAt,
       knownRootSessionIds: state.knownRootSessionIds,
@@ -330,6 +401,11 @@ function restoreBinding(): SessionBinding | null {
       directory: state.directory,
       droneLabel: state.droneLabel,
       cubeName: state.cubeName,
+      pendingSubmissions: [...state.pendingSubmissions].map(([entryId, pending]) => ({
+        entryId,
+        sourceEntryId: pending.sourceEntryId,
+        sessionId: pending.sessionId,
+      })),
     };
   }
 
@@ -338,6 +414,13 @@ function restoreBinding(): SessionBinding | null {
   state.sessionId = binding.sessionId;
   state.sessionCreatedAt = binding.sessionCreatedAt;
   state.knownRootSessionIds = binding.knownRootSessionIds;
+  state.pendingSubmissions = new Map(binding.pendingSubmissions.map((pending) => [
+    pending.entryId,
+    {
+      sourceEntryId: pending.sourceEntryId,
+      sessionId: pending.sessionId,
+    },
+  ]));
   return binding;
 }
 
@@ -451,12 +534,13 @@ async function resolveInjectionSession(): Promise<OCSession | null> {
 }
 
 function rememberBounded(
-  entries: Map<string, string>,
+  entries: Map<string, OpenCodeDeliveryRecord>,
   entryId: string,
   text: string,
+  sourceEntryId: string,
 ): void {
   entries.delete(entryId);
-  entries.set(entryId, text);
+  entries.set(entryId, { text, sourceEntryId });
   while (entries.size > OPEN_CODE_DELIVERY_HISTORY_LIMIT) {
     const oldest = entries.keys().next().value;
     if (typeof oldest !== 'string') break;
@@ -464,6 +548,60 @@ function rememberBounded(
   }
 }
 
+function clearPendingSubmission(owner: OpenCodeDroneState, entryId: string): void {
+  if (!owner.pendingSubmissions.delete(entryId)) return;
+  if (state === owner) persistCurrentBinding();
+}
+
+function confirmOpenCodeDelivery(
+  owner: OpenCodeDroneState,
+  delivery: Pick<OpenCodeDelivery, 'entryId' | 'sourceEntryId' | 'text'>,
+): void {
+  const unconfirmed = owner.unconfirmedEntries.get(delivery.entryId);
+  if (unconfirmed && unconfirmed.text !== delivery.text) return;
+  owner.unconfirmedEntries.delete(delivery.entryId);
+  owner.failedEntries.delete(delivery.entryId);
+  clearPendingSubmission(owner, delivery.entryId);
+  rememberBounded(
+    owner.deliveredEntries,
+    delivery.entryId,
+    delivery.text,
+    delivery.sourceEntryId,
+  );
+  owner.totalEntriesInjected++;
+}
+
+function scheduleOpenCodeReconciliation(
+  owner: OpenCodeDroneState,
+  delivery: OpenCodeDelivery,
+): void {
+  if (!delivery.sessionId || owner.reconcilingEntryIds.has(delivery.entryId)) return;
+  owner.reconcilingEntryIds.add(delivery.entryId);
+  const sessionId = delivery.sessionId;
+  void (async () => {
+    try {
+      for (let attempt = 0; attempt < OPEN_CODE_RECONCILIATION_ATTEMPTS; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, OPEN_CODE_RECONCILIATION_DELAY_MS));
+        if (state !== owner || !owner.connected || delivery.settled) return;
+        const record = owner.unconfirmedEntries.get(delivery.entryId);
+        if (!record || record.text !== delivery.text) return;
+        owner.totalEntriesRetried++;
+        try {
+          if (await findInjectedMessage(sessionId, delivery.entryId)) {
+            if (delivery.settled) return;
+            confirmOpenCodeDelivery(owner, delivery);
+            return;
+          }
+        } catch (err) {
+          log(`entry ${delivery.entryId} reconciliation unavailable: ${err}`);
+        }
+      }
+    } finally {
+      owner.reconcilingEntryIds.delete(delivery.entryId);
+    }
+  })();
+}
+
 function waitForDeliveryRetry(attempt: number): Promise<void> {
   const delay = OPEN_CODE_DELIVERY_RETRY_DELAYS_MS[attempt] ?? 0;
   return delay > 0
@@ -483,11 +621,13 @@ async function deliverOpenCodeEntry(
   // ever becoming the active user turn. The unique inbox text correlates the
   // generated message across confirmation and process-replay instead.
   for (let attempt = 0; attempt < OPEN_CODE_DELIVERY_RETRY_DELAYS_MS.length; attempt++) {
+    if (delivery.settled) return 'delivered';
     if (state !== owner || !owner.connected) return 'failed';
     if (attempt > 0) {
       delivery.state = 'retried';
       owner.totalEntriesRetried++;
       await waitForDeliveryRetry(attempt);
+      if (delivery.settled) return 'delivered';
       if (state !== owner || !owner.connected) return 'failed';
     }
 
@@ -502,11 +642,22 @@ async function deliverOpenCodeEntry(
         log(`entry ${delivery.entryId} target unavailable: no bound session`);
         return 'failed';
       }
+      delivery.sessionId = target.id;
     }
 
+    const pendingSubmission = owner.pendingSubmissions.get(delivery.entryId);
+    const confirmationSessionId = pendingSubmission?.sessionId ?? target.id;
+    delivery.sessionId = confirmationSessionId;
+
     try {
-      if (await findInjectedMessage(target.id, delivery.entryId)) {
-        log(`entry ${delivery.entryId} already present in session ${target.id}`);
+      const deliveredIdentity = await findInjectedMessage(confirmationSessionId, delivery.entryId) ?? (
+        delivery.sourceEntryId === delivery.entryId
+          ? null
+          : await findInjectedMessage(confirmationSessionId, delivery.sourceEntryId)
+      );
+      if (deliveredIdentity) {
+        log(`entry ${delivery.entryId} already present in session ${confirmationSessionId}`);
+        clearPendingSubmission(owner, delivery.entryId);
         return 'delivered';
       }
     } catch (err) {
@@ -514,33 +665,51 @@ async function deliverOpenCodeEntry(
       continue;
     }
 
-    if (!delivery.allowSubmit) {
+    const submittedBefore = pendingSubmission !== undefined;
+    if (!delivery.allowSubmit && !submittedBefore) {
       continue;
     }
 
-    // prompt_async is not idempotent. Submit at most once, then only poll for
-    // the exact text. A transport failure is ambiguous and follows the same
-    // confirmation-only path.
-    let status: number | null = null;
-    try {
-      status = await promptSession(target.id, {
-        parts: [{
-          type: 'text',
-          text: delivery.text,
-          metadata: {
-            [OPENCODE_INJECTED_ENTRY_METADATA_KEY]: true,
-            [OPENCODE_WAKE_IDENTITY_METADATA_KEY]: delivery.entryId,
-          },
-        }],
+    if (submittedBefore) {
+      delivery.acceptedSubmission = true;
+      delivery.state = 'delivered-unconfirmed';
+    } else {
+      if (delivery.settled) return 'delivered';
+      owner.pendingSubmissions.set(delivery.entryId, {
+        sourceEntryId: delivery.sourceEntryId,
+        sessionId: target.id,
       });
-    } catch (err) {
-      log(`entry ${delivery.entryId} submission outcome unavailable: ${err}`);
-    }
+      if (!persistCurrentBinding()) {
+        owner.pendingSubmissions.delete(delivery.entryId);
+        log(`entry ${delivery.entryId} submission skipped: pending intent was not durable`);
+        return 'failed';
+      }
 
-    delivery.state = 'delivered-unconfirmed';
-    if (status !== null && status !== 200 && status !== 204) {
-      if (status === 404) clearBinding();
-      return 'failed';
+      // prompt_async is not idempotent. Persist the intent before the one POST;
+      // every recovery path is confirmation-only until that identity appears.
+      let status: number | null = null;
+      try {
+        status = await promptSession(target.id, {
+          parts: [{
+            type: 'text',
+            text: delivery.text,
+            metadata: {
+              [OPENCODE_INJECTED_ENTRY_METADATA_KEY]: true,
+              [OPENCODE_WAKE_IDENTITY_METADATA_KEY]: delivery.entryId,
+            },
+          }],
+        });
+      } catch (err) {
+        log(`entry ${delivery.entryId} submission outcome unavailable: ${err}`);
+      }
+
+      delivery.state = 'delivered-unconfirmed';
+      if (status !== null && status !== 200 && status !== 204) {
+        clearPendingSubmission(owner, delivery.entryId);
+        if (status === 404) clearBinding();
+        return 'failed';
+      }
+      delivery.acceptedSubmission = true;
     }
 
     for (
@@ -552,11 +721,13 @@ async function deliverOpenCodeEntry(
         delivery.state = 'retried';
         owner.totalEntriesRetried++;
         await waitForDeliveryRetry(confirmationAttempt);
+        if (delivery.settled) return 'delivered';
         if (state !== owner || !owner.connected) return 'delivered-unconfirmed';
         delivery.state = 'delivered-unconfirmed';
       }
       try {
-        if (await findInjectedMessage(target.id, delivery.entryId)) {
+        if (await findInjectedMessage(delivery.sessionId!, delivery.entryId)) {
+          clearPendingSubmission(owner, delivery.entryId);
           return 'delivered';
         }
       } catch (err) {
@@ -587,19 +758,29 @@ async function processOpenCodeDeliveries(owner: OpenCodeDroneState): Promise<voi
       }
 
       owner.activeDeliveries.delete(delivery.entryId);
-      if (outcome === 'delivered') {
-        owner.unconfirmedEntries.delete(delivery.entryId);
-        owner.failedEntries.delete(delivery.entryId);
-        rememberBounded(owner.deliveredEntries, delivery.entryId, delivery.text);
-        owner.totalEntriesInjected++;
+      if (delivery.settled) {
+        delivery.resolve(true);
+      } else if (outcome === 'delivered') {
+        confirmOpenCodeDelivery(owner, delivery);
         delivery.resolve(true);
       } else if (outcome === 'delivered-unconfirmed') {
         owner.failedEntries.delete(delivery.entryId);
-        rememberBounded(owner.unconfirmedEntries, delivery.entryId, delivery.text);
-        delivery.resolve(false);
+        rememberBounded(
+          owner.unconfirmedEntries,
+          delivery.entryId,
+          delivery.text,
+          delivery.sourceEntryId,
+        );
+        delivery.resolve(delivery.acceptedSubmission);
+        if (delivery.acceptedSubmission) scheduleOpenCodeReconciliation(owner, delivery);
       } else {
         owner.unconfirmedEntries.delete(delivery.entryId);
-        rememberBounded(owner.failedEntries, delivery.entryId, delivery.text);
+        rememberBounded(
+          owner.failedEntries,
+          delivery.entryId,
+          delivery.text,
+          delivery.sourceEntryId,
+        );
         delivery.resolve(false);
       }
     }
@@ -657,12 +838,15 @@ export async function injectInitialKickoff(launch: OpenCodeLaunchKickoff): Promi
  * Queue one durable inbox entry for delivery into the bound OpenCode session.
  * The delivery identity is stored in TextPart metadata, so retries and replay
  * can confirm an earlier ambiguous submission without supplying an
- * ordering-breaking caller message ID or exposing the identity in delivered text.
+ * ordering-breaking caller message ID or exposing the identity in delivered
+ * text. Retry nonces also carry their durable source entry ID so they reconcile
+ * one submission instead of creating a second prompt.
  */
 export function injectOpenCodeEntry(
   text: string,
   entryId: string = createHash('sha256').update(text).digest('hex'),
   allowSubmit: boolean = true,
+  sourceEntryId: string = entryId,
 ): Promise<boolean> {
   const owner = state;
   if (!owner?.connected) {
@@ -670,33 +854,84 @@ export function injectOpenCodeEntry(
     return Promise.resolve(false);
   }
 
-  const deliveredText = owner.deliveredEntries.get(entryId);
-  if (deliveredText !== undefined) {
-    if (deliveredText !== text) {
+  // Rehydrate durable source markers before source-level deduplication. A
+  // freshly connected MCP child starts with an empty in-memory map; waiting
+  // until target resolution would let a different wake nonce queue a second
+  // submission before the prior source identity is visible locally.
+  restoreBinding();
+  const pendingSource = [...owner.pendingSubmissions].find(
+    ([pendingEntryId, pending]) =>
+      pendingEntryId !== entryId && pending.sourceEntryId === sourceEntryId,
+  );
+  if (pendingSource) {
+    log(`entry ${entryId} reconciles pending source ${sourceEntryId}`);
+    return injectOpenCodeEntry(text, pendingSource[0], false, sourceEntryId);
+  }
+  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`);
+      return Promise.resolve(true);
+    }
+  }
+  for (const [unconfirmedEntryId, record] of owner.unconfirmedEntries) {
+    if (unconfirmedEntryId !== entryId && record.sourceEntryId === sourceEntryId) {
+      if (record.text !== text) return Promise.resolve(false);
+      log(`entry ${entryId} source ${sourceEntryId} remains unconfirmed`);
+      return Promise.resolve(true);
+    }
+  }
+  for (const active of owner.activeDeliveries.values()) {
+    if (active.entryId !== entryId && active.sourceEntryId === sourceEntryId) {
+      if (active.text !== text) return Promise.resolve(false);
+      log(`entry ${entryId} joined active source ${sourceEntryId}`);
+      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`);
-      rememberBounded(owner.failedEntries, entryId, text);
+      rememberBounded(owner.failedEntries, entryId, text, sourceEntryId);
       return Promise.resolve(false);
     }
     log(`entry ${entryId} replay already delivered`);
     return Promise.resolve(true);
   }
 
-  const unconfirmedText = owner.unconfirmedEntries.get(entryId);
-  if (unconfirmedText !== undefined) {
-    if (unconfirmedText !== text) {
+  const unconfirmed = owner.unconfirmedEntries.get(entryId);
+  if (unconfirmed !== undefined) {
+    if (unconfirmed.text !== text || unconfirmed.sourceEntryId !== sourceEntryId) {
       log(`entry ${entryId} unconfirmed replay text mismatch`);
-      rememberBounded(owner.failedEntries, entryId, text);
+      rememberBounded(owner.failedEntries, entryId, text, sourceEntryId);
       return Promise.resolve(false);
     }
     log(`entry ${entryId} replay remains unconfirmed`);
-    return Promise.resolve(false);
+    const pending = owner.pendingSubmissions.get(entryId);
+    const accepted = pending !== undefined;
+    if (pending) {
+      scheduleOpenCodeReconciliation(owner, {
+        entryId,
+        sourceEntryId,
+        text,
+        allowSubmit: false,
+        acceptedSubmission: true,
+        sessionId: pending.sessionId,
+        settled: false,
+        state: 'delivered-unconfirmed',
+        resolve: () => {},
+        promise: Promise.resolve(true),
+      });
+    }
+    return Promise.resolve(accepted);
   }
 
   const active = owner.activeDeliveries.get(entryId);
   if (active) {
-    if (active.text !== text) {
+    if (active.text !== text || active.sourceEntryId !== sourceEntryId) {
       log(`entry ${entryId} active text mismatch`);
-      rememberBounded(owner.failedEntries, entryId, text);
+      rememberBounded(owner.failedEntries, entryId, text, sourceEntryId);
       return Promise.resolve(false);
     }
     log(`entry ${entryId} replay joined active delivery`);
@@ -709,8 +944,12 @@ export function injectOpenCodeEntry(
   });
   const delivery: OpenCodeDelivery = {
     entryId,
+    sourceEntryId,
     text,
     allowSubmit,
+    acceptedSubmission: false,
+    sessionId: null,
+    settled: false,
     state: 'queued',
     resolve: resolveDelivery,
     promise,
@@ -723,6 +962,30 @@ export function injectOpenCodeEntry(
   return promise;
 }
 
+/** Stop retrying every delivery identity derived from a durable entry that the
+ * agent has already consumed. Confirmed history stays available for dedup. */
+export function settleOpenCodeEntry(sourceEntryId: string): void {
+  const owner = state;
+  if (!owner) return;
+
+  let bindingChanged = false;
+  for (const [entryId, record] of owner.unconfirmedEntries) {
+    if (record.sourceEntryId !== sourceEntryId) continue;
+    owner.unconfirmedEntries.delete(entryId);
+    bindingChanged = owner.pendingSubmissions.delete(entryId) || bindingChanged;
+  }
+  for (const [entryId, record] of owner.failedEntries) {
+    if (record.sourceEntryId === sourceEntryId) owner.failedEntries.delete(entryId);
+  }
+  for (const delivery of owner.activeDeliveries.values()) {
+    if (delivery.sourceEntryId !== sourceEntryId) continue;
+    delivery.settled = true;
+    delivery.resolve(true);
+    bindingChanged = owner.pendingSubmissions.delete(delivery.entryId) || bindingChanged;
+  }
+  if (bindingChanged) persistCurrentBinding();
+}
+
 export async function probeOpenCodeDroneArmed(): Promise<boolean | null> {
   if (!state?.connected) return null;
   const binding = restoreBinding();

package/src/opencode-plugin.ts

@@ -138,7 +138,19 @@ export function createOpenCodePluginCore(
       try {
         const history = await deps.listMessages(input.sessionID);
         const nudge = deps.audit([...history, current]);
-        if (nudge) output.parts.push({ type: 'text', text: nudge });
+        if (nudge) {
+          // OpenCode's chat.message hook receives resolved parts after their
+          // id/sessionID/messageID fields have been assigned. A newly pushed
+          // part skips that assignment and fails the durable PartUpdated
+          // aggregate in Session.updatePart. Preserve the resolved identity by
+          // replacing an existing text part with an augmented copy instead.
+          const index = output.parts.findIndex((part) =>
+            part?.type === 'text' && typeof part.text === 'string');
+          if (index >= 0) {
+            const part = output.parts[index];
+            output.parts[index] = { ...part, text: `${part.text}\n\n${nudge}` };
+          }
+        }
       } catch {
         // Audit is advisory and must never block a prompt.
       }

package/src/parse-clone-args.ts

@@ -0,0 +1,44 @@
+import { redactCloneSecrets } from './clone-security.js';
+
+export interface CloneArgs {
+  repositoryUrl: string;
+  destination?: string;
+  noLaunch: boolean;
+}
+
+export type ParseCloneResult =
+  | { ok: true; args: CloneArgs }
+  | { ok: false; error: string };
+
+export function parseCloneArgs(rawArgs: readonly string[]): ParseCloneResult {
+  let repositoryUrl: string | undefined;
+  let destination: string | undefined;
+  let noLaunch = false;
+  for (const arg of rawArgs) {
+    if (arg === '--no-launch') {
+      if (noLaunch) return { ok: false, error: '--no-launch was provided more than once' };
+      noLaunch = true;
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      const option = arg.startsWith('--') ? arg.split('=', 1)[0] : arg.slice(0, 2);
+      return { ok: false, error: `unknown option ${option}; the only option is --no-launch` };
+    }
+    if (repositoryUrl === undefined) repositoryUrl = arg;
+    else if (destination === undefined) destination = arg;
+    else return { ok: false, error: 'unexpected extra argument' };
+  }
+  if (!repositoryUrl) return { ok: false, error: 'a repository URL is required' };
+  return {
+    ok: true,
+    args: {
+      repositoryUrl,
+      ...(destination === undefined ? {} : { destination }),
+      noLaunch,
+    },
+  };
+}
+
+export function safeCloneParseError(result: Extract<ParseCloneResult, { ok: false }>): string {
+  return redactCloneSecrets(result.error);
+}