ticlawk 0.1.16-dev.1 → 0.1.16-dev.2

package/src/adapters/ticlawk/index.mjs

@@ -9,7 +9,6 @@ import { getActiveProfile, ensureLegacyProfile, readProfileMeta, saveAndActivate
 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,10 +44,6 @@ function normalizeInboundMediaAssets(msg) {
     .filter(Boolean);
 }
 
-function shortMsgId(value) {
-  return value ? String(value).slice(0, 8) : '';
-}
-
 function buildEnvelopeTarget(msg) {
   const convType = msg.conversation_type || 'dm';
   const conversationId = msg.conversation_id || '';
@@ -57,13 +52,8 @@ function buildEnvelopeTarget(msg) {
     return senderHandle ? `dm:@${senderHandle}` : `dm:${conversationId}`;
   }
   if (convType === 'thread') {
-    // For thread deliveries the message itself is in-thread; reply target
-    // is the parent group's id + the thread root's short id. The RPC
-    // returns conversation_type='thread' only when the message lives in
-    // a thread conversation directly, which we represent as
-    // `<group>:<thread-root>`.
     const groupName = msg.conversation_name || conversationId;
-    const threadRoot = shortMsgId(msg.thread_root_message_id || msg.message_id);
+    const threadRoot = msg.thread_root_message_id || msg.message_id || '';
     return `#${groupName}:${threadRoot}`;
   }
   // group
@@ -71,26 +61,104 @@ function buildEnvelopeTarget(msg) {
   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 = shortMsgId(msg.id || msg.message_id);
+  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';
-  return `[target=${target} msg=${msgId} seq=${seq} time=${time} type=${type}] @${sender}:`;
+  // `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 || msg.agent_id || '';
+  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 header = buildEnvelopeHeader({ ...msg, id: messageId });
+  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: recipientAgentId,
     messageId,
@@ -99,7 +167,8 @@ export function normalizeInboundMessage(msg) {
     seq: msg.seq != null ? Number(msg.seq) : null,
     senderType: msg.sender_type || 'human',
     envelopeHeader: header,
-    text: header ? `${header} ${rawText}` : rawText,
+    envelopeTarget: target,
+    text,
     rawText,
     action: msg.action || (media.length > 0 ? 'image' : 'task'),
     media,
@@ -114,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;
@@ -140,65 +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) {
-  // Delivery rows expose the recipient agent under recipient_agent_id;
-  // older code paths may pass plain agent_id. Either works.
-  const agentId = String(
-    msg.recipient_agent_id
-    || msg.agent_id
-    || msg.agentId
-    || ''
-  ).trim();
-  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 = {}) {
@@ -529,7 +633,7 @@ 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');
         }
@@ -629,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', {
@@ -724,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);
@@ -806,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') {
@@ -1016,9 +1165,10 @@ export function createTiclawkAdapter(ctx) {
     id: 'ticlawk',
 
     async start() {
-      // Stale-delivery recovery is handled server-side via lease expiry
-      // (message_deliveries.claimed_at + lease_seconds). The connector no
-      // longer issues an explicit recover call at startup.
+      // 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();