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

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

@@ -7,12 +7,11 @@
  * runtime owns the binary-level details.
  */
 
-import { existsSync } from 'node:fs';
 import { basename } from 'node:path';
 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,
@@ -24,12 +23,9 @@ import {
 } from './session.mjs';
 import { discoverSessions } from './transcripts.mjs';
 import { buildImageMessageFromInbound } from '../../core/media/inbound.mjs';
-import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
 import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
-  sendAdapterMessage,
-  recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
@@ -38,15 +34,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,
@@ -97,8 +87,6 @@ export const claudeCodeRuntime = {
         runtimeMeta: {
           sessionId: session.sessionId,
           project: session.project,
-          workdir: session.projectDir,
-          projectDir: session.projectDir,
           path: session.path,
           runtimePath: claudePath,
           claudePath,
@@ -108,21 +96,12 @@ export const claudeCodeRuntime = {
       };
     }
 
-    if (!requestedProjectDir) {
-      throw new Error('projectDir or sessionId is required for claude_code binding');
-    }
-    if (!existsSync(requestedProjectDir)) {
-      throw new Error(`project dir not found locally: ${requestedProjectDir}`);
-    }
-
     return {
       runtime: this.name,
-      displayName: payload?.name || basename(requestedProjectDir) || 'Claude Code',
+      displayName: payload?.name || (requestedProjectDir ? basename(requestedProjectDir) : 'Claude Code'),
       runtimeMeta: {
         sessionId: null,
-        project: basename(requestedProjectDir) || '',
-        workdir: requestedProjectDir,
-        projectDir: requestedProjectDir,
+        project: requestedProjectDir ? basename(requestedProjectDir) : '',
         path: null,
         runtimePath: claudePath,
         claudePath,
@@ -141,117 +120,37 @@ export const claudeCodeRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    const projectDir = meta.projectDir;
-    const sessionId = meta.sessionId || binding.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 runtimeClaudePath = meta.claudePath || meta.runtimePath || null;
 
-    if (!projectDir || !existsSync(projectDir)) {
-      await sendAdapterMessage(adapter, binding, {
-        type: 'assistant',
-        text: `⚠️ Claude Code project dir not found: ${projectDir || '(missing)'}`,
-        media: [],
-        replyToMessageId: inbound.messageId || null,
-      });
-      return true;
-    }
-
     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,
-          projectDir,
-          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') {
@@ -259,7 +158,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: {
@@ -273,7 +172,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: {
@@ -286,22 +185,20 @@ 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,
-        media: normalizeOutboundMedia(result),
-      });
       await emitWorkerEvent({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || sessionId,
+        sessionId: result?.sessionId || targetSessionId || binding.id,
         cwd: projectDir,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -316,7 +213,7 @@ export const claudeCodeRuntime = {
         adapter,
         binding,
         agent: this.name,
-        sessionId,
+        sessionId: errEventSessionId,
         cwd: projectDir,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -349,7 +246,7 @@ export const claudeCodeRuntime = {
       binding,
       agent: this.name,
       sessionId: meta.sessionId || binding.id,
-      cwd: meta.projectDir || '',
+      cwd: ensureAgentHome(binding.id) || '',
       event: {
         hook_event_name: 'Stop',
         worker_event_name: 'worker.turn.complete',

package/src/runtimes/codex/index.mjs

@@ -5,7 +5,6 @@
  * and discover local sessions.
  */
 
-import { existsSync } from 'node:fs';
 import { basename } from 'node:path';
 import {
   createCodexSession,
@@ -19,13 +18,10 @@ import {
   requireCodexPath,
 } from './session.mjs';
 import { buildCodexInputFromInbound } from '../../core/media/inbound.mjs';
-import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
 import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
   createDeltaAggregator,
-  sendAdapterMessage,
-  recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
@@ -33,6 +29,7 @@ import {
 } from '../../core/runtime-support.mjs';
 import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
 import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
+import { ensureAgentHome } from '../../core/agent-home.mjs';
 
 export const codexRuntime = {
   name: 'codex',
@@ -98,8 +95,6 @@ export const codexRuntime = {
         displayName: payload.name || basename(session.cwd) || 'Codex',
         runtimeMeta: {
           sessionId: session.sessionId,
-          workdir: session.cwd,
-          cwd: session.cwd,
           path: session.path || null,
           runtimePath: codexPath,
           codexPath,
@@ -109,20 +104,11 @@ export const codexRuntime = {
       };
     }
 
-    if (!requestedCwd) {
-      throw new Error('cwd or sessionId is required for codex binding');
-    }
-    if (!existsSync(requestedCwd)) {
-      throw new Error(`codex cwd not found locally: ${requestedCwd}`);
-    }
-
     return {
       runtime: this.name,
-      displayName: payload.name || basename(requestedCwd) || 'Codex',
+      displayName: payload.name || (requestedCwd ? basename(requestedCwd) : 'Codex'),
       runtimeMeta: {
         sessionId: null,
-        workdir: requestedCwd,
-        cwd: requestedCwd,
         path: null,
         runtimePath: codexPath,
         codexPath,
@@ -141,16 +127,11 @@ export const codexRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-
-    if (!meta.cwd || !existsSync(meta.cwd)) {
-      await sendAdapterMessage(adapter, binding, {
-        type: 'assistant',
-        text: `⚠️ Codex cwd not found: ${meta.cwd || '(missing)'}`,
-        media: [],
-        replyToMessageId: inbound.messageId || null,
-      });
-      return true;
-    }
+    // 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,
+    });
 
     const codexInput = inbound.action === 'image'
       ? await buildCodexInputFromInbound(inbound, 'codex')
@@ -168,7 +149,7 @@ export const codexRuntime = {
           agent: this.name,
           sessionId: sessionId || meta.sessionId || binding.id,
           turnId: turnId || null,
-          cwd: cwd || meta.cwd,
+          cwd: cwd || agentHome,
           replyToMessageId: inbound.messageId || null,
           event: {
             hook_event_name: 'worker.message.delta',
@@ -189,7 +170,7 @@ export const codexRuntime = {
       });
       const developerInstructions = buildStandingPrompt({ agentId: binding.id });
       const result = (shouldRotate || inbound.action === 'image' || shouldStreamRuntime(this.name, this))
-        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, codexPath: runtimeCodexPath, agentEnv }, message, {
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
             developerInstructions,
             onEvent: async (event) => {
@@ -200,7 +181,7 @@ export const codexRuntime = {
                   agent: this.name,
                   sessionId: event.sessionId || meta.sessionId || binding.id,
                   turnId: event.turnId || null,
-                  cwd: meta.cwd,
+                  cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
                   event: {
                     hook_event_name: 'worker.turn.start',
@@ -212,19 +193,18 @@ export const codexRuntime = {
                 deltaAggregator.push(event.text, {
                   sessionId: event.sessionId || meta.sessionId || binding.id,
                   turnId: event.turnId || null,
-                  cwd: meta.cwd,
+                  cwd: agentHome,
                 });
               }
             },
           })
-        : await this.runTurn({ sessionId: meta.sessionId, cwd: meta.cwd, codexPath: runtimeCodexPath, agentEnv }, message, {
+        : await this.runTurn({ sessionId: meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
           });
 
       await deltaAggregator.flush();
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
         sessionId: result?.sessionId || meta.sessionId,
-        cwd: result?.cwd || meta.cwd,
         path: result?.path || meta.path || null,
         runtimePath: runtimeCodexPath,
         codexPath: runtimeCodexPath,
@@ -232,17 +212,13 @@ export const codexRuntime = {
         rotatePending: false,
         lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      await recordActivity(adapter, nextBinding, inbound, {
-        ...result,
-        media: normalizeOutboundMedia(result),
-      });
       await emitWorkerEvent({
         adapter,
         binding: nextBinding,
         agent: this.name,
         sessionId: result?.sessionId || meta.sessionId || binding.id,
         turnId: result?.turnId || null,
-        cwd: result?.cwd || meta.cwd,
+        cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
           hook_event_name: 'Stop',
@@ -273,7 +249,7 @@ export const codexRuntime = {
         agent: this.name,
         sessionId: meta.sessionId || binding.id,
         turnId: failureInfo?.turnId || null,
-        cwd: meta.cwd,
+        cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
           hook_event_name: 'worker.turn.error',
@@ -300,7 +276,7 @@ export const codexRuntime = {
       binding,
       agent: this.name,
       sessionId: meta.sessionId || binding.id,
-      cwd: meta.cwd || '',
+      cwd: ensureAgentHome(binding.id) || '',
       event: {
         hook_event_name: 'Stop',
         worker_event_name: 'worker.turn.complete',

package/src/runtimes/openclaw/index.mjs

@@ -1,8 +1,27 @@
-import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
-import { reportSubprocessFailure, sendAdapterMessage, recordActivity, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
+import { reportSubprocessFailure, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
 import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
 import { GATEWAY_HOST, GATEWAY_PORT } from './identity.mjs';
-import { buildOpenClawSessionKey, normalizeOpenClawAgentId, resolveOpenClawWorkspace } from './target.mjs';
+
+// Cheap availability probe used by the harness picker. We can't use
+// isGatewayReady() here because the daemon only opens the gateway WS
+// after at least one openclaw binding exists (registerOpenClawChannel),
+// so an empty install would always look "unavailable" and you'd never
+// be able to pick it for the first time. Probing the gateway's plain
+// HTTP /health avoids that chicken-and-egg.
+const OPENCLAW_HEALTH_TIMEOUT_MS = 1500;
+async function probeOpenClawGatewayHealth() {
+  try {
+    const res = await fetch(`http://${GATEWAY_HOST}:${GATEWAY_PORT}/health`, {
+      signal: AbortSignal.timeout(OPENCLAW_HEALTH_TIMEOUT_MS),
+    });
+    if (!res.ok) return false;
+    const body = await res.json().catch(() => null);
+    return body?.ok === true;
+  } catch {
+    return false;
+  }
+}
+import { buildOpenClawSessionKey, normalizeOpenClawAgentId } from './target.mjs';
 import { askGateway, isGatewayReady, registerOpenClawChannel } from './gateway.mjs';
 
 // Tracks which (agentId, sessionKey) pairs already saw the standing
@@ -87,18 +106,24 @@ export const openClawRuntime = {
     return isGatewayReady();
   },
 
+  // Health probe for the harness picker. openclaw is gateway-based —
+  // "available" means the local openclaw gateway is up and responds to
+  // an unauthenticated /health request. Doesn't depend on the daemon
+  // having an open WS, so the picker can offer openclaw on a fresh
+  // install where no binding exists yet.
+  async health() {
+    return {
+      available: await probeOpenClawGatewayHealth(),
+      path: null,
+      version: null,
+    };
+  },
+
   async resolveBinding(payload) {
     if (!payload?.agentId) {
       throw new Error('agentId is required for openclaw binding');
     }
     const agentId = normalizeOpenClawAgentId(payload.agentId);
-    const workspace = String(
-      payload.workdir
-      || payload.projectDir
-      || payload.cwd
-      || resolveOpenClawWorkspace(agentId)
-      || '',
-    ).trim();
     const sessionKey = payload.sessionKey
       ? String(payload.sessionKey).trim()
       : buildOpenClawSessionKey(agentId);
@@ -110,11 +135,6 @@ export const openClawRuntime = {
         sessionKey,
         gatewayHost: GATEWAY_HOST,
         gatewayPort: GATEWAY_PORT,
-        ...(workspace ? {
-          workdir: workspace,
-          projectDir: workspace,
-          cwd: workspace,
-        } : {}),
       },
     };
   },
@@ -171,10 +191,6 @@ export const openClawRuntime = {
           });
         },
       });
-      await recordActivity(adapter, binding, inbound, {
-        ...result,
-        media: normalizeOutboundMedia(result),
-      });
       return true;
     } catch (err) {
       if (typeof adapter.emitEvent === 'function') {
@@ -212,18 +228,11 @@ export const openClawRuntime = {
     }
   },
 
-  async recoverInFlight(ctx) {
+  async recoverInFlight() {
+    // Just drain the persisted in-flight set — the user-facing notice
+    // that used to surface here went through the dead chat-projection
+    // path. OpenClaw is non-primary; this no-ops cleanly for now.
     const entries = recoverInFlightEntries();
-    for (const entry of entries) {
-      const binding = ctx.getBinding(entry.bindingId);
-      if (!binding) continue;
-      await sendAdapterMessage(ctx.adapter, binding, {
-        type: 'assistant',
-        text: '⚠️ Lost while ticlawk restarted.\n\nThis OpenClaw message was in flight when ticlawk restarted. Please retry your message.',
-        media: [],
-        replyToMessageId: entry.messageId || null,
-      }).catch(() => {});
-    }
     return entries.length;
   },
 

package/src/runtimes/openclaw/target.mjs

@@ -5,42 +5,12 @@
  * `agent:<id>:main` session key is derived internally when dispatching.
  */
 
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-let cachedOpenClawConfig = null;
-
-function loadOpenClawConfig() {
-  if (cachedOpenClawConfig !== null) return cachedOpenClawConfig;
-  const home = process.env.HOME || '';
-  const configPath = home ? join(home, '.openclaw', 'openclaw.json') : '';
-  if (!configPath || !existsSync(configPath)) {
-    cachedOpenClawConfig = {};
-    return cachedOpenClawConfig;
-  }
-  try {
-    cachedOpenClawConfig = JSON.parse(readFileSync(configPath, 'utf8')) || {};
-  } catch {
-    cachedOpenClawConfig = {};
-  }
-  return cachedOpenClawConfig;
-}
-
 export function normalizeOpenClawAgentId(value) {
   const trimmed = String(value || '').trim().toLowerCase();
   if (!trimmed) return 'main';
   return trimmed.replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'main';
 }
 
-export function resolveOpenClawWorkspace(agentId) {
-  const normalizedId = normalizeOpenClawAgentId(agentId);
-  const config = loadOpenClawConfig();
-  const agents = Array.isArray(config?.agents?.list) ? config.agents.list : [];
-  const matched = agents.find((agent) => normalizeOpenClawAgentId(agent?.id || agent?.name || '') === normalizedId);
-  const workspace = String(matched?.workspace || '').trim();
-  return workspace || '';
-}
-
 export function buildOpenClawSessionKey(agentId = 'main') {
   return `agent:${normalizeOpenClawAgentId(agentId)}:main`;
 }