thepopebot 1.2.76-beta.2 → 1.2.76-beta.4

package/bin/cli.js

@@ -420,7 +420,7 @@ function reset(filePath) {
       console.log(`  ${destPath(file)}`);
     }
     console.log('\nUsage: thepopebot reset <file>');
-    console.log('Example: thepopebot reset agent-job/SOUL.md\n');
+    console.log('Example: thepopebot reset agent-job/SYSTEM.md\n');
     return;
   }
 
@@ -502,7 +502,7 @@ function diff(filePath) {
       console.log('  All files match package templates.');
     }
     console.log('\nUsage: thepopebot diff <file>');
-    console.log('Example: thepopebot diff agent-job/SOUL.md\n');
+    console.log('Example: thepopebot diff agent-job/SYSTEM.md\n');
     return;
   }
 

package/lib/ai/index.js

@@ -4,8 +4,10 @@ import { z } from 'zod';
 import { getAgentChat, getCodeChat } from './agent.js';
 import { createModel } from './model.js';
 import path from 'path';
+import { existsSync } from 'fs';
 import { PROJECT_ROOT } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
+import { buildCodingAgentSystemPrompt } from './system-prompt.js';
 import { getChatById, createChat, saveMessage, updateChatTitle, linkChatToWorkspace } from '../db/chats.js';
 import { getConfig } from '../config.js';
 import { getSdkAdapter } from './sdk-adapters/index.js';
@@ -171,35 +173,41 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
     const workspace = getCodeWorkspaceById(workspaceId);
     const featureBranch = workspace?.featureBranch;
 
+    const needsSetup = !existsSync(path.join(repoDir, '.git'));
     const setupToolCallId = `setup-${workspaceId.slice(0, 8)}`;
     const setupArgs = { repo, branch, featureBranch };
-    yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'set_up_workspace', args: setupArgs };
+
+    if (needsSetup) {
+      yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'set_up_workspace', args: setupArgs };
+    }
 
     try {
       await ensureWorkspaceRepo({ workspaceDir: repoDir, repo, branch, featureBranch });
       ensureSkills(repoDir, isCodeMode ? 'code' : 'agent');
-      yield { type: 'tool-result', toolCallId: setupToolCallId, result: JSON.stringify({ result: `Workspace ready on ${featureBranch || branch}` }) };
+      if (needsSetup) {
+        const result = JSON.stringify({ result: `Workspace ready on ${featureBranch || branch}` });
+        yield { type: 'tool-result', toolCallId: setupToolCallId, result };
+        persistMessage(threadId, 'assistant', JSON.stringify({
+          type: 'tool-invocation',
+          toolCallId: setupToolCallId,
+          toolName: 'set_up_workspace',
+          state: 'output-available',
+          input: setupArgs,
+          output: result,
+        }), options);
+      }
     } catch (err) {
-      yield { type: 'tool-result', toolCallId: setupToolCallId, result: JSON.stringify({ result: `Setup failed: ${err.message}` }) };
+      if (needsSetup) {
+        yield { type: 'tool-result', toolCallId: setupToolCallId, result: JSON.stringify({ result: `Setup failed: ${err.message}` }) };
+      }
       throw err;
     }
 
     // 2. Session continuity
     const sessionId = readSessionId(wsBaseDir);
 
-    // 3. System prompt (agent mode: SOUL.md + SYSTEM.md, code mode: none)
-    let systemPrompt = null;
-    if (!isCodeMode) {
-      const soulPath = path.join(PROJECT_ROOT, 'agent-job/SOUL.md');
-      const systemPath = path.join(PROJECT_ROOT, 'agent-job/SYSTEM.md');
-      try {
-        const soul = render_md(soulPath) || '';
-        const system = render_md(systemPath) || '';
-        systemPrompt = [soul, system].filter(Boolean).join('\n\n') || null;
-      } catch {
-        // Files may not exist — proceed without system prompt
-      }
-    }
+    // 3. System prompt
+    const systemPrompt = buildCodingAgentSystemPrompt(isCodeMode ? 'code' : 'agent');
 
     // 4. Stream from SDK adapter
     let pendingText = '';

package/lib/ai/sdk-adapters/CLAUDE.md

@@ -0,0 +1,113 @@
+# lib/ai/sdk-adapters/ — SDK Adapter System
+
+In-process SDK adapters that replace the legacy LangGraph + Docker path for chat. Each adapter wraps a coding agent's SDK and yields a unified chunk stream consumed by `chatStream()` in `lib/ai/index.js`.
+
+## Architecture
+
+```
+Browser → POST /stream/chat (api.js)
+  → chatStream() (index.js)
+    → getSdkAdapter() returns adapter function or null
+    → if adapter: workspace setup → SDK adapter streaming → DB persistence
+    → if null: falls back to legacy LangGraph/Docker path
+```
+
+The adapter is a pure stream translator — it receives a prompt and options, calls the SDK, and yields normalized chunks. Everything else (workspace setup, DB persistence, session continuity, system prompts) is handled by `chatStream()` in `index.js`.
+
+## Existing Adapter
+
+| File | Agent | SDK |
+|------|-------|-----|
+| `claude-code.js` | `claude-code` | `@anthropic-ai/claude-agent-sdk` |
+
+## Adding a New SDK Adapter
+
+### 1. Create the adapter file
+
+Create `{agent-name}.js` in this directory. Export a single async generator function:
+
+```js
+export async function* myAgentStream({ prompt, workspaceDir, systemPrompt, sessionId, permissionMode, attachments }) {
+  // ... call the SDK, yield chunks
+}
+```
+
+### 2. Required chunk types to yield
+
+The adapter MUST yield these chunk types for `chatStream()` and `api.js` to work correctly:
+
+| Chunk | Shape | When | Purpose |
+|-------|-------|------|---------|
+| `meta` | `{ type: 'meta', sessionId: string }` | First event | Session ID for continuity across messages. `chatStream()` writes this to disk via `writeSessionId()` so subsequent messages resume the session. |
+| `text` | `{ type: 'text', text: string }` | Text output | Streamed to UI as deltas. Accumulated by `chatStream()` and flushed to DB as assistant messages at tool boundaries and stream end. |
+| `tool-call` | `{ type: 'tool-call', toolCallId: string, toolName: string, args: object }` | Tool invocation starts | Triggers tool UI in the browser. May be yielded twice: once at start with `args: {}`, once at `content_block_stop` with complete args. `chatStream()` tracks these in `pendingToolCalls` for pairing with results. |
+| `tool-result` | `{ type: 'tool-result', toolCallId: string, result: string }` | Tool completes | Paired with the matching `tool-call` by `toolCallId`. `chatStream()` persists the pair as a `tool-invocation` JSON message in the DB. |
+| `result` | `{ type: 'result', text: string, cost?: number, duration?: number, subtype?: string }` | Stream ends | Final summary. Logged by `chatStream()`, not persisted or sent to UI. |
+
+Optional:
+| `unknown` | `{ type: 'unknown', raw: any }` | Unrecognized events | `api.js` renders these as collapsible boxes in the UI. Use for debugging unhandled SDK events. |
+
+### 3. Register in index.js
+
+Add the import and mapping in `getSdkAdapter()`:
+
+```js
+import { myAgentStream } from './my-agent.js';
+
+export function getSdkAdapter(agentType) {
+  if (agentType === 'claude-code') return claudeCodeStream;
+  if (agentType === 'my-agent') return myAgentStream;
+  return null;
+}
+```
+
+The `agentType` string comes from the `CODING_AGENT` config value set in the admin UI.
+
+### 4. Auth resolution
+
+Use `buildAgentAuthEnv(agentType)` from `lib/tools/docker.js` to get credentials from the settings DB. This returns `{ env: string[], backendApi: string }` where `env` is an array of `KEY=value` strings. Parse them into an env object:
+
+```js
+import { buildAgentAuthEnv } from '../../tools/docker.js';
+
+const env = { ...process.env };
+const { env: authEnvPairs } = buildAgentAuthEnv('my-agent');
+for (const pair of authEnvPairs) {
+  const eqIdx = pair.indexOf('=');
+  if (eqIdx > 0) env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+}
+```
+
+The agent's auth config (API keys, OAuth tokens, provider selection) is managed in the admin UI at `/admin/event-handler/coding-agents` and stored in the settings DB. `buildAgentAuthEnv()` reads it — you don't need to access the settings DB directly.
+
+### 5. Function parameters
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `prompt` | `string` | User message text |
+| `workspaceDir` | `string` | Absolute path to git repo root (the SDK should execute here) |
+| `systemPrompt` | `string\|null` | System prompt for agent mode (null in code mode) |
+| `sessionId` | `string\|null` | Previous session ID to resume (null on first message) |
+| `permissionMode` | `string` | `'plan'` (read-only) or `'code'` (read-write). Map to the SDK's equivalent permission concept. |
+| `attachments` | `Array` | Image attachments: `{ category: 'image', mimeType, dataUrl }` |
+
+### 6. Session continuity contract
+
+Multi-turn conversation works via session IDs:
+
+1. First message: `sessionId` param is `null`. Adapter yields `{ type: 'meta', sessionId: '<new-id>' }`.
+2. `chatStream()` writes the session ID to `{workspaceBaseDir}/.claude-ttyd-sessions/7681`.
+3. Next message: `sessionId` param contains the saved ID. Adapter passes it to the SDK's resume mechanism.
+
+If the SDK doesn't support session resume, the adapter can ignore `sessionId` — but multi-turn context will be lost between messages.
+
+## What the adapter does NOT handle
+
+These are managed by `chatStream()` in `index.js` — adapters should not duplicate them:
+
+- **Workspace git setup** — `ensureWorkspaceRepo()` clones/checkouts before the adapter is called
+- **DB persistence** — `chatStream()` saves user messages, assistant text, and tool invocations
+- **Chat creation** — `chatStream()` creates the chat and workspace DB records
+- **Auto-titling** — `chatStream()` generates a title after the first message
+- **System prompt loading** — `chatStream()` calls `buildCodingAgentSystemPrompt()` and passes the result as `systemPrompt`
+- **Skill activation** — `ensureSkills()` runs before the adapter is called

package/lib/ai/sdk-adapters/claude-code.js

@@ -1,3 +1,5 @@
+import path from 'path';
+import fs from 'fs';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { getConfig } from '../../config.js';
 import { buildAgentAuthEnv } from '../../tools/docker.js';
@@ -15,10 +17,61 @@ import { buildAgentAuthEnv } from '../../tools/docker.js';
  * @param {Array} [opts.attachments] - Image attachments
  * @yields {{ type: 'text'|'tool-call'|'tool-result'|'meta'|'result'|'unknown', ... }}
  */
+/**
+ * Encode an absolute path the same way Claude Code encodes cwd for session storage.
+ * Non-alphanumeric characters are replaced with '-'.
+ */
+function encodeCwd(absolutePath) {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+/**
+ * Ensure the interactive container can find SDK-created sessions on the shared volume.
+ *
+ * The SDK stores sessions at $HOME/.claude/projects/<encoded-cwd>/. The interactive
+ * container uses cwd=/home/coding-agent/workspace, but the SDK adapter uses
+ * cwd=/app/data/workspaces/workspace-XXX/workspace — different encoded paths.
+ *
+ * Creates a symlink so the interactive container's encoded path resolves to the
+ * SDK adapter's encoded path, both on the same volume.
+ */
+function ensureSessionSymlink(wsBaseDir, workspaceDir) {
+  const projectsDir = path.join(wsBaseDir, '.claude', 'projects');
+  const sdkEncoded = encodeCwd(workspaceDir);
+  const interactiveEncoded = encodeCwd('/home/coding-agent/workspace');
+
+  // Both point to the same dir — no symlink needed
+  if (sdkEncoded === interactiveEncoded) return;
+
+  fs.mkdirSync(path.join(projectsDir, sdkEncoded), { recursive: true });
+
+  const symlinkPath = path.join(projectsDir, interactiveEncoded);
+  try {
+    const existing = fs.readlinkSync(symlinkPath);
+    if (existing === sdkEncoded) return; // already correct
+    fs.unlinkSync(symlinkPath);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      // It's a real directory (not a symlink) — don't touch it
+      if (err.code === 'EINVAL') return;
+    }
+  }
+
+  try {
+    fs.symlinkSync(sdkEncoded, symlinkPath);
+  } catch {}
+}
+
 export async function* claudeCodeStream({ prompt, workspaceDir, systemPrompt, sessionId, permissionMode, attachments }) {
+  // Point HOME at the workspace volume so the SDK stores session data on the
+  // shared volume (not the EH container's ephemeral filesystem).
+  const wsBaseDir = path.dirname(workspaceDir);
+  ensureSessionSymlink(wsBaseDir, workspaceDir);
+
   // Build a local env object with auth credentials from the settings DB.
   // Passed via the SDK's `env` option — no process.env mutation needed.
   const env = { ...process.env };
+  env.HOME = wsBaseDir;
   try {
     const { env: authEnvPairs } = buildAgentAuthEnv('claude-code');
     for (const pair of authEnvPairs) {

package/lib/ai/system-prompt.js

@@ -0,0 +1,16 @@
+import path from 'path';
+import { PROJECT_ROOT } from '../paths.js';
+import { render_md } from '../utils/render-md.js';
+
+/**
+ * Build the system prompt for a coding agent.
+ * @param {'agent'|'code'} mode - Chat mode
+ * @returns {string|null} Rendered system prompt, or null if not configured
+ */
+export function buildCodingAgentSystemPrompt(mode) {
+  const file = mode === 'agent'
+    ? path.join(PROJECT_ROOT, 'agent-job/SYSTEM.md')
+    : path.join(PROJECT_ROOT, 'coding-workspace/SYSTEM.md');
+  const rendered = render_md(file);
+  return rendered?.trim() || null;
+}

package/lib/ai/tools.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { createAgentJob } from '../tools/create-agent-job.js';
 
 import { getConfig } from '../config.js';
+import { buildCodingAgentSystemPrompt } from './system-prompt.js';
 
 const agentJobTool = tool(
   async ({ prompt }) => {
@@ -63,6 +64,7 @@ const agentChatCodingTool = tool(
         workspaceId,
         taskPrompt: prompt,
         mode,
+        systemPrompt: buildCodingAgentSystemPrompt('agent'),
         injectSecrets: true,
       });
 
@@ -124,6 +126,7 @@ const codeChatCodingTool = tool(
         containerName, repo, branch, featureBranch, workspaceId,
         taskPrompt: prompt,
         mode,
+        systemPrompt: buildCodingAgentSystemPrompt('code'),
       });
 
       const chunks = [{ type: 'meta', codingAgent, backendApi }];

package/lib/code/actions.js

@@ -14,6 +14,7 @@ import {
 import {
   getChatByWorkspaceId,
 } from '../db/chats.js';
+import { buildCodingAgentSystemPrompt } from '../ai/system-prompt.js';
 import {
   addSession,
   getSession as getTermSession,
@@ -137,6 +138,7 @@ export async function ensureCodeWorkspaceContainer(id) {
   // Inject agent job secrets when the linked chat is in agent mode
   const chat = getChatByWorkspaceId(id);
   const injectSecrets = chat?.chatMode === 'agent';
+  const systemPrompt = buildCodingAgentSystemPrompt(chat?.chatMode === 'agent' ? 'agent' : 'code');
 
   try {
     const { inspectContainer, startContainer, removeContainer, runInteractiveContainer } =
@@ -153,6 +155,7 @@ export async function ensureCodeWorkspaceContainer(id) {
         featureBranch: workspace.featureBranch,
         workspaceId: id,
         injectSecrets,
+        systemPrompt,
       });
       return { status: 'created' };
     }
@@ -181,6 +184,7 @@ export async function ensureCodeWorkspaceContainer(id) {
       featureBranch: workspace.featureBranch,
       workspaceId: id,
       injectSecrets,
+      systemPrompt,
     });
     return { status: 'created' };
   } catch (err) {
@@ -208,6 +212,7 @@ export async function startInteractiveMode(id) {
   // Inject agent job secrets when the linked chat is in agent mode
   const chat = getChatByWorkspaceId(id);
   const injectSecrets = chat?.chatMode === 'agent';
+  const systemPrompt = buildCodingAgentSystemPrompt(chat?.chatMode === 'agent' ? 'agent' : 'code');
 
   try {
     const { getConfig } = await import('../config.js');
@@ -223,6 +228,7 @@ export async function startInteractiveMode(id) {
       featureBranch: workspace.featureBranch,
       workspaceId: id,
       injectSecrets,
+      systemPrompt,
     });
 
     updateContainerName(id, containerName);

package/lib/tools/docker.js

@@ -196,9 +196,10 @@ async function runContainer({ containerName, image, env = [], workingDir, hostCo
  * @param {string} [options.featureBranch] - Feature branch to create after cloning
  * @param {string} [options.workspaceId] - Workspace ID (for bind mount)
  * @param {boolean} [options.injectSecrets] - Inject agent job secrets into container env
+ * @param {string} [options.systemPrompt] - Pre-rendered system prompt (written to volume as SYSTEM.md)
  * @returns {Promise<{containerId: string, containerName: string}>}
  */
-async function runInteractiveContainer({ containerName, repo, branch, codingAgent, featureBranch, workspaceId, injectSecrets, continueSession = true }) {
+async function runInteractiveContainer({ containerName, repo, branch, codingAgent, featureBranch, workspaceId, injectSecrets, systemPrompt, continueSession = true }) {
   const agent = codingAgent || getConfig('CODING_AGENT') || 'claude-code';
   const version = process.env.THEPOPEBOT_VERSION;
   const image = `stephengpope/thepopebot:coding-agent-${agent}-${version}`;
@@ -246,8 +247,16 @@ async function runInteractiveContainer({ containerName, repo, branch, codingAgen
     const dir = workspaceDir(workspaceId);
     const wsDir = path.join(dir, 'workspace');
     fs.mkdirSync(wsDir, { recursive: true });
-    fs.chownSync(dir, CODING_AGENT_UID, CODING_AGENT_UID);
-    fs.chownSync(wsDir, CODING_AGENT_UID, CODING_AGENT_UID);
+
+    // Write pre-rendered system prompt to volume (read by container setup scripts)
+    const systemPromptPath = path.join(dir, 'SYSTEM.md');
+    if (systemPrompt) {
+      fs.writeFileSync(systemPromptPath, systemPrompt, 'utf8');
+    } else {
+      // Remove stale prompt if no system prompt for this mode
+      try { fs.unlinkSync(systemPromptPath); } catch {}
+    }
+
     const hostDir = await resolveHostPath(dir);
     hostConfig.Binds = [`${hostDir}:/home/coding-agent`];
   }
@@ -418,9 +427,6 @@ async function runHeadlessContainer({ containerName, repo, branch, featureBranch
     const permission = mode === 'dangerous' ? 'code' : mode;
     env.push(`PERMISSION=${permission}`);
   }
-  if (systemPrompt) {
-    env.push(`SYSTEM_PROMPT=${systemPrompt}`);
-  }
   if (continueSession) {
     env.push(`CONTINUE_SESSION=1`);
   }
@@ -456,8 +462,15 @@ async function runHeadlessContainer({ containerName, repo, branch, featureBranch
     const dir = workspaceDir(workspaceId);
     const wsDir = path.join(dir, 'workspace');
     fs.mkdirSync(wsDir, { recursive: true });
-    fs.chownSync(dir, CODING_AGENT_UID, CODING_AGENT_UID);
-    fs.chownSync(wsDir, CODING_AGENT_UID, CODING_AGENT_UID);
+
+    // Write pre-rendered system prompt to volume (read by container setup scripts)
+    const systemPromptPath = path.join(dir, 'SYSTEM.md');
+    if (systemPrompt) {
+      fs.writeFileSync(systemPromptPath, systemPrompt, 'utf8');
+    } else {
+      try { fs.unlinkSync(systemPromptPath); } catch {}
+    }
+
     const hostDir = await resolveHostPath(dir);
     hostConfig.Binds = [`${hostDir}:/home/coding-agent`];
   }

package/lib/utils/render-md.js

@@ -32,7 +32,7 @@ function loadSkillDescriptions() {
       const frontmatter = frontmatterMatch[1];
       const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
       if (descMatch) {
-        descriptions.push(`- ${descMatch[1].trim()}`);
+        descriptions.push(`- **${entry.name}**: ${descMatch[1].trim()}`);
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thepopebot",
-  "version": "1.2.76-beta.2",
+  "version": "1.2.76-beta.4",
   "type": "module",
   "description": "Create autonomous AI agents with a two-layer architecture: Next.js Event Handler + Docker Agent.",
   "bin": {
@@ -68,7 +68,7 @@
   "license": "MIT",
   "dependencies": {
     "@ai-sdk/react": "^2.0.0",
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.101",
     "@clack/prompts": "^0.10.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",

package/templates/.gitignore.template

@@ -11,7 +11,7 @@
 # Playwright MCP
 .playwright-mcp/
 
-# Pi system prompt (generated at runtime from SOUL.md)
+# Pi system prompt (generated at runtime)
 .pi/SYSTEM.md
 
 # Dynamically activated skills (created at container runtime, not user config)

package/templates/CLAUDE.md

@@ -11,7 +11,7 @@ This directory contains files that get copied into user projects when they run `
 
 ## What belongs here
 
-- **Agent job config**: `agent-job/SOUL.md`, `agent-job/CRONS.json`, etc.
+- **Agent job config**: `agent-job/SYSTEM.md`, `agent-job/CRONS.json`, etc.
 - **Event handler config**: `event-handler/agent-chat/SYSTEM.md`, `event-handler/TRIGGERS.json`, etc.
 - **GitHub Actions workflows**: `.github/workflows/`
 - **Docker compose**: `docker-compose.yml`

package/templates/CLAUDE.md.template

@@ -4,7 +4,8 @@ This is a [thepopebot](https://github.com/stephengpope/thepopebot) project.
 
 ## Directories
 
-- **`agent-job/`** — Agent job configuration: system prompts (`SOUL.md`, `SYSTEM.md`), heartbeat prompt, and cron schedules (`CRONS.json`).
+- **`agent-job/`** — Agent job configuration: system prompt (`SYSTEM.md`), heartbeat prompt, and cron schedules (`CRONS.json`).
+- **`coding-workspace/`** — Optional system prompt (`SYSTEM.md`) for code mode workspaces. Empty by default.
 - **`agents/`** — Custom agent definitions. Each subdirectory defines an agent (see Managing Agents below).
 - **`event-handler/`** — Event handler configuration: chat system prompts, trigger definitions (`TRIGGERS.json`), cluster templates, and LiteLLM proxy config.
 - **`skills/library/`** — Skill plugins. Activate by symlinking into `skills/active/`.

package/templates/agent-job/CLAUDE.md.template

@@ -4,8 +4,7 @@ This directory contains your agent job configuration files — system prompts, s
 
 ## Files
 
-- **`SOUL.md`** — Agent personality, identity, and values. Included in every agent job system prompt.
-- **`SYSTEM.md`** — Runtime environment documentation injected into the agent's context.
+- **`SYSTEM.md`** — Agent system prompt: identity, runtime environment, and instructions. Rendered with full template support (`{{skills}}`, `{{datetime}}`, file includes).
 - **`HEARTBEAT.md`** — Prompt for the agent's periodic heartbeat cron job.
 - **`CRONS.json`** — Scheduled job definitions, loaded at server startup.
 

package/templates/agent-job/SYSTEM.md

@@ -1,6 +1,6 @@
 # Agent Job Environment
 
-You are an autonomous AI agent running inside a Docker container on thepopebot.
+You are an autonomous AI agent running inside a Docker container on thepopebot. You approach tasks methodically — plan before acting, favor simplicity, and prioritize quality over speed.
 
 ## Runtime Environment
 
@@ -16,7 +16,7 @@ Everything in the workspace is automatically committed and pushed when your job
 ## Directory Layout
 
 - `agents/` — Agent definitions. Each subdirectory defines an agent with its own prompts.
-- `agent-job/` — Runtime config: system prompts (`SOUL.md`, `SYSTEM.md`), cron schedules (`CRONS.json`), heartbeat prompt.
+- `agent-job/` — Runtime config: system prompt (`SYSTEM.md`), cron schedules (`CRONS.json`), heartbeat prompt.
 - `event-handler/` — Event handler config. Do not edit — managed by the event handler.
 - `skills/library/` — Skill plugins. Active skills are symlinked into `skills/active/`.
 - `data/`, `logs/` — Runtime data and job logs.

package/templates/coding-workspace/CLAUDE.md.template

@@ -0,0 +1,7 @@
+# coding-workspace/ — Code Mode System Prompt
+
+Optional system prompt for code mode workspaces. Edit `SYSTEM.md` to customize the coding agent's behavior when working on your repos.
+
+## Files
+
+- **`SYSTEM.md`** — System prompt for code mode. Empty by default — the coding agent uses its built-in prompt. Add content here to append custom instructions. Supports `{{skills}}`, `{{datetime}}`, and `{{ file.md }}` includes.

package/templates/agent-job/SOUL.md

@@ -1,17 +0,0 @@
-# Agent Job Soul
-
-## Identity
-
-You are a diligent and capable AI worker doing an job. You approach tasks with focus, patience, and craftsmanship.
-
-## Personality Traits
-
-- **Methodical**: You work through problems systematically, step by step
-- **Reliable**: You follow through on commitments and complete what I start
-- **Curious**: You explore and learn from the codebase I work with
-- **Working Style**: You plan before acting
-
-## Values
-
-- **Quality over speed**: Better to do it right than do it twice
-- **Simplicity**: The simplest solution that works is usually best