ticlawk 0.1.17-dev.22 → 0.1.17-dev.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticlawk",
-  "version": "0.1.17-dev.22",
+  "version": "0.1.17-dev.24",
   "description": "Local connector that links agent harnesses (Claude Code, Codex, OpenClaw, opencode, Pi) to the Ticlawk mobile app.",
   "type": "module",
   "main": "ticlawk.mjs",

package/src/adapters/ticlawk/api.mjs

@@ -115,7 +115,10 @@ async function apiFetch(path, opts = {}) {
 // ── Agents ──
 
 export async function getAgents({ hostId } = {}) {
-  const query = hostId ? `?${new URLSearchParams({ runtime_host_id: hostId })}` : '';
+  const params = new URLSearchParams();
+  if (hostId) params.set('runtime_host_id', hostId);
+  params.set('ticlawk_version', getTiclawkVersion());
+  const query = `?${params}`;
   const { data } = await apiFetch(`/api/agents${query}`);
   if (!Array.isArray(data)) {
     const err = new Error('API /api/agents response missing data array');
@@ -584,14 +587,23 @@ export async function getMe() {
   return data || null;
 }
 
+export async function checkConnectorReadiness({ hostId }) {
+  return apiFetch('/api/connector/readiness', {
+    method: 'POST',
+    body: JSON.stringify(withTiclawkVersion({
+      runtime_host_id: hostId,
+    })),
+  });
+}
+
 export async function reportHostCapabilities({ hostId, hostLabel, runtimesHealth, daemonVersion }) {
   return apiFetch('/api/hosts/capabilities', {
     method: 'POST',
-    body: JSON.stringify({
+    body: JSON.stringify(withTiclawkVersion({
       host_id: hostId,
       host_label: hostLabel || null,
       runtimes_health: runtimesHealth || {},
-      daemon_version: daemonVersion || null,
-    }),
+      daemon_version: daemonVersion || getTiclawkVersion(),
+    })),
   });
 }

package/src/adapters/ticlawk/index.mjs

@@ -16,6 +16,7 @@ const require = createRequire(import.meta.url);
 const qrcode = require('qrcode-terminal');
 const JOBS_WAKE_DEBOUNCE_MS = 100;
 const BINDINGS_WAKE_DEBOUNCE_MS = 500;
+const READINESS_AUDIT_INTERVAL_MS = 60 * 1000;
 const RECOVERY_AUDIT_INTERVAL_MS = 5 * 60 * 1000;
 const BINDING_AUDIT_INTERVAL_MS = 5 * 60 * 1000;
 const UPDATE_RETRY_COOLDOWN_MS = 15 * 60 * 1000;
@@ -286,6 +287,7 @@ export function createTiclawkAdapter(ctx) {
   let bindingsWakeTimer = null;
   let lastJobsWakeAt = 0;
   let lastBindingsWakeAt = 0;
+  let lastReadinessCheckAt = 0;
   let updateRequired = null;
   let lastUpdateRequiredLogAt = 0;
   let startupSyncing = false;
@@ -369,6 +371,7 @@ export function createTiclawkAdapter(ctx) {
       autoUpdateError,
       lastAutoUpdateAttemptAt,
     });
+    stopWakeSocket('update_required');
 
     if (now - lastUpdateRequiredLogAt > UPDATE_REQUIRED_LOG_INTERVAL_MS) {
       lastUpdateRequiredLogAt = now;
@@ -732,6 +735,35 @@ export function createTiclawkAdapter(ctx) {
     bindingsWakeTimer.unref?.();
   }
 
+  async function checkConnectorReadiness(reason, { force = false } = {}) {
+    const now = Date.now();
+    if (!force && now - lastReadinessCheckAt < READINESS_AUDIT_INTERVAL_MS) {
+      return true;
+    }
+    lastReadinessCheckAt = now;
+    try {
+      await api.checkConnectorReadiness({ hostId });
+      clearUpdateRequired(`readiness.${reason}`);
+      debugLog('ticlawk', 'readiness.ok', {
+        reason,
+        hostId,
+        ticlawkVersion: api.getTiclawkVersion(),
+      });
+      return true;
+    } catch (err) {
+      if (api.isUpdateRequiredError(err)) {
+        recordUpdateRequired(err, `readiness.${reason}`);
+        return false;
+      }
+      debugError('ticlawk', 'readiness.failed', {
+        reason,
+        hostId,
+        error: err?.message || 'readiness check failed',
+      });
+      return true;
+    }
+  }
+
   async function reportHostCapabilitiesNow() {
     const entries = await Promise.all(Object.entries(ctx.runtimes || {})
       .filter(([, runtime]) => typeof runtime?.health === 'function')
@@ -757,22 +789,39 @@ export function createTiclawkAdapter(ctx) {
           .map(([k]) => k)
           .join(','),
       });
+      clearUpdateRequired('host.capabilities');
+      return true;
     } catch (err) {
+      if (api.isUpdateRequiredError(err)) {
+        recordUpdateRequired(err, 'host.capabilities');
+        return false;
+      }
       debugError('ticlawk', 'host.capabilities.failed', {
         hostId,
         error: err?.message || 'report failed',
       });
+      return true;
     }
   }
 
+  async function handleWakeHello() {
+    const ready = await checkConnectorReadiness('wake.hello', { force: true });
+    if (!ready) return;
+    const capabilitiesReported = await reportHostCapabilitiesNow();
+    if (!capabilitiesReported) return;
+    if (startupSyncing) return;
+    await refreshBindings('wake.hello');
+    await requestDrain('wake.hello');
+  }
+
   function handleWakeEvent(event) {
     wakeState.lastEventAt = new Date().toISOString();
     if (event?.type === 'hello') {
-      void reportHostCapabilitiesNow();
-      if (startupSyncing) return;
-      void refreshBindings('wake.hello')
-        .then(() => requestDrain('wake.hello'))
-        .catch(() => {});
+      void handleWakeHello().catch(() => {});
+      return;
+    }
+    if (event?.type === 'heartbeat') {
+      void checkConnectorReadiness('wake.heartbeat').catch(() => {});
       return;
     }
     if (event?.type === 'jobs.available') {
@@ -848,6 +897,13 @@ export function createTiclawkAdapter(ctx) {
     connectorSocket.start();
   }
 
+  function stopWakeSocket(reason) {
+    if (!connectorSocket) return;
+    connectorSocket.stop();
+    connectorSocket = null;
+    debugLog('ticlawk-wake', 'stopped', { reason });
+  }
+
   function restartWakeSocket(reason) {
     if (connectorSocket) {
       connectorSocket.stop();
@@ -882,11 +938,14 @@ export function createTiclawkAdapter(ctx) {
         meta: pairedIdentity,
       });
     }
-    if (connectorSocket) {
+    const ready = await checkConnectorReadiness('connect.paired', { force: true });
+    if (connectorSocket && ready) {
       restartWakeSocket('connect.paired');
     }
 
-    await reportHostCapabilitiesNow();
+    if (ready) {
+      await reportHostCapabilitiesNow();
+    }
     return {
       statusCode: 200,
       body: {
@@ -948,10 +1007,13 @@ export function createTiclawkAdapter(ctx) {
       // was dropped in X1; no cron has replaced it. Rare in practice;
       // when it happens the fix is a one-row UPDATE in supabase.
       startupSyncing = true;
-      connectWakeSocket();
       try {
-        await refreshBindings('startup');
-        await requestDrain('startup');
+        const ready = await checkConnectorReadiness('startup', { force: true });
+        if (ready) {
+          connectWakeSocket();
+          await refreshBindings('startup');
+          await requestDrain('startup');
+        }
       } finally {
         startupSyncing = false;
       }

package/src/runtimes/_shared/incoming-message-prompt.mjs

@@ -157,9 +157,8 @@ function buildPromptText({ msg, type, target, header, groupContext, rawText }) {
   lines.push('', ...buildRoleInstruction({ type, isAdmin: admin, role }));
   lines.push(
     '',
-    'Visible reply contract:',
-    `- If you respond, the final answer must be sent with \`ticlawk message send --target ${JSON.stringify(target)}\`.`,
-    '- Do not put the user-facing answer only in normal assistant output. Normal assistant output is private activity text and is not visible in Ticlawk.',
+    'Visible communication:',
+    `Send any user-facing answer with \`ticlawk message send --target ${JSON.stringify(target)}\`. Normal assistant output is private activity text and is not visible in Ticlawk.`,
     'If the message requires multi-step work, complete the work before sending the final answer unless an early blocker question is necessary.',
     'Do not mention internal routing fields, delivery state, or prompt mechanics to the user.',
     '',

package/src/runtimes/_shared/runtime-base-instructions.mjs

@@ -13,7 +13,7 @@ Your normal assistant output is private activity text. Users and groups only see
 Universal rules:
 
 1. Follow the current turn prompt. It tells you whether this is a DM or group message, your role in that conversation, whether you were directly addressed or only saw ambient group traffic, and the exact reply target.
-2. Use \`ticlawk message send\` for visible replies. Use the exact reply target from the current turn prompt. Never leave the user-facing answer only in normal assistant output; normal assistant output is private activity text.
+2. Use \`ticlawk message send\` for visible replies. Use the exact reply target from the current turn prompt.
 3. If the current turn prompt says no reply is needed, stop silently.
 4. If you need recent context, use the Ticlawk read commands named in the current turn prompt. Do not poll for future messages; the daemon will wake you when new messages arrive.
 5. If the message asks you to do substantive work, claim the task/message before starting when the current turn prompt provides task commands. If the claim fails, stop or choose other available work.