@netnodeag/kraftwerk 0.80.0 → 0.82.0

package/dist/core/temp.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The temp folder: where a session's scratch work goes — intermediate
+ * results, downloads, build output, a markdown written for a CLI to read —
+ * instead of the system's temp dir or, worse, the workspace's files.
+ *
+ *   kraftwerk-data/temp/<session-id>/   one folder per chat session
+ *   <run dir>/temp/                     a workflow run's (inside its mount)
+ *
+ * Three things make it stick, so it does not depend on an agent reading a
+ * sentence: the folder is handed to every spawned agent as TMPDIR (and
+ * TMP, TEMP, KRAFTWERK_TEMP), so mktemp, Python's tempfile, Node's
+ * os.tmpdir() and the agent's own scratchpad land there by themselves; it
+ * sits inside the workspace, so writes there need no approval from the
+ * harness; and the session prompt names it next to the files folders,
+ * which say in turn that nothing temporary belongs in them.
+ *
+ * The temp root is local: a .gitignore of its own keeps everything in it
+ * out of the workspace git (and `kraftwerk init` lists it too). Nothing in
+ * it is a deliverable, so nothing goes to the trash: a chat's folder is
+ * removed with the chat, and folders nobody touched for SWEEP_AFTER_MS are
+ * swept when a session starts (at most once an hour) or on demand
+ * (`kraftwerk temp clean`, DELETE /api/temp).
+ */
+export declare const TEMP_DIR = "kraftwerk-data/temp";
+/** A folder idle this long is swept. */
+export declare const SWEEP_AFTER_MS: number;
+export interface TempEntry {
+    /** The folder name: the session's id. */
+    id: string;
+    /** Relative to the workspace root, forward slashes. */
+    path: string;
+    files: number;
+    bytes: number;
+    /** The newest change inside (the folder's own when empty). */
+    modifiedAt: string;
+}
+export interface TempView {
+    root: string;
+    entries: TempEntry[];
+    bytes: number;
+}
+/** Absolute temp root of the current workspace. */
+export declare function tempRoot(): Promise<string>;
+/** The environment that points a process at `dir` for everything temporary. */
+export declare function tempEnv(dir: string): Record<string, string>;
+/** Create a folder outside the workspace's temp root (a workflow run's) and return the env for it. */
+export declare function tempEnvFor(dir: string): Promise<Record<string, string>>;
+/**
+ * A session's own folder, created: absolute path and the path relative to
+ * the workspace root (for the prompt). Starting a session is also when
+ * folders nobody uses any more are swept, at most once an hour.
+ */
+export declare function sessionTemp(id: string): Promise<{
+    abs: string;
+    rel: string;
+    env: Record<string, string>;
+}>;
+/** Remove one session's folder for good (nothing there is a deliverable). */
+export declare function removeSessionTemp(id: string): Promise<void>;
+/** Every session folder in the temp root, newest first. */
+export declare function listTemp(): Promise<TempView>;
+/**
+ * Remove session folders: all of them, or those idle longer than
+ * `olderThanMs` (default SWEEP_AFTER_MS). `keep` names folders that stay
+ * whatever their age (the session being started). Returns what went.
+ */
+export declare function cleanTemp(opts?: {
+    all?: boolean;
+    olderThanMs?: number;
+    keep?: string[];
+}): Promise<TempEntry[]>;
+/** The "## Temporary files" block of a session's context. */
+export declare function tempContext(rel: string): string;

package/dist/core/temp.js

@@ -0,0 +1,154 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { resolveWorkspace } from "../config.js";
+import { workspaceRoot } from "./context.js";
+import { perWorkspace } from "./workspace.js";
+/**
+ * The temp folder: where a session's scratch work goes — intermediate
+ * results, downloads, build output, a markdown written for a CLI to read —
+ * instead of the system's temp dir or, worse, the workspace's files.
+ *
+ *   kraftwerk-data/temp/<session-id>/   one folder per chat session
+ *   <run dir>/temp/                     a workflow run's (inside its mount)
+ *
+ * Three things make it stick, so it does not depend on an agent reading a
+ * sentence: the folder is handed to every spawned agent as TMPDIR (and
+ * TMP, TEMP, KRAFTWERK_TEMP), so mktemp, Python's tempfile, Node's
+ * os.tmpdir() and the agent's own scratchpad land there by themselves; it
+ * sits inside the workspace, so writes there need no approval from the
+ * harness; and the session prompt names it next to the files folders,
+ * which say in turn that nothing temporary belongs in them.
+ *
+ * The temp root is local: a .gitignore of its own keeps everything in it
+ * out of the workspace git (and `kraftwerk init` lists it too). Nothing in
+ * it is a deliverable, so nothing goes to the trash: a chat's folder is
+ * removed with the chat, and folders nobody touched for SWEEP_AFTER_MS are
+ * swept when a session starts (at most once an hour) or on demand
+ * (`kraftwerk temp clean`, DELETE /api/temp).
+ */
+export const TEMP_DIR = "kraftwerk-data/temp";
+/** A folder idle this long is swept. */
+export const SWEEP_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+const SWEEP_EVERY_MS = 60 * 60 * 1000;
+/** A session id as a folder name: what newChatId() produces, nothing that could leave the root. */
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,120}$/;
+async function resolvedRoot() {
+    const ws = await resolveWorkspace(workspaceRoot()).catch(() => null);
+    return ws?.root ?? workspaceRoot();
+}
+/** Absolute temp root of the current workspace. */
+export async function tempRoot() {
+    return path.join(await resolvedRoot(), TEMP_DIR);
+}
+/** Create the root and keep it out of the workspace git: a .gitignore of its own ignores everything in it, itself included. */
+async function prepare(root) {
+    await fs.mkdir(root, { recursive: true });
+    await fs.writeFile(path.join(root, ".gitignore"), "*\n", { flag: "wx" }).catch(() => { });
+}
+/** The environment that points a process at `dir` for everything temporary. */
+export function tempEnv(dir) {
+    return { KRAFTWERK_TEMP: dir, TMPDIR: dir, TMP: dir, TEMP: dir };
+}
+/** Create a folder outside the workspace's temp root (a workflow run's) and return the env for it. */
+export async function tempEnvFor(dir) {
+    await fs.mkdir(dir, { recursive: true });
+    return tempEnv(dir);
+}
+const lastSweep = perWorkspace(() => ({ at: 0 }));
+/**
+ * A session's own folder, created: absolute path and the path relative to
+ * the workspace root (for the prompt). Starting a session is also when
+ * folders nobody uses any more are swept, at most once an hour.
+ */
+export async function sessionTemp(id) {
+    if (!ID_RE.test(id))
+        throw new Error("invalid session id");
+    const root = await tempRoot();
+    await prepare(root);
+    const abs = path.join(root, id);
+    await fs.mkdir(abs, { recursive: true });
+    const sweep = lastSweep();
+    if (Date.now() - sweep.at > SWEEP_EVERY_MS) {
+        sweep.at = Date.now();
+        void cleanTemp({ keep: [id] }).catch(() => { });
+    }
+    return { abs, rel: `${TEMP_DIR}/${id}`, env: tempEnv(abs) };
+}
+/** Remove one session's folder for good (nothing there is a deliverable). */
+export async function removeSessionTemp(id) {
+    if (!ID_RE.test(id))
+        return;
+    await fs.rm(path.join(await tempRoot(), id), { recursive: true, force: true });
+}
+/** Files, bytes and the newest mtime below a folder. */
+async function measure(dir) {
+    const st = await fs.stat(dir);
+    const out = { files: 0, bytes: 0, newest: st.mtimeMs };
+    const walk = async (d) => {
+        if (out.files > 20000)
+            return;
+        for (const k of await fs.readdir(d, { withFileTypes: true }).catch(() => [])) {
+            const abs = path.join(d, k.name);
+            if (k.isDirectory())
+                await walk(abs);
+            else if (k.isFile()) {
+                const s = await fs.stat(abs).catch(() => null);
+                if (!s)
+                    continue;
+                out.files++;
+                out.bytes += s.size;
+                if (s.mtimeMs > out.newest)
+                    out.newest = s.mtimeMs;
+            }
+        }
+    };
+    await walk(dir);
+    return out;
+}
+/** Every session folder in the temp root, newest first. */
+export async function listTemp() {
+    const root = await tempRoot();
+    const kids = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const entries = [];
+    for (const k of kids) {
+        if (!k.isDirectory() || k.name.startsWith("."))
+            continue;
+        const m = await measure(path.join(root, k.name)).catch(() => null);
+        if (!m)
+            continue;
+        entries.push({ id: k.name, path: `${TEMP_DIR}/${k.name}`, files: m.files, bytes: m.bytes, modifiedAt: new Date(m.newest).toISOString() });
+    }
+    entries.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+    return { root, entries, bytes: entries.reduce((n, e) => n + e.bytes, 0) };
+}
+/**
+ * Remove session folders: all of them, or those idle longer than
+ * `olderThanMs` (default SWEEP_AFTER_MS). `keep` names folders that stay
+ * whatever their age (the session being started). Returns what went.
+ */
+export async function cleanTemp(opts = {}) {
+    const view = await listTemp();
+    const cutoff = Date.now() - (opts.olderThanMs ?? SWEEP_AFTER_MS);
+    const keep = new Set(opts.keep ?? []);
+    const gone = [];
+    for (const e of view.entries) {
+        if (keep.has(e.id))
+            continue;
+        if (!opts.all && Date.parse(e.modifiedAt) > cutoff)
+            continue;
+        await fs.rm(path.join(view.root, e.id), { recursive: true, force: true });
+        gone.push(e);
+    }
+    return gone;
+}
+/** The "## Temporary files" block of a session's context. */
+export function tempContext(rel) {
+    return (`## Temporary files\n` +
+        `Your scratch folder is ${rel}/ — TMPDIR (and KRAFTWERK_TEMP) point there, so \`mktemp\`, Python's tempfile, ` +
+        `os.tmpdir() and your own scratchpad land in it by themselves. Put everything that is not a result there: ` +
+        `intermediate output, downloads, extracted archives, build output, one-off scripts, a markdown written for a CLI ` +
+        `to read. It is private to this session, kept out of git, and removed when the session is deleted or after a week ` +
+        `unused — never store anything there you or the user want to keep. The files folders named above hold only what ` +
+        `the user keeps: what you produce for them, and the material they gave you. Never create temporary or ` +
+        `intermediate files there, and never in the system's temp dir.`);
+}

package/dist/core/trash.d.ts

@@ -8,7 +8,7 @@
  */
 export declare const TRASH_DIR = "kraftwerk-data/trash";
 /** What can be in the trash; also the folder under trash/ it lands in. */
-export type TrashKind = "agents" | "agent-skills" | "projects" | "contacts" | "places" | "events" | "workflows" | "knowledge" | "vibeables" | "channels" | "repos" | "chats" | "runs" | "files";
+export type TrashKind = "agents" | "agent-skills" | "projects" | "boards" | "tasks" | "contacts" | "places" | "events" | "workflows" | "knowledge" | "vibeables" | "channels" | "repos" | "chats" | "runs" | "files";
 export interface TrashEntry {
     /** Path inside the trash, forward slashes — the entry's handle. */
     id: string;

package/dist/harness.d.ts

@@ -47,6 +47,8 @@ export interface AgentInvocation {
     clis?: string[];
     /** MCP servers available in this phase, keyed by server name. */
     mcpServers?: Record<string, McpServerConfig>;
+    /** Extra environment for the agent process (the run's temp folder as TMPDIR, see core/temp.ts); on top of the workspace's. */
+    env?: Record<string, string>;
     resume?: string;
     onToolUse?: (tool: string, target: string) => void;
     onText?: (text: string) => void;

package/dist/harnesses/acp.js

@@ -83,7 +83,7 @@ async function open(agent, inv, resume) {
     };
     const { child, conn } = await connectAcp(agent, {
         cwd: inv.cwd,
-        env: adapterEnv(agent, { model: inv.model, effort: inv.effort }),
+        env: { ...adapterEnv(agent, { model: inv.model, effort: inv.effort }), ...inv.env },
         client,
         clientName: "kraftwerk",
         onError: (err) => end(`could not start the ${agent} adapter: ${err.message}`),

package/dist/harnesses/claude.js

@@ -38,6 +38,7 @@ function invokeClaude(inv) {
         const child = spawn("claude", args, {
             cwd: inv.cwd,
             stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...inv.env },
         });
         child.stdin.write(inv.prompt);
         child.stdin.end();

package/dist/harnesses/codex.js

@@ -62,6 +62,7 @@ function invokeCodex(inv) {
         const child = spawn("codex", args, {
             cwd: inv.cwd,
             stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...inv.env },
         });
         child.stdin.write(prompt);
         child.stdin.end();

package/dist/harnesses/pi.js

@@ -64,6 +64,7 @@ function invokePi(inv) {
         const child = spawn("pi", args, {
             cwd: inv.cwd,
             stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...inv.env },
         });
         child.stdin.write(inv.prompt);
         child.stdin.end();

package/dist/run.d.ts

@@ -39,6 +39,13 @@ export declare class Run {
     private readonly verbose;
     private readonly maxGateRetries;
     constructor(options: RunOptions);
+    /**
+     * The run's scratch folder, <run dir>/temp, as TMPDIR for every phase
+     * (core/temp.ts): inside the run dir so a sandboxed run finds it in its
+     * mount, created when the first phase starts.
+     */
+    private temp?;
+    private tempEnv;
     trace(event: string, data?: Record<string, unknown>): Promise<void>;
     agentPhase(params: {
         name: string;

package/dist/run.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { harnessFor } from "./harnesses/registry.js";
 import { correctionPrompt, parseEnvelope } from "./envelope.js";
 import { fmtDuration, phaseStatsLine, summaryTable } from "./stats.js";
+import { tempEnvFor } from "./core/temp.js";
 export class Run {
     /** Session per harness AND protocol: a CLI session id means nothing to the ACP adapter and vice versa. */
     sessions = new Map();
@@ -19,6 +20,15 @@ export class Run {
         this.verbose = options.verbose ?? false;
         this.maxGateRetries = options.maxGateRetries ?? 2;
     }
+    /**
+     * The run's scratch folder, <run dir>/temp, as TMPDIR for every phase
+     * (core/temp.ts): inside the run dir so a sandboxed run finds it in its
+     * mount, created when the first phase starts.
+     */
+    temp;
+    tempEnv() {
+        return (this.temp ??= tempEnvFor(path.join(this.runDir, "temp")));
+    }
     async trace(event, data = {}) {
         await appendFile(path.join(this.runDir, "trace.jsonl"), JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + "\n");
     }
@@ -78,6 +88,7 @@ export class Run {
                 tools: agent.tools,
                 clis: cliEntries.map(([name]) => name),
                 mcpServers: agent.mcp,
+                env: await this.tempEnv(),
                 resume: this.sessions.get(sessionKey),
                 onToolUse: (tool, target) => {
                     console.log(`  ⚙ ${tool} ${target}`.trimEnd());
@@ -160,10 +171,11 @@ export class Run {
         console.log(`\n▸ Phase "${params.name}" — script (bash)`);
         await this.trace("phase_start", { phase: params.name, kind: "script" });
         const started = Date.now();
+        const temp = await this.tempEnv();
         const result = await new Promise((resolve, reject) => {
             const child = spawn("bash", ["-c", params.script], {
                 cwd: this.runDir,
-                env: { ...process.env, RUN_DIR: this.runDir, PHASE: params.name, ...params.env },
+                env: { ...process.env, ...temp, RUN_DIR: this.runDir, PHASE: params.name, ...params.env },
             });
             let stdout = "";
             let stderr = "";

package/dist/server/api/boards.d.ts

@@ -0,0 +1,105 @@
+import * as z from "zod";
+/**
+ * Boards and tasks over the API. A board is addressed by its slug and, for
+ * a project's board, `?project=<slug>`; a task by its folder name or its
+ * bare number. Writes that change a task's column or assignee are logged
+ * on the task and may wake the assignee (core/board-wake.ts).
+ */
+export declare const boardErrors: (message: string) => number;
+export declare const boardRoutes: (import("./router.js").Route<"boards.create", import("./router.js").Reply<import("../../core/boards.js").BoardDetail>, "/api/boards", z.ZodObject<{
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        slug: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        done: z.ZodOptional<z.ZodBoolean>;
+        review: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>>;
+    agent: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"boards.delete", {
+    ok: boolean;
+}, "/api/boards/:board", undefined> | import("./router.js").Route<"boards.ensure", import("../../core/boards.js").BoardDetail, "/api/boards/default", z.ZodObject<{
+    project: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"boards.get", import("../../core/boards.js").BoardDetail, "/api/boards/:board", undefined> | import("./router.js").Route<"boards.list", import("../../core/boards.js").BoardsView, "/api/boards", undefined> | import("./router.js").Route<"boards.save", import("../../core/boards.js").BoardDetail, "/api/boards/:board", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        slug: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        done: z.ZodOptional<z.ZodBoolean>;
+        review: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>>;
+    agent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    staleAfter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"tasks.assign", import("../../core/boards.js").TaskDetail, "/api/boards/:board/tasks/:task/assign", z.ZodObject<{
+    to: z.ZodNullable<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"tasks.create", import("./router.js").Reply<import("../../core/boards.js").TaskDetail>, "/api/boards/:board/tasks", z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    due: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+}, z.core.$strip>> | import("./router.js").Route<"tasks.delete", {
+    ok: boolean;
+}, "/api/boards/:board/tasks/:task", undefined> | import("./router.js").Route<"tasks.get", {
+    slug: string;
+    number: number;
+    title: string;
+    status: string;
+    order: number;
+    assignee?: string;
+    due?: string;
+    created: string;
+    tags: string[];
+    refs: string[];
+    extra?: Record<string, unknown>;
+    ref: string;
+    path: string;
+    updatedAt?: string;
+    configError?: string;
+    files: number;
+    lastLog?: string;
+    stale?: boolean;
+    notes: string;
+    log: string;
+    fileList: string[];
+    board: string;
+    project?: string;
+    sessions: import("../../core/board-wake.js").TaskSession[];
+}, "/api/boards/:board/tasks/:task", undefined> | import("./router.js").Route<"tasks.log", import("../../core/boards.js").TaskDetail, "/api/boards/:board/tasks/:task/log", z.ZodObject<{
+    entry: z.ZodString;
+    actor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"tasks.move", import("../../core/boards.js").TaskDetail, "/api/boards/:board/tasks/:task/move", z.ZodObject<{
+    status: z.ZodString;
+    before: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"tasks.pick", {
+    task: import("../../core/boards.js").TaskDetail | null;
+}, "/api/boards/:board/pick", z.ZodObject<{
+    agent: z.ZodString;
+    column: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"tasks.save", import("../../core/boards.js").TaskDetail, "/api/boards/:board/tasks/:task", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    due: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>)[];

package/dist/server/api/boards.js

@@ -0,0 +1,160 @@
+import * as z from "zod";
+import { appendTaskLog, assignTask, createBoard, createTask, deleteBoard, deleteTask, ensureDefaultBoard, getBoard, getTask, listAllBoards, listBoards, moveTask, openBoards, pickTask, saveBoard, saveTask, } from "../../core/boards.js";
+import { taskSessions } from "../../core/board-wake.js";
+import { fail, reply, route, statusByMessage } from "./router.js";
+/**
+ * Boards and tasks over the API. A board is addressed by its slug and, for
+ * a project's board, `?project=<slug>`; a task by its folder name or its
+ * bare number. Writes that change a task's column or assignee are logged
+ * on the task and may wake the assignee (core/board-wake.ts).
+ */
+export const boardErrors = statusByMessage(/^no (board|task|project)/);
+const Columns = z.array(z.union([z.string(), z.object({ slug: z.string(), label: z.string().optional(), limit: z.number().optional(), done: z.boolean().optional(), review: z.boolean().optional() })]));
+const BoardFields = z.object({
+    title: z.string().optional(),
+    columns: Columns.optional(),
+    agent: z.string().nullable().optional(),
+    staleAfter: z.string().nullable().optional(),
+    notes: z.string().optional(),
+});
+const TaskFields = z.object({
+    title: z.string().optional(),
+    status: z.string().optional(),
+    order: z.number().optional(),
+    assignee: z.string().nullable().optional(),
+    due: z.string().nullable().optional(),
+    tags: z.array(z.string()).optional(),
+    refs: z.array(z.string()).optional(),
+    notes: z.string().optional(),
+    /** Who writes (human:user by default) and a line for the log. */
+    actor: z.string().optional(),
+    message: z.string().optional(),
+});
+const refOf = (c) => {
+    const project = c.query.get("project");
+    return { ...(project ? { project } : {}), board: c.params.board };
+};
+const requireOn = async () => {
+    if ((await openBoards()).off)
+        fail(409, "boards are off");
+};
+export const boardRoutes = [
+    route({ name: "boards.list", method: "GET", path: "/api/boards", summary: "the boards: a project's with ?project=, every board with ?all=1, else the workspace's" }, async (c) => {
+        if (c.query.get("all") === "1") {
+            const opened = await openBoards();
+            return { enabled: !opened.off && !!opened.root, ...(opened.root ? { root: opened.root } : {}), boards: await listAllBoards(), ...(opened.error ? { error: opened.error } : {}) };
+        }
+        return listBoards(c.query.get("project") ?? undefined);
+    }),
+    route({
+        name: "boards.create",
+        method: "POST",
+        path: "/api/boards",
+        summary: "create a board {title, slug?, project?, columns?, agent?, notes?}",
+        errors: boardErrors,
+        body: z.object({ title: z.string(), slug: z.string().optional(), project: z.string().optional(), columns: Columns.optional(), agent: z.string().optional(), notes: z.string().optional() }),
+    }, async (c) => {
+        await requireOn();
+        return reply(201, await createBoard(await c.body()));
+    }),
+    route({ name: "boards.get", method: "GET", path: "/api/boards/:board", summary: "columns, rules, counts and every task (?project=)", errors: boardErrors }, async (c) => {
+        await requireOn();
+        const ref = refOf(c);
+        return (await getBoard(ref)) ?? fail(404, `no board "${ref.board}"`);
+    }),
+    route({ name: "boards.save", method: "PUT", path: "/api/boards/:board", summary: "save title, columns, default agent, stale_after, rules", errors: boardErrors, body: BoardFields }, async (c) => {
+        await requireOn();
+        return saveBoard(refOf(c), (await c.body()));
+    }),
+    route({ name: "boards.delete", method: "DELETE", path: "/api/boards/:board", summary: "move the board, tasks and all, to the trash", errors: boardErrors }, async (c) => {
+        await requireOn();
+        await deleteBoard(refOf(c));
+        return { ok: true };
+    }),
+    route({
+        name: "boards.ensure",
+        method: "POST",
+        path: "/api/boards/default",
+        summary: "the project's (or workspace's) default board `tasks`, created on first use {project?}",
+        errors: boardErrors,
+        body: z.object({ project: z.string().optional() }),
+    }, async (c) => {
+        await requireOn();
+        const ref = await ensureDefaultBoard((await c.body()).project);
+        return (await getBoard(ref));
+    }),
+    route({
+        name: "tasks.create",
+        method: "POST",
+        path: "/api/boards/:board/tasks",
+        summary: "create a task {title, status?, assignee?, due?, tags?, refs?, notes?, actor?, message?} (an assigned agent in a work column is woken)",
+        errors: boardErrors,
+        body: TaskFields.extend({ title: z.string() }),
+    }, async (c) => {
+        await requireOn();
+        return reply(201, await createTask(refOf(c), (await c.body())));
+    }),
+    route({ name: "tasks.get", method: "GET", path: "/api/boards/:board/tasks/:task", summary: "the task: fields, markdown, files, log and the sessions that worked on it (:task = folder name or number)", errors: boardErrors }, async (c) => {
+        await requireOn();
+        const task = (await getTask(refOf(c), c.params.task)) ?? fail(404, `no task "${c.params.task}"`);
+        return { ...task, sessions: await taskSessions(task.ref) };
+    }),
+    route({ name: "tasks.save", method: "PUT", path: "/api/boards/:board/tasks/:task", summary: "save fields and markdown; a status or assignee change is logged (message?)", errors: boardErrors, body: TaskFields }, async (c) => {
+        await requireOn();
+        const { actor, message, ...fields } = await c.body();
+        return saveTask(refOf(c), c.params.task, fields, { actor, message });
+    }),
+    route({
+        name: "tasks.move",
+        method: "POST",
+        path: "/api/boards/:board/tasks/:task/move",
+        summary: "put the task into a column {status, before?, order?, message?, actor?}",
+        errors: boardErrors,
+        body: z.object({ status: z.string(), before: z.string().optional(), order: z.number().optional(), message: z.string().optional(), actor: z.string().optional() }),
+    }, async (c) => {
+        await requireOn();
+        const { status, ...opts } = await c.body();
+        return moveTask(refOf(c), c.params.task, status, opts);
+    }),
+    route({
+        name: "tasks.assign",
+        method: "POST",
+        path: "/api/boards/:board/tasks/:task/assign",
+        summary: 'give the task to an agent {to, message?, actor?}; to = null or "human" hands it back to the review column',
+        errors: boardErrors,
+        body: z.object({ to: z.string().nullable(), message: z.string().optional(), actor: z.string().optional() }),
+    }, async (c) => {
+        await requireOn();
+        const { to, ...opts } = await c.body();
+        return assignTask(refOf(c), c.params.task, to, opts);
+    }),
+    route({
+        name: "tasks.log",
+        method: "POST",
+        path: "/api/boards/:board/tasks/:task/log",
+        summary: "append a stamped line {entry, actor?} to the task's log",
+        errors: boardErrors,
+        body: z.object({ entry: z.string(), actor: z.string().optional() }),
+    }, async (c) => {
+        await requireOn();
+        const { entry, actor } = await c.body();
+        return appendTaskLog(refOf(c), c.params.task, entry, actor);
+    }),
+    route({
+        name: "tasks.pick",
+        method: "POST",
+        path: "/api/boards/:board/pick",
+        summary: "an agent takes the next task of the pick column {agent, column?}; null when there is none",
+        errors: boardErrors,
+        body: z.object({ agent: z.string(), column: z.string().optional() }),
+    }, async (c) => {
+        await requireOn();
+        const { agent, column } = await c.body();
+        return { task: await pickTask(refOf(c), agent, { column }) };
+    }),
+    route({ name: "tasks.delete", method: "DELETE", path: "/api/boards/:board/tasks/:task", summary: "move the task folder to the trash", errors: boardErrors }, async (c) => {
+        await requireOn();
+        await deleteTask(refOf(c), c.params.task);
+        return { ok: true };
+    }),
+];

package/dist/server/api/chats.d.ts

@@ -31,9 +31,11 @@ export declare const chatRoutes: (import("./router.js").Route<"agents.sessions",
         runId: z.ZodOptional<z.ZodString>;
         bundle: z.ZodOptional<z.ZodString>;
         slug: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     resume: z.ZodOptional<z.ZodString>;
     project: z.ZodOptional<z.ZodString>;
+    task: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>> | import("./router.js").Route<"chats.delete", import("./router.js").Reply<{
     error?: string;
 }>, "/api/chats/:id", undefined> | import("./router.js").Route<"chats.elicitation", import("./router.js").Reply<{