@netnodeag/kraftwerk 0.81.0 → 0.82.0

package/dist/core/chat/acp.d.ts

@@ -1,6 +1,6 @@
 import { type ContentBlock, type SessionConfigOption, type SessionNotification } from "@agentclientprotocol/sdk";
 import { type AcpAgent, type AcpExtensionNotification } from "../../acp.js";
-import type { BackendHooks, BackendTuning, ChatBackend, PromptFile } from "./backend.js";
+import { type BackendHooks, type BackendTuning, type ChatBackend, type PromptFile } from "./backend.js";
 import type { AuthStatus, ChatEvent, ConfigOption, ElicitationField, SessionFailure } from "./types.js";
 /** The session failure a `session_info_update` carries, if it is one (AIR `sessionFailure` in `_meta`). */
 export declare function failureOf(meta: unknown): SessionFailure | undefined;

package/dist/core/chat/acp.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { RequestError, } from "@agentclientprotocol/sdk";
 import { adapterEnv, airMeta, connectAcp, EXT_METHODS, EXT_NOTIFICATIONS, fileChangeReportMeta, openSession, withAdapter, } from "../../acp.js";
+import { identityEnv } from "./backend.js";
 import { tempEnv } from "../temp.js";
 import { unattendedMode } from "./permissions.js";
 /**
@@ -390,7 +391,7 @@ export async function startAcpBackend(agent, cwd, hooks, tuning = {}) {
     };
     const { child, conn } = await connectAcp(agent, {
         cwd,
-        env: { ...adapterEnv(agent, tuning), ...(tuning.temp ? tempEnv(tuning.temp) : {}) },
+        env: { ...adapterEnv(agent, tuning), ...(tuning.temp ? tempEnv(tuning.temp) : {}), ...identityEnv(agent, tuning) },
         client,
         clientName: "kraftwerk-inspector",
         elicitation: true,

package/dist/core/chat/backend.d.ts

@@ -39,6 +39,8 @@ export interface BackendTuning {
     addDirs?: string[];
     /** The session's scratch folder (core/temp.ts): handed to the process as TMPDIR and KRAFTWERK_TEMP. */
     temp?: string;
+    /** The agent this seat is (its slug), handed to the process as KRAFTWERK_AGENT, with KRAFTWERK_ACTOR = <slug>/<harness>; absent for a project assistant or Ralv. */
+    agent?: string;
     /**
      * Nobody is watching this session live (routine runs). The backend selects
      * the harness's own hands-off permission mode — the harness keeps deciding
@@ -48,6 +50,15 @@ export interface BackendTuning {
     /** ACP agents: the session id to continue (from ChatMeta.sessions) instead of opening a new one. */
     resume?: string;
 }
+/**
+ * Who the process is, for the CLI it runs: `kraftwerk tasks pick`, `tasks log`,
+ * `journal` and `knowledge put` read KRAFTWERK_AGENT / KRAFTWERK_ACTOR so an
+ * agent never has to name itself. A seat that is no agent (a project
+ * assistant, Ralv) is the actor `kraftwerk-chat/<harness>` — the name its
+ * context already tells it to write with — and has no KRAFTWERK_AGENT, so
+ * `tasks pick` still asks who picks.
+ */
+export declare const identityEnv: (harness: string, tuning: BackendTuning) => Record<string, string>;
 /**
  * How a turn ended. `failure` is the typed session failure the agent
  * attached to the turn's own outcome (a usage limit, a rate limit, a

package/dist/core/chat/backend.js

@@ -1 +1,9 @@
-export {};
+/**
+ * Who the process is, for the CLI it runs: `kraftwerk tasks pick`, `tasks log`,
+ * `journal` and `knowledge put` read KRAFTWERK_AGENT / KRAFTWERK_ACTOR so an
+ * agent never has to name itself. A seat that is no agent (a project
+ * assistant, Ralv) is the actor `kraftwerk-chat/<harness>` — the name its
+ * context already tells it to write with — and has no KRAFTWERK_AGENT, so
+ * `tasks pick` still asks who picks.
+ */
+export const identityEnv = (harness, tuning) => tuning.agent ? { KRAFTWERK_AGENT: tuning.agent, KRAFTWERK_ACTOR: `${tuning.agent}/${harness}` } : { KRAFTWERK_ACTOR: `kraftwerk-chat/${harness}` };

package/dist/core/chat/context.js

@@ -8,6 +8,7 @@ import { listRepos } from "../repos.js";
 import { listVibeables, vibeableStatus, VIBEABLE_CONFIG_FILE } from "../vibeables.js";
 import { projectContext } from "../projects.js";
 import { entitiesContext } from "../entities.js";
+import { boardsContext, taskContext } from "../boards.js";
 import { unattendedTimeoutLabel } from "./permissions.js";
 import { getChannel } from "../channels.js";
 import { JOURNAL_FILE, journalExcerpt, readJournal } from "../journal.js";
@@ -275,8 +276,9 @@ async function baseScopeContext(scope, agent) {
             (await agentFilesContext(def)) +
             `The working directory is the project root. Stay within your role; if a request is clearly outside it, ` +
             `say so and suggest which agent or tool fits better.` +
-            (scope.routine
-                ? `\n\nThis session was started automatically by your scheduled routine "${scope.routine}" — ` +
+            (scope.task ? `\n\n${await taskContext(scope.task)}` : "") +
+            (scope.routine || scope.task
+                ? `\n\nThis session was started automatically by ${scope.routine ? `your scheduled routine "${scope.routine}"` : `the board: task ${scope.task} was given to you`} — ` +
                     `nobody may be watching live. Complete the task autonomously. Edits inside the project ` +
                     `need no approval; anything your harness asks about (shell commands, network, files ` +
                     `outside the project) is shown to a human who may look later — say in one line why you ` +
@@ -394,7 +396,7 @@ export async function scopeContext(meta, seat) {
     const agent = seat.harness;
     // The repositories block reads every clone from git, so it runs alongside
     // the rest instead of adding its spawns to the first prompt's latency.
-    const [base, repos, vibe, skills, channel, project, entities] = await Promise.all([
+    const [base, repos, vibe, skills, channel, project, entities, boards] = await Promise.all([
         baseScopeContext(scope, agent),
         scope.kind === "agent" || scope.kind === "kraftwerk" ? reposContext() : Promise.resolve(""),
         meta.vibeable ? vibeableContext(meta.vibeable, meta.cwd) : Promise.resolve(""),
@@ -404,11 +406,21 @@ export async function scopeContext(meta, seat) {
         meta.scope.kind === "channel" && meta.project ? projectContext(meta.project, `${seat.key}/${agent}`, { member: true }) : Promise.resolve(""),
         // Who, where and when: the workspace's contacts, places and events, wherever the chat works (a run discusses its own artifacts only).
         scope.kind === "run" ? Promise.resolve("") : entitiesContext().catch(() => ""),
+        // Boards: a project chat sees the project's boards; an agent sees the workspace boards narrowed to its tasks, plus its project's when filed under one.
+        scope.kind === "project"
+            ? boardsContext(scope.slug, `kraftwerk-chat/${agent}`).catch(() => "")
+            : scope.kind === "agent"
+                ? Promise.all([boardsContext(undefined, `${scope.slug}/${agent}`, scope.slug), meta.project ? boardsContext(meta.project, `${scope.slug}/${agent}`, scope.slug) : Promise.resolve("")])
+                    .then((xs) => xs.filter(Boolean).join("\n\n"))
+                    .catch(() => "")
+                : Promise.resolve(""),
     ]);
     // Every session has a scratch folder of its own (core/temp.ts), named by its absolute path: a run chat or a
     // vibeable session works in another folder than the workspace root. The block comes after the files blocks it refers to.
     const temp = await sessionTemp(meta.id).catch(() => null);
-    return [base, channel, project, repos, entities, vibe, temp ? tempContext(temp.abs) : "", RENDERING_BLOCK, skillsBlock(skills)].filter(Boolean).join("\n\n");
+    // "Work on this" from a task page: the chat is tagged with the task (meta.task) and reads it like the agent's own task session would.
+    const task = meta.task && !(scope.kind === "agent" && scope.task === meta.task) ? await taskContext(meta.task).catch(() => "") : "";
+    return [base, channel, project, boards, task, repos, entities, vibe, temp ? tempContext(temp.abs) : "", RENDERING_BLOCK, skillsBlock(skills)].filter(Boolean).join("\n\n");
 }
 /** The channel block a member agent gets once per process: who is here, how turns work, how to hand over. */
 async function channelContext(slug, self) {

package/dist/core/chat/pi.d.ts

@@ -1,2 +1,2 @@
-import type { BackendHooks, BackendTuning, ChatBackend } from "./backend.js";
+import { type BackendHooks, type BackendTuning, type ChatBackend } from "./backend.js";
 export declare function startPiBackend(cwd: string, hooks: BackendHooks, tuning?: BackendTuning): ChatBackend;

package/dist/core/chat/pi.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { identityEnv } from "./backend.js";
 import { workspaceEnv } from "../env.js";
 import { tempEnv } from "../temp.js";
 const clip = (raw) => {
@@ -25,7 +26,7 @@ export function startPiBackend(cwd, hooks, tuning = {}) {
                 const proc = spawn("pi", ["-p", "--mode", "json", "--session-id", sessionId, ...tuningArgs], {
                     cwd,
                     stdio: ["pipe", "pipe", "pipe"],
-                    env: { ...workspaceEnv(), ...(tuning.temp ? tempEnv(tuning.temp) : {}) },
+                    env: { ...workspaceEnv(), ...(tuning.temp ? tempEnv(tuning.temp) : {}), ...identityEnv("pi", tuning) },
                 });
                 child = proc;
                 proc.stdin.write(text);

package/dist/core/chat/seats.js

@@ -23,6 +23,7 @@ async function backendTuning(meta, seat) {
     const tuning = {};
     const agentSlug = scope.kind === "agent" ? scope.slug : scope.kind === "channel" ? seat.key : undefined;
     if (agentSlug) {
+        tuning.agent = agentSlug;
         const def = await getAgent(agentSlug).catch(() => null);
         if (def?.model)
             tuning.model = def.model;
@@ -106,7 +107,7 @@ export async function ensureBackend(state, seat) {
                     });
                     if (!state.pendingInfo.has(requestId))
                         await dismissKey(notifyKey);
-                });
+                }).catch(() => { });
                 if (isUnattended(state.meta.scope)) {
                     deadline = setTimeout(() => {
                         const pending = state.pendingPermissions.get(requestId);
@@ -157,7 +158,7 @@ export async function ensureBackend(state, seat) {
                     });
                     if (!state.pendingInfo.has(requestId))
                         await dismissKey(notifyKey);
-                });
+                }).catch(() => { });
                 if (isUnattended(state.meta.scope)) {
                     deadline = setTimeout(() => {
                         const pending = state.pendingElicitations.get(requestId);

package/dist/core/chat/sessions.d.ts

@@ -30,6 +30,8 @@ export declare function createChat(opts: {
     resume?: string;
     /** The project an agent's chat works in (meta.project); the caller checks that it exists. */
     project?: string;
+    /** The board task the chat works on (meta.task); the caller checks that it exists. */
+    task?: string;
     /** Who starts it; default this machine's person. */
     author?: ChatPerson;
     /** A private routine's run: hidden from remote callers (meta.private). */

package/dist/core/chat/sessions.js

@@ -55,6 +55,7 @@ export async function createChat(opts) {
         cwd,
         scope: opts.scope,
         ...(opts.project && opts.scope.kind === "agent" ? { project: opts.project } : {}),
+        ...(opts.task ? { task: opts.task } : {}),
         ...(opts.resume && opts.agent !== "pi" ? { sessions: { [MAIN]: opts.resume } } : {}),
         author,
         ...(opts.private ? { private: true } : {}),

package/dist/core/chat/state.js

@@ -29,7 +29,7 @@ export const isBusy = (state) => [...state.seats.values()].some((s) => s.busy);
 /** The event author for a seat: channel members sign their events, the lone agent of a chat does not. */
 export const seatAuthor = (seat) => (seat.key === MAIN ? undefined : { kind: "agent", slug: seat.key });
 /** Routine-fired sessions: nobody is expected to be watching live. */
-export const isUnattended = (scope) => scope.kind === "agent" && !!scope.routine;
+export const isUnattended = (scope) => scope.kind === "agent" && (!!scope.routine || !!scope.task);
 /** Diagnose handle for a failed routine session (only called for unattended agent scopes). */
 export function routineRef(meta) {
     const scope = meta.scope;

package/dist/core/chat/types.d.ts

@@ -16,10 +16,13 @@ export type ChatScope = {
 } | {
     kind: "knowledge";
     bundle?: string;
-} | {
+}
+/** `routine`: a scheduled run; `task`: opened for a task (<project>/<board>/<task>) the agent was assigned — both unattended. */
+ | {
     kind: "agent";
     slug: string;
     routine?: string;
+    task?: string;
 }
 /** A project: the chat carries its brief, state, systems of record and links; see projects.ts. */
  | {
@@ -64,6 +67,13 @@ export interface ChatMeta {
      * the project and hands every seat the project's context.
      */
     project?: string;
+    /**
+     * The board task this chat works on (<project>/<board>/<task> or
+     * <board>/<task>) when the scope is not the agent's task session itself:
+     * "work on this" from the task page. The task page lists the chat as one
+     * of its sessions, and every seat gets the task block in its context.
+     */
+    task?: string;
     /**
      * The agent's own session id per seat ("main", or the agent slug in a
      * channel): after a restart or the idle reaper, the next backend resumes

package/dist/core/files.d.ts

@@ -19,7 +19,7 @@ export declare const PROJECT_FILES_DIR = "files";
 export declare const LOCAL_OVER_BYTES: number;
 /** Upload cap: a guard against a runaway request, not a policy. */
 export declare const MAX_UPLOAD_BYTES: number;
-/** "workspace" or "project:<slug>". */
+/** "workspace", "project:<slug>" or "task:<board>/<task>" / "task:<project>/<board>/<task>" (a task's folder). */
 export type FilesScope = string;
 export interface FileEntry {
     name: string;

package/dist/core/files.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { pipeline } from "node:stream/promises";
 import { resolveWorkspace } from "../config.js";
 import { workspaceRoot } from "./context.js";
+import { findTask, noteTaskFile, TASK_FILE, TASK_LOG } from "./boards.js";
 import { listProjects, openProjects, safeProjectSlug } from "./projects.js";
 import { moveToTrash } from "./trash.js";
 /**
@@ -66,6 +67,13 @@ export async function scopeRoot(scope) {
         const abs = path.join(workspace, WORKSPACE_FILES_DIR);
         return { abs, rel: WORKSPACE_FILES_DIR, label: "Workspace", workspace };
     }
+    const task = /^task:(.+)$/.exec(scope);
+    if (task) {
+        const t = await findTask(task[1]);
+        if (!t)
+            throw new Error(`no task "${task[1]}"`);
+        return { abs: t.path, rel: path.relative(workspace, t.path).split(path.sep).join("/"), label: `${t.number} ${t.title}`, workspace };
+    }
     const m = /^project:(.+)$/.exec(scope);
     if (!m)
         throw new Error(`invalid files scope "${scope}"`);
@@ -153,9 +161,13 @@ export async function listFiles(scope, rel = "") {
     const local = new Set(await readIgnore(root.abs));
     const kids = st ? await fs.readdir(dir, { withFileTypes: true }) : [];
     const entries = [];
+    const taskScope = scope.startsWith("task:");
     for (const k of kids) {
         if (k.name.startsWith("."))
             continue;
+        // A task's own markdown and log are the task, not its files.
+        if (taskScope && dir === root.abs && (k.name === TASK_FILE || k.name === TASK_LOG))
+            continue;
         const abs = path.join(dir, k.name);
         const s = await fs.stat(abs).catch(() => null);
         if (!s)
@@ -228,6 +240,8 @@ export async function saveUpload(scope, dirRel, name, body) {
     const p = toPosix(path.relative(root.abs, abs));
     if (size > LOCAL_OVER_BYTES)
         await markLocal(root.abs, p, true);
+    if (scope.startsWith("task:"))
+        await noteTaskFile(scope.slice(5), "added", p).catch(() => { });
     return { name: final, path: p, type: "file", size, modifiedAt: new Date().toISOString(), mime: mimeOf(final), ...(size > LOCAL_OVER_BYTES ? { local: true } : {}) };
 }
 export async function makeFolder(scope, rel) {
@@ -271,10 +285,14 @@ export async function deleteFile(scope, rel) {
     if (!st)
         throw new Error(`no file "${rel}"`);
     const p = toPosix(path.relative(root.abs, abs));
-    const owner = scope === "workspace" ? "workspace" : `projects/${scope.slice("project:".length)}`;
+    if (scope.startsWith("task:") && (p === TASK_FILE || p === TASK_LOG))
+        throw new Error("the task's own files cannot be removed");
+    const owner = scope === "workspace" ? "workspace" : scope.startsWith("task:") ? `tasks/${scope.slice(5)}` : `projects/${scope.slice("project:".length)}`;
     await moveToTrash("files", `${owner}/${p}`, abs);
     if (st.isFile() && st.size > LOCAL_OVER_BYTES)
         await markLocal(root.abs, p, false);
+    if (scope.startsWith("task:"))
+        await noteTaskFile(scope.slice(5), "removed", p).catch(() => { });
 }
 /* ---------- context for agents ---------- */
 /** "files/ (23 files; recent: designs/home-v3.png 2026-10-05, …)" — where the files are, not every file. */

package/dist/core/git.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
 import path from "node:path";
-import { ENTITY_KINDS, entitiesRootFor, projectsRootFor, reposRootFor, resolveWorkspace, vibeablesRootFor, isSafeGitName } from "../config.js";
+import { boardsRootFor, ENTITY_KINDS, entitiesRootFor, projectsRootFor, reposRootFor, resolveWorkspace, vibeablesRootFor, isSafeGitName } from "../config.js";
 import { ENV_FILE } from "../runner/docker.js";
 import { getOutputDir, workspaceRoot } from "./context.js";
 import { perWorkspace, workspaceOpen } from "./workspace.js";
@@ -241,6 +241,8 @@ function scopeFor({ project, repoRoot }) {
         projectsRootFor(project),
         // Contacts, places and events: who, where and when — the workspace's records.
         ...ENTITY_KINDS.map((kind) => entitiesRootFor(project, kind)),
+        // Workspace boards: tasks, logs and their files (project boards sit inside the projects root).
+        boardsRootFor(project),
         // Workspace files: shared material, versioned (files over 25 MB ignore themselves, see files.ts).
         path.resolve(project.root, "kraftwerk-data/files"),
         project.configPath,

package/dist/core/notifications.d.ts

@@ -10,7 +10,7 @@ import type { ChatMeta } from "./chat/types.js";
  * Approval items carry a `key` so the same request is never listed twice
  * and disappears again the moment someone answers (dismissKey).
  */
-export type NotificationKind = "approval" | "routine_done" | "routine_failed" | "run_done" | "run_failed";
+export type NotificationKind = "approval" | "routine_done" | "routine_failed" | "run_done" | "run_failed" | "task_woken" | "task_wake_failed";
 /**
  * What a "diagnose" on a failure item should look at: a workflow run (chat
  * in the run folder) or a routine (its agent, and the session that failed

package/dist/core/refs.d.ts

@@ -13,7 +13,7 @@
  * like never do. A target that does not exist is reported (found: false),
  * never an error — the same rule project links have always followed.
  */
-export declare const REF_KIND_NAMES: readonly ["knowledge", "vibeables", "repos", "workflows", "agents", "projects", "contacts", "places", "events"];
+export declare const REF_KIND_NAMES: readonly ["knowledge", "vibeables", "repos", "workflows", "agents", "projects", "contacts", "places", "events", "boards", "tasks"];
 /** The kind's plural: the link-list name in project.yml and the folder/route name. */
 export type RefKind = (typeof REF_KIND_NAMES)[number];
 /** One existing target. */

package/dist/core/refs.js

@@ -1,5 +1,6 @@
 import { listAgents } from "./agents.js";
 import { CONTACTS, EVENTS, listEntities, PLACES } from "./entities.js";
+import { boardKey, listAllBoards } from "./boards.js";
 import { knowledgeIndex } from "./knowledge.js";
 import { listProjects } from "./projects.js";
 import { listRepos } from "./repos.js";
@@ -20,7 +21,7 @@ import { listWorkflows } from "./workflows.js";
  * like never do. A target that does not exist is reported (found: false),
  * never an error — the same rule project links have always followed.
  */
-export const REF_KIND_NAMES = ["knowledge", "vibeables", "repos", "workflows", "agents", "projects", "contacts", "places", "events"];
+export const REF_KIND_NAMES = ["knowledge", "vibeables", "repos", "workflows", "agents", "projects", "contacts", "places", "events", "boards", "tasks"];
 /** A list that fails to read is an empty list: a reference into it is "not found", never an error. */
 const safe = async (p, fallback) => p.catch(() => fallback);
 export const REF_KINDS = [
@@ -80,7 +81,30 @@ export const REF_KINDS = [
         noun: "event",
         list: async () => (await safe(listEntities(EVENTS), { items: [] })).items.map((e) => ({ slug: e.slug, label: EVENTS.describe(e), href: `/events/${e.slug}` })),
     },
+    {
+        kind: "boards",
+        token: "board",
+        noun: "board",
+        // A board's slug is unique within its project; across the workspace the first match wins and the label names where it is.
+        list: async () => (await safe(listAllBoards(), [])).map((b) => ({ slug: b.board, label: b.project ? `${b.title} · project ${b.project}` : b.title, href: boardHref(b) })),
+    },
+    {
+        kind: "tasks",
+        token: "task",
+        noun: "task",
+        list: async () => {
+            const { getBoard } = await import("./boards.js");
+            const out = [];
+            for (const b of await safe(listAllBoards(), [])) {
+                const detail = await safe(getBoard(b), null);
+                for (const t of detail?.items ?? [])
+                    out.push({ slug: t.slug, label: `${t.title} · ${boardKey(b)} (${t.status})`, href: `${boardHref(b)}/${t.slug}` });
+            }
+            return out;
+        },
+    },
 ];
+const boardHref = (b) => (b.project ? `/projects/${b.project}/boards/${b.board}` : `/boards/${b.board}`);
 const byKind = new Map(REF_KINDS.map((d) => [d.kind, d]));
 const byToken = new Map(REF_KINDS.map((d) => [d.token, d]));
 /** The kind registered under a plural name or a token; undefined for anything else. */

package/dist/core/search.d.ts

@@ -27,6 +27,18 @@ export interface WorkspaceAgents {
     projects: ProjectHit[];
     /** Contacts, places and events of this instance (the registry does not carry them); empty for other workspaces and while the features are off. */
     entities: EntityHit[];
+    /** Open tasks of this instance's boards; empty for other workspaces and while boards are off. */
+    tasks: TaskHit[];
+}
+/** What the palette needs of a task. */
+export interface TaskHit {
+    slug: string;
+    title: string;
+    board: string;
+    project?: string;
+    status: string;
+    /** Where it opens. */
+    href: string;
 }
 /** What the palette needs of a contact, place or event. */
 export interface EntityHit {

package/dist/core/search.js

@@ -6,6 +6,23 @@ import { listChannels, toChannelSummary } from "./channels.js";
 import { currentInstanceUrl, discoverWorkspaces, listWorkspaceRecords } from "./instances.js";
 import { CONTACTS, EVENTS, listEntities, PLACES } from "./entities.js";
 import { listProjects, toProjectHit } from "./projects.js";
+import { getBoard, listAllBoards } from "./boards.js";
+async function taskHits() {
+    const out = [];
+    for (const b of await listAllBoards().catch(() => [])) {
+        const detail = await getBoard(b).catch(() => null);
+        if (!detail)
+            continue;
+        const done = new Set(detail.columns.filter((c) => c.done).map((c) => c.slug));
+        for (const t of detail.items) {
+            if (t.configError || done.has(t.status))
+                continue;
+            const base = b.project ? `/projects/${b.project}/boards/${b.board}` : `/boards/${b.board}`;
+            out.push({ slug: t.slug, title: t.title, board: b.board, ...(b.project ? { project: b.project } : {}), status: t.status, href: `${base}/${t.slug}` });
+        }
+    }
+    return out;
+}
 async function entityHits(def) {
     const view = await listEntities(def).catch(() => ({ items: [] }));
     return view.items
@@ -28,6 +45,7 @@ export async function searchAgents() {
         channels: (await listChannels().catch(() => [])).map(toChannelSummary),
         projects: (await listProjects().catch(() => ({ projects: [] }))).projects.filter((p) => p.status !== "archived").map(toProjectHit),
         entities: (await Promise.all([CONTACTS, PLACES, EVENTS].map(entityHits))).flat(),
+        tasks: await taskHits(),
     };
     const [workspaces, known] = await Promise.all([discoverWorkspaces(), listWorkspaceRecords()]);
     const records = new Map(known.map((p) => [p.root, p]));
@@ -45,6 +63,7 @@ export async function searchAgents() {
         channels: records.get(w.root)?.channels ?? [],
         projects: records.get(w.root)?.projects ?? [],
         entities: [],
+        tasks: [],
     }));
     return { workspaces: [self, ...others] };
 }

package/dist/core/settings.d.ts

@@ -36,6 +36,8 @@ export interface SaveSettingsInput {
     contacts?: ReposSettingsInput;
     places?: ReposSettingsInput;
     events?: ReposSettingsInput;
+    /** Omitted = untouched. Same shape and rules as repos (boards.columns in the file is kept). */
+    boards?: ReposSettingsInput;
 }
 export interface ReposSettingsInput {
     enabled: boolean;

package/dist/core/settings.js

@@ -1,7 +1,8 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { parseDocument } from "yaml";
-import { ENTITY_KINDS, entityDefaultRoot, ignoreEntryFor, PROJECTS_DEFAULT_ROOT, REPOS_DEFAULT_ROOT, resolveWorkspace, VIBEABLES_DEFAULT_ROOT, isSafeGitName } from "../config.js";
+import { BOARDS_DEFAULT_ROOT, ENTITY_KINDS, entityDefaultRoot, ignoreEntryFor, PROJECTS_DEFAULT_ROOT, REPOS_DEFAULT_ROOT, resolveWorkspace, VIBEABLES_DEFAULT_ROOT, isSafeGitName } from "../config.js";
+import { ensureBoardsRoot } from "./boards.js";
 import { ensureEntitiesRoot } from "./entities.js";
 import { ensureProjectsRoot } from "./projects.js";
 import { disposeAllDevs, ensureVibeablesRoot } from "./vibeables.js";
@@ -84,6 +85,7 @@ const ROOT_DEFAULTS = {
     contacts: entityDefaultRoot("contacts"),
     places: entityDefaultRoot("places"),
     events: entityDefaultRoot("events"),
+    boards: BOARDS_DEFAULT_ROOT,
 };
 /** The repos, vibeables, projects, contacts, places or events block to write; null when the feature is off and nothing else is set. */
 function cleanRootBlock(block, value, projectRoot) {
@@ -181,6 +183,14 @@ export async function saveSettings(input) {
         else
             doc.set(kind, block);
     }
+    if (input.boards !== undefined) {
+        const block = cleanRootBlock("boards", input.boards, project.root);
+        const columns = project.config.boards?.columns;
+        if (block === null && !columns)
+            doc.delete("boards");
+        else
+            doc.set("boards", { ...(block ?? { enabled: false }), ...(columns ? { columns } : {}) });
+    }
     await fs.writeFile(configPath, doc.toString());
     // Turning repositories on prepares the folder so the first clone and the
     // workspace git both find it in the right state.
@@ -193,5 +203,7 @@ export async function saveSettings(input) {
     for (const kind of ENTITY_KINDS)
         if (input[kind]?.enabled)
             await ensureEntitiesRoot(kind).catch(() => { });
+    if (input.boards?.enabled)
+        await ensureBoardsRoot().catch(() => { });
     return getSettings();
 }

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/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>>)[];