@netnodeag/kraftwerk 0.57.4 → 0.58.1

package/dist/inspector/files.js

@@ -0,0 +1,316 @@
+import { createReadStream, createWriteStream, promises as fs } from "node:fs";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { resolveProject } from "../config.js";
+import { getProjectRoot } from "./context.js";
+import { listProjects, openProjects, safeProjectSlug } from "./projects.js";
+import { moveToTrash } from "./trash.js";
+/**
+ * Files: the material of the work, any format, as plain folders. Two
+ * owners, by how long a file lives:
+ *
+ *   kraftwerk-data/files/                    workspace files: shared, outlive any project
+ *   kraftwerk-data/projects/<slug>/files/    a project's files: briefing, drafts, deliverables
+ *
+ * Agents own none (they link folders; see agentFilesContext). Being plain
+ * folders, agents read and write them like any directory, the workspace
+ * git keeps their history, and a delete goes to the trash. Files over
+ * LOCAL_OVER_BYTES stay out of git: listed in the root's own .gitignore,
+ * shown as "local only". Knowledge is separate: a file becomes evidence in
+ * a bundle's references/ through "learn from this" (later).
+ */
+export const WORKSPACE_FILES_DIR = "kraftwerk-data/files";
+export const PROJECT_FILES_DIR = "files";
+/** Bigger files stay local: kept out of the workspace git. */
+export const LOCAL_OVER_BYTES = 25 * 1024 * 1024;
+/** Upload cap: a guard against a runaway request, not a policy. */
+export const MAX_UPLOAD_BYTES = 2 * 1024 * 1024 * 1024;
+const IGNORE_HEAD = "# kraftwerk: files over 25 MB stay local (not in git)";
+const MIME = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".avif": "image/avif",
+    ".heic": "image/heic",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".m4a": "audio/mp4",
+    ".wav": "audio/wav",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+    ".csv": "text/csv; charset=utf-8",
+    ".tsv": "text/tab-separated-values; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".yml": "text/yaml; charset=utf-8",
+    ".yaml": "text/yaml; charset=utf-8",
+    ".xml": "text/xml; charset=utf-8",
+    ".html": "text/html; charset=utf-8",
+    ".log": "text/plain; charset=utf-8",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".zip": "application/zip",
+};
+export const mimeOf = (name) => MIME[path.extname(name).toLowerCase()] ?? "application/octet-stream";
+/** The root folder of a scope, its display label, and the root relative to the workspace. */
+export async function scopeRoot(scope) {
+    const project = await resolveProject(getProjectRoot());
+    const workspace = project.root;
+    if (scope === "workspace") {
+        const abs = path.join(workspace, WORKSPACE_FILES_DIR);
+        return { abs, rel: WORKSPACE_FILES_DIR, label: "Workspace", workspace };
+    }
+    const m = /^project:(.+)$/.exec(scope);
+    if (!m)
+        throw new Error(`invalid files scope "${scope}"`);
+    const slug = safeProjectSlug(m[1]);
+    const opened = await openProjects();
+    if (!opened.root)
+        throw new Error(opened.error ?? "projects are off");
+    const dir = path.join(opened.root, slug);
+    if (!(await fs.stat(path.join(dir, "project.yml")).catch(() => null)))
+        throw new Error(`no project "${slug}"`);
+    const abs = path.join(dir, PROJECT_FILES_DIR);
+    const title = (await listProjects()).projects.find((p) => p.slug === slug)?.title ?? slug;
+    return { abs, rel: path.relative(workspace, abs).split(path.sep).join("/"), label: title, workspace };
+}
+/** A path inside a root: no escaping it, no hidden segments (.gitignore and friends are kraftwerk's). */
+function inside(root, rel) {
+    const clean = rel.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    if (clean.split("/").some((s) => s === ".." || (s.startsWith(".") && s !== "")))
+        throw new Error("invalid path");
+    const abs = path.resolve(root, clean);
+    if (abs !== root && !abs.startsWith(root + path.sep))
+        throw new Error("invalid path");
+    return abs;
+}
+const toPosix = (p) => p.split(path.sep).join("/");
+/** Number of files below a folder, stopping at `cap`. */
+async function countFiles(dir, cap = 5000) {
+    let n = 0;
+    const walk = async (d) => {
+        if (n >= cap)
+            return;
+        const kids = await fs.readdir(d, { withFileTypes: true }).catch(() => []);
+        for (const k of kids) {
+            if (k.name.startsWith("."))
+                continue;
+            if (k.isDirectory())
+                await walk(path.join(d, k.name));
+            else if (k.isFile())
+                n++;
+            if (n >= cap)
+                return;
+        }
+    };
+    await walk(dir);
+    return n;
+}
+/* ---------- local-only (over the size limit) ---------- */
+async function readIgnore(root) {
+    const raw = await fs.readFile(path.join(root, ".gitignore"), "utf8").catch(() => "");
+    return raw.split("\n").filter((l) => l.startsWith("/"));
+}
+/** Keep `rel` out of git (on) or let it back in (off), in the root's own .gitignore. */
+async function markLocal(root, rel, on) {
+    const line = `/${rel}`;
+    const lines = await readIgnore(root);
+    const has = lines.includes(line);
+    if (on === has)
+        return;
+    const next = on ? [...lines, line] : lines.filter((l) => l !== line);
+    const file = path.join(root, ".gitignore");
+    if (next.length === 0)
+        await fs.rm(file, { force: true });
+    else
+        await fs.writeFile(file, `${IGNORE_HEAD}\n${next.sort().join("\n")}\n`);
+}
+/* ---------- reading ---------- */
+export async function listScopes() {
+    const ws = await scopeRoot("workspace");
+    const out = [{ scope: "workspace", label: ws.label, root: ws.rel, count: await countFiles(ws.abs) }];
+    const projects = await listProjects().catch(() => ({ projects: [] }));
+    for (const p of projects.projects) {
+        const r = await scopeRoot(`project:${p.slug}`).catch(() => null);
+        if (!r)
+            continue;
+        out.push({ scope: `project:${p.slug}`, label: p.title, root: r.rel, count: await countFiles(r.abs), status: p.status });
+    }
+    return out;
+}
+export async function listFiles(scope, rel = "") {
+    const root = await scopeRoot(scope);
+    const dir = inside(root.abs, rel);
+    const st = await fs.stat(dir).catch(() => null);
+    if (rel && !st?.isDirectory())
+        throw new Error(`no folder "${rel}"`);
+    const local = new Set(await readIgnore(root.abs));
+    const kids = st ? await fs.readdir(dir, { withFileTypes: true }) : [];
+    const entries = [];
+    for (const k of kids) {
+        if (k.name.startsWith("."))
+            continue;
+        const abs = path.join(dir, k.name);
+        const s = await fs.stat(abs).catch(() => null);
+        if (!s)
+            continue;
+        const p = toPosix(path.relative(root.abs, abs));
+        if (s.isDirectory()) {
+            entries.push({ name: k.name, path: p, type: "dir", modifiedAt: s.mtime.toISOString(), count: await countFiles(abs, 1000) });
+        }
+        else if (s.isFile()) {
+            // A big file dropped in by hand (Finder, an agent) is kept out of git the moment it is seen.
+            const big = s.size > LOCAL_OVER_BYTES;
+            if (big && !local.has(`/${p}`))
+                await markLocal(root.abs, p, true);
+            entries.push({ name: k.name, path: p, type: "file", size: s.size, modifiedAt: s.mtime.toISOString(), mime: mimeOf(k.name), ...(big ? { local: true } : {}) });
+        }
+    }
+    entries.sort((a, b) => (a.type === b.type ? a.name.localeCompare(b.name, undefined, { numeric: true }) : a.type === "dir" ? -1 : 1));
+    return { scope, label: root.label, path: toPosix(path.relative(root.abs, dir)), root: root.rel, entries };
+}
+/** A file to stream to the browser. */
+export async function openFile(scope, rel) {
+    const root = await scopeRoot(scope);
+    const abs = inside(root.abs, rel);
+    const st = await fs.stat(abs).catch(() => null);
+    if (!st?.isFile())
+        throw new Error(`no file "${rel}"`);
+    return { stream: createReadStream(abs), size: st.size, mime: mimeOf(abs), name: path.basename(abs) };
+}
+/* ---------- writing ---------- */
+/** A name for an upload: no folders, no control characters, no leading dot. */
+function cleanName(name) {
+    const base = path.basename(name.replace(/\\/g, "/")).replace(/[\u0000-\u001f\u007f/]/g, "").trim().replace(/^\.+/, "");
+    if (!base)
+        throw new Error("invalid file name");
+    return base.slice(0, 200);
+}
+/** "report.pdf" taken -> "report (2).pdf". */
+async function freeName(dir, name) {
+    const ext = path.extname(name);
+    const stem = name.slice(0, name.length - ext.length);
+    let candidate = name;
+    for (let n = 2; await fs.stat(path.join(dir, candidate)).then(() => true, () => false); n++)
+        candidate = `${stem} (${n})${ext}`;
+    return candidate;
+}
+/** Stream an upload into a folder; a name already taken gets " (2)". */
+export async function saveUpload(scope, dirRel, name, body) {
+    const root = await scopeRoot(scope);
+    const dir = inside(root.abs, dirRel);
+    await fs.mkdir(dir, { recursive: true });
+    const final = await freeName(dir, cleanName(name));
+    const abs = path.join(dir, final);
+    const tmp = path.join(dir, `.upload-${process.pid}-${Date.now()}`);
+    let size = 0;
+    body.on("data", (c) => {
+        size += c.length;
+        if (size > MAX_UPLOAD_BYTES)
+            body.destroy(new Error("file too large"));
+    });
+    try {
+        await pipeline(body, createWriteStream(tmp));
+        if (size === 0)
+            throw new Error("empty file");
+        await fs.rename(tmp, abs);
+    }
+    catch (err) {
+        await fs.rm(tmp, { force: true });
+        throw err;
+    }
+    const p = toPosix(path.relative(root.abs, abs));
+    if (size > LOCAL_OVER_BYTES)
+        await markLocal(root.abs, p, true);
+    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) {
+    const root = await scopeRoot(scope);
+    const abs = inside(root.abs, rel);
+    if (abs === root.abs)
+        throw new Error("folder name is required");
+    if (await fs.stat(abs).catch(() => null))
+        throw new Error(`"${path.basename(abs)}" already exists`);
+    await fs.mkdir(abs, { recursive: true });
+    return { name: path.basename(abs), path: toPosix(path.relative(root.abs, abs)), type: "dir", modifiedAt: new Date().toISOString(), count: 0 };
+}
+/** Rename or move inside the scope. Refused when the target exists. */
+export async function moveFile(scope, fromRel, toRel) {
+    const root = await scopeRoot(scope);
+    const from = inside(root.abs, fromRel);
+    const to = inside(root.abs, toRel);
+    if (from === root.abs || to === root.abs)
+        throw new Error("invalid path");
+    const st = await fs.stat(from).catch(() => null);
+    if (!st)
+        throw new Error(`no file "${fromRel}"`);
+    if (await fs.stat(to).catch(() => null))
+        throw new Error(`"${toRel}" already exists`);
+    if (st.isDirectory() && (to + path.sep).startsWith(from + path.sep))
+        throw new Error("cannot move a folder into itself");
+    await fs.mkdir(path.dirname(to), { recursive: true });
+    await fs.rename(from, to);
+    if (st.isFile() && st.size > LOCAL_OVER_BYTES) {
+        await markLocal(root.abs, toPosix(path.relative(root.abs, from)), false);
+        await markLocal(root.abs, toPosix(path.relative(root.abs, to)), true);
+    }
+}
+/** Move a file or folder to the trash (trash/files/<workspace | projects/slug>/<path>). */
+export async function deleteFile(scope, rel) {
+    const root = await scopeRoot(scope);
+    const abs = inside(root.abs, rel);
+    if (abs === root.abs)
+        throw new Error("invalid path");
+    const st = await fs.stat(abs).catch(() => null);
+    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)}`;
+    await moveToTrash("files", `${owner}/${p}`, abs);
+    if (st.isFile() && st.size > LOCAL_OVER_BYTES)
+        await markLocal(root.abs, p, false);
+}
+/* ---------- context for agents ---------- */
+/** "files/ (23 files; recent: designs/home-v3.png 2026-10-05, …)" — where the files are, not every file. */
+export async function filesSummary(scope, recent = 5) {
+    const root = await scopeRoot(scope).catch(() => null);
+    if (!root)
+        return null;
+    const all = [];
+    const walk = async (d) => {
+        if (all.length > 5000)
+            return;
+        for (const k of await fs.readdir(d, { withFileTypes: true }).catch(() => [])) {
+            if (k.name.startsWith("."))
+                continue;
+            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)
+                    all.push({ path: toPosix(path.relative(root.abs, abs)), at: s.mtime.toISOString() });
+            }
+        }
+    };
+    await walk(root.abs);
+    all.sort((a, b) => b.at.localeCompare(a.at));
+    return { root: root.rel, count: all.length, recent: all.slice(0, recent) };
+}
+/** The "## Files" block of a session's context: the folder to use, what is in it lately. */
+export async function filesContext(scope, heading, intro) {
+    const s = await filesSummary(scope);
+    if (!s)
+        return "";
+    const recent = s.recent.map((r) => `  - ${r.path} (${r.at.slice(0, 10)})`).join("\n");
+    return (`## ${heading}\n${intro} ${s.root}/ — ${s.count} file${s.count === 1 ? "" : "s"}` +
+        (recent ? `, most recently changed:\n${recent}\n` : " (empty so far)\n") +
+        `Read and write them there like any folder; put what you produce for the user in ${s.root}/deliverables/. ` +
+        `Files over 25 MB stay out of git automatically. Delete nothing there unless asked.`);
+}

package/dist/inspector/git.js

@@ -204,7 +204,7 @@ async function checkedOut(repo) {
 }
 /**
  * The roots that may be committed, as repo-relative paths: the workflows,
- * knowledge, agents, skills, channels, vibeables and projects roots this project
+ * knowledge, agents, skills, channels, vibeables, projects and files roots this project
  * declares, plus kraftwerk.yml and the project README. The output directory
  * is excluded even when it lives inside one of them.
  */
@@ -237,6 +237,8 @@ function scopeFor({ project, repoRoot }) {
         vibeablesRootFor(project),
         // Projects too: briefs, state and logs are the workspace's own record.
         projectsRootFor(project),
+        // Workspace files: shared material, versioned (files over 25 MB ignore themselves, see files.ts).
+        path.resolve(project.root, "kraftwerk-data/files"),
         project.configPath,
         path.resolve(project.root, "README.md"),
     ];

package/dist/inspector/journal.d.ts

@@ -0,0 +1,31 @@
+/**
+ * An agent's journal: agents/<slug>/journal.md, the agent's own memory
+ * across sessions. What it learned, decided, promised and finished, one
+ * line per entry under a dated heading, newest first (like a project's
+ * log.md). The agent writes it through `kraftwerk journal` and reads the
+ * recent part back at the start of every session, so next week it is the
+ * same colleague; a human can add a line from the inspector.
+ */
+export declare const JOURNAL_FILE = "journal.md";
+export declare const JOURNAL_KINDS: readonly ["learned", "decided", "promised", "done", "note"];
+export type JournalKind = (typeof JOURNAL_KINDS)[number];
+/** The whole journal; empty when nothing was written yet. */
+export declare function readJournal(slug: string): Promise<string>;
+/**
+ * Prepend one entry under today's heading. `actor` is stamped unless it is
+ * the agent itself: in its own journal, its own lines need no signature,
+ * and a human's stand out.
+ */
+export declare function appendJournal(slug: string, entry: string, opts?: {
+    kind?: string;
+    actor?: string;
+}): Promise<string>;
+/**
+ * The recent part of a journal for a session's context: whole days, newest
+ * first, until the budget is spent. Older days stay in the file, where the
+ * agent can read them when it needs to.
+ */
+export declare function journalExcerpt(raw: string, budget?: number): {
+    text: string;
+    truncated: boolean;
+};

package/dist/inspector/journal.js

@@ -0,0 +1,72 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { agentsRoot, getAgent, safeAgentSlug } from "./agents.js";
+/**
+ * An agent's journal: agents/<slug>/journal.md, the agent's own memory
+ * across sessions. What it learned, decided, promised and finished, one
+ * line per entry under a dated heading, newest first (like a project's
+ * log.md). The agent writes it through `kraftwerk journal` and reads the
+ * recent part back at the start of every session, so next week it is the
+ * same colleague; a human can add a line from the inspector.
+ */
+export const JOURNAL_FILE = "journal.md";
+export const JOURNAL_KINDS = ["learned", "decided", "promised", "done", "note"];
+async function journalPath(slug) {
+    return path.join(await agentsRoot(), safeAgentSlug(slug), JOURNAL_FILE);
+}
+/** The whole journal; empty when nothing was written yet. */
+export async function readJournal(slug) {
+    return fs.readFile(await journalPath(slug), "utf8").catch(() => "");
+}
+/**
+ * Prepend one entry under today's heading. `actor` is stamped unless it is
+ * the agent itself: in its own journal, its own lines need no signature,
+ * and a human's stand out.
+ */
+export async function appendJournal(slug, entry, opts = {}) {
+    const def = await getAgent(slug);
+    if (!def)
+        throw new Error(`no agent "${slug}"`);
+    const text = entry.trim().replace(/\s*\n\s*/g, " ");
+    if (!text)
+        throw new Error("entry is required");
+    const kind = (opts.kind ?? "note").trim().toLowerCase();
+    if (!JOURNAL_KINDS.includes(kind))
+        throw new Error(`kind must be one of: ${JOURNAL_KINDS.join(", ")}`);
+    const actor = opts.actor?.trim();
+    const own = !actor || actor === slug || actor.startsWith(`${slug}/`);
+    const line = `* ${kind === "note" ? "" : `**${kind[0].toUpperCase()}${kind.slice(1)}**: `}${text}${own ? "" : ` (${actor})`}`;
+    const file = await journalPath(slug);
+    const today = new Date().toISOString().slice(0, 10);
+    const raw = (await fs.readFile(file, "utf8").catch(() => null)) ?? `# ${def.name}'s journal\n`;
+    const lines = raw.split("\n");
+    const todayIdx = lines.findIndex((l) => l.trim() === `## ${today}`);
+    if (todayIdx >= 0) {
+        lines.splice(todayIdx + 1, 0, line);
+    }
+    else {
+        const titleIdx = lines.findIndex((l) => l.startsWith("# "));
+        lines.splice(titleIdx + 1, 0, "", `## ${today}`, line);
+    }
+    const out = lines.join("\n").replace(/\n{3,}/g, "\n\n");
+    await fs.writeFile(file, out);
+    return out;
+}
+/**
+ * The recent part of a journal for a session's context: whole days, newest
+ * first, until the budget is spent. Older days stay in the file, where the
+ * agent can read them when it needs to.
+ */
+export function journalExcerpt(raw, budget = 4000) {
+    const days = raw.split(/\n(?=## )/).filter((d) => d.startsWith("## "));
+    const kept = [];
+    let used = 0;
+    for (const d of days) {
+        const day = d.trim();
+        if (used + day.length > budget && kept.length > 0)
+            break;
+        kept.push(day.length > budget ? `${day.slice(0, budget)}…` : day);
+        used += day.length;
+    }
+    return { text: kept.join("\n\n"), truncated: kept.length < days.length };
+}

package/dist/inspector/knowledge.d.ts

@@ -18,6 +18,8 @@ export interface BundleDetail {
 }
 export declare function knowledgeIndex(): Promise<KnowledgeIndex>;
 export declare function createBundle(name: string): Promise<BundleInfo>;
+/** Move a bundle to the trash. */
+export declare function deleteBundle(name: string): Promise<void>;
 export declare function bundleDetail(name: string): Promise<BundleDetail | null>;
 export declare function conceptDetail(bundle: string, id: string): Promise<ConceptDetail | null>;
 export declare function putConcept(bundle: string, id: string, content: string): Promise<ConceptDetail>;

package/dist/inspector/knowledge.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { resolveProject } from "../config.js";
 import { getConcept, initBundle, knowledgeRoot, listBundles, listConcepts, safeBundleName, verifyConcept, writeConcept, } from "../okf.js";
 import { getProjectRoot } from "./context.js";
+import { moveToTrash } from "./trash.js";
 /**
  * Knowledge for the inspector: a thin API layer over the OKF
  * core (src/okf.ts). Writes from the UI are stamped as `human:user` — the
@@ -22,6 +23,12 @@ export async function createBundle(name) {
     await initBundle(await root(), name);
     return { name, concepts: 0 };
 }
+/** Move a bundle to the trash. */
+export async function deleteBundle(name) {
+    const dir = path.join(await root(), safeBundleName(name));
+    if (!(await moveToTrash("knowledge", name, dir)))
+        throw new Error(`no bundle "${name}"`);
+}
 export async function bundleDetail(name) {
     const kroot = await root();
     const dir = path.join(kroot, safeBundleName(name));

package/dist/inspector/projects.d.ts

@@ -161,7 +161,7 @@ export declare function linkProject(slug: string, kind: string, target: string,
  * agent reads as such next to a human's.
  */
 export declare function appendProjectLog(slug: string, entry: string, actor: string): Promise<string>;
-/** Remove the folder; its history stays in the workspace git. */
+/** Move the folder to the trash. */
 export declare function deleteProject(slug: string): Promise<void>;
 /** One line per system of record: what it is, where, and what usually lives there. */
 export declare function recordLine(r: SystemOfRecord): string;

package/dist/inspector/projects.js

@@ -8,8 +8,10 @@ import { syncWorkspaceProjects } from "./instances.js";
 import { knowledgeIndex } from "./knowledge.js";
 import { newestMtime } from "./mtime.js";
 import { listRepos } from "./repos.js";
+import { moveToTrash } from "./trash.js";
 import { listVibeables } from "./vibeables.js";
 import { listWorkflows } from "./workflows.js";
+import { filesContext } from "./files.js";
 /**
  * Projects: a goal with everything the agents need to reach it gathered in
  * one folder — the brief, the systems of record where the truth is managed
@@ -427,13 +429,13 @@ export async function appendProjectLog(slug, entry, actor) {
     await fs.writeFile(file, out);
     return out;
 }
-/** Remove the folder; its history stays in the workspace git. */
+/** Move the folder to the trash. */
 export async function deleteProject(slug) {
     const root = await requireRoot();
     const dir = path.join(root, safeProjectSlug(slug));
     if (!(await fs.stat(path.join(dir, PROJECT_FILE)).catch(() => null)))
         throw new Error(`no project "${slug}"`);
-    await fs.rm(dir, { recursive: true, force: true });
+    await moveToTrash("projects", slug, dir);
 }
 /* ---------- chat context ---------- */
 /** One line per system of record: what it is, where, and what usually lives there. */
@@ -500,6 +502,7 @@ export async function projectContext(slug, actor, opts = {}) {
                         `\`npx kraftwerk repos\` lists every clone, \`repos add <url>\` clones a new one into the root.`
                     : `\nRepositories are switched off in this workspace's settings, so these clones are not reachable right now — tell the user.`)
             : "",
+        await filesContext(`project:${p.slug}`, "Files", "The project's files (briefings, drafts, designs, deliverables) are in"),
         vibeables
             ? `## Vibeables\nSmall apps of this project (one folder each under the vibeables root):\n` +
                 linkLines("vibeables", (l) => `- ${l.slug}${l.label ? ` (${l.label})` : ""}`) +

package/dist/inspector/repos.js

@@ -2,6 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { gitignoreHas, ignoreEntryFor, reposRootFor, resolveProject } from "../config.js";
 import { getProjectRoot } from "./context.js";
+import { moveToTrash } from "./trash.js";
 import { newestMtime } from "./mtime.js";
 import { capDiff, DENY, diffAgainstHead, git, gitNet, label, literal, parseStatus, sshCommandFor } from "./git.js";
 /**
@@ -340,7 +341,7 @@ export async function removeRepo(slug, force = false) {
         if (repo.ahead)
             return { ok: false, conflict: true, error: `"${slug}" has ${repo.ahead} unpushed commit(s)` };
     }
-    await fs.rm(dir, { recursive: true, force: true });
+    await moveToTrash("repos", slug, dir);
     return { ok: true };
 }
 /**

package/dist/inspector/runs.d.ts

@@ -66,7 +66,7 @@ export declare function readRunFile(id: string, name: string): Promise<{
     size: number;
 } | null>;
 /**
- * Remove a run folder. A run that still looks live is refused: its process
+ * Move a run folder to the trash. A run that still looks live is refused: its process
  * would keep writing into a folder that no longer exists — stop it first.
  */
 export declare function deleteRun(id: string): Promise<"deleted" | "running" | "missing">;

package/dist/inspector/runs.js

@@ -1,6 +1,7 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { getOutputDir } from "./context.js";
+import { moveToTrash } from "./trash.js";
 import { awaitingDecision, readDecision } from "./decisions.js";
 /**
  * Filesystem + trace.jsonl reading for the inspector. The output directory
@@ -306,7 +307,7 @@ export async function readRunFile(id, name) {
     return { absPath, size: st.size };
 }
 /**
- * Remove a run folder. A run that still looks live is refused: its process
+ * Move a run folder to the trash. A run that still looks live is refused: its process
  * would keep writing into a folder that no longer exists — stop it first.
  */
 export async function deleteRun(id) {
@@ -315,6 +316,6 @@ export async function deleteRun(id) {
         return "missing";
     if (run.status === "running")
         return "running";
-    await fs.rm(safeRunDir(id), { recursive: true, force: true });
+    await moveToTrash("runs", id, safeRunDir(id));
     return "deleted";
 }