ticlawk 0.1.15 → 0.1.16-dev.2

package/src/adapters/ticlawk/index.mjs

@@ -2,14 +2,13 @@ import { parseOptionArgs } from '../../core/argv.mjs';
 import { createHash, randomBytes } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { basename } from 'node:path';
-import { AF_ADAPTER_KEY, loadPersistentConfig, persistConfig, TICLAWK_CONNECTOR_API_KEY, TICLAWK_CONNECTOR_WS_URL } from '../../core/config.mjs';
+import { loadPersistentConfig, persistConfig, TICLAWK_CONNECTOR_API_KEY, TICLAWK_CONNECTOR_WS_URL } from '../../core/config.mjs';
 import { belongsToRuntimeHost, getBindingRuntimeHostId, getHostId, getHostLabel } from '../../core/host-id.mjs';
 import { debugError, debugLog } from '../../core/logger.mjs';
 import { getActiveProfile, ensureLegacyProfile, readProfileMeta, saveAndActivateProfile } from '../../core/profiles.mjs';
 import { isTerminalRuntimeFailure } from '../../core/runtime-support.mjs';
 import { clearUpdateRequiredState, readUpdateState, setUpdateRequiredState } from '../../core/update-state.mjs';
 import { isManagedInstall, startDetachedSelfUpdate } from '../../core/update.mjs';
-import { resolveOpenClawWorkspace } from '../../runtimes/openclaw/target.mjs';
 import * as api from './api.mjs';
 import { processAndSaveResult } from './cards.mjs';
 import { persistApiCredential } from './credentials.mjs';
@@ -45,13 +44,132 @@ function normalizeInboundMediaAssets(msg) {
     .filter(Boolean);
 }
 
-function normalizeInboundMessage(msg) {
+function buildEnvelopeTarget(msg) {
+  const convType = msg.conversation_type || 'dm';
+  const conversationId = msg.conversation_id || '';
+  const senderHandle = msg.sender_display_name || msg.sender_user_id || msg.sender_agent_id || '';
+  if (convType === 'dm') {
+    return senderHandle ? `dm:@${senderHandle}` : `dm:${conversationId}`;
+  }
+  if (convType === 'thread') {
+    const groupName = msg.conversation_name || conversationId;
+    const threadRoot = msg.thread_root_message_id || msg.message_id || '';
+    return `#${groupName}:${threadRoot}`;
+  }
+  // group
+  const groupName = msg.conversation_name || conversationId;
+  return `#${groupName}`;
+}
+
+function buildTaskSuffix(msg) {
+  if (msg.task_number == null) return '';
+  const status = msg.task_status || 'todo';
+  const parts = [`task #${msg.task_number} status=${status}`];
+  if (msg.task_assignee_agent_id || msg.task_assignee_user_id) {
+    const t = msg.task_assignee_type || 'agent';
+    const id = msg.task_assignee_agent_id || msg.task_assignee_user_id;
+    parts.push(`assignee=${t}:${id}`);
+  }
+  if (msg.task_title) {
+    parts.push(`title=${JSON.stringify(msg.task_title)}`);
+  }
+  return ` [${parts.join(' ')}]`;
+}
+
+function buildReactionsSuffix(msg) {
+  const entries = Array.isArray(msg.reactions_summary) ? msg.reactions_summary : [];
+  if (entries.length === 0) return '';
+  return ` [reactions: ${entries.join('; ')}]`;
+}
+
+function buildEnvelopeHeader(msg) {
+  const target = buildEnvelopeTarget(msg);
+  const msgId = msg.id || msg.message_id || '';
+  const seq = msg.seq != null ? msg.seq : '';
+  const time = msg.created_at || new Date().toISOString();
+  const type = msg.sender_type || 'human';
+  const sender = msg.sender_display_name || msg.sender_user_id || msg.sender_agent_id || 'unknown';
+  // `reason` tells the agent how this delivery was routed: 'mention'
+  // / 'assignment' = you were directly addressed → respond by default;
+  // 'ambient' = you are in the room and saw it → respond only if
+  // clearly the right responder; 'dm' / 'thread_follow' / 'manual' =
+  // the legacy direct paths. The agent's behaviour split is in the
+  // standing prompt; we just surface the field.
+  const reason = msg.reason ? ` reason=${msg.reason}` : '';
+  return `[target=${target} msg=${msgId} seq=${seq} time=${time} type=${type}${reason}] @${sender}:`;
+}
+
+function buildGroupContextBlock(msg) {
+  // Only useful in groups — DMs don't need group-purpose context.
+  if ((msg.conversation_type || 'dm') !== 'group') return '';
+  const lines = [];
+  const name = msg.conversation_name || msg.conversation_display_name || '';
+  if (name) lines.push(`name: ${name}`);
+  const description = (msg.conversation_description || '').trim();
+  if (description) lines.push(`purpose: ${description}`);
+  if (lines.length === 0) return '';
+  return [
+    'Group context:',
+    ...lines.map((l) => `  ${l}`),
+    'Use `ticlawk group members --target <target>` if you need to see who else is here.',
+  ].join('\n');
+}
+
+// Wrap each per-turn message with an explicit reply instruction so the
+// runtime LLM never has to remember the standing prompt to figure out
+// HOW to reply. Codex in particular treats the developerInstructions as
+// background and ignores the chat-send pattern without this per-turn
+// nudge (Slock does the same — see chunk-M4A5QPUN.js dynamicReplyInstruction).
+function buildWakePromptText({ envelopeHeader, target, rawText, groupContext }) {
+  const body = `${envelopeHeader} ${rawText || ''}`.trim();
+  const lines = ['New message received:', '', body];
+  if (groupContext) {
+    lines.push('', groupContext);
+  }
+  lines.push(
+    '',
+    `Respond as appropriate — reply using \`ticlawk message send --target "${target}"\` (body via stdin / heredoc), or take action as needed. Complete ALL your work before stopping.`,
+    'Reply in the channel or create/reply in a thread as appropriate; use each message\'s `target` and `msg` fields to choose the exact target.',
+    '',
+    'IMPORTANT: If the message requires multi-step work (research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done — only stop when you have NO more work to do. The daemon will wake you again automatically when new messages arrive.',
+  );
+  return lines.join('\n');
+}
+
+export function normalizeInboundMessage(msg) {
+  // Claimed delivery rows carry the recipient agent id; legacy messages
+  // (history sync, manual inserts) may still use plain agent_id. Prefer
+  // the new field but fall back so the same normalizer works for both.
+  const recipientAgentId = msg.recipient_agent_id || '';
   const messageId = msg.id || msg.message_id || null;
+  const deliveryId = msg.delivery_id || null;
   const media = normalizeInboundMediaAssets(msg);
+  const rawText = msg.text || '';
+  const enriched = { ...msg, id: messageId };
+  const baseHeader = buildEnvelopeHeader(enriched);
+  // Task + reactions suffixes are appended INSIDE the envelope so an
+  // agent can see at a glance whether a message is already claimed and
+  // who has already acknowledged it — same shape as slock's incoming
+  // message render (`[task #N status=… assignee=…]` + `[reactions: …]`).
+  const taskSuffix = buildTaskSuffix(enriched);
+  const reactionsSuffix = buildReactionsSuffix(enriched);
+  const header = baseHeader + taskSuffix + reactionsSuffix;
+  const target = buildEnvelopeTarget(enriched);
+  const groupContext = buildGroupContextBlock(enriched);
+  const text = header
+    ? buildWakePromptText({ envelopeHeader: header, target, rawText, groupContext })
+    : rawText;
   return {
-    bindingId: msg.agent_id || '',
+    bindingId: recipientAgentId,
     messageId,
-    text: msg.text || '',
+    deliveryId,
+    conversationId: msg.conversation_id || null,
+    seq: msg.seq != null ? Number(msg.seq) : null,
+    senderType: msg.sender_type || 'human',
+    envelopeHeader: header,
+    envelopeTarget: target,
+    text,
+    rawText,
     action: msg.action || (media.length > 0 ? 'image' : 'task'),
     media,
     raw: {
@@ -65,10 +183,6 @@ function getBindingSessionId(binding) {
   return binding?.runtimeMeta?.sessionId || binding?.runtimeMeta?.sessionKey || binding?.runtimeMeta?.agentId || binding?.id || null;
 }
 
-function getWorkdir(meta = {}) {
-  return String(meta.workdir || meta.projectDir || meta.cwd || '').trim();
-}
-
 function getRuntimeVersion(bindingOrMeta) {
   const value = bindingOrMeta?.runtimeMeta?.runtimeVersion ?? bindingOrMeta?.runtimeVersion ?? bindingOrMeta?.agent_runtime_version ?? null;
   return Number.isInteger(value) ? Number(value) : null;
@@ -91,58 +205,104 @@ function getRuntimeHostLabelFromPayload(payload) {
 }
 
 function getAgentIdFromPayload(payload) {
-  return String(payload?.agent_id || payload?.agentId || '').trim();
+  // claim_pending_deliveries is the canonical source and returns
+  // `recipient_agent_id`. The historical fallbacks (`agent_id`,
+  // `agentId`) were left in by an earlier partial cleanup but they
+  // never fire against the current schema — dead branches.
+  return String(payload?.recipient_agent_id || '').trim();
 }
 
-function buildBindingFromClaimedMessage(msg) {
-  const agentId = getAgentIdFromPayload(msg);
-  const runtime = msg.agent_service_type || msg.service_type;
-  const rawMeta = msg.agent_meta || msg.meta;
-  const sourceMeta = (rawMeta && typeof rawMeta === 'object') ? { ...rawMeta } : {};
-  const fallbackWorkdir = runtime === 'openclaw' && sourceMeta.agentId
-    ? resolveOpenClawWorkspace(sourceMeta.agentId)
-    : '';
-  const workdir = getWorkdir(sourceMeta) || fallbackWorkdir;
-  if (workdir) {
-    sourceMeta.workdir = workdir;
-    sourceMeta.projectDir = sourceMeta.projectDir || workdir;
-    sourceMeta.cwd = sourceMeta.cwd || workdir;
+// Whitelist of meta keys runtimes actually consume. Anything else in
+// the source row's meta blob is dropped on the floor so stale fields
+// (like the post-Y2 workdir/cwd/projectDir leftovers) can't sneak
+// back into runtimeMeta and confuse downstream code.
+const RUNTIME_META_KEYS = [
+  'sessionId',
+  'path',
+  'runtimePath',
+  'rotatePending',
+  'lastRotatedAt',
+  // claude_code
+  'claudePath',
+  'claudeVersion',
+  'project',
+  // codex
+  'codexPath',
+  'codexVersion',
+  // opencode
+  'opencodePath',
+  'opencodeVersion',
+  // pi
+  'piPath',
+  'piVersion',
+  // openclaw (gateway-based)
+  'agentId',
+  'sessionKey',
+  'gatewayHost',
+  'gatewayPort',
+  'lastGatewayFailureAt',
+  'lastGatewayFailureReason',
+];
+
+function projectRuntimeMeta(source) {
+  const out = {};
+  if (!source || typeof source !== 'object') return out;
+  for (const key of RUNTIME_META_KEYS) {
+    if (source[key] !== undefined) out[key] = source[key];
   }
-  const rawRuntimeVersion = msg.agent_runtime_version ?? msg.runtime_version;
-  const runtimeVersion = Number.isInteger(rawRuntimeVersion) ? Number(rawRuntimeVersion) : 0;
+  return out;
+}
 
+function normalizeRuntimeVersion(value) {
+  return Number.isInteger(value) ? Number(value) : 0;
+}
+
+// Build a binding from the agent table snapshot (returned by
+// /api/agents and used by the startup hydrate path). Reads agent.id,
+// agent.service_type, agent.meta, etc. — the agent-row shape.
+function buildBindingFromAgentRow(agent) {
+  const agentId = String(agent?.id || agent?.agent_id || '').trim();
+  const runtime = agent?.service_type;
+  const hostId = getRuntimeHostIdFromPayload(agent) || undefined;
   return {
     id: agentId,
     adapter: 'ticlawk',
     targetKey: agentId,
-    targetMeta: {
-      agentId,
-      runtime_host_id: getRuntimeHostIdFromPayload(msg) || undefined,
-    },
-    runtime_host_id: getRuntimeHostIdFromPayload(msg) || undefined,
-    runtime_host_label: getRuntimeHostLabelFromPayload(msg) || undefined,
+    targetMeta: { agentId, runtime_host_id: hostId },
+    runtime_host_id: hostId,
+    runtime_host_label: getRuntimeHostLabelFromPayload(agent) || undefined,
     runtime,
     runtimeMeta: {
-      ...sourceMeta,
-      runtimeVersion,
+      ...projectRuntimeMeta(agent?.meta),
+      runtimeVersion: normalizeRuntimeVersion(agent?.runtime_version),
     },
-    displayName: msg.agent_display_name || msg.agent_name || agentId,
-    status: msg.agent_status || msg.status || 'connected',
+    displayName: agent?.display_name || agent?.name || agentId,
+    status: agent?.status || 'connected',
   };
 }
 
-function buildBindingFromChannelSnapshot(agent) {
-  return buildBindingFromClaimedMessage({
-    agent_id: agent.id || agent.agent_id,
-    agent_name: agent.name,
-    agent_display_name: agent.display_name,
-    agent_status: agent.status,
-    agent_service_type: agent.service_type,
-    agent_meta: agent.meta,
-    agent_runtime_version: agent.runtime_version,
-    runtime_host_id: agent.runtime_host_id,
-    runtime_host_label: agent.runtime_host_label,
-  });
+// Build a binding from a claimed delivery row. Reads
+// recipient_agent_id, agent_service_type, agent_meta, etc. — the
+// claim-payload shape returned by claim_pending_deliveries.
+function buildBindingFromDeliveryRow(msg) {
+  const agentId = String(msg?.recipient_agent_id || '').trim();
+  const runtime = msg?.agent_service_type;
+  const hostId = getRuntimeHostIdFromPayload(msg) || undefined;
+  return {
+    id: agentId,
+    adapter: 'ticlawk',
+    targetKey: agentId,
+    targetMeta: { agentId, runtime_host_id: hostId },
+    runtime_host_id: hostId,
+    runtime_host_label: getRuntimeHostLabelFromPayload(msg) || undefined,
+    runtime,
+    runtimeMeta: {
+      ...projectRuntimeMeta(msg?.agent_meta),
+      runtimeVersion: normalizeRuntimeVersion(msg?.agent_runtime_version),
+    },
+    displayName: msg?.agent_display_name || msg?.agent_name || agentId,
+    status: msg?.agent_status || 'connected',
+  };
 }
 
 function maskIdentity(identity = {}) {
@@ -458,12 +618,14 @@ export function createTiclawkAdapter(ctx) {
 
   async function processPendingMessagesForAgent(agentId, messages) {
     for (const msg of messages) {
+      const deliveryId = msg.delivery_id;
       try {
         const messageHostId = getRuntimeHostIdFromPayload(msg);
         if (messageHostId && messageHostId !== hostId) {
-          await api.releaseMessage(msg.message_id, hostId);
+          await api.releaseDelivery(deliveryId, hostId, 'host-mismatch');
           debugError('ticlawk', 'message.host-mismatch', {
             agentId,
+            deliveryId,
             messageId: msg.message_id,
             hostId,
             runtime_host_id: messageHostId,
@@ -471,14 +633,15 @@ export function createTiclawkAdapter(ctx) {
           continue;
         }
 
-        const binding = await ctx.cacheBinding(buildBindingFromClaimedMessage(msg));
+        const binding = await ctx.persistBinding(buildBindingFromDeliveryRow(msg));
         if (!binding?.runtime) {
           throw new Error('claimed message missing runtime binding');
         }
         if (!belongsToRuntimeHost(binding, hostId)) {
-          await api.releaseMessage(msg.message_id, hostId);
+          await api.releaseDelivery(deliveryId, hostId, 'binding-host-mismatch');
           debugError('ticlawk', 'message.binding-host-mismatch', {
             agentId,
+            deliveryId,
             messageId: msg.message_id,
             hostId,
             runtime_host_id: getBindingRuntimeHostId(binding),
@@ -489,10 +652,11 @@ export function createTiclawkAdapter(ctx) {
         const completed = await ctx.bus.dispatchToAgent(binding.runtime, binding.id, normalizeInboundMessage(msg));
         if (completed !== true) {
           if (isTerminalRuntimeFailure(completed)) {
-            await api.completeMessage(msg.message_id, hostId);
+            await api.completeDelivery(deliveryId, hostId);
             void requestDrain('message.terminal-completed');
             debugError('ticlawk', 'message.terminal-failed', {
               agentId,
+              deliveryId,
               messageId: msg.message_id,
               runtime: binding.runtime,
               runtimeVersion: getRuntimeVersion(binding),
@@ -502,10 +666,11 @@ export function createTiclawkAdapter(ctx) {
           }
           throw new Error('runtime did not complete turn');
         }
-        await api.completeMessage(msg.message_id, hostId);
+        await api.completeDelivery(deliveryId, hostId);
         void requestDrain('message.completed');
         debugLog('ticlawk', 'message.completed', {
           agentId,
+          deliveryId,
           messageId: msg.message_id,
           runtime: binding.runtime,
           runtimeVersion: getRuntimeVersion(binding),
@@ -515,7 +680,7 @@ export function createTiclawkAdapter(ctx) {
           recordUpdateRequired(err, 'message.dispatch');
         }
         try {
-          await api.releaseMessage(msg.message_id, hostId);
+          await api.releaseDelivery(deliveryId, hostId, 'dispatch-error');
         } catch (releaseErr) {
           debugError('ticlawk', 'message.release-failed', {
             agentId,
@@ -568,7 +733,7 @@ export function createTiclawkAdapter(ctx) {
         continue;
       }
       try {
-        await ctx.cacheBinding(buildBindingFromChannelSnapshot(agent));
+        await ctx.persistBinding(buildBindingFromAgentRow(agent));
         hydrated += 1;
       } catch (err) {
         debugError('ticlawk', 'binding.hydrate-failed', {
@@ -592,13 +757,14 @@ export function createTiclawkAdapter(ctx) {
 
   async function releaseBlockedRows(agentId, messages, reason) {
     for (const msg of messages) {
-      if (!msg?.message_id) continue;
+      if (!msg?.delivery_id) continue;
       try {
-        await api.releaseMessage(msg.message_id, hostId);
+        await api.releaseDelivery(msg.delivery_id, hostId, reason);
       } catch (err) {
         debugError('ticlawk', 'claim.blocked-release-failed', {
           reason,
           agentId,
+          deliveryId: msg.delivery_id,
           messageId: msg.message_id,
           error: err?.message || 'unknown error',
         });
@@ -620,7 +786,7 @@ export function createTiclawkAdapter(ctx) {
       return { failed: true, claimed: 0, launched: 0, updateRequired: true };
     }
     try {
-      data = await api.claimPendingMessages(hostId, 5, excludedChannelIds);
+      data = await api.claimPendingDeliveries(hostId, 5, excludedChannelIds);
       clearUpdateRequired('claim');
     } catch (err) {
       if (api.isUpdateRequiredError(err)) {
@@ -662,7 +828,18 @@ export function createTiclawkAdapter(ctx) {
 
     const grouped = new Map();
     for (const msg of data) {
-      const agentId = getAgentIdFromPayload(msg) || '__default__';
+      const agentId = getAgentIdFromPayload(msg);
+      if (!agentId) {
+        // Claim rows must carry the recipient agent id; a missing value
+        // is a contract violation upstream, not something we paper over
+        // with a synthetic key.
+        debugError('ticlawk', 'claim.missing-agent-id', {
+          reason,
+          deliveryId: msg?.delivery_id,
+          messageId: msg?.message_id,
+        });
+        continue;
+      }
       const bucket = grouped.get(agentId) || [];
       bucket.push(msg);
       grouped.set(agentId, bucket);
@@ -744,12 +921,46 @@ export function createTiclawkAdapter(ctx) {
     bindingsWakeTimer.unref?.();
   }
 
+  async function reportHostCapabilitiesNow() {
+    const entries = await Promise.all(Object.entries(ctx.runtimes || {})
+      .filter(([, runtime]) => typeof runtime?.health === 'function')
+      .map(async ([name, runtime]) => {
+        try {
+          return [name, await runtime.health()];
+        } catch (err) {
+          return [name, { available: false, error: err?.message || 'health probe failed' }];
+        }
+      }));
+    const runtimesHealth = Object.fromEntries(entries);
+    try {
+      await api.reportHostCapabilities({
+        hostId,
+        hostLabel,
+        runtimesHealth,
+        daemonVersion: api.getTiclawkVersion(),
+      });
+      debugLog('ticlawk', 'host.capabilities.reported', {
+        hostId,
+        runtimes: Object.entries(runtimesHealth)
+          .filter(([, v]) => v?.available)
+          .map(([k]) => k)
+          .join(','),
+      });
+    } catch (err) {
+      debugError('ticlawk', 'host.capabilities.failed', {
+        hostId,
+        error: err?.message || 'report failed',
+      });
+    }
+  }
+
   function handleWakeEvent(event) {
     wakeState.lastEventAt = new Date().toISOString();
     if (event?.type === 'hello') {
       void refreshBindings('wake.hello')
         .then(() => requestDrain('wake.hello'))
         .catch(() => {});
+      void reportHostCapabilitiesNow();
       return;
     }
     if (event?.type === 'jobs.available') {
@@ -954,24 +1165,10 @@ export function createTiclawkAdapter(ctx) {
     id: 'ticlawk',
 
     async start() {
-      try {
-        const recovered = await api.recoverClaimedMessages(hostId);
-        if (recovered?.recoveredCount) {
-          debugLog('ticlawk', 'message.recovered', {
-            recoveredCount: recovered.recoveredCount,
-            hostId,
-          });
-        }
-      } catch (err) {
-        if (api.isUpdateRequiredError(err)) {
-          recordUpdateRequired(err, 'recover');
-        }
-        debugError('ticlawk', 'message.recover-failed', {
-          hostId,
-          error: err?.message || 'unknown error',
-        });
-      }
-
+      // No stale-delivery recovery anywhere — if the daemon is killed
+      // mid-claim, the row stays `claimed` forever. lease_expires_at
+      // was dropped in X1; no cron has replaced it. Rare in practice;
+      // when it happens the fix is a one-row UPDATE in supabase.
       await refreshBindings('startup');
       await requestDrain('startup');
       connectWakeSocket();
@@ -1234,7 +1431,6 @@ export async function runTiclawkAuth(rawArgs) {
     };
   }
   const updates = {
-    [AF_ADAPTER_KEY]: 'ticlawk',
     TICLAWK_SETUP_CODE: code,
   };
   const apiUrl = String(args['api-url'] || '').trim();