ticlawk 0.1.16-dev.3 → 0.1.16-dev.31

package/src/runtimes/claude-code/index.mjs

@@ -12,7 +12,6 @@ import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
 import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
 import { ensureAgentHome } from '../../core/agent-home.mjs';
 import {
-  createCCSession,
   getClaudeCodeRuntimeHealth,
   runCCPrompt,
   streamCCPrompt,
@@ -24,29 +23,22 @@ import {
 } from './session.mjs';
 import { discoverSessions } from './transcripts.mjs';
 import { buildImageMessageFromInbound } from '../../core/media/inbound.mjs';
-import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
-import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
+import { emitWorkerEventBestEffort } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
-  sendAdapterMessage,
-  recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
+  resolveRuntimeSessionScope,
+  buildRuntimeSessionMetaPatch,
 } from '../../core/runtime-support.mjs';
 
 export const claudeCodeRuntime = {
   name: 'claude_code',
 
-  // Start a new Claude session without blocking on local transcript
-  // discovery. The live turn path trusts stdout/session_id; transcript
-  // indexing is a separate concern.
-  async createSession({ projectDir, text, claudePath }) {
-    return createCCSession({ projectDir, message: text, claudePath });
-  },
-
-  // Run a Claude turn and wait for the final result on stdout. This is
-  // the worker-first path used by the adapter for direct reply delivery.
+  // Run a Claude turn and wait for the final result on stdout. Used by
+  // deliverTurn when streaming is disabled; both fresh sessions
+  // (sessionId=null) and resumed sessions go through here.
   runTurn({ sessionId, projectDir, claudePath, agentEnv }, text, opts = {}) {
     return runCCPrompt({
       sessionId,
@@ -130,117 +122,49 @@ export const claudeCodeRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    // slock-style: cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
+    // cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
     const projectDir = ensureAgentHome(binding.id, {
       displayName: binding.display_name || binding.name || null,
     });
-    const sessionId = meta.sessionId || binding.id;
     const runtimeClaudePath = meta.claudePath || meta.runtimePath || null;
 
     const message = inbound.action === 'image'
       ? await buildImageMessageFromInbound(inbound, 'claude-code')
       : inbound.text;
 
-    const shouldRotate = !meta.sessionId || meta.rotatePending;
-    if (shouldRotate) {
-      await emitWorkerEvent({
-        adapter,
-        binding,
-        agent: this.name,
-        sessionId: sessionId || binding.id,
-        cwd: projectDir,
-        replyToMessageId: inbound.messageId || null,
-        event: {
-          hook_event_name: 'worker.turn.start',
-          worker_event_name: 'worker.turn.start',
-        },
-        logger: ctx.logger,
-      });
-      try {
-        const claudePath = requireClaudePath(runtimeClaudePath);
-        const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
-        const created = await this.createSession({ projectDir, text: message, claudePath });
-        const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-          sessionId: created.sessionId,
-          path: null,
-          runtimePath: claudePath,
-          claudePath,
-          claudeVersion,
-          rotatePending: false,
-          lastRotatedAt: new Date().toISOString(),
-        }, { status: 'connected' });
-        if (created.resultText && created.resultText.trim()) {
-          await sendAdapterMessage(adapter, nextBinding, {
-            type: 'assistant',
-            text: created.resultText,
-            media: [],
-            replyToMessageId: inbound.messageId || null,
-          });
-        }
-        await emitWorkerEvent({
-          adapter,
-          binding: nextBinding,
-          agent: this.name,
-          sessionId: created.sessionId,
-          cwd: projectDir,
-          replyToMessageId: inbound.messageId || null,
-          event: {
-            hook_event_name: 'Stop',
-            worker_event_name: 'worker.turn.complete',
-          },
-          logger: ctx.logger,
-        });
-        return true;
-      } catch (err) {
-        await emitWorkerEvent({
-          adapter,
-          binding,
-          agent: this.name,
-          sessionId: sessionId || binding.id,
-          cwd: projectDir,
-          replyToMessageId: inbound.messageId || null,
-          event: {
-            hook_event_name: 'worker.turn.error',
-            worker_event_name: 'worker.turn.error',
-            error: err?.message || 'Claude Code failed',
-          },
-          logger: ctx.logger,
-        });
-        await reportSubprocessFailure({
-          adapter,
-          binding,
-          inbound,
-          runtimeName: 'Claude Code',
-          info: err?.info || {
-            ok: false,
-            kind: 'exit-error',
-            errorMessage: err?.message || 'Claude Code failed',
-            durationMs: 0,
-          },
-        });
-        return terminalRuntimeFailure(err?.message || 'Claude Code failed');
-      }
-    }
+    // shouldRotate=true means this conversation has no runtime session
+    // yet, or the agent was reset and all scoped sessions are invalid.
+    // We pass sessionId=null so `claude` creates a fresh session; the new
+    // session_id is captured from stream events and persisted below.
+    // Unifying rotate + non-rotate into one path means the standing prompt
+    // is always attached, so the agent uses the CLI to reply on every
+    // turn — including the first.
+    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
+    const targetSessionId = sessionScope.shouldRotate ? null : sessionScope.sessionId;
+    const errEventSessionId = targetSessionId || binding.id;
 
     try {
       const claudePath = requireClaudePath(runtimeClaudePath);
       const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId,
+        sessionId: targetSessionId,
         hostId: binding.runtime_host_id,
+        conversationId: inbound.conversationId,
+        messageId: inbound.messageId,
+        target: inbound.envelopeTarget,
       });
-      const appendSystemPrompt = buildStandingPrompt({ agentId: binding.id });
+      const appendSystemPrompt = buildStandingPrompt({ agentId: binding.id, inbound });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId, projectDir, claudePath, agentEnv }, message, {
+        ? await this.runTurnStream({ sessionId: targetSessionId, projectDir, claudePath, agentEnv }, message, {
             appendSystemPrompt,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
-                await emitWorkerEvent({
+                emitWorkerEventBestEffort({
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || sessionId,
+                  sessionId: event.sessionId || targetSessionId || binding.id,
                   cwd: projectDir,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -249,40 +173,23 @@ export const claudeCodeRuntime = {
                   },
                   logger: ctx.logger,
                 });
-              } else if (event?.type === 'message.delta' && event.text) {
-                await emitWorkerEvent({
-                  adapter,
-                  binding,
-                  agent: this.name,
-                  sessionId: event.sessionId || sessionId,
-                  cwd: projectDir,
-                  replyToMessageId: inbound.messageId || null,
-                  event: {
-                    hook_event_name: 'worker.message.delta',
-                    worker_event_name: 'worker.message.delta',
-                    delta: event.text,
-                  },
-                  logger: ctx.logger,
-                });
               }
             },
           })
-        : await this.runTurn({ sessionId, projectDir, claudePath, agentEnv }, message, { appendSystemPrompt });
+        : await this.runTurn({ sessionId: targetSessionId, projectDir, claudePath, agentEnv }, message, { appendSystemPrompt });
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-        sessionId: result?.sessionId || meta.sessionId,
+        ...buildRuntimeSessionMetaPatch(meta, sessionScope, {
+          sessionId: result?.sessionId,
+        }),
         runtimePath: claudePath,
         claudePath,
         claudeVersion,
       }, { status: 'connected' });
-      await recordActivity(adapter, nextBinding, inbound, {
-        ...result,
-        media: normalizeOutboundMedia(result),
-      });
-      await emitWorkerEvent({
+      emitWorkerEventBestEffort({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || sessionId,
+        sessionId: result?.sessionId || targetSessionId || binding.id,
         cwd: projectDir,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -293,11 +200,11 @@ export const claudeCodeRuntime = {
       });
       return true;
     } catch (err) {
-      await emitWorkerEvent({
+      emitWorkerEventBestEffort({
         adapter,
         binding,
         agent: this.name,
-        sessionId,
+        sessionId: errEventSessionId,
         cwd: projectDir,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -325,7 +232,7 @@ export const claudeCodeRuntime = {
 
   async reconcileAfterRestart(binding, ctx) {
     const meta = binding.runtimeMeta || {};
-    await emitWorkerEvent({
+    emitWorkerEventBestEffort({
       adapter: ctx.adapter,
       binding,
       agent: this.name,

package/src/runtimes/claude-code/session.mjs

@@ -231,23 +231,19 @@ export function streamCCPrompt({
     let seenTurnStart = false;
     let activeSessionId = sessionId || null;
     let finalText = '';
-    let eventChain = Promise.resolve();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      eventChain = eventChain
+      void Promise.resolve()
         .then(() => onEvent(event))
         .catch(() => {});
-      return eventChain;
     };
 
     const settle = (fn, value) => {
       if (settled) return;
       settled = true;
       if (timeout) clearTimeout(timeout);
-      eventChain
-        .catch(() => {})
-        .finally(() => fn(value));
+      fn(value);
     };
 
     const parseLine = (line) => {
@@ -267,7 +263,6 @@ export function streamCCPrompt({
         const deltaText = parsed.event?.delta?.text;
         if (typeof deltaText === 'string' && deltaText) {
           finalText += deltaText;
-          emit({ type: 'message.delta', sessionId: activeSessionId, text: deltaText });
         }
         return;
       }

package/src/runtimes/codex/index.mjs

@@ -5,7 +5,10 @@
  * and discover local sessions.
  */
 
-import { basename } from 'node:path';
+import { createHash } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
 import {
   createCodexSession,
   runCodexPrompt,
@@ -18,21 +21,97 @@ import {
   requireCodexPath,
 } from './session.mjs';
 import { buildCodexInputFromInbound } from '../../core/media/inbound.mjs';
-import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
-import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
+import { emitWorkerEventBestEffort } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
-  createDeltaAggregator,
-  sendAdapterMessage,
-  recordActivity,
   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 { 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',
@@ -130,7 +209,7 @@ export const codexRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    // slock-style: cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
+    // cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
     // ensureAgentHome creates it + seeds MEMORY.md if missing.
     const agentHome = ensureAgentHome(binding.id, {
       displayName: binding.display_name || binding.name || null,
@@ -143,46 +222,42 @@ export const codexRuntime = {
       ? (codexInput.find((item) => item?.type === 'text')?.text || inbound.text || '(image attached)')
       : inbound.text;
 
-    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,
-        });
-      },
-    });
+    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
+    const shouldRotate = sessionScope.shouldRotate;
+    const targetSessionId = shouldRotate ? null : sessionScope.sessionId;
     try {
       const runtimeCodexPath = requireCodexPath(meta.codexPath || meta.runtimePath);
       const runtimeCodexVersion = getCodexRuntimeHealth(runtimeCodexPath).version || meta.codexVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId: meta.sessionId,
+        sessionId: targetSessionId,
         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 = buildStandingPrompt({ agentId: binding.id });
       const result = (shouldRotate || inbound.action === 'image' || shouldStreamRuntime(this.name, this))
-        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
+        ? await this.runTurnStream({ sessionId: targetSessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
             developerInstructions,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
-                await emitWorkerEvent({
+                emitWorkerEventBestEffort({
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  sessionId: event.sessionId || targetSessionId || binding.id,
                   turnId: event.turnId || null,
                   cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
@@ -192,38 +267,27 @@ 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: meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
+        : await this.runTurn({ sessionId: targetSessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
           });
 
-      await deltaAggregator.flush();
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-        sessionId: result?.sessionId || meta.sessionId,
-        path: result?.path || meta.path || null,
+        ...buildRuntimeSessionMetaPatch(meta, sessionScope, {
+          sessionId: result?.sessionId,
+          path: result?.path,
+        }),
         runtimePath: runtimeCodexPath,
         codexPath: runtimeCodexPath,
         codexVersion: runtimeCodexVersion,
-        rotatePending: false,
-        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      await recordActivity(adapter, nextBinding, inbound, {
-        ...result,
-        media: normalizeOutboundMedia(result),
-      });
-      await emitWorkerEvent({
+      emitWorkerEventBestEffort({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || meta.sessionId || binding.id,
+        sessionId: result?.sessionId || targetSessionId || binding.id,
         turnId: result?.turnId || null,
         cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
@@ -235,7 +299,6 @@ export const codexRuntime = {
       });
       return true;
     } catch (err) {
-      await deltaAggregator.flush().catch(() => {});
       const failureInfo = err?.info || {
         ok: false,
         kind: 'exit-error',
@@ -250,11 +313,11 @@ export const codexRuntime = {
           lastGatewayFailureReason: failureInfo.errorMessage || err?.message || 'Codex app-server error',
         }, { status: 'degraded' }).catch(() => binding);
       }
-      await emitWorkerEvent({
+      emitWorkerEventBestEffort({
         adapter,
         binding: failureBinding,
         agent: this.name,
-        sessionId: meta.sessionId || binding.id,
+        sessionId: targetSessionId || binding.id,
         turnId: failureInfo?.turnId || null,
         cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
@@ -278,7 +341,7 @@ export const codexRuntime = {
 
   async reconcileAfterRestart(binding, ctx) {
     const meta = binding.runtimeMeta || {};
-    await emitWorkerEvent({
+    emitWorkerEventBestEffort({
       adapter: ctx.adapter,
       binding,
       agent: this.name,

package/src/runtimes/codex/session.mjs

@@ -368,14 +368,12 @@ export function streamCodexPrompt({
     let finalText = '';
     let threadPath = null;
     const ignoredChildEventsLogged = new Set();
-    let eventChain = Promise.resolve();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      eventChain = eventChain
+      void Promise.resolve()
         .then(() => onEvent(event))
         .catch(() => {});
-      return eventChain;
     };
 
     const settle = (fn, value) => {
@@ -387,9 +385,7 @@ export function streamCodexPrompt({
       }
       pending.clear();
       try { child.kill('SIGTERM'); } catch {}
-      eventChain
-        .catch(() => {})
-        .finally(() => fn(value));
+      fn(value);
     };
 
     const send = (method, params = {}) => {
@@ -451,12 +447,6 @@ 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,5 +1,5 @@
-import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
-import { reportSubprocessFailure, sendAdapterMessage, recordActivity, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
+import { reportSubprocessFailure, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
+import { getGoalTaskProtocolOverlayKey } from '../_shared/goal-task-protocol.mjs';
 import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
 import { GATEWAY_HOST, GATEWAY_PORT } from './identity.mjs';
 
@@ -25,10 +25,11 @@ async function probeOpenClawGatewayHealth() {
 import { buildOpenClawSessionKey, normalizeOpenClawAgentId } from './target.mjs';
 import { askGateway, isGatewayReady, registerOpenClawChannel } from './gateway.mjs';
 
-// Tracks which (agentId, sessionKey) pairs 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
-// turn after daemon restart"; the gateway dedupes redundant context.
+// 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();
 import { addInFlight, recoverInFlightEntries, removeInFlight } from './inflight.mjs';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
@@ -160,13 +161,13 @@ export const openClawRuntime = {
     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) pair. OpenClaw has no
-    // separate "system prompt" parameter on the gateway, so we prepend
-    // exactly once.
-    const standingKey = `${agentId}|${sessionId}`;
+    // 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 })}`;
     let prompt = rawPrompt;
     if (!standingPromptSeen.has(standingKey)) {
-      const standing = buildStandingPrompt({ agentId: binding.id });
+      const standing = buildStandingPrompt({ agentId: binding.id, inbound });
       prompt = `${standing}\n\n---\n\n${rawPrompt}`;
       standingPromptSeen.add(standingKey);
     }
@@ -192,10 +193,6 @@ export const openClawRuntime = {
           });
         },
       });
-      await recordActivity(adapter, binding, inbound, {
-        ...result,
-        media: normalizeOutboundMedia(result),
-      });
       return true;
     } catch (err) {
       if (typeof adapter.emitEvent === 'function') {
@@ -233,18 +230,11 @@ export const openClawRuntime = {
     }
   },
 
-  async recoverInFlight(ctx) {
+  async recoverInFlight() {
+    // Just drain the persisted in-flight set — the user-facing notice
+    // that used to surface here went through the dead chat-projection
+    // path. OpenClaw is non-primary; this no-ops cleanly for now.
     const entries = recoverInFlightEntries();
-    for (const entry of entries) {
-      const binding = ctx.getBinding(entry.bindingId);
-      if (!binding) continue;
-      await sendAdapterMessage(ctx.adapter, binding, {
-        type: 'assistant',
-        text: '⚠️ Lost while ticlawk restarted.\n\nThis OpenClaw message was in flight when ticlawk restarted. Please retry your message.',
-        media: [],
-        replyToMessageId: entry.messageId || null,
-      }).catch(() => {});
-    }
     return entries.length;
   },