agent-office 0.3.1 → 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

@@ -35,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);
 });
@@ -123,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/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/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.1",
+  "version": "0.3.2",
   "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",