@netnodeag/kraftwerk 0.61.0 → 0.63.0

package/dist/inspector/api/index.d.ts

@@ -0,0 +1,334 @@
+import { type PathOf, type ResultOf, type Route } from "./router.js";
+/**
+ * The control plane's contract. Every route has a stable name; clients
+ * (the web UI today, a native app or the CLI later) address it by that name
+ * and get the handler's return type as its result — inferred, so the
+ * contract cannot drift from the implementation. Bump PROTOCOL_VERSION when
+ * a route is removed or its result changes incompatibly; adding routes or
+ * fields is not a bump.
+ */
+export declare const PROTOCOL_VERSION = 1;
+/** One line per route, for clients and people: what exists and how to reach it. */
+export interface RouteInfo {
+    name: string;
+    method: string;
+    path: string;
+    summary: string;
+    /** A stream or a file, not a JSON result. */
+    raw?: boolean;
+    /** The body is a file's bytes. */
+    upload?: boolean;
+}
+export declare const routes: (Route<"agents.addJournal", {
+    journal: string;
+}, "/api/agents/:slug/journal"> | Route<"agents.archive", import("../agents.js").AgentDetail, "/api/agents/:slug/archive"> | Route<"agents.create", import("../agents.js").AgentDetail, "/api/agents"> | Route<"agents.delete", {
+    ok: boolean;
+}, "/api/agents/:slug"> | Route<"agents.deleteRoutine", {
+    ok: boolean;
+}, "/api/agents/:slug/routines/:id"> | Route<"agents.deleteSkill", {
+    ok: boolean;
+}, "/api/agents/:slug/skills/:name"> | Route<"agents.get", import("../agents.js").AgentDetail, "/api/agents/:slug"> | Route<"agents.journal", {
+    journal: string;
+}, "/api/agents/:slug/journal"> | Route<"agents.list", {
+    root: string;
+    agents: import("../agents.js").Agent[];
+}, "/api/agents"> | Route<"agents.routines", {
+    routines: import("../routines.js").RoutineStatus[];
+}, "/api/agents/:slug/routines"> | Route<"agents.runRoutine", {
+    chatId: string;
+}, "/api/agents/:slug/routines/:id/run"> | Route<"agents.save", import("../agents.js").AgentDetail, "/api/agents/:slug"> | Route<"agents.saveRoutine", import("../routines.js").Routine, "/api/agents/:slug/routines"> | Route<"agents.saveSkill", import("../skills.js").SkillInfo & {
+    content: string;
+}, "/api/agents/:slug/skills"> | Route<"agents.sessions", {
+    sessions: {
+        sessionId: string;
+        title?: string;
+        updatedAt?: string;
+        cwd: string;
+    }[];
+}, "/api/agent-sessions"> | Route<"agents.skill", {
+    name: string;
+    description: string;
+    path: string;
+    dir: string;
+    source: "workspace" | "project" | "user" | "agent";
+    agent?: string;
+    content: string;
+}, "/api/agents/:slug/skills/:name"> | Route<"agents.skills", {
+    skills: import("../skills.js").SkillInfo[];
+}, "/api/agents/:slug/skills"> | Route<"agents.status", Record<string, import("../agent-status.js").AgentStatus>, "/api/agent-status"> | Route<"attention.list", import("../attention.js").AttentionView, "/api/attention"> | Route<"channels.create", {
+    slug: string;
+    name: string;
+    purpose?: string;
+    members: string[];
+    responder?: string;
+    maxHops: number;
+    project?: string;
+    chatId: string;
+    busy: boolean;
+    awaitingApproval: boolean;
+    updatedAt: string;
+}, "/api/channels"> | Route<"channels.delete", {
+    ok: boolean;
+}, "/api/channels/:slug"> | Route<"channels.fromChat", {
+    slug: string;
+    name: string;
+    purpose?: string;
+    members: string[];
+    responder?: string;
+    maxHops: number;
+    project?: string;
+    chatId: string;
+    busy: boolean;
+    awaitingApproval: boolean;
+    updatedAt: string;
+}, "/api/channels/from-chat"> | Route<"channels.get", {
+    slug: string;
+    name: string;
+    purpose?: string;
+    members: string[];
+    responder?: string;
+    maxHops: number;
+    project?: string;
+    chatId: string;
+    busy: boolean;
+    awaitingApproval: boolean;
+    updatedAt: string;
+}, "/api/channels/:slug"> | Route<"channels.list", {
+    root: string;
+    channels: {
+        slug: string;
+        name: string;
+        purpose?: string;
+        members: string[];
+        responder?: string;
+        maxHops: number;
+        project?: string;
+        chatId: string;
+        busy: boolean;
+        awaitingApproval: boolean;
+        updatedAt: string;
+    }[];
+}, "/api/channels"> | Route<"channels.save", {
+    slug: string;
+    name: string;
+    purpose?: string;
+    members: string[];
+    responder?: string;
+    maxHops: number;
+    project?: string;
+    chatId: string;
+    busy: boolean;
+    awaitingApproval: boolean;
+    updatedAt: string;
+}, "/api/channels/:slug"> | Route<"chats.attach", {
+    name: string;
+    mimeType: string;
+    size: number;
+}, "/api/chats/:id/attachments"> | Route<"chats.attachment", undefined, "/api/chats/:id/attachments/:name"> | Route<"chats.cancel", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/cancel"> | Route<"chats.config", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/config"> | Route<"chats.create", import("../chat/types.js").ChatMeta, "/api/chats"> | Route<"chats.delete", import("./router.js").Reply<{
+    error?: string;
+}>, "/api/chats/:id"> | Route<"chats.elicitation", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/elicitation"> | Route<"chats.events", undefined, "/api/chats/:id/events"> | Route<"chats.fork", import("../chat/types.js").ChatMeta, "/api/chats/:id/fork"> | Route<"chats.get", {
+    meta: import("../chat/types.js").ChatMeta;
+    events: import("../chat/types.js").StoredChatEvent[];
+    busy: boolean;
+}, "/api/chats/:id"> | Route<"chats.list", {
+    chats: (import("../chat/types.js").ChatMeta & {
+        busy: boolean;
+        awaitingApproval: boolean;
+    })[];
+}, "/api/chats"> | Route<"chats.message", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/message"> | Route<"chats.permission", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/permission"> | Route<"chats.rename", import("./router.js").Reply<{
+    meta?: import("../chat/types.js").ChatMeta;
+    error?: string;
+}>, "/api/chats/:id"> | Route<"chats.resetSession", import("../chat/types.js").ChatMeta, "/api/chats/:id/reset-session"> | Route<"chats.setVibeable", import("../chat/types.js").ChatMeta, "/api/chats/:id/vibeable"> | Route<"chats.steer", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/steer"> | Route<"chats.stopTask", import("./router.js").Reply<{
+    error: string;
+}> | {
+    ok: true;
+}, "/api/chats/:id/task-stop"> | Route<"files.delete", {
+    ok: boolean;
+}, "/api/files"> | Route<"files.list", import("../files.js").FilesListing, "/api/files/list"> | Route<"files.mkdir", import("./router.js").Reply<import("../files.js").FileEntry>, "/api/files/folder"> | Route<"files.move", {
+    ok: boolean;
+}, "/api/files/move"> | Route<"files.raw", void, "/api/files/raw"> | Route<"files.recent", {
+    root: string;
+    count: number;
+    recent: {
+        path: string;
+        at: string;
+    }[];
+}, "/api/files/recent"> | Route<"files.scopes", {
+    scopes: import("../files.js").FilesScopeInfo[];
+}, "/api/files"> | Route<"files.upload", import("./router.js").Reply<import("../files.js").FileEntry>, "/api/files/upload"> | Route<"git.commit", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+    committed?: number;
+}>, "/api/git/commit"> | Route<"git.diff", import("../git.js").GitDiff, "/api/git/diff"> | Route<"git.fetch", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+}>, "/api/git/fetch"> | Route<"git.pull", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+}>, "/api/git/pull"> | Route<"git.push", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+}>, "/api/git/push"> | Route<"git.status", import("../git.js").GitStatus, "/api/git"> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept"> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge"> | Route<"knowledge.delete", {
+    ok: boolean;
+}, "/api/knowledge/:bundle"> | Route<"knowledge.get", import("../knowledge.js").BundleDetail, "/api/knowledge/:bundle"> | Route<"knowledge.list", import("../knowledge.js").KnowledgeIndex, "/api/knowledge"> | Route<"knowledge.putConcept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept"> | Route<"knowledge.verify", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/verify"> | Route<"meta.get", {
+    version: string;
+    diskVersion: string;
+    restartable: boolean;
+    projectName: string;
+    projectIcon: string;
+    projectColor: string;
+    projectNamed: boolean;
+    projectRoot: string;
+    projectRootLabel: string;
+    git: boolean;
+    repos: boolean;
+    vibeables: boolean;
+    projects: boolean;
+    publicUrl: string;
+    cloud: import("../cloud.js").CloudStatus;
+    switcher: import("../../config.js").SwitcherEntry[];
+}, "/api/meta"> | Route<"notifications.clear", {
+    ok: boolean;
+}, "/api/notifications"> | Route<"notifications.diagnose", import("./router.js").Reply<{
+    error: string;
+    status: number;
+}> | {
+    chatId: string;
+    href: string;
+}, "/api/notifications/:id/diagnose"> | Route<"notifications.list", import("../notifications.js").NotificationsView, "/api/notifications"> | Route<"notifications.read", import("../notifications.js").NotificationsView, "/api/notifications/read"> | Route<"projects.create", import("./router.js").Reply<import("../projects.js").ProjectDetail>, "/api/projects"> | Route<"projects.delete", {
+    ok: boolean;
+}, "/api/projects/:slug"> | Route<"projects.get", import("../projects.js").ProjectDetail, "/api/projects/:slug"> | Route<"projects.link", import("../projects.js").ProjectDetail, "/api/projects/:slug/links"> | Route<"projects.list", import("../projects.js").ProjectsView, "/api/projects"> | Route<"projects.log", {
+    ok: boolean;
+    log: string;
+}, "/api/projects/:slug/log"> | Route<"projects.save", import("../projects.js").ProjectDetail, "/api/projects/:slug"> | Route<"projects.saveLayout", {
+    ok: boolean;
+    layout: import("../projects.js").ProjectLayout;
+}, "/api/projects"> | Route<"protocol.get", {
+    version: number;
+    routes: RouteInfo[];
+}, "/api/protocol"> | Route<"repos.add", import("./router.js").Reply<import("../repos.js").RepoInfo>, "/api/repos"> | Route<"repos.commit", import("./router.js").Reply<import("../git.js").GitDiff>, "/api/repos/:slug/commits/:hash"> | Route<"repos.diff", import("./router.js").Reply<import("../git.js").GitDiff>, "/api/repos/:slug/diff"> | Route<"repos.get", import("../repos.js").RepoDetail, "/api/repos/:slug"> | Route<"repos.list", import("../repos.js").ReposView, "/api/repos"> | Route<"repos.remove", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+    off?: boolean;
+    conflict?: boolean;
+}>, "/api/repos/:slug"> | Route<"repos.update", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+    off?: boolean;
+    repo?: import("../repos.js").RepoInfo;
+}>, "/api/repos/:slug/update"> | Route<"routines.list", {
+    routines: (import("../routines.js").RoutineStatus & {
+        agent: {
+            slug: string;
+            name: string;
+            emoji: string;
+        };
+        workflows: string[];
+    })[];
+}, "/api/routines"> | Route<"runs.decide", import("../decisions.js").DecisionAnswer, "/api/runs/:id/decision"> | Route<"runs.delete", {
+    deleted: boolean;
+}, "/api/runs/:id"> | Route<"runs.file", undefined, "/api/runs/:id/file"> | Route<"runs.fileText", {
+    name: string;
+    size: number;
+    truncated: boolean;
+    content: string;
+}, "/api/runs/:id/text"> | Route<"runs.get", import("../runs.js").RunDetail, "/api/runs/:id"> | Route<"runs.list", {
+    outputDir: string;
+    runs: import("../runs.js").RunListItem[];
+}, "/api/runs"> | Route<"runs.stop", {
+    stopped: boolean;
+}, "/api/runs/:id/stop"> | Route<"search.agents", import("../search.js").AgentSearch, "/api/search/agents"> | Route<"server.restart", {
+    ok: boolean;
+}, "/api/restart"> | Route<"settings.get", import("../settings.js").SettingsView, "/api/settings"> | Route<"settings.save", import("../settings.js").SettingsView, "/api/settings"> | Route<"skills.get", import("../skills.js").SkillDetail, "/api/skills/:name"> | Route<"skills.list", {
+    root: string;
+    skills: import("../skills.js").SkillInfo[];
+}, "/api/skills"> | Route<"trash.empty", {
+    ok: boolean;
+    purged: number;
+}, "/api/trash"> | Route<"trash.list", {
+    root: string;
+    entries: import("../trash.js").TrashEntry[];
+}, "/api/trash"> | Route<"trash.purge", import("../trash.js").TrashEntry, "/api/trash/purge"> | Route<"trash.restore", import("../trash.js").TrashEntry, "/api/trash/restore"> | Route<"update.check", import("./router.js").Reply<{
+    name: string;
+    current: string;
+    latest: string;
+    error: string;
+}> | {
+    name: string;
+    current: string;
+    latest: string;
+    error?: string;
+}, "/api/update-check"> | Route<"update.start", import("./router.js").Reply<{
+    state: "idle" | "running" | "done" | "failed";
+    version?: string;
+    log: string[];
+    startedAt?: string;
+    finishedAt?: string;
+    exitCode?: number | null;
+    name: string;
+}>, "/api/update"> | Route<"update.status", {
+    state: "idle" | "running" | "done" | "failed";
+    version?: string;
+    log: string[];
+    startedAt?: string;
+    finishedAt?: string;
+    exitCode?: number | null;
+    name: string;
+    available: boolean;
+    reason: string | undefined;
+    restartable: boolean;
+}, "/api/update"> | Route<"vibeables.create", import("./router.js").Reply<import("../vibeables.js").VibeableInfo>, "/api/vibeables"> | Route<"vibeables.delete", {
+    ok: boolean;
+}, "/api/vibeables/:slug"> | Route<"vibeables.devStart", import("../vibeables.js").VibeableStatus, "/api/vibeables/:slug/dev/start"> | Route<"vibeables.devStop", import("../vibeables.js").VibeableStatus, "/api/vibeables/:slug/dev/stop"> | Route<"vibeables.events", void, "/api/vibeables/:slug/events"> | Route<"vibeables.get", import("../vibeables.js").VibeableStatus, "/api/vibeables/:slug"> | Route<"vibeables.list", import("../vibeables.js").VibeablesView, "/api/vibeables"> | Route<"workflows.delete", {
+    ok: boolean;
+}, "/api/workflows/:slug"> | Route<"workflows.get", import("../workflows.js").WorkflowDetail, "/api/workflows/:slug"> | Route<"workflows.list", {
+    root?: string;
+    workflows: import("../workflows.js").WorkflowSummary[];
+}, "/api/workflows"> | Route<"workflows.run", {
+    runId: string;
+}, "/api/workflows/:slug/run"> | Route<"workflows.runner", {
+    available: boolean;
+    image: boolean;
+}, "/api/workflows/:slug/run"> | Route<"workspaces.forget", {
+    ok: boolean;
+}, "/api/workspaces/forget"> | Route<"workspaces.list", import("../instances.js").WorkspaceDetail[], "/api/workspaces"> | Route<"workspaces.start", import("./router.js").Reply<import("../instances.js").StartResult>, "/api/workspaces/start"> | Route<"workspaces.stop", import("./router.js").Reply<{
+    ok: boolean;
+    error?: string;
+}>, "/api/workspaces/stop">)[];
+export declare const apiRouter: import("./router.js").Router;
+type AnyRoute = (typeof routes)[number];
+/** Every route name. */
+export type ApiName = AnyRoute["name"];
+/** The result of route `N` (its 200 body). */
+export type ApiResult<N extends ApiName> = ResultOf<Extract<AnyRoute, {
+    name: N;
+}>>;
+/** The path pattern of route `N` (`/api/projects/:slug`). */
+export type ApiPath<N extends ApiName> = PathOf<Extract<AnyRoute, {
+    name: N;
+}>>;
+export {};

package/dist/inspector/api/index.js

@@ -0,0 +1,43 @@
+import { agentRoutes } from "./agents.js";
+import { attentionRoutes } from "./attention.js";
+import { channelRoutes } from "./channels.js";
+import { chatRoutes } from "./chats.js";
+import { fileRoutes } from "./files.js";
+import { gitRoutes } from "./git.js";
+import { knowledgeRoutes } from "./knowledge.js";
+import { projectRoutes } from "./projects.js";
+import { createRouter, route } from "./router.js";
+import { runRoutes } from "./runs.js";
+import { vibeableRoutes } from "./vibeables.js";
+import { workspaceRoutes } from "./workspace.js";
+/**
+ * The control plane's contract. Every route has a stable name; clients
+ * (the web UI today, a native app or the CLI later) address it by that name
+ * and get the handler's return type as its result — inferred, so the
+ * contract cannot drift from the implementation. Bump PROTOCOL_VERSION when
+ * a route is removed or its result changes incompatibly; adding routes or
+ * fields is not a bump.
+ */
+export const PROTOCOL_VERSION = 1;
+const domainRoutes = [
+    ...workspaceRoutes,
+    ...attentionRoutes,
+    ...agentRoutes,
+    ...chatRoutes,
+    ...channelRoutes,
+    ...projectRoutes,
+    ...runRoutes,
+    ...knowledgeRoutes,
+    ...fileRoutes,
+    ...gitRoutes,
+    ...vibeableRoutes,
+];
+const protocolRoute = route({ name: "protocol.get", method: "GET", path: "/api/protocol", summary: "the protocol version and every route" }, async () => ({
+    version: PROTOCOL_VERSION,
+    routes: describe(),
+}));
+function describe() {
+    return routes.map(({ name, method, path, summary, raw, upload }) => ({ name, method, path, summary, ...(raw ? { raw } : {}), ...(upload ? { upload } : {}) }));
+}
+export const routes = [protocolRoute, ...domainRoutes];
+export const apiRouter = createRouter(routes);

package/dist/inspector/api/knowledge.d.ts

@@ -0,0 +1,13 @@
+/** Knowledge bundles and their concepts, the workspace's skills, and the trash. */
+export declare const knowledgeRoutes: (import("./router.js").Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept"> | import("./router.js").Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge"> | import("./router.js").Route<"knowledge.delete", {
+    ok: boolean;
+}, "/api/knowledge/:bundle"> | import("./router.js").Route<"knowledge.get", import("../knowledge.js").BundleDetail, "/api/knowledge/:bundle"> | import("./router.js").Route<"knowledge.list", import("../knowledge.js").KnowledgeIndex, "/api/knowledge"> | import("./router.js").Route<"knowledge.putConcept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept"> | import("./router.js").Route<"knowledge.verify", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/verify"> | import("./router.js").Route<"skills.get", import("../skills.js").SkillDetail, "/api/skills/:name"> | import("./router.js").Route<"skills.list", {
+    root: string;
+    skills: import("../skills.js").SkillInfo[];
+}, "/api/skills"> | import("./router.js").Route<"trash.empty", {
+    ok: boolean;
+    purged: number;
+}, "/api/trash"> | import("./router.js").Route<"trash.list", {
+    root: string;
+    entries: import("../trash.js").TrashEntry[];
+}, "/api/trash"> | import("./router.js").Route<"trash.purge", import("../trash.js").TrashEntry, "/api/trash/purge"> | import("./router.js").Route<"trash.restore", import("../trash.js").TrashEntry, "/api/trash/restore">)[];

package/dist/inspector/api/knowledge.js

@@ -0,0 +1,56 @@
+import { tildify } from "../instances.js";
+import { bundleDetail, conceptDetail, createBundle, deleteBundle, knowledgeIndex, putConcept, verifyFromUi } from "../knowledge.js";
+import { getSkill, listSkills, skillsRoot } from "../skills.js";
+import { emptyTrash, listTrash, purgeFromTrash, restoreFromTrash, trashRoot } from "../trash.js";
+import { ApiError, fail, route } from "./router.js";
+/** Knowledge bundles and their concepts, the workspace's skills, and the trash. */
+export const knowledgeRoutes = [
+    route({ name: "knowledge.list", method: "GET", path: "/api/knowledge", summary: "the bundle index" }, async () => knowledgeIndex()),
+    route({ name: "knowledge.create", method: "POST", path: "/api/knowledge", summary: "create a bundle {name}", errors: 400 }, async (c) => createBundle(String((await c.body()).name ?? "").trim())),
+    route({ name: "knowledge.get", method: "GET", path: "/api/knowledge/:bundle", summary: "a bundle's concepts and log" }, async (c) => {
+        const detail = await bundleDetail(c.params.bundle).catch(() => {
+            throw new ApiError(400, "invalid bundle name");
+        });
+        return detail ?? fail(404, "not found");
+    }),
+    route({ name: "knowledge.delete", method: "DELETE", path: "/api/knowledge/:bundle", summary: "move the bundle to the trash", errors: 400 }, async (c) => {
+        await deleteBundle(c.params.bundle);
+        return { ok: true };
+    }),
+    route({ name: "knowledge.concept", method: "GET", path: "/api/knowledge/:bundle/concept", summary: "one concept ?id=", errors: 400 }, async (c) => (await conceptDetail(c.params.bundle, c.query.get("id") ?? "")) ?? fail(404, "not found")),
+    route({ name: "knowledge.putConcept", method: "POST", path: "/api/knowledge/:bundle/concept", summary: "write one concept {id, content}", errors: 400 }, async (c) => {
+        const body = await c.body();
+        if (!body.id || !body.content?.trim())
+            fail(400, "id and content are required");
+        return putConcept(c.params.bundle, body.id, body.content);
+    }),
+    route({ name: "knowledge.verify", method: "POST", path: "/api/knowledge/:bundle/verify", summary: "a person verifies a concept {id}", errors: 400 }, async (c) => {
+        const { id } = await c.body();
+        if (!id)
+            fail(400, "id is required");
+        return verifyFromUi(c.params.bundle, id);
+    }),
+    // Discovered from the workspace root, .claude/skills and ~/.claude/skills.
+    route({ name: "skills.list", method: "GET", path: "/api/skills", summary: "every discovered skill" }, async () => {
+        const [root, skills] = await Promise.all([skillsRoot(), listSkills()]);
+        return { root, skills };
+    }),
+    route({ name: "skills.get", method: "GET", path: "/api/skills/:name", summary: "one skill with SKILL.md and its bundled files" }, async (c) => (await getSkill(c.params.name)) ?? fail(404, "not found")),
+    route({ name: "trash.list", method: "GET", path: "/api/trash", summary: "what was deleted, newest first", errors: 400 }, async () => ({
+        root: tildify(await trashRoot()),
+        entries: await listTrash(),
+    })),
+    route({ name: "trash.empty", method: "DELETE", path: "/api/trash", summary: "empty the trash for good", errors: 400 }, async () => ({ ok: true, purged: await emptyTrash() })),
+    route({ name: "trash.restore", method: "POST", path: "/api/trash/restore", summary: "put one {id} back", errors: 400 }, async (c) => {
+        const { id } = await c.body();
+        if (!id)
+            fail(400, "id is required");
+        return restoreFromTrash(id);
+    }),
+    route({ name: "trash.purge", method: "POST", path: "/api/trash/purge", summary: "delete one {id} for good", errors: 400 }, async (c) => {
+        const { id } = await c.body();
+        if (!id)
+            fail(400, "id is required");
+        return purgeFromTrash(id);
+    }),
+];

package/dist/inspector/api/mime.d.ts

@@ -0,0 +1,2 @@
+/** Content types by extension, for files served as themselves. */
+export declare const MIME: Record<string, string>;

package/dist/inspector/api/mime.js

@@ -0,0 +1,18 @@
+/** Content types by extension, for files served as themselves. */
+export const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".pdf": "application/pdf",
+    ".json": "application/json; charset=utf-8",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".txt": "text/plain; charset=utf-8",
+};

package/dist/inspector/api/projects.d.ts

@@ -0,0 +1,11 @@
+export declare const projectErrors: (message: string) => number;
+/** Projects: folders with a goal, a brief, a log and links, plus the rail's order. */
+export declare const projectRoutes: (import("./router.js").Route<"projects.create", import("./router.js").Reply<import("../projects.js").ProjectDetail>, "/api/projects"> | import("./router.js").Route<"projects.delete", {
+    ok: boolean;
+}, "/api/projects/:slug"> | import("./router.js").Route<"projects.get", import("../projects.js").ProjectDetail, "/api/projects/:slug"> | import("./router.js").Route<"projects.link", import("../projects.js").ProjectDetail, "/api/projects/:slug/links"> | import("./router.js").Route<"projects.list", import("../projects.js").ProjectsView, "/api/projects"> | import("./router.js").Route<"projects.log", {
+    ok: boolean;
+    log: string;
+}, "/api/projects/:slug/log"> | import("./router.js").Route<"projects.save", import("../projects.js").ProjectDetail, "/api/projects/:slug"> | import("./router.js").Route<"projects.saveLayout", {
+    ok: boolean;
+    layout: import("../projects.js").ProjectLayout;
+}, "/api/projects">)[];

package/dist/inspector/api/projects.js

@@ -0,0 +1,32 @@
+import { appendProjectLog, createProject, deleteProject, getProject, linkProject, listProjects, openProjects, saveLayout, saveProject } from "../projects.js";
+import { fail, reply, route, statusByMessage } from "./router.js";
+export const projectErrors = statusByMessage(/^no project/);
+const str = (v) => (typeof v === "string" ? v : undefined);
+/** Projects: folders with a goal, a brief, a log and links, plus the rail's order. */
+export const projectRoutes = [
+    route({ name: "projects.list", method: "GET", path: "/api/projects", summary: "every project folder, with the rail's layout" }, async () => listProjects()),
+    route({ name: "projects.create", method: "POST", path: "/api/projects", summary: "create one {title, goal?, slug?} from the starter", errors: 400 }, async (c) => {
+        if ((await openProjects()).off)
+            fail(409, "projects are off");
+        const body = await c.body();
+        return reply(201, await createProject({ title: str(body.title) ?? "", goal: str(body.goal), slug: str(body.slug) }));
+    }),
+    route({ name: "projects.saveLayout", method: "PUT", path: "/api/projects", summary: "save the rail's order and sections {top, sections}", errors: projectErrors }, async (c) => ({
+        ok: true,
+        layout: await saveLayout(await c.body()),
+    })),
+    route({ name: "projects.get", method: "GET", path: "/api/projects/:slug", summary: "definition, brief, state, log and link states", errors: projectErrors }, async (c) => (await getProject(c.params.slug)) ?? fail(404, `no project "${c.params.slug}"`)),
+    route({ name: "projects.save", method: "PUT", path: "/api/projects/:slug", summary: "save fields", errors: projectErrors }, async (c) => saveProject(c.params.slug, await c.body())),
+    route({ name: "projects.delete", method: "DELETE", path: "/api/projects/:slug", summary: "move the folder to the trash", errors: projectErrors }, async (c) => {
+        await deleteProject(c.params.slug);
+        return { ok: true };
+    }),
+    route({ name: "projects.log", method: "POST", path: "/api/projects/:slug/log", summary: "append a stamped line {entry, actor?} to log.md", errors: projectErrors }, async (c) => {
+        const body = await c.body();
+        return { ok: true, log: await appendProjectLog(c.params.slug, str(body.entry) ?? "", str(body.actor) ?? "human:user") };
+    }),
+    route({ name: "projects.link", method: "POST", path: "/api/projects/:slug/links", summary: "add or drop one linked slug {kind, target, remove?}", errors: projectErrors }, async (c) => {
+        const body = await c.body();
+        return linkProject(c.params.slug, str(body.kind) ?? "", str(body.target) ?? "", body.remove === true);
+    }),
+];

package/dist/inspector/api/router.d.ts

@@ -0,0 +1,75 @@
+import type http from "node:http";
+/**
+ * The API's routing: every endpoint is one named route — an RPC-style name
+ * (`projects.get`), an HTTP method + path pattern, and a handler that
+ * returns its result instead of writing the response. The name and the
+ * result type are the contract other clients build on (see api/index.ts);
+ * HTTP is one transport for it. Handlers that must own the response — SSE
+ * streams, file downloads, raw uploads — are marked `raw` and write to
+ * `c.res` themselves.
+ */
+export type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface Ctx {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    url: URL;
+    /** Path parameters, already URI-decoded (`:slug` → params.slug). */
+    params: Record<string, string>;
+    query: URLSearchParams;
+    /** The JSON body; an empty body is `{}`, malformed JSON a 400. Read once. */
+    body<T = Record<string, unknown>>(): Promise<T>;
+}
+/** A result with a status other than 200 (201 created, 409 with a body, …). */
+export declare class Reply<B> {
+    readonly status: number;
+    readonly body: B;
+    constructor(status: number, body: B);
+}
+export declare const reply: <B>(status: number, body: B) => Reply<B>;
+/** A refusal with a status; the body is `{error}` unless given. */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, message: string, body?: unknown);
+}
+export declare function fail(status: number, message: string): never;
+export interface RouteDef<N extends string, P extends string = string> {
+    name: N;
+    method: Method;
+    /** `/api/projects/:slug/log` — literal segments win over parameters. */
+    path: P;
+    summary: string;
+    /** Status for an Error the handler throws (not an ApiError); default 500. */
+    errors?: number | ((message: string) => number);
+    /** The handler writes the response itself (streams, files). HTTP only. */
+    raw?: boolean;
+    /** The request body is the bytes of a file (`c.req`), not JSON. HTTP only. */
+    upload?: boolean;
+}
+export interface Route<N extends string = string, R = unknown, P extends string = string> extends RouteDef<N, P> {
+    handle(c: Ctx): Promise<R>;
+}
+export declare function route<const N extends string, R, const P extends string>(def: RouteDef<N, P>, handle: (c: Ctx) => Promise<R>): Route<N, R, P>;
+/** The 200 body of a route's result. */
+export type ResultOf<R> = R extends Route<string, infer T, string> ? (T extends Reply<infer B> ? B : T) : never;
+/** A route's path pattern, as a literal type. */
+export type PathOf<R> = R extends Route<string, unknown, infer P> ? P : never;
+/** Maps an error message to a status by the usual wording: "no <thing>" is 404, "… are off" 409, else 400. */
+export declare const statusByMessage: (missing: RegExp) => (message: string) => number;
+export interface Router {
+    routes: readonly Route[];
+    handle(req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void>;
+    /**
+     * Run a route by name without HTTP (the socket): path parameters by name,
+     * `query` and `body` beside them. Raw and upload routes are refused.
+     */
+    invoke(name: string, input: Record<string, unknown>): Promise<{
+        status: number;
+        data: unknown;
+    }>;
+}
+export declare function json(res: http.ServerResponse, body: unknown, status?: number): void;
+export declare function readBody(req: http.IncomingMessage): Promise<string>;
+/** A raw upload body (attachments), capped at `max` bytes. */
+export declare function readRawBody(req: http.IncomingMessage, max: number): Promise<Buffer>;
+export declare function createRouter(routes: readonly Route[]): Router;