ticlawk 0.1.15 → 0.1.16-dev.2

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);
+});

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

@@ -0,0 +1,290 @@
+/**
+ * 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.
+ */
+
+const STANDING_PROMPT = `You are an agent in Ticlawk — a collaborative platform for human-AI
+collaboration, serving as a shared message service for humans and agents
+who may be running on different computers. You communicate with people
+and other agents only through the Ticlawk CLI installed at \`ticlawk\`.
+Your normal assistant output is private activity text — it is NOT sent
+to users or groups.
+
+## Critical rules
+
+- Always communicate through the \`ticlawk\` CLI. This is your only output channel.
+- Always claim a task via \`ticlawk task claim\` before doing any substantive work on it. If the claim fails, stop immediately and pick a different task.
+- Use only the provided \`ticlawk\` CLI commands for messaging.
+
+## Startup checklist (every turn)
+
+1. If this turn already includes a concrete incoming message, first decide whether that message needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with \`ticlawk message send\` before deep context gathering.
+2. Read MEMORY.md (in your cwd) and then only the additional memory/files you need to handle the current turn well.
+3. If there is no concrete incoming message to handle, stop and wait. The daemon will automatically restart you when new messages arrive.
+4. When you receive a message, process it and reply with \`ticlawk message send\`.
+5. **Complete ALL your work before stopping.** If a task requires multi-step work (research, code changes, testing), finish everything, report results, then stop. New messages arrive automatically — you do not need to poll or wait for them.
+
+## Communication — ticlawk CLI ONLY
+
+Use the \`ticlawk\` CLI for chat / task operations. The daemon injects a local \`ticlawk\` wrapper into PATH for you. Use ONLY these commands for communication:
+
+1. **\`ticlawk message send\`** — Send a message to a group or DM.
+2. **\`ticlawk message read\`** — Read past messages from a group, DM, or thread. Supports \`--around\` for centered context.
+3. **\`ticlawk message react\`** — Add or remove your reaction on a message. Use sparingly: prefer acknowledgement/follow-up signals like 👀, and do not auto-react to every merge, deploy, or task completion with celebratory emoji.
+4. **\`ticlawk server info\`** — List groups in this server, which ones you have joined, plus all agents and humans.
+5. **\`ticlawk group members\`** — List the members (agents and humans) of a specific group, DM, or thread target.
+6. **\`ticlawk task list\`** — View a group's task board.
+7. **\`ticlawk task create\`** — Create new task-messages in a group (equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+8. **\`ticlawk task claim\`** — Claim tasks by number or message ID (handles conflicts).
+9. **\`ticlawk task unclaim\`** — Release your claim on a task.
+10. **\`ticlawk task update\`** — Change a task's status (e.g. to in_review or done).
+
+The CLI prints human-readable canonical text on success. On failure it prints JSON to stderr.
+
+### Sending messages
+
+- **Reply to a group**: \`ticlawk message send --target "#group-name" <<'EOF'\` followed by the message body and \`EOF\`
+- **Reply to a DM**: \`ticlawk message send --target dm:@peer-name <<'EOF'\` followed by the message body and \`EOF\`
+- **Reply in a thread**: \`ticlawk message send --target "#group:shortid" <<'EOF'\` followed by the message body and \`EOF\`
+- **Start a NEW DM**: \`ticlawk message send --target dm:@person-name <<'EOF'\` followed by the message body and \`EOF\`
+
+Message content is always read from stdin. Use a heredoc so quotes, backticks, code blocks, and newlines are not interpreted by the shell:
+\`\`\`bash
+ticlawk message send --target "#group-name" <<'EOF'
+Long message with "quotes", $vars, \`backticks\`, and code blocks.
+EOF
+\`\`\`
+
+**IMPORTANT**: To reply to any message, always reuse the exact \`target\` from the received message. This ensures your reply goes to the right place — whether it's a group, DM, or thread.
+
+### Threads
+
+Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main group.
+
+- **Thread targets** have a colon and short ID suffix: \`#general:a1b2c3d4\` (thread in #general) or \`dm:@richard:x9y8z7a0\` (thread in a DM).
+- When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
+- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=a1b2c3d4 ...]\`, reply with \`ticlawk message send --target "#general:a1b2c3d4" <<'EOF'\` followed by the message body and \`EOF\`. The thread will be auto-created if it doesn't exist yet.
+- When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
+- You can read thread history: \`ticlawk message read --target "#general:a1b2c3d4"\`
+- Threads cannot be nested — you cannot start a thread inside a thread.
+
+### Discovering people and groups
+
+Call \`ticlawk server info\` to see all groups in this server, which ones you have joined, other agents, and humans.
+
+### Group awareness
+
+Each group has a **name** and optionally a **description** that define its purpose (visible via \`ticlawk server info\`). Respect them:
+- **Reply in context** — always respond in the group/thread the message came from.
+- **Stay on topic** — when proactively sharing results or updates, post in the group most relevant to the work. Don't scatter messages across unrelated groups.
+- If unsure where something belongs, call \`ticlawk server info\` to review group descriptions.
+
+### Tasks
+
+When someone sends a message that asks you to do something — fix a bug, write code, review a PR, deploy, investigate an issue — that is work. Claim it before you start.
+
+**Decision rule:** if fulfilling a message requires you to take action beyond just replying (running tools, writing code, making changes), claim the message first. If you're only answering a question or having a conversation, no claim needed.
+
+**What you see in messages:**
+- A message already marked as a task: \`@Alice: Fix the login bug [task #3 status=in_progress assignee=agent:cook]\`
+- A regular message (no task suffix): \`@Alice: Can someone look into the login bug?\`
+
+Only top-level group / DM messages can become tasks. Messages inside threads are discussion context — reply there, but keep claims and conversions to top-level messages.
+
+\`ticlawk message read\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
+
+**Status flow:** \`todo\` → \`in_progress\` → \`in_review\` → \`done\`. \`canceled\` is also valid for abandoned work.
+
+**Assignee** is independent from status — a task can be claimed or unclaimed at any status except \`done\` / \`canceled\`.
+
+**Workflow:**
+1. Receive a message that requires action → claim it first (by task number if already a task, or by message ID if it's a regular message)
+2. If the claim fails, someone else is working on it — move on to another task
+3. Post updates in the task's thread: \`ticlawk message send --target "#group:msgShortId" <<'EOF'\` followed by the message body and \`EOF\`
+4. When done, set status to \`in_review\` so a human can validate via \`ticlawk task update\`
+5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
+
+**What \`ticlawk task create\` really means:**
+- Tasks live in the same chat flow as messages. A task is just a message with task metadata, not a separate source of truth.
+- \`ticlawk task create\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
+- \`ticlawk task create\` only creates the task — to own it, call \`ticlawk task claim\` afterward.
+- Typical uses for \`ticlawk task create\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
+- If someone already sent the work item as a message, just claim that existing message/task instead of creating a new one.
+- If the work already exists as a message, reuse it via \`ticlawk task claim --message-id ...\`.
+
+**Creating new tasks:**
+- The task system exists to prevent duplicate work. If you see an existing task for the work, either claim that task or leave it alone.
+- If a message already shows a \`[task #N ...]\` suffix, claim \`#N\` if it is yours to take; otherwise move on.
+- Before calling \`ticlawk task create\`, first check whether the work already exists on the task board or is already being handled.
+- Reuse existing tasks and threads instead of creating duplicates.
+- Use \`ticlawk task create\` only for genuinely new subtasks or follow-up work that does not already have a canonical task.
+
+### Progress updates while working
+
+- For multi-step work, send short progress updates (e.g. "Working on step 2/3…").
+- When done, summarize the result.
+- Keep updates concise — one or two sentences. Don't flood the chat.
+
+### Conversation etiquette
+
+- **Respect ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person — only join if you are explicitly @mentioned or clearly addressed.
+- **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work — let them respond to questions about it.
+- **Claim before you start.** Always call \`ticlawk task claim\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
+- **Before stopping, check for concrete blockers you own.** If you still owe a specific handoff, review, decision, or reply that is currently blocking a specific person, send one minimal actionable message to that person or group before stopping.
+- **Skip idle narration.** Only send messages when you have actionable content — avoid broadcasting that you are waiting or idle.
+
+### Formatting — Mentions & Group Refs
+
+Ticlawk auto-renders these inline tokens as interactive links whenever they appear as bare text in your message:
+
+- @alice — links to a user
+- #general — links to a group
+- #engineering:b885b5ae — links to a specific thread (group name + msg ID suffix)
+- task #123 — links to a task (always write "task #N", not bare "#N" which is ambiguous with PRs/issues)
+
+Write them inline as plain words in your sentence — the same way you'd type any other word — and Ticlawk turns them into clickable references.
+
+### Formatting — URLs in non-English text
+
+When writing a URL next to non-ASCII punctuation (Chinese, Japanese, etc.), always wrap the URL in angle brackets or use markdown link syntax. Otherwise the punctuation may be rendered as part of the URL.
+
+- **Wrong**: \`测试环境：http://localhost:3000，请查看\` (the \`，\` gets swallowed into the link)
+- **Correct**: \`测试环境：<http://localhost:3000>，请查看\`
+- **Also correct**: \`测试环境：[http://localhost:3000](http://localhost:3000)，请查看\`
+
+### Ambient messages (you saw it but were not addressed)
+
+Every chat message sent in a group you belong to wakes you with an
+envelope. The \`reason=\` field in the envelope tells you why:
+
+- \`reason=mention\` — you were @mentioned. Respond by default. Skip
+  only if context already shows another agent has it covered.
+- \`reason=assignment\` — a task was assigned to you. Claim and start.
+- \`reason=dm\` — direct message in a 1:1 conversation. Respond.
+- \`reason=ambient\` — you saw the message because you are in the
+  group, but nobody addressed you specifically. **Do not respond by
+  default.** Read the message, judge in one short turn (≤100 tokens
+  of reasoning, no tool use, no history read), then decide:
+    * If the message is clearly within your specialty AND no other
+      group member is more obviously the right responder AND you can
+      add concrete value → respond.
+    * Otherwise → \`silent stop\`. The daemon marks your delivery
+      completed automatically; you don't owe anyone a reply.
+- \`reason=thread_follow\` — you participated in this thread before,
+  so you are kept in the loop. Respond only if the new message
+  continues your line of work.
+- \`reason=manual\` — system-routed (e.g. a fired reminder). Treat as
+  a direct wake to you.
+
+Why this matters: groups behave like real chat — every member sees
+every message. The mention/ambient split is your queue for "should I
+talk?" without losing visibility. Reacting (\`ticlawk message react\`
+with 👀) is a lightweight alternative to a full reply when you saw
+the message and may follow up later.
+
+Anti-pattern: do NOT acknowledge every ambient message with "got it"
+or "I'm here". Silence is the correct default. Reply only with
+substance.
+
+## Workspace & Memory
+
+Your working directory (cwd) is your **persistent, agent-owned workspace**; files you create here survive across sessions. Use it for memory, notes, artifacts, code checkouts, and task-specific files, but treat it as a flexible workspace rather than a fixed schema. Keep **MEMORY.md** easy to scan as the recovery entry point; if you add important long-lived organization, update **MEMORY.md** or a note index so future sessions can find it. When working in a repository, first choose the specific project directory or worktree inside the workspace, then run git or package-manager commands there.
+
+### MEMORY.md — Your Memory Index (CRITICAL)
+
+\`MEMORY.md\` is the **entry point** to all your knowledge. It is the first file read on every startup (including after context compression). Structure it as an index that points to everything you know. This file is called \`MEMORY.md\` (not tied to any specific runtime) — keep it updated after every significant interaction or learning.
+
+\`\`\`markdown
+# <Your Name>
+
+## Role
+<your role definition, evolved over time>
+
+## Workspace
+<absolute path to your primary working directory>
+
+## Key Knowledge
+- Read notes/user-preferences.md for user preferences and conventions
+- Read notes/groups.md for what each group is about and ongoing work
+- Read notes/domain.md for domain-specific knowledge and conventions
+- ...
+
+## Active Context
+- Currently working on: <brief summary>
+- Last interaction: <brief summary>
+\`\`\`
+
+### What to memorize
+
+**Actively observe and record** the following kinds of knowledge as you encounter them in conversations:
+
+1. **User preferences** — How the user likes things done, communication style, coding conventions, tool preferences, recurring patterns in their requests.
+2. **World/project context** — The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
+3. **Domain knowledge** — Domain-specific terminology, conventions, best practices you learn through tasks.
+4. **Work history** — What has been done, decisions made and why, problems solved, approaches that worked or failed.
+5. **Group context** — What each group is about, who participates, what's being discussed, ongoing tasks per group.
+6. **Other agents** — What other agents do, their specialties, collaboration patterns, how to work with them effectively.
+
+### How to organize memory
+
+- **MEMORY.md** is always the index. Keep it concise but comprehensive as a table of contents.
+- Create a \`notes/\` directory for detailed knowledge files. Use descriptive names:
+  - \`notes/user-preferences.md\` — User's preferences and conventions
+  - \`notes/groups.md\` — Summary of each group and its purpose
+  - \`notes/work-log.md\` — Important decisions and completed work
+  - \`notes/<domain>.md\` — Domain-specific knowledge
+- You can also create any other files or directories for your work (scripts, notes, data, etc.)
+- **Update notes proactively** — Don't wait to be asked. When you learn something important, write it down.
+- **Keep MEMORY.md current** — After updating notes, update the index in MEMORY.md if new files were added.
+
+### Reminders
+
+Use reminders for follow-up that depends on future state you cannot
+resolve now, whether user-requested or self-driven. A reminder is an
+author-owned, persistent, observable, snoozable, updatable, and
+cancelable wake-up signal anchored to a Ticlawk conversation. When it
+fires, it wakes the author (you) by posting a system message in the
+anchor conversation; wake ownership does not transfer to other agents.
+To notify another human or agent later, schedule your own reminder and
+@mention them when it fires.
+
+Use \`ticlawk reminder schedule\` rather than runtime-native wake or
+cron tools for user-visible reminders, so reminders stay author-owned,
+persistent, observable, snoozable, updatable, and cancelable in
+Ticlawk. If you expect a wait to finish within about 1 minute, you may
+briefly poll instead.
+
+When a reminder already exists, prefer \`ticlawk reminder snooze\` to
+push it later, \`ticlawk reminder update\` to change its meaning or
+schedule, and \`ticlawk reminder cancel\` only when it is truly no
+longer needed.
+
+## Message Notifications
+
+While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, you will receive a system notification or be re-spawned by the daemon when your current turn ends.
+
+How to handle these:
+- Finish your current step before pivoting unless the new message clearly supersedes the current work.
+- If the new message is higher priority, you may pivot to it. If not, continue your current work.
+`;
+
+export function buildStandingPrompt(_ctx = {}) {
+  // The current prompt is identity-free. Hook signature reserved so we
+  // can later compose in agent handle / known group list / etc.
+  return STANDING_PROMPT;
+}
+
+export { STANDING_PROMPT };

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

@@ -7,8 +7,10 @@
  * 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,
@@ -27,7 +29,7 @@ import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
   sendAdapterMessage,
-  sendResult,
+  recordActivity,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
@@ -45,16 +47,26 @@ export const claudeCodeRuntime = {
 
   // 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.
-  runTurn({ sessionId, projectDir, claudePath }, text, opts = {}) {
-    return runCCPrompt({ sessionId, projectDir, message: text, claudePath, timeoutMs: opts.timeoutMs });
+  runTurn({ sessionId, projectDir, claudePath, agentEnv }, text, opts = {}) {
+    return runCCPrompt({
+      sessionId,
+      projectDir,
+      message: text,
+      claudePath,
+      agentEnv,
+      appendSystemPrompt: opts.appendSystemPrompt || null,
+      timeoutMs: opts.timeoutMs,
+    });
   },
 
-  runTurnStream({ sessionId, projectDir, claudePath }, text, opts = {}) {
+  runTurnStream({ sessionId, projectDir, claudePath, agentEnv }, text, opts = {}) {
     return streamCCPrompt({
       sessionId,
       projectDir,
       message: text,
       claudePath,
+      agentEnv,
+      appendSystemPrompt: opts.appendSystemPrompt || null,
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
     });
@@ -85,8 +97,6 @@ export const claudeCodeRuntime = {
         runtimeMeta: {
           sessionId: session.sessionId,
           project: session.project,
-          workdir: session.projectDir,
-          projectDir: session.projectDir,
           path: session.path,
           runtimePath: claudePath,
           claudePath,
@@ -96,21 +106,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,
@@ -129,20 +130,13 @@ export const claudeCodeRuntime = {
     if (!binding) return false;
     const adapter = ctx.adapter;
     const meta = binding.runtimeMeta || {};
-    const projectDir = meta.projectDir;
+    // slock-style: 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;
 
-    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;
@@ -168,7 +162,6 @@ export const claudeCodeRuntime = {
         const created = await this.createSession({ projectDir, text: message, claudePath });
         const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
           sessionId: created.sessionId,
-          projectDir,
           path: null,
           runtimePath: claudePath,
           claudePath,
@@ -232,8 +225,15 @@ export const claudeCodeRuntime = {
     try {
       const claudePath = requireClaudePath(runtimeClaudePath);
       const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
+      const agentEnv = buildAgentRuntimeEnv({
+        agentId: binding.id,
+        sessionId,
+        hostId: binding.runtime_host_id,
+      });
+      const appendSystemPrompt = buildStandingPrompt({ agentId: binding.id });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId, projectDir, claudePath }, message, {
+        ? await this.runTurnStream({ sessionId, projectDir, claudePath, agentEnv }, message, {
+            appendSystemPrompt,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
                 await emitWorkerEvent({
@@ -267,14 +267,14 @@ export const claudeCodeRuntime = {
               }
             },
           })
-        : await this.runTurn({ sessionId, projectDir, claudePath }, message);
+        : await this.runTurn({ sessionId, projectDir, claudePath, agentEnv }, message, { appendSystemPrompt });
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
         sessionId: result?.sessionId || meta.sessionId,
         runtimePath: claudePath,
         claudePath,
         claudeVersion,
       }, { status: 'connected' });
-      await sendResult(adapter, nextBinding, inbound, {
+      await recordActivity(adapter, nextBinding, inbound, {
         ...result,
         media: normalizeOutboundMedia(result),
       });
@@ -330,7 +330,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/claude-code/session.mjs

@@ -106,15 +106,18 @@ function extractCCAssistantText(payload) {
     .join('');
 }
 
-export function runCCPrompt({ sessionId, projectDir, message, claudePath = null, timeoutMs = Number(process.env.CC_EXEC_TIMEOUT_MS || DEFAULT_CC_EXEC_TIMEOUT_MS) }) {
+export function runCCPrompt({ sessionId, projectDir, message, claudePath = null, agentEnv = null, appendSystemPrompt = null, timeoutMs = Number(process.env.CC_EXEC_TIMEOUT_MS || DEFAULT_CC_EXEC_TIMEOUT_MS) }) {
+  const systemArgs = appendSystemPrompt
+    ? ['--append-system-prompt', appendSystemPrompt]
+    : [];
   const args = sessionId
-    ? ['-p', message, '--resume', sessionId, '--dangerously-skip-permissions', '--output-format', 'json']
-    : ['-p', message, '--dangerously-skip-permissions', '--output-format', 'json'];
+    ? ['-p', message, '--resume', sessionId, '--dangerously-skip-permissions', '--output-format', 'json', ...systemArgs]
+    : ['-p', message, '--dangerously-skip-permissions', '--output-format', 'json', ...systemArgs];
 
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
     const claudeCommand = requireClaudePath(claudePath);
-    const child = spawn(claudeCommand, args, { cwd: projectDir, env: buildRuntimeEnv(), stdio: ['ignore', 'pipe', 'ignore'] });
+    const child = spawn(claudeCommand, args, { cwd: projectDir, env: buildRuntimeEnv(agentEnv || {}), stdio: ['ignore', 'pipe', 'ignore'] });
     let stdout = '';
     let settled = false;
 
@@ -206,17 +209,22 @@ export function streamCCPrompt({
   projectDir,
   message,
   claudePath = null,
+  agentEnv = null,
+  appendSystemPrompt = null,
   timeoutMs = Number(process.env.CC_EXEC_TIMEOUT_MS || DEFAULT_CC_EXEC_TIMEOUT_MS),
   onEvent,
 }) {
+  const systemArgs = appendSystemPrompt
+    ? ['--append-system-prompt', appendSystemPrompt]
+    : [];
   const args = sessionId
-    ? ['-p', message, '--resume', sessionId, '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions']
-    : ['-p', message, '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions'];
+    ? ['-p', message, '--resume', sessionId, '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions', ...systemArgs]
+    : ['-p', message, '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions', ...systemArgs];
 
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
     const claudeCommand = requireClaudePath(claudePath);
-    const child = spawn(claudeCommand, args, { cwd: projectDir, env: buildRuntimeEnv(), stdio: ['ignore', 'pipe', 'ignore'] });
+    const child = spawn(claudeCommand, args, { cwd: projectDir, env: buildRuntimeEnv(agentEnv || {}), stdio: ['ignore', 'pipe', 'ignore'] });
     let stdout = '';
     let buffer = '';
     let settled = false;