agent-office 0.3.0 → 0.3.2

package/README.md

@@ -84,7 +84,7 @@ From the TUI you can create coworkers, send them messages, browse mail, manage c
 ### 3. Chat with a coworker in the browser
 
 ```bash
-agent-office communicator web "Alice" --secret mysecret
+agent-office communicator web "Alice" --password mysecret
 ```
 
 Opens a web-based chat interface at `http://127.0.0.1:7655` for real-time conversation with the named coworker.
@@ -183,7 +183,7 @@ Arguments:
 
 Options:
   --url <url>              Server URL (default: http://127.0.0.1:7654)
-  --secret <secret>        API password (env: AGENT_OFFICE_PASSWORD)
+  --password <password>    API password (env: AGENT_OFFICE_PASSWORD)
   --host <host>            Communicator bind host (default: 127.0.0.1)
   --port <port>            Communicator bind port (default: 7655)
 ```
@@ -330,7 +330,7 @@ npm run dev:serve -- --password secret
 npm run dev:manage -- --password secret
 
 # Run communicator (in another terminal)
-npm run dev:communicator -- "Alice" --secret secret
+npm run dev:communicator -- "Alice" --password secret
 
 # Build
 npm run build

package/dist/cli.js

@@ -16,6 +16,7 @@ program
     .option("--memory-path <path>", "Directory for memory storage (default: ./.memory)", "./.memory")
     .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
     .option("--opencode-url <url>", "URL of the OpenCode server (default: http://127.0.0.1:4096)", process.env.OPENCODE_URL ?? "http://127.0.0.1:4096")
+    .option("--simple-memory", "Use lightweight SQLite+BM25 memory instead of the default fastmemory (no embeddings, no model download)")
     .action(async (options) => {
     const { serve } = await import("./commands/serve.js");
     await serve(options);
@@ -34,32 +35,23 @@ const appCmd = program
     .description("[HUMAN ONLY] Interactive visual applications");
 appCmd
     .command("coworker-chat-web")
-    .description("[HUMAN ONLY] Launch a web chat interface for a single coworker")
-    .argument("<coworker>", "Name of the coworker to chat with (e.g. 'Howard Roark')")
+    .description("[HUMAN ONLY] Launch a web chat interface for coworkers")
     .option("--url <url>", "URL of the agent-office serve endpoint (e.g. http://127.0.0.1:7654)", process.env.AGENT_OFFICE_URL ?? "http://127.0.0.1:7654")
-    .option("--secret <secret>", "API password for the agent-office server", process.env.AGENT_OFFICE_PASSWORD)
+    .option("--password <password>", "API password for the agent-office server", process.env.AGENT_OFFICE_PASSWORD ?? "secret")
     .option("--host <host>", "Host to bind the web server to", "127.0.0.1")
     .option("--port <port>", "Port to run the web server on", "7655")
-    .action(async (coworker, options) => {
-    if (!options.secret) {
-        console.error("Error: --secret is required (or set AGENT_OFFICE_PASSWORD)");
-        process.exit(1);
-    }
+    .action(async (options) => {
     const { appCoworkerChatWeb } = await import("./commands/communicator.js");
-    await appCoworkerChatWeb(coworker, options);
+    await appCoworkerChatWeb(options);
 });
 appCmd
     .command("screensaver")
     .description("[HUMAN ONLY] Launch a visualization of recent mail activity (live screensaver)")
     .option("--url <url>", "URL of the agent-office serve endpoint (e.g. http://127.0.0.1:7654)", process.env.AGENT_OFFICE_URL ?? "http://127.0.0.1:7654")
-    .option("--secret <secret>", "API password for the agent-office server", process.env.AGENT_OFFICE_PASSWORD)
+    .option("--password <password>", "API password for the agent-office server", process.env.AGENT_OFFICE_PASSWORD ?? "secret")
     .option("--host <host>", "Host to bind the screensaver web server to", "127.0.0.1")
     .option("--port <port>", "Port to run the screensaver web server on", "7656")
     .action(async (options) => {
-    if (!options.secret) {
-        console.error("Error: --secret is required (or set AGENT_OFFICE_PASSWORD)");
-        process.exit(1);
-    }
     const { appScreensaver } = await import("./commands/screensaver.js");
     await appScreensaver(options);
 });
@@ -122,7 +114,8 @@ cronCmd
     .description("Create a new cron job")
     .requiredOption("--name <name>", "Cron job name")
     .requiredOption("--schedule <schedule>", "Cron expression (e.g., '0 9 * * *' for daily at 9am)")
-    .requiredOption("--message <message>", "Message to inject when job fires")
+    .requiredOption("--message <message>", "Action to perform when job fires")
+    .requiredOption("--respond-to <respondTo>", "Who to respond to when done")
     .option("--timezone <timezone>", "IANA timezone (e.g., 'America/New_York')")
     .action(async (token, options) => {
     const { createCron } = await import("./commands/worker.js");

package/dist/commands/communicator.d.ts

@@ -1,8 +1,8 @@
 interface CommunicatorOptions {
     url: string;
-    secret: string;
+    password: string;
     host: string;
     port: string;
 }
-export declare function appCoworkerChatWeb(coworker: string, options: CommunicatorOptions): Promise<void>;
+export declare function appCoworkerChatWeb(options: CommunicatorOptions): Promise<void>;
 export {};

package/dist/commands/communicator.js

@@ -1,11 +1,11 @@
 import express from "express";
 // ── API helpers ───────────────────────────────────────────────────────────────
-async function apiFetch(agentUrl, secret, path, init = {}) {
+async function apiFetch(agentUrl, password, path, init = {}) {
     const res = await fetch(`${agentUrl}${path}`, {
         ...init,
         headers: {
             "Content-Type": "application/json",
-            "Authorization": `Bearer ${secret}`,
+            "Authorization": `Bearer ${password}`,
             ...(init.headers ?? {}),
         },
     });
@@ -15,19 +15,22 @@ async function apiFetch(agentUrl, secret, path, init = {}) {
     }
     return res.json();
 }
-async function getHumanName(agentUrl, secret) {
-    const cfg = await apiFetch(agentUrl, secret, "/config");
+async function getHumanName(agentUrl, password) {
+    const cfg = await apiFetch(agentUrl, password, "/config");
     return cfg.human_name ?? "Human";
 }
-async function fetchCoworkerStatus(agentUrl, secret, coworker) {
-    const sessions = await apiFetch(agentUrl, secret, "/sessions");
+async function fetchSessions(agentUrl, password) {
+    return apiFetch(agentUrl, password, "/sessions");
+}
+async function fetchCoworkerStatus(agentUrl, password, coworker) {
+    const sessions = await fetchSessions(agentUrl, password);
     const session = sessions.find((s) => s.name === coworker);
     return session?.status ?? null;
 }
-async function fetchMessages(agentUrl, secret, humanName, coworker) {
+async function fetchMessages(agentUrl, password, humanName, coworker) {
     const [sent, received] = await Promise.all([
-        apiFetch(agentUrl, secret, `/messages/${encodeURIComponent(humanName)}?sent=true`),
-        apiFetch(agentUrl, secret, `/messages/${encodeURIComponent(humanName)}`),
+        apiFetch(agentUrl, password, `/messages/${encodeURIComponent(humanName)}?sent=true`),
+        apiFetch(agentUrl, password, `/messages/${encodeURIComponent(humanName)}`),
     ]);
     // sent: from humanName → coworker
     const sentToCoworker = sent.filter((m) => m.to_name === coworker);
@@ -37,8 +40,8 @@ async function fetchMessages(agentUrl, secret, humanName, coworker) {
     all.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
     return all;
 }
-async function markRead(agentUrl, secret, id) {
-    await apiFetch(agentUrl, secret, `/messages/${id}/read`, { method: "POST" });
+async function markRead(agentUrl, password, id) {
+    await apiFetch(agentUrl, password, `/messages/${id}/read`, { method: "POST" });
 }
 // ── HTML helpers ──────────────────────────────────────────────────────────────
 function escapeHtml(str) {
@@ -83,14 +86,31 @@ function renderMessages(msgs, humanName) {
     return `<div id="messages-inner" data-last-id="${lastId}">${inner}</div>`;
 }
 // ── Full page ─────────────────────────────────────────────────────────────────
-function renderPage(coworker, msgs, humanName) {
+function renderDropdown(coworker, coworkers) {
+    const selected = coworker ?? "";
+    const dropdownOptions = coworkers.filter(c => !c.isHuman);
+    const totalUnread = dropdownOptions.reduce((sum, c) => sum + (c.unreadMessages ?? 0), 0);
+    const unreadDot = totalUnread > 0 ? '<span class="unread-badge"></span>' : '';
+    const coworkerOptions = dropdownOptions.map(c => {
+        const unreadBadge = c.unreadMessages && c.unreadMessages > 0 ? ` (${c.unreadMessages})` : '';
+        return `<option value="${escapeHtml(c.name)}" ${c.name === selected ? 'selected' : ''}>${escapeHtml(c.name)}${unreadBadge}</option>`;
+    }).join('');
+    return `<select id="coworker-select" class="coworker-select" onchange="switchCoworker(this.value)">
+        <option value="">Select coworker…</option>
+        ${coworkerOptions}
+      </select>
+      ${unreadDot}`;
+}
+function renderPage(coworker, coworkers, msgs, humanName) {
     const msgsHtml = renderMessages(msgs, humanName);
+    const selected = coworker ?? "";
+    const dropdownHtml = renderDropdown(coworker, coworkers);
     return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-  <title>${escapeHtml(coworker)} — agent-office</title>
+  <title>${selected ? escapeHtml(selected) + ' — ' : ''}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)">
@@ -162,6 +182,29 @@ function renderPage(coworker, msgs, humanName) {
     }
 
     .header-info { flex: 1; min-width: 0; }
+    .select-wrapper { display: inline-flex; align-items: center; position: relative; }
+    .coworker-select {
+      font-weight: 600;
+      font-size: 15px;
+      background: transparent;
+      border: none;
+      color: var(--text);
+      cursor: pointer;
+      padding: 0;
+      margin: 0;
+      outline: none;
+      max-width: 180px;
+    }
+    .coworker-select:focus { color: var(--accent); }
+    .coworker-select option { background: var(--surface); color: var(--text); }
+    .unread-badge {
+      width: 8px;
+      height: 8px;
+      background: #ff4444;
+      border-radius: 50%;
+      margin-left: 6px;
+      flex-shrink: 0;
+    }
     .header-name {
       font-weight: 600;
       font-size: 15px;
@@ -418,22 +461,28 @@ function renderPage(coworker, msgs, humanName) {
 
   <!-- Header -->
   <div class="header">
-    <div class="avatar">${escapeHtml(coworker.charAt(0).toUpperCase())}</div>
+    <div class="avatar">${selected ? escapeHtml(selected.charAt(0).toUpperCase()) : '?'}</div>
     <div class="header-info">
-      <div class="header-name">${escapeHtml(coworker)}</div>
+      <div class="select-wrapper" id="dropdown-wrapper"
+           hx-get="/dropdown?coworker=${encodeURIComponent(selected)}"
+           hx-trigger="load, every 5s"
+           hx-swap="innerHTML">
+        ${dropdownHtml}
+      </div>
       <div class="header-sub"
            id="coworker-status"
-           hx-get="/status"
+           hx-get="/status?coworker=${encodeURIComponent(selected)}"
            hx-trigger="load, every 5s"
            hx-swap="innerHTML"></div>
     </div>
     <button class="reset-btn"
-            hx-post="/reset"
+            hx-post="/reset?coworker=${encodeURIComponent(selected)}"
             hx-target="#reset-status"
             hx-swap="innerHTML"
-            hx-confirm="Reset ${escapeHtml(coworker)}'s session? This will revert them to their first message and re-inject the enrollment prompt."
+            hx-confirm="Reset session? This will revert them to their first message and re-inject the enrollment prompt."
             hx-on::after-request="showResetStatus()"
-            title="Reset session">
+            title="Reset session"
+            ${!selected ? 'disabled' : ''}>
       ↺ Reset
     </button>
     <div class="refresh-indicator" id="refresh-dot"
@@ -449,7 +498,7 @@ function renderPage(coworker, msgs, humanName) {
   <!-- Messages -->
   <div class="messages-outer" id="messages-outer">
     <div id="messages"
-         hx-get="/messages"
+         hx-get="/messages?coworker=${encodeURIComponent(selected)}"
          hx-trigger="load, every 5s"
          hx-swap="innerHTML">
       ${msgsHtml}
@@ -466,11 +515,12 @@ function renderPage(coworker, msgs, humanName) {
           hx-on::after-request="handleSent(event)"
           hx-on::before-request="this.querySelector('.send-btn').classList.add('sending')"
           hx-encoding="application/x-www-form-urlencoded">
+      <input type="hidden" name="coworker" value="${escapeHtml(selected)}">
       <textarea
         class="input-textarea"
         name="body"
         id="msg-input"
-        placeholder="Message ${escapeHtml(coworker)}…"
+        placeholder="${selected ? 'Message ' + escapeHtml(selected) + '…' : 'Select a coworker to message…'}"
         rows="1"
         autocomplete="off"
         autocorrect="on"
@@ -554,6 +604,14 @@ function renderPage(coworker, msgs, humanName) {
   // Initial scroll
   scrollToBottom()
 
+  // Switch to a different coworker
+  function switchCoworker(name) {
+    if (!name) return
+    const url = new URL(window.location.href)
+    url.searchParams.set('coworker', name)
+    window.location.href = url.toString()
+  }
+
   // Flash the reset status toast then fade it out
   function showResetStatus() {
     const el = document.getElementById('reset-status')
@@ -569,8 +627,9 @@ function renderPage(coworker, msgs, humanName) {
     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)
+        // Decode base64 to get original text with preserved newlines and UTF-8 chars
+        const binary = atob(b64)
+        const text = new TextDecoder().decode(Uint8Array.from(binary, c => c.charCodeAt(0)))
         el.innerHTML = marked.parse(text)
         el.setAttribute('data-rendered', 'true')
       }
@@ -589,8 +648,8 @@ function renderPage(coworker, msgs, humanName) {
 </html>`;
 }
 // ── Express app ───────────────────────────────────────────────────────────────
-export async function appCoworkerChatWeb(coworker, options) {
-    const { url: agentUrl, secret, host, port: portStr } = options;
+export async function appCoworkerChatWeb(options) {
+    const { url: agentUrl, password, host, port: portStr } = options;
     const port = parseInt(portStr, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error(`Error: invalid port "${portStr}"`);
@@ -606,22 +665,76 @@ export async function appCoworkerChatWeb(coworker, options) {
     // Resolve human name once at startup
     let humanName = "Human";
     try {
-        humanName = await getHumanName(agentUrl, secret);
+        humanName = await getHumanName(agentUrl, password);
     }
     catch (err) {
         console.error(`Warning: could not fetch human name from ${agentUrl}: ${err instanceof Error ? err.message : String(err)}`);
-        console.error("Check that agent-office serve is running and --secret is correct.");
+        console.error("Check that agent-office serve is running and --password is correct.");
     }
-    console.log(`Communicator: chatting as "${humanName}" with "${coworker}"`);
+    console.log(`Communicator: chatting as "${humanName}"`);
     const app = express();
     app.use(express.urlencoded({ extended: false }));
     app.use(express.json());
+    // ── GET /coworkers — list of coworkers (HTMX) ───────────────────────────────
+    app.get("/coworkers", async (_req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        try {
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: { "Authorization": `Bearer ${password}` },
+            });
+            if (!response.ok) {
+                res.json([{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]);
+                return;
+            }
+            const coworkers = await response.json();
+            res.json(coworkers);
+        }
+        catch {
+            res.json([{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]);
+        }
+    });
+    // ── GET /dropdown — dropdown fragment for HTMX polling ────────────────────
+    app.get("/dropdown", async (req, res) => {
+        const coworker = req.query.coworker;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        try {
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: { "Authorization": `Bearer ${password}` },
+            });
+            if (!response.ok) {
+                res.send(renderDropdown(coworker ?? null, [{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]));
+                return;
+            }
+            const coworkers = await response.json();
+            res.send(renderDropdown(coworker ?? null, coworkers));
+        }
+        catch {
+            res.send(renderDropdown(coworker ?? null, [{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }]));
+        }
+    });
     // ── GET / — full page ────────────────────────────────────────────────────
-    app.get("/", async (_req, res) => {
+    app.get("/", async (req, res) => {
         try {
-            const msgs = await fetchMessages(agentUrl, secret, humanName, coworker);
+            // Fetch coworkers with unread counts from main server
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: { "Authorization": `Bearer ${password}` },
+            });
+            let coworkers;
+            if (response.ok) {
+                coworkers = await response.json();
+            }
+            else {
+                coworkers = [{ name: humanName, status: null, isHuman: true, unreadMessages: 0 }];
+            }
+            const nonHumans = coworkers.filter(c => !c.isHuman);
+            let coworker = req.query.coworker;
+            // Default to first non-human coworker if none specified
+            if (!coworker && nonHumans.length > 0) {
+                coworker = nonHumans[0].name;
+            }
+            const msgs = coworker ? await fetchMessages(agentUrl, password, humanName, coworker) : [];
             res.setHeader("Content-Type", "text/html; charset=utf-8");
-            res.send(renderPage(coworker, msgs, humanName));
+            res.send(renderPage(coworker ?? null, coworkers, msgs, humanName));
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -629,12 +742,18 @@ export async function appCoworkerChatWeb(coworker, options) {
         }
     });
     // ── GET /messages — HTMX fragment (polled every 5s) ──────────────────────
-    app.get("/messages", async (_req, res) => {
+    app.get("/messages", async (req, res) => {
+        const coworker = req.query.coworker;
+        if (!coworker) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<div class="empty-state">Select a coworker to view messages.</div>`);
+            return;
+        }
         try {
-            const msgs = await fetchMessages(agentUrl, secret, humanName, coworker);
+            const msgs = await fetchMessages(agentUrl, password, humanName, coworker);
             // Mark any unread received messages as read
             const unread = msgs.filter((m) => m.from_name === coworker && !m.read);
-            await Promise.allSettled(unread.map((m) => markRead(agentUrl, secret, m.id)));
+            await Promise.allSettled(unread.map((m) => markRead(agentUrl, password, m.id)));
             res.setHeader("Content-Type", "text/html; charset=utf-8");
             res.send(renderMessages(msgs, humanName));
         }
@@ -646,14 +765,20 @@ export async function appCoworkerChatWeb(coworker, options) {
     });
     // ── POST /send — HTMX form submit ────────────────────────────────────────
     app.post("/send", async (req, res) => {
-        const body = req.body.body?.trim();
+        const { body: msgBody, coworker } = req.body;
+        const body = msgBody?.trim();
         if (!body) {
             res.setHeader("Content-Type", "text/html; charset=utf-8");
             res.send(`<span class="send-err">Message cannot be empty.</span>`);
             return;
         }
+        if (!coworker) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(`<span class="send-err">No coworker selected.</span>`);
+            return;
+        }
         try {
-            await apiFetch(agentUrl, secret, "/messages", {
+            await apiFetch(agentUrl, password, "/messages", {
                 method: "POST",
                 body: JSON.stringify({ from: humanName, to: [coworker], body }),
             });
@@ -667,10 +792,15 @@ export async function appCoworkerChatWeb(coworker, options) {
         }
     });
     // ── GET /status — coworker status fragment (polled every 5s) ────────────
-    app.get("/status", async (_req, res) => {
+    app.get("/status", async (req, res) => {
+        const coworker = req.query.coworker;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
+        if (!coworker) {
+            res.send(`<span style="color:var(--text-dim)">—</span>`);
+            return;
+        }
         try {
-            const status = await fetchCoworkerStatus(agentUrl, secret, coworker);
+            const status = await fetchCoworkerStatus(agentUrl, password, coworker);
             res.send(status ? escapeHtml(status) : `<span style="color:var(--text-dim)">—</span>`);
         }
         catch {
@@ -678,10 +808,15 @@ export async function appCoworkerChatWeb(coworker, options) {
         }
     });
     // ── POST /reset — revert the coworker's session to first message ─────────
-    app.post("/reset", async (_req, res) => {
+    app.post("/reset", async (req, res) => {
+        const coworker = req.query.coworker;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
+        if (!coworker) {
+            res.send(`<span style="color:var(--red)">✗ No coworker selected.</span>`);
+            return;
+        }
         try {
-            await apiFetch(agentUrl, secret, `/sessions/${encodeURIComponent(coworker)}/revert-to-start`, {
+            await apiFetch(agentUrl, password, `/sessions/${encodeURIComponent(coworker)}/revert-to-start`, {
                 method: "POST",
             });
             res.send(`<span style="color:var(--green)">✓ ${escapeHtml(coworker)} reset and restarted.</span>`);

package/dist/commands/screensaver.d.ts

@@ -1,6 +1,6 @@
 interface ScreensaverOptions {
     url: string;
-    secret: string;
+    password: string;
     host: string;
     port: string;
 }

package/dist/commands/screensaver.js

@@ -1,6 +1,6 @@
 import express from "express";
 export async function appScreensaver(options) {
-    const { url: agentUrl, secret, host, port: portStr } = options;
+    const { url: agentUrl, password, host, port: portStr } = options;
     const port = parseInt(portStr, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error(`Error: invalid port "${portStr}"`);
@@ -16,6 +16,26 @@ export async function appScreensaver(options) {
     console.log(`Screensaver: visualizing mail activity from ${agentUrl}/watch`);
     const app = express();
     app.use(express.json());
+    // ── GET /coworkers — proxies coworker list from agent-office ───────────────
+    app.get("/coworkers", async (_req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        try {
+            const response = await fetch(`${agentUrl}/coworkers`, {
+                headers: {
+                    "Authorization": `Bearer ${password}`,
+                },
+            });
+            if (!response.ok) {
+                res.json([]);
+                return;
+            }
+            const data = await response.json();
+            res.json(data);
+        }
+        catch {
+            res.json([]);
+        }
+    });
     // ── GET / — Three.js ring visualization ─────────────────────────────────────
     app.get("/", (_req, res) => {
         res.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -40,7 +60,7 @@ export async function appScreensaver(options) {
             // Connect to the agent-office /watch endpoint
             const response = await fetch(`${agentUrl}/watch`, {
                 headers: {
-                    "Authorization": `Bearer ${secret}`,
+                    "Authorization": `Bearer ${password}`,
                 },
                 signal: abortController.signal,
             });
@@ -150,6 +170,7 @@ function renderScreensaverPage() {
     let agentNodes = new Map()   // name -> { mesh, label, angle }
     let arrowObjects = []        // { from, to, mesh, arrowHead, createdAt, opacity }
     let watchState = {}          // latest state from SSE
+    let coworkersSet = new Set() // valid coworker names from /coworkers endpoint
 
     // Track all messages we've seen: key = "from->to", value = lastSent ISO string
     let messageEdges = new Map() // "from->to" -> { lastSent: Date }
@@ -1092,11 +1113,15 @@ function renderScreensaverPage() {
       watchState = state
       const nameSet = new Set()
 
-      // Collect all agent names and message edges
+      // Collect all agent names and message edges (only for valid coworkers)
       for (const agentName in state) {
+        // Only include if this is a known coworker
+        if (!coworkersSet.has(agentName)) continue
         nameSet.add(agentName)
         const senders = state[agentName] || {}
         for (const senderName in senders) {
+          // Only include sender if they're also a known coworker
+          if (!coworkersSet.has(senderName)) continue
           nameSet.add(senderName)
           const edgeKey = senderName + '->' + agentName
           const lastSent = new Date(senders[senderName].lastSent)
@@ -1135,6 +1160,25 @@ function renderScreensaverPage() {
       updateArrows()
     }
 
+    // ── Fetch coworkers list on startup ──────────────────────────────────────
+    async function fetchCoworkers() {
+      try {
+        const response = await fetch('/coworkers')
+        const coworkers = await response.json()
+        coworkersSet = new Set(coworkers.map(c => c.name))
+        console.log('Loaded coworkers:', Array.from(coworkersSet))
+        // Re-process watch state if we already have data
+        if (Object.keys(watchState).length > 0) {
+          processWatchState(watchState)
+        }
+      } catch (err) {
+        console.error('Failed to fetch coworkers:', err)
+      }
+    }
+
+    // Fetch coworkers immediately
+    fetchCoworkers()
+
     // ── SSE connection ─────────────────────────────────────────────────────
     const es = new EventSource('/watch-stream')
 

package/dist/commands/serve.d.ts

@@ -6,6 +6,7 @@ interface ServeOptions {
     memoryPath: string;
     password?: string;
     opencodeUrl: string;
+    simpleMemory?: boolean;
 }
 export declare function serve(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/serve.js

@@ -3,7 +3,7 @@ import { runMigrations } from "../db/migrate.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";
+import { AgentOfficeFastMemory, AgentOfficeSimpleMemory } from "../server/memory.js";
 export async function serve(options) {
     const password = options.password;
     if (!password) {
@@ -44,20 +44,28 @@ export async function serve(options) {
     const agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
     console.log(`Connecting to OpenCode server at ${options.opencodeUrl}...`);
     const serverUrl = `http://${options.host}:${port}`;
-    // Create memory manager and verify embedding model
-    const memoryManager = new MemoryManager(options.memoryPath);
-    console.log("Warming up embedding model...");
-    try {
+    // Create memory manager
+    let memoryManager;
+    if (options.simpleMemory) {
+        console.log("Using simple SQLite+BM25 memory backend.");
+        memoryManager = new AgentOfficeSimpleMemory(options.memoryPath);
         await memoryManager.warmup();
-        console.log("Embedding model ready.");
     }
-    catch (err) {
-        console.error("Embedding model failed to load:", err);
-        console.error("Try deleting the model cache and restarting:");
-        console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
-        memoryManager.closeAll();
-        await storage.close();
-        process.exit(1);
+    else {
+        memoryManager = new AgentOfficeFastMemory(options.memoryPath);
+        console.log("Warming up embedding model...");
+        try {
+            await memoryManager.warmup();
+            console.log("Embedding model ready.");
+        }
+        catch (err) {
+            console.error("Embedding model failed to load:", err);
+            console.error("Try deleting the model cache and restarting:");
+            console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
+            memoryManager.closeAll();
+            await storage.close();
+            process.exit(1);
+        }
     }
     // Create cron scheduler
     const cronScheduler = new CronScheduler();

package/dist/commands/worker.d.ts

@@ -6,6 +6,7 @@ export declare function createCron(token: string, options: {
     name: string;
     schedule: string;
     message: string;
+    respondTo: string;
     timezone?: string;
 }): Promise<void>;
 export declare function deleteCron(token: string, cronId: number): Promise<void>;

package/dist/commands/worker.js

@@ -96,7 +96,8 @@ export async function listCrons(token) {
     console.log(JSON.stringify(crons, null, 2));
 }
 export async function createCron(token, options) {
-    const cron = await postWorker(token, "/worker/crons", options);
+    const finalMessage = `Action: ${options.message}\n\nWho to respond to when done: ${options.respondTo}`;
+    const cron = await postWorker(token, "/worker/crons", { name: options.name, schedule: options.schedule, message: finalMessage, timezone: options.timezone });
     console.log(JSON.stringify(cron, null, 2));
 }
 export async function deleteCron(token, cronId) {

package/dist/db/postgresql-storage.d.ts

@@ -21,6 +21,7 @@ export declare class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase
     setConfig(key: string, value: string): Promise<void>;
     listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;

package/dist/db/postgresql-storage.js

@@ -131,6 +131,19 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
       ORDER BY created_at DESC
     `;
     }
+    async countUnreadBySender(recipientName) {
+        const rows = await this.sql `
+      SELECT from_name, COUNT(*) as count
+      FROM messages
+      WHERE to_name = ${recipientName} AND read = FALSE
+      GROUP BY from_name
+    `;
+        const result = new Map();
+        for (const row of rows) {
+            result.set(row.from_name, Number(row.count));
+        }
+        return result;
+    }
     async createMessageImpl(from, to, body) {
         const [row] = await this.sql `
       INSERT INTO messages (from_name, to_name, body)

package/dist/db/sqlite-storage.d.ts

@@ -22,6 +22,7 @@ export declare class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
     setConfig(key: string, value: string): Promise<void>;
     listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;

package/dist/db/sqlite-storage.js

@@ -172,6 +172,20 @@ export class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
             created_at: new Date(row.created_at + 'Z'), // Treat SQLite datetime as UTC
         }));
     }
+    async countUnreadBySender(recipientName) {
+        const stmt = this.db.prepare(`
+      SELECT from_name, COUNT(*) as count
+      FROM messages
+      WHERE to_name = ? AND read = FALSE
+      GROUP BY from_name
+    `);
+        const rows = stmt.all(recipientName);
+        const result = new Map();
+        for (const row of rows) {
+            result.set(row.from_name, row.count);
+        }
+        return result;
+    }
     async createMessageImpl(from, to, body) {
         const stmt = this.db.prepare(`
       INSERT INTO messages (from_name, to_name, body)

package/dist/db/storage-base.d.ts

@@ -23,6 +23,7 @@ export declare abstract class AgentOfficeStorageBase implements AgentOfficeStora
     abstract setConfig(key: string, value: string): Promise<void>;
     abstract listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
     abstract listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    abstract countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     abstract markMessageAsRead(id: number): Promise<MessageRow | null>;
     abstract markMessageAsInjected(id: number): Promise<void>;
     abstract listCronJobs(): Promise<CronJobRow[]>;

package/dist/db/storage.d.ts

@@ -32,6 +32,7 @@ export interface AgentOfficeStorage {
     setConfig(key: string, value: string): Promise<void>;
     listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
     createMessage(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import type { AgentOfficeStorage } from "../db/index.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(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: MemoryManager): import("express-serve-static-core").Express;
+import type { AgentOfficeMemory } from "./memory.js";
+export declare function createApp(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: AgentOfficeMemory): import("express-serve-static-core").Express;

package/dist/server/memory.d.ts

@@ -1,24 +1,66 @@
-import { createAgentMemory, type MemoryEntry } from "fastmemory";
+import { type MemoryEntry } from "fastmemory";
 export interface MemoryRecord {
     id: string;
     content: string;
     metadata: Record<string, unknown>;
     createdAt: string;
 }
-type MemoryStore = Awaited<ReturnType<typeof createAgentMemory>>;
+export type AgentOfficeMemorySearchResult = MemoryEntry;
 /**
- * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Abstract base class for agent memory backends.
+ * Consumers should depend on this type rather than any concrete implementation.
+ */
+export declare abstract class AgentOfficeMemory {
+    abstract addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+    abstract searchMemories(sessionName: string, query: string, limit?: number): Promise<AgentOfficeMemorySearchResult[]>;
+    abstract listMemories(sessionName: string, limit?: number): MemoryRecord[];
+    abstract getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
+    abstract deleteMemory(sessionName: string, memoryId: string): boolean;
+    abstract updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
+    abstract getStats(sessionName: string): {
+        total: number;
+    };
+    abstract warmup(): Promise<void>;
+    abstract closeAll(): void;
+}
+/**
+ * Lightweight memory backend using a single SQLite database file at
+ * <memoryPath>/simple-memory.db.  All sessions share the same file; rows are
+ * partitioned by session_name.  Full-text search is provided by SQLite's
+ * built-in FTS5 (BM25 ranking).  No embeddings, no external dependencies
+ * beyond better-sqlite3.
+ *
+ * Activate with: agent-office serve --simple-memory
+ */
+export declare class AgentOfficeSimpleMemory extends AgentOfficeMemory {
+    private basePath;
+    private db;
+    constructor(memoryPath: string);
+    private _migrate;
+    private newId;
+    private sanitizeFts5Query;
+    addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+    searchMemories(sessionName: string, query: string, limit?: number): Promise<AgentOfficeMemorySearchResult[]>;
+    listMemories(sessionName: string, limit?: number): MemoryRecord[];
+    getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
+    deleteMemory(sessionName: string, memoryId: string): boolean;
+    updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
+    getStats(sessionName: string): {
+        total: number;
+    };
+    warmup(): Promise<void>;
+    closeAll(): void;
+}
+/**
+ * Concrete AgentOfficeMemory implementation backed by fastmemory (SQLite + embeddings).
  * Each session gets its own .db file under <memoryPath>/<sessionName>.db
  */
-export declare class MemoryManager {
+export declare class AgentOfficeFastMemory extends AgentOfficeMemory {
     private basePath;
     private stores;
     constructor(memoryPath: string);
     private dbPathFor;
-    getStore(sessionName: string): Promise<MemoryStore>;
-    /**
-     * Add a memory for a session
-     */
+    private getStore;
     addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
     /**
      * Sanitize a query string for FTS5 MATCH syntax.
@@ -27,29 +69,11 @@ export declare class MemoryManager {
      * treated as literals rather than FTS5 operators.
      */
     private sanitizeFts5Query;
-    /**
-     * Search memories using hybrid search (BM25 + vector + RRF)
-     */
-    searchMemories(sessionName: string, query: string, limit?: number): Promise<MemoryEntry[]>;
-    /**
-     * List all memories for a session (direct SQLite access since fastmemory has no list method)
-     */
+    searchMemories(sessionName: string, query: string, limit?: number): Promise<AgentOfficeMemorySearchResult[]>;
     listMemories(sessionName: string, limit?: number): MemoryRecord[];
-    /**
-     * Get a single memory by ID
-     */
     getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
-    /**
-     * Delete a memory by ID (direct SQLite - fastmemory has no delete method)
-     */
     deleteMemory(sessionName: string, memoryId: string): boolean;
-    /**
-     * Update a memory's content (direct SQLite, re-embeds via delete+add)
-     */
     updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
-    /**
-     * Get stats for a session's memory store
-     */
     getStats(sessionName: string): {
         total: number;
     };
@@ -61,4 +85,3 @@ export declare class MemoryManager {
     warmup(): Promise<void>;
     closeAll(): void;
 }
-export {};

package/dist/server/memory.js

@@ -3,13 +3,169 @@ import { mkdirSync, existsSync } from "fs";
 import { join, resolve } from "path";
 import Database from "better-sqlite3";
 /**
- * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Abstract base class for agent memory backends.
+ * Consumers should depend on this type rather than any concrete implementation.
+ */
+export class AgentOfficeMemory {
+}
+// ── AgentOfficeSimpleMemory ───────────────────────────────────────────────────
+/**
+ * Lightweight memory backend using a single SQLite database file at
+ * <memoryPath>/simple-memory.db.  All sessions share the same file; rows are
+ * partitioned by session_name.  Full-text search is provided by SQLite's
+ * built-in FTS5 (BM25 ranking).  No embeddings, no external dependencies
+ * beyond better-sqlite3.
+ *
+ * Activate with: agent-office serve --simple-memory
+ */
+export class AgentOfficeSimpleMemory extends AgentOfficeMemory {
+    basePath;
+    db;
+    constructor(memoryPath) {
+        super();
+        this.basePath = resolve(memoryPath);
+        if (!existsSync(this.basePath)) {
+            mkdirSync(this.basePath, { recursive: true });
+        }
+        const dbPath = join(this.basePath, "simple-memory.db");
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this._migrate();
+    }
+    _migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id          TEXT PRIMARY KEY,
+        session_name TEXT NOT NULL,
+        content     TEXT NOT NULL,
+        metadata    TEXT NOT NULL DEFAULT '{}',
+        created_at  TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS memories_session_idx ON memories (session_name);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        content,
+        session_name UNINDEXED,
+        memory_id UNINDEXED,
+        content='memories',
+        content_rowid='rowid',
+        tokenize='porter unicode61'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(rowid, content, session_name, memory_id)
+          VALUES (new.rowid, new.content, new.session_name, new.id);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content, session_name, memory_id)
+          VALUES ('delete', old.rowid, old.content, old.session_name, old.id);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content, session_name, memory_id)
+          VALUES ('delete', old.rowid, old.content, old.session_name, old.id);
+        INSERT INTO memories_fts(rowid, content, session_name, memory_id)
+          VALUES (new.rowid, new.content, new.session_name, new.id);
+      END;
+    `);
+    }
+    newId() {
+        // Compact random UUID without hyphens
+        return crypto.randomUUID().replace(/-/g, "");
+    }
+    sanitizeFts5Query(query) {
+        return query
+            .split(/\s+/)
+            .filter((t) => t.length > 0)
+            .map((t) => `"${t.replace(/"/g, '""')}"`)
+            .join(" ");
+    }
+    async addMemory(sessionName, content, metadata = {}) {
+        const id = this.newId();
+        const createdAt = new Date().toISOString();
+        this.db.prepare(`INSERT INTO memories (id, session_name, content, metadata, created_at) VALUES (?, ?, ?, ?, ?)`).run(id, sessionName, content, JSON.stringify(metadata), createdAt);
+        return id;
+    }
+    async searchMemories(sessionName, query, limit = 10) {
+        if (!query.trim())
+            return [];
+        const safeQuery = this.sanitizeFts5Query(query);
+        const rows = this.db.prepare(`
+      SELECT m.id, m.content, m.metadata, m.created_at,
+             -bm25(memories_fts) AS score
+        FROM memories_fts
+        JOIN memories m ON m.id = memories_fts.memory_id
+       WHERE memories_fts MATCH ?
+         AND memories_fts.session_name = ?
+       ORDER BY score DESC
+       LIMIT ?
+    `).all(safeQuery, sessionName, limit);
+        return rows.map((r) => ({
+            id: r.id,
+            content: r.content,
+            metadata: r.metadata ? JSON.parse(r.metadata) : {},
+            createdAt: r.created_at,
+            score: r.score,
+        }));
+    }
+    listMemories(sessionName, limit = 50) {
+        const rows = this.db.prepare(`SELECT id, content, metadata, created_at FROM memories WHERE session_name = ? ORDER BY created_at DESC LIMIT ?`).all(sessionName, limit);
+        return rows.map((r) => ({
+            id: r.id,
+            content: r.content,
+            metadata: r.metadata ? JSON.parse(r.metadata) : {},
+            createdAt: r.created_at,
+        }));
+    }
+    getMemory(sessionName, memoryId) {
+        const row = this.db.prepare(`SELECT id, content, metadata, created_at FROM memories WHERE id = ? AND session_name = ?`).get(memoryId, sessionName);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            content: row.content,
+            metadata: row.metadata ? JSON.parse(row.metadata) : {},
+            createdAt: row.created_at,
+        };
+    }
+    deleteMemory(sessionName, memoryId) {
+        const result = this.db.prepare(`DELETE FROM memories WHERE id = ? AND session_name = ?`).run(memoryId, sessionName);
+        return result.changes > 0;
+    }
+    async updateMemory(sessionName, memoryId, content, metadata) {
+        const existing = this.getMemory(sessionName, memoryId);
+        if (!existing)
+            return false;
+        const finalMetadata = metadata ?? existing.metadata;
+        const result = this.db.prepare(`UPDATE memories SET content = ?, metadata = ? WHERE id = ? AND session_name = ?`).run(content, JSON.stringify(finalMetadata), memoryId, sessionName);
+        return result.changes > 0;
+    }
+    getStats(sessionName) {
+        const row = this.db.prepare(`SELECT COUNT(*) as total FROM memories WHERE session_name = ?`).get(sessionName);
+        return { total: row.total };
+    }
+    async warmup() {
+        // No model to warm up — DB is already open and ready.
+    }
+    closeAll() {
+        try {
+            this.db.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Concrete AgentOfficeMemory implementation backed by fastmemory (SQLite + embeddings).
  * Each session gets its own .db file under <memoryPath>/<sessionName>.db
  */
-export class MemoryManager {
+export class AgentOfficeFastMemory extends AgentOfficeMemory {
     basePath;
     stores = new Map();
     constructor(memoryPath) {
+        super();
         this.basePath = resolve(memoryPath);
         if (!existsSync(this.basePath)) {
             mkdirSync(this.basePath, { recursive: true });
@@ -34,9 +190,6 @@ export class MemoryManager {
         this.stores.set(sessionName, store);
         return store;
     }
-    /**
-     * Add a memory for a session
-     */
     async addMemory(sessionName, content, metadata = {}) {
         const store = await this.getStore(sessionName);
         return await store.add(content, metadata);
@@ -54,17 +207,11 @@ export class MemoryManager {
             .map((t) => `"${t.replace(/"/g, '""')}"`)
             .join(" ");
     }
-    /**
-     * Search memories using hybrid search (BM25 + vector + RRF)
-     */
     async searchMemories(sessionName, query, limit = 10) {
         const store = await this.getStore(sessionName);
         const safeQuery = this.sanitizeFts5Query(query);
         return await store.searchHybrid(safeQuery, limit);
     }
-    /**
-     * List all memories for a session (direct SQLite access since fastmemory has no list method)
-     */
     listMemories(sessionName, limit = 50) {
         const dbPath = this.dbPathFor(sessionName);
         if (!existsSync(dbPath))
@@ -84,9 +231,6 @@ export class MemoryManager {
             db.close();
         }
     }
-    /**
-     * Get a single memory by ID
-     */
     getMemory(sessionName, memoryId) {
         const dbPath = this.dbPathFor(sessionName);
         if (!existsSync(dbPath))
@@ -108,9 +252,6 @@ export class MemoryManager {
             db.close();
         }
     }
-    /**
-     * Delete a memory by ID (direct SQLite - fastmemory has no delete method)
-     */
     deleteMemory(sessionName, memoryId) {
         const dbPath = this.dbPathFor(sessionName);
         if (!existsSync(dbPath))
@@ -125,9 +266,6 @@ export class MemoryManager {
             db.close();
         }
     }
-    /**
-     * Update a memory's content (direct SQLite, re-embeds via delete+add)
-     */
     async updateMemory(sessionName, memoryId, content, metadata) {
         const existing = this.getMemory(sessionName, memoryId);
         if (!existing)
@@ -140,14 +278,10 @@ export class MemoryManager {
             this.stores.delete(sessionName);
         }
         const store = await this.getStore(sessionName);
-        // Re-add with new content but preserve metadata if not provided
         const finalMetadata = metadata ?? existing.metadata;
         await store.add(content, finalMetadata);
         return true;
     }
-    /**
-     * Get stats for a session's memory store
-     */
     getStats(sessionName) {
         const dbPath = this.dbPathFor(sessionName);
         if (!existsSync(dbPath))
@@ -177,7 +311,7 @@ export class MemoryManager {
         });
         try {
             // Force an embedding by adding and searching
-            const id = await store.add("warmup test memory");
+            await store.add("warmup test memory");
             const results = await store.searchHybrid("warmup test", 1);
             if (results.length === 0) {
                 throw new Error("Embedding model warmup: search returned no results");

package/dist/server/routes.d.ts

@@ -2,7 +2,7 @@ import { Router } from "express";
 import type { AgentOfficeStorage } from "../db/index.js";
 import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import { CronScheduler } from "./cron.js";
-import type { MemoryManager } from "./memory.js";
+import type { AgentOfficeMemory } from "./memory.js";
 /**
  * Build the persistent system-prompt briefing for a worker session.
  * This is injected as the `system` field on every `promptAsync` call so the
@@ -10,5 +10,5 @@ import type { MemoryManager } from "./memory.js";
  * without consuming a user-message turn.
  */
 export declare function generateSystemPrompt(name: string, status: string | null, humanName: string, humanDescription: string, token: string): string;
-export declare function createRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
-export declare function createWorkerRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, memoryManager: MemoryManager): Router;
+export declare function createRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler, memoryManager: AgentOfficeMemory): Router;
+export declare function createWorkerRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, memoryManager: AgentOfficeMemory): Router;

package/dist/server/routes.js

@@ -4,17 +4,12 @@ const MAIL_INJECTION_BLURB = [
     ``,
     `---`,
     `You have a new message. Please review the injected message above and respond accordingly.`,
-    `IMPORTANT: When reading or responding, note that dollar signs ($) and other special`,
-    `characters may be interpreted as markdown. The sender may have included them but they`,
-    `could appear differently in your session view. Interpret context accordingly.`,
     ``,
     `When responding to the sender:`,
     `- Use the \`agent-office worker send-message\` tool so they can see your reply`,
     `- Avoid excessive length - keep responses concise`,
-    `- Use markdown front-matter with a "choices" array if offering options`,
-    ``,
-    `Tip: For currency or prices, use code blocks. Example: put numbers in single or`,
-    `double quotes to preserve formatting characters like dollar signs.`,
+    `- Feel free to use markdown formatting`,
+    `- IMPORTANT: Remember when using bash commands certain characters (like dollar signs) may need to be escaped or wrapped in quotes`,
 ].join("\n");
 /**
  * Build the persistent system-prompt briefing for a worker session.
@@ -78,6 +73,23 @@ export function generateSystemPrompt(name, status, humanName, humanDescription,
         `   agent-office worker cron \\`,
         `     ${token}`,
         ``,
+        ` Create a cron job (scheduled task)`,
+        `   agent-office worker cron create \\`,
+        `     --name <job-name> \\`,
+        `     --schedule "<cron-expression>" \\`,
+        `     --message "<action-to-perform>" \\`,
+        `     --respond-to "<who-to-respond-to-when-done>" \\`,
+        `     ${token}`,
+        ``,
+        `   Example: Daily standup reminder at 9am`,
+        `     --schedule "0 9 * * *" \\`,
+        `     --message "Prepare your standup update" \\`,
+        `     --respond-to "${humanName} in the standup channel"`,
+        ``,
+        `   The final injected message will be formatted as:`,
+        `     Action: <message>`,
+        `     Who to respond to when done: <respond-to>`,
+        ``,
         ` Store a memory (persistent across sessions)`,
         `   agent-office worker memory add \\`,
         `     --content "your memory here" \\`,
@@ -192,6 +204,27 @@ export function createRouter(storage, agenticCodingServer, serverUrl, scheduler,
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    router.get("/coworkers", async (_req, res) => {
+        try {
+            const sessions = await storage.listSessions();
+            const humanName = await storage.getConfig('human_name') ?? "Human";
+            const unreadCounts = await storage.countUnreadBySender(humanName);
+            const coworkers = [
+                { name: humanName, status: null, isHuman: true, unreadMessages: 0 },
+                ...sessions.map(s => ({
+                    name: s.name,
+                    status: s.status,
+                    isHuman: false,
+                    unreadMessages: unreadCounts.get(s.name) ?? 0
+                }))
+            ];
+            res.json(coworkers);
+        }
+        catch (err) {
+            console.error("GET /coworkers error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     router.post("/sessions", async (req, res) => {
         const { name, agent: agentArg } = req.body;
         if (!name || typeof name !== "string" || !name.trim()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",