ticlawk 0.1.16-dev.1 → 0.1.16-dev.11

package/src/adapters/ticlawk/index.mjs

@@ -9,9 +9,7 @@ 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';
 import { TiclawkWakeClient } from './wake-client.mjs';
 
@@ -28,6 +26,32 @@ function connectError(statusCode, error) {
   return { statusCode, body: { ok: false, error } };
 }
 
+// Coalesce: returns a wrapped fn that runs at most one invocation at a
+// time. If it's called while an invocation is in flight, the most recent
+// args are stashed and the wrapped fn re-runs exactly once after the
+// current run completes (regardless of how many times it was called
+// during the run). The wrapped fn always returns the in-flight Promise.
+function coalesce(fn) {
+  let running = null;
+  let pendingArgs = null;
+  return function call(...args) {
+    if (running) {
+      pendingArgs = args;
+      return running;
+    }
+    running = (async () => {
+      let currentArgs = args;
+      while (true) {
+        pendingArgs = null;
+        await fn(...currentArgs);
+        if (pendingArgs === null) return;
+        currentArgs = pendingArgs;
+      }
+    })().finally(() => { running = null; });
+    return running;
+  };
+}
+
 function normalizeInboundMediaAssets(msg) {
   if (!Array.isArray(msg?.media_assets)) return [];
   return msg.media_assets
@@ -45,10 +69,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 +77,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 +86,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.
+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: `[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 +192,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,
@@ -110,14 +204,6 @@ export function normalizeInboundMessage(msg) {
   };
 }
 
-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,67 +226,101 @@ 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 any source row that carries agent metadata.
+// Two source shapes feed in:
+//   /api/agents row           — id, service_type, meta, …
+//   claim_pending_deliveries  — recipient_agent_id, agent_service_type,
+//                               agent_meta, … (prefixed because the
+//                               delivery row also carries message fields)
+// We try the prefixed names first, then fall through to the bare names,
+// so one builder handles both without the caller having to remember
+// which shape it has.
+function buildBindingFromSource(source) {
+  const agentId = String(
+    source?.recipient_agent_id
+      || source?.id
+      || source?.agent_id
+      || ''
+  ).trim();
+  const runtime = source?.agent_service_type || source?.service_type;
+  const meta = source?.agent_meta ?? source?.meta;
+  const runtimeVersion = source?.agent_runtime_version ?? source?.runtime_version;
+  const displayName = source?.agent_display_name
+    || source?.agent_name
+    || source?.display_name
+    || source?.name
+    || agentId;
+  const status = source?.agent_status || source?.status || 'connected';
+  const hostId = getRuntimeHostIdFromPayload(source) || 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(source) || undefined,
     runtime,
     runtimeMeta: {
-      ...sourceMeta,
-      runtimeVersion,
+      ...projectRuntimeMeta(meta),
+      runtimeVersion: normalizeRuntimeVersion(runtimeVersion),
     },
-    displayName: msg.agent_display_name || msg.agent_name || agentId,
-    status: msg.agent_status || msg.status || 'connected',
+    displayName,
+    status,
   };
 }
 
-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,
-  });
-}
-
 function maskIdentity(identity = {}) {
   return {
     userId: identity.userId || identity.user_id || identity.id || null,
@@ -352,8 +472,6 @@ export function createTiclawkAdapter(ctx) {
   let bindingAuditTimer = null;
   let jobsWakeTimer = null;
   let bindingsWakeTimer = null;
-  let drainPromise = null;
-  let drainRequested = false;
   let lastJobsWakeAt = 0;
   let lastBindingsWakeAt = 0;
   let updateRequired = null;
@@ -529,7 +647,7 @@ export function createTiclawkAdapter(ctx) {
           continue;
         }
 
-        const binding = await ctx.cacheBinding(buildBindingFromClaimedMessage(msg));
+        const binding = await ctx.persistBinding(buildBindingFromSource(msg));
         if (!binding?.runtime) {
           throw new Error('claimed message missing runtime binding');
         }
@@ -629,7 +747,7 @@ export function createTiclawkAdapter(ctx) {
         continue;
       }
       try {
-        await ctx.cacheBinding(buildBindingFromChannelSnapshot(agent));
+        await ctx.persistBinding(buildBindingFromSource(agent));
         hydrated += 1;
       } catch (err) {
         debugError('ticlawk', 'binding.hydrate-failed', {
@@ -724,7 +842,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);
@@ -768,23 +897,7 @@ export function createTiclawkAdapter(ctx) {
     return { totalClaimed, iterations };
   }
 
-  function requestDrain(reason) {
-    if (drainPromise) {
-      drainRequested = true;
-      return drainPromise;
-    }
-    drainPromise = (async () => {
-      let currentReason = reason;
-      do {
-        drainRequested = false;
-        await runDrain(currentReason);
-        currentReason = 'drain.requested-again';
-      } while (drainRequested);
-    })().finally(() => {
-      drainPromise = null;
-    });
-    return drainPromise;
-  }
+  const requestDrain = coalesce(runDrain);
 
   function scheduleDrain(reason) {
     jobsWakeTimer = clearDebounce(jobsWakeTimer);
@@ -806,12 +919,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 +1163,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();
@@ -1188,22 +1336,19 @@ export function createTiclawkAdapter(ctx) {
       }
     },
 
-    async send(binding, outbound) {
-      const localMediaPaths = (outbound.media || [])
-        .filter((item) => item.kind === 'local_path')
-        .map((item) => item.value);
-      await processAndSaveResult({
-        text: outbound.text || '',
-        mediaUrls: localMediaPaths,
-      }, {
-        agentId: binding.id,
-        hostId,
-        agent: binding.runtime,
-        sessionId: getBindingSessionId(binding),
-        runtimeVersion: getRuntimeVersion(binding),
-        turnId: outbound.turnId || outbound.replyToMessageId || null,
-        type: outbound.type || 'agent_message',
-        replyToMessageId: outbound.replyToMessageId || null,
+    // Daemon-driven impersonated reply: the runtime never reached
+    // `ticlawk message send` (subprocess died, timeout, etc.), so the
+    // daemon speaks for the agent. Used by reportSubprocessFailure
+    // with visibility='admin' so the notice only reaches owners.
+    async postAgentReply(binding, { conversationId, text, replyToMessageId, visibility }) {
+      if (!conversationId || !text) return null;
+      return api.sendAgentMessage({
+        actingAgentId: binding.id,
+        conversationId,
+        text,
+        replyToMessageId: replyToMessageId || null,
+        runtimeHostId: hostId,
+        visibility: visibility || null,
       });
     },