agent-office 0.0.15 → 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/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  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,
+            system,
         });
     }
     async getMessages(sessionID, limit) {

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);
+            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) => {
@@ -205,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);
+            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);
@@ -319,7 +332,7 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             return;
         }
         const rows = await sql `
-      SELECT id, name, session_id, agent_code, agent, 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` });
@@ -327,7 +340,10 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
         }
         const row = rows[0];
         try {
-            await agenticCodingServer.sendMessage(row.session_id, text.trim(), row.agent);
+            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) {
@@ -357,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) {
@@ -372,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);
@@ -385,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) {
@@ -515,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, agent FROM sessions`;
-        const sessionMap = new Map(sessions.map((s) => [s.name, { sessionId: s.session_id, agent: s.agent }]));
+        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);
             }
@@ -542,10 +559,12 @@ export function createRouter(sql, agenticCodingServer, serverUrl, scheduler, mem
             const msgId = msgRow.id;
             let injected = false;
             if (sessionMap.has(recipient)) {
-                const { sessionId, agent } = 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, agent ?? undefined);
+                    await agenticCodingServer.sendMessage(sessionId, injectText, agent ?? undefined, system);
                     await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`;
                     injected = true;
                 }
@@ -956,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") {
@@ -1076,10 +1066,9 @@ export function createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryMa
             return;
         }
         const trimmedBody = body.trim();
-        const sessions = await sql `SELECT name, session_id, agent FROM sessions`;
-        const sessionMap = new Map(sessions.map((s) => [s.name, { sessionId: s.session_id, agent: s.agent }]));
-        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())
@@ -1103,10 +1092,12 @@ export function createWorkerRouter(sql, agenticCodingServer, serverUrl, memoryMa
             const msgId = msgRow.id;
             let injected = false;
             if (sessionMap.has(recipient)) {
-                const { sessionId: recipientSessionId, agent: recipientAgent } = 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, recipientAgent ?? undefined);
+                    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.15",
+  "version": "0.0.16",
   "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",