ticlawk 0.1.16-dev.9 → 0.1.17-dev.1

package/src/runtimes/pi/index.mjs

@@ -6,6 +6,7 @@
 
 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 { ensureAgentHome } from '../../core/agent-home.mjs';
 import {
@@ -18,15 +19,18 @@ import {
   requirePiPath,
   runPiPrompt,
 } from './session.mjs';
-import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
+import { emitWorkerEventBestEffort } 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 piRuntime = {
   name: 'pi',
 
@@ -39,6 +43,7 @@ export const piRuntime = {
       piPath,
       agentEnv,
       standingPrompt: opts.standingPrompt || null,
+      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
       timeoutMs: opts.timeoutMs,
     });
   },
@@ -52,6 +57,7 @@ export const piRuntime = {
       piPath,
       agentEnv,
       standingPrompt: opts.standingPrompt || null,
+      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
     });
@@ -128,46 +134,39 @@ export const piRuntime = {
       message = captionText || 'Please analyze the attached image(s).';
     }
 
-    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,
-        });
-      },
-    });
+    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
+    const shouldRotate = sessionScope.shouldRotate;
+    const targetSessionId = shouldRotate ? null : sessionScope.sessionId;
 
     try {
       const runtimePiPath = requirePiPath(meta.piPath || meta.runtimePath);
       const runtimePiVersion = getPiRuntimeHealth(runtimePiPath).version || meta.piVersion || 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 standingPrompt = buildStandingPrompt({ agentId: binding.id });
+      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 result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, {
+        ? await this.runTurnStream({ sessionId: targetSessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, {
             standingPrompt,
+            forceStandingPrompt,
             images,
             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,
                   cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -176,31 +175,29 @@ export const piRuntime = {
                   },
                   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: shouldRotate ? null : meta.sessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, { images, standingPrompt });
+        : await this.runTurn({ sessionId: targetSessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, { images, standingPrompt, forceStandingPrompt });
 
-      await deltaAggregator.flush();
+      const observedSessionId = result?.sessionId || targetSessionId;
+      if (observedSessionId) {
+        standingPromptSeen.add(`${binding.id}|${observedSessionId}|${protocolOverlayKey}`);
+      }
       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: runtimePiPath,
         piPath: runtimePiPath,
         piVersion: runtimePiVersion,
-        rotatePending: false,
-        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      await emitWorkerEvent({
+      emitWorkerEventBestEffort({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || meta.sessionId || binding.id,
+        sessionId: result?.sessionId || targetSessionId || binding.id,
         cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -211,12 +208,11 @@ export const piRuntime = {
       });
       return true;
     } catch (err) {
-      await deltaAggregator.flush().catch(() => {});
-      await emitWorkerEvent({
+      emitWorkerEventBestEffort({
         adapter,
         binding,
         agent: this.name,
-        sessionId: meta.sessionId || binding.id,
+        sessionId: targetSessionId || binding.id,
         cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -242,24 +238,6 @@ export const piRuntime = {
     }
   },
 
-  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: PI_SESSIONS_DIR,
   maxAgeMs: PI_MAX_AGE_MS,
 };

package/src/runtimes/pi/session.mjs

@@ -197,11 +197,14 @@ export function runPiPrompt({
   piPath = null,
   agentEnv = null,
   standingPrompt = null,
+  forceStandingPrompt = false,
   timeoutMs = Number(process.env.PI_RUN_TIMEOUT_MS || DEFAULT_PI_RUN_TIMEOUT_MS),
   onEvent,
 }) {
-  // pi has no documented system-prompt flag — prepend on first turn.
-  const finalMessage = standingPrompt && !sessionId
+  // pi has no documented system-prompt flag. Prepend on first turn, and
+  // let callers force one resumed-session injection for a newly selected
+  // protocol overlay.
+  const finalMessage = standingPrompt && (!sessionId || forceStandingPrompt)
     ? `${standingPrompt}\n\n---\n\n${message}`
     : message;
   return new Promise((resolve, reject) => {
@@ -220,12 +223,13 @@ export function runPiPrompt({
     let activeSessionFile = null;
     let finalText = '';
     let settled = false;
-    let eventChain = Promise.resolve();
     const pending = new Map();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      eventChain = eventChain.then(() => onEvent(event)).catch(() => {});
+      void Promise.resolve()
+        .then(() => onEvent(event))
+        .catch(() => {});
     };
 
     const settle = (fn, value) => {
@@ -237,7 +241,7 @@ export function runPiPrompt({
       }
       pending.clear();
       try { child.kill('SIGTERM'); } catch {}
-      eventChain.catch(() => {}).finally(() => fn(value));
+      fn(value);
     };
 
     const sendRaw = (payload) => {
@@ -305,7 +309,6 @@ export function runPiPrompt({
           const delta = extractDeltaFromEvent(event);
           if (delta) {
             finalText += delta;
-            emit({ type: 'message.delta', sessionId: activeSessionId, text: delta });
           }
           return;
         }

package/ticlawk.mjs

@@ -211,35 +211,6 @@ async function recoverAllRuntimes(runtimeList, adapter) {
   }
 }
 
-async function reconcileBindingsAfterRestart(runtimes, adapter) {
-  const hostId = getHostId();
-  for (const binding of listBindings({ adapter: adapter.id })) {
-    if (!belongsToRuntimeHost(binding, hostId)) {
-      logger.debugError('core', 'binding.reconcile-host-mismatch', {
-        bindingId: binding.id,
-        adapter: binding.adapter,
-        hostId,
-        runtime_host_id: getBindingRuntimeHostId(binding),
-      });
-      continue;
-    }
-    const runtime = binding.runtime ? runtimes[binding.runtime] : null;
-    if (typeof runtime?.reconcileAfterRestart !== 'function') continue;
-    try {
-      await runtime.reconcileAfterRestart(binding, {
-        adapter,
-        logger,
-      });
-    } catch (err) {
-      logger.debugError('startup', 'reconcileAfterRestart.failed', {
-        runtime: binding.runtime,
-        bindingId: binding.id,
-        error: err?.message || String(err),
-      });
-    }
-  }
-}
-
 export async function startTiclawk() {
   if (started) return;
   started = true;
@@ -278,7 +249,6 @@ export async function startTiclawk() {
   });
   startReminderTicker();
   await recoverAllRuntimes(runtimeList, adapter);
-  await reconcileBindingsAfterRestart(runtimes, adapter);
   await adapter.start();
 }