ticlawk 0.1.17-dev.17 → 0.1.17-dev.19

package/src/runtimes/codex/index.mjs

@@ -5,10 +5,7 @@
  * and discover local sessions.
  */
 
-import { createHash } from 'node:crypto';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
+import { basename } from 'node:path';
 import {
   createCodexSession,
   runCodexPrompt,
@@ -21,97 +18,18 @@ import {
   requireCodexPath,
 } from './session.mjs';
 import { buildCodexInputFromInbound } from '../../core/media/inbound.mjs';
-import { emitWorkerEventBestEffort } from '../../core/events/worker-events.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
+  createDeltaAggregator,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
   isRuntimeGatewayFailure,
-  resolveRuntimeSessionScope,
-  buildRuntimeSessionMetaPatch,
 } from '../../core/runtime-support.mjs';
 import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
-import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
+import { buildRuntimeBaseInstructions } from '../_shared/runtime-base-instructions.mjs';
 import { ensureAgentHome } from '../../core/agent-home.mjs';
-import { debugError, debugLog } from '../../core/logger.mjs';
-
-function parseBooleanish(value) {
-  if (value === undefined || value === null || value === '') return false;
-  return ['1', 'true', 'on', 'yes'].includes(String(value).trim().toLowerCase());
-}
-
-function sha256(text) {
-  return createHash('sha256').update(String(text || ''), 'utf8').digest('hex');
-}
-
-function fileSafeId(value) {
-  return String(value || 'unknown')
-    .replace(/[^a-zA-Z0-9_-]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 80) || 'unknown';
-}
-
-function writePromptSnapshot({
-  binding,
-  inbound,
-  agentHome,
-  targetSessionId,
-  shouldRotate,
-  developerInstructions,
-  message,
-  input,
-}) {
-  if (!parseBooleanish(process.env.TICLAWK_LOG_RUNTIME_PROMPTS)) return;
-
-  try {
-    const rootDir = process.env.TICLAWK_RUNTIME_PROMPT_LOG_DIR
-      || join(homedir(), '.ticlawk', 'prompt-logs');
-    const dir = join(rootDir, fileSafeId(binding?.id));
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const messageId = fileSafeId(inbound?.messageId);
-    const filePath = join(dir, `${stamp}-${messageId}.json`);
-    const payload = {
-      createdAt: new Date().toISOString(),
-      runtime: 'codex',
-      agentId: binding?.id || null,
-      conversationId: inbound?.conversationId || null,
-      messageId: inbound?.messageId || null,
-      target: inbound?.envelopeTarget || null,
-      action: inbound?.action || null,
-      sessionId: targetSessionId || null,
-      shouldRotate: Boolean(shouldRotate),
-      agentHome,
-      hashes: {
-        developerInstructionsSha256: sha256(developerInstructions),
-        messageSha256: sha256(message),
-      },
-      developerInstructions,
-      message,
-      input: input || null,
-    };
-    writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
-    debugLog('codex', 'prompt.snapshot', {
-      agentId: binding?.id,
-      conversationId: inbound?.conversationId,
-      messageId: inbound?.messageId,
-      target: inbound?.envelopeTarget,
-      path: filePath,
-      developerInstructionChars: String(developerInstructions || '').length,
-      messageChars: String(message || '').length,
-      developerInstructionsSha256: payload.hashes.developerInstructionsSha256,
-      messageSha256: payload.hashes.messageSha256,
-    });
-  } catch (err) {
-    debugError('codex', 'prompt.snapshot.failed', {
-      agentId: binding?.id,
-      conversationId: inbound?.conversationId,
-      messageId: inbound?.messageId,
-      error: err?.message || String(err),
-    });
-  }
-}
 
 export const codexRuntime = {
   name: 'codex',
@@ -222,42 +140,46 @@ export const codexRuntime = {
       ? (codexInput.find((item) => item?.type === 'text')?.text || inbound.text || '(image attached)')
       : inbound.text;
 
-    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
-    const shouldRotate = sessionScope.shouldRotate;
-    const targetSessionId = shouldRotate ? null : sessionScope.sessionId;
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, turnId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          turnId: turnId || null,
+          cwd: cwd || agentHome,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.message.delta',
+            worker_event_name: 'worker.message.delta',
+            delta: text,
+          },
+          logger: ctx.logger,
+        });
+      },
+    });
     try {
       const runtimeCodexPath = requireCodexPath(meta.codexPath || meta.runtimePath);
       const runtimeCodexVersion = getCodexRuntimeHealth(runtimeCodexPath).version || meta.codexVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId: targetSessionId,
+        sessionId: shouldRotate ? null : meta.sessionId,
         hostId: binding.runtime_host_id,
-        conversationId: inbound.conversationId,
-        messageId: inbound.messageId,
-        target: inbound.envelopeTarget,
-      });
-      const developerInstructions = buildStandingPrompt({ agentId: binding.id, inbound });
-      writePromptSnapshot({
-        binding,
-        inbound,
-        agentHome,
-        targetSessionId,
-        shouldRotate,
-        developerInstructions,
-        message,
-        input: codexInput,
       });
+      const developerInstructions = buildRuntimeBaseInstructions({ agentId: binding.id });
       const result = (shouldRotate || inbound.action === 'image' || shouldStreamRuntime(this.name, this))
-        ? await this.runTurnStream({ sessionId: targetSessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
             developerInstructions,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
-                emitWorkerEventBestEffort({
+                await emitWorkerEvent({
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || targetSessionId || binding.id,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
                   turnId: event.turnId || null,
                   cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
@@ -267,27 +189,34 @@ export const codexRuntime = {
                   },
                   logger: ctx.logger,
                 });
+              } else if (event?.type === 'message.delta' && event.text) {
+                deltaAggregator.push(event.text, {
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  turnId: event.turnId || null,
+                  cwd: agentHome,
+                });
               }
             },
           })
-        : await this.runTurn({ sessionId: targetSessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
           });
 
+      await deltaAggregator.flush();
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-        ...buildRuntimeSessionMetaPatch(meta, sessionScope, {
-          sessionId: result?.sessionId,
-          path: result?.path,
-        }),
+        sessionId: result?.sessionId || meta.sessionId,
+        path: result?.path || meta.path || null,
         runtimePath: runtimeCodexPath,
         codexPath: runtimeCodexPath,
         codexVersion: runtimeCodexVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      emitWorkerEventBestEffort({
+      await emitWorkerEvent({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || targetSessionId || binding.id,
+        sessionId: result?.sessionId || meta.sessionId || binding.id,
         turnId: result?.turnId || null,
         cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
@@ -299,6 +228,7 @@ export const codexRuntime = {
       });
       return true;
     } catch (err) {
+      await deltaAggregator.flush().catch(() => {});
       const failureInfo = err?.info || {
         ok: false,
         kind: 'exit-error',
@@ -313,11 +243,11 @@ export const codexRuntime = {
           lastGatewayFailureReason: failureInfo.errorMessage || err?.message || 'Codex app-server error',
         }, { status: 'degraded' }).catch(() => binding);
       }
-      emitWorkerEventBestEffort({
+      await emitWorkerEvent({
         adapter,
         binding: failureBinding,
         agent: this.name,
-        sessionId: targetSessionId || binding.id,
+        sessionId: meta.sessionId || binding.id,
         turnId: failureInfo?.turnId || null,
         cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
@@ -339,6 +269,24 @@ export const codexRuntime = {
     }
   },
 
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: ensureAgentHome(binding.id) || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
   sessionsDir: CODEX_SESSIONS_DIR,
   maxAgeMs: CODEX_MAX_AGE_MS,
 };

package/src/runtimes/codex/session.mjs

@@ -368,12 +368,14 @@ export function streamCodexPrompt({
     let finalText = '';
     let threadPath = null;
     const ignoredChildEventsLogged = new Set();
+    let eventChain = Promise.resolve();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      void Promise.resolve()
+      eventChain = eventChain
         .then(() => onEvent(event))
         .catch(() => {});
+      return eventChain;
     };
 
     const settle = (fn, value) => {
@@ -385,7 +387,9 @@ export function streamCodexPrompt({
       }
       pending.clear();
       try { child.kill('SIGTERM'); } catch {}
-      fn(value);
+      eventChain
+        .catch(() => {})
+        .finally(() => fn(value));
     };
 
     const send = (method, params = {}) => {
@@ -447,6 +451,12 @@ export function streamCodexPrompt({
         const delta = params?.delta;
         if (typeof delta === 'string' && delta && isRootContext(params)) {
           finalText += delta;
+          emit({
+            type: 'message.delta',
+            sessionId: rootThreadId,
+            turnId: rootTurnId,
+            text: delta,
+          });
         } else if (typeof delta === 'string' && delta) {
           logIgnoredChildEvent('codex.non-root-agent-delta', params);
         }

package/src/runtimes/openclaw/index.mjs

@@ -1,6 +1,5 @@
 import { reportSubprocessFailure, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
-import { getGoalTaskProtocolOverlayKey } from '../_shared/goal-task-protocol.mjs';
-import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
+import { buildRuntimeBaseInstructions } from '../_shared/runtime-base-instructions.mjs';
 import { GATEWAY_HOST, GATEWAY_PORT } from './identity.mjs';
 
 // Cheap availability probe used by the harness picker. We can't use
@@ -25,12 +24,11 @@ async function probeOpenClawGatewayHealth() {
 import { buildOpenClawSessionKey, normalizeOpenClawAgentId } from './target.mjs';
 import { askGateway, isGatewayReady, registerOpenClawChannel } from './gateway.mjs';
 
-// Tracks which (agentId, sessionKey, protocol overlay) combinations
-// already saw the standing prompt this process lifetime. OpenClaw's
-// gateway holds session state out of process, so we err on the side of
-// "inject on first observed overlay after daemon restart"; the gateway
-// dedupes redundant context.
-const standingPromptSeen = new Set();
+// Tracks which (agentId, sessionKey) pairs already saw the runtime base
+// instructions this process lifetime. OpenClaw's gateway holds session state
+// out of process, so we err on the side of "inject on first observed
+// turn after daemon restart"; the gateway dedupes redundant context.
+const runtimeBaseInstructionsSeen = new Set();
 import { addInFlight, recoverInFlightEntries, removeInFlight } from './inflight.mjs';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { extname } from 'node:path';
@@ -160,16 +158,16 @@ export const openClawRuntime = {
     const agentId = normalizeOpenClawAgentId(meta.agentId || binding.id);
     const sessionId = String(meta.sessionKey || buildOpenClawSessionKey(agentId)).trim();
 
-    // Inject the standing prompt on the first observed turn after a
-    // daemon start for this (agent, session, protocol overlay). OpenClaw
-    // has no separate "system prompt" parameter on the gateway, so we
-    // prepend through the prompt body.
-    const standingKey = `${agentId}|${sessionId}|${getGoalTaskProtocolOverlayKey({ agentId: binding.id, inbound })}`;
+    // Inject the runtime base instructions on the first observed turn after a
+    // daemon start for this (agent, session) pair. OpenClaw has no
+    // separate "system prompt" parameter on the gateway, so we prepend
+    // exactly once.
+    const runtimeBaseInstructionsKey = `${agentId}|${sessionId}`;
     let prompt = rawPrompt;
-    if (!standingPromptSeen.has(standingKey)) {
-      const standing = buildStandingPrompt({ agentId: binding.id, inbound });
-      prompt = `${standing}\n\n---\n\n${rawPrompt}`;
-      standingPromptSeen.add(standingKey);
+    if (!runtimeBaseInstructionsSeen.has(runtimeBaseInstructionsKey)) {
+      const baseInstructions = buildRuntimeBaseInstructions({ agentId: binding.id });
+      prompt = `${baseInstructions}\n\n---\n\n${rawPrompt}`;
+      runtimeBaseInstructionsSeen.add(runtimeBaseInstructionsKey);
     }
 
     if (inbound.messageId) {
@@ -238,6 +236,21 @@ export const openClawRuntime = {
     return entries.length;
   },
 
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    if (typeof ctx.adapter.emitEvent === 'function') {
+      await ctx.adapter.emitEvent(binding, {
+        agent: this.name,
+        sessionId: String(meta.sessionKey || buildOpenClawSessionKey(meta.agentId || binding.id)).trim(),
+        cwd: '',
+        event: {
+          hook_event_name: 'agent.run.end',
+          reason: 'connector.restart.reconcile',
+        },
+      });
+    }
+    return 1;
+  },
 };
 
 export default openClawRuntime;

package/src/runtimes/opencode/index.mjs

@@ -10,8 +10,7 @@
 import { existsSync } from 'node:fs';
 import { basename } from 'node:path';
 import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
-import { getGoalTaskProtocolOverlayKey } from '../_shared/goal-task-protocol.mjs';
-import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
+import { buildRuntimeBaseInstructions } from '../_shared/runtime-base-instructions.mjs';
 import { ensureAgentHome } from '../../core/agent-home.mjs';
 import {
   createOpenCodeSession,
@@ -25,18 +24,15 @@ import {
   requireOpenCodePath,
 } from './session.mjs';
 import { buildOpenCodeInputFromInbound } from '../../core/media/inbound.mjs';
-import { emitWorkerEventBestEffort } from '../../core/events/worker-events.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
+  createDeltaAggregator,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
-  resolveRuntimeSessionScope,
-  buildRuntimeSessionMetaPatch,
 } from '../../core/runtime-support.mjs';
 
-const standingPromptSeen = new Set();
-
 export const openCodeRuntime = {
   name: 'opencode',
 
@@ -51,8 +47,7 @@ export const openCodeRuntime = {
       message: text,
       opencodePath,
       agentEnv,
-      standingPrompt: opts.standingPrompt || null,
-      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
+      runtimeBaseInstructions: opts.runtimeBaseInstructions || null,
       files: opts.files,
       timeoutMs: opts.timeoutMs,
     });
@@ -65,8 +60,7 @@ export const openCodeRuntime = {
       message: text,
       opencodePath,
       agentEnv,
-      standingPrompt: opts.standingPrompt || null,
-      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
+      runtimeBaseInstructions: opts.runtimeBaseInstructions || null,
       files: opts.files,
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
@@ -162,39 +156,47 @@ export const openCodeRuntime = {
       // instruction so it has something to anchor on.
       message = captionText || 'Please analyze the attached image(s).';
     }
-    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
-    const shouldRotate = sessionScope.shouldRotate;
-    const targetSessionId = shouldRotate ? null : sessionScope.sessionId;
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          cwd: cwd || agentHome,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.message.delta',
+            worker_event_name: 'worker.message.delta',
+            delta: text,
+          },
+          logger: ctx.logger,
+        });
+      },
+    });
 
     try {
       const opencodePath = requireOpenCodePath(runtimeOpenCodePath);
       const opencodeVersion = getOpenCodeRuntimeHealth(opencodePath).version || meta.opencodeVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId: targetSessionId,
+        sessionId: meta.sessionId,
         hostId: binding.runtime_host_id,
-        conversationId: inbound.conversationId,
-        messageId: inbound.messageId,
-        target: inbound.envelopeTarget,
       });
-      const standingPrompt = buildStandingPrompt({ agentId: binding.id, inbound });
-      const protocolOverlayKey = getGoalTaskProtocolOverlayKey({ agentId: binding.id, inbound });
-      const standingPromptSeenKey = targetSessionId
-        ? `${binding.id}|${targetSessionId}|${protocolOverlayKey}`
-        : null;
-      const forceStandingPrompt = Boolean(standingPromptSeenKey && !standingPromptSeen.has(standingPromptSeenKey));
+      const runtimeBaseInstructions = buildRuntimeBaseInstructions({ agentId: binding.id });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId: targetSessionId, cwd: agentHome, opencodePath, agentEnv }, message, {
-            standingPrompt,
-            forceStandingPrompt,
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, opencodePath, agentEnv }, message, {
+            runtimeBaseInstructions,
             files,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
-                emitWorkerEventBestEffort({
+                await emitWorkerEvent({
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || targetSessionId || binding.id,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
                   cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -203,30 +205,31 @@ export const openCodeRuntime = {
                   },
                   logger: ctx.logger,
                 });
+              } else if (event?.type === 'message.delta' && event.text) {
+                deltaAggregator.push(event.text, {
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: agentHome,
+                });
               }
             },
           })
-        : await this.runTurn({ sessionId: targetSessionId, cwd: agentHome, opencodePath, agentEnv }, message, { files, standingPrompt, forceStandingPrompt });
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, opencodePath, agentEnv }, message, { files, runtimeBaseInstructions });
 
-      const observedSessionId = result?.sessionId || targetSessionId;
-      if (observedSessionId) {
-        standingPromptSeen.add(`${binding.id}|${observedSessionId}|${protocolOverlayKey}`);
-      }
+      await deltaAggregator.flush();
 
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-        ...buildRuntimeSessionMetaPatch(meta, sessionScope, {
-          sessionId: result?.sessionId,
-          path: result?.path,
-        }),
+        sessionId: result?.sessionId || meta.sessionId,
         runtimePath: opencodePath,
         opencodePath,
         opencodeVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      emitWorkerEventBestEffort({
+      await emitWorkerEvent({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || targetSessionId || binding.id,
+        sessionId: result?.sessionId || meta.sessionId || binding.id,
         cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -237,11 +240,12 @@ export const openCodeRuntime = {
       });
       return true;
     } catch (err) {
-      emitWorkerEventBestEffort({
+      await deltaAggregator.flush().catch(() => {});
+      await emitWorkerEvent({
         adapter,
         binding,
         agent: this.name,
-        sessionId: targetSessionId || binding.id,
+        sessionId: meta.sessionId || binding.id,
         cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -267,6 +271,24 @@ export const openCodeRuntime = {
     }
   },
 
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: ensureAgentHome(binding.id) || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
   dataDir: OPENCODE_DATA_DIR,
   maxAgeMs: OPENCODE_MAX_AGE_MS,
 };

package/src/runtimes/opencode/session.mjs

@@ -193,9 +193,10 @@ function buildOpenCodeRunArgs({ sessionId, message, files = [] }) {
 /**
  * Spawn `opencode run` and resolve with the final result.
  *
- * If `onEvent` is provided it is invoked for lifecycle events such as
- * `{ type: 'turn.started', sessionId }`. Token deltas are kept local to
- * build the final text and are not emitted to the caller.
+ * If `onEvent` is provided it is invoked for each parsed event during
+ * the turn — `{ type: 'turn.started', sessionId }`,
+ * `{ type: 'message.delta', sessionId, text }`, etc. — so callers can
+ * forward typing indicators / partial text to the chat client.
  *
  * Resolves with `{ sessionId, cwd, text, durationMs }` on success.
  * Rejects with an Error whose `.info` carries `{ ok: false, kind, ... }`
@@ -208,17 +209,16 @@ export function runOpenCodePrompt({
   files = [],
   opencodePath = null,
   agentEnv = null,
-  standingPrompt = null,
-  forceStandingPrompt = false,
+  runtimeBaseInstructions = null,
   timeoutMs = Number(process.env.OPENCODE_RUN_TIMEOUT_MS || DEFAULT_OPENCODE_RUN_TIMEOUT_MS),
   onEvent,
 }) {
   // opencode has no documented `--system` flag, so we prepend the
-  // standing prompt to the first-turn message body. Callers may force a
-  // resumed-session injection when the selected protocol overlay changes
-  // or this daemon process has not yet observed the session.
-  const finalMessage = standingPrompt && (!sessionId || forceStandingPrompt)
-    ? `${standingPrompt}\n\n---\n\n${message}`
+  // runtime base instructions to the first-turn message body. Resumed sessions
+  // (sessionId set) skip injection because the model already saw it
+  // on the originating turn.
+  const finalMessage = runtimeBaseInstructions && !sessionId
+    ? `${runtimeBaseInstructions}\n\n---\n\n${message}`
     : message;
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
@@ -245,19 +245,18 @@ export function runOpenCodePrompt({
     let lastError = null;
     let settled = false;
     let turnStartedEmitted = false;
+    let eventChain = Promise.resolve();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      void Promise.resolve()
-        .then(() => onEvent(event))
-        .catch(() => {});
+      eventChain = eventChain.then(() => onEvent(event)).catch(() => {});
     };
 
     const settle = (fn, value) => {
       if (settled) return;
       settled = true;
       if (timeout) clearTimeout(timeout);
-      fn(value);
+      eventChain.catch(() => {}).finally(() => fn(value));
     };
 
     const handleEvent = (event) => {
@@ -273,6 +272,7 @@ export function runOpenCodePrompt({
         const delta = extractEventText(event);
         if (delta) {
           finalText += delta;
+          emit({ type: 'message.delta', sessionId: activeSessionId, text: delta });
         }
       }