@timqi/pier 0.0.1

package/dist/tasks/groups.js

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import { Router } from "../core/router.js";
+import { logger } from "../log.js";
+import { runResultText } from "./callbacks.js";
+import { TaskStore } from "./store.js";
+import { isTerminal } from "./types.js";
+const log = logger("tasks");
+/** Core-owned fan-out join: members run detached, the group delivers one
+ * aggregated callback when the join condition is met (design 04). */
+export class TaskGroups {
+    store;
+    router;
+    host;
+    changed;
+    delivering = new Set();
+    constructor(store, router, host, changed) {
+        this.store = store;
+        this.router = router;
+        this.host = host;
+        this.changed = changed;
+    }
+    /** Enqueues every member or none: a partially started group is worse than
+     * a rejected one. */
+    runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId) {
+        const group = this.create(join, callerSessionId, callbackSessionId);
+        const runs = [];
+        try {
+            for (const definition of definitions) {
+                runs.push(this.host.startMember(definition.id, group.id, callerSessionId, parentRunId));
+            }
+        }
+        catch (error) {
+            log.warn(`group ${group.id} rolled back after ${String(runs.length)} members`, error);
+            for (const run of runs)
+                this.host.cancel(run.id);
+            throw error;
+        }
+        this.setMembers(group, runs.map((run) => run.id));
+        return { group: this.get(group.id), runs };
+    }
+    members(id) {
+        const group = this.get(id);
+        return { group, members: group.memberRunIds.map((runId) => this.host.getRun(runId)) };
+    }
+    cancelAll(id) {
+        for (const runId of this.get(id).memberRunIds)
+            this.host.cancel(runId);
+        return this.get(id);
+    }
+    create(join, invokedBySessionId, callbackSessionId) {
+        const group = {
+            id: randomUUID(),
+            join,
+            invokedBySessionId,
+            callbackSessionId,
+            memberRunIds: [],
+            winnerRunId: null,
+            callbackState: null,
+            callbackAttempts: 0,
+            callbackError: null,
+            callbackNextAttemptAt: null,
+            createdAt: Date.now(),
+            finishedAt: null,
+        };
+        this.store.saveGroup(group);
+        return group;
+    }
+    setMembers(group, runIds) {
+        group.memberRunIds = runIds;
+        this.store.saveGroup(group);
+        this.changed(group);
+    }
+    get(id) {
+        const group = this.store.getGroup(id);
+        if (!group)
+            throw new Error(`unknown task group: ${id}`);
+        return group;
+    }
+    onSettled(run) {
+        if (!run.groupId)
+            return;
+        const group = this.store.getGroup(run.groupId);
+        if (group && !group.finishedAt && group.memberRunIds.length > 0)
+            this.evaluate(group);
+    }
+    recover(now = Date.now()) {
+        for (const group of this.store.listOpenGroups(now)) {
+            if (!group.finishedAt)
+                this.evaluate(group);
+            else
+                void this.deliver(group);
+        }
+    }
+    evaluate(group) {
+        const members = group.memberRunIds.map((id) => this.host.getRun(id));
+        if (group.join === "first") {
+            const winner = members.find((run) => isTerminal(run.state));
+            if (!winner)
+                return;
+            group.winnerRunId = winner.id;
+            // Losers are cancelled, not erased: their sessions stay resumable.
+            for (const run of members)
+                if (!isTerminal(run.state))
+                    this.host.cancel(run.id);
+        }
+        else if (!members.every((run) => isTerminal(run.state))) {
+            return;
+        }
+        group.finishedAt = Date.now();
+        group.callbackState = group.callbackSessionId ? "pending" : null;
+        this.store.saveGroup(group);
+        this.changed(group);
+        if (group.callbackState === "pending")
+            void this.deliver(group);
+    }
+    /** Same outbox semantics as run callbacks: busy defer, transcript dedupe on
+     * the group id, backoff retry, restart recovery. */
+    async deliver(candidate) {
+        if (this.delivering.has(candidate.id))
+            return;
+        this.delivering.add(candidate.id);
+        try {
+            const group = this.store.getGroup(candidate.id);
+            if (!group?.callbackSessionId || (group.callbackState !== "pending" && group.callbackState !== "failed"))
+                return;
+            const session = await this.router.ensure({ channelId: "task", conversationId: group.callbackSessionId });
+            const alreadyDelivered = (await session.history()).some((turn) => turn.role === "system" && turn.origin?.kind === "task-callback" && turn.origin.runId === group.id);
+            // Busy target: waiting is not an attempt (see TaskCallbacks.deliver).
+            if (!alreadyDelivered && session.state === "streaming") {
+                group.callbackNextAttemptAt = Date.now() + 1000;
+                this.store.saveGroup(group);
+                return;
+            }
+            group.callbackAttempts += 1;
+            group.callbackState = "pending";
+            group.callbackError = null;
+            this.store.saveGroup(group);
+            // Delivered means Pi accepted the input, not that the recipient's turn
+            // ended (see TaskCallbacks.deliver); a rejection flips it to failed.
+            const sent = alreadyDelivered
+                ? Promise.resolve()
+                : session.systemInput(this.text(group), { kind: "task-callback", taskId: group.id, runId: group.id, sourceSessionId: null }, "followUp");
+            group.callbackState = "delivered";
+            group.callbackNextAttemptAt = null;
+            this.store.saveGroup(group);
+            this.changed(group);
+            await sent;
+        }
+        catch (error) {
+            log.warn(`group ${candidate.id} callback failed, will retry`, error);
+            const group = this.store.getGroup(candidate.id);
+            if (!group)
+                return;
+            group.callbackState = "failed";
+            group.callbackError = String(error);
+            group.callbackNextAttemptAt = Date.now() + Math.min(60_000, 1000 * 2 ** Math.min(group.callbackAttempts, 6));
+            this.store.saveGroup(group);
+            this.changed(group);
+        }
+        finally {
+            this.delivering.delete(candidate.id);
+        }
+    }
+    text(group) {
+        const members = group.memberRunIds.map((id) => this.host.getRun(id));
+        const sections = members.map((run) => {
+            const head = [
+                `- "${run.context.definition.name}" \u2014 state: ${run.state}`,
+                `  Run: ${run.id}${run.targetSessionId ? ` / Session: ${run.targetSessionId}` : ""}`,
+            ];
+            const decision = this.host.openDecisionId(run.id);
+            if (decision)
+                head.push(`  Needs a decision: reply to message ${decision}`);
+            if (group.join === "first" && run.id !== group.winnerRunId) {
+                head.push("  Cancelled after the winning run; resume its session to recover partial work.");
+                return head.join("\n");
+            }
+            return [...head, "", runResultText(run)].join("\n");
+        });
+        return [
+            `Task group finished (join: ${group.join}) with ${String(members.length)} runs`,
+            `Group: ${group.id}`,
+            "",
+            sections.join("\n\n---\n\n"),
+        ].join("\n");
+    }
+}

package/dist/tasks/messages.js

@@ -0,0 +1,248 @@
+import { randomUUID } from "node:crypto";
+import { EventHub } from "../core/hub.js";
+import { Router } from "../core/router.js";
+import { logger } from "../log.js";
+import { TaskStore } from "./store.js";
+import { isTerminal } from "./types.js";
+const log = logger("tasks");
+const MAX_MESSAGE_LENGTH = 16 * 1024;
+function bounded(content) {
+    const text = content.trim();
+    if (!text)
+        throw new Error("message required");
+    if (Buffer.byteLength(text, "utf8") > MAX_MESSAGE_LENGTH)
+        throw new Error("message exceeds 16 KiB");
+    return text;
+}
+export class TaskMessenger {
+    store;
+    router;
+    hub;
+    resumeRun;
+    /** Retry schedule for failed injections. In-memory on purpose: a restart
+     * expires undelivered control messages and re-offers decisions anyway. */
+    retries = new Map();
+    constructor(store, router, hub, 
+    /** Continues a terminal child with a supervisor reply as its prompt. */
+    resumeRun) {
+        this.store = store;
+        this.router = router;
+        this.hub = hub;
+        this.resumeRun = resumeRun;
+    }
+    expirePending() {
+        for (const message of this.store.expirePendingMessages())
+            this.changed(message);
+    }
+    /** The unanswered decision on a run, if any. */
+    openDecisionId(runId) {
+        return this.store.listMessages(runId).find((m) => m.kind === "decision" && (m.state === "pending" || m.state === "delivered"))?.id ?? null;
+    }
+    /** A manual continuation supersedes an unanswered decision (design 04):
+     * one continuation per run, never two racing ones. */
+    expireDecisions(runId, reason) {
+        for (const message of this.store.listMessages(runId)) {
+            if (message.kind !== "decision" || (message.state !== "pending" && message.state !== "delivered"))
+                continue;
+            message.state = "expired";
+            message.error = reason;
+            message.answeredAt = Date.now();
+            this.store.saveMessage(message);
+            this.changed(message);
+        }
+    }
+    list(runId) {
+        return this.store.listMessages(runId);
+    }
+    recent(since, limit = 200) {
+        return this.store.listRecentMessages(since, limit);
+    }
+    async control(run, fromSessionId, kind, content) {
+        const message = this.create(run, kind, fromSessionId, run.targetSessionId ?? "", content, null);
+        if (run.targetSessionId)
+            this.deliver(message, run, run.targetSessionId);
+        return this.require(message.id);
+    }
+    deliverPendingControls(run) {
+        if (!run.targetSessionId)
+            return;
+        for (const message of this.store.listMessages(run.id)) {
+            if (message.state !== "pending" || (message.kind !== "steer" && message.kind !== "follow_up"))
+                continue;
+            this.deliver(message, run, run.targetSessionId);
+        }
+    }
+    /** Injection is fire-and-forget, so this sweep is what closes a failed one.
+     * `inject` dedupes on the recipient transcript, so a retry cannot double
+     * deliver. Controls aimed at a finished run are dead and expire here. */
+    retryUndelivered(now = Date.now()) {
+        for (const message of this.store.listUndeliveredMessages()) {
+            const run = this.store.getRun(message.runId);
+            if (!run)
+                continue;
+            // Expiring a dead control is not a retry, so it ignores the backoff.
+            if ((message.kind === "steer" || message.kind === "follow_up") && isTerminal(run.state)) {
+                message.state = "expired";
+                message.error = "run finished before delivery completed";
+                this.store.saveMessage(message);
+                this.changed(message);
+                continue;
+            }
+            if ((this.retries.get(message.id)?.nextAt ?? 0) > now)
+                continue;
+            const target = message.toSessionId || run.targetSessionId;
+            if (target)
+                this.deliver(message, run, target);
+        }
+    }
+    /** Asynchronous by design: returns the receipt immediately. A decision
+     * child states what it awaits and ends its turn; the reply arrives as a
+     * follow-up (active run) or resumes the session (terminal run).
+     * A decision steers the supervisor: a follow-up only lands once the
+     * supervisor has no tool calls left, so a blocked child would wait out the
+     * whole turn. Progress stays a follow-up — nobody waits on it. */
+    async contact(run, fromSessionId, reason, content) {
+        if (!run.invokedBySessionId)
+            throw new Error("run has no supervisor session");
+        if (reason === "decision" && this.openDecisionId(run.id)) {
+            throw new Error("run already has a pending supervisor decision");
+        }
+        const message = this.create(run, reason, fromSessionId, run.invokedBySessionId, content, null);
+        this.deliver(message, run, run.invokedBySessionId);
+        return this.require(message.id);
+    }
+    async reply(questionId, fromSessionId, content) {
+        const question = this.require(questionId);
+        if (question.kind !== "decision")
+            throw new Error("message is not a decision request");
+        if (question.toSessionId !== fromSessionId)
+            throw new Error("only the addressed supervisor may reply");
+        const existing = this.store.listMessages(question.runId).find((m) => m.kind === "reply" && m.replyTo === question.id);
+        const text = bounded(content);
+        if (existing) {
+            if (existing.content !== text)
+                throw new Error("decision already answered with different content");
+            return existing;
+        }
+        if (question.state !== "delivered" && question.state !== "pending") {
+            throw new Error(`decision is ${question.state}`);
+        }
+        const run = this.store.getRun(question.runId);
+        if (!run)
+            throw new Error(`unknown task run: ${question.runId}`);
+        const reply = this.create(run, "reply", fromSessionId, question.fromSessionId, text, question.id);
+        question.state = "answered";
+        question.answeredAt = Date.now();
+        this.store.saveMessage(question);
+        this.changed(question);
+        // Core routes the reply: follow-up into an active run, auto-resume of a
+        // terminal one — the replier gets the continuation's callback.
+        if (run.targetSessionId && (run.state === "queued" || run.state === "running")) {
+            this.deliver(reply, run, run.targetSessionId);
+        }
+        else if (isTerminal(run.state)) {
+            this.resumeRun(run.id, this.format(reply, run), fromSessionId);
+            reply.state = "delivered";
+            reply.deliveredAt = Date.now();
+            this.store.saveMessage(reply);
+            this.changed(reply);
+        }
+        return this.require(reply.id);
+    }
+    create(run, kind, fromSessionId, toSessionId, content, replyTo) {
+        const message = {
+            id: randomUUID(),
+            runId: run.id,
+            kind,
+            fromSessionId,
+            toSessionId,
+            replyTo,
+            state: "pending",
+            content: bounded(content),
+            createdAt: Date.now(),
+            deliveredAt: null,
+            answeredAt: null,
+            error: null,
+        };
+        this.store.saveMessage(message);
+        this.changed(message);
+        return message;
+    }
+    /** Never awaits the recipient: the seam's `systemInput` settles with the turn
+     * the input triggers, so awaiting it would block the sender — a child's
+     * `contact` on its supervisor's whole answer turn — which the design forbids.
+     * Delivery is therefore recorded on hand-off and corrected to `failed` by the
+     * catch; the tick sweep retries from there. */
+    deliver(candidate, run, targetSessionId) {
+        const message = this.require(candidate.id);
+        if (message.state !== "pending" && message.state !== "failed")
+            return;
+        if (message.toSessionId !== targetSessionId)
+            message.toSessionId = targetSessionId;
+        message.state = "delivered";
+        message.deliveredAt = Date.now();
+        message.error = null;
+        this.store.saveMessage(message);
+        this.changed(message);
+        void this.inject(message, run, targetSessionId, this.mode(message))
+            .catch((error) => { this.failed(message.id, error); });
+    }
+    /** A decision steers — a follow-up would land only after the supervisor runs
+     * out of tool calls, leaving the child waiting out the whole turn. */
+    mode(message) {
+        return message.kind === "steer" || message.kind === "decision" ? "steer" : "follow_up";
+    }
+    failed(id, error) {
+        const message = this.store.getMessage(id);
+        if (!message || message.state === "answered" || message.state === "expired")
+            return;
+        // Both ends are waiting on this one: the sender for an answer, the
+        // recipient for a message it never got told about.
+        log.warn(`${message.kind} ${id} to session ${message.toSessionId} failed`, error);
+        message.state = "failed";
+        message.error = String(error);
+        this.store.saveMessage(message);
+        this.changed(message);
+        const attempts = (this.retries.get(id)?.attempts ?? 0) + 1;
+        this.retries.set(id, { attempts, nextAt: Date.now() + Math.min(60_000, 1000 * 2 ** Math.min(attempts, 6)) });
+    }
+    async inject(message, run, targetSessionId, mode) {
+        const session = await this.router.ensure({ channelId: "task", conversationId: targetSessionId });
+        const delivered = (await session.history()).some((turn) => turn.role === "system" && turn.origin?.kind === "task-message" && turn.origin.messageId === message.id);
+        if (delivered)
+            return;
+        await session.systemInput(this.format(message, run), this.origin(message, run), mode === "follow_up" ? "followUp" : mode);
+    }
+    format(message, run) {
+        const title = run.context.definition.name;
+        if (message.kind === "progress") {
+            return `Subagent progress for task "${title}"\nRun: ${run.id}\nMessage: ${message.id}\n\n${message.content}`;
+        }
+        if (message.kind === "decision") {
+            return `Subagent needs a decision for task "${title}"\nRun: ${run.id}\nMessage: ${message.id}\nReply with the Task reply operation.\n\n${message.content}`;
+        }
+        if (message.kind === "reply") {
+            return `Supervisor reply for task "${title}"\nRun: ${run.id}\nReply to: ${message.replyTo ?? "-"}\n\n${message.content}`;
+        }
+        return `Task guidance for "${title}"\nRun: ${run.id}\nMessage: ${message.id}\n\n${message.content}`;
+    }
+    origin(message, run) {
+        return {
+            kind: "task-message",
+            taskId: run.taskId,
+            runId: run.id,
+            sourceSessionId: message.fromSessionId,
+            messageId: message.id,
+            messageKind: message.kind,
+        };
+    }
+    require(id) {
+        const message = this.store.getMessage(id);
+        if (!message)
+            throw new Error(`unknown task message: ${id}`);
+        return message;
+    }
+    changed(message) {
+        this.hub.emitWorkspace({ type: "task-message-changed", runId: message.runId, messageId: message.id });
+    }
+}

package/dist/tasks/routes.js

@@ -0,0 +1,219 @@
+import { record, requiredString } from "./definitions.js";
+const jsonBody = async (req) => req.json().catch(() => null);
+export function registerTaskRoutes(app, tasks, activity) {
+    if (activity)
+        app.get("/api/activity", async (c) => {
+            const now = Date.now();
+            const recent = c.req.query("scope") === "recent";
+            const runs = tasks.recentRuns(200).filter((run) => recent
+                ? run.queuedAt >= now - 60 * 60 * 1000
+                : run.state === "queued" || run.state === "running");
+            const listed = await activity.factory.list();
+            const byId = new Map(listed.map((session) => [session.id, session]));
+            const linkedIds = new Set();
+            for (const run of runs) {
+                for (const id of [run.invokedBySessionId, run.targetSessionId, run.callbackSessionId]) {
+                    if (id)
+                        linkedIds.add(id);
+                }
+            }
+            for (const session of listed) {
+                if (activity.router.stateOf(session.id) === "streaming")
+                    linkedIds.add(session.id);
+            }
+            const messages = tasks.recentMessages(recent ? now - 60 * 60 * 1000 : now - 24 * 60 * 60 * 1000)
+                .filter((message) => runs.some((run) => run.id === message.runId));
+            for (const message of messages) {
+                if (message.fromSessionId !== "console")
+                    linkedIds.add(message.fromSessionId);
+                if (message.toSessionId !== "console")
+                    linkedIds.add(message.toSessionId);
+            }
+            return c.json({
+                sessions: [...linkedIds].map((id) => {
+                    const session = byId.get(id);
+                    return {
+                        id,
+                        cwd: session?.cwd ?? "",
+                        title: session?.title,
+                        state: activity.router.stateOf(id) ?? "idle",
+                        stateSince: activity.router.stateSinceOf(id) ?? null,
+                    };
+                }),
+                runs,
+                messages,
+            });
+        });
+    app.get("/api/tasks", (c) => {
+        const trigger = c.req.query("trigger");
+        const state = c.req.query("state");
+        const kind = c.req.query("kind");
+        let rows = tasks.list();
+        // Subagent one-shots are hidden unless explicitly requested via ?kind=subagent.
+        rows = kind ? rows.filter((task) => task.kind === kind) : rows.filter((task) => task.kind !== "subagent");
+        if (trigger)
+            rows = rows.filter((task) => task.trigger.type === trigger);
+        if (state === "archived")
+            rows = rows.filter((task) => task.archived);
+        else if (state === "active")
+            rows = rows.filter((task) => !task.archived);
+        return c.json(rows.map((task) => ({
+            ...task,
+            lastRun: tasks.listRuns(task.id, 1)[0] ?? null,
+        })));
+    });
+    app.post("/api/tasks", async (c) => {
+        const body = await jsonBody(c.req);
+        const runNow = typeof body === "object" && body !== null && "runNow" in body && body.runNow === true;
+        const definition = typeof body === "object" && body !== null && "task" in body ? body.task : body;
+        try {
+            const task = await tasks.create(definition);
+            const run = runNow ? tasks.run(task.id) : null;
+            return c.json({ task, runId: run?.id ?? null }, 201);
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.get("/api/tasks/:id/runs", (c) => {
+        try {
+            const limit = Number(c.req.query("limit") ?? 50);
+            const offset = Number(c.req.query("offset") ?? 0);
+            return c.json(tasks.listRuns(c.req.param("id"), limit, offset));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 404);
+        }
+    });
+    app.get("/api/task-runs/:id", (c) => {
+        try {
+            const run = tasks.getRun(c.req.param("id"));
+            // Same view as the task tool: a pending decision is the one run fact that
+            // lives on the messages, and HTTP callers need it too.
+            return c.json({ ...run, pendingDecisionId: tasks.openDecisionId(run.id) });
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 404);
+        }
+    });
+    app.get("/api/task-groups/:id", (c) => {
+        try {
+            return c.json(tasks.getGroup(c.req.param("id")));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 404);
+        }
+    });
+    app.get("/api/task-runs/:id/messages", (c) => {
+        try {
+            return c.json(tasks.listMessages(c.req.param("id")));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 404);
+        }
+    });
+    app.post("/api/task-runs/:id/steer", async (c) => {
+        const body = record(await jsonBody(c.req));
+        try {
+            return c.json(await tasks.control(c.req.param("id"), typeof body?.sourceSessionId === "string" ? body.sourceSessionId : "console", body?.mode === "followUp" ? "follow_up" : "steer", requiredString(body?.message, "message")), 202);
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/task-runs/:id/resume", async (c) => {
+        const body = record(await jsonBody(c.req));
+        try {
+            const wait = body?.wait === true;
+            const source = typeof body?.sourceSessionId === "string" ? body.sourceSessionId : null;
+            const run = tasks.resume(c.req.param("id"), requiredString(body?.message, "message"), {
+                invokedBySessionId: source,
+                callbackSessionId: wait ? null : source,
+                background: !wait,
+            });
+            return c.json(wait ? await tasks.waitForRun(run.id) : run, wait ? 200 : 202);
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/task-messages/:id/reply", async (c) => {
+        const body = record(await jsonBody(c.req));
+        try {
+            const source = requiredString(body?.sourceSessionId, "sourceSessionId");
+            return c.json(await tasks.reply(c.req.param("id"), source, requiredString(body?.message, "message")), 202);
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/task-runs/:id/cancel", (c) => {
+        try {
+            return c.json(tasks.cancel(c.req.param("id")), 202);
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 404);
+        }
+    });
+    app.get("/api/tasks/:id", (c) => {
+        try {
+            return c.json(tasks.get(c.req.param("id")));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 404);
+        }
+    });
+    app.patch("/api/tasks/:id", async (c) => {
+        try {
+            return c.json(await tasks.update(c.req.param("id"), await jsonBody(c.req)));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/tasks/:id/run", async (c) => {
+        const body = record(await jsonBody(c.req));
+        const input = body && "input" in body ? body.input : null;
+        try {
+            const sessionMode = body?.sessionMode === "fresh" || body?.sessionMode === "fork" ? body.sessionMode : undefined;
+            const sourceSessionId = typeof body?.sourceSessionId === "string" && body.sourceSessionId ? body.sourceSessionId : null;
+            const task = tasks.get(c.req.param("id"));
+            const effectiveMode = task.action.type === "agent" ? sessionMode ?? task.action.session.mode : null;
+            if (effectiveMode === "fork" && (!sourceSessionId || !(await tasks.sessionExists(sourceSessionId)))) {
+                throw new Error("fork requires a known sourceSessionId");
+            }
+            return c.json({ runId: tasks.run(task.id, input, "manual", null, {
+                    invokedBySessionId: sourceSessionId,
+                    sourceSessionId,
+                    sessionMode,
+                }).id }, 202);
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/tasks/:id/pause", (c) => {
+        try {
+            return c.json(tasks.setEnabled(c.req.param("id"), false));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/tasks/:id/resume", (c) => {
+        try {
+            return c.json(tasks.setEnabled(c.req.param("id"), true));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+    app.post("/api/tasks/:id/archive", (c) => {
+        try {
+            return c.json(tasks.archive(c.req.param("id")));
+        }
+        catch (err) {
+            return c.json({ error: String(err) }, 400);
+        }
+    });
+}