onkol 0.1.0

package/scripts/spawn-worker.sh

@@ -0,0 +1,253 @@
+#!/bin/bash
+set -euo pipefail
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --name) WORKER_NAME="$2"; shift 2 ;;
+    --dir) WORK_DIR="$2"; shift 2 ;;
+    --task) TASK_DESC="$2"; shift 2 ;;
+    --intent) INTENT="$2"; shift 2 ;;
+    --context) CONTEXT="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+# Validate required args
+: "${WORKER_NAME:?--name is required}"
+: "${WORK_DIR:?--dir is required}"
+: "${TASK_DESC:?--task is required}"
+: "${INTENT:=fix}"
+: "${CONTEXT:=No additional context.}"
+
+# Load config
+ONKOL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$ONKOL_DIR/config.json"
+BOT_TOKEN=$(jq -r '.botToken' "$CONFIG")
+GUILD_ID=$(jq -r '.guildId' "$CONFIG")
+CATEGORY_ID=$(jq -r '.categoryId' "$CONFIG")
+ALLOWED_USERS=$(jq -c '.allowedUsers' "$CONFIG")
+NODE_NAME=$(jq -r '.nodeName' "$CONFIG")
+MAX_WORKERS=$(jq -r '.maxWorkers // 3' "$CONFIG")
+TMUX_SESSION="onkol-${NODE_NAME}"
+
+# Check concurrency limit
+TRACKING="$ONKOL_DIR/workers/tracking.json"
+if [ -f "$TRACKING" ]; then
+  ACTIVE_COUNT=$(jq '[.[] | select(.status == "active")] | length' "$TRACKING")
+  if [ "$ACTIVE_COUNT" -ge "$MAX_WORKERS" ]; then
+    echo "ERROR: Worker limit reached ($ACTIVE_COUNT/$MAX_WORKERS). Task queued."
+    exit 1
+  fi
+fi
+
+# Create Discord channel
+CHANNEL_RESPONSE=$(curl -s -X POST \
+  "https://discord.com/api/v10/guilds/${GUILD_ID}/channels" \
+  -H "Authorization: Bot ${BOT_TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d "{\"name\": \"$(echo "$WORKER_NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')\", \"type\": 0, \"parent_id\": \"${CATEGORY_ID}\"}")
+
+CHANNEL_ID=$(echo "$CHANNEL_RESPONSE" | jq -r '.id')
+if [ "$CHANNEL_ID" = "null" ] || [ -z "$CHANNEL_ID" ]; then
+  echo "ERROR: Failed to create Discord channel: $CHANNEL_RESPONSE"
+  exit 1
+fi
+
+# Create worker directory
+WORKER_DIR="$ONKOL_DIR/workers/$WORKER_NAME"
+mkdir -p "$WORKER_DIR"
+
+# Write task.md (using printf to prevent heredoc injection from user input)
+printf '%s\n' "# Task: $WORKER_NAME" "" \
+  "**Intent:** $INTENT" \
+  "**Working directory:** $WORK_DIR" \
+  "**Created:** $(date -Iseconds)" "" \
+  "## Description" "" > "$WORKER_DIR/task.md"
+printf '%s' "$TASK_DESC" >> "$WORKER_DIR/task.md"
+
+# Write context.md (using printf to prevent heredoc injection from user input)
+printf '%s\n' "# Context for $WORKER_NAME" "" > "$WORKER_DIR/context.md"
+printf '%s' "$CONTEXT" >> "$WORKER_DIR/context.md"
+
+# Write .mcp.json (DISCORD_ALLOWED_USERS must be a string, not raw JSON array)
+ALLOWED_USERS_ESCAPED=$(echo "$ALLOWED_USERS" | sed 's/\\/\\\\/g; s/"/\\"/g')
+PLUGIN_PATH="$ONKOL_DIR/plugins/discord-filtered/index.ts"
+cat > "$WORKER_DIR/.mcp.json" << MCPEOF
+{
+  "mcpServers": {
+    "discord-filtered": {
+      "command": "bun",
+      "args": ["$PLUGIN_PATH"],
+      "env": {
+        "DISCORD_BOT_TOKEN": "$BOT_TOKEN",
+        "DISCORD_CHANNEL_ID": "$CHANNEL_ID",
+        "DISCORD_ALLOWED_USERS": "$ALLOWED_USERS_ESCAPED"
+      }
+    }
+  }
+}
+MCPEOF
+
+# Write worker CLAUDE.md
+INTENT_INSTRUCTION=$(case $INTENT in
+  fix) echo "- Diagnose the issue, fix it, run tests, commit to a branch (not main), report results" ;;
+  investigate) echo "- Analyze the issue, gather data, report findings. Do NOT modify any files." ;;
+  build) echo "- Implement the feature, write tests, create a branch, show diff, wait for approval" ;;
+  analyze) echo "- Read logs/data/code, produce analysis, report. Do NOT modify any files." ;;
+  override) echo "- Full autonomy including push and deploy. Before deploying: ask 'About to deploy. Confirm?' and wait." ;;
+esac)
+
+cat > "$WORKER_DIR/CLAUDE.md" << CLEOF
+You are an Onkol worker session for "$NODE_NAME".
+
+## Your Task
+Read your task brief: $WORKER_DIR/task.md
+Read your context: $WORKER_DIR/context.md
+
+## Intent: $INTENT
+$INTENT_INSTRUCTION
+
+## CRITICAL: How to Communicate
+You are connected to Discord via the discord-filtered MCP channel.
+ALL your output must go through the reply tool — the user CANNOT see your terminal.
+
+- Use the \`reply\` tool from the discord-filtered MCP server to send ALL messages to the user.
+- NEVER just print output to the terminal. The user only sees Discord.
+- Send progress updates via reply tool as you work.
+- Send your final report/results via reply tool.
+- If you need to ask a question, use the reply tool. The user will respond via Discord.
+- For long reports, split into multiple reply calls (Discord has a 2000 char limit per message).
+
+## Rules
+- If you get stuck, ask via the reply tool. A human will respond via Discord.
+- Update your status in $WORKER_DIR/status.json periodically
+- Before dissolution, write learnings to $WORKER_DIR/learnings.md
+CLEOF
+
+# Write initial status.json
+cat > "$WORKER_DIR/status.json" << STATUSEOF
+{
+  "status": "starting",
+  "updated": "$(date -Iseconds)",
+  "task": "$WORKER_NAME",
+  "intent": "$INTENT"
+}
+STATUSEOF
+
+# Write per-worker .claude/settings.json with PostToolUse hook for bash logging
+mkdir -p "$WORKER_DIR/.claude"
+cat > "$WORKER_DIR/.claude/settings.json" << SETTINGSEOF
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "jq -r 'if .tool_name == \"Bash\" then \"[\"+.tool_input.command+\"] => \"+(.tool_result.stdout // \"\" | tostring) else empty end' >> $WORKER_DIR/bash-log.txt"
+          }
+        ]
+      }
+    ]
+  }
+}
+SETTINGSEOF
+
+# Determine allowed tools based on intent
+case $INTENT in
+  fix|build|override) ALLOWED_TOOLS="Bash,Read,Edit,Write,Glob,Grep" ;;
+  investigate|analyze) ALLOWED_TOOLS="Bash,Read,Glob,Grep" ;;
+  *) ALLOWED_TOOLS="Bash,Read,Edit,Write,Glob,Grep" ;;
+esac
+
+# Pre-accept trust dialog for the working directory
+CLAUDE_JSON="$HOME/.claude/.claude.json"
+if [ -f "$CLAUDE_JSON" ]; then
+  UPDATED_CLAUDE=$(jq --arg dir "$WORK_DIR" '
+    .projects[$dir] = (.projects[$dir] // {}) + {hasTrustDialogAccepted: true, allowedTools: []}
+  ' "$CLAUDE_JSON")
+  echo "$UPDATED_CLAUDE" > "$CLAUDE_JSON"
+fi
+
+# Add startup instructions to the worker CLAUDE.md so it acts immediately
+cat >> "$WORKER_DIR/CLAUDE.md" << STARTEOF
+
+## On Startup
+Immediately when you start:
+1. Read $WORKER_DIR/task.md for your task
+2. Read $WORKER_DIR/context.md for context
+3. Begin work according to your intent
+4. Report progress and results using the reply tool to your Discord channel
+Do NOT wait for a message. Start working as soon as you boot.
+STARTEOF
+
+# Create a self-contained wrapper script with all paths baked in
+WRAPPER="$WORKER_DIR/start-worker.sh"
+cat > "$WRAPPER" << WRAPEOF
+#!/bin/bash
+TMUX_TARGET="${TMUX_SESSION}:${WORKER_NAME}"
+
+# Auto-accept prompts in the background
+(
+  for i in \$(seq 1 10); do
+    sleep 2
+    PANE_CONTENT=\$(tmux capture-pane -t "\$TMUX_TARGET" -p 2>/dev/null || echo "")
+    if echo "\$PANE_CONTENT" | grep -q "^❯"; then
+      # Claude is ready — send the initial prompt via tmux keys
+      sleep 1
+      tmux send-keys -t "\$TMUX_TARGET" "Read $WORKER_DIR/task.md and $WORKER_DIR/context.md, then begin work per CLAUDE.md." Enter
+      break
+    fi
+    tmux send-keys -t "\$TMUX_TARGET" Enter 2>/dev/null || true
+  done
+) &
+
+# Copy .mcp.json to work directory so claude auto-discovers the MCP server.
+# --mcp-config registers servers under a different namespace that
+# --dangerously-load-development-channels doesn't find. The .mcp.json in cwd works.
+# Save any existing .mcp.json and restore on exit.
+WORK_MCP="$WORK_DIR/.mcp.json"
+WORK_MCP_BACKUP=""
+if [ -f "\$WORK_MCP" ]; then
+  WORK_MCP_BACKUP="\${WORK_MCP}.onkol-backup"
+  cp "\$WORK_MCP" "\$WORK_MCP_BACKUP"
+fi
+cp "$WORKER_DIR/.mcp.json" "\$WORK_MCP"
+
+cleanup() {
+  if [ -n "\$WORK_MCP_BACKUP" ]; then
+    mv "\$WORK_MCP_BACKUP" "\$WORK_MCP"
+  else
+    rm -f "\$WORK_MCP"
+  fi
+}
+trap cleanup EXIT
+
+# Start claude (no positional prompt — startup instructions are in CLAUDE.md,
+# and the auto-acceptor sends the first prompt via tmux keys once claude is ready)
+cd "$WORK_DIR" && claude \\
+  --dangerously-skip-permissions \\
+  --dangerously-load-development-channels server:discord-filtered
+WRAPEOF
+chmod +x "$WRAPPER"
+
+# Start the worker in tmux
+tmux new-window -t "$TMUX_SESSION" -n "$WORKER_NAME" "bash '$WRAPPER'"
+
+# Update tracking.json
+if [ ! -f "$TRACKING" ]; then
+  echo '[]' > "$TRACKING"
+fi
+UPDATED=$(jq ". + [{
+  \"name\": \"$WORKER_NAME\",
+  \"channelId\": \"$CHANNEL_ID\",
+  \"workDir\": \"$WORK_DIR\",
+  \"intent\": \"$INTENT\",
+  \"status\": \"active\",
+  \"started\": \"$(date -Iseconds)\"
+}]" "$TRACKING")
+echo "$UPDATED" > "$TRACKING"
+
+echo "Worker '$WORKER_NAME' spawned. Discord channel: $CHANNEL_ID"
+echo "Talk to it in the new Discord channel."

package/scripts/start-orchestrator.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+ONKOL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$ONKOL_DIR/config.json"
+NODE_NAME=$(jq -r '.nodeName' "$CONFIG")
+TMUX_SESSION="onkol-${NODE_NAME}"
+
+if tmux has-session -t "$TMUX_SESSION" 2>/dev/null; then
+  echo "Session $TMUX_SESSION already running."
+  exit 0
+fi
+
+tmux new-session -d -s "$TMUX_SESSION" \
+  "cd '$ONKOL_DIR' && claude \
+    --dangerously-skip-permissions \
+    --dangerously-load-development-channels server:discord-filtered \
+    --mcp-config '$ONKOL_DIR/.mcp.json'"
+
+# Auto-accept interactive prompts (trust dialog + dev channels warning)
+# Background loop sends Enter every 2 seconds until claude reaches the ❯ prompt
+(
+  for i in $(seq 1 10); do
+    sleep 2
+    PANE_CONTENT=$(tmux capture-pane -t "$TMUX_SESSION" -p 2>/dev/null || echo "")
+    if echo "$PANE_CONTENT" | grep -q "^❯"; then
+      break
+    fi
+    tmux send-keys -t "$TMUX_SESSION" Enter 2>/dev/null || true
+  done
+) &
+
+echo "Orchestrator started in tmux session '$TMUX_SESSION'."
+echo "Attach with: tmux attach -t $TMUX_SESSION"

package/src/plugin/discord-client.ts

@@ -0,0 +1,68 @@
+import { Client, GatewayIntentBits, type Message } from 'discord.js'
+
+export interface DiscordClientConfig {
+  botToken: string
+  channelId: string
+  allowedUsers: string[]
+}
+
+export function shouldForwardMessage(
+  messageChannelId: string,
+  authorId: string,
+  isBot: boolean,
+  targetChannelId: string,
+  allowedUsers: string[]
+): boolean {
+  if (isBot) return false
+  if (messageChannelId !== targetChannelId) return false
+  if (allowedUsers.length > 0 && !allowedUsers.includes(authorId)) return false
+  return true
+}
+
+export function createDiscordClient(
+  config: DiscordClientConfig,
+  onMessage: (message: Message) => void
+) {
+  const client = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+    ],
+  })
+
+  client.on('messageCreate', (message) => {
+    if (
+      shouldForwardMessage(
+        message.channel.id,
+        message.author.id,
+        message.author.bot,
+        config.channelId,
+        config.allowedUsers
+      )
+    ) {
+      onMessage(message)
+    }
+  })
+
+  client.on('ready', () => {
+    console.error(`[discord-filtered] Connected as ${client.user?.tag}, filtering to channel ${config.channelId}`)
+  })
+
+  return {
+    login: () => client.login(config.botToken),
+    client,
+    async sendMessage(channelId: string, text: string) {
+      const channel = await client.channels.fetch(channelId)
+      if (channel?.isTextBased() && 'send' in channel) {
+        await channel.send(text)
+      }
+    },
+    async sendMessageWithFile(channelId: string, text: string, filePath: string) {
+      const channel = await client.channels.fetch(channelId)
+      if (channel?.isTextBased() && 'send' in channel) {
+        await channel.send({ content: text, files: [{ attachment: filePath }] })
+      }
+    },
+  }
+}

package/src/plugin/index.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env bun
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { createMcpServer } from './mcp-server.js'
+import { createDiscordClient } from './discord-client.js'
+import { MessageBatcher } from './message-batcher.js'
+
+const BOT_TOKEN = process.env.DISCORD_BOT_TOKEN
+const CHANNEL_ID = process.env.DISCORD_CHANNEL_ID
+const ALLOWED_USERS: string[] = JSON.parse(process.env.DISCORD_ALLOWED_USERS || '[]')
+
+if (!BOT_TOKEN) {
+  console.error('[discord-filtered] DISCORD_BOT_TOKEN is required')
+  process.exit(1)
+}
+if (!CHANNEL_ID) {
+  console.error('[discord-filtered] DISCORD_CHANNEL_ID is required')
+  process.exit(1)
+}
+
+const discord = createDiscordClient(
+  { botToken: BOT_TOKEN, channelId: CHANNEL_ID, allowedUsers: ALLOWED_USERS },
+  async (message) => {
+    await mcpServer.notification({
+      method: 'notifications/claude/channel',
+      params: {
+        content: message.content,
+        meta: {
+          channel_id: message.channel.id,
+          sender: message.author.username,
+          sender_id: message.author.id,
+          message_id: message.id,
+        },
+      },
+    })
+  }
+)
+
+const batcher = new MessageBatcher(async (text) => {
+  await discord.sendMessage(CHANNEL_ID, text)
+})
+
+const mcpServer = createMcpServer({
+  async reply(_channelId: string, text: string) {
+    batcher.enqueue(text)
+  },
+  async replyWithFile(_channelId: string, text: string, filePath: string) {
+    await discord.sendMessageWithFile(CHANNEL_ID, text, filePath)
+  },
+})
+
+async function main() {
+  await mcpServer.connect(new StdioServerTransport())
+  await discord.login()
+  console.error(`[discord-filtered] Ready. Listening to channel ${CHANNEL_ID}`)
+}
+
+main().catch((err) => {
+  console.error('[discord-filtered] Fatal error:', err)
+  process.exit(1)
+})

package/src/plugin/mcp-server.ts

@@ -0,0 +1,79 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+
+export interface McpToolHandlers {
+  reply: (channelId: string, text: string) => Promise<void>
+  replyWithFile: (channelId: string, text: string, filePath: string) => Promise<void>
+}
+
+export function createMcpServer(handlers?: McpToolHandlers) {
+  const server = new Server(
+    { name: 'discord-filtered', version: '0.1.0' },
+    {
+      capabilities: {
+        experimental: { 'claude/channel': {} },
+        tools: {},
+      },
+      instructions:
+        'Messages arrive as <channel source="discord-filtered">. Reply using the reply tool. Use reply_with_file to attach files.',
+    }
+  )
+
+  const channelId = process.env.DISCORD_CHANNEL_ID || ''
+
+  const tools = [
+    {
+      name: 'reply',
+      description: 'Send a text message back to the Discord channel',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          text: { type: 'string', description: 'The message text to send' },
+        },
+        required: ['text'],
+      },
+    },
+    {
+      name: 'reply_with_file',
+      description: 'Send a text message with a file attachment to the Discord channel',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          text: { type: 'string', description: 'The message text to send' },
+          file_path: { type: 'string', description: 'Absolute path to the file to attach' },
+        },
+        required: ['text', 'file_path'],
+      },
+    },
+  ]
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools,
+  }))
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params
+    if (name === 'reply' && handlers) {
+      await handlers.reply(channelId, (args as any).text)
+      return { content: [{ type: 'text' as const, text: 'sent' }] }
+    }
+    if (name === 'reply_with_file' && handlers) {
+      await handlers.replyWithFile(channelId, (args as any).text, (args as any).file_path)
+      return { content: [{ type: 'text' as const, text: 'sent' }] }
+    }
+    return { content: [{ type: 'text' as const, text: `unknown tool: ${name}` }] }
+  })
+
+  // Expose listTools for testing
+  ;(server as any).listTools = async () => {
+    const handler = (server as any)._requestHandlers.get('tools/list')
+    if (!handler) return []
+    const result = await handler({ method: 'tools/list', params: {} }, {})
+    return result?.tools || []
+  }
+
+  return server
+}

package/src/plugin/message-batcher.ts

@@ -0,0 +1,33 @@
+const DISCORD_MAX_LENGTH = 2000
+const TRUNCATION_SUFFIX = '\n... (truncated)'
+
+export class MessageBatcher {
+  private buffer: string[] = []
+  private timer: ReturnType<typeof setTimeout> | null = null
+  private sendFn: (text: string) => Promise<void>
+  private delayMs: number
+
+  constructor(sendFn: (text: string) => Promise<void>, delayMs = 3000) {
+    this.sendFn = sendFn
+    this.delayMs = delayMs
+  }
+
+  enqueue(text: string): void {
+    this.buffer.push(text)
+    if (this.timer) clearTimeout(this.timer)
+    this.timer = setTimeout(() => this.flush(), this.delayMs)
+  }
+
+  private async flush(): Promise<void> {
+    if (this.buffer.length === 0) return
+    let combined = this.buffer.join('\n')
+    this.buffer = []
+    this.timer = null
+
+    if (combined.length > DISCORD_MAX_LENGTH) {
+      combined = combined.slice(0, DISCORD_MAX_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX
+    }
+
+    await this.sendFn(combined)
+  }
+}

package/templates/orchestrator-claude.md.hbs

@@ -0,0 +1,95 @@
+You are the Onkol orchestrator for "{{nodeName}}" on this VM.
+
+## Your Role
+You do NOT solve tasks yourself. You ALWAYS spawn worker Claude Code sessions using the spawn-worker.sh script.
+
+## CRITICAL RULES — DO NOT VIOLATE
+- NEVER run `claude` commands directly. NEVER use `claude --print`, `claude -p`, or any variation.
+- NEVER craft your own worker spawning logic. ALWAYS use `./scripts/spawn-worker.sh`.
+- NEVER investigate codebases, read project files, or run project commands yourself.
+- If `spawn-worker.sh` fails, report the error to the user and ask what to do. Do NOT try to work around it.
+- You are a DISPATCHER. Your only tools are: spawn-worker.sh, dissolve-worker.sh, list-workers.sh, check-worker.sh, and reading your own state files (config.json, registry.json, services.md, knowledge/, tracking.json).
+
+## When a message arrives
+1. Understand the task and its intent (fix, investigate, build, analyze, override)
+2. Determine which project directory the task relates to (check registry.json and services.md)
+3. Prepare a task brief with relevant context from:
+   - registry.json (secrets, endpoints, ports)
+   - services.md (what runs where, how to access logs)
+   - knowledge/ (past learnings from dissolved workers)
+4. Run `./scripts/spawn-worker.sh` to create a worker — this is the ONLY way to create workers
+5. Report back with the Discord channel name
+
+## Intent Detection
+- "fix..." / "resolve..." / "patch..." → intent: fix (autonomous — diagnose, fix, test, commit to branch)
+- "look into..." / "investigate..." / "check why..." → intent: investigate (report only — no code changes)
+- "add..." / "build..." / "create..." / "implement..." → intent: build (semi-autonomous — implement, test, show diff, wait for approval)
+- "just ship it" / "deploy" / "push it" → intent: override (fully autonomous — requires confirmation before deploy)
+- "analyze..." / "show me..." / "report on..." → intent: analyze (read-only)
+
+## Spawning a Worker
+```bash
+./scripts/spawn-worker.sh \
+  --name "short-task-name" \
+  --dir "/path/to/project" \
+  --task "Full task description" \
+  --intent "fix|investigate|build|analyze|override" \
+  --context "relevant context excerpts"
+```
+
+## Monitoring Workers
+- Read `workers/tracking.json` to see active workers
+- Run `./scripts/check-worker.sh --name "worker-name"` to check status
+- Run `./scripts/list-workers.sh` to see all workers
+
+## Dissolving Workers
+When a worker is done or you are asked to dissolve:
+```bash
+./scripts/dissolve-worker.sh --name "worker-name"
+```
+
+## On Startup
+Read these files to understand your current state:
+1. config.json — who you are
+2. registry.json — VM-specific endpoints, secrets, ports
+3. services.md — what runs on this VM, how to access logs
+4. workers/tracking.json — any active workers
+5. knowledge/index.json — past learnings (include relevant ones in worker context)
+6. state.md — any pending decisions from before restart
+
+Then post: "{{nodeName}} is online. [N] active workers."
+
+## Setup Prompts (First Boot)
+After reading your state files, check if `setup-prompts.json` exists and has entries with status "pending".
+If so, for each pending prompt:
+1. Read the prompt
+2. Execute it — run commands, discover information, read files as needed
+3. Write the result to the target file (registry.json, services.md, or CLAUDE.md)
+4. For registry.json: output must be valid JSON with key-value pairs
+5. For services.md: output should be structured markdown documenting services
+6. For CLAUDE.md: convert the plain language description into a well-structured CLAUDE.md with sections for project overview, tech stack, key files, dos and don'ts, deploy process
+7. Mark the prompt's status as "completed" in setup-prompts.json
+8. Report what was generated in the Discord channel
+
+## Health Checks
+Every time you receive a message, also check:
+1. Read tracking.json for active workers
+2. Run `tmux list-windows -t onkol-{{nodeName}}` to verify workers are alive
+3. If a worker's window is gone, report it and ask: respawn, dissolve, or investigate?
+
+## Adaptive Communication
+- Quick tasks (< 5 min): just report results
+- Medium tasks (5-15 min): report at start and finish
+- Long tasks (15+ min): milestone updates every 10 minutes
+- If stuck: ask immediately, block until human responds
+
+## Worker Concurrency
+Maximum {{maxWorkers}} concurrent workers. If at capacity, queue the task and notify.
+
+## Important
+- You do NOT write code yourself
+- You do NOT access project codebases directly — that's what workers are for
+- You do NOT run `claude` commands directly — ONLY use spawn-worker.sh
+- You are a dispatcher and manager, nothing more
+- All your state is in files — your conversation history is ephemeral
+- If spawn-worker.sh fails, report the exact error. Do NOT improvise alternatives.

package/templates/settings.json.hbs

@@ -0,0 +1,20 @@
+{
+  "hooks": {
+    "PreCompact": [{
+      "hooks": [{
+        "type": "command",
+        "command": "echo '{\"systemMessage\": \"Before compacting: write any in-flight task state to workers/tracking.json and pending decisions to state.md\"}'"
+      }]
+    }],
+    "PostToolUse": [{
+      "matcher": "Bash",
+      "hooks": [{
+        "type": "command",
+        "command": "jq -r '.tool_input.command' >> {{bashLogPath}}"
+      }]
+    }]
+  },
+  "permissions": {
+    "defaultMode": "acceptEdits"
+  }
+}