ticlawk 0.1.15 → 0.1.16-dev.2

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,
@@ -25,12 +24,15 @@ import {
   shouldStreamRuntime,
   createDeltaAggregator,
   sendAdapterMessage,
-  sendResult,
+  recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
   isRuntimeGatewayFailure,
 } 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',
@@ -48,23 +50,26 @@ export const codexRuntime = {
     };
   },
 
-  runTurn({ sessionId, cwd, codexPath }, text, opts = {}) {
+  runTurn({ sessionId, cwd, codexPath, agentEnv }, text, opts = {}) {
     return runCodexPrompt({
       sessionId,
       cwd,
       message: text,
       codexPath,
+      agentEnv,
       input: opts.input,
       timeoutMs: opts.timeoutMs,
     });
   },
 
-  runTurnStream({ sessionId, cwd, codexPath }, text, opts = {}) {
+  runTurnStream({ sessionId, cwd, codexPath, agentEnv }, text, opts = {}) {
     return streamCodexPrompt({
       sessionId,
       cwd,
       message: text,
       codexPath,
+      agentEnv,
+      developerInstructions: opts.developerInstructions || null,
       input: opts.input,
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
@@ -93,8 +98,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,
@@ -104,20 +107,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,
@@ -136,16 +130,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;
-    }
+    // slock-style: 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')
@@ -163,7 +152,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',
@@ -177,9 +166,16 @@ export const codexRuntime = {
     try {
       const runtimeCodexPath = requireCodexPath(meta.codexPath || meta.runtimePath);
       const runtimeCodexVersion = getCodexRuntimeHealth(runtimeCodexPath).version || meta.codexVersion || null;
+      const agentEnv = buildAgentRuntimeEnv({
+        agentId: binding.id,
+        sessionId: meta.sessionId,
+        hostId: binding.runtime_host_id,
+      });
+      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 }, message, {
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, codexPath: runtimeCodexPath, agentEnv }, message, {
             input: codexInput,
+            developerInstructions,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
                 await emitWorkerEvent({
@@ -188,7 +184,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',
@@ -200,19 +196,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 }, 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,
@@ -220,7 +215,7 @@ export const codexRuntime = {
         rotatePending: false,
         lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      await sendResult(adapter, nextBinding, inbound, {
+      await recordActivity(adapter, nextBinding, inbound, {
         ...result,
         media: normalizeOutboundMedia(result),
       });
@@ -230,7 +225,7 @@ export const codexRuntime = {
         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',
@@ -261,7 +256,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',
@@ -288,7 +283,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/codex/session.mjs

@@ -221,13 +221,13 @@ function isSubAgentThread(thread) {
   return Boolean(source.subAgent || source.sub_agent);
 }
 
-export function runCodexPrompt({ sessionId, cwd, message, codexPath = null, timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS) }) {
+export function runCodexPrompt({ sessionId, cwd, message, codexPath = null, agentEnv = null, timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS) }) {
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
     const codexCommand = requireCodexPath(codexPath);
     const child = spawn(codexCommand, buildCodexExecArgs({ sessionId, message }), {
       cwd,
-      env: buildRuntimeEnv(),
+      env: buildRuntimeEnv(agentEnv || {}),
       stdio: ['ignore', 'pipe', 'ignore'],
     });
 
@@ -344,6 +344,8 @@ export function streamCodexPrompt({
   cwd,
   message,
   codexPath = null,
+  agentEnv = null,
+  developerInstructions = null,
   input = null,
   timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS),
   onEvent,
@@ -353,7 +355,7 @@ export function streamCodexPrompt({
     const codexCommand = requireCodexPath(codexPath);
     const child = spawn(codexCommand, ['app-server'], {
       cwd,
-      env: buildRuntimeEnv(),
+      env: buildRuntimeEnv(agentEnv || {}),
       stdio: ['pipe', 'pipe', 'ignore'],
     });
 
@@ -598,6 +600,7 @@ export function streamCodexPrompt({
             cwd,
             approvalPolicy: 'never',
             sandbox: 'danger-full-access',
+            ...(developerInstructions ? { developerInstructions } : {}),
           });
         } else {
           const started = await send('thread/start', {
@@ -605,6 +608,7 @@ export function streamCodexPrompt({
             model: process.env.CODEX_MODEL || null,
             approvalPolicy: 'never',
             sandbox: 'danger-full-access',
+            ...(developerInstructions ? { developerInstructions } : {}),
           });
           rootThreadId = started?.thread?.id || rootThreadId;
           threadPath = started?.thread?.path || threadPath;
@@ -636,7 +640,7 @@ export function streamCodexPrompt({
   });
 }
 
-export function createCodexSession({ cwd, message, codexPath = null, timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS) }) {
+export function createCodexSession({ cwd, message, codexPath = null, agentEnv = null, timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS) }) {
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
     const codexCommand = requireCodexPath(codexPath);
@@ -651,7 +655,7 @@ export function createCodexSession({ cwd, message, codexPath = null, timeoutMs =
       ],
       {
         cwd,
-        env: buildRuntimeEnv(),
+        env: buildRuntimeEnv(agentEnv || {}),
         stdio: ['ignore', 'pipe', 'ignore'],
       }
     );

package/src/runtimes/openclaw/index.mjs

@@ -1,8 +1,35 @@
 import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
-import { reportSubprocessFailure, sendAdapterMessage, sendResult, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
+import { reportSubprocessFailure, sendAdapterMessage, recordActivity, 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
+// prompt this process lifetime. OpenClaw's gateway holds session state
+// out of process, so we err on the side of "inject on first observed
+// turn after daemon restart"; the gateway dedupes redundant context.
+const standingPromptSeen = new Set();
 import { addInFlight, recoverInFlightEntries, removeInFlight } from './inflight.mjs';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { extname } from 'node:path';
@@ -80,18 +107,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);
@@ -103,11 +136,6 @@ export const openClawRuntime = {
         sessionKey,
         gatewayHost: GATEWAY_HOST,
         gatewayPort: GATEWAY_PORT,
-        ...(workspace ? {
-          workdir: workspace,
-          projectDir: workspace,
-          cwd: workspace,
-        } : {}),
       },
     };
   },
@@ -125,12 +153,24 @@ export const openClawRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    const prompt = inbound.action === 'image'
+    const rawPrompt = inbound.action === 'image'
       ? await buildOpenClawImagePrompt(inbound)
       : (inbound.text || '').trim();
     const agentId = normalizeOpenClawAgentId(meta.agentId || binding.id);
     const sessionId = String(meta.sessionKey || buildOpenClawSessionKey(agentId)).trim();
 
+    // Inject the standing prompt on the first observed turn after a
+    // daemon start for this (agent, session) pair. OpenClaw has no
+    // separate "system prompt" parameter on the gateway, so we prepend
+    // exactly once.
+    const standingKey = `${agentId}|${sessionId}`;
+    let prompt = rawPrompt;
+    if (!standingPromptSeen.has(standingKey)) {
+      const standing = buildStandingPrompt({ agentId: binding.id });
+      prompt = `${standing}\n\n---\n\n${rawPrompt}`;
+      standingPromptSeen.add(standingKey);
+    }
+
     if (inbound.messageId) {
       addInFlight({
         messageId: inbound.messageId,
@@ -152,7 +192,7 @@ export const openClawRuntime = {
           });
         },
       });
-      await sendResult(adapter, binding, inbound, {
+      await recordActivity(adapter, binding, inbound, {
         ...result,
         media: normalizeOutboundMedia(result),
       });

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`;
 }

package/src/runtimes/opencode/index.mjs

@@ -9,6 +9,9 @@
 
 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 {
   createOpenCodeSession,
   getOpenCodeRuntimeHealth,
@@ -27,7 +30,7 @@ import {
   shouldStreamRuntime,
   createDeltaAggregator,
   sendAdapterMessage,
-  sendResult,
+  recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
@@ -40,23 +43,27 @@ export const openCodeRuntime = {
     return createOpenCodeSession({ cwd, message: text, opencodePath });
   },
 
-  runTurn({ sessionId, cwd, opencodePath }, text, opts = {}) {
+  runTurn({ sessionId, cwd, opencodePath, agentEnv }, text, opts = {}) {
     return runOpenCodePrompt({
       sessionId,
       cwd,
       message: text,
       opencodePath,
+      agentEnv,
+      standingPrompt: opts.standingPrompt || null,
       files: opts.files,
       timeoutMs: opts.timeoutMs,
     });
   },
 
-  runTurnStream({ sessionId, cwd, opencodePath }, text, opts = {}) {
+  runTurnStream({ sessionId, cwd, opencodePath, agentEnv }, text, opts = {}) {
     return streamOpenCodePrompt({
       sessionId,
       cwd,
       message: text,
       opencodePath,
+      agentEnv,
+      standingPrompt: opts.standingPrompt || null,
       files: opts.files,
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
@@ -91,8 +98,6 @@ export const openCodeRuntime = {
         displayName: payload.name || session.title || basename(requestedCwd) || 'opencode',
         runtimeMeta: {
           sessionId: session.sessionId,
-          workdir: requestedCwd,
-          cwd: requestedCwd,
           runtimePath: opencodePath,
           opencodePath,
           opencodeVersion,
@@ -101,20 +106,11 @@ export const openCodeRuntime = {
       };
     }
 
-    if (!requestedCwd) {
-      throw new Error('cwd or sessionId is required for opencode binding');
-    }
-    if (!existsSync(requestedCwd)) {
-      throw new Error(`opencode cwd not found locally: ${requestedCwd}`);
-    }
-
     return {
       runtime: this.name,
-      displayName: payload.name || basename(requestedCwd) || 'opencode',
+      displayName: payload.name || (requestedCwd ? basename(requestedCwd) : 'opencode'),
       runtimeMeta: {
         sessionId: null,
-        workdir: requestedCwd,
-        cwd: requestedCwd,
         runtimePath: opencodePath,
         opencodePath,
         opencodeVersion,
@@ -133,16 +129,9 @@ export const openCodeRuntime = {
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
     const runtimeOpenCodePath = meta.opencodePath || meta.runtimePath || null;
-
-    if (!meta.cwd || !existsSync(meta.cwd)) {
-      await sendAdapterMessage(adapter, binding, {
-        type: 'assistant',
-        text: `⚠️ opencode cwd not found: ${meta.cwd || '(missing)'}`,
-        media: [],
-        replyToMessageId: inbound.messageId || null,
-      });
-      return true;
-    }
+    const agentHome = ensureAgentHome(binding.id, {
+      displayName: binding.display_name || binding.name || null,
+    });
 
     // For image inbound, resolve the attached media to local file paths
     // and forward them to opencode via `--file` (mirrors how Codex uses
@@ -189,7 +178,7 @@ export const openCodeRuntime = {
           binding,
           agent: this.name,
           sessionId: sessionId || meta.sessionId || binding.id,
-          cwd: cwd || meta.cwd,
+          cwd: cwd || agentHome,
           replyToMessageId: inbound.messageId || null,
           event: {
             hook_event_name: 'worker.message.delta',
@@ -204,8 +193,15 @@ export const openCodeRuntime = {
     try {
       const opencodePath = requireOpenCodePath(runtimeOpenCodePath);
       const opencodeVersion = getOpenCodeRuntimeHealth(opencodePath).version || meta.opencodeVersion || null;
+      const agentEnv = buildAgentRuntimeEnv({
+        agentId: binding.id,
+        sessionId: meta.sessionId,
+        hostId: binding.runtime_host_id,
+      });
+      const standingPrompt = buildStandingPrompt({ agentId: binding.id });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, opencodePath }, message, {
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, opencodePath, agentEnv }, message, {
+            standingPrompt,
             files,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
@@ -214,7 +210,7 @@ export const openCodeRuntime = {
                   binding,
                   agent: this.name,
                   sessionId: event.sessionId || meta.sessionId || binding.id,
-                  cwd: meta.cwd,
+                  cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
                   event: {
                     hook_event_name: 'worker.turn.start',
@@ -225,25 +221,24 @@ export const openCodeRuntime = {
               } else if (event?.type === 'message.delta' && event.text) {
                 deltaAggregator.push(event.text, {
                   sessionId: event.sessionId || meta.sessionId || binding.id,
-                  cwd: meta.cwd,
+                  cwd: agentHome,
                 });
               }
             },
           })
-        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, opencodePath }, message, { files });
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, opencodePath, agentEnv }, message, { files, standingPrompt });
 
       await deltaAggregator.flush();
 
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
         sessionId: result?.sessionId || meta.sessionId,
-        cwd: result?.cwd || meta.cwd,
         runtimePath: opencodePath,
         opencodePath,
         opencodeVersion,
         rotatePending: false,
         lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      await sendResult(adapter, nextBinding, inbound, {
+      await recordActivity(adapter, nextBinding, inbound, {
         ...result,
         media: normalizeOutboundMedia(result),
       });
@@ -252,7 +247,7 @@ export const openCodeRuntime = {
         binding: nextBinding,
         agent: this.name,
         sessionId: result?.sessionId || meta.sessionId || binding.id,
-        cwd: result?.cwd || meta.cwd,
+        cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
           hook_event_name: 'Stop',
@@ -268,7 +263,7 @@ export const openCodeRuntime = {
         binding,
         agent: this.name,
         sessionId: meta.sessionId || binding.id,
-        cwd: meta.cwd,
+        cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
           hook_event_name: 'worker.turn.error',
@@ -300,7 +295,7 @@ export const openCodeRuntime = {
       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/opencode/session.mjs

@@ -208,15 +208,24 @@ export function runOpenCodePrompt({
   message,
   files = [],
   opencodePath = null,
+  agentEnv = null,
+  standingPrompt = null,
   timeoutMs = Number(process.env.OPENCODE_RUN_TIMEOUT_MS || DEFAULT_OPENCODE_RUN_TIMEOUT_MS),
   onEvent,
 }) {
+  // opencode has no documented `--system` flag, so we prepend the
+  // standing prompt to the first-turn message body. Resumed sessions
+  // (sessionId set) skip injection because the model already saw it
+  // on the originating turn.
+  const finalMessage = standingPrompt && !sessionId
+    ? `${standingPrompt}\n\n---\n\n${message}`
+    : message;
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
     const opencodeCommand = requireOpenCodePath(opencodePath);
-    const child = spawn(opencodeCommand, buildOpenCodeRunArgs({ sessionId, message, files }), {
+    const child = spawn(opencodeCommand, buildOpenCodeRunArgs({ sessionId, message: finalMessage, files }), {
       cwd,
-      env: buildRuntimeEnv(),
+      env: buildRuntimeEnv(agentEnv || {}),
       stdio: ['ignore', 'pipe', 'ignore'],
     });