agent-office 0.3.2 → 0.4.1

package/README.md

@@ -1,20 +1,20 @@
 # agent-office
 
-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.
+An office for your AI agents. Manage multiple [OpenCode](https://opencode.ai) coding sessions as named coworkers with inter-agent messaging, scheduled tasks, and a terminal UI for human oversight.
 
 ## Overview
 
-`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.
+`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, and cron-based scheduling -- creating an "office" where AI agents are coworkers that communicate, take direction, and operate autonomously.
 
 **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
+- **`serve`** -- an HTTP server that manages sessions, messages, and cron jobs, 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
+- **`worker`** -- subcommands that agents invoke from within their OpenCode sessions to clock in, message coworkers, set status, and manage cron jobs
 
 ```
                     +---------------------+
@@ -27,10 +27,10 @@ An office for your AI agents. Manage multiple [OpenCode](https://opencode.ai) co
 |  Ink/React   |    |      :7654           |    |              |
 +--------------+    |                      |    +--------------+
                     |   CronScheduler      |
-+--------------+    |   MemoryManager      |    +--------------+
-| Communicator |<-->|                      |<-->|  .memory/    |
-| Web (HTMX)   |    |                      |    |  SQLite DBs  |
-| :7655        |    +---------+-----------+    +--------------+
++--------------+    |                      |
+| Communicator |<-->|                      |
+| Web (HTMX)   |    |                      |
+| :7655        |    +---------+-----------+
 +--------------+              |
                               | /worker/* endpoints
                     +---------+-----------+
@@ -69,7 +69,7 @@ agent-office serve \
   --password mysecret
 ```
 
-The server runs migrations automatically on startup, initializes the cron scheduler, and warms up the embedding model for agent memory.
+The server runs migrations automatically on startup and initializes the cron scheduler.
 
 ### 2. Open the manager
 
@@ -97,11 +97,11 @@ Opens a web-based chat interface at `http://127.0.0.1:7655` for real-time conver
 
 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.
+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 and create cron jobs.
 
 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.
+5. **Reset** - - A session can be reverted to its initial state (clearing all conversation history) and re-enrolled.
 
 6. **Delete** -- Deleting a coworker removes both the OpenCode session and the database record.
 
@@ -139,7 +139,7 @@ cp .env.example .env
 
 ### `agent-office serve`
 
-Starts the HTTP server. Connects to PostgreSQL, runs migrations, initializes the cron scheduler, and warms up the embedding model.
+Starts the HTTP server. Connects to PostgreSQL, runs migrations, and initializes the cron scheduler.
 
 ```
 Options:
@@ -147,7 +147,6 @@ Options:
   --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)
 ```
 
@@ -165,7 +164,7 @@ Options:
 
 | Screen | Description |
 |---|---|
-| **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 |
+| **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 |
 | **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 |
@@ -217,11 +216,6 @@ 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
@@ -251,12 +245,7 @@ agent-office worker memory forget <token> <memory-id>
 | `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>`)
 
@@ -272,10 +261,7 @@ agent-office worker memory forget <token> <memory-id>
 | `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
 
@@ -289,14 +275,6 @@ The server uses PostgreSQL with automatic migrations. Tables:
 - **`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:

package/dist/cli.js

@@ -13,10 +13,8 @@ program
     .option("--sqlite <path>", "SQLite database file path (alternative to PostgreSQL)", process.env.AGENT_OFFICE_SQLITE)
     .option("--host <host>", "Host to bind to", "127.0.0.1")
     .option("--port <port>", "Port to serve on", "7654")
-    .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,8 +32,8 @@ const appCmd = program
     .command("app")
     .description("[HUMAN ONLY] Interactive visual applications");
 appCmd
-    .command("coworker-chat-web")
-    .description("[HUMAN ONLY] Launch a web chat interface for coworkers")
+    .command("chat")
+    .description("Web chat interface for human to chat to 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("--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")
@@ -44,9 +42,8 @@ appCmd
     const { appCoworkerChatWeb } = await import("./commands/communicator.js");
     await appCoworkerChatWeb(options);
 });
-appCmd
-    .command("screensaver")
-    .description("[HUMAN ONLY] Launch a visualization of recent mail activity (live screensaver)")
+appCmd.command("screensaver")
+    .description("3D visualization of recent mail activity")
     .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("--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")
@@ -55,6 +52,19 @@ appCmd
     const { appScreensaver } = await import("./commands/screensaver.js");
     await appScreensaver(options);
 });
+appCmd
+    .command('notifier')
+    .description('Notify human by email when unread messages have been waiting over certain amount of time')
+    .option('--agent-office-url <url>', 'Agent Office server URL', process.env.AGENT_OFFICE_URL ?? 'http://127.0.0.1:7654')
+    .option('--password <pw>', 'API password', process.env.AGENT_OFFICE_PASSWORD)
+    .option('--to-email <email>', 'Recipient email address', process.env.TO_EMAIL)
+    .option('--resend-api-key <key>', 'Resend API key', process.env.RESEND_API_KEY)
+    .option('--domain <domain>', 'Sender domain (e.g. coworker.innercontext.com)', process.env.EMAIL_DOMAIN)
+    .option('--wait-minutes <minutes>', 'Minutes a message must be unread before notifying', '15')
+    .action(async (options) => {
+    const { notifier } = await import('./commands/notifier.js');
+    await notifier(options);
+});
 const workerCmd = program
     .command("worker")
     .description("Worker agent commands");
@@ -178,47 +188,4 @@ cronCmd
     const { cronHistory } = await import("./commands/worker.js");
     await cronHistory(token, cronId);
 });
-// ── Worker Memory Commands (nested) ──────────────────────────────────────────
-const memoryCmd = workerCmd
-    .command("memory")
-    .description("Manage your persistent memories");
-memoryCmd
-    .command("add")
-    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
-    .description("Add a new memory")
-    .requiredOption("--content <content>", "Memory content to store")
-    .action(async (token, options) => {
-    const { memoryAdd } = await import("./commands/worker.js");
-    await memoryAdd(token, options.content);
-});
-memoryCmd
-    .command("search")
-    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
-    .description("Search memories using hybrid search (keyword + semantic)")
-    .requiredOption("--query <query>", "Search query")
-    .option("--limit <limit>", "Maximum results (default 10)", "10")
-    .action(async (token, options) => {
-    const limit = parseInt(options.limit ?? "10", 10);
-    const { memorySearch } = await import("./commands/worker.js");
-    await memorySearch(token, options.query, limit);
-});
-memoryCmd
-    .command("list")
-    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
-    .description("List all stored memories")
-    .option("--limit <limit>", "Maximum memories to list (default 50)", "50")
-    .action(async (token, options) => {
-    const limit = parseInt(options.limit ?? "50", 10);
-    const { memoryList } = await import("./commands/worker.js");
-    await memoryList(token, limit);
-});
-memoryCmd
-    .command("forget")
-    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
-    .argument("<memoryId>", "ID of the memory to forget")
-    .description("Delete a memory by ID")
-    .action(async (token, memoryId) => {
-    const { memoryForget } = await import("./commands/worker.js");
-    await memoryForget(token, memoryId);
-});
 program.parse();

package/dist/commands/notifier.d.ts

@@ -0,0 +1,11 @@
+import { type AgentOfficeNotifier } from "../lib/notifier.js";
+type Options = {
+    agentOfficeUrl?: string;
+    password?: string;
+    toEmail?: string;
+    resendApiKey?: string;
+    domain?: string;
+    waitMinutes?: string;
+};
+export declare function notifier(options: Options, customNotifier?: AgentOfficeNotifier): Promise<void>;
+export {};

package/dist/commands/notifier.js

@@ -0,0 +1,100 @@
+import { Cron } from "croner";
+import { ResendNotifier } from "../lib/notifier.js";
+export async function notifier(options, customNotifier) {
+    const toEmail = options.toEmail;
+    if (!toEmail) {
+        console.error("Error: --to-email or TO_EMAIL env required");
+        process.exit(1);
+    }
+    const domain = options.domain;
+    if (!domain) {
+        console.error("Error: --domain or EMAIL_DOMAIN env required");
+        process.exit(1);
+    }
+    const agentOfficeUrl = options.agentOfficeUrl ?? "http://127.0.0.1:7654";
+    const password = options.password;
+    if (!password) {
+        console.error("Error: --password or AGENT_OFFICE_PASSWORD env required");
+        process.exit(1);
+    }
+    const waitMinutes = parseInt(options.waitMinutes ?? "15", 10);
+    const waitHours = waitMinutes / 60;
+    let notify;
+    if (customNotifier) {
+        notify = customNotifier;
+    }
+    else {
+        const resendApiKey = options.resendApiKey;
+        if (!resendApiKey) {
+            console.error("Error: --resend-api-key or RESEND_API_KEY env required");
+            process.exit(1);
+        }
+        notify = new ResendNotifier(resendApiKey);
+    }
+    const authHeaders = {
+        Authorization: `Bearer ${password}`,
+        "Content-Type": "application/json",
+    };
+    const check = async () => {
+        try {
+            // Fetch messages old enough to notify about
+            const resp = await fetch(`${agentOfficeUrl}/human/unread-old?hours=${waitHours}`, {
+                headers: authHeaders,
+            });
+            if (!resp.ok) {
+                console.error(`GET /human/unread-old failed: ${resp.status}`);
+                return;
+            }
+            const qualifying = (await resp.json());
+            if (qualifying.length === 0) {
+                // Check if there are any unread messages at all (just not old enough yet)
+                const allResp = await fetch(`${agentOfficeUrl}/human/unread-old?hours=0`, {
+                    headers: authHeaders,
+                });
+                if (allResp.ok) {
+                    const allUnread = (await allResp.json());
+                    if (allUnread.length > 0) {
+                        console.log(`${allUnread.length} unread message(s) exist but haven't been waiting >${waitMinutes}m yet — skipping notification`);
+                    }
+                    else {
+                        console.log("No unread messages — nothing to notify");
+                    }
+                }
+                return;
+            }
+            const senders = [...new Set(qualifying.map((m) => m.from_name))];
+            for (const sender of senders) {
+                const fromAddress = `${sender} <${sender.replace(/\s+/g, "+")}@${domain}>`;
+                await notify.send({
+                    from: fromAddress,
+                    to: toEmail,
+                    subject: "Agent Office: Message Waiting",
+                    text: "There is a message waiting for you at Agent Office.",
+                });
+                console.log(`Sent out notification for waiting mail | from: ${fromAddress} | to: ${toEmail}`);
+            }
+            const ids = qualifying.map((m) => m.id);
+            const markResp = await fetch(`${agentOfficeUrl}/human/mark-notified`, {
+                method: "POST",
+                headers: authHeaders,
+                body: JSON.stringify({ ids }),
+            });
+            if (!markResp.ok) {
+                console.error(`POST /human/mark-notified failed: ${markResp.status}`);
+            }
+        }
+        catch (e) {
+            console.error("Notifier cron error:", e);
+        }
+    };
+    const cron = new Cron("0 * * * *", check);
+    console.log(`Agent Office notifier started. Notifying for messages unread >${waitMinutes}m. Checking ${agentOfficeUrl} every hour. ^C to stop.`);
+    await check();
+    const shutdown = async () => {
+        console.log("\nShutting down...");
+        cron.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}

package/dist/commands/serve.d.ts

@@ -3,10 +3,8 @@ interface ServeOptions {
     sqlite?: string;
     host: string;
     port: string;
-    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,6 @@ 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 { AgentOfficeFastMemory, AgentOfficeSimpleMemory } from "../server/memory.js";
 export async function serve(options) {
     const password = options.password;
     if (!password) {
@@ -44,33 +43,10 @@ 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
-    let memoryManager;
-    if (options.simpleMemory) {
-        console.log("Using simple SQLite+BM25 memory backend.");
-        memoryManager = new AgentOfficeSimpleMemory(options.memoryPath);
-        await memoryManager.warmup();
-    }
-    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();
     // Create Express app
-    const app = createApp(storage, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager);
+    const app = createApp(storage, agenticCodingServer, password, serverUrl, cronScheduler);
     // Start cron scheduler
     await cronScheduler.start(storage, agenticCodingServer, serverUrl);
     // Start server
@@ -82,7 +58,6 @@ export async function serve(options) {
         console.log("\nShutting down...");
         server.close(async () => {
             cronScheduler.stop();
-            memoryManager.closeAll();
             await storage.close();
             console.log("Goodbye.");
             process.exit(0);

package/dist/commands/worker.d.ts

@@ -13,7 +13,3 @@ export declare function deleteCron(token: string, cronId: number): Promise<void>
 export declare function enableCron(token: string, cronId: number): Promise<void>;
 export declare function disableCron(token: string, cronId: number): Promise<void>;
 export declare function cronHistory(token: string, cronId: number): Promise<void>;
-export declare function memoryAdd(token: string, content: string): Promise<void>;
-export declare function memorySearch(token: string, query: string, limit: number): Promise<void>;
-export declare function memoryList(token: string, limit: number): Promise<void>;
-export declare function memoryForget(token: string, memoryId: string): Promise<void>;

package/dist/commands/worker.js

@@ -139,66 +139,3 @@ export async function cronHistory(token, cronId) {
     const history = await fetchWorker(token, `/worker/crons/${cronId}/history`);
     console.log(JSON.stringify(history, null, 2));
 }
-// ── Memory Commands ──────────────────────────────────────────────────────────
-export async function memoryAdd(token, content) {
-    const result = await postWorker(token, "/worker/memory/add", { content });
-    console.log(JSON.stringify(result, null, 2));
-}
-export async function memorySearch(token, query, limit) {
-    const result = await postWorker(token, "/worker/memory/search", { query, limit });
-    console.log(JSON.stringify(result, null, 2));
-}
-export async function memoryList(token, limit) {
-    const { agentCode, serverUrl } = parseToken(token);
-    const url = `${serverUrl}/worker/memory/list?code=${encodeURIComponent(agentCode)}&limit=${limit}`;
-    let res;
-    try {
-        res = await fetch(url);
-    }
-    catch (err) {
-        console.error(`Error: could not reach ${serverUrl}`);
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    let body;
-    try {
-        body = await res.json();
-    }
-    catch {
-        console.error(`Error: invalid response from server`);
-        process.exit(1);
-    }
-    if (!res.ok) {
-        const msg = body.error ?? `HTTP ${res.status}`;
-        console.error(`Error: ${msg}`);
-        process.exit(1);
-    }
-    console.log(JSON.stringify(body, null, 2));
-}
-export async function memoryForget(token, memoryId) {
-    const { agentCode, serverUrl } = parseToken(token);
-    const url = `${serverUrl}/worker/memory/${encodeURIComponent(memoryId)}?code=${encodeURIComponent(agentCode)}`;
-    let res;
-    try {
-        res = await fetch(url, { method: "DELETE" });
-    }
-    catch (err) {
-        console.error(`Error: could not reach ${serverUrl}`);
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    let body;
-    try {
-        body = await res.json();
-    }
-    catch {
-        console.error(`Error: invalid response from server`);
-        process.exit(1);
-    }
-    if (!res.ok) {
-        const msg = body.error ?? `HTTP ${res.status}`;
-        console.error(`Error: ${msg}`);
-        process.exit(1);
-    }
-    console.log(JSON.stringify(body, null, 2));
-}

package/dist/db/index.d.ts

@@ -24,6 +24,7 @@ export interface MessageRow {
     body: string;
     read: boolean;
     injected: boolean;
+    notified?: boolean;
     created_at: Date;
 }
 export interface CronJobRow {

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

@@ -19,12 +19,18 @@ export declare class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase
     getAllConfig(): Promise<ConfigRow[]>;
     getConfig(key: string): Promise<string | null>;
     setConfig(key: string, value: string): Promise<void>;
-    listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    listMessagesForRecipient(name: string, filters?: {
+        unread?: boolean;
+        olderThanHours?: number;
+        notified?: boolean;
+    }): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
     countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
+    lastMessageAtByCoworker(humanName: string): Promise<Map<string, Date>>;
     createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;
+    markMessagesAsNotified(ids: number[]): Promise<void>;
     listCronJobs(): Promise<CronJobRow[]>;
     listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
     getCronJobById(id: number): Promise<CronJobRow | null>;

package/dist/db/postgresql-storage.js

@@ -107,21 +107,19 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
     `;
     }
     // Messages
-    async listMessagesForRecipient(name, unreadOnly) {
-        if (unreadOnly) {
-            return this.sql `
-        SELECT id, from_name, to_name, body, read, injected, created_at
-        FROM messages
-        WHERE to_name = ${name} AND read = FALSE
-        ORDER BY created_at DESC
-      `;
+    async listMessagesForRecipient(name, filters) {
+        const whereClauses = ["to_name = $1"];
+        const params = [name];
+        if (filters?.unread)
+            whereClauses.push("read = FALSE");
+        if (filters?.notified === false)
+            whereClauses.push("notified = FALSE");
+        if (filters?.olderThanHours !== undefined) {
+            whereClauses.push(`created_at < NOW() - INTERVAL '${filters.olderThanHours} hours'`);
         }
-        return this.sql `
-      SELECT id, from_name, to_name, body, read, injected, created_at
-      FROM messages
-      WHERE to_name = ${name}
-      ORDER BY created_at DESC
-    `;
+        const whereSQL = whereClauses.join(" AND ");
+        const rows = await this.sql.unsafe(`SELECT id, from_name, to_name, body, read, injected, created_at, notified FROM messages WHERE ${whereSQL} ORDER BY created_at DESC`, params);
+        return rows;
     }
     async listMessagesFromSender(name) {
         return this.sql `
@@ -144,6 +142,21 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
         }
         return result;
     }
+    async lastMessageAtByCoworker(humanName) {
+        const rows = await this.sql `
+      SELECT
+        CASE WHEN from_name = ${humanName} THEN to_name ELSE from_name END AS coworker,
+        MAX(created_at) AS last_at
+      FROM messages
+      WHERE from_name = ${humanName} OR to_name = ${humanName}
+      GROUP BY coworker
+    `;
+        const result = new Map();
+        for (const row of rows) {
+            result.set(row.coworker, row.last_at);
+        }
+        return result;
+    }
     async createMessageImpl(from, to, body) {
         const [row] = await this.sql `
       INSERT INTO messages (from_name, to_name, body)
@@ -162,6 +175,11 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
     async markMessageAsInjected(id) {
         await this.sql `UPDATE messages SET injected = TRUE WHERE id = ${id}`;
     }
+    async markMessagesAsNotified(ids) {
+        if (ids.length === 0)
+            return;
+        await this.sql `UPDATE messages SET notified = TRUE WHERE id = ANY(${ids})`;
+    }
     // Cron Jobs
     async listCronJobs() {
         return this.sql `
@@ -343,6 +361,13 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
                 name: "rename_mode_to_agent",
                 sql: `
           ALTER TABLE sessions RENAME COLUMN mode TO agent;
+        `,
+            },
+            {
+                version: 9,
+                name: "add_notified_to_messages",
+                sql: `
+          ALTER TABLE messages ADD COLUMN IF NOT EXISTS notified BOOLEAN NOT NULL DEFAULT FALSE;
         `,
             },
         ];

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

@@ -20,12 +20,18 @@ export declare class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
     getAllConfig(): Promise<ConfigRow[]>;
     getConfig(key: string): Promise<string | null>;
     setConfig(key: string, value: string): Promise<void>;
-    listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    listMessagesForRecipient(name: string, filters?: {
+        unread?: boolean;
+        olderThanHours?: number;
+        notified?: boolean;
+    }): Promise<MessageRow[]>;
     listMessagesFromSender(name: string): Promise<MessageRow[]>;
     countUnreadBySender(recipientName: string): Promise<Map<string, number>>;
+    lastMessageAtByCoworker(humanName: string): Promise<Map<string, Date>>;
     createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
     markMessageAsRead(id: number): Promise<MessageRow | null>;
     markMessageAsInjected(id: number): Promise<void>;
+    markMessagesAsNotified(ids: number[]): Promise<void>;
     listCronJobs(): Promise<CronJobRow[]>;
     listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
     getCronJobById(id: number): Promise<CronJobRow | null>;