ticlawk 0.1.15-dev.6 → 0.1.16-dev.1

package/bin/ticlawk.mjs

@@ -3,8 +3,6 @@
 import { request } from 'node:http';
 import { installProcessDiagnostics } from '../src/core/diagnostics.mjs';
 import {
-  AF_ADAPTER_KEY,
-  getConfiguredAdapter,
   loadPersistentConfig,
   getStreamingConfigView,
   normalizeAdapterConfigTarget,
@@ -20,7 +18,7 @@ import {
   getActiveProfile,
   listProfiles,
 } from '../src/core/profiles.mjs';
-import { getAdapterAuthHelp, runAdapterAuth } from '../src/core/adapter-registry.mjs';
+import { runAdapterAuth } from '../src/core/adapter-registry.mjs';
 import { runTiclawkConnect } from '../src/core/ticlawk-control.mjs';
 import {
   RUNTIME_DEFINITIONS,
@@ -30,12 +28,22 @@ import { runSelfUpdate, readPkgVersion } from '../src/core/update.mjs';
 import { getUninstallHelp, runSelfUninstall } from '../src/core/uninstall.mjs';
 import { getInstallDaemonHelp, runInstallDaemon } from '../src/core/daemon-install.mjs';
 import { runSetupReadiness } from '../src/core/setup-readiness.mjs';
+import {
+  AGENT_COMMAND_HELP,
+  runGroupMembersCommand,
+  runMessageReadCommand,
+  runMessageSendCommand,
+  runServerInfoCommand,
+  runTaskClaimCommand,
+  runTaskListCommand,
+  runTaskUpdateCommand,
+} from '../src/cli/agent-commands.mjs';
 
 const TICLAWK_PORT = Number(process.env.FEED_RELAY_PORT || 8741);
 
 function getConfigKeyUsage() {
   const runtimeKeys = getRuntimeExecutableDefinitions().map((runtime) => runtime.executableCliKey);
-  return ['adapter', 'streaming...', ...runtimeKeys, 'telegram.bot-token', 'ticlawk.connector-api-key', 'ticlawk.api-url', 'ticlawk.connector-ws-url'].join('|');
+  return ['streaming...', ...runtimeKeys, 'ticlawk.connector-api-key', 'ticlawk.api-url', 'ticlawk.connector-ws-url'].join('|');
 }
 
 function getRuntimeConfigExamples() {
@@ -56,7 +64,7 @@ Usage:
   ticlawk config
   ticlawk config get <${configKeys}>
   ticlawk config set <${configKeys}> <value>
-  ticlawk auth <adapter> [adapter-auth-args...]
+  ticlawk auth --code <6-digit-code> [--api-url <url>]
   ticlawk connect
   ticlawk profile list
   ticlawk profile current
@@ -66,44 +74,50 @@ Usage:
   ticlawk uninstall [-y]
   ticlawk version
 
+Agent CLI (run inside an agent runtime; requires TICLAWK_RUNTIME_AGENT_ID):
+  ticlawk message send --target <t>           # body on stdin
+  ticlawk message read --target <t> [opts]
+  ticlawk task claim --message-id <id>
+  ticlawk task update --task-id <id> --status <s>
+  ticlawk task list [--target <t>]
+  ticlawk group members --target <t>
+  ticlawk server info [--refresh]
+
 Commands:
-  auth     store adapter-specific auth/setup input locally
-  connect  connect the selected adapter to a local runtime
+  auth     store the ticlawk app pairing code locally
+  connect  connect ticlawk to a local runtime
   profile  list or switch saved local identities
+  message  send/read chat messages (agent CLI surface)
+  task     claim/update/list tasks (agent CLI surface)
+  group    list members of a group conversation (agent CLI surface)
+  server   server-info introspection (agent CLI surface)
   install-daemon  install or refresh the background daemon
   update   update the npm package and refresh the daemon
   uninstall  remove service and managed install files, preserving ~/.ticlawk
 
 Config examples:
-  ticlawk config get adapter
-  ticlawk config set adapter telegram
-  ticlawk config set adapter ticlawk
   ticlawk config set streaming off                    # turn streaming off for all runtimes
   ticlawk config set streaming.codex default          # clear the codex-specific override and inherit the global streaming setting
 ${getRuntimeConfigExamples()}
-  ticlawk config set telegram.bot-token <bot-token>   # advanced/manual
   ticlawk config set ticlawk.connector-api-key <key>   # advanced/manual
   ticlawk config set ticlawk.api-url <api-url>        # advanced/manual
   ticlawk config set ticlawk.connector-ws-url <url>   # advanced/manual
 
 Examples:
   ticlawk connect
-  ticlawk auth telegram --bot-token <bot-token>
+  ticlawk auth --code <6-digit-code>
 `;
 }
 
 function getAuthHelp() {
-  return `ticlawk auth
-
-Use \`auth\` to store adapter-specific auth/setup input locally.
-Adapter-specific args live after \`--\` so new adapters can define their own flags
-without changing the top-level CLI.
+  return `ticlawk auth --code <6-digit-code> [--api-url <url>]
 
-Examples:
-  ticlawk auth telegram --bot-token <bot-token>
+Store the ticlawk app pairing code locally. The daemon picks it up on the
+next start and exchanges it for an API key.
 
-Per-adapter help:
-  ticlawk auth telegram --help
+Options:
+  --code <code>       6-digit setup code from the ticlawk app
+  --api-url <url>     optional ticlawk API base URL override
 `;
 }
 
@@ -132,11 +146,6 @@ function printHelp(helpPath, args = {}) {
     return;
   }
   if (head === 'auth') {
-    const adapterValue = helpPath[1] || args._?.[1];
-    if (adapterValue) {
-      console.log(getAdapterAuthHelp(requireAdapter(adapterValue)));
-      return;
-    }
     console.log(getAuthHelp());
     return;
   }
@@ -169,7 +178,6 @@ function parseConfigBoolean(value) {
 }
 
 function printConfigView(config = loadPersistentConfig()) {
-  console.log(`adapter=${getConfiguredAdapter(config)}`);
   const view = getStreamingConfigView(config);
   console.log(`streaming=${formatStreamingValue(view.streaming.value, view.streaming.inherited)}`);
   for (const runtime of RUNTIME_DEFINITIONS) {
@@ -180,7 +188,6 @@ function printConfigView(config = loadPersistentConfig()) {
   for (const runtime of getRuntimeExecutableDefinitions()) {
     console.log(`${runtime.executableCliKey}=${config[runtime.executableConfigKey] || ''}`);
   }
-  console.log(`telegram.bot-token=${config.TELEGRAM_BOT_TOKEN ? 'set' : 'unset'}`);
   console.log(`ticlawk.connector-api-key=${config[TICLAWK_CONNECTOR_API_KEY] ? 'set' : 'unset'}`);
   console.log(`ticlawk.api-url=${config.TICLAWK_API_URL || ''}`);
   console.log(`ticlawk.connector-ws-url=${config[TICLAWK_CONNECTOR_WS_URL] || ''}`);
@@ -211,7 +218,7 @@ function getLocal(path) {
 }
 
 function formatSecretConfigValue(configKey, value) {
-  if (configKey === 'TELEGRAM_BOT_TOKEN' || configKey === TICLAWK_CONNECTOR_API_KEY) {
+  if (configKey === TICLAWK_CONNECTOR_API_KEY) {
     return value ? 'set' : 'unset';
   }
   return value || '';
@@ -302,6 +309,75 @@ async function main() {
     return;
   }
 
+  // ── Agent-facing subcommands (run inside a runtime; talk to local daemon) ──
+  if (command === 'message') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.message);
+      return;
+    }
+    if (sub === 'send') {
+      process.exitCode = await runMessageSendCommand(args);
+      return;
+    }
+    if (sub === 'read') {
+      process.exitCode = await runMessageReadCommand(args);
+      return;
+    }
+    console.error(`unknown message subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'task') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.task);
+      return;
+    }
+    if (sub === 'claim') {
+      process.exitCode = await runTaskClaimCommand(args);
+      return;
+    }
+    if (sub === 'update') {
+      process.exitCode = await runTaskUpdateCommand(args);
+      return;
+    }
+    if (sub === 'list') {
+      process.exitCode = await runTaskListCommand(args);
+      return;
+    }
+    console.error(`unknown task subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'group') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.group);
+      return;
+    }
+    if (sub === 'members') {
+      process.exitCode = await runGroupMembersCommand(args);
+      return;
+    }
+    console.error(`unknown group subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  if (command === 'server') {
+    const sub = args._[1];
+    if (args.help || args.h || !sub) {
+      console.log(AGENT_COMMAND_HELP.server);
+      return;
+    }
+    if (sub === 'info') {
+      process.exitCode = await runServerInfoCommand(args);
+      return;
+    }
+    console.error(`unknown server subcommand: ${sub}`);
+    process.exit(1);
+  }
+
   if (command === 'config') {
     const subcommand = args._[1];
     const config = loadPersistentConfig();
@@ -312,10 +388,6 @@ async function main() {
 
     if (subcommand === 'get') {
       const key = args._[2];
-      if (key === 'adapter') {
-        console.log(getConfiguredAdapter(config));
-        return;
-      }
       const adapterTarget = normalizeAdapterConfigTarget(key);
       if (adapterTarget) {
         console.log(formatSecretConfigValue(adapterTarget.configKey, config[adapterTarget.configKey]));
@@ -340,16 +412,6 @@ async function main() {
     if (subcommand === 'set') {
       const key = args._[2];
       const rawValue = args._[3];
-      if (key === 'adapter') {
-        if (!rawValue) {
-          console.error('config set adapter requires a value');
-          process.exit(1);
-        }
-        const adapterId = requireAdapter(rawValue);
-        persistConfig({ [AF_ADAPTER_KEY]: adapterId });
-        console.log(`adapter=${adapterId}`);
-        return;
-      }
       const adapterTarget = normalizeAdapterConfigTarget(key);
       if (adapterTarget) {
         if (!rawValue) {
@@ -464,9 +526,8 @@ async function main() {
       printHelp(['auth'], args);
       return;
     }
-    const adapterId = requireAdapter(args._[1]);
-    const adapterArgv = rawArgv.slice(2);
-    const res = await runAdapterAuth(adapterId, adapterArgv);
+    const adapterArgv = rawArgv.slice(1);
+    const res = await runAdapterAuth('ticlawk', adapterArgv);
     printCommandResult(res);
     process.exitCode = res.statusCode >= 400 ? 1 : 0;
     return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ticlawk",
-  "version": "0.1.15-dev.6",
-  "description": "Connect local agent harnesses to Ticlawk, Telegram, and other mobile clients.",
+  "version": "0.1.16-dev.1",
+  "description": "Local connector that links agent harnesses (Claude Code, Codex, OpenClaw, opencode, Pi) to the Ticlawk mobile app.",
   "type": "module",
   "main": "ticlawk.mjs",
   "exports": {
@@ -48,9 +48,6 @@
     "codex",
     "agent",
     "ai-agent",
-    "telegram",
-    "telegram-bot",
-    "chatops",
     "remote-agent",
     "mobile",
     "bridge",

package/src/adapters/ticlawk/api.mjs

@@ -150,26 +150,21 @@ export async function updateChannel(id, updates) {
 }
 
 export async function postRuntimeResult(body) {
+  // Activity-only: backend records the agent_event for UI trajectory
+  // display but does NOT project it into a chat message. The agent CLI's
+  // `ticlawk message send` is the only path that produces chat rows.
   const result = await apiFetch('/api/runtime-results', {
     method: 'POST',
     body: JSON.stringify(body),
     timeout: 30000,
   });
-  if (result?.matched === false) {
-    throw new Error('runtime result was not matched');
-  }
   return result;
 }
 
-// ── Messages ──
-
-export async function getPendingMessages() {
-  const { data } = await apiFetch('/api/messages/pending');
-  return data || [];
-}
+// ── Deliveries (replaces legacy message_jobs poll/ack) ──
 
-export async function claimPendingMessages(hostId, limit = 5, excludedAgentIds = []) {
-  const { data } = await apiFetch('/api/messages/claim-pending', {
+export async function claimPendingDeliveries(hostId, limit = 5, excludedAgentIds = []) {
+  const { data } = await apiFetch('/api/agent/deliveries/claim-pending', {
     method: 'POST',
     body: JSON.stringify(withTiclawkVersion({
       runtime_host_id: hostId,
@@ -180,38 +175,110 @@ export async function claimPendingMessages(hostId, limit = 5, excludedAgentIds =
   return data || [];
 }
 
-export async function syncMessages(rows) {
-  return apiFetch('/api/messages/sync', {
+export async function completeDelivery(deliveryId, hostId) {
+  return apiFetch(`/api/agent/deliveries/${deliveryId}/complete`, {
     method: 'POST',
-    body: JSON.stringify({ rows }),
+    body: JSON.stringify({ runtime_host_id: hostId }),
   });
 }
 
-export async function claimMessage(id, hostId) {
-  return apiFetch(`/api/messages/${id}/claim`, {
+export async function releaseDelivery(deliveryId, hostId, reason = null) {
+  return apiFetch(`/api/agent/deliveries/${deliveryId}/release`, {
     method: 'POST',
-    body: JSON.stringify(withTiclawkVersion({ runtime_host_id: hostId })),
+    body: JSON.stringify({ runtime_host_id: hostId, reason }),
   });
 }
 
-export async function releaseMessage(id, hostId) {
-  return apiFetch(`/api/messages/${id}/release`, {
+// ── Agent-facing CLI surface (group chat tool path) ──
+
+export async function sendAgentMessage({
+  actingAgentId,
+  conversationId,
+  text,
+  seenUpToSeq,
+  replyToMessageId,
+  runtimeHostId,
+}) {
+  const { data } = await apiFetch('/api/agent/messages/send', {
     method: 'POST',
-    body: JSON.stringify({ runtime_host_id: hostId }),
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      conversation_id: conversationId,
+      text,
+      seen_up_to_seq: seenUpToSeq ?? null,
+      reply_to_message_id: replyToMessageId ?? null,
+      runtime_host_id: runtimeHostId ?? null,
+    }),
   });
+  return data || null;
 }
 
-export async function completeMessage(id, hostId) {
-  return apiFetch(`/api/messages/${id}/complete`, {
+export async function readAgentMessages({
+  actingAgentId,
+  conversationId,
+  aroundMessageId,
+  beforeSeq,
+  limit,
+}) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  params.set('conversation_id', conversationId);
+  if (aroundMessageId) params.set('around_message_id', aroundMessageId);
+  if (beforeSeq != null) params.set('before_seq', String(beforeSeq));
+  if (limit != null) params.set('limit', String(limit));
+  const { data } = await apiFetch(`/api/agent/messages/read?${params}`);
+  return data || [];
+}
+
+export async function claimAgentTask({ actingAgentId, sourceMessageId, leaseSeconds }) {
+  return apiFetch('/api/agent/tasks/claim', {
     method: 'POST',
-    body: JSON.stringify({ runtime_host_id: hostId }),
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      source_message_id: sourceMessageId,
+      lease_seconds: leaseSeconds ?? null,
+    }),
   });
 }
 
-export async function recoverClaimedMessages(hostId) {
-  return apiFetch('/api/messages/recover', {
+export async function updateAgentTask({ actingAgentId, taskId, status }) {
+  return apiFetch('/api/agent/tasks/update', {
     method: 'POST',
-    body: JSON.stringify(withTiclawkVersion({ runtime_host_id: hostId })),
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      task_id: taskId,
+      status,
+    }),
+  });
+}
+
+export async function listAgentTasks({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  if (conversationId) params.set('conversation_id', conversationId);
+  const { data } = await apiFetch(`/api/agent/tasks/list?${params}`);
+  return data || [];
+}
+
+export async function getConversationMembers({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const res = await apiFetch(`/api/agent/conversations/${conversationId}/members?${params}`);
+  return res || { data: [], conversation: null };
+}
+
+export async function getAgentServerInfo({ actingAgentId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(`/api/agent/server-info?${params}`);
+}
+
+// ── Transcript history ──
+
+export async function syncMessages(rows) {
+  return apiFetch('/api/messages/sync', {
+    method: 'POST',
+    body: JSON.stringify({ rows }),
   });
 }
 

package/src/adapters/ticlawk/credentials.mjs

@@ -6,13 +6,12 @@
  * using the connector-specific env name.
  */
 
-import { AF_ADAPTER_KEY, AF_CONFIG_PATH, persistConfig, TICLAWK_CONNECTOR_API_KEY } from '../../core/config.mjs';
+import { AF_CONFIG_PATH, persistConfig, TICLAWK_CONNECTOR_API_KEY } from '../../core/config.mjs';
 
 export function persistApiCredential(apiKey) {
   if (!apiKey || !apiKey.startsWith('tk_')) return;
 
   persistConfig({
-    [AF_ADAPTER_KEY]: 'ticlawk',
     [TICLAWK_CONNECTOR_API_KEY]: apiKey,
     TICLAWK_SETUP_CODE: '',
   });

package/src/adapters/ticlawk/index.mjs

@@ -2,7 +2,7 @@ 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';
@@ -45,13 +45,62 @@ function normalizeInboundMediaAssets(msg) {
     .filter(Boolean);
 }
 
-function normalizeInboundMessage(msg) {
+function shortMsgId(value) {
+  return value ? String(value).slice(0, 8) : '';
+}
+
+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') {
+    // 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);
+    return `#${groupName}:${threadRoot}`;
+  }
+  // group
+  const groupName = msg.conversation_name || conversationId;
+  return `#${groupName}`;
+}
+
+function buildEnvelopeHeader(msg) {
+  const target = buildEnvelopeTarget(msg);
+  const msgId = shortMsgId(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}:`;
+}
+
+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 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 });
   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,
+    text: header ? `${header} ${rawText}` : rawText,
+    rawText,
     action: msg.action || (media.length > 0 ? 'image' : 'task'),
     media,
     raw: {
@@ -95,7 +144,14 @@ function getAgentIdFromPayload(payload) {
 }
 
 function buildBindingFromClaimedMessage(msg) {
-  const agentId = getAgentIdFromPayload(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 } : {};
@@ -458,12 +514,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,
@@ -476,9 +534,10 @@ export function createTiclawkAdapter(ctx) {
           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 +548,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 +562,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 +576,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,
@@ -592,13 +653,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 +682,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)) {
@@ -954,24 +1016,9 @@ 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',
-        });
-      }
-
+      // 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.
       await refreshBindings('startup');
       await requestDrain('startup');
       connectWakeSocket();
@@ -1234,7 +1281,6 @@ export async function runTiclawkAuth(rawArgs) {
     };
   }
   const updates = {
-    [AF_ADAPTER_KEY]: 'ticlawk',
     TICLAWK_SETUP_CODE: code,
   };
   const apiUrl = String(args['api-url'] || '').trim();