agent-office 0.0.14 → 0.0.16

package/dist/cli.js

@@ -50,14 +50,6 @@ communicatorCmd
 const workerCmd = program
     .command("worker")
     .description("Worker agent commands");
-workerCmd
-    .command("clock-in")
-    .description("Clock in as a worker agent")
-    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
-    .action(async (token) => {
-    const { clockIn } = await import("./commands/worker.js");
-    await clockIn(token);
-});
 workerCmd
     .command("list-coworkers")
     .description("List all other workers (coworkers)")

package/dist/commands/serve.js

@@ -57,7 +57,7 @@ export async function serve(options) {
     // Create Express app
     const app = createApp(sql, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager);
     // Start cron scheduler
-    await cronScheduler.start(sql, agenticCodingServer);
+    await cronScheduler.start(sql, agenticCodingServer, serverUrl);
     // Start server
     const server = app.listen(port, options.host, () => {
         console.log(`agent-office server listening on ${serverUrl}`);

package/dist/commands/worker.d.ts

@@ -1,4 +1,3 @@
-export declare function clockIn(token: string): Promise<void>;
 export declare function listCoworkers(token: string): Promise<void>;
 export declare function setStatus(token: string, status: string | null): Promise<void>;
 export declare function sendMessage(token: string, recipients: string[], body: string): Promise<void>;

package/dist/commands/worker.js

@@ -79,35 +79,6 @@ async function postWorker(token, endpoint, payload) {
     }
     return body;
 }
-export async function clockIn(token) {
-    const { agentCode, serverUrl } = parseToken(token);
-    const parsedUrl = new URL(serverUrl);
-    const clockInUrl = `${parsedUrl.origin}/worker/clock-in?code=${encodeURIComponent(agentCode)}`;
-    let res;
-    try {
-        res = await fetch(clockInUrl);
-    }
-    catch (err) {
-        console.error(`Error: could not reach ${parsedUrl.origin}`);
-        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);
-    }
-    const { message } = body;
-    console.log(message);
-}
 export async function listCoworkers(token) {
     const workers = await fetchWorker(token, "/worker/list-coworkers");
     console.log(JSON.stringify(workers, null, 2));

package/dist/db/index.d.ts

@@ -6,7 +6,7 @@ export interface SessionRow {
     name: string;
     session_id: string;
     agent_code: string;
-    agent: string | null;
+    agent: string;
     status: string | null;
     created_at: Date;
 }

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

@@ -35,9 +35,12 @@ export interface AgenticCodingServer {
      * Inject a text message into a session (fire-and-forget).
      * The server processes the message asynchronously.
      *
-     * @param agent  optional agent-mode identifier to route the prompt.
+     * @param agent   agent-mode identifier to route the prompt.
+     * @param system  system prompt appended after the agent's built-in system
+     *                prompt. Always pass the worker briefing here so the agent
+     *                has persistent identity/context on every message turn.
      */
-    sendMessage(sessionID: string, text: string, agent?: string): Promise<void>;
+    sendMessage(sessionID: string, text: string, agent: string, system: string): Promise<void>;
     /**
      * Retrieve the message history for a session.
      *

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

@@ -4,7 +4,7 @@ export declare class OpenCodeCodingServer implements AgenticCodingServer {
     constructor(baseURL: string);
     createSession(): Promise<string>;
     deleteSession(sessionID: string): Promise<void>;
-    sendMessage(sessionID: string, text: string, agent?: string): Promise<void>;
+    sendMessage(sessionID: string, text: string, agent: string, system: string): Promise<void>;
     getMessages(sessionID: string, limit?: number): Promise<SessionMessage[]>;
     revertSession(sessionID: string, messageID: string): Promise<void>;
     getAgentModes(): Promise<AgentMode[]>;

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

@@ -18,11 +18,12 @@ export class OpenCodeCodingServer {
     async deleteSession(sessionID) {
         await this.client.session.delete({ sessionID });
     }
-    async sendMessage(sessionID, text, agent) {
+    async sendMessage(sessionID, text, agent, system) {
         await this.client.session.promptAsync({
             sessionID,
             parts: [{ type: "text", text }],
-            ...(agent ? { agent } : {}),
+            agent,
+            system,
         });
     }
     async getMessages(sessionID, limit) {

package/dist/manage/components/CreateSession.d.ts

@@ -1,7 +1,8 @@
 interface CreateSessionProps {
     serverUrl: string;
     password: string;
+    agent: string;
     onBack: () => void;
 }
-export declare function CreateSession({ serverUrl, password, onBack }: CreateSessionProps): import("react/jsx-runtime").JSX.Element;
+export declare function CreateSession({ serverUrl, password, agent, onBack }: CreateSessionProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/manage/components/CreateSession.js

@@ -3,7 +3,7 @@ import { useState, useEffect } from "react";
 import { Box, Text } from "ink";
 import { TextInput, Spinner } from "@inkjs/ui";
 import { useApi, useAsyncState } from "../hooks/useApi.js";
-export function CreateSession({ serverUrl, password, onBack }) {
+export function CreateSession({ serverUrl, password, agent, onBack }) {
     const { createSession } = useApi(serverUrl, password);
     const { loading, error, run } = useAsyncState();
     const [created, setCreated] = useState(null);
@@ -20,7 +20,7 @@ export function CreateSession({ serverUrl, password, onBack }) {
         if (!trimmed)
             return;
         setSubmitted(true);
-        const result = await run(() => createSession(trimmed));
+        const result = await run(() => createSession(trimmed, agent));
         if (result)
             setCreated(result);
     };

package/dist/manage/components/SessionList.js

@@ -474,7 +474,7 @@ function MemoryView({ serverUrl, password, sessionName, contentHeight, onClose }
 }
 // ─── Main component ──────────────────────────────────────────────────────────
 export function SessionList({ serverUrl, password, contentHeight, onSubViewChange }) {
-    const { listSessions, createSession, deleteSession, regenerateCode, getModes, revertToStart, revertAll } = useApi(serverUrl, password);
+    const { listSessions, createSession, deleteSession, updateSessionAgent, regenerateCode, getModes, revertToStart, revertAll } = useApi(serverUrl, password);
     const { data: sessions, loading, error: loadError, run } = useAsyncState();
     const [cursor, setCursor] = useState(0);
     const [revealedRows, setRevealedRows] = useState(new Set());
@@ -554,6 +554,26 @@ export function SessionList({ serverUrl, password, contentHeight, onSubViewChang
                 setActionMsg(null);
                 setMode("confirm-revert-all");
             }
+            if (input === "a" && rows.length > 0) {
+                setActionError(null);
+                setActionMsg(null);
+                setModeCursor(0);
+                setMode("changing-agent-loading");
+                getModes().then((modes) => {
+                    const safeMode = Array.isArray(modes) ? modes : [];
+                    setAvailableModes(safeMode);
+                    if (safeMode.length > 0) {
+                        setMode("changing-agent-pick");
+                    }
+                    else {
+                        setActionError("No agent modes available");
+                        setMode("create-error");
+                    }
+                }).catch(() => {
+                    setActionError("Failed to fetch agent modes");
+                    setMode("create-error");
+                });
+            }
             if (rows.length > 0) {
                 if (input === "t")
                     setSubView("tail");
@@ -582,6 +602,23 @@ export function SessionList({ serverUrl, password, contentHeight, onSubViewChang
             }
             return;
         }
+        if (mode === "changing-agent-pick") {
+            const total = availableModes.length;
+            if (key.upArrow)
+                setModeCursor((c) => (c - 1 + total) % total);
+            if (key.downArrow)
+                setModeCursor((c) => (c + 1) % total);
+            if (key.return) {
+                const selected = availableModes[modeCursor]?.name;
+                if (selected && rows[cursor]) {
+                    void handleChangeAgent(rows[cursor].name, selected);
+                }
+            }
+            if (key.escape) {
+                setMode("browse");
+            }
+            return;
+        }
         if (mode === "creating-name" && key.escape) {
             setMode("browse");
             return;
@@ -601,9 +638,14 @@ export function SessionList({ serverUrl, password, contentHeight, onSubViewChang
         const trimmed = name.trim();
         if (!trimmed)
             return;
+        if (!pendingAgent) {
+            setActionError("Agent mode is required");
+            setMode("create-error");
+            return;
+        }
         setMode("creating-busy");
         try {
-            await createSession(trimmed, pendingAgent ?? undefined);
+            await createSession(trimmed, pendingAgent);
             const modeNote = pendingAgent ? ` [${pendingAgent}]` : "";
             setActionMsg(`Coworker "${trimmed}"${modeNote} created.`);
             setMode("create-done");
@@ -614,6 +656,19 @@ export function SessionList({ serverUrl, password, contentHeight, onSubViewChang
             setMode("create-error");
         }
     };
+    const handleChangeAgent = async (sessionName, agent) => {
+        setMode("changing-agent-busy");
+        try {
+            await updateSessionAgent(sessionName, agent);
+            setActionMsg(`Agent for "${sessionName}" changed to [${agent}].`);
+            setMode("create-done");
+            reload();
+        }
+        catch (err) {
+            setActionError(err instanceof Error ? err.message : String(err));
+            setMode("create-error");
+        }
+    };
     const handleConfirmDelete = async (confirmed) => {
         if (!confirmed) {
             setMode("browse");
@@ -709,6 +764,20 @@ export function SessionList({ serverUrl, password, contentHeight, onSubViewChang
             setMode("create-error");
         }
     };
+    // ── Full-screen change-agent flow ──────────────────────────────────────────
+    if (mode === "changing-agent-loading") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading agent configs..." }) }));
+    }
+    if (mode === "changing-agent-pick") {
+        const target = rows[cursor];
+        return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Change Agent" }), _jsxs(Text, { dimColor: true, children: ["for \"", target?.name, "\""] }), target?.agent ? _jsxs(Text, { color: "yellow", children: ["[current: ", target.agent, "]"] }) : null] }), _jsx(Box, { flexDirection: "column", children: availableModes.map((m, i) => {
+                        const sel = i === modeCursor;
+                        return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: sel ? "cyan" : undefined, bold: sel, children: sel ? "▶" : " " }), _jsx(Text, { color: sel ? "cyan" : undefined, bold: sel, children: m.name }), m.description ? _jsxs(Text, { dimColor: true, children: ["\u2014 ", m.description] }) : null] }, i));
+                    }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u00B7 Enter select \u00B7 Esc cancel" }) })] }));
+    }
+    if (mode === "changing-agent-busy") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Changing agent..." }) }));
+    }
     // ── Full-screen create flow ───────────────────────────────────────────────
     if (mode === "creating-loading") {
         return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading agent configs..." }) }));

package/dist/manage/hooks/useApi.d.ts

@@ -64,8 +64,9 @@ export interface MemoryRecord {
 }
 export declare function useApi(serverUrl: string, password: string): {
     listSessions: () => Promise<Session[]>;
-    createSession: (name: string, agent?: string) => Promise<Session>;
+    createSession: (name: string, agent: string) => Promise<Session>;
     deleteSession: (name: string) => Promise<void>;
+    updateSessionAgent: (name: string, agent: string) => Promise<Session>;
     checkHealth: () => Promise<boolean>;
     getMessages: (name: string, limit?: number) => Promise<SessionMessage[]>;
     injectText: (name: string, text: string) => Promise<{

package/dist/manage/hooks/useApi.js

@@ -31,7 +31,7 @@ export function useApi(serverUrl, password) {
     const createSession = useCallback(async (name, agent) => {
         return apiFetch(`${base}/sessions`, password, {
             method: "POST",
-            body: JSON.stringify({ name, ...(agent ? { agent } : {}) }),
+            body: JSON.stringify({ name, agent }),
         });
     }, [base, password]);
     const getModes = useCallback(async () => {
@@ -42,6 +42,12 @@ export function useApi(serverUrl, password) {
             method: "DELETE",
         });
     }, [base, password]);
+    const updateSessionAgent = useCallback(async (name, agent) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/agent`, password, {
+            method: "PATCH",
+            body: JSON.stringify({ agent }),
+        });
+    }, [base, password]);
     const checkHealth = useCallback(async () => {
         try {
             await apiFetch(`${base}/health`, password);
@@ -131,6 +137,7 @@ export function useApi(serverUrl, password) {
         listSessions,
         createSession,
         deleteSession,
+        updateSessionAgent,
         checkHealth,
         getMessages,
         injectText,

package/dist/server/cron.d.ts

@@ -9,9 +9,10 @@ export declare class CronScheduler {
     private activeJobs;
     private sql;
     private agenticCodingServer;
+    private serverUrl;
     private started;
     constructor(options?: CronSchedulerOptions);
-    start(sql: Sql, agenticCodingServer: AgenticCodingServer): Promise<void>;
+    start(sql: Sql, agenticCodingServer: AgenticCodingServer, serverUrl: string): Promise<void>;
     stop(): void;
     private addJob;
     private executeJob;

package/dist/server/cron.js

@@ -1,4 +1,5 @@
 import { Cron } from "croner";
+import { generateSystemPrompt } from "./routes.js";
 const CRON_INJECTION_BLURB = [
     ``,
     `---`,
@@ -10,15 +11,17 @@ export class CronScheduler {
     activeJobs = new Map();
     sql = null;
     agenticCodingServer = null;
+    serverUrl = "";
     started = false;
     constructor(options = {}) {
         this.options = options;
     }
-    async start(sql, agenticCodingServer) {
+    async start(sql, agenticCodingServer, serverUrl) {
         if (this.started)
             return;
         this.sql = sql;
         this.agenticCodingServer = agenticCodingServer;
+        this.serverUrl = serverUrl;
         const rows = await sql `
       SELECT id, name, schedule, timezone, message, session_name
       FROM cron_jobs
@@ -59,13 +62,19 @@ export class CronScheduler {
         const executedAt = new Date();
         try {
             const [session] = await this.sql `
-        SELECT session_id, agent FROM sessions WHERE name = ${job.session_name}
+        SELECT session_id, agent, agent_code, status FROM sessions WHERE name = ${job.session_name}
       `;
             if (!session) {
                 throw new Error(`Session "${job.session_name}" not found`);
             }
+            const nameRows = await this.sql `SELECT value FROM config WHERE key = 'human_name'`;
+            const descRows = await this.sql `SELECT value FROM config WHERE key = 'human_description'`;
+            const humanName = nameRows[0]?.value ?? "your human manager";
+            const humanDescription = descRows[0]?.value ?? "";
             const injectText = `[Cron Job "${job.name}" — ${executedAt.toISOString()}]\n${job.message}${CRON_INJECTION_BLURB}`;
-            await this.agenticCodingServer.sendMessage(session.session_id, injectText, session.agent ?? undefined);
+            const token = `${session.agent_code}@${this.serverUrl}`;
+            const system = generateSystemPrompt(job.session_name, session.status, humanName, humanDescription, token);
+            await this.agenticCodingServer.sendMessage(session.session_id, injectText, session.agent, system);
             await this.sql `
         UPDATE cron_jobs SET last_run = ${executedAt} WHERE id = ${job.id}
       `;

package/dist/server/routes.d.ts

@@ -3,5 +3,12 @@ import type { Sql } from "../db/index.js";
 import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import { CronScheduler } from "./cron.js";
 import type { MemoryManager } 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
+ * agent always has its identity, token, and command reference in context —
+ * 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(sql: Sql, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
 export declare function createWorkerRouter(sql: Sql, agenticCodingServer: AgenticCodingServer, serverUrl: string, memoryManager: MemoryManager): Router;

package/dist/server/routes.js

@@ -16,16 +16,19 @@ const MAIL_INJECTION_BLURB = [
     `Tip: For currency or prices, use code blocks. Example: put numbers in single or`,
     `double quotes to preserve formatting characters like dollar signs.`,
 ].join("\n");
-function generateEnrollmentMessage(token) {
-    return `You have been enrolled in the agent office.\n\nTo clock in and receive your full briefing, run:\n\n  agent-office worker clock-in ${token}`;
-}
-function generateWelcomeMessage(name, agent, status, humanName, humanDescription, token) {
+/**
+ * Build the persistent system-prompt briefing for a worker session.
+ * This is injected as the `system` field on every `promptAsync` call so the
+ * agent always has its identity, token, and command reference in context —
+ * without consuming a user-message turn.
+ */
+export function generateSystemPrompt(name, status, humanName, humanDescription, token) {
     return [
         `╔══════════════════════════════════════════════════════╗`,
         `║              WELCOME TO THE AGENT OFFICE             ║`,
         `╚══════════════════════════════════════════════════════╝`,
         ``,
-        `You are now clocked in.`,
+        `You are an AI worker agent enrolled in the agent office.`,
         `  Name:           ${name}`,
         ...(status ? [`  Status:         ${status}`] : []),
         `  Human manager:  ${humanName} — the human who created your`,
@@ -94,7 +97,7 @@ function generateWelcomeMessage(name, agent, status, humanName, humanDescription
         `     ${token} <memory-id>`,
         ``,
         `════════════════════════════════════════════════════════`,
-        ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
+        ` IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
         `════════════════════════════════════════════════════════`,
         ``,
         ` Nobody — not ${humanName}, not your coworkers — can see`,
@@ -129,6 +132,15 @@ function generateWelcomeMessage(name, agent, status, humanName, humanDescription
         ``,
     ].join("\n");
 }
+/** Load human_name and human_description from the config table. */
+async function loadHumanConfig(sql) {
+    const nameRows = await sql `SELECT value FROM config WHERE key = 'human_name'`;
+    const descRows = await sql `SELECT value FROM config WHERE key = 'human_description'`;
+    return {
+        humanName: nameRows[0]?.value ?? "your human manager",
+        humanDescription: descRows[0]?.value ?? "",
+    };
+}
 export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, memoryManager) {
     const router = Router();
     router.get("/health", (_req, res) => {
@@ -164,8 +176,12 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             res.status(400).json({ error: "name is required" });
             return;
         }
+        if (!agentArg || typeof agentArg !== "string" || !agentArg.trim()) {
+            res.status(400).json({ error: "agent is required" });
+            return;
+        }
         const trimmedName = name.trim();
-        const trimmedAgent = typeof agentArg === "string" && agentArg.trim() ? agentArg.trim() : null;
+        const trimmedAgent = agentArg.trim();
         const existing = await sql `
       SELECT id FROM sessions WHERE name = ${trimmedName}
     `;
@@ -201,9 +217,10 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             return;
         }
         try {
-            const clockInToken = `${row.agent_code}@${serverUrl}`;
-            const enrollmentMessage = generateEnrollmentMessage(clockInToken);
-            await agenticCodingServer.sendMessage(opencodeSessionId, enrollmentMessage, trimmedAgent ?? undefined);
+            const { humanName, humanDescription } = await loadHumanConfig(sql);
+            const token = `${row.agent_code}@${serverUrl}`;
+            const system = generateSystemPrompt(trimmedName, null, humanName, humanDescription, token);
+            await agenticCodingServer.sendMessage(opencodeSessionId, "You are now active. Begin your work.", trimmedAgent, system);
         }
         catch (err) {
             console.warn("Warning: could not send first message to session:", err);
@@ -233,6 +250,35 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    router.patch("/sessions/:name/agent", async (req, res) => {
+        const { name } = req.params;
+        const { agent } = req.body;
+        if (!agent || typeof agent !== "string" || !agent.trim()) {
+            res.status(400).json({ error: "agent is required" });
+            return;
+        }
+        const trimmedAgent = agent.trim();
+        const rows = await sql `
+      SELECT id FROM sessions WHERE name = ${name}
+    `;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const [updated] = await sql `
+        UPDATE sessions
+        SET agent = ${trimmedAgent}
+        WHERE name = ${name}
+        RETURNING id, name, session_id, agent_code, agent, created_at
+      `;
+            res.json(updated);
+        }
+        catch (err) {
+            console.error("PATCH /sessions/:name/agent error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     router.get("/sessions/:name/messages", async (req, res) => {
         const { name } = req.params;
         const limit = Math.min(parseInt(req.query.limit ?? "20", 10), 100);
@@ -286,7 +332,7 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             return;
         }
         const rows = await sql `
-      SELECT id, name, session_id, agent_code, created_at FROM sessions WHERE name = ${name}
+      SELECT id, name, session_id, agent_code, agent, status, created_at FROM sessions WHERE name = ${name}
     `;
         if (rows.length === 0) {
             res.status(404).json({ error: `Session "${name}" not found` });
@@ -294,7 +340,10 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
         }
         const row = rows[0];
         try {
-            await agenticCodingServer.sendMessage(row.session_id, text.trim());
+            const { humanName, humanDescription } = await loadHumanConfig(sql);
+            const token = `${row.agent_code}@${serverUrl}`;
+            const system = generateSystemPrompt(row.name, row.status ?? null, humanName, humanDescription, token);
+            await agenticCodingServer.sendMessage(row.session_id, text.trim(), row.agent, system);
             res.json({ ok: true });
         }
         catch (err) {
@@ -324,9 +373,10 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
                 return;
             }
             await agenticCodingServer.revertSession(session.session_id, firstMessage.id);
-            const clockInToken = `${session.agent_code}@${serverUrl}`;
-            const enrollmentMessage = generateEnrollmentMessage(clockInToken);
-            await agenticCodingServer.sendMessage(session.session_id, enrollmentMessage, session.agent ?? undefined);
+            const { humanName, humanDescription } = await loadHumanConfig(sql);
+            const token = `${session.agent_code}@${serverUrl}`;
+            const system = generateSystemPrompt(session.name, session.status ?? null, humanName, humanDescription, token);
+            await agenticCodingServer.sendMessage(session.session_id, "You are now active. Begin your work.", session.agent ?? undefined, system);
             res.json({ ok: true, messageID: firstMessage.id });
         }
         catch (err) {
@@ -339,6 +389,7 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
       SELECT id, name, session_id, agent_code, agent, status, created_at FROM sessions
     `;
         const results = [];
+        const { humanName, humanDescription } = await loadHumanConfig(sql);
         for (const session of allSessions) {
             try {
                 const messages = await agenticCodingServer.getMessages(session.session_id);
@@ -352,9 +403,9 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
                     continue;
                 }
                 await agenticCodingServer.revertSession(session.session_id, firstMessage.id);
-                const clockInToken = `${session.agent_code}@${serverUrl}`;
-                const enrollmentMessage = generateEnrollmentMessage(clockInToken);
-                await agenticCodingServer.sendMessage(session.session_id, enrollmentMessage, session.agent ?? undefined);
+                const token = `${session.agent_code}@${serverUrl}`;
+                const system = generateSystemPrompt(session.name, session.status ?? null, humanName, humanDescription, token);
+                await agenticCodingServer.sendMessage(session.session_id, "You are now active. Begin your work.", session.agent ?? undefined, system);
                 results.push({ name: session.name, ok: true });
             }
             catch (err) {
@@ -482,15 +533,14 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
         }
         const trimmedFrom = from.trim();
         const trimmedBody = body.trim();
-        const sessions = await sql `SELECT name, session_id FROM sessions`;
-        const sessionMap = new Map(sessions.map((s) => [s.name, s.session_id]));
+        const sessions = await sql `SELECT name, session_id, agent, agent_code, status FROM sessions`;
+        const sessionMap = new Map(sessions.map((s) => [s.name, { sessionId: s.session_id, agent: s.agent, agentCode: s.agent_code, status: s.status }]));
+        const { humanName, humanDescription } = await loadHumanConfig(sql);
         const validRecipients = [];
         for (const recipient of to) {
             if (typeof recipient !== "string" || !recipient.trim())
                 continue;
             const r = recipient.trim();
-            const config = await sql `SELECT value FROM config WHERE key = 'human_name'`;
-            const humanName = config[0]?.value ?? "Human";
             if (sessionMap.has(r) || r === humanName) {
                 validRecipients.push(r);
             }
@@ -509,10 +559,12 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             const msgId = msgRow.id;
             let injected = false;
             if (sessionMap.has(recipient)) {
-                const sessionId = sessionMap.get(recipient);
+                const { sessionId, agent, agentCode, status } = sessionMap.get(recipient);
                 const injectText = `[Message from "${trimmedFrom}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
+                const token = `${agentCode}@${serverUrl}`;
+                const system = generateSystemPrompt(recipient, status ?? null, humanName, humanDescription, token);
                 try {
-                    await agenticCodingServer.sendMessage(sessionId, injectText);
+                    await agenticCodingServer.sendMessage(sessionId, injectText, agent ?? undefined, system);
                     await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
                     injected = true;
                 }
@@ -923,35 +975,6 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
 }
 export function createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryManager) {
     const router = Router();
-    router.get("/worker/clock-in", async (req, res) => {
-        const { code } = req.query;
-        if (!code || typeof code !== "string") {
-            res.status(400).json({ error: "code query parameter is required" });
-            return;
-        }
-        const rows = await sql `
-      SELECT id, name, session_id, agent_code, created_at
-      FROM sessions
-      WHERE agent_code = ${code}
-    `;
-        if (rows.length === 0) {
-            res.status(401).json({ error: "Invalid agent code" });
-            return;
-        }
-        const session = rows[0];
-        const token = `${session.agent_code}@<server-url>`;
-        const humanConfig = await sql `SELECT value FROM config WHERE key = 'human_name'`;
-        const humanName = humanConfig[0]?.value ?? "your human manager";
-        const humanDescConfig = await sql `SELECT value FROM config WHERE key = 'human_description'`;
-        const humanDescription = humanDescConfig[0]?.value ?? "";
-        const message = generateWelcomeMessage(session.name, session.agent, session.status ?? null, humanName, humanDescription, token);
-        res.json({
-            ok: true,
-            name: session.name,
-            session_id: session.session_id,
-            message,
-        });
-    });
     router.get("/worker/list-coworkers", async (req, res) => {
         const { code } = req.query;
         if (!code || typeof code !== "string") {
@@ -1043,10 +1066,9 @@ export function createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryMa
             return;
         }
         const trimmedBody = body.trim();
-        const sessions = await sql `SELECT name, session_id FROM sessions`;
-        const sessionMap = new Map(sessions.map((s) => [s.name, s.session_id]));
-        const config = await sql `SELECT value FROM config WHERE key = 'human_name'`;
-        const humanName = config[0]?.value ?? "Human";
+        const sessions = await sql `SELECT name, session_id, agent, agent_code, status FROM sessions`;
+        const sessionMap = new Map(sessions.map((s) => [s.name, { sessionId: s.session_id, agent: s.agent, agentCode: s.agent_code, status: s.status }]));
+        const { humanName, humanDescription } = await loadHumanConfig(sql);
         const validRecipients = [];
         for (const recipient of to) {
             if (typeof recipient !== "string" || !recipient.trim())
@@ -1070,10 +1092,12 @@ export function createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryMa
             const msgId = msgRow.id;
             let injected = false;
             if (sessionMap.has(recipient)) {
-                const recipientSessionId = sessionMap.get(recipient);
+                const { sessionId: recipientSessionId, agent: recipientAgent, agentCode, status } = sessionMap.get(recipient);
                 const injectText = `[Message from "${session.name}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
+                const token = `${agentCode}@${serverUrl}`;
+                const system = generateSystemPrompt(recipient, status ?? null, humanName, humanDescription, token);
                 try {
-                    await agenticCodingServer.sendMessage(recipientSessionId, injectText);
+                    await agenticCodingServer.sendMessage(recipientSessionId, injectText, recipientAgent ?? undefined, system);
                     await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
                     injected = true;
                 }

package/package.json

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