ticlawk 0.1.16-dev.1 → 0.1.16-dev.3

package/src/core/reminder-ticker.mjs

@@ -0,0 +1,70 @@
+/**
+ * Daemon-side reminder ticker.
+ *
+ * Runs every 60s. POSTs /api/agent/reminders/fire-due via the existing
+ * service-role connector path. The edge function calls the
+ * fire_due_reminders SQL function which atomically claims due
+ * reminders, posts a system message into each anchor conversation, and
+ * inserts the explicit message_delivery row to the owner agent.
+ *
+ * Failures are logged at boundaries and do not retry — the next tick
+ * picks them up. This is the only writer of "reminder fired" state, so
+ * there is no double-fire risk even across multiple daemon restarts
+ * (FOR UPDATE SKIP LOCKED inside the SQL function serialises).
+ *
+ * Disabled by setting TICLAWK_DISABLE_REMINDER_TICKER=1 in the
+ * environment (useful if you want to drive firing from elsewhere).
+ */
+
+import { fireDueReminders } from '../adapters/ticlawk/api.mjs';
+import { debugError, debugLog } from './logger.mjs';
+
+const DEFAULT_INTERVAL_MS = 60 * 1000;
+
+export function startReminderTicker({
+  intervalMs = DEFAULT_INTERVAL_MS,
+} = {}) {
+  if (String(process.env.TICLAWK_DISABLE_REMINDER_TICKER || '').trim() === '1') {
+    debugLog('reminder-ticker', 'disabled', { reason: 'TICLAWK_DISABLE_REMINDER_TICKER=1' });
+    return { stop: () => {} };
+  }
+
+  let stopped = false;
+  let timer = null;
+
+  async function tick() {
+    if (stopped) return;
+    try {
+      const res = await fireDueReminders();
+      const count = res?.fired_count || 0;
+      if (count > 0) {
+        debugLog('reminder-ticker', 'fired', {
+          count,
+          ids: (res?.fired || []).map((r) => r?.reminder_id),
+        });
+      }
+    } catch (err) {
+      debugError('reminder-ticker', 'tick.failed', {
+        error: err?.message || String(err),
+        status: err?.status || null,
+      });
+    } finally {
+      if (!stopped) timer = setTimeout(tick, intervalMs);
+    }
+  }
+
+  debugLog('reminder-ticker', 'start', { intervalMs });
+  // Start with an initial small delay so the daemon's HTTP server is
+  // up before the first tick.
+  timer = setTimeout(tick, 5000);
+
+  return {
+    stop() {
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+  };
+}

package/src/core/runtime-contract.mjs

@@ -42,7 +42,7 @@ import { normalizeServiceType } from './runtime-registry.mjs';
  * @property {(bindingId: string) => any} getBinding
  * @property {(filters?: Record<string, any>) => any[]} listBindings
  * @property {(bindingId: string) => Promise<void>} [deleteBinding]
- * @property {(binding: any) => Promise<any>} [cacheBinding]
+ * @property {(binding: any) => Promise<any>} [persistBinding]
  * @property {(binding: any) => Promise<any>} upsertBinding
  * @property {(inbound: any, runtimeName: string) => Promise<string>} buildImageMessageFromInbound
  * @property {any} logger

package/src/core/runtime-support.mjs

@@ -1,4 +1,5 @@
 import { getStreamingMode } from './config.mjs';
+import { getAgentHome } from './agent-home.mjs';
 const ERROR_MAX_CHARS = 500;
 const DEFAULT_DELTA_FLUSH_MS = 250;
 const DEFAULT_DELTA_FLUSH_CHARS = 64;
@@ -15,7 +16,7 @@ function runtimeContextLines(binding, info = {}) {
   const lines = [];
   if (meta.sessionId) lines.push(`Session: ${meta.sessionId}`);
   if (info.turnId) lines.push(`Turn: ${info.turnId}`);
-  if (meta.cwd || meta.workdir) lines.push(`Workdir: ${meta.cwd || meta.workdir}`);
+  if (binding?.id) lines.push(`Workdir: ${getAgentHome(binding.id)}`);
   return lines;
 }
 
@@ -74,39 +75,40 @@ export async function recordActivity(adapter, binding, inbound, result) {
 export async function reportSubprocessFailure({ adapter, binding, inbound, runtimeName, info }) {
   if (!info || info.ok) return;
   const seconds = ((info.durationMs || 0) / 1000).toFixed(1);
-  if (runtimeName === 'Codex' && isRuntimeGatewayFailure(info)) {
-    await sendAdapterMessage(adapter, binding, {
-      type: 'assistant',
-      text: buildCodexGatewayFailureText({ binding, info, seconds }),
-      media: [],
-      turnId: inbound?.messageId || null,
-      replyToMessageId: inbound?.messageId || null,
-    });
-    return;
-  }
 
-  let summary;
-  if (info.kind === 'killed') {
-    summary = `⚠️ ${runtimeName} was killed by signal ${info.signal} after ${seconds}s.`;
-  } else if (info.kind === 'spawn-failed') {
-    summary = `⚠️ ${runtimeName} failed to spawn: ${info.error || 'unknown error'}.`;
-  } else if (info.kind === 'gateway-timeout') {
-    summary = `⚠️ ${runtimeName} did not respond after ${seconds}s (timeout).`;
-  } else if (info.kind === 'gateway-error') {
-    summary = `⚠️ ${runtimeName} returned an error after ${seconds}s.`;
-  } else if (typeof info.code === 'number') {
-    summary = `⚠️ ${runtimeName} exited with code ${info.code} after ${seconds}s.`;
+  let text;
+  if (runtimeName === 'Codex' && isRuntimeGatewayFailure(info)) {
+    text = buildCodexGatewayFailureText({ binding, info, seconds });
   } else {
-    summary = `⚠️ ${runtimeName} failed after ${seconds}s.`;
+    let summary;
+    if (info.kind === 'killed') {
+      summary = `⚠️ ${runtimeName} was killed by signal ${info.signal} after ${seconds}s.`;
+    } else if (info.kind === 'spawn-failed') {
+      summary = `⚠️ ${runtimeName} failed to spawn: ${info.error || 'unknown error'}.`;
+    } else if (info.kind === 'gateway-timeout') {
+      summary = `⚠️ ${runtimeName} did not respond after ${seconds}s (timeout).`;
+    } else if (info.kind === 'gateway-error') {
+      summary = `⚠️ ${runtimeName} returned an error after ${seconds}s.`;
+    } else if (typeof info.code === 'number') {
+      summary = `⚠️ ${runtimeName} exited with code ${info.code} after ${seconds}s.`;
+    } else {
+      summary = `⚠️ ${runtimeName} failed after ${seconds}s.`;
+    }
+    const detail = truncateError(info.errorMessage);
+    text = detail ? `${summary}\n\n${detail}` : `${summary}\n\nCheck ~/.ticlawk/ticlawk.log on the host for details.`;
   }
-  const detail = truncateError(info.errorMessage);
-  const text = detail ? `${summary}\n\n${detail}` : `${summary}\n\nCheck ~/.ticlawk/ticlawk.log on the host for details.`;
-  await sendAdapterMessage(adapter, binding, {
-    type: 'assistant',
+
+  // Runtime never got to invoke `ticlawk message send`, so the daemon
+  // speaks for the agent. visibility='admin' so the message reaches
+  // owner/admin members only — the enqueue_message_deliveries trigger
+  // skips fan-out to member-role agents, breaking what would otherwise
+  // be a failure→fan-out→failure cascade when several agents share a
+  // broken runtime.
+  await adapter.postAgentReply(binding, {
+    conversationId: inbound?.conversationId || null,
     text,
-    media: [],
-    turnId: inbound?.messageId || null,
     replyToMessageId: inbound?.messageId || null,
+    visibility: 'admin',
   });
 }
 

package/src/core/ticlawk-control.mjs

@@ -30,7 +30,7 @@ function createUpsertBindingWithSync(runtimes, adapter) {
   };
 }
 
-function createCacheBinding(runtimes, getAdapter) {
+function createPersistBinding(runtimes, getAdapter) {
   return async (binding) => {
     const nextBinding = await upsertBinding(binding);
     const runtime = nextBinding?.runtime ? runtimes[nextBinding.runtime] : null;
@@ -48,7 +48,7 @@ export async function createTiclawkController(adapterId = ADAPTER_ID) {
   const { runtimes } = await buildRuntimeContext();
   const resolveRuntimeBinding = createResolveRuntimeBinding(runtimes);
   let adapter;
-  const cacheBinding = createCacheBinding(runtimes, () => adapter);
+  const persistBinding = createPersistBinding(runtimes, () => adapter);
   let syncBinding = async (binding) => {
     if (!adapter) {
       throw new Error('adapter not initialized');
@@ -64,7 +64,7 @@ export async function createTiclawkController(adapterId = ADAPTER_ID) {
     deleteBinding,
     findBindingByTarget,
     resolveRuntimeBinding,
-    cacheBinding: (binding) => cacheBinding(binding),
+    persistBinding: (binding) => persistBinding(binding),
     upsertBinding: (binding) => syncBinding(binding),
     buildImageMessageFromInbound,
     logger,

package/src/migrate/write-initial-memory.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+// Seed the slock-style per-agent home + MEMORY.md for every paired
+// agent in the linked Supabase project.
+//
+//   ~/.ticlawk/agents/<agent_id>/MEMORY.md
+//
+// This replaces the Phase-B variant that wrote MEMORY.md into each
+// agent's *project* workdir. The new design follows slock exactly:
+// agent cwd = its own home dir, MEMORY.md lives in cwd.
+//
+// Usage:
+//   node src/migrate/write-initial-memory.mjs           # dry-run
+//   node src/migrate/write-initial-memory.mjs --apply   # actually write
+//
+// Idempotent: existing MEMORY.md files are never overwritten.
+
+import fs from 'node:fs';
+import { ensureAgentHome, getAgentHome, getAgentMemoryPath } from '../core/agent-home.mjs';
+
+const APPLY = process.argv.includes('--apply');
+
+function loadEnv(file) {
+  const text = fs.readFileSync(file, 'utf8');
+  const out = {};
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    const k = trimmed.slice(0, eq).trim();
+    let v = trimmed.slice(eq + 1).trim();
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+      v = v.slice(1, -1);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+
+const ENV_PATH = '/home/wei/Projects/ticlawk/.env.local';
+const env = loadEnv(ENV_PATH);
+const SUPABASE_URL = env.SUPABASE_URL;
+const SUPABASE_SECRET_KEY = env.SUPABASE_SECRET_KEY;
+if (!SUPABASE_URL || !SUPABASE_SECRET_KEY) {
+  console.error('Missing SUPABASE_URL or SUPABASE_SECRET_KEY in', ENV_PATH);
+  process.exit(2);
+}
+
+async function rest(pathRel, init = {}) {
+  const res = await fetch(`${SUPABASE_URL}/rest/v1/${pathRel}`, {
+    ...init,
+    headers: {
+      apikey: SUPABASE_SECRET_KEY,
+      Authorization: `Bearer ${SUPABASE_SECRET_KEY}`,
+      'Content-Type': 'application/json',
+      ...(init.headers || {}),
+    },
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`REST ${pathRel} → ${res.status}: ${body}`);
+  }
+  return res.json();
+}
+
+async function main() {
+  const agents = await rest('agents?select=id,name,display_name,service_type,meta');
+  const plan = agents.map((agent) => ({
+    agent,
+    home: getAgentHome(agent.id),
+    memoryPath: getAgentMemoryPath(agent.id),
+    already: fs.existsSync(getAgentMemoryPath(agent.id)),
+  }));
+
+  console.log(`[memory-migrate] ${plan.length} agents; mode=${APPLY ? 'apply' : 'dry-run'}`);
+  for (const p of plan) {
+    const tag = p.already ? 'SKIP ' : 'WRITE';
+    const note = p.already ? 'MEMORY.md already present' : `→ ${p.memoryPath}`;
+    console.log(`[memory-migrate] ${tag} ${p.agent.name || p.agent.id}: ${note}`);
+  }
+
+  if (!APPLY) {
+    console.log('[memory-migrate] dry-run done. Re-run with --apply to write files.');
+    return;
+  }
+
+  let written = 0;
+  for (const p of plan) {
+    if (p.already) continue;
+    ensureAgentHome(p.agent.id, {
+      displayName: p.agent.display_name || p.agent.name || null,
+    });
+    written += 1;
+  }
+  console.log(`[memory-migrate] wrote ${written} MEMORY.md files (skipped ${plan.length - written}).`);
+}
+
+main().catch((err) => {
+  console.error('[memory-migrate] failed:', err.message);
+  process.exit(1);
+});