agent-office 0.0.12 → 0.0.14

package/README.md

@@ -1,14 +1,44 @@
 # agent-office
 
-Manage [OpenCode](https://opencode.ai) sessions with named aliases, agent codes, and a full-screen terminal UI.
+An office for your AI agents. Manage multiple [OpenCode](https://opencode.ai) coding sessions as named coworkers with inter-agent messaging, scheduled tasks, persistent memory, and a terminal UI for human oversight.
 
 ## Overview
 
-`agent-office` is a CLI tool with two main roles:
+`agent-office` sits between a human operator and one or more AI coding agents running on an OpenCode server. It wraps raw OpenCode sessions with named identities, a messaging system, cron-based scheduling, and per-agent memory -- creating an "office" where AI agents are coworkers that communicate, take direction, and operate autonomously.
 
-- **`serve`** — runs an HTTP server that sits in front of an OpenCode server and a PostgreSQL database. It manages named sessions, agent codes, and exposes a REST API.
-- **`manage`** — a full-screen React Ink TUI that connects to a running `serve` instance and lets you create, delete, inspect, and interact with sessions.
-- **`worker clock-in`** — lets an agent identify itself using its unique agent code and receive a welcome message with its session details.
+**For humans**, there are three interfaces:
+
+- **`serve`** -- an HTTP server that manages sessions, messages, cron jobs, and memory, backed by PostgreSQL and a running OpenCode server
+- **`manage`** -- a full-screen terminal UI (React Ink) for creating coworkers, sending messages, browsing mail, managing cron jobs, and observing agent activity
+- **`communicator web`** -- a browser-based chat interface for conversing with a specific agent in real time
+
+**For AI agents**, there is a CLI:
+
+- **`worker`** -- subcommands that agents invoke from within their OpenCode sessions to clock in, message coworkers, set status, manage cron jobs, and store memories
+
+```
+                    +---------------------+
+                    |   OpenCode Server   |
+                    |   :4096             |
+                    +---------+-----------+
+                              |
++--------------+    +---------+-----------+    +--------------+
+| TUI (manage) |<-->|  agent-office serve  |<-->|  PostgreSQL  |
+|  Ink/React   |    |      :7654           |    |              |
++--------------+    |                      |    +--------------+
+                    |   CronScheduler      |
++--------------+    |   MemoryManager      |    +--------------+
+| Communicator |<-->|                      |<-->|  .memory/    |
+| Web (HTMX)   |    |                      |    |  SQLite DBs  |
+| :7655        |    +---------+-----------+    +--------------+
++--------------+              |
+                              | /worker/* endpoints
+                    +---------+-----------+
+                    |   AI Agent Workers   |
+                    |  (running inside     |
+                    |   OpenCode sessions) |
+                    +-----------------------+
+```
 
 ## Installation
 
@@ -19,7 +49,7 @@ npm install -g agent-office
 Or run without installing:
 
 ```bash
-npx agent-office serve --help
+npx agent-office --help
 ```
 
 ## Requirements
@@ -36,31 +66,60 @@ npx agent-office serve --help
 agent-office serve \
   --database-url "postgresql://user:pass@localhost:5432/mydb" \
   --opencode-url "http://localhost:4096" \
-  --host 127.0.0.1 \
-  --port 7654 \
   --password mysecret
 ```
 
-Or use environment variables:
-
-```bash
-export DATABASE_URL="postgresql://user:pass@localhost:5432/mydb"
-export AGENT_OFFICE_PASSWORD="mysecret"
-agent-office serve
-```
+The server runs migrations automatically on startup, initializes the cron scheduler, and warms up the embedding model for agent memory.
 
 ### 2. Open the manager
 
+In another terminal:
+
 ```bash
-agent-office manage http://localhost:7654 --password mysecret
+agent-office manage --password mysecret
 ```
 
-### 3. Clock in as a worker
+From the TUI you can create coworkers, send them messages, browse mail, manage cron jobs, and observe their sessions.
+
+### 3. Chat with a coworker in the browser
 
 ```bash
-agent-office worker clock-in <agent_code>@http://localhost:7654
+agent-office communicator web "Alice" --secret mysecret
 ```
 
+Opens a web-based chat interface at `http://127.0.0.1:7655` for real-time conversation with the named coworker.
+
+## How It Works
+
+### Session Lifecycle
+
+1. **Create** -- A human creates a named coworker via the TUI or API. This creates an OpenCode session, stores the mapping in PostgreSQL, and sends an enrollment message containing a clock-in command.
+
+2. **Clock In** -- The AI agent sees the enrollment message in its session, runs `agent-office worker clock-in <token>`, and receives a welcome briefing with its name, the human manager's identity, all available CLI commands, and a privacy notice.
+
+3. **Work** -- The agent operates in its OpenCode session. It communicates with the human and other agents by running `agent-office worker send-message`. It can set its status, create cron jobs, and store persistent memories.
+
+4. **Message Delivery** -- Messages are stored in PostgreSQL and simultaneously injected as prompts into the recipient's OpenCode session. This means agents see messages immediately in their active session context.
+
+5. **Reset** -- A session can be reverted to its initial state (clearing all conversation history) and re-enrolled. Memories persist across resets since they are stored separately.
+
+6. **Delete** -- Deleting a coworker removes both the OpenCode session and the database record.
+
+### Privacy Model
+
+Agent sessions are private by design. The welcome message tells each agent:
+
+> Nobody -- not your human manager, not your coworkers -- can see anything you think, reason, or write inside this session. Your work is completely private until you explicitly send a message.
+
+This means agents must actively communicate to report progress, ask questions, or share results.
+
+### Authentication
+
+Two authentication schemes run in parallel:
+
+- **Bearer token** -- Human operators authenticate with `Authorization: Bearer <password>` for all management endpoints.
+- **Agent code** -- AI agents authenticate with a UUID passed as `?code=<uuid>` for all `/worker/*` endpoints. Each agent gets a unique code generated at session creation time.
+
 ## Environment Variables
 
 Copy `.env.example` to `.env` for local development:
@@ -69,81 +128,191 @@ Copy `.env.example` to `.env` for local development:
 cp .env.example .env
 ```
 
-| Variable | Description |
-|---|---|
-| `DATABASE_URL` | PostgreSQL connection string |
-| `AGENT_OFFICE_PASSWORD` | Password for the server API (required) |
-| `OPENCODE_URL` | OpenCode server URL (default: `http://localhost:4096`) |
+| Variable | Description | Default |
+|---|---|---|
+| `DATABASE_URL` | PostgreSQL connection string | (required) |
+| `AGENT_OFFICE_PASSWORD` | API password for human access | (required) |
+| `OPENCODE_URL` | OpenCode server URL | `http://localhost:4096` |
+| `AGENT_OFFICE_URL` | Server URL for manage/communicator clients | `http://127.0.0.1:7654` |
 
 ## Commands
 
 ### `agent-office serve`
 
-Starts the HTTP server. Runs database migrations automatically on startup.
+Starts the HTTP server. Connects to PostgreSQL, runs migrations, initializes the cron scheduler, and warms up the embedding model.
 
 ```
 Options:
-  --database-url <url>   PostgreSQL connection string (env: DATABASE_URL)
-  --opencode-url <url>   OpenCode server URL (env: OPENCODE_URL)
-  --host <host>          Host to bind to (default: 127.0.0.1)
-  --port <port>          Port to serve on (default: 7654)
-  --password <password>  REQUIRED. API password (env: AGENT_OFFICE_PASSWORD)
+  --database-url <url>     PostgreSQL connection string (env: DATABASE_URL)
+  --opencode-url <url>     OpenCode server URL (default: http://localhost:4096)
+  --host <host>            Bind host (default: 127.0.0.1)
+  --port <port>            Bind port (default: 7654)
+  --memory-path <path>     Directory for memory storage (default: ./.memory)
+  --password <password>    REQUIRED. API password (env: AGENT_OFFICE_PASSWORD)
 ```
 
-### `agent-office manage <url>`
+### `agent-office manage`
 
-Opens the full-screen terminal UI. All operations go through the server — `manage` never touches the database or OpenCode directly.
+Opens the full-screen terminal UI. All operations go through the HTTP server -- the TUI never touches PostgreSQL or OpenCode directly.
 
 ```
-Arguments:
-  url                    URL of the agent-office server
-
 Options:
-  --password <password>  REQUIRED. API password (env: AGENT_OFFICE_PASSWORD)
+  --url <url>              Server URL (default: http://127.0.0.1:7654)
+  --password <password>    REQUIRED. API password (env: AGENT_OFFICE_PASSWORD)
 ```
 
-#### TUI screens
+#### TUI Features
 
 | Screen | Description |
 |---|---|
-| List sessions | View all named sessions with masked agent codes. `↑↓` to navigate, `r` to reveal/hide the selected session's agent code |
-| Create session | Create a new named session. Automatically creates an OpenCode session and generates an agent code |
-| Delete session | Select and delete a session (also deletes the OpenCode session) |
-| Tail messages | View the most recent messages in a session |
-| Inject text | Send a message into a session |
-| Agent code | Reveal, hide, or regenerate the agent code for a session |
+| **Coworkers** | Table of all agents showing name, status, mode, session ID, and masked agent code. Keyboard: `c` create, `d` delete, `r` reveal code, `g` regenerate code, `x` revert session, `X` revert all, `t` tail messages, `i` inject text, `m` coworker mail, `M` memories |
+| **Send message** | Select a recipient and compose a message |
+| **My mail** | View received and sent messages. `r` reply, `m` mark read, `a` mark all read. Tab between received/sent |
+| **Cron jobs** | Table of scheduled tasks with name, coworker, schedule, next run, and status. Create, delete, enable/disable, view history |
+| **My profile** | Set your display name and description (visible to agents in their welcome message) |
 
-### `agent-office worker clock-in <token>`
+A sidebar shows all coworkers with live status indicators, refreshed every 5 seconds. An unread mail badge appears in the header.
 
-Clock in as a named agent. No password required — authentication is via the agent code.
+### `agent-office communicator web <coworker>`
 
-```bash
-agent-office worker clock-in <agent_code>@<server-url>
+Launches a browser-based chat interface for real-time conversation with a specific agent.
 
-# Example
-agent-office worker clock-in 550e8400-e29b-41d4-a716-446655440000@http://localhost:7654
 ```
+Arguments:
+  <coworker>               Name of the coworker to chat with
 
-On success, prints:
-
+Options:
+  --url <url>              Server URL (default: http://127.0.0.1:7654)
+  --secret <secret>        API password (env: AGENT_OFFICE_PASSWORD)
+  --host <host>            Communicator bind host (default: 127.0.0.1)
+  --port <port>            Communicator bind port (default: 7655)
 ```
-Welcome to the agent office, your name is john. Your OpenCode session ID is <id>. You are now clocked in and ready to work.
+
+Features: dark theme, iMessage-style chat bubbles, auto-scroll, Enter to send (Shift+Enter for newline), live message polling (5s), unread indicators, status display, and a reset button to revert the agent's session.
+
+### `agent-office worker` (for AI agents)
+
+All worker commands authenticate via a token in the format `<agent_code>@<server_url>`.
+
+```bash
+# Clock in and receive your briefing
+agent-office worker clock-in <token>
+
+# List coworkers and the human manager
+agent-office worker list-coworkers <token>
+
+# Set or clear your public status (max 140 chars)
+agent-office worker set-status --status "Working on auth module" <token>
+agent-office worker set-status --clear <token>
+
+# Send a message to one or more recipients
+agent-office worker send-message --name Alice --name Bob --body "Status update: PR is ready" <token>
+
+# Cron job management
+agent-office worker cron list <token>
+agent-office worker cron create --name "daily-report" --schedule "0 9 * * *" --message "Send daily status" <token>
+agent-office worker cron create --name "weekly" --schedule "0 9 * * 1" --message "Weekly sync" --timezone "America/New_York" <token>
+agent-office worker cron delete <token> <id>
+agent-office worker cron enable <token> <id>
+agent-office worker cron disable <token> <id>
+agent-office worker cron history <token> <id>
+
+# Persistent memory (survives session resets)
+agent-office worker memory add --content "The auth module uses JWT with RS256" <token>
+agent-office worker memory search --query "authentication" <token>
+agent-office worker memory list <token>
+agent-office worker memory forget <token> <memory-id>
 ```
 
 ## REST API
 
-All endpoints except `/worker/clock-in` require `Authorization: Bearer <password>`.
+### Authenticated Endpoints (Bearer token required)
 
 | Method | Path | Description |
 |---|---|---|
 | `GET` | `/health` | Health check |
+| `GET` | `/modes` | List available agent modes from the OpenCode server |
 | `GET` | `/sessions` | List all sessions |
-| `POST` | `/sessions` | Create session `{ name }` |
-| `DELETE` | `/sessions/:name` | Delete session by name |
-| `GET` | `/sessions/:name/messages` | Fetch recent messages (`?limit=N`, max 100) |
-| `POST` | `/sessions/:name/inject` | Inject text `{ text, modelID?, providerID? }` |
-| `POST` | `/sessions/:name/regenerate-code` | Regenerate agent code |
-| `GET` | `/worker/clock-in?code=<uuid>` | Validate agent code (no auth) |
+| `POST` | `/sessions` | Create a session. Body: `{ name, agent? }` |
+| `DELETE` | `/sessions/:name` | Delete a session |
+| `POST` | `/sessions/:name/regenerate-code` | Regenerate the agent code UUID |
+| `GET` | `/sessions/:name/messages` | Fetch messages. Query: `?limit=N` (max 100) |
+| `POST` | `/sessions/:name/inject` | Inject text. Body: `{ text }` |
+| `POST` | `/sessions/:name/revert-to-start` | Revert session and re-enroll |
+| `POST` | `/sessions/revert-all` | Revert all sessions |
+| `GET` | `/config` | Get all config values |
+| `PUT` | `/config` | Set a config value. Body: `{ key, value }` |
+| `GET` | `/messages/:name` | Get messages for a person. Query: `?sent=true`, `?unread_only=true` |
+| `POST` | `/messages` | Send a message. Body: `{ from, to: string[], body }` |
+| `POST` | `/messages/:id/read` | Mark a message as read |
+| `GET` | `/crons` | List cron jobs. Query: `?session_name=<name>` |
+| `POST` | `/crons` | Create a cron job. Body: `{ name, session_name, schedule, message, timezone? }` |
+| `DELETE` | `/crons/:id` | Delete a cron job |
+| `POST` | `/crons/:id/enable` | Enable a cron job |
+| `POST` | `/crons/:id/disable` | Disable a cron job |
+| `GET` | `/crons/:id/history` | Cron execution history. Query: `?limit=N` |
+| `GET` | `/sessions/:name/memories` | List memories. Query: `?limit=N` |
+| `POST` | `/sessions/:name/memories` | Add a memory. Body: `{ content, metadata? }` |
+| `GET` | `/sessions/:name/memories/:id` | Get a memory |
+| `PUT` | `/sessions/:name/memories/:id` | Update a memory. Body: `{ content, metadata? }` |
+| `DELETE` | `/sessions/:name/memories/:id` | Delete a memory |
+| `POST` | `/sessions/:name/memories/search` | Search memories. Body: `{ query, limit? }` |
+
+### Worker Endpoints (agent code auth via `?code=<uuid>`)
+
+| Method | Path | Description |
+|---|---|---|
+| `GET` | `/worker/clock-in` | Clock in and receive welcome briefing |
+| `GET` | `/worker/list-coworkers` | List all other agents and the human manager |
+| `POST` | `/worker/set-status` | Set or clear status. Body: `{ status }` |
+| `POST` | `/worker/send-message` | Send a message. Body: `{ to: string[], body }` |
+| `GET` | `/worker/crons` | List own cron jobs |
+| `POST` | `/worker/crons` | Create a cron job |
+| `DELETE` | `/worker/crons/:id` | Delete own cron job |
+| `POST` | `/worker/crons/:id/enable` | Enable own cron job |
+| `POST` | `/worker/crons/:id/disable` | Disable own cron job |
+| `GET` | `/worker/crons/:id/history` | View own cron job history |
+| `POST` | `/worker/memory/add` | Add a memory |
+| `POST` | `/worker/memory/search` | Search memories |
+| `GET` | `/worker/memory/list` | List memories |
+| `DELETE` | `/worker/memory/:memoryId` | Delete a memory |
+
+## Architecture
+
+### Database Schema
+
+The server uses PostgreSQL with automatic migrations. Tables:
+
+- **`sessions`** -- Maps coworker names to OpenCode session IDs with agent codes, agent modes, and status
+- **`config`** -- Key-value store for application settings (`human_name`, `human_description`)
+- **`messages`** -- Inter-agent and human-agent mail with read/injected tracking
+- **`cron_jobs`** -- Scheduled tasks tied to sessions with cron expressions and timezone support
+- **`cron_history`** -- Execution log for cron jobs with success/failure tracking
+
+### Memory System
+
+Each agent gets a private SQLite database (via [fastmemory](https://github.com/nichochar/fastmemory)) stored in the `--memory-path` directory. Memories support:
+
+- **Hybrid search** -- BM25 full-text search combined with vector semantic search using Reciprocal Rank Fusion
+- **Persistence across resets** -- Memories are stored outside the OpenCode session, so they survive session reverts
+- **Quantized embeddings** -- Uses `q4` dtype for efficient storage
+
+### Agentic Coding Server Abstraction
+
+The application does not depend on the OpenCode SDK directly. Instead, all OpenCode interactions go through an `AgenticCodingServer` interface (`src/lib/agentic-coding-server.ts`) with six methods:
+
+```typescript
+interface AgenticCodingServer {
+  createSession(): Promise<string>
+  deleteSession(sessionID: string): Promise<void>
+  sendMessage(sessionID: string, text: string, agent?: string): Promise<void>
+  getMessages(sessionID: string, limit?: number): Promise<SessionMessage[]>
+  revertSession(sessionID: string, messageID: string): Promise<void>
+  getAgentModes(): Promise<AgentMode[]>
+}
+```
+
+The concrete `OpenCodeCodingServer` implementation (`src/lib/opencode-coding-server.ts`) encapsulates all SDK interactions. Only the server entrypoint (`src/commands/serve.ts`) knows the concrete class -- everything else depends on the interface.
 
 ## Development
 
@@ -151,15 +320,17 @@ All endpoints except `/worker/clock-in` require `Authorization: Bearer <password
 # Install dependencies
 npm install
 
-# Copy env
+# Copy and edit environment
 cp .env.example .env
-# Edit .env with your values
 
-# Run server
+# Run server with hot reload
 npm run dev:serve -- --password secret
 
-# Run manager (in another terminal)
-npm run dev:manage -- http://localhost:7654 --password secret
+# Run TUI (in another terminal)
+npm run dev:manage -- --password secret
+
+# Run communicator (in another terminal)
+npm run dev:communicator -- "Alice" --secret secret
 
 # Build
 npm run build
@@ -167,4 +338,4 @@ npm run build
 
 ## License
 
-MIT © Richard Anaya
+MIT

package/dist/commands/communicator.js

@@ -59,11 +59,12 @@ function renderMessage(msg, humanName, spacingClass) {
     const isMine = msg.from_name === humanName;
     const bubbleClass = isMine ? "bubble bubble-mine" : "bubble bubble-theirs";
     const wrapClass = `msg-wrap ${isMine ? "msg-wrap-mine" : "msg-wrap-theirs"} ${spacingClass}`;
-    const bodyHtml = escapeHtml(msg.body).replace(/\n/g, "<br>");
+    // Base64 encode to preserve newlines and special chars reliably
+    const bodyEncoded = Buffer.from(msg.body).toString('base64');
     const unreadDot = !isMine && !msg.read ? `<span class="unread-dot"></span>` : "";
     return `<div class="${wrapClass}" data-id="${msg.id}">
   <div class="${bubbleClass}">
-    <div class="bubble-body">${bodyHtml}</div>
+    <div class="bubble-body markdown-body" data-markdown-b64="${bodyEncoded}"></div>
     <div class="bubble-time">${unreadDot}${formatTime(msg.created_at)}</div>
   </div>
 </div>`;
@@ -91,6 +92,9 @@ function renderPage(coworker, msgs, humanName) {
   <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
   <title>${escapeHtml(coworker)} — agent-office</title>
   <script src="https://unpkg.com/htmx.org@2.0.4/dist/htmx.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/marked@11.1.1/marked.min.js"></script>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5.5.1/github-markdown-light.min.css" media="(prefers-color-scheme: light)">
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5.5.1/github-markdown-dark.min.css" media="(prefers-color-scheme: dark)">
   <style>
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
 
@@ -264,6 +268,66 @@ function renderPage(coworker, msgs, humanName) {
     }
 
     .bubble-body { font-size: 14.5px; }
+    .bubble-body.markdown-body {
+      background: transparent;
+      color: inherit;
+      font-size: 14px;
+      line-height: 1.5;
+    }
+    .bubble-body.markdown-body p { margin: 0 0 8px 0; }
+    .bubble-body.markdown-body p:last-child { margin-bottom: 0; }
+    .bubble-body.markdown-body pre {
+      background: rgba(0,0,0,0.3);
+      border-radius: 6px;
+      padding: 8px 12px;
+      overflow-x: auto;
+      margin: 8px 0;
+    }
+    .bubble-body.markdown-body code {
+      background: rgba(0,0,0,0.2);
+      padding: 2px 5px;
+      border-radius: 3px;
+      font-size: 13px;
+      font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+    }
+    .bubble-body.markdown-body pre code {
+      background: transparent;
+      padding: 0;
+    }
+    .bubble-body.markdown-body ul, .bubble-body.markdown-body ol {
+      margin: 8px 0;
+      padding-left: 20px;
+    }
+    .bubble-body.markdown-body li { margin: 4px 0; }
+    .bubble-body.markdown-body blockquote {
+      border-left: 3px solid var(--accent);
+      margin: 8px 0;
+      padding-left: 12px;
+      color: var(--text-dim);
+    }
+    .bubble-body.markdown-body h1, .bubble-body.markdown-body h2,
+    .bubble-body.markdown-body h3, .bubble-body.markdown-body h4 {
+      margin: 12px 0 8px 0;
+      font-size: 15px;
+      font-weight: 600;
+    }
+    .bubble-body.markdown-body table {
+      border-collapse: collapse;
+      margin: 8px 0;
+      font-size: 13px;
+    }
+    .bubble-body.markdown-body th, .bubble-body.markdown-body td {
+      border: 1px solid var(--border);
+      padding: 6px 10px;
+    }
+    .bubble-body.markdown-body th {
+      background: var(--surface2);
+    }
+    .bubble-body.markdown-body strong,
+    .bubble-body.markdown-body b {
+      color: #ffffff;
+      font-weight: 600;
+    }
     .bubble-time {
       font-size: 10px;
       color: var(--text-dim);
@@ -498,6 +562,28 @@ function renderPage(coworker, msgs, humanName) {
     clearTimeout(el._hideTimer)
     el._hideTimer = setTimeout(() => el.classList.remove('visible'), 3000)
   }
+
+  // Render markdown in chat bubbles
+  function renderMarkdown() {
+    if (typeof marked === 'undefined') return
+    document.querySelectorAll('.markdown-body[data-markdown-b64]').forEach(el => {
+      const b64 = el.getAttribute('data-markdown-b64')
+      if (b64 && !el.hasAttribute('data-rendered')) {
+        // Decode base64 to get original text with preserved newlines
+        const text = atob(b64)
+        el.innerHTML = marked.parse(text)
+        el.setAttribute('data-rendered', 'true')
+      }
+    })
+  }
+
+  // Initial render
+  renderMarkdown()
+
+  // Re-render after HTMX swaps new content
+  document.addEventListener('htmx:afterSwap', () => {
+    renderMarkdown()
+  })
 </script>
 </body>
 </html>`;
@@ -609,10 +695,19 @@ export async function communicatorWeb(coworker, options) {
     app.get("/ping", (_req, res) => {
         res.status(204).end();
     });
-    app.listen(port, host, () => {
+    const server = app.listen(port, host, () => {
         console.log(`Communicator running at http://${host}:${port}`);
         console.log(`Press Ctrl+C to stop.`);
     });
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`Error: Port ${port} is already in use. Is another instance running?`);
+        }
+        else {
+            console.error(`Error: ${err.message}`);
+        }
+        process.exit(1);
+    });
     // Keep process alive
     await new Promise(() => { });
 }

package/dist/commands/serve.js

@@ -1,6 +1,6 @@
 import { createDb } from "../db/index.js";
 import { runMigrations } from "../db/migrate.js";
-import { createOpencodeClient } from "../lib/opencode.js";
+import { OpenCodeCodingServer } from "../lib/opencode-coding-server.js";
 import { createApp } from "../server/index.js";
 import { CronScheduler } from "../server/cron.js";
 import { MemoryManager } from "../server/memory.js";
@@ -34,8 +34,8 @@ export async function serve(options) {
         await sql.end();
         process.exit(1);
     }
-    // Init OpenCode client
-    const opencode = createOpencodeClient(options.opencodeUrl);
+    // Init agentic coding server (OpenCode implementation)
+    const agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
     const serverUrl = `http://${options.host}:${port}`;
     // Create memory manager and verify embedding model
     const memoryManager = new MemoryManager(options.memoryPath);
@@ -55,9 +55,9 @@ export async function serve(options) {
     // Create cron scheduler
     const cronScheduler = new CronScheduler();
     // Create Express app
-    const app = createApp(sql, opencode, password, serverUrl, cronScheduler, memoryManager);
+    const app = createApp(sql, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager);
     // Start cron scheduler
-    await cronScheduler.start(sql, opencode);
+    await cronScheduler.start(sql, agenticCodingServer);
     // Start server
     const server = app.listen(port, options.host, () => {
         console.log(`agent-office server listening on ${serverUrl}`);

package/dist/lib/agentic-coding-server.d.ts

@@ -0,0 +1,58 @@
+/**
+ * AgenticCodingServer — abstract interface for interacting with an agentic
+ * coding backend. The application code depends only on this interface;
+ * concrete implementations (e.g. OpenCodeCodingServer) supply the wiring
+ * to a specific server.
+ */
+/** Minimal representation of a message part. */
+export interface MessagePart {
+    type: string;
+    [key: string]: unknown;
+}
+/** A single message inside a session. */
+export interface SessionMessage {
+    id: string;
+    role: string;
+    parts: MessagePart[];
+}
+/** An agent mode advertised by the server. */
+export interface AgentMode {
+    name: string;
+    description: string;
+    model: string;
+}
+export interface AgenticCodingServer {
+    /**
+     * Create a new session.
+     * @returns the server-assigned session ID.
+     */
+    createSession(): Promise<string>;
+    /**
+     * Permanently delete a session.
+     */
+    deleteSession(sessionID: string): Promise<void>;
+    /**
+     * Inject a text message into a session (fire-and-forget).
+     * The server processes the message asynchronously.
+     *
+     * @param agent  optional agent-mode identifier to route the prompt.
+     */
+    sendMessage(sessionID: string, text: string, agent?: string): Promise<void>;
+    /**
+     * Retrieve the message history for a session.
+     *
+     * @param limit  maximum number of messages to return (server may cap this).
+     */
+    getMessages(sessionID: string, limit?: number): Promise<SessionMessage[]>;
+    /**
+     * Reset a session to a specific message.
+     *
+     * Implementations should abort any in-progress generation before reverting
+     * so callers don't need to worry about "session is busy" errors.
+     */
+    revertSession(sessionID: string, messageID: string): Promise<void>;
+    /**
+     * Return the list of agent modes the server knows about.
+     */
+    getAgentModes(): Promise<AgentMode[]>;
+}

package/dist/lib/agentic-coding-server.js

@@ -0,0 +1,7 @@
+/**
+ * AgenticCodingServer — abstract interface for interacting with an agentic
+ * coding backend. The application code depends only on this interface;
+ * concrete implementations (e.g. OpenCodeCodingServer) supply the wiring
+ * to a specific server.
+ */
+export {};

package/dist/lib/opencode-coding-server.d.ts

@@ -0,0 +1,11 @@
+import type { AgenticCodingServer, SessionMessage, AgentMode } from "./agentic-coding-server.js";
+export declare class OpenCodeCodingServer implements AgenticCodingServer {
+    private client;
+    constructor(baseURL: string);
+    createSession(): Promise<string>;
+    deleteSession(sessionID: string): Promise<void>;
+    sendMessage(sessionID: string, text: string, agent?: string): Promise<void>;
+    getMessages(sessionID: string, limit?: number): Promise<SessionMessage[]>;
+    revertSession(sessionID: string, messageID: string): Promise<void>;
+    getAgentModes(): Promise<AgentMode[]>;
+}

package/dist/lib/opencode-coding-server.js

@@ -0,0 +1,56 @@
+/**
+ * Concrete AgenticCodingServer backed by an OpenCode server
+ * via the @opencode-ai/sdk.
+ */
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
+import { cwd } from "process";
+export class OpenCodeCodingServer {
+    client;
+    constructor(baseURL) {
+        this.client = createOpencodeClient({ baseUrl: baseURL, directory: cwd() });
+    }
+    async createSession() {
+        const { data: session } = await this.client.session.create();
+        if (!session)
+            throw new Error("OpenCode returned no session");
+        return session.id;
+    }
+    async deleteSession(sessionID) {
+        await this.client.session.delete({ sessionID });
+    }
+    async sendMessage(sessionID, text, agent) {
+        await this.client.session.promptAsync({
+            sessionID,
+            parts: [{ type: "text", text }],
+            ...(agent ? { agent } : {}),
+        });
+    }
+    async getMessages(sessionID, limit) {
+        const { data: messages } = await this.client.session.messages({
+            sessionID,
+            ...(limit != null ? { limit } : {}),
+        });
+        return (messages ?? []).map((m) => ({
+            id: m.info.id,
+            role: m.info.role,
+            parts: m.parts,
+        }));
+    }
+    async revertSession(sessionID, messageID) {
+        // Abort any in-progress generation first — swallow errors because the
+        // session may not be busy.
+        await this.client.session.abort({ sessionID }).catch(() => { });
+        await this.client.session.revert({ sessionID, messageID });
+    }
+    async getAgentModes() {
+        const { data: config } = await this.client.config.get();
+        const agent = config?.agent ?? {};
+        return Object.entries(agent)
+            .filter(([, val]) => val != null)
+            .map(([name, val]) => ({
+            name,
+            description: val.description ?? "",
+            model: val.model ?? "",
+        }));
+    }
+}

package/dist/server/cron.d.ts

@@ -1,5 +1,5 @@
 import type { Sql } from "../db/index.js";
-import type { OpencodeClient } from "../lib/opencode.js";
+import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import type { CronJobRow } from "../db/index.js";
 interface CronSchedulerOptions {
     onJobExecuted?: (jobId: number, success: boolean, error?: string) => void;
@@ -8,10 +8,10 @@ export declare class CronScheduler {
     private options;
     private activeJobs;
     private sql;
-    private opencode;
+    private agenticCodingServer;
     private started;
     constructor(options?: CronSchedulerOptions);
-    start(sql: Sql, opencode: OpencodeClient): Promise<void>;
+    start(sql: Sql, agenticCodingServer: AgenticCodingServer): Promise<void>;
     stop(): void;
     private addJob;
     private executeJob;

package/dist/server/cron.js

@@ -9,16 +9,16 @@ export class CronScheduler {
     options;
     activeJobs = new Map();
     sql = null;
-    opencode = null;
+    agenticCodingServer = null;
     started = false;
     constructor(options = {}) {
         this.options = options;
     }
-    async start(sql, opencode) {
+    async start(sql, agenticCodingServer) {
         if (this.started)
             return;
         this.sql = sql;
-        this.opencode = opencode;
+        this.agenticCodingServer = agenticCodingServer;
         const rows = await sql `
       SELECT id, name, schedule, timezone, message, session_name
       FROM cron_jobs
@@ -39,7 +39,7 @@ export class CronScheduler {
         console.log("Cron scheduler stopped");
     }
     addJob(job) {
-        if (!this.opencode || !this.sql)
+        if (!this.agenticCodingServer || !this.sql)
             return;
         const options = {
             protect: true,
@@ -54,7 +54,7 @@ export class CronScheduler {
         this.activeJobs.set(job.id, { cron, job });
     }
     async executeJob(job) {
-        if (!this.sql || !this.opencode)
+        if (!this.sql || !this.agenticCodingServer)
             return;
         const executedAt = new Date();
         try {
@@ -65,11 +65,7 @@ export class CronScheduler {
                 throw new Error(`Session "${job.session_name}" not found`);
             }
             const injectText = `[Cron Job "${job.name}" — ${executedAt.toISOString()}]\n${job.message}${CRON_INJECTION_BLURB}`;
-            await this.opencode.session.promptAsync({
-                sessionID: session.session_id,
-                parts: [{ type: "text", text: injectText }],
-                ...(session.agent ? { agent: session.agent } : {}),
-            });
+            await this.agenticCodingServer.sendMessage(session.session_id, injectText, session.agent ?? undefined);
             await this.sql `
         UPDATE cron_jobs SET last_run = ${executedAt} WHERE id = ${job.id}
       `;

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import type { Sql } from "../db/index.js";
-import type { OpencodeClient } from "../lib/opencode.js";
+import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import { CronScheduler } from "./cron.js";
 import type { MemoryManager } from "./memory.js";
-export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: MemoryManager): import("express-serve-static-core").Express;
+export declare function createApp(sql: Sql, agenticCodingServer: AgenticCodingServer, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: MemoryManager): import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -10,13 +10,13 @@ function authMiddleware(password) {
         next();
     };
 }
-export function createApp(sql, opencode, password, serverUrl, cronScheduler, memoryManager) {
+export function createApp(sql, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager) {
     const app = express();
     app.use(express.json());
     // Worker routes are unauthenticated — mounted before auth middleware
-    app.use("/", createWorkerRouter(sql, opencode, serverUrl, memoryManager));
+    app.use("/", createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryManager));
     // Everything else requires Bearer auth
     app.use(authMiddleware(password));
-    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler, memoryManager));
+    app.use("/", createRouter(sql, agenticCodingServer, serverUrl, cronScheduler, memoryManager));
     return app;
 }

package/dist/server/routes.d.ts

@@ -1,7 +1,7 @@
 import { Router } from "express";
 import type { Sql } from "../db/index.js";
-import type { OpencodeClient } from "../lib/opencode.js";
+import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import { CronScheduler } from "./cron.js";
 import type { MemoryManager } from "./memory.js";
-export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
-export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, memoryManager: MemoryManager): Router;
+export declare function createRouter(sql: Sql, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
+export declare function createWorkerRouter(sql: Sql, agenticCodingServer: AgenticCodingServer, serverUrl: string, memoryManager: MemoryManager): Router;

package/dist/server/routes.js

@@ -129,22 +129,14 @@ function generateWelcomeMessage(name, agent, status, humanName, humanDescription
         ``,
     ].join("\n");
 }
-export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager) {
+export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, memoryManager) {
     const router = Router();
     router.get("/health", (_req, res) => {
         res.json({ ok: true });
     });
     router.get("/modes", async (_req, res) => {
         try {
-            const { data: config } = await opencode.config.get();
-            const agent = config?.agent ?? {};
-            const modes = Object.entries(agent)
-                .filter(([, val]) => val != null)
-                .map(([name, val]) => ({
-                name,
-                description: val.description ?? "",
-                model: val.model ?? "",
-            }));
+            const modes = await agenticCodingServer.getAgentModes();
             res.json(modes);
         }
         catch (err) {
@@ -183,10 +175,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         }
         let opencodeSessionId;
         try {
-            const { data: session } = await opencode.session.create();
-            if (!session)
-                throw new Error("No session returned");
-            opencodeSessionId = session.id;
+            opencodeSessionId = await agenticCodingServer.createSession();
         }
         catch (err) {
             console.error("OpenCode session.create error:", err);
@@ -205,7 +194,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         catch (err) {
             console.error("DB insert error:", err);
             try {
-                await opencode.session.delete({ sessionID: opencodeSessionId });
+                await agenticCodingServer.deleteSession(opencodeSessionId);
             }
             catch { }
             res.status(500).json({ error: "Internal server error" });
@@ -214,11 +203,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         try {
             const clockInToken = `${row.agent_code}@${serverUrl}`;
             const enrollmentMessage = generateEnrollmentMessage(clockInToken);
-            await opencode.session.promptAsync({
-                sessionID: opencodeSessionId,
-                parts: [{ type: "text", text: enrollmentMessage }],
-                ...(trimmedAgent ? { agent: trimmedAgent } : {}),
-            });
+            await agenticCodingServer.sendMessage(opencodeSessionId, enrollmentMessage, trimmedAgent ?? undefined);
         }
         catch (err) {
             console.warn("Warning: could not send first message to session:", err);
@@ -260,29 +245,28 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         }
         const row = rows[0];
         try {
-            const { data: messages } = await opencode.session.messages({ sessionID: row.session_id, limit });
-            const result = (messages ?? [])
+            const messages = await agenticCodingServer.getMessages(row.session_id, limit);
+            const result = messages
                 .slice(-limit)
                 .map((m) => ({
-                role: m.info.role,
+                role: m.role,
                 parts: m.parts.map((p) => {
-                    const part = p;
-                    if (part.type === "text") {
-                        return { type: "text", text: part.text ?? "" };
+                    if (p.type === "text") {
+                        return { type: "text", text: p.text ?? "" };
                     }
-                    else if (part.type === "tool") {
+                    else if (p.type === "tool") {
                         // Extract tool name, input, and output from the tool state
-                        const state = part.state;
+                        const state = p.state;
                         return {
                             type: "tool",
-                            tool: part.tool,
+                            tool: p.tool,
                             input: state?.input,
                             output: state?.output,
-                            data: part,
+                            data: p,
                         };
                     }
                     else {
-                        return { type: part.type, data: part };
+                        return { type: p.type, data: p };
                     }
                 }),
             }))
@@ -310,10 +294,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         }
         const row = rows[0];
         try {
-            await opencode.session.promptAsync({
-                sessionID: row.session_id,
-                parts: [{ type: "text", text: text.trim() }],
-            });
+            await agenticCodingServer.sendMessage(row.session_id, text.trim());
             res.json({ ok: true });
         }
         catch (err) {
@@ -332,28 +313,21 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         }
         const session = rows[0];
         try {
-            const { data: messages } = await opencode.session.messages({ sessionID: session.session_id });
-            if (!messages || messages.length === 0) {
+            const messages = await agenticCodingServer.getMessages(session.session_id);
+            if (messages.length === 0) {
                 res.status(400).json({ error: "Session has no messages to revert to" });
                 return;
             }
             const firstMessage = messages[0];
-            if (!firstMessage || !firstMessage.info || !firstMessage.info.id) {
+            if (!firstMessage.id) {
                 res.status(500).json({ error: "Failed to get first message ID" });
                 return;
             }
-            // Abort any in-progress generation before reverting, to avoid "session is busy" errors.
-            // Swallow errors — the session may not be busy, in which case abort is a no-op.
-            await opencode.session.abort({ sessionID: session.session_id }).catch(() => { });
-            await opencode.session.revert({ sessionID: session.session_id, messageID: firstMessage.info.id });
+            await agenticCodingServer.revertSession(session.session_id, firstMessage.id);
             const clockInToken = `${session.agent_code}@${serverUrl}`;
             const enrollmentMessage = generateEnrollmentMessage(clockInToken);
-            await opencode.session.promptAsync({
-                sessionID: session.session_id,
-                parts: [{ type: "text", text: enrollmentMessage }],
-                ...(session.agent ? { agent: session.agent } : {}),
-            });
-            res.json({ ok: true, messageID: firstMessage.info.id });
+            await agenticCodingServer.sendMessage(session.session_id, enrollmentMessage, session.agent ?? undefined);
+            res.json({ ok: true, messageID: firstMessage.id });
         }
         catch (err) {
             console.error("POST /sessions/:name/revert-to-start error:", err);
@@ -367,26 +341,20 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         const results = [];
         for (const session of allSessions) {
             try {
-                const { data: messages } = await opencode.session.messages({ sessionID: session.session_id });
-                if (!messages || messages.length === 0) {
+                const messages = await agenticCodingServer.getMessages(session.session_id);
+                if (messages.length === 0) {
                     results.push({ name: session.name, ok: false, error: "No messages" });
                     continue;
                 }
                 const firstMessage = messages[0];
-                if (!firstMessage?.info?.id) {
+                if (!firstMessage.id) {
                     results.push({ name: session.name, ok: false, error: "Failed to get first message ID" });
                     continue;
                 }
-                // Abort any in-progress generation before reverting
-                await opencode.session.abort({ sessionID: session.session_id }).catch(() => { });
-                await opencode.session.revert({ sessionID: session.session_id, messageID: firstMessage.info.id });
+                await agenticCodingServer.revertSession(session.session_id, firstMessage.id);
                 const clockInToken = `${session.agent_code}@${serverUrl}`;
                 const enrollmentMessage = generateEnrollmentMessage(clockInToken);
-                await opencode.session.promptAsync({
-                    sessionID: session.session_id,
-                    parts: [{ type: "text", text: enrollmentMessage }],
-                    ...(session.agent ? { agent: session.agent } : {}),
-                });
+                await agenticCodingServer.sendMessage(session.session_id, enrollmentMessage, session.agent ?? undefined);
                 results.push({ name: session.name, ok: true });
             }
             catch (err) {
@@ -408,7 +376,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
         }
         const row = rows[0];
         try {
-            await opencode.session.delete({ sessionID: row.session_id });
+            await agenticCodingServer.deleteSession(row.session_id);
         }
         catch (err) {
             console.error("OpenCode session.delete error:", err);
@@ -544,10 +512,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
                 const sessionId = sessionMap.get(recipient);
                 const injectText = `[Message from "${trimmedFrom}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
                 try {
-                    await opencode.session.promptAsync({
-                        sessionID: sessionId,
-                        parts: [{ type: "text", text: injectText }],
-                    });
+                    await agenticCodingServer.sendMessage(sessionId, injectText);
                     await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
                     injected = true;
                 }
@@ -956,7 +921,7 @@ export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager)
     });
     return router;
 }
-export function createWorkerRouter(sql, opencode, serverUrl, memoryManager) {
+export function createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryManager) {
     const router = Router();
     router.get("/worker/clock-in", async (req, res) => {
         const { code } = req.query;
@@ -1108,10 +1073,7 @@ export function createWorkerRouter(sql, opencode, serverUrl, memoryManager) {
                 const recipientSessionId = sessionMap.get(recipient);
                 const injectText = `[Message from "${session.name}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
                 try {
-                    await opencode.session.promptAsync({
-                        sessionID: recipientSessionId,
-                        parts: [{ type: "text", text: injectText }],
-                    });
+                    await agenticCodingServer.sendMessage(recipientSessionId, injectText);
                     await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
                     injected = true;
                 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-office",
-  "version": "0.0.12",
-  "description": "Manage OpenCode sessions with named aliases",
+  "version": "0.0.14",
+  "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",
   "author": "Richard Anaya",
@@ -34,6 +34,7 @@
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
     "@opencode-ai/sdk": "^1.2.10",
+    "agent-office": "^0.0.12",
     "commander": "^14.0.0",
     "croner": "^10.0.1",
     "dotenv": "^17.0.0",

package/dist/lib/opencode.d.ts

@@ -1,7 +0,0 @@
-import { createOpencodeClient as _createOpencodeClient } from "@opencode-ai/sdk/v2/client";
-export type OpencodeClient = ReturnType<typeof _createOpencodeClient>;
-export declare function createOpencodeClient(baseURL: string): OpencodeClient;
-export interface OpencodeSession {
-    id: string;
-    title?: string;
-}

package/dist/lib/opencode.js

@@ -1,5 +0,0 @@
-import { createOpencodeClient as _createOpencodeClient } from "@opencode-ai/sdk/v2/client";
-import { cwd } from "process";
-export function createOpencodeClient(baseURL) {
-    return _createOpencodeClient({ baseUrl: baseURL, directory: cwd() });
-}