@netnodeag/kraftwerk 0.57.3 → 0.58.0

package/README.md

@@ -158,6 +158,8 @@ kraftwerk knowledge                     # Knowledge: OKF bundles (list/get/put/v
 kraftwerk ui                            # inspector web UI on http://localhost:1981; --port, --output
 kraftwerk workspaces                    # every workspace on this machine; workspaces start|stop|forget <ref>
 kraftwerk projects                      # goal-scoped project folders; projects create|show|link|log|remove
+kraftwerk trash                         # what was deleted; trash restore|purge <id>, trash empty
+kraftwerk journal <agent> ["<entry>"]   # an agent's memory across sessions: print it, add a line (--kind)
 kraftwerk doctor                        # preflight: harness CLIs, docker, workflows, declared env vars
 kraftwerk validate                      # all discovered: schema + semantics + files, exit 1 on failure
 kraftwerk validate src/workflows/pitch  # specific paths
@@ -169,6 +171,15 @@ kraftwerk tunnel setup kw.example.com   # Cloudflare Tunnel to the inspector: lo
 kraftwerk tunnel                        # run that tunnel alone (the UI runs elsewhere)
 ```
 
+Nothing is deleted at once. Removing an agent, a project, a knowledge bundle,
+a vibeable, a channel, a repository, a chat or a run, in the inspector or the
+CLI, moves its folder to `kraftwerk-data/trash/`. The trash mirrors the
+workspace (`trash/agents/<slug>`, `trash/knowledge/<bundle>`,
+`trash/projects/<slug>`, `trash/chats/<id>`, …) and ignores itself in git.
+The **trash** screen (`#/trash`) or `kraftwerk trash restore <id>` puts an entry
+back where it came from. Deleting it there, or `kraftwerk trash empty`, makes it
+final. A chat's agent transcripts are only removed then, so a restored chat can resume.
+
 The inspector binds `127.0.0.1` — it has no authentication of its own and
 its chat runs coding agents against the repo, so it stays off the LAN, and
 while bound there it only answers requests whose `Host` is a loopback name
@@ -510,6 +521,11 @@ directory stays the workspace root, so linked repositories and knowledge
 are reachable by path; opening a vibeable moves it into the app folder as
 in any chat.
 
+**In the rail.** The agents linked to a project and its apps (the linked
+vibeables) are listed under the project. Pin an app from the vibeables tab
+of the project's context column, or unpin it there; clicking it in the rail
+opens the project with the app beside its chat (`#/projects/<slug>?app=<vibeable>`).
+
 **Coworkers.** "Add coworker" on a project chat works as on an agent
 session: the chat becomes a channel whose members are the agents you pick,
 with everything said so far and the project's brief, state, records and
@@ -530,6 +546,37 @@ kraftwerk projects remove relaunch-netnode-ch
 The registry of workspaces on this machine, which answered to
 `kraftwerk projects` until 0.48, is `kraftwerk workspaces` now.
 
+## Files
+
+Files are the material of the work, in any format: briefings, contracts,
+designs, spreadsheets, deliverables. They are plain folders with two kinds
+of owner, chosen by how long a file lives:
+
+```
+kraftwerk-data/files/                    # workspace files: shared, outlive any project
+kraftwerk-data/projects/<slug>/files/    # a project's files: archived and trashed with the project
+```
+
+Agents own no files. They work in the project's files when they work on
+a project, and may link workspace folders in `agent.yml` (`files: [contracts]`)
+the way they link knowledge. Every session's context names the folders, the
+file count and the latest changes, not every file, and tells the agent to put
+what it produces in `files/deliverables/` (or `files/inbox/` without a
+project). Because they are plain folders, agents read and write them like any
+directory, and you can drop files in with Finder.
+
+The **files** page (`#/files`) has the workspace and every project on the
+left, the folder in the middle, and a preview on the right for images, PDFs,
+video, audio, markdown, CSV and text. Drop files anywhere on the list to
+upload. A project's chat has the same browser in its context column. Files
+are versioned in the workspace git; a file over 25 MB stays local, listed in
+the files root's own `.gitignore` and marked "local only". Deleting goes to
+the trash (`trash/files/…`, mirroring the folders).
+
+Files are not knowledge. A knowledge bundle holds curated, verified concepts,
+and a file becomes part of one as evidence, in the bundle's `references/`
+folder, which concepts cite in `sources` (OKF §5.1, §6.3).
+
 ## Persistent agents
 
 The inspector's "agents" screen turns chat agents into persistent teammates. An
@@ -539,6 +586,7 @@ agent is one folder under the project's `agents/` root:
 agents/max/
   agent.yml     # name, emoji, description, harness, model, effort, workflows, knowledge, vibeables
   system.md     # the agent's system prompt (its role)
+  journal.md    # the agent's own memory across sessions (written through `kraftwerk journal`)
 ```
 
 ```yaml
@@ -564,6 +612,40 @@ and write knowledge through `kraftwerk knowledge`, with writes stamped with
 the agent's own actor, `<slug>/<harness>`. So the agent triggers its own
 workflows when a request matches, and keeps its bundles current.
 
+Every agent keeps a journal, `agents/<slug>/journal.md`: what it learned,
+decided, promised and finished, one line per entry under a dated heading,
+newest first. The recent days (about 4,000 characters) are part of every
+new session's context, together with how to add to it:
+
+```bash
+kraftwerk journal max                                          # print it
+kraftwerk journal max "send the summary on Friday" --kind promised   # learned | decided | promised | done | note
+```
+
+The agent's own lines are not signed; a line from anyone else is stamped
+with its actor. In the inspector, the agent's context column has a
+**journal** tab, where you can also add a note for the agent to remember
+(`GET`/`POST /api/agents/:slug/journal`). That is what makes an agent the
+same colleague next week, whichever chat you open.
+
+**What needs you.** Everything that blocks an agent, an approval or a
+question it asked, plus failures nobody has opened yet, is one list
+(`GET /api/attention`), oldest first, each item with its owner: the agent,
+the project or the channel. The rail puts a red count on every row that
+leads there: the agent, the project (its own chats and its agents'), the
+channel, Ralv, and the projects header while folded. The bell lists these
+items under "needs you", grouped by owner, with finished runs and routines
+below as "updates". **next** in the top bar (⌥N) opens the next waiting
+item where it lives: the chat, scrolled to the card, which lights up, with
+the project's or agent's context beside it. Answer, press next again.
+Notification titles name the owner first ("🦊 Lisa needs approval").
+
+Under each agent's name the rail shows what it is doing now: waiting for
+you (an approval or a question, with a red light), working (in which chat,
+for how long, with a pulsing light), the next routine due within a day and
+a half, or when it was last active (`GET /api/agent-status`). Agents linked
+to a project are listed under the project too.
+
 A chat keeps the agent's own session. The ACP session id is stored with the
 chat (`sessions` in `meta.json`), and the next process — after an inspector
 restart, or once the idle reaper released the agent — resumes it over
@@ -593,8 +675,8 @@ and cost plus the model and thinking settings it lets you change live
 (`POST /api/chats/:id/config`). The agent's slash commands join the
 skills in the `/` menu. Each turn ends with the files the agent says it
 changed. Background tasks that can be stopped have a stop button
-(`POST /api/chats/:id/task-stop`). Deleting a chat deletes the agent's own
-sessions with it, and "continue a session" on the new-chat screen lists
+(`POST /api/chats/:id/task-stop`). Deleting a chat moves it to the trash; the
+agent's own sessions go when it is deleted from there, and "continue a session" on the new-chat screen lists
 the agent's sessions in the project (`GET /api/agent-sessions`) to pick
 one up as a chat.
 
@@ -821,6 +903,7 @@ kraftwerk knowledge search "refund"                     # full-text across bundl
 kraftwerk knowledge verify customer-support/playbooks/refunds --by human:user
 kraftwerk knowledge validate                            # OKF conformance + warnings
 kraftwerk knowledge fsck --fix                          # heal out-of-band edits (reindex)
+kraftwerk knowledge remove customer-support             # move the bundle to the trash
 ```
 
 Actors follow the OKF convention: `<producer>/<version>` for agents,

package/dist/acp.js

@@ -157,7 +157,8 @@ export function divertExtensionUpdates(source, onExtension) {
  * representation of that work.
  */
 export async function connectAcp(agent, opts) {
-    const entry = fileURLToPath(import.meta.resolve(ADAPTERS[agent]));
+    // KRAFTWERK_ACP_ADAPTER: a script standing in for the adapter (the tests' scripted fake agent).
+    const entry = process.env.KRAFTWERK_ACP_ADAPTER || fileURLToPath(import.meta.resolve(ADAPTERS[agent]));
     const child = spawn(process.execPath, [entry], {
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "pipe"],

package/dist/cli/journal.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+/**
+ * `kraftwerk journal` — an agent's own memory across sessions
+ * (agents/<slug>/journal.md). Agents write it from their sessions; every
+ * new session starts with the recent part of it:
+ *
+ *   kraftwerk journal <agent>                          print the journal
+ *   kraftwerk journal <agent> "<entry>" [--kind ..]    add a line under today (learned|decided|promised|done|note)
+ */
+export declare function registerJournalCommands(program: Command): void;

package/dist/cli/journal.js

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { appendJournal, JOURNAL_KINDS, readJournal } from "../inspector/journal.js";
+import { initContext as prepare } from "./routines.js";
+/**
+ * `kraftwerk journal` — an agent's own memory across sessions
+ * (agents/<slug>/journal.md). Agents write it from their sessions; every
+ * new session starts with the recent part of it:
+ *
+ *   kraftwerk journal <agent>                          print the journal
+ *   kraftwerk journal <agent> "<entry>" [--kind ..]    add a line under today (learned|decided|promised|done|note)
+ */
+export function registerJournalCommands(program) {
+    program
+        .command("journal")
+        .description("An agent's journal: print it, or add one line (what it learned, decided, promised, did)")
+        .argument("<agent>", "Agent slug (folder under agents/)")
+        .argument("[entry]", "One line to add under today's date")
+        .option("--kind <kind>", `Kind of entry: ${JOURNAL_KINDS.join(" | ")}`, "note")
+        .option("--actor <actor>", "Who writes (default: the agent itself; KRAFTWERK_ACTOR)")
+        .action(async (agent, entry, opts) => {
+        await prepare();
+        try {
+            if (!entry) {
+                const text = await readJournal(agent);
+                console.log(text.trim() || chalk.dim(`${agent}'s journal is empty.`));
+                return;
+            }
+            await appendJournal(agent, entry, { kind: opts.kind, actor: opts.actor ?? process.env.KRAFTWERK_ACTOR });
+            console.log(`${chalk.green("✔")} added to ${chalk.cyan(agent)}'s journal`);
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(2);
+        }
+    });
+}

package/dist/cli/knowledge.js

@@ -3,6 +3,8 @@ import path from "node:path";
 import chalk from "chalk";
 import { resolveProject } from "../config.js";
 import { fsck, getConcept, initBundle, knowledgeRoot, listBundles, listConcepts, searchKnowledge, validateBundle, verifyConcept, writeConcept, } from "../okf.js";
+import { deleteBundle } from "../inspector/knowledge.js";
+import { initContext as prepare } from "./routines.js";
 /**
  * `kraftwerk knowledge` — the CLI surface over OKF bundles (the
  * inspector's Knowledge screen). This is the enforced write path: `put` stamps provenance
@@ -182,6 +184,21 @@ export function registerKnowledgeCommands(program) {
             process.exit(2);
         }
     });
+    knowledge
+        .command("remove")
+        .description("Move a bundle to the trash (`kraftwerk trash` puts it back)")
+        .argument("<bundle>", "Bundle name")
+        .action(async (bundle) => {
+        try {
+            await prepare();
+            await deleteBundle(bundle);
+            console.log(`${chalk.green("✔")} moved ${chalk.cyan(bundle)} to the trash`);
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(2);
+        }
+    });
     knowledge
         .command("validate")
         .description("OKF conformance check (errors) + provenance/staleness warnings")

package/dist/cli/kraftwerk.js

@@ -16,6 +16,8 @@ import { registerProjectCommands } from "./projects.js";
 import { registerWorkspaceCommands } from "./workspaces.js";
 import { registerRepoCommands } from "./repos.js";
 import { registerVibeableCommands } from "./vibeables.js";
+import { registerTrashCommands } from "./trash.js";
+import { registerJournalCommands } from "./journal.js";
 import { registerTunnelCommands } from "./tunnel.js";
 import { applyDotenv } from "../dotenv.js";
 import { resolveProject } from "../config.js";
@@ -36,6 +38,8 @@ import { runUi } from "./ui.js";
  *   kraftwerk projects ...            goal-scoped project folders (list/create/show/link/log/remove)
  *   kraftwerk vibeables ...           small apps built live in a chat (list/create/remove)
  *   kraftwerk repos ...               repositories the agents work on (list/add/update/remove)
+ *   kraftwerk journal <agent> [entry] an agent's memory across sessions: print it, add a line
+ *   kraftwerk trash ...               what was deleted: list, restore, purge, empty
  *   kraftwerk tunnel [setup <host>]   Cloudflare Tunnel to the inspector: run it alone, or set one up
  *   kraftwerk doctor                  preflight: harness CLIs, docker, workflows, env
  *   kraftwerk validate [paths...]     validate without executing
@@ -286,6 +290,8 @@ registerWorkspaceCommands(program);
 registerProjectCommands(program);
 registerRepoCommands(program);
 registerVibeableCommands(program);
+registerTrashCommands(program);
+registerJournalCommands(program);
 registerTunnelCommands(program);
 program
     .command("ui")

package/dist/cli/projects.js

@@ -19,7 +19,7 @@ import { fmtAgo } from "./workspaces.js";
  *   kraftwerk projects link <slug> <kind> <name>    add a knowledge|vibeables|repos|workflows|agents link
  *   kraftwerk projects unlink <slug> <kind> <name>  remove one
  *   kraftwerk projects log <slug> "<entry>"         append a stamped line to log.md (--actor)
- *   kraftwerk projects remove <slug>                delete the folder (its history stays in the workspace git)
+ *   kraftwerk projects remove <slug>                move the folder to the trash
  *
  * The workspace registry answered to this name until 0.48; it is
  * `kraftwerk workspaces` now (workspaces.ts).
@@ -208,13 +208,13 @@ export function registerProjectCommands(program) {
     });
     projects
         .command("remove")
-        .description("Delete a project folder; its history stays in the workspace git")
+        .description("Move a project folder to the trash (`kraftwerk trash` puts it back)")
         .argument("<slug>", "Folder name under the root")
         .action(async (slug) => {
         await prepare();
         try {
             await deleteProject(slug);
-            console.log(`${chalk.green("✔")} removed ${chalk.cyan(slug)}`);
+            console.log(`${chalk.green("✔")} moved ${chalk.cyan(slug)} to the trash`);
         }
         catch (err) {
             die(err.message);

package/dist/cli/repos.js

@@ -110,6 +110,6 @@ export function registerRepoCommands(program) {
         const r = await removeRepo(name, !!opts.force).catch((err) => ({ ok: false, error: err.message }));
         if (!r.ok)
             die(r.error ?? "remove failed");
-        console.log(`${chalk.green("✔")} removed ${chalk.cyan(name)}`);
+        console.log(`${chalk.green("✔")} moved ${chalk.cyan(name)} to the trash`);
     });
 }

package/dist/cli/trash.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerTrashCommands(program: Command): void;

package/dist/cli/trash.js

@@ -0,0 +1,70 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import { emptyTrash, listTrash, purgeFromTrash, restoreFromTrash, trashRoot } from "../inspector/trash.js";
+import { fmtAgo } from "./workspaces.js";
+import { initContext as prepare } from "./routines.js";
+/**
+ * `kraftwerk trash` — what was deleted (agents, projects, knowledge bundles,
+ * vibeables, channels, repos, chats, runs), kept under kraftwerk-data/trash
+ * until it is deleted from there:
+ *
+ *   kraftwerk trash                  list: id, what it was, when
+ *   kraftwerk trash restore <id>     put an entry back where it came from
+ *   kraftwerk trash purge <id>       delete one entry for good
+ *   kraftwerk trash empty            delete everything in the trash for good
+ */
+const die = (msg) => {
+    console.error(chalk.red(msg));
+    process.exit(1);
+};
+export function registerTrashCommands(program) {
+    const trash = program.command("trash").description("What was deleted: list, restore, purge one, empty");
+    trash
+        .command("list", { isDefault: true })
+        .description("List the trash, newest first")
+        .option("--json", "Machine-readable output")
+        .action(async (opts) => {
+        await prepare();
+        const entries = await listTrash();
+        if (opts.json) {
+            console.log(JSON.stringify(entries, null, 2));
+            return;
+        }
+        if (entries.length === 0) {
+            console.log(chalk.dim("The trash is empty."));
+            return;
+        }
+        const table = new Table({ head: ["id", "was", "deleted"].map((h) => chalk.bold(h)), wordWrap: true });
+        for (const e of entries)
+            table.push([chalk.cyan(e.id), chalk.dim(e.from), chalk.dim(fmtAgo(e.trashedAt))]);
+        console.log(table.toString());
+        console.log(chalk.dim(await trashRoot()));
+    });
+    for (const [verb, fn, done] of [
+        ["restore", restoreFromTrash, "restored"],
+        ["purge", purgeFromTrash, "deleted for good:"],
+    ]) {
+        trash
+            .command(verb)
+            .description(verb === "restore" ? "Put an entry back where it came from" : "Delete one entry for good")
+            .argument("<id>", "Entry id as `kraftwerk trash` lists it, e.g. knowledge/customer-support")
+            .action(async (id) => {
+            await prepare();
+            try {
+                const e = await fn(id);
+                console.log(`${chalk.green("✔")} ${done} ${chalk.cyan(e.from)}`);
+            }
+            catch (err) {
+                die(err.message);
+            }
+        });
+    }
+    trash
+        .command("empty")
+        .description("Delete everything in the trash for good")
+        .action(async () => {
+        await prepare();
+        const n = await emptyTrash();
+        console.log(`${chalk.green("✔")} deleted ${n} entr${n === 1 ? "y" : "ies"} for good`);
+    });
+}

package/dist/cli/vibeables.js

@@ -11,7 +11,7 @@ import { initContext as prepare } from "./routines.js";
  *
  *   kraftwerk vibeables                    list: name, mode, state
  *   kraftwerk vibeables create <name>      new app from the starter (index.html, vibeable.yml)
- *   kraftwerk vibeables remove <name>      delete the folder (its history stays in the workspace git)
+ *   kraftwerk vibeables remove <name>      move the folder to the trash
  */
 const die = (msg) => {
     console.error(chalk.red(msg));
@@ -74,13 +74,13 @@ export function registerVibeableCommands(program) {
     });
     vibeables
         .command("remove")
-        .description("Delete an app folder; its history stays in the workspace git")
+        .description("Move an app folder to the trash (`kraftwerk trash` puts it back)")
         .argument("<name>", "Folder name under the root")
         .action(async (name) => {
         await prepare();
         try {
             await deleteVibeable(name);
-            console.log(`${chalk.green("✔")} removed ${chalk.cyan(name)}`);
+            console.log(`${chalk.green("✔")} moved ${chalk.cyan(name)} to the trash`);
         }
         catch (err) {
             die(err.message);

package/dist/inspector/agent-status.d.ts

@@ -0,0 +1,21 @@
+import { type AgentActivity } from "./chat/sessions.js";
+/**
+ * What each agent is up to, for the status line under its name: waiting on
+ * a human, working (where, since when), the next scheduled routine, and
+ * when it was last active. The UI picks the one line that matters most.
+ */
+export interface AgentStatus {
+    /** Chats where it waits for an approval or an answer. */
+    waiting: AgentActivity[];
+    /** Chats where it is mid-turn. */
+    working: AgentActivity[];
+    /** The next enabled routine due. */
+    nextRoutine?: {
+        id: string;
+        name: string;
+        at: string;
+    };
+    /** Newest change in any of its sessions or channels. */
+    lastActiveAt?: string;
+}
+export declare function agentStatuses(): Promise<Record<string, AgentStatus>>;

package/dist/inspector/agent-status.js

@@ -0,0 +1,25 @@
+import { listAgents } from "./agents.js";
+import { agentActivity, listChats } from "./chat/sessions.js";
+import { routineStatuses } from "./routines.js";
+export async function agentStatuses() {
+    const [agents, chats] = await Promise.all([listAgents(), listChats()]);
+    const live = agentActivity();
+    const out = {};
+    await Promise.all(agents.map(async (a) => {
+        const act = live.get(a.slug);
+        const routines = await routineStatuses(a.slug).catch(() => []);
+        const next = routines
+            .filter((r) => r.nextRunAt)
+            .sort((x, y) => x.nextRunAt.localeCompare(y.nextRunAt))[0];
+        // A channel chat counts once the agent has a session there (sessions are keyed by agent slug).
+        const mine = chats.filter((c) => (c.scope.kind === "agent" && c.scope.slug === a.slug) || (c.scope.kind === "channel" && c.sessions?.[a.slug]));
+        const last = mine.reduce((m, c) => (!m || c.updatedAt > m ? c.updatedAt : m), undefined);
+        out[a.slug] = {
+            waiting: act?.waiting ?? [],
+            working: act?.working ?? [],
+            ...(next ? { nextRoutine: { id: next.id, name: next.name, at: next.nextRunAt } } : {}),
+            ...(last ? { lastActiveAt: last } : {}),
+        };
+    }));
+    return out;
+}

package/dist/inspector/agents.d.ts

@@ -27,6 +27,8 @@ export interface Agent {
     knowledge: string[];
     /** Vibeables (folder names under the vibeables root) this member builds and maintains. */
     vibeables: string[];
+    /** Workspace file folders (paths under kraftwerk-data/files) this agent works with; agents own no files. */
+    files?: string[];
     /**
      * Skill allowlist (names from .claude/skills, project or user level).
      * Absent = all discovered skills; empty list = no skills.
@@ -67,6 +69,8 @@ export interface SaveAgentInput {
     workflows?: string[];
     knowledge?: string[];
     vibeables?: string[];
+    /** Linked workspace file folders; omitted = keep what agent.yml has. */
+    files?: string[];
     /** Omit for "all skills"; a list (possibly empty) restricts to those names. */
     skills?: string[];
     system?: string;
@@ -74,4 +78,5 @@ export interface SaveAgentInput {
 export declare function saveAgent(input: SaveAgentInput): Promise<AgentDetail>;
 /** Archive/unarchive a member: toggles `archived:` in agent.yml, nothing else. */
 export declare function setAgentArchived(slug: string, archived: boolean): Promise<AgentDetail>;
+/** Move the agent's folder to the trash. */
 export declare function deleteAgent(slug: string): Promise<void>;

package/dist/inspector/agents.js

@@ -4,6 +4,7 @@ import { parse, stringify } from "yaml";
 import { resolveProject } from "../config.js";
 import { getProjectRoot } from "./context.js";
 import { syncWorkspaceAgents } from "./instances.js";
+import { moveToTrash } from "./trash.js";
 /**
  * Agents: persistent agents, defined on the filesystem. Each one
  * is one folder under the project's agents/ root:
@@ -60,6 +61,7 @@ function normalize(slug, raw) {
         workflows: Array.isArray(raw.workflows) ? raw.workflows.map(String) : [],
         knowledge: Array.isArray(raw.knowledge) ? raw.knowledge.map(String) : [],
         vibeables: Array.isArray(raw.vibeables) ? raw.vibeables.map(String) : [],
+        ...(Array.isArray(raw.files) && raw.files.length ? { files: raw.files.map(String) } : {}),
         ...(Array.isArray(raw.skills) ? { skills: raw.skills.map(String) } : {}),
         ...(raw.archived === true ? { archived: true } : {}),
     };
@@ -135,6 +137,12 @@ export async function saveAgent(input) {
         knowledge: (input.knowledge ?? []).map(String),
         // Empty list left out: most agents build nothing, and agent.yml stays as short as before.
         ...(input.vibeables?.length ? { vibeables: [...new Set(input.vibeables.map((v) => String(v).trim()).filter(Boolean))] } : {}),
+        ...(() => {
+            // Linked folders survive an edit from a form that does not know them.
+            const files = input.files ?? (Array.isArray(existing?.files) ? existing.files.map(String) : []);
+            const clean = [...new Set(files.map((f) => String(f).trim().replace(/^\/+|\/+$/g, "")).filter(Boolean))];
+            return clean.length ? { files: clean } : {};
+        })(),
         ...(input.skills ? { skills: input.skills.map(String) } : {}),
         ...(existing?.archived === true ? { archived: true } : {}),
     };
@@ -160,7 +168,8 @@ export async function setAgentArchived(slug, archived) {
     await fs.writeFile(path.join(dir, "agent.yml"), stringify(yml));
     return (await getAgent(slug));
 }
+/** Move the agent's folder to the trash. */
 export async function deleteAgent(slug) {
     const dir = path.join(await agentsRoot(), safeAgentSlug(slug));
-    await fs.rm(dir, { recursive: true, force: true });
+    await moveToTrash("agents", slug, dir);
 }

package/dist/inspector/attention.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What needs you: every place where work is stuck on a human, with whose it
+ * is. Two sources: requests waiting in a live chat (an approval, a question
+ * — the agent cannot go on until someone answers) and failures nobody has
+ * looked at yet (a routine or a workflow run that ended badly; unread
+ * failure notifications). Oldest first: what waits longest comes first.
+ *
+ * The inspector builds everything urgent from this one list: the counts on
+ * the rail, the "needs you" part of the bell, the tab title and "next",
+ * which walks through it and lands on each item with its context.
+ */
+/** Who an item belongs to — what the rail lights up and the bell groups by. */
+export interface AttentionOwner {
+    project?: {
+        slug: string;
+        title: string;
+    };
+    agent?: {
+        slug: string;
+        name: string;
+        emoji?: string;
+    };
+    channel?: string;
+    /** A chat with Ralv, the workspace's general assistant. */
+    general?: boolean;
+    /** A workflow run. */
+    workflow?: string;
+}
+export interface AttentionItem {
+    /** The request id (live requests) or the notification id (failures). */
+    id: string;
+    kind: "approval" | "question" | "failed";
+    /** What is asked, or what went wrong. */
+    title: string;
+    /** The session it sits in. */
+    chatId?: string;
+    chatTitle?: string;
+    /** Where to go: a chat route with ?focus=<request id>, or the failed run or routine. */
+    href: string;
+    since: string;
+    owner: AttentionOwner;
+    /** Failures: the notification to mark read once the item was opened. */
+    notificationId?: string;
+}
+export interface AttentionView {
+    items: AttentionItem[];
+}
+export declare function listAttention(): Promise<AttentionView>;

package/dist/inspector/attention.js

@@ -0,0 +1,66 @@
+import { listAgents } from "./agents.js";
+import { waitingRequests } from "./chat/sessions.js";
+import { chatHref, listNotifications } from "./notifications.js";
+import { listProjects } from "./projects.js";
+export async function listAttention() {
+    const [agents, projects, notes] = await Promise.all([
+        listAgents().catch(() => []),
+        listProjects().catch(() => ({ projects: [] })),
+        listNotifications().catch(() => ({ items: [] })),
+    ]);
+    const agentOf = (slug) => {
+        const a = agents.find((x) => x.slug === slug);
+        return { slug, name: a?.name ?? slug, ...(a?.emoji ? { emoji: a.emoji } : {}) };
+    };
+    const projectOf = (slug) => ({
+        slug,
+        title: projects.projects.find((p) => p.slug === slug)?.title ?? slug,
+    });
+    const waiting = waitingRequests().map((w) => {
+        const { scope } = w.meta;
+        const owner = {};
+        if (scope.kind === "agent")
+            owner.agent = agentOf(scope.slug);
+        if (scope.kind === "project")
+            owner.project = projectOf(scope.slug);
+        if (scope.kind === "channel") {
+            owner.channel = scope.slug;
+            owner.agent = agentOf(w.seat);
+            if (w.meta.project)
+                owner.project = projectOf(w.meta.project);
+        }
+        if (scope.kind === "general" || scope.kind === "kraftwerk" || scope.kind === "knowledge")
+            owner.general = true;
+        return {
+            id: w.requestId,
+            kind: w.kind,
+            title: w.title,
+            chatId: w.meta.id,
+            ...(w.meta.title ? { chatTitle: w.meta.title } : {}),
+            href: `${chatHref(w.meta)}?focus=${encodeURIComponent(w.requestId)}`,
+            since: w.since,
+            owner,
+        };
+    });
+    const failed = notes.items
+        .filter((n) => !n.readAt && (n.kind === "routine_failed" || n.kind === "run_failed"))
+        .map((n) => {
+        const owner = {};
+        if (n.diagnose?.kind === "routine")
+            owner.agent = agentOf(n.diagnose.agent);
+        if (n.diagnose?.kind === "run")
+            owner.workflow = n.title.replace(/ run .*$/, "");
+        return {
+            id: n.id,
+            kind: "failed",
+            title: n.body ? `${n.title}: ${n.body.split("\n")[0]}` : n.title,
+            ...(n.diagnose?.kind === "routine" && n.diagnose.chatId ? { chatId: n.diagnose.chatId } : {}),
+            href: n.href,
+            since: n.at,
+            owner,
+            notificationId: n.id,
+        };
+    });
+    const items = [...waiting, ...failed].sort((a, b) => a.since.localeCompare(b.since));
+    return { items };
+}

package/dist/inspector/channels.js

@@ -2,6 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { parse, stringify } from "yaml";
 import { getProjectRoot } from "./context.js";
+import { moveToTrash } from "./trash.js";
 import { resolveProject } from "../config.js";
 import { listAgents, safeAgentSlug, slugFromName } from "./agents.js";
 import { syncWorkspaceChannels } from "./instances.js";
@@ -130,7 +131,7 @@ export async function saveChannel(input) {
     return channel;
 }
 export async function deleteChannel(slug) {
-    await fs.rm(path.join(await channelsRoot(), safeChannelSlug(slug)), { recursive: true, force: true });
+    await moveToTrash("channels", slug, path.join(await channelsRoot(), safeChannelSlug(slug)));
 }
 /**
  * Who a channel message wakes. @mentions of members win (in text order, each