agent-office 0.0.1 → 0.0.3

package/dist/server/routes.js

@@ -1,13 +1,141 @@
 import { Router } from "express";
-export function createRouter(sql, opencode, serverUrl) {
+import { Cron as CronerInstance } from "croner";
+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.`,
+].join("\n");
+function generateWelcomeMessage(name, mode, status, humanName, humanDescription, token) {
+    return [
+        `╔══════════════════════════════════════════════════════╗`,
+        `║              WELCOME TO THE AGENT OFFICE             ║`,
+        `╚══════════════════════════════════════════════════════╝`,
+        ``,
+        `You are now clocked in.`,
+        `  Name:           ${name}`,
+        ...(mode ? [`  Mode:           ${mode}`] : []),
+        ...(status ? [`  Status:         ${status}`] : []),
+        `  Human manager:  ${humanName} — the human who created your`,
+        `                  session, assigns your work, and is your`,
+        `                  primary point of contact for questions,`,
+        `                  updates, and decisions.`,
+        ...(humanDescription ? [
+            `                  "${humanDescription}"`,
+        ] : []),
+        ``,
+        `The agent-office CLI is your PRIMARY means of communicating`,
+        `with your human manager (${humanName}) and your coworkers.`,
+        `Use it to send and receive messages, and to discover who`,
+        `else is working.`,
+        ``,
+        `════════════════════════════════════════════════════════`,
+        ` AVAILABLE COMMANDS`,
+        `════════════════════════════════════════════════════════`,
+        ``,
+        ` List your coworkers`,
+        `   agent-office worker list-coworkers \\`,
+        `     ${token}`,
+        ``,
+        ` Set your public status (visible to coworkers and manager)`,
+        `   agent-office worker set-status \\`,
+        `     --status "your status here" \\`,
+        `     ${token}`,
+        ``,
+        ` Clear your public status`,
+        `   agent-office worker set-status \\`,
+        `     --clear \\`,
+        `     ${token}`,
+        ``,
+        ` Send a message to your manager or a coworker`,
+        `   agent-office worker send-message \\`,
+        `     --name <recipient-name> \\`,
+        `     --body "Your message here" \\`,
+        `     ${token}`,
+        ``,
+        ` Send a message to multiple recipients at once`,
+        `   agent-office worker send-message \\`,
+        `     --name alice --name bob \\`,
+        `     --body "Your message here" \\`,
+        `     ${token}`,
+        ``,
+        ` Manage scheduled tasks (optional)`,
+        `   agent-office worker cron \\`,
+        `     ${token}`,
+        ``,
+        `════════════════════════════════════════════════════════`,
+        ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
+        `════════════════════════════════════════════════════════`,
+        ``,
+        ` Nobody — not ${humanName}, not your coworkers — can see`,
+        ` anything you think, reason, or write inside this session.`,
+        ` Your work is completely private until you explicitly send`,
+        ` a message using the send-message command.`,
+        ``,
+        ` This means:`,
+        `   • You must send a message to report progress or ask`,
+        `     for help. Silence looks like inaction.`,
+        `   • Finishing a task without messaging ${humanName}`,
+        `     means they will never know it is done.`,
+        `   • If you are blocked or uncertain, send a message —`,
+        `     nobody will know otherwise.`,
+        ``,
+        `════════════════════════════════════════════════════════`,
+        ` TIPS`,
+        `════════════════════════════════════════════════════════`,
+        ``,
+        ` - Run list-coworkers to discover who is available and`,
+        `   what their names are before sending messages.`,
+        ` - Messages you send are delivered directly into the`,
+        `   recipient's active session — they will see them`,
+        `   immediately.`,
+        ` - Your human manager is ${humanName}. They can send you`,
+        `   messages at any time and those will appear here in`,
+        `   your session just like this one. You can reach them`,
+        `   by sending a message to --name ${humanName}.`,
+        ` - Optional: Set up recurring scheduled tasks with cron`,
+        `   jobs. Run 'agent-office worker cron list ${token}' to`,
+        `   get started.`,
+        ``,
+    ].join("\n");
+}
+export function createRouter(sql, opencode, serverUrl, scheduler) {
     const router = Router();
     router.get("/health", (_req, res) => {
         res.json({ ok: true });
     });
+    router.get("/modes", async (_req, res) => {
+        try {
+            const config = await opencode.config.get();
+            const agent = config.agent ?? {};
+            const modes = Object.entries(agent)
+                .filter(([, val]) => val != null)
+                .map(([name, val]) => ({
+                name,
+                description: val.description ?? "",
+                model: val.model ?? "",
+            }));
+            res.json(modes);
+        }
+        catch (err) {
+            console.error("GET /modes error:", err);
+            res.json([]);
+        }
+    });
     router.get("/sessions", async (_req, res) => {
         try {
             const rows = await sql `
-        SELECT id, name, session_id, agent_code, created_at
+        SELECT id, name, session_id, agent_code, mode, status, created_at
         FROM sessions
         ORDER BY created_at DESC
       `;
@@ -19,12 +147,13 @@ export function createRouter(sql, opencode, serverUrl) {
         }
     });
     router.post("/sessions", async (req, res) => {
-        const { name } = req.body;
+        const { name, mode } = req.body;
         if (!name || typeof name !== "string" || !name.trim()) {
             res.status(400).json({ error: "name is required" });
             return;
         }
         const trimmedName = name.trim();
+        const trimmedMode = typeof mode === "string" && mode.trim() ? mode.trim() : null;
         const existing = await sql `
       SELECT id FROM sessions WHERE name = ${trimmedName}
     `;
@@ -45,9 +174,9 @@ export function createRouter(sql, opencode, serverUrl) {
         let row;
         try {
             const [inserted] = await sql `
-        INSERT INTO sessions (name, session_id)
-        VALUES (${trimmedName}, ${opencodeSessionId})
-        RETURNING id, name, session_id, agent_code, created_at
+        INSERT INTO sessions (name, session_id, mode)
+        VALUES (${trimmedName}, ${opencodeSessionId}, ${trimmedMode})
+        RETURNING id, name, session_id, agent_code, mode, created_at
       `;
             row = inserted;
         }
@@ -65,11 +194,12 @@ export function createRouter(sql, opencode, serverUrl) {
             const defaultEntry = Object.entries(providers.default)[0];
             if (defaultEntry) {
                 const clockInToken = `${row.agent_code}@${serverUrl}`;
-                const firstMessage = `Run \`agent-office worker clock-in ${clockInToken}\``;
+                const enrollmentMessage = `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 ${clockInToken}`;
                 await opencode.session.chat(opencodeSessionId, {
                     modelID: defaultEntry[0],
                     providerID: defaultEntry[1],
-                    parts: [{ type: "text", text: firstMessage }],
+                    parts: [{ type: "text", text: enrollmentMessage }],
+                    ...(trimmedMode ? { mode: trimmedMode } : {}),
                 });
             }
         }
@@ -118,9 +248,26 @@ export function createRouter(sql, opencode, serverUrl) {
                 .slice(-limit)
                 .map((m) => ({
                 role: m.info.role,
-                parts: m.parts
-                    .filter((p) => p.type === "text")
-                    .map((p) => ({ type: "text", text: p.text })),
+                parts: m.parts.map((p) => {
+                    const part = p;
+                    if (part.type === "text") {
+                        return { type: "text", text: part.text ?? "" };
+                    }
+                    else if (part.type === "tool") {
+                        // Extract tool name, input, and output from the tool state
+                        const state = part.state;
+                        return {
+                            type: "tool",
+                            tool: part.tool,
+                            input: state?.input,
+                            output: state?.output,
+                            data: part,
+                        };
+                    }
+                    else {
+                        return { type: part.type, data: part };
+                    }
+                }),
             }))
                 .filter((m) => m.parts.length > 0);
             res.json(result);
@@ -177,6 +324,48 @@ export function createRouter(sql, opencode, serverUrl) {
             res.status(502).json({ error: "Failed to inject message into OpenCode session", detail: String(err) });
         }
     });
+    router.post("/sessions/:name/revert-to-start", async (req, res) => {
+        const { name } = req.params;
+        const rows = await sql `
+      SELECT id, name, session_id, agent_code, mode, status, created_at FROM sessions WHERE name = ${name}
+    `;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        const session = rows[0];
+        try {
+            const messages = await opencode.session.messages(session.session_id);
+            if (messages.length === 0) {
+                res.status(400).json({ error: "Session has no messages to revert to" });
+                return;
+            }
+            const firstMessage = messages[0];
+            if (!firstMessage || !firstMessage.info || !firstMessage.info.id) {
+                res.status(500).json({ error: "Failed to get first message ID" });
+                return;
+            }
+            await opencode.session.revert(session.session_id, { messageID: firstMessage.info.id });
+            const providers = await opencode.app.providers();
+            const defaultEntry = Object.entries(providers.default)[0];
+            if (!defaultEntry) {
+                res.status(502).json({ error: "No default model configured in OpenCode" });
+                return;
+            }
+            const clockInToken = `${session.agent_code}@${serverUrl}`;
+            const enrollmentMessage = `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 ${clockInToken}`;
+            await opencode.session.chat(session.session_id, {
+                modelID: defaultEntry[0],
+                providerID: defaultEntry[1],
+                parts: [{ type: "text", text: enrollmentMessage }],
+            });
+            res.json({ ok: true, messageID: firstMessage.info.id });
+        }
+        catch (err) {
+            console.error("POST /sessions/:name/revert-to-start error:", err);
+            res.status(502).json({ error: "Failed to revert session", detail: String(err) });
+        }
+    });
     router.delete("/sessions/:name", async (req, res) => {
         const { name } = req.params;
         const rows = await sql `
@@ -321,23 +510,21 @@ export function createRouter(sql, opencode, serverUrl) {
       `;
             if (sessionMap.has(recipient)) {
                 const sessionId = sessionMap.get(recipient);
-                try {
-                    const providers = await opencode.app.providers();
+                const msgId = msgRow.id;
+                injected = true;
+                opencode.app.providers().then((providers) => {
                     const defaultEntry = Object.entries(providers.default)[0];
-                    if (defaultEntry) {
-                        const injectText = `[Message from "${trimmedFrom}"]: ${trimmedBody}`;
-                        await opencode.session.chat(sessionId, {
-                            modelID: defaultEntry[0],
-                            providerID: defaultEntry[1],
-                            parts: [{ type: "text", text: injectText }],
-                        });
-                        injected = true;
-                        await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgRow.id}`;
-                    }
-                }
-                catch (err) {
+                    if (!defaultEntry)
+                        return;
+                    const injectText = `[Message from "${trimmedFrom}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
+                    return opencode.session.chat(sessionId, {
+                        modelID: defaultEntry[0],
+                        providerID: defaultEntry[1],
+                        parts: [{ type: "text", text: injectText }],
+                    }).then(() => sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`);
+                }).catch((err) => {
                     console.warn(`Warning: could not inject message into session ${recipient}:`, err);
-                }
+                });
             }
             results.push({ to: recipient, messageId: msgRow.id, injected });
         }
@@ -365,6 +552,253 @@ export function createRouter(sql, opencode, serverUrl) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    // ── Cron Jobs Endpoints ────────────────────────────────────────────────────
+    router.get("/crons", async (req, res) => {
+        try {
+            const { session_name } = req.query;
+            let rows;
+            if (session_name) {
+                rows = await sql `
+          SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+          FROM cron_jobs
+          WHERE session_name = ${session_name}
+          ORDER BY name
+        `;
+            }
+            else {
+                rows = await sql `
+          SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+          FROM cron_jobs
+          ORDER BY name
+        `;
+            }
+            const jobs = rows.map((job) => {
+                let nextRun = null;
+                if (job.enabled) {
+                    try {
+                        const options = {};
+                        if (job.timezone)
+                            options.timezone = job.timezone;
+                        const cronJob = new CronerInstance(job.schedule, options);
+                        const next = cronJob.nextRun();
+                        nextRun = next ? next.toISOString() : null;
+                    }
+                    catch { }
+                }
+                return { ...job, next_run: nextRun, last_run: job.last_run ? job.last_run.toISOString() : null, created_at: job.created_at.toISOString() };
+            });
+            res.json(jobs);
+        }
+        catch (err) {
+            console.error("GET /crons error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/crons", async (req, res) => {
+        const { name, session_name, schedule, message, timezone } = req.body;
+        if (!name || typeof name !== "string" || !name.trim()) {
+            res.status(400).json({ error: "name is required" });
+            return;
+        }
+        if (!session_name || typeof session_name !== "string") {
+            res.status(400).json({ error: "session_name is required" });
+            return;
+        }
+        if (!schedule || typeof schedule !== "string" || !schedule.trim()) {
+            res.status(400).json({ error: "schedule is required" });
+            return;
+        }
+        if (!message || typeof message !== "string" || !message.trim()) {
+            res.status(400).json({ error: "message is required" });
+            return;
+        }
+        const trimmedName = name.trim();
+        const trimmedSchedule = schedule.trim();
+        const trimmedMessage = message.trim();
+        try {
+            new CronerInstance(trimmedSchedule);
+        }
+        catch {
+            res.status(400).json({ error: "Invalid cron schedule expression" });
+            return;
+        }
+        if (timezone) {
+            try {
+                new CronerInstance("0 0 * * *", { timezone });
+            }
+            catch {
+                res.status(400).json({ error: "Invalid timezone" });
+                return;
+            }
+        }
+        const [existing] = await sql `
+      SELECT id FROM cron_jobs WHERE name = ${trimmedName} AND session_name = ${session_name}
+    `;
+        if (existing) {
+            res.status(409).json({ error: `Cron job "${trimmedName}" already exists for this session` });
+            return;
+        }
+        try {
+            const [inserted] = await sql `
+        INSERT INTO cron_jobs (name, session_name, schedule, timezone, message)
+        VALUES (${trimmedName}, ${session_name}, ${trimmedSchedule}, ${timezone ?? null}, ${trimmedMessage})
+        RETURNING id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+      `;
+            const cronJobrow = inserted;
+            scheduler.addCronJob(cronJobrow);
+            const nextRun = cronJobrow.enabled ? (() => {
+                try {
+                    const options = {};
+                    if (cronJobrow.timezone)
+                        options.timezone = cronJobrow.timezone;
+                    const cronJob = new CronerInstance(cronJobrow.schedule, options);
+                    const next = cronJob.nextRun();
+                    return next ? next.toISOString() : null;
+                }
+                catch {
+                    return null;
+                }
+            })() : null;
+            res.status(201).json({
+                ...cronJobrow,
+                next_run: nextRun,
+                last_run: cronJobrow?.last_run?.toISOString() ?? null,
+                created_at: cronJobrow.created_at.toISOString(),
+            });
+        }
+        catch (err) {
+            console.error("POST /crons error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.delete("/crons/:id", async (req, res) => {
+        const id = parseInt(req.params.id, 10);
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        try {
+            const [job] = await sql `SELECT id, name FROM cron_jobs WHERE id = ${id}`;
+            if (!job) {
+                res.status(404).json({ error: "Cron job not found" });
+                return;
+            }
+            scheduler.removeCronJob(id);
+            await sql `DELETE FROM cron_jobs WHERE id = ${id}`;
+            res.json({ deleted: true, id, name: job.name });
+        }
+        catch (err) {
+            console.error("DELETE /crons/:id error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/crons/:id/enable", async (req, res) => {
+        const id = parseInt(req.params.id, 10);
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        try {
+            const [existing] = await sql `
+        SELECT id, name FROM cron_jobs WHERE id = ${id}
+      `;
+            if (!existing) {
+                res.status(404).json({ error: "Cron job not found" });
+                return;
+            }
+            await sql `UPDATE cron_jobs SET enabled = TRUE WHERE id = ${id}`;
+            const [updated] = await sql `
+        SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+        FROM cron_jobs WHERE id = ${id}
+      `;
+            if (updated) {
+                scheduler.enableCronJob(updated);
+                const nextRun = (() => {
+                    try {
+                        const options = {};
+                        if (updated.timezone)
+                            options.timezone = updated.timezone;
+                        const cronJob = new CronerInstance(updated.schedule, options);
+                        const next = cronJob.nextRun();
+                        return next ? next.toISOString() : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                res.json({
+                    ...updated,
+                    next_run: nextRun,
+                    last_run: updated.last_run?.toISOString() ?? null,
+                    created_at: updated.created_at.toISOString(),
+                });
+            }
+            else {
+                res.status(404).json({ error: "Cron job not found" });
+            }
+        }
+        catch (err) {
+            console.error("POST /crons/:id/enable error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/crons/:id/disable", async (req, res) => {
+        const id = parseInt(req.params.id, 10);
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        try {
+            const [job] = await sql `
+        SELECT id, name FROM cron_jobs WHERE id = ${id}
+      `;
+            if (!job) {
+                res.status(404).json({ error: "Cron job not found" });
+                return;
+            }
+            await sql `UPDATE cron_jobs SET enabled = FALSE WHERE id = ${id}`;
+            scheduler.disableCronJob(id);
+            const [updated] = await sql `
+        SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+        FROM cron_jobs WHERE id = ${id}
+      `;
+            res.json({
+                ...updated,
+                next_run: null,
+                last_run: updated?.last_run?.toISOString() ?? null,
+                created_at: updated?.created_at.toISOString() ?? null,
+            });
+        }
+        catch (err) {
+            console.error("POST /crons/:id/disable error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.get("/crons/:id/history", async (req, res) => {
+        const id = parseInt(req.params.id, 10);
+        const limit = Math.min(parseInt(req.query.limit ?? "10", 10), 100);
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        try {
+            const rows = await sql `
+        SELECT id, cron_job_id, executed_at, success, error_message
+        FROM cron_history
+        WHERE cron_job_id = ${id}
+        ORDER BY executed_at DESC
+        LIMIT ${limit}
+      `;
+            res.json(rows.map((r) => ({
+                ...r,
+                executed_at: r.executed_at.toISOString(),
+            })));
+        }
+        catch (err) {
+            console.error("GET /crons/:id/history error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     return router;
 }
 export function createWorkerRouter(sql, opencode, serverUrl) {
@@ -385,11 +819,97 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             return;
         }
         const session = rows[0];
+        const token = `${session.agent_code}@<server-url>`;
+        const name = session.name;
+        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 = [
+            `╔══════════════════════════════════════════════════════╗`,
+            `║              WELCOME TO THE AGENT OFFICE             ║`,
+            `╚══════════════════════════════════════════════════════╝`,
+            ``,
+            `You are now clocked in.`,
+            `  Name:           ${name}`,
+            ...(session.mode ? [`  Mode:           ${session.mode}`] : []),
+            `  Human manager:  ${humanName} — the human who created your`,
+            `                  session, assigns your work, and is your`,
+            `                  primary point of contact for questions,`,
+            `                  updates, and decisions.`,
+            ...(humanDescription ? [
+                `                  "${humanDescription}"`,
+            ] : []),
+            ``,
+            `The agent-office CLI is your PRIMARY means of communicating`,
+            `with your human manager (${humanName}) and your coworkers.`,
+            `Use it to send and receive messages, and to discover who`,
+            `else is working.`,
+            ``,
+            `════════════════════════════════════════════════════════`,
+            ` AVAILABLE COMMANDS`,
+            `════════════════════════════════════════════════════════`,
+            ``,
+            ` List your coworkers`,
+            `   agent-office worker list-coworkers \\`,
+            `     ${token}`,
+            ``,
+            ` Send a message to your manager or a coworker`,
+            `   agent-office worker send-message \\`,
+            `     --name <recipient-name> \\`,
+            `     --body "Your message here" \\`,
+            `     ${token}`,
+            ``,
+            ` Send a message to multiple recipients at once`,
+            `   agent-office worker send-message \\`,
+            `     --name alice --name bob \\`,
+            `     --body "Your message here" \\`,
+            `     ${token}`,
+            ``,
+            ` Manage scheduled tasks (optional)`,
+            `   agent-office worker cron \\`,
+            `     ${token}`,
+            ``,
+            `════════════════════════════════════════════════════════`,
+            ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
+            `════════════════════════════════════════════════════════`,
+            ``,
+            ` Nobody — not ${humanName}, not your coworkers — can see`,
+            ` anything you think, reason, or write inside this session.`,
+            ` Your work is completely private until you explicitly send`,
+            ` a message using the send-message command.`,
+            ``,
+            ` This means:`,
+            `   • You must send a message to report progress or ask`,
+            `     for help. Silence looks like inaction.`,
+            `   • Finishing a task without messaging ${humanName}`,
+            `     means they will never know it is done.`,
+            `   • If you are blocked or uncertain, send a message —`,
+            `     nobody will know otherwise.`,
+            ``,
+            `════════════════════════════════════════════════════════`,
+            ` TIPS`,
+            `════════════════════════════════════════════════════════`,
+            ``,
+            ` - Run list-coworkers to discover who is available and`,
+            `   what their names are before sending messages.`,
+            ` - Messages you send are delivered directly into the`,
+            `   recipient's active session — they will see them`,
+            `   immediately.`,
+            ` - Your human manager is ${humanName}. They can send you`,
+            `   messages at any time and those will appear here in`,
+            `   your session just like this one. You can reach them`,
+            `   by sending a message to --name ${humanName}.`,
+            ` - Optional: Set up recurring scheduled tasks with cron`,
+            `   jobs. Run 'agent-office worker cron list ${token}' to`,
+            `   get started.`,
+            ``,
+        ].join("\n");
         res.json({
             ok: true,
             name: session.name,
             session_id: session.session_id,
-            message: `Welcome to the agent office, your name is ${session.name}. Your OpenCode session ID is ${session.session_id}. You are now clocked in and ready to work.`,
+            message,
         });
     });
     router.get("/worker/list-coworkers", async (req, res) => {
@@ -421,6 +941,42 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    router.post("/worker/set-status", async (req, res) => {
+        const { code } = req.query;
+        const { status } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const trimmedStatus = status === null ? null : (status === undefined ? null : status.trim());
+        if (trimmedStatus !== null && trimmedStatus.length > 140) {
+            res.status(400).json({ error: "status must be at most 140 characters" });
+            return;
+        }
+        const rows = await sql `
+      SELECT id, name, session_id, agent_code, mode, status, 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];
+        try {
+            await sql `
+        UPDATE sessions
+        SET status = ${trimmedStatus}
+        WHERE agent_code = ${code}
+      `;
+        }
+        catch (err) {
+            console.error("POST /worker/set-status error:", err);
+            res.status(500).json({ error: "Internal server error" });
+            return;
+        }
+        res.json({ ok: true, name: session.name, status: trimmedStatus });
+    });
     router.post("/worker/send-message", async (req, res) => {
         const { code } = req.query;
         const { to, body } = req.body;
@@ -474,27 +1030,345 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
       `;
             if (sessionMap.has(recipient)) {
                 const recipientSessionId = sessionMap.get(recipient);
-                try {
-                    const providers = await opencode.app.providers();
+                const msgId = msgRow.id;
+                injected = true;
+                opencode.app.providers().then((providers) => {
                     const defaultEntry = Object.entries(providers.default)[0];
-                    if (defaultEntry) {
-                        const injectText = `[Message from "${session.name}"]: ${trimmedBody}`;
-                        await opencode.session.chat(recipientSessionId, {
-                            modelID: defaultEntry[0],
-                            providerID: defaultEntry[1],
-                            parts: [{ type: "text", text: injectText }],
-                        });
-                        injected = true;
-                        await sql `UPDATE messages SET injected = TRUE WHERE id = ${msgRow.id}`;
-                    }
-                }
-                catch (err) {
+                    if (!defaultEntry)
+                        return;
+                    const injectText = `[Message from "${session.name}"]: ${trimmedBody}${MAIL_INJECTION_BLURB}`;
+                    return opencode.session.chat(recipientSessionId, {
+                        modelID: defaultEntry[0],
+                        providerID: defaultEntry[1],
+                        parts: [{ type: "text", text: injectText }],
+                    }).then(() => sql `UPDATE messages SET injected = TRUE WHERE id = ${msgId}`);
+                }).catch((err) => {
                     console.warn(`Warning: could not inject message into session ${recipient}:`, err);
-                }
+                });
             }
             results.push({ to: recipient, messageId: msgRow.id, injected });
         }
         res.status(201).json({ ok: true, results });
     });
+    // ── Worker Cron Endpoints (authenticated via agent_code in query) ───────────
+    router.get("/worker/crons", async (req, res) => {
+        const { code } = req.query;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const rows = await sql `
+        SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+        FROM cron_jobs
+        WHERE session_name = ${sessionName}
+        ORDER BY name
+      `;
+            const jobs = rows.map((job) => {
+                let nextRun = null;
+                if (job.enabled) {
+                    try {
+                        const options = {};
+                        if (job.timezone)
+                            options.timezone = job.timezone;
+                        const cronJob = new CronerInstance(job.schedule, options);
+                        const next = cronJob.nextRun();
+                        nextRun = next ? next.toISOString() : null;
+                    }
+                    catch { }
+                }
+                return {
+                    ...job,
+                    next_run: nextRun,
+                    last_run: job.last_run ? job.last_run.toISOString() : null,
+                    created_at: job.created_at.toISOString(),
+                };
+            });
+            res.json(jobs);
+        }
+        catch (err) {
+            console.error("GET /worker/crons error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/worker/crons", async (req, res) => {
+        const { code } = req.query;
+        const { name, schedule, message, timezone } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        if (!name || typeof name !== "string" || !name.trim()) {
+            res.status(400).json({ error: "name is required" });
+            return;
+        }
+        if (!schedule || typeof schedule !== "string" || !schedule.trim()) {
+            res.status(400).json({ error: "schedule is required" });
+            return;
+        }
+        if (!message || typeof message !== "string" || !message.trim()) {
+            res.status(400).json({ error: "message is required" });
+            return;
+        }
+        const trimmedName = name.trim();
+        const trimmedSchedule = schedule.trim();
+        const trimmedMessage = message.trim();
+        const sessionName = session[0].name;
+        try {
+            new CronerInstance(trimmedSchedule);
+        }
+        catch {
+            res.status(400).json({ error: "Invalid cron schedule expression" });
+            return;
+        }
+        if (timezone) {
+            try {
+                new CronerInstance("0 0 * * *", { timezone });
+            }
+            catch {
+                res.status(400).json({ error: "Invalid timezone" });
+                return;
+            }
+        }
+        const [existing] = await sql `
+      SELECT id FROM cron_jobs WHERE name = ${trimmedName} AND session_name = ${sessionName}
+    `;
+        if (existing) {
+            res.status(409).json({ error: `Cron job "${trimmedName}" already exists` });
+            return;
+        }
+        try {
+            const [inserted] = await sql `
+        INSERT INTO cron_jobs (name, session_name, schedule, timezone, message)
+        VALUES (${trimmedName}, ${sessionName}, ${trimmedSchedule}, ${timezone ?? null}, ${trimmedMessage})
+        RETURNING id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+      `;
+            const cronJobrow = inserted;
+            const nextRun = cronJobrow.enabled ? (() => {
+                try {
+                    const options = {};
+                    if (cronJobrow.timezone)
+                        options.timezone = cronJobrow.timezone;
+                    const cronJob = new CronerInstance(cronJobrow.schedule, options);
+                    const next = cronJob.nextRun();
+                    return next ? next.toISOString() : null;
+                }
+                catch {
+                    return null;
+                }
+            })() : null;
+            res.status(201).json({
+                ...cronJobrow,
+                next_run: nextRun,
+                last_run: cronJobrow?.last_run?.toISOString() ?? null,
+                created_at: cronJobrow.created_at.toISOString(),
+            });
+        }
+        catch (err) {
+            console.error("POST /worker/crons error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.delete("/worker/crons/:id", async (req, res) => {
+        const { code } = req.query;
+        const id = parseInt(req.params.id, 10);
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const [job] = await sql `
+        SELECT id, name FROM cron_jobs WHERE id = ${id} AND session_name = ${sessionName}
+      `;
+            if (!job) {
+                res.status(404).json({ error: "Cron job not found or not owned by you" });
+                return;
+            }
+            await sql `DELETE FROM cron_jobs WHERE id = ${id}`;
+            res.json({ deleted: true, id, name: job.name });
+        }
+        catch (err) {
+            console.error("DELETE /worker/crons/:id error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/worker/crons/:id/enable", async (req, res) => {
+        const { code } = req.query;
+        const id = parseInt(req.params.id, 10);
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const [existing] = await sql `
+        SELECT id FROM cron_jobs WHERE id = ${id} AND session_name = ${sessionName}
+      `;
+            if (!existing) {
+                res.status(404).json({ error: "Cron job not found or not owned by you" });
+                return;
+            }
+            await sql `UPDATE cron_jobs SET enabled = TRUE WHERE id = ${id}`;
+            const [updated] = await sql `
+        SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+        FROM cron_jobs WHERE id = ${id}
+      `;
+            if (updated) {
+                const nextRun = (() => {
+                    try {
+                        const options = {};
+                        if (updated.timezone)
+                            options.timezone = updated.timezone;
+                        const cronJob = new CronerInstance(updated.schedule, options);
+                        const next = cronJob.nextRun();
+                        return next ? next.toISOString() : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                res.json({
+                    ...updated,
+                    next_run: nextRun,
+                    last_run: updated.last_run?.toISOString() ?? null,
+                    created_at: updated.created_at.toISOString(),
+                });
+            }
+            else {
+                res.status(404).json({ error: "Cron job not found" });
+            }
+        }
+        catch (err) {
+            console.error("POST /worker/crons/:id/enable error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/worker/crons/:id/disable", async (req, res) => {
+        const { code } = req.query;
+        const id = parseInt(req.params.id, 10);
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const [job] = await sql `
+        SELECT id FROM cron_jobs WHERE id = ${id} AND session_name = ${sessionName}
+      `;
+            if (!job) {
+                res.status(404).json({ error: "Cron job not found or not owned by you" });
+                return;
+            }
+            await sql `UPDATE cron_jobs SET enabled = FALSE WHERE id = ${id}`;
+            const [updated] = await sql `
+        SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+        FROM cron_jobs WHERE id = ${id}
+      `;
+            res.json({
+                ...updated,
+                next_run: null,
+                last_run: updated?.last_run?.toISOString() ?? null,
+                created_at: updated?.created_at.toISOString() ?? null,
+            });
+        }
+        catch (err) {
+            console.error("POST /worker/crons/:id/disable error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.get("/worker/crons/:id/history", async (req, res) => {
+        const { code } = req.query;
+        const id = parseInt(req.params.id, 10);
+        const limit = Math.min(parseInt(req.query.limit ?? "10", 10), 100);
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid cron job id" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const [job] = await sql `
+        SELECT id FROM cron_jobs WHERE id = ${id} AND session_name = ${sessionName}
+      `;
+            if (!job) {
+                res.status(404).json({ error: "Cron job not found or not owned by you" });
+                return;
+            }
+            const rows = await sql `
+        SELECT id, cron_job_id, executed_at, success, error_message
+        FROM cron_history
+        WHERE cron_job_id = ${id}
+        ORDER BY executed_at DESC
+        LIMIT ${limit}
+      `;
+            res.json(rows.map((r) => ({
+                ...r,
+                executed_at: r.executed_at.toISOString(),
+            })));
+        }
+        catch (err) {
+            console.error("GET /worker/crons/:id/history error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     return router;
 }