ticlawk 0.1.16-dev.4 → 0.1.16-dev.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticlawk",
-  "version": "0.1.16-dev.4",
+  "version": "0.1.16-dev.7",
   "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

@@ -436,6 +436,20 @@ export async function uploadAgentAttachment({
   });
 }
 
+export async function uploadAgentAvatar({
+  actingAgentId, filename, contentType, dataBase64,
+}) {
+  return apiFetch('/api/agent/profile/avatar', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      filename,
+      content_type: contentType,
+      data_base64: dataBase64,
+    }),
+  });
+}
+
 export async function viewAgentAttachment({ actingAgentId, assetId }) {
   const params = new URLSearchParams();
   params.set('acting_as_agent_id', actingAgentId);

package/src/adapters/ticlawk/index.mjs

@@ -27,6 +27,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
@@ -119,7 +145,7 @@ function buildGroupContextBlock(msg) {
 // 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).
+// nudge.
 function buildWakePromptText({ envelopeHeader, target, rawText, groupContext }) {
   const body = `${envelopeHeader} ${rawText || ''}`.trim();
   const lines = ['New message received:', '', body];
@@ -149,8 +175,8 @@ export function normalizeInboundMessage(msg) {
   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: …]`).
+  // who has already acknowledged it: `[task #N status=… assignee=…]` +
+  // `[reactions: …]`.
   const taskSuffix = buildTaskSuffix(enriched);
   const reactionsSuffix = buildReactionsSuffix(enriched);
   const header = baseHeader + taskSuffix + reactionsSuffix;
@@ -257,51 +283,46 @@ 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: hostId },
-    runtime_host_id: hostId,
-    runtime_host_label: getRuntimeHostLabelFromPayload(agent) || undefined,
-    runtime,
-    runtimeMeta: {
-      ...projectRuntimeMeta(agent?.meta),
-      runtimeVersion: normalizeRuntimeVersion(agent?.runtime_version),
-    },
-    displayName: agent?.display_name || agent?.name || agentId,
-    status: agent?.status || 'connected',
-  };
-}
-
-// 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;
+// 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: hostId },
     runtime_host_id: hostId,
-    runtime_host_label: getRuntimeHostLabelFromPayload(msg) || undefined,
+    runtime_host_label: getRuntimeHostLabelFromPayload(source) || undefined,
     runtime,
     runtimeMeta: {
-      ...projectRuntimeMeta(msg?.agent_meta),
-      runtimeVersion: normalizeRuntimeVersion(msg?.agent_runtime_version),
+      ...projectRuntimeMeta(meta),
+      runtimeVersion: normalizeRuntimeVersion(runtimeVersion),
     },
-    displayName: msg?.agent_display_name || msg?.agent_name || agentId,
-    status: msg?.agent_status || 'connected',
+    displayName,
+    status,
   };
 }
 
@@ -456,8 +477,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;
@@ -633,7 +652,7 @@ export function createTiclawkAdapter(ctx) {
           continue;
         }
 
-        const binding = await ctx.persistBinding(buildBindingFromDeliveryRow(msg));
+        const binding = await ctx.persistBinding(buildBindingFromSource(msg));
         if (!binding?.runtime) {
           throw new Error('claimed message missing runtime binding');
         }
@@ -733,7 +752,7 @@ export function createTiclawkAdapter(ctx) {
         continue;
       }
       try {
-        await ctx.persistBinding(buildBindingFromAgentRow(agent));
+        await ctx.persistBinding(buildBindingFromSource(agent));
         hydrated += 1;
       } catch (err) {
         debugError('ticlawk', 'binding.hydrate-failed', {
@@ -883,23 +902,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);

package/src/cli/agent-commands.mjs

@@ -17,7 +17,8 @@
  *   ticlawk server info [--refresh]
  *
  * `ticlawk message send` reads the message body from stdin so heredocs
- * work cleanly (matching the Slock convention).
+ * work cleanly — quotes, backticks, and code blocks survive without
+ * shell-quoting gymnastics.
  */
 
 import { readFileSync, statSync, writeFileSync } from 'node:fs';
@@ -544,13 +545,12 @@ export async function runProfileUpdateCommand(args) {
   }
   let avatarUrl = null;
   if (avatarFile) {
-    // Re-use the attachment upload path then set the public_url as the avatar.
-    const upload = await uploadFileViaDaemon(env, avatarFile);
+    const upload = await uploadAvatarViaDaemon(env, avatarFile);
     if (!upload.ok) {
       console.error(`avatar upload failed: ${upload.error}`);
       return 1;
     }
-    avatarUrl = upload.publicUrl;
+    avatarUrl = upload.url;
   }
   const res = await daemonRequest({
     method: 'POST',
@@ -566,6 +566,34 @@ export async function runProfileUpdateCommand(args) {
   return exitFromStatus(res.statusCode);
 }
 
+async function uploadAvatarViaDaemon(env, filePath) {
+  let stat;
+  try { stat = statSync(filePath); } catch (err) {
+    return { ok: false, error: `cannot stat ${filePath}: ${err.message}` };
+  }
+  if (!stat.isFile()) return { ok: false, error: `${filePath} is not a regular file` };
+  const contentType = inferContentType(filePath);
+  if (!contentType.startsWith('image/')) {
+    return { ok: false, error: `avatar must be an image (got content_type ${contentType})` };
+  }
+  const data = readFileSync(filePath);
+  const res = await daemonRequest({
+    method: 'POST',
+    path: '/agent/profile/avatar',
+    headers: commonHeaders(env),
+    body: {
+      filename: basename(filePath),
+      content_type: contentType,
+      data_base64: data.toString('base64'),
+    },
+  });
+  if (res.statusCode < 200 || res.statusCode >= 300) {
+    return { ok: false, error: res.body?.error || `HTTP ${res.statusCode}` };
+  }
+  if (!res.body?.url) return { ok: false, error: 'avatar upload returned no url' };
+  return { ok: true, url: res.body.url };
+}
+
 async function uploadFileViaDaemon(env, filePath) {
   let stat;
   try { stat = statSync(filePath); } catch (err) {
@@ -587,7 +615,11 @@ async function uploadFileViaDaemon(env, filePath) {
   if (res.statusCode < 200 || res.statusCode >= 300) {
     return { ok: false, error: res.body?.error || `HTTP ${res.statusCode}` };
   }
-  return { ok: true, assetId: res.body?.asset?.asset_id, publicUrl: res.body?.public_url };
+  const asset = res.body?.data;
+  if (!asset?.asset_id || !asset?.url) {
+    return { ok: false, error: 'attachment upload returned no asset' };
+  }
+  return { ok: true, assetId: asset.asset_id, url: asset.url, expiresAt: asset.expires_at };
 }
 
 function inferContentType(filePath) {

package/src/core/agent-cli-handlers.mjs

@@ -587,8 +587,8 @@ export async function handleAttachmentUpload(req, body, ctx) {
     });
     debugLog('agent-cli', 'attachment.upload', {
       actingAgentId,
-      asset_id: data?.asset?.asset_id,
-      bytes: data?.asset?.size_bytes,
+      asset_id: data?.data?.asset_id,
+      bytes: data?.data?.size_bytes,
     });
     return { status: 200, body: data };
   } catch (err) {
@@ -596,6 +596,28 @@ export async function handleAttachmentUpload(req, body, ctx) {
   }
 }
 
+export async function handleProfileAvatarUpload(req, body, ctx) {
+  const actingAgentId = getActingAgentId(req, body);
+  const v = validateActingAgent(actingAgentId, ctx);
+  if (!v.ok) return { status: v.status, body: { error: v.error } };
+  if (!body?.data_base64) return { status: 400, body: { error: 'data_base64 is required' } };
+  if (!body?.content_type || !String(body.content_type).startsWith('image/')) {
+    return { status: 400, body: { error: 'content_type must be image/*' } };
+  }
+  try {
+    const data = await api.uploadAgentAvatar({
+      actingAgentId,
+      filename: body?.filename || 'avatar.bin',
+      contentType: body.content_type,
+      dataBase64: body.data_base64,
+    });
+    debugLog('agent-cli', 'avatar.upload', { actingAgentId, url: data?.url });
+    return { status: 200, body: data };
+  } catch (err) {
+    return { status: err?.status || 500, body: { error: err?.message || 'avatar upload failed' } };
+  }
+}
+
 export async function handleAttachmentView(req, query, ctx) {
   const actingAgentId = getActingAgentId(req, query);
   const v = validateActingAgent(actingAgentId, ctx);

package/src/core/agent-home.mjs

@@ -1,14 +1,10 @@
 /**
- * Per-agent slock-style home directory: ~/.ticlawk/agents/<agent_id>/
+ * Per-agent home directory: ~/.ticlawk/agents/<agent_id>/
  *
- * This is the agent's authoritative workspace. The daemon spawns every
- * runtime with this as cwd; the agent's MEMORY.md, notes/, and any
- * artifacts it produces live here. No project binding.
- *
- * Following slock's daemon model (dist/chunk-M4A5QPUN.js:5079) —
- * dataDir = ~/.slock/agents, agentDataDir = <dataDir>/<id>, and every
- * driver.spawn() receives `workingDirectory: agentDataDir`. One MEMORY.md
- * per agent, lives in cwd, agent reads it via `cat MEMORY.md`.
+ * The agent's authoritative workspace. The daemon spawns every runtime
+ * with this as cwd; the agent's MEMORY.md, notes/, and any artifacts
+ * it produces live here. No project binding — one MEMORY.md per agent,
+ * lives in cwd, agent reads it via `cat MEMORY.md`.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';

package/src/core/http.mjs

@@ -11,6 +11,7 @@ import {
   handleMessageRead,
   handleMessageSearch,
   handleMessageSend,
+  handleProfileAvatarUpload,
   handleProfileShow,
   handleProfileUpdate,
   handleReminderCancel,
@@ -148,6 +149,12 @@ export function startLocalHttpServer({ port, adapter, ctx }) {
         const r = await handleProfileUpdate(req, body, cliCtx);
         return writeJson(res, r.status, r.body);
       }
+      if (urlNoQuery === '/agent/profile/avatar' && method === 'POST') {
+        const body = await readJsonBody(req);
+        if (body === null) return writeJson(res, 400, { error: 'invalid json body' });
+        const r = await handleProfileAvatarUpload(req, body, cliCtx);
+        return writeJson(res, r.status, r.body);
+      }
       if (urlNoQuery === '/agent/attachment/upload' && method === 'POST') {
         const body = await readJsonBody(req);
         if (body === null) return writeJson(res, 400, { error: 'invalid json body' });

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

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-// Seed the slock-style per-agent home + MEMORY.md for every paired
-// agent in the linked Supabase project.
+// Seed the 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.
+// Replaces the Phase-B variant that wrote MEMORY.md into each agent's
+// project workdir. Each agent now has its own home dir as cwd, with
+// MEMORY.md living at the root of that home.
 //
 // Usage:
 //   node src/migrate/write-initial-memory.mjs           # dry-run

package/src/runtimes/_shared/standing-prompt.mjs

@@ -1,19 +1,12 @@
 /**
  * Standing prompt injected into every runtime turn.
  *
- * Structurally a port of Slock's "CLI variant" system prompt
- * (照抄 — see the upstream @slock-ai/daemon source at
- *  dist/chunk-M4A5QPUN.js `buildPrompt`).
- *
- * Substitutions applied:
- *   slock   → ticlawk
- *   channel → group
- *   command surface trimmed to what Ticlawk actually exposes today
- *
- * Adapted sections deliberately preserved verbatim where they encode the
- * etiquette rules that make multi-agent coordination work without
- * runtime-level orchestration. Trim with care; this prompt has been
- * field-calibrated upstream.
+ * Encodes the agent's communication contract: how to receive messages,
+ * how to reply (always via the `ticlawk` CLI), how to handle ambient
+ * vs mention traffic, task lifecycle, and the per-agent home-dir +
+ * MEMORY.md workspace convention. Trim with care — the etiquette
+ * sections are load-bearing for multi-agent coordination without
+ * runtime-level orchestration.
  */
 
 const STANDING_PROMPT = `You are an agent in Ticlawk — a collaborative platform for human-AI

package/src/runtimes/claude-code/index.mjs

@@ -12,7 +12,6 @@ import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
 import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
 import { ensureAgentHome } from '../../core/agent-home.mjs';
 import {
-  createCCSession,
   getClaudeCodeRuntimeHealth,
   runCCPrompt,
   streamCCPrompt,
@@ -28,7 +27,6 @@ import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
 import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
-  sendAdapterMessage,
   recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
@@ -38,15 +36,9 @@ import {
 export const claudeCodeRuntime = {
   name: 'claude_code',
 
-  // Start a new Claude session without blocking on local transcript
-  // discovery. The live turn path trusts stdout/session_id; transcript
-  // indexing is a separate concern.
-  async createSession({ projectDir, text, claudePath }) {
-    return createCCSession({ projectDir, message: text, claudePath });
-  },
-
-  // Run a Claude turn and wait for the final result on stdout. This is
-  // the worker-first path used by the adapter for direct reply delivery.
+  // Run a Claude turn and wait for the final result on stdout. Used by
+  // deliverTurn when streaming is disabled; both fresh sessions
+  // (sessionId=null) and resumed sessions go through here.
   runTurn({ sessionId, projectDir, claudePath, agentEnv }, text, opts = {}) {
     return runCCPrompt({
       sessionId,
@@ -130,109 +122,37 @@ export const claudeCodeRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    // slock-style: cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
+    // cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
     const projectDir = ensureAgentHome(binding.id, {
       displayName: binding.display_name || binding.name || null,
     });
-    const sessionId = meta.sessionId || binding.id;
     const runtimeClaudePath = meta.claudePath || meta.runtimePath || null;
 
     const message = inbound.action === 'image'
       ? await buildImageMessageFromInbound(inbound, 'claude-code')
       : inbound.text;
 
+    // shouldRotate=true means meta.sessionId is missing or invalidated.
+    // We pass sessionId=null so `claude` creates a fresh session; the new
+    // session_id is captured from stream events and persisted below.
+    // Unifying rotate + non-rotate into one path means the standing prompt
+    // is always attached, so the agent uses the CLI to reply on every
+    // turn — including the first.
     const shouldRotate = !meta.sessionId || meta.rotatePending;
-    if (shouldRotate) {
-      await emitWorkerEvent({
-        adapter,
-        binding,
-        agent: this.name,
-        sessionId: sessionId || binding.id,
-        cwd: projectDir,
-        replyToMessageId: inbound.messageId || null,
-        event: {
-          hook_event_name: 'worker.turn.start',
-          worker_event_name: 'worker.turn.start',
-        },
-        logger: ctx.logger,
-      });
-      try {
-        const claudePath = requireClaudePath(runtimeClaudePath);
-        const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
-        const created = await this.createSession({ projectDir, text: message, claudePath });
-        const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-          sessionId: created.sessionId,
-          path: null,
-          runtimePath: claudePath,
-          claudePath,
-          claudeVersion,
-          rotatePending: false,
-          lastRotatedAt: new Date().toISOString(),
-        }, { status: 'connected' });
-        if (created.resultText && created.resultText.trim()) {
-          await sendAdapterMessage(adapter, nextBinding, {
-            type: 'assistant',
-            text: created.resultText,
-            media: [],
-            replyToMessageId: inbound.messageId || null,
-          });
-        }
-        await emitWorkerEvent({
-          adapter,
-          binding: nextBinding,
-          agent: this.name,
-          sessionId: created.sessionId,
-          cwd: projectDir,
-          replyToMessageId: inbound.messageId || null,
-          event: {
-            hook_event_name: 'Stop',
-            worker_event_name: 'worker.turn.complete',
-          },
-          logger: ctx.logger,
-        });
-        return true;
-      } catch (err) {
-        await emitWorkerEvent({
-          adapter,
-          binding,
-          agent: this.name,
-          sessionId: sessionId || binding.id,
-          cwd: projectDir,
-          replyToMessageId: inbound.messageId || null,
-          event: {
-            hook_event_name: 'worker.turn.error',
-            worker_event_name: 'worker.turn.error',
-            error: err?.message || 'Claude Code failed',
-          },
-          logger: ctx.logger,
-        });
-        await reportSubprocessFailure({
-          adapter,
-          binding,
-          inbound,
-          runtimeName: 'Claude Code',
-          info: err?.info || {
-            ok: false,
-            kind: 'exit-error',
-            errorMessage: err?.message || 'Claude Code failed',
-            durationMs: 0,
-          },
-        });
-        return terminalRuntimeFailure(err?.message || 'Claude Code failed');
-      }
-    }
+    const targetSessionId = shouldRotate ? null : meta.sessionId;
+    const errEventSessionId = meta.sessionId || binding.id;
 
     try {
       const claudePath = requireClaudePath(runtimeClaudePath);
       const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId,
+        sessionId: meta.sessionId,
         hostId: binding.runtime_host_id,
       });
       const appendSystemPrompt = buildStandingPrompt({ agentId: binding.id });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId, projectDir, claudePath, agentEnv }, message, {
+        ? await this.runTurnStream({ sessionId: targetSessionId, projectDir, claudePath, agentEnv }, message, {
             appendSystemPrompt,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
@@ -240,7 +160,7 @@ export const claudeCodeRuntime = {
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || sessionId,
+                  sessionId: event.sessionId || targetSessionId || binding.id,
                   cwd: projectDir,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -254,7 +174,7 @@ export const claudeCodeRuntime = {
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || sessionId,
+                  sessionId: event.sessionId || targetSessionId || binding.id,
                   cwd: projectDir,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -267,12 +187,14 @@ export const claudeCodeRuntime = {
               }
             },
           })
-        : await this.runTurn({ sessionId, projectDir, claudePath, agentEnv }, message, { appendSystemPrompt });
+        : await this.runTurn({ sessionId: targetSessionId, projectDir, claudePath, agentEnv }, message, { appendSystemPrompt });
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
         sessionId: result?.sessionId || meta.sessionId,
         runtimePath: claudePath,
         claudePath,
         claudeVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
       await recordActivity(adapter, nextBinding, inbound, {
         ...result,
@@ -282,7 +204,7 @@ export const claudeCodeRuntime = {
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || sessionId,
+        sessionId: result?.sessionId || targetSessionId || binding.id,
         cwd: projectDir,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -297,7 +219,7 @@ export const claudeCodeRuntime = {
         adapter,
         binding,
         agent: this.name,
-        sessionId,
+        sessionId: errEventSessionId,
         cwd: projectDir,
         replyToMessageId: inbound.messageId || null,
         event: {

package/src/runtimes/codex/index.mjs

@@ -130,7 +130,7 @@ export const codexRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    // slock-style: cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
+    // cwd is the per-agent home dir under ~/.ticlawk/agents/<id>/.
     // ensureAgentHome creates it + seeds MEMORY.md if missing.
     const agentHome = ensureAgentHome(binding.id, {
       displayName: binding.display_name || binding.name || null,