@openparachute/agent 0.1.1 → 0.2.0

package/container/agent-runner/src/index.ts

@@ -1,110 +0,0 @@
-/**
- * parachute-agent runner
- *
- * Runs inside a container. All IO goes through the session DB.
- * No stdin, no stdout markers, no IPC files.
- *
- * Config is read from /workspace/agent/container.json (mounted RO).
- * Only TZ comes from env.
- *
- * Mount structure:
- *   /workspace/
- *     inbound.db        ← host-owned session DB (container reads only)
- *     outbound.db       ← container-owned session DB
- *     .heartbeat        ← container touches for liveness detection
- *     outbox/           ← outbound files
- *     agent/            ← agent group folder (CLAUDE.md, container.json, working files)
- *       container.json  ← per-group config (RO nested mount)
- *     global/           ← shared global memory (RO)
- *   /app/src/           ← shared agent-runner source (RO)
- *   /app/skills/        ← shared skills (RO)
- *   /home/node/.claude/ ← Claude SDK state + skill symlinks (RW)
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { loadConfig } from './config.js';
-import { buildSystemPromptAddendum } from './destinations.js';
-// Providers barrel — each enabled provider self-registers on import.
-// Provider skills append imports to providers/index.ts.
-import './providers/index.js';
-import { createProvider, type ProviderName } from './providers/factory.js';
-import { runPollLoop } from './poll-loop.js';
-
-function log(msg: string): void {
-  console.error(`[agent-runner] ${msg}`);
-}
-
-const CWD = '/workspace/agent';
-
-async function main(): Promise<void> {
-  const config = loadConfig();
-  const providerName = config.provider.toLowerCase() as ProviderName;
-
-  log(`Starting v2 agent-runner (provider: ${providerName})`);
-
-  // Runtime-generated system-prompt addendum: agent identity (name) plus
-  // the live destinations map. Everything else (capabilities, per-module
-  // instructions, per-channel formatting) is loaded by Claude Code from
-  // /workspace/agent/CLAUDE.md — the composed entry imports the shared
-  // base (/app/CLAUDE.md) and each enabled module's fragment. Per-group
-  // memory lives in /workspace/agent/CLAUDE.local.md (auto-loaded).
-  const instructions = buildSystemPromptAddendum(config.assistantName || undefined);
-
-  // Discover additional directories mounted at /workspace/extra/*
-  const additionalDirectories: string[] = [];
-  const extraBase = '/workspace/extra';
-  if (fs.existsSync(extraBase)) {
-    for (const entry of fs.readdirSync(extraBase)) {
-      const fullPath = path.join(extraBase, entry);
-      if (fs.statSync(fullPath).isDirectory()) {
-        additionalDirectories.push(fullPath);
-      }
-    }
-    if (additionalDirectories.length > 0) {
-      log(`Additional directories: ${additionalDirectories.join(', ')}`);
-    }
-  }
-
-  // MCP server path — bun runs TS directly; no tsc build step in-image.
-  const __dirname = path.dirname(fileURLToPath(import.meta.url));
-  const mcpServerPath = path.join(__dirname, 'mcp-tools', 'index.ts');
-
-  // Build MCP servers config: parachute-agent built-in + any from container.json.
-  // Tools advertise as `mcp__parachute_agent__<verb>-<noun>` (the SDK's name
-  // mangle replaces non-alphanum with underscore). Renamed from `paraclaw` in
-  // 0.1.0; existing sessions need a restart to pick up the new prefix.
-  const mcpServers: Record<string, { command: string; args: string[]; env: Record<string, string> }> = {
-    'parachute-agent': {
-      command: 'bun',
-      args: ['run', mcpServerPath],
-      env: {},
-    },
-  };
-
-  for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-    mcpServers[name] = serverConfig;
-    log(`Additional MCP server: ${name} (${serverConfig.command})`);
-  }
-
-  const provider = createProvider(providerName, {
-    assistantName: config.assistantName || undefined,
-    mcpServers,
-    env: { ...process.env },
-    additionalDirectories: additionalDirectories.length > 0 ? additionalDirectories : undefined,
-  });
-
-  await runPollLoop({
-    provider,
-    providerName,
-    cwd: CWD,
-    systemContext: { instructions },
-  });
-}
-
-main().catch((err) => {
-  log(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
-  process.exit(1);
-});

package/container/agent-runner/src/integration.test.ts

@@ -1,121 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-
-import { initTestSessionDb, closeSessionDb, getInboundDb, getOutboundDb } from './db/connection.js';
-import { getUndeliveredMessages } from './db/messages-out.js';
-import { getPendingMessages } from './db/messages-in.js';
-import { MockProvider } from './providers/mock.js';
-import { runPollLoop } from './poll-loop.js';
-
-beforeEach(() => {
-  initTestSessionDb();
-  // Seed a destination so output parsing can resolve "discord-test" → routing
-  getInboundDb()
-    .prepare(
-      `INSERT INTO destinations (name, display_name, type, channel_type, platform_id, agent_group_id)
-       VALUES ('discord-test', 'Discord Test', 'channel', 'discord', 'chan-1', NULL)`,
-    )
-    .run();
-});
-
-afterEach(() => {
-  closeSessionDb();
-});
-
-function insertMessage(id: string, content: object, opts?: { platformId?: string; channelType?: string; threadId?: string }) {
-  getInboundDb()
-    .prepare(
-      `INSERT INTO messages_in (id, kind, timestamp, status, platform_id, channel_type, thread_id, content)
-       VALUES (?, 'chat', datetime('now'), 'pending', ?, ?, ?, ?)`,
-    )
-    .run(id, opts?.platformId ?? null, opts?.channelType ?? null, opts?.threadId ?? null, JSON.stringify(content));
-}
-
-describe('poll loop integration', () => {
-  it('should pick up a message, process it, and write a response', async () => {
-    insertMessage('m1', { sender: 'Alice', text: 'What is the meaning of life?' }, { platformId: 'chan-1', channelType: 'discord', threadId: 'thread-1' });
-
-    const provider = new MockProvider({}, () => '<message to="discord-test">42</message>');
-
-    const controller = new AbortController();
-    const loopPromise = runPollLoopWithTimeout(provider, controller.signal, 2000);
-
-    await waitFor(() => getUndeliveredMessages().length > 0, 2000);
-    controller.abort();
-
-    const out = getUndeliveredMessages();
-    expect(out).toHaveLength(1);
-    expect(JSON.parse(out[0].content).text).toBe('42');
-    expect(out[0].platform_id).toBe('chan-1');
-    expect(out[0].channel_type).toBe('discord');
-    expect(out[0].in_reply_to).toBe('m1');
-
-    // Input message should be acked (not pending)
-    const pending = getPendingMessages();
-    expect(pending).toHaveLength(0);
-
-    await loopPromise.catch(() => {});
-  });
-
-  it('should process multiple messages in a batch', async () => {
-    insertMessage('m1', { sender: 'Alice', text: 'Hello' });
-    insertMessage('m2', { sender: 'Bob', text: 'World' });
-
-    const provider = new MockProvider({}, () => '<message to="discord-test">Got both messages</message>');
-    const controller = new AbortController();
-    const loopPromise = runPollLoopWithTimeout(provider, controller.signal, 2000);
-
-    await waitFor(() => getUndeliveredMessages().length > 0, 2000);
-    controller.abort();
-
-    const out = getUndeliveredMessages();
-    expect(out).toHaveLength(1);
-    expect(JSON.parse(out[0].content).text).toBe('Got both messages');
-
-    await loopPromise.catch(() => {});
-  });
-
-  it('should process messages arriving after loop starts', async () => {
-    const provider = new MockProvider({}, () => '<message to="discord-test">Processed</message>');
-    const controller = new AbortController();
-    const loopPromise = runPollLoopWithTimeout(provider, controller.signal, 3000);
-
-    // Insert message after loop has started
-    await sleep(200);
-    insertMessage('m-late', { sender: 'Charlie', text: 'Late arrival' });
-
-    await waitFor(() => getUndeliveredMessages().length > 0, 2000);
-    controller.abort();
-
-    const out = getUndeliveredMessages();
-    expect(out.length).toBeGreaterThanOrEqual(1);
-
-    await loopPromise.catch(() => {});
-  });
-});
-
-// Helper: run poll loop until aborted or timeout
-async function runPollLoopWithTimeout(provider: MockProvider, signal: AbortSignal, timeoutMs: number): Promise<void> {
-  return Promise.race([
-    runPollLoop({
-      provider,
-      providerName: 'mock',
-      cwd: '/tmp',
-    }),
-    new Promise<void>((_, reject) => {
-      signal.addEventListener('abort', () => reject(new Error('aborted')));
-    }),
-    new Promise<void>((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs)),
-  ]);
-}
-
-async function waitFor(condition: () => boolean, timeoutMs: number): Promise<void> {
-  const start = Date.now();
-  while (!condition()) {
-    if (Date.now() - start > timeoutMs) throw new Error('waitFor timeout');
-    await sleep(50);
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/container/agent-runner/src/mcp-tools/agents.instructions.md

@@ -1,26 +0,0 @@
-## Companion and collaborator agents (`create_agent`)
-
-`mcp__parachute_agent__create_agent({ name, instructions })` spins up a new long-lived agent and wires it as a destination — bidirectional, so you can send it tasks and it can message you back.
-
-### How it works
-
-- Creates a new agent with its own container, workspace, and session. Your `instructions` string seeds the agent's `CLAUDE.local.md` — its starting role and personality.
-- The agent's `name` becomes a destination on both sides: you address it via `send_message({ to: "<name>", ... })`, and its replies arrive as inbound messages with `from="<name>"`.
-- Each agent has its own persistent workspace under `groups/<folder>/` — memory, conversation history, and notes all survive across sessions. This is a full standalone agent, not a stateless sub-query.
-- **Fire-and-forget:** the call returns immediately without waiting for the agent to confirm it's ready. Messages you send will queue until it's up.
-
-### When to use
-
-- **Companions** — a long-running presence that accumulates context over time: a `Researcher` tracking an ongoing inquiry, a `Calendar` agent managing scheduling, an assistant that knows your preferences and history.
-- **Collaborators** — a parallel specialist that works independently and reports back: a `Builder` handling code edits while you stay in conversation, a `Reviewer` running checks in the background.
-
-The right frame is: does this agent need its own memory and context that builds over time, or does it need to work independently without blocking your turn? Either is a good reason to spawn one.
-
-### When NOT to use
-
-- **One-off lookups or short tasks** — use the SDK `Agent` tool instead. It's stateless, spins up and completes in one shot, and leaves no persistent footprint.
-- **Work that finishes before the user's next message** — agents persist indefinitely. Don't create one for something you could do inline.
-
-### Writing good `instructions`
-
-Cover: the agent's role, who it takes tasks from (you, by name), how it should report back (on completion only? with milestones for long work?), and any domain-specific rules. Don't restate Parachute Agent base behavior — the shared base is already loaded on the agent's end.

package/container/agent-runner/src/mcp-tools/agents.ts

@@ -1,66 +0,0 @@
-/**
- * Agent management MCP tools: create_agent.
- *
- * send_to_agent was removed — sending to another agent is now just
- * send_message(to="agent-name") since agents and channels share the
- * unified destinations namespace.
- *
- * create_agent is admin-only. Non-admin containers never see this tool
- * (see mcp-tools/index.ts). The host re-checks permission on receive.
- */
-import { writeMessageOut } from '../db/messages-out.js';
-import { registerTools } from './server.js';
-import type { McpToolDefinition } from './types.js';
-
-function log(msg: string): void {
-  console.error(`[mcp-tools] ${msg}`);
-}
-
-function generateId(): string {
-  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-function ok(text: string) {
-  return { content: [{ type: 'text' as const, text }] };
-}
-
-function err(text: string) {
-  return { content: [{ type: 'text' as const, text: `Error: ${text}` }], isError: true };
-}
-
-export const createAgent: McpToolDefinition = {
-  tool: {
-    name: 'create_agent',
-    description:
-      'Create a long-lived companion sub-agent (research assistant, task manager, specialist) — the name becomes your destination for it. Admin-only. Fire-and-forget.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        name: { type: 'string', description: 'Human-readable name (also becomes your destination name for this agent)' },
-        instructions: { type: 'string', description: 'CLAUDE.md content for the new agent (personality, role, instructions)' },
-      },
-      required: ['name'],
-    },
-  },
-  async handler(args) {
-    const name = args.name as string;
-    if (!name) return err('name is required');
-
-    const requestId = generateId();
-    writeMessageOut({
-      id: requestId,
-      kind: 'system',
-      content: JSON.stringify({
-        action: 'create_agent',
-        requestId,
-        name,
-        instructions: (args.instructions as string) || null,
-      }),
-    });
-
-    log(`create_agent: ${requestId} → "${name}"`);
-    return ok(`Creating agent "${name}". You will be notified when it is ready.`);
-  },
-};
-
-registerTools([createAgent]);

package/container/agent-runner/src/mcp-tools/core.instructions.md

@@ -1,27 +0,0 @@
-## Sending messages
-
-Your final response is delivered via the `## Sending messages` rules in your runtime system prompt (single-destination: just write; multi-destination: use `<message to="name">...</message>` blocks). See that section for the current destination list.
-
-### Mid-turn updates (`send_message`)
-
-Use the `mcp__parachute_agent__send_message` tool to send a message while you're still working (before your final output). If you have one destination, `to` is optional; with multiple, specify it. Pace your updates to the length of the work:
-
-- **Short turn (≤2 quick tool calls):** Don't narrate. Output any response.
-- **Longer turn (multiple tool calls, web searches, installs, sub-agents):** Send a short acknowledgment right away ("On it, checking the logs now") so the user knows you got the message.
-- **Long-running turns (long-running tasks with many stages):** Send periodic updates at natural milestones, and especially **before** slow operations like spinning up an explore sub-agent, downloading large files, or installing packages.
-
-**Never narrate micro-steps.** "I'm going to read the file now… okay, I'm reading it… now I'm parsing it…" is noise. Updates should mark meaningful transitions, not every tool call.
-
-**Outcomes, not play-by-play.** When the turn is done, the final message should be about the result, not a transcript of what you did.
-
-### Sending files (`send_file`)
-
-Use `mcp__parachute_agent__send_file({ path, text?, filename?, to? })` to deliver a file from your workspace. `path` is absolute or relative to `/workspace/agent/`; `filename` overrides the display name shown in chat (defaults to the file's basename); `text` is an optional accompanying message. Use this for artifacts you produce (charts, PDFs, generated images, reports) rather than dumping contents into chat.
-
-### Reacting to messages (`add_reaction`)
-
-Use `mcp__parachute_agent__add_reaction({ messageId, emoji })` to react to a specific inbound message by its `#N` id — pass `messageId` as an integer (e.g. `22`, not `"22"`). Good for lightweight acknowledgment (`eyes` = seen, `white_check_mark` = done) when a full reply would be noise. `emoji` is the shortcode name (e.g. `thumbs_up`, `heart`), not the raw character.
-
-### Internal thoughts
-
-Wrap reasoning in `<internal>...</internal>` tags to mark it as scratchpad — logged but not sent.

package/container/agent-runner/src/mcp-tools/core.ts

@@ -1,262 +0,0 @@
-/**
- * Core MCP tools: send_message, send_file, edit_message, add_reaction.
- *
- * All outbound tools resolve destinations via the local destination map
- * (see destinations.ts). Agents reference destinations by name; the map
- * translates name → routing tuple. Permission enforcement happens on
- * the host side in delivery.ts via the agent_destinations table.
- */
-import fs from 'fs';
-import path from 'path';
-
-import { findByName, getAllDestinations } from '../destinations.js';
-import { getMessageIdBySeq, getRoutingBySeq, writeMessageOut } from '../db/messages-out.js';
-import { getSessionRouting } from '../db/session-routing.js';
-import { registerTools } from './server.js';
-import type { McpToolDefinition } from './types.js';
-
-function log(msg: string): void {
-  console.error(`[mcp-tools] ${msg}`);
-}
-
-function generateId(): string {
-  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-function ok(text: string) {
-  return { content: [{ type: 'text' as const, text }] };
-}
-
-function err(text: string) {
-  return { content: [{ type: 'text' as const, text: `Error: ${text}` }], isError: true };
-}
-
-function destinationList(): string {
-  const all = getAllDestinations();
-  if (all.length === 0) return '(none)';
-  return all.map((d) => d.name).join(', ');
-}
-
-/**
- * Resolve a destination name to routing fields.
- *
- * If `to` is omitted, use the session's default reply routing (channel +
- * thread the conversation is in) — the agent replies in place.
- *
- * If `to` is specified, look up the named destination. If it resolves to
- * the same channel the session is bound to, the session's thread_id is
- * preserved so replies land in the correct thread. Otherwise thread_id
- * is null (a cross-destination send starts a new conversation).
- */
-function resolveRouting(
-  to: string | undefined,
-):
-  | { channel_type: string; platform_id: string; thread_id: string | null; resolvedName: string }
-  | { error: string } {
-  if (!to) {
-    // Default: reply to whatever thread/channel this session is bound to.
-    const session = getSessionRouting();
-    if (session.channel_type && session.platform_id) {
-      return {
-        channel_type: session.channel_type,
-        platform_id: session.platform_id,
-        thread_id: session.thread_id,
-        resolvedName: '(current conversation)',
-      };
-    }
-    // No session routing (e.g., agent-shared or internal-only agent) —
-    // fall back to the legacy single-destination shortcut.
-    const all = getAllDestinations();
-    if (all.length === 0) return { error: 'No destinations configured.' };
-    if (all.length > 1) {
-      return {
-        error: `You have multiple destinations — specify "to". Options: ${all.map((d) => d.name).join(', ')}`,
-      };
-    }
-    to = all[0].name;
-  }
-  const dest = findByName(to);
-  if (!dest) return { error: `Unknown destination "${to}". Known: ${destinationList()}` };
-  if (dest.type === 'channel') {
-    // If the destination is the same channel the session is bound to,
-    // preserve the thread_id so replies land in the correct thread.
-    const session = getSessionRouting();
-    const threadId =
-      session.channel_type === dest.channelType && session.platform_id === dest.platformId
-        ? session.thread_id
-        : null;
-    return {
-      channel_type: dest.channelType!,
-      platform_id: dest.platformId!,
-      thread_id: threadId,
-      resolvedName: to,
-    };
-  }
-  return { channel_type: 'agent', platform_id: dest.agentGroupId!, thread_id: null, resolvedName: to };
-}
-
-export const sendMessage: McpToolDefinition = {
-  tool: {
-    name: 'send_message',
-    description:
-      'Send a message to a named destination. If you have only one destination, you can omit `to`.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        to: { type: 'string', description: 'Destination name (e.g., "family", "worker-1"). Optional if you have only one destination.' },
-        text: { type: 'string', description: 'Message content' },
-      },
-      required: ['text'],
-    },
-  },
-  async handler(args) {
-    const text = args.text as string;
-    if (!text) return err('text is required');
-
-    const routing = resolveRouting(args.to as string | undefined);
-    if ('error' in routing) return err(routing.error);
-
-    const id = generateId();
-    const seq = writeMessageOut({
-      id,
-      kind: 'chat',
-      platform_id: routing.platform_id,
-      channel_type: routing.channel_type,
-      thread_id: routing.thread_id,
-      content: JSON.stringify({ text }),
-    });
-
-    log(`send_message: #${seq} → ${routing.resolvedName}`);
-    return ok(`Message sent to ${routing.resolvedName} (id: ${seq})`);
-  },
-};
-
-export const sendFile: McpToolDefinition = {
-  tool: {
-    name: 'send_file',
-    description: 'Send a file to a named destination. If you have only one destination, you can omit `to`.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        to: { type: 'string', description: 'Destination name. Optional if you have only one destination.' },
-        path: { type: 'string', description: 'File path (relative to /workspace/agent/ or absolute)' },
-        text: { type: 'string', description: 'Optional accompanying message' },
-        filename: { type: 'string', description: 'Display name (default: basename of path)' },
-      },
-      required: ['path'],
-    },
-  },
-  async handler(args) {
-    const filePath = args.path as string;
-    if (!filePath) return err('path is required');
-
-    const routing = resolveRouting(args.to as string | undefined);
-    if ('error' in routing) return err(routing.error);
-
-    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve('/workspace/agent', filePath);
-    if (!fs.existsSync(resolvedPath)) return err(`File not found: ${filePath}`);
-
-    const id = generateId();
-    const filename = (args.filename as string) || path.basename(resolvedPath);
-
-    const outboxDir = path.join('/workspace/outbox', id);
-    fs.mkdirSync(outboxDir, { recursive: true });
-    fs.copyFileSync(resolvedPath, path.join(outboxDir, filename));
-
-    writeMessageOut({
-      id,
-      kind: 'chat',
-      platform_id: routing.platform_id,
-      channel_type: routing.channel_type,
-      thread_id: routing.thread_id,
-      content: JSON.stringify({ text: (args.text as string) || '', files: [filename] }),
-    });
-
-    log(`send_file: ${id} → ${routing.resolvedName} (${filename})`);
-    return ok(`File sent to ${routing.resolvedName} (id: ${id}, filename: ${filename})`);
-  },
-};
-
-export const editMessage: McpToolDefinition = {
-  tool: {
-    name: 'edit_message',
-    description: 'Edit a previously sent message. Targets the same destination the original message was sent to.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        messageId: { type: 'integer', description: 'Message ID (the numeric id shown in messages)' },
-        text: { type: 'string', description: 'New message content' },
-      },
-      required: ['messageId', 'text'],
-    },
-  },
-  async handler(args) {
-    const seq = Number(args.messageId);
-    const text = args.text as string;
-    if (!seq || !text) return err('messageId and text are required');
-
-    const platformId = getMessageIdBySeq(seq);
-    if (!platformId) return err(`Message #${seq} not found`);
-
-    const routing = getRoutingBySeq(seq);
-    if (!routing || !routing.channel_type || !routing.platform_id) {
-      return err(`Cannot determine destination for message #${seq}`);
-    }
-
-    const id = generateId();
-    writeMessageOut({
-      id,
-      kind: 'chat',
-      platform_id: routing.platform_id,
-      channel_type: routing.channel_type,
-      thread_id: routing.thread_id,
-      content: JSON.stringify({ operation: 'edit', messageId: platformId, text }),
-    });
-
-    log(`edit_message: #${seq} → ${platformId}`);
-    return ok(`Message edit queued for #${seq}`);
-  },
-};
-
-export const addReaction: McpToolDefinition = {
-  tool: {
-    name: 'add_reaction',
-    description: 'Add an emoji reaction to a message.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        messageId: { type: 'integer', description: 'Message ID (the numeric id shown in messages)' },
-        emoji: { type: 'string', description: 'Emoji name (e.g., thumbs_up, heart, check)' },
-      },
-      required: ['messageId', 'emoji'],
-    },
-  },
-  async handler(args) {
-    const seq = Number(args.messageId);
-    const emoji = args.emoji as string;
-    if (!seq || !emoji) return err('messageId and emoji are required');
-
-    const platformId = getMessageIdBySeq(seq);
-    if (!platformId) return err(`Message #${seq} not found`);
-
-    const routing = getRoutingBySeq(seq);
-    if (!routing || !routing.channel_type || !routing.platform_id) {
-      return err(`Cannot determine destination for message #${seq}`);
-    }
-
-    const id = generateId();
-    writeMessageOut({
-      id,
-      kind: 'chat',
-      platform_id: routing.platform_id,
-      channel_type: routing.channel_type,
-      thread_id: routing.thread_id,
-      content: JSON.stringify({ operation: 'reaction', messageId: platformId, emoji }),
-    });
-
-    log(`add_reaction: #${seq} → ${emoji} on ${platformId}`);
-    return ok(`Reaction queued for #${seq}`);
-  },
-};
-
-registerTools([sendMessage, sendFile, editMessage, addReaction]);

package/container/agent-runner/src/mcp-tools/index.ts

@@ -1,22 +0,0 @@
-/**
- * MCP tools barrel — imports each tool module for its side-effect
- * `registerTools([...])` call, then starts the MCP server.
- *
- * Adding a new tool module: create the file, call `registerTools([...])`
- * at module scope, and append the import here. No central list.
- */
-import './core.js';
-import './scheduling.js';
-import './interactive.js';
-import './agents.js';
-import './self-mod.js';
-import { startMcpServer } from './server.js';
-
-function log(msg: string): void {
-  console.error(`[mcp-tools] ${msg}`);
-}
-
-startMcpServer().catch((err) => {
-  log(`MCP server error: ${err instanceof Error ? err.message : String(err)}`);
-  process.exit(1);
-});

package/container/agent-runner/src/mcp-tools/interactive.instructions.md

@@ -1,22 +0,0 @@
-## Interactive prompts
-
-The two tools here solve different problems: `ask_user_question` forces a decision and waits for it; `send_card` displays structured content and moves on.
-
-### Asking a multiple-choice question (`ask_user_question`)
-
-`mcp__parachute_agent__ask_user_question({ title, question, options, timeout? })` presents the user with a set of choices and **blocks your turn** until they tap one or the timeout expires (default: 300 seconds). Returns their chosen value.
-
-`options` can be plain strings or `{ label, selectedLabel?, value? }` objects:
-- `label` — the button text shown before selection
-- `selectedLabel` — the text shown on the button *after* selection (useful for confirmations, e.g. `"✓ Confirmed"`)
-- `value` — the string returned to you when that option is chosen (defaults to `label`)
-
-Use this when you genuinely cannot proceed without a decision. For free-text input, send a normal message and wait for their reply — don't reach for this tool.
-
-### Structured cards (`send_card`)
-
-`mcp__parachute_agent__send_card({ card, fallbackText? })` renders a structured card and **returns immediately** — it does not pause your turn or collect a response.
-
-`card` supports: `title`, `description`, `children` (nested text or content blocks), and `actions` (buttons). `fallbackText` is sent as a plain message on platforms without card support.
-
-Use this for presenting information in a cleaner format than prose: summaries, options the user can read (but you're not waiting on), or results with contextual buttons. If you need the user to actually *choose* something and return a value, use `ask_user_question` instead.