@netnodeag/kraftwerk 0.61.0 → 0.63.0

package/dist/cli/routines.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import chalk from "chalk";
 import { resolveProject } from "../config.js";
-import { setOutputDir, setProjectRoot } from "../inspector/context.js";
+import { setDefaultWorkspace, Workspace } from "../inspector/workspace.js";
 import { deleteRoutine, listRoutines, routineStatuses, saveRoutine, } from "../inspector/routines.js";
 import { getAgent, listAgents } from "../inspector/agents.js";
 /**
@@ -14,8 +14,7 @@ import { getAgent, listAgents } from "../inspector/agents.js";
 /** Point the inspector context at this project so agent/routine paths resolve. */
 export async function initContext() {
     const project = await resolveProject(process.cwd());
-    setProjectRoot(project.root);
-    setOutputDir(project.outputDir);
+    setDefaultWorkspace(new Workspace({ root: project.root, outputDir: project.outputDir }));
     return { port: project.config.port ?? 1981 };
 }
 async function requireAgent(slug) {

package/dist/client/index.d.ts

@@ -0,0 +1,59 @@
+import type { ApiName, ApiPath, ApiResult } from "../inspector/api/index.js";
+/**
+ * The kraftwerk client: every control-plane route by name, typed by the
+ * server's own handlers. Runs wherever `fetch` does — the web UI, Node (the
+ * CLI), a native app's JS runtime. No server code is bundled: the route
+ * table is generated (routes.ts), the types are erased.
+ *
+ *   const api = createClient();
+ *   const project = await api.call("projects.get", { slug });
+ *   await api.call("projects.log", { slug, body: { entry } });
+ *
+ * Path parameters go by name next to `query` and `body`. `call` throws an
+ * ApiRequestError on any non-2xx answer; `request` returns the status and
+ * body instead, for routes whose refusal carries a result (a 409 git commit,
+ * a repository with unpushed work).
+ */
+export type { ApiName, ApiPath, ApiResult };
+export { createLive, type Live, type LiveOptions, type WatchOptions } from "./live.js";
+type ParamNames<P extends string> = P extends `${string}:${infer Name}/${infer Rest}` ? Name | ParamNames<`/${Rest}`> : P extends `${string}:${infer Name}` ? Name : never;
+type PathParams<N extends ApiName> = {
+    [K in ParamNames<ApiPath<N>>]: string;
+};
+export type Query = Record<string, string | number | boolean | undefined | null>;
+/** What a call sends besides the path parameters. A Blob/File/ArrayBuffer body is sent as is (uploads), anything else as JSON. */
+export interface CallExtras {
+    query?: Query;
+    body?: unknown;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    /** Let the request outlive the page (a save on tab close). */
+    keepalive?: boolean;
+}
+export type CallInput<N extends ApiName> = PathParams<N> & CallExtras;
+/** Routes without path parameters may omit the input. */
+type InputArg<N extends ApiName> = [ParamNames<ApiPath<N>>] extends [never] ? [input?: CallInput<N>] : [input: CallInput<N>];
+export declare class ApiRequestError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    readonly route: string;
+    constructor(status: number, body: unknown, route: string);
+}
+export interface ApiResponse<T> {
+    ok: boolean;
+    status: number;
+    /** The result when ok; the error body (usually `{error}`) otherwise. */
+    data: T;
+}
+export interface ClientOptions {
+    /** Where the server is; "" (the default) is the page's own origin. */
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+export interface Client {
+    call<N extends ApiName>(name: N, ...input: InputArg<N>): Promise<ApiResult<N>>;
+    request<N extends ApiName>(name: N, ...input: InputArg<N>): Promise<ApiResponse<ApiResult<N>>>;
+    /** The URL of a route: for raw routes (a file to show or download, an event stream) and links. */
+    url<N extends ApiName>(name: N, ...input: InputArg<N>): string;
+}
+export declare function createClient(opts?: ClientOptions): Client;

package/dist/client/index.js

@@ -0,0 +1,63 @@
+import { ROUTES } from "./routes.js";
+export { createLive } from "./live.js";
+export class ApiRequestError extends Error {
+    status;
+    body;
+    route;
+    constructor(status, body, route) {
+        const error = body && typeof body === "object" && "error" in body ? body.error : undefined;
+        super(typeof error === "string" && error ? error : `${route}: HTTP ${status}`);
+        this.status = status;
+        this.body = body;
+        this.route = route;
+    }
+}
+export function createClient(opts = {}) {
+    const base = (opts.baseUrl ?? "").replace(/\/+$/, "");
+    const doFetch = opts.fetch ?? ((...a) => fetch(...a));
+    const url = (name, input = {}) => {
+        const [, pattern] = ROUTES[name];
+        const path = pattern.replace(/:([A-Za-z]+)/g, (_, key) => {
+            const v = input[key];
+            if (v === undefined || v === null || v === "")
+                throw new Error(`${name}: missing path parameter ${key}`);
+            return encodeURIComponent(String(v));
+        });
+        const q = new URLSearchParams();
+        for (const [k, v] of Object.entries(input.query ?? {}))
+            if (v !== undefined && v !== null && v !== false)
+                q.set(k, v === true ? "1" : String(v));
+        const qs = q.toString();
+        return `${base}${path}${qs ? `?${qs}` : ""}`;
+    };
+    const request = async (name, input = {}) => {
+        const [method] = ROUTES[name];
+        const { body, headers = {}, signal, keepalive } = input;
+        const raw = body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+        const res = await doFetch(url(name, input), {
+            method,
+            cache: "no-store",
+            signal,
+            keepalive,
+            headers: { ...(body !== undefined && !raw ? { "content-type": "application/json" } : {}), ...headers },
+            body: body === undefined ? undefined : raw ? body : JSON.stringify(body),
+        });
+        const text = await res.text();
+        let data = text;
+        try {
+            data = text ? JSON.parse(text) : undefined;
+        }
+        catch { }
+        return { ok: res.ok, status: res.status, data };
+    };
+    return {
+        url: ((name, input) => url(name, input)),
+        request: ((name, input) => request(name, input)),
+        call: (async (name, input) => {
+            const r = await request(name, input);
+            if (!r.ok)
+                throw new ApiRequestError(r.status, r.data, name);
+            return r.data;
+        }),
+    };
+}

package/dist/client/live.d.ts

@@ -0,0 +1,34 @@
+import type { ApiName, ApiResult, CallInput, Client } from "./index.js";
+/**
+ * Live data over the control plane's socket (/api/ws): route results that
+ * stay current (`watch`) and event streams (`subscribe`). One connection
+ * carries them all; the server pushes a watched result when it changes,
+ * and replays a chat's events from the last one seen after a reconnect.
+ *
+ * Without a socket — none in this runtime, or the connection is down — a
+ * watch polls over HTTP at its interval and a stream uses the server-sent
+ * events route where the runtime has EventSource, so callers never notice
+ * which one they got. One-off calls stay on the HTTP client.
+ */
+export interface WatchOptions {
+    /** How stale the result may get when nothing announces a change, in ms (default 6 s). */
+    interval?: number;
+}
+export interface Live {
+    watch<N extends ApiName>(name: N, input: CallInput<N> | undefined, opts: WatchOptions, onData: (data: ApiResult<N>) => void): () => void;
+    /** `chat.<id>` (from the event after seq `after`) or `vibeable.<slug>`. */
+    subscribe(topic: string, opts: {
+        after?: number;
+    }, onEvent: (event: unknown) => void): () => void;
+    /** Whether the socket is up (else watches poll and streams use EventSource). */
+    readonly connected: boolean;
+    close(): void;
+}
+export interface LiveOptions {
+    /** The HTTP client for fallbacks; its baseUrl is the server. */
+    client: Client;
+    baseUrl?: string;
+    WebSocket?: typeof WebSocket;
+    EventSource?: typeof EventSource;
+}
+export declare function createLive(opts: LiveOptions): Live;

package/dist/client/live.js

@@ -0,0 +1,169 @@
+const MAX_BACKOFF = 10_000;
+export function createLive(opts) {
+    const WS = opts.WebSocket ?? (typeof WebSocket === "undefined" ? undefined : WebSocket);
+    const ES = opts.EventSource ?? (typeof EventSource === "undefined" ? undefined : EventSource);
+    const { client } = opts;
+    const watches = new Map();
+    const subs = new Map();
+    let socket = null;
+    let connected = false;
+    let closed = false;
+    let backoff = 500;
+    let retry;
+    let counter = 0;
+    const socketUrl = () => {
+        const base = opts.baseUrl ?? (typeof location === "undefined" ? "" : location.origin);
+        return `${base.replace(/^http/, "ws").replace(/\/+$/, "")}/api/ws`;
+    };
+    const send = (msg) => {
+        if (connected)
+            socket?.send(JSON.stringify(msg));
+    };
+    /* ---------- fallbacks ---------- */
+    const poll = (key) => {
+        const w = watches.get(key);
+        if (!w || connected)
+            return;
+        clearTimeout(w.timer);
+        void client.request(w.name, w.input)
+            .then((r) => r.ok && watches.get(key) === w && !connected && w.onData(r.data))
+            .catch(() => { })
+            .finally(() => {
+            if (watches.get(key) === w && !connected)
+                w.timer = setTimeout(() => poll(key), w.interval);
+        });
+    };
+    const stream = (key) => {
+        const s = subs.get(key);
+        if (!s || connected || s.source || !ES)
+            return;
+        const [kind, ...rest] = s.topic.split(".");
+        const name = rest.join(".");
+        const url = kind === "chat"
+            ? client.url("chats.events", { id: name, query: { after: s.after } })
+            : kind === "vibeable"
+                ? client.url("vibeables.events", { slug: name })
+                : "";
+        if (!url)
+            return;
+        s.source = new ES(url);
+        s.source.onmessage = (m) => deliver(key, JSON.parse(m.data));
+    };
+    const deliver = (key, data) => {
+        const s = subs.get(key);
+        if (!s)
+            return;
+        const seq = data?.seq;
+        if (typeof seq === "number") {
+            // A replay after a reconnect may overlap what arrived already.
+            if (seq <= s.after)
+                return;
+            s.after = seq;
+        }
+        s.onEvent(data);
+    };
+    /* ---------- the socket ---------- */
+    const resume = () => {
+        for (const [key, w] of watches) {
+            clearTimeout(w.timer);
+            send({ watch: key, name: w.name, input: w.input, interval: w.interval });
+        }
+        for (const [key, s] of subs) {
+            s.source?.close();
+            s.source = undefined;
+            send({ sub: key, topic: s.topic, after: s.after });
+        }
+    };
+    const fallBack = () => {
+        for (const key of watches.keys())
+            poll(key);
+        for (const key of subs.keys())
+            stream(key);
+    };
+    const connect = () => {
+        if (closed || socket || !WS)
+            return;
+        let ws;
+        try {
+            ws = new WS(socketUrl());
+        }
+        catch {
+            return fallBack();
+        }
+        socket = ws;
+        ws.onopen = () => {
+            connected = true;
+            backoff = 500;
+            resume();
+        };
+        ws.onmessage = (m) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(m.data));
+            }
+            catch {
+                return;
+            }
+            if (msg.watch && "data" in msg)
+                watches.get(msg.watch)?.onData(msg.data);
+            else if (msg.event)
+                deliver(msg.event, msg.data);
+        };
+        ws.onclose = () => {
+            socket = null;
+            connected = false;
+            if (closed)
+                return;
+            fallBack();
+            retry = setTimeout(connect, backoff);
+            backoff = Math.min(MAX_BACKOFF, backoff * 2);
+        };
+    };
+    return {
+        get connected() {
+            return connected;
+        },
+        watch(name, input, o, onData) {
+            const key = `w${++counter}`;
+            watches.set(key, { name, input: (input ?? {}), interval: o.interval ?? 6000, onData: onData });
+            if (connected)
+                send({ watch: key, name, input: input ?? {}, interval: o.interval ?? 6000 });
+            else {
+                // Until the socket is up (or for good, without one), poll.
+                poll(key);
+                connect();
+            }
+            return () => {
+                clearTimeout(watches.get(key)?.timer);
+                watches.delete(key);
+                send({ unwatch: key });
+            };
+        },
+        subscribe(topic, o, onEvent) {
+            const key = `s${++counter}`;
+            subs.set(key, { topic, after: o.after ?? 0, onEvent });
+            if (connected)
+                send({ sub: key, topic, after: o.after ?? 0 });
+            else {
+                stream(key);
+                connect();
+            }
+            return () => {
+                subs.get(key)?.source?.close();
+                subs.delete(key);
+                send({ unsub: key });
+            };
+        },
+        close() {
+            closed = true;
+            clearTimeout(retry);
+            socket?.close();
+            for (const w of watches.values())
+                clearTimeout(w.timer);
+            for (const s of subs.values())
+                s.source?.close();
+            watches.clear();
+            subs.clear();
+        },
+    };
+}

package/dist/client/routes.d.ts

@@ -0,0 +1,125 @@
+/** Route name → [method, path pattern, and "raw" (answers a stream or a file) or "upload" (sends file bytes): both HTTP only]. */
+export declare const ROUTES: {
+    readonly "agents.addJournal": readonly ["POST", "/api/agents/:slug/journal"];
+    readonly "agents.archive": readonly ["POST", "/api/agents/:slug/archive"];
+    readonly "agents.create": readonly ["POST", "/api/agents"];
+    readonly "agents.delete": readonly ["DELETE", "/api/agents/:slug"];
+    readonly "agents.deleteRoutine": readonly ["DELETE", "/api/agents/:slug/routines/:id"];
+    readonly "agents.deleteSkill": readonly ["DELETE", "/api/agents/:slug/skills/:name"];
+    readonly "agents.get": readonly ["GET", "/api/agents/:slug"];
+    readonly "agents.journal": readonly ["GET", "/api/agents/:slug/journal"];
+    readonly "agents.list": readonly ["GET", "/api/agents"];
+    readonly "agents.routines": readonly ["GET", "/api/agents/:slug/routines"];
+    readonly "agents.runRoutine": readonly ["POST", "/api/agents/:slug/routines/:id/run"];
+    readonly "agents.save": readonly ["PUT", "/api/agents/:slug"];
+    readonly "agents.saveRoutine": readonly ["POST", "/api/agents/:slug/routines"];
+    readonly "agents.saveSkill": readonly ["POST", "/api/agents/:slug/skills"];
+    readonly "agents.sessions": readonly ["GET", "/api/agent-sessions"];
+    readonly "agents.skill": readonly ["GET", "/api/agents/:slug/skills/:name"];
+    readonly "agents.skills": readonly ["GET", "/api/agents/:slug/skills"];
+    readonly "agents.status": readonly ["GET", "/api/agent-status"];
+    readonly "attention.list": readonly ["GET", "/api/attention"];
+    readonly "channels.create": readonly ["POST", "/api/channels"];
+    readonly "channels.delete": readonly ["DELETE", "/api/channels/:slug"];
+    readonly "channels.fromChat": readonly ["POST", "/api/channels/from-chat"];
+    readonly "channels.get": readonly ["GET", "/api/channels/:slug"];
+    readonly "channels.list": readonly ["GET", "/api/channels"];
+    readonly "channels.save": readonly ["PUT", "/api/channels/:slug"];
+    readonly "chats.attach": readonly ["POST", "/api/chats/:id/attachments", "upload"];
+    readonly "chats.attachment": readonly ["GET", "/api/chats/:id/attachments/:name", "raw"];
+    readonly "chats.cancel": readonly ["POST", "/api/chats/:id/cancel"];
+    readonly "chats.config": readonly ["POST", "/api/chats/:id/config"];
+    readonly "chats.create": readonly ["POST", "/api/chats"];
+    readonly "chats.delete": readonly ["DELETE", "/api/chats/:id"];
+    readonly "chats.elicitation": readonly ["POST", "/api/chats/:id/elicitation"];
+    readonly "chats.events": readonly ["GET", "/api/chats/:id/events", "raw"];
+    readonly "chats.fork": readonly ["POST", "/api/chats/:id/fork"];
+    readonly "chats.get": readonly ["GET", "/api/chats/:id"];
+    readonly "chats.list": readonly ["GET", "/api/chats"];
+    readonly "chats.message": readonly ["POST", "/api/chats/:id/message"];
+    readonly "chats.permission": readonly ["POST", "/api/chats/:id/permission"];
+    readonly "chats.rename": readonly ["PATCH", "/api/chats/:id"];
+    readonly "chats.resetSession": readonly ["POST", "/api/chats/:id/reset-session"];
+    readonly "chats.setVibeable": readonly ["POST", "/api/chats/:id/vibeable"];
+    readonly "chats.steer": readonly ["POST", "/api/chats/:id/steer"];
+    readonly "chats.stopTask": readonly ["POST", "/api/chats/:id/task-stop"];
+    readonly "files.delete": readonly ["DELETE", "/api/files"];
+    readonly "files.list": readonly ["GET", "/api/files/list"];
+    readonly "files.mkdir": readonly ["POST", "/api/files/folder"];
+    readonly "files.move": readonly ["POST", "/api/files/move"];
+    readonly "files.raw": readonly ["GET", "/api/files/raw", "raw"];
+    readonly "files.recent": readonly ["GET", "/api/files/recent"];
+    readonly "files.scopes": readonly ["GET", "/api/files"];
+    readonly "files.upload": readonly ["POST", "/api/files/upload", "upload"];
+    readonly "git.commit": readonly ["POST", "/api/git/commit"];
+    readonly "git.diff": readonly ["GET", "/api/git/diff"];
+    readonly "git.fetch": readonly ["POST", "/api/git/fetch"];
+    readonly "git.pull": readonly ["POST", "/api/git/pull"];
+    readonly "git.push": readonly ["POST", "/api/git/push"];
+    readonly "git.status": readonly ["GET", "/api/git"];
+    readonly "knowledge.concept": readonly ["GET", "/api/knowledge/:bundle/concept"];
+    readonly "knowledge.create": readonly ["POST", "/api/knowledge"];
+    readonly "knowledge.delete": readonly ["DELETE", "/api/knowledge/:bundle"];
+    readonly "knowledge.get": readonly ["GET", "/api/knowledge/:bundle"];
+    readonly "knowledge.list": readonly ["GET", "/api/knowledge"];
+    readonly "knowledge.putConcept": readonly ["POST", "/api/knowledge/:bundle/concept"];
+    readonly "knowledge.verify": readonly ["POST", "/api/knowledge/:bundle/verify"];
+    readonly "meta.get": readonly ["GET", "/api/meta"];
+    readonly "notifications.clear": readonly ["DELETE", "/api/notifications"];
+    readonly "notifications.diagnose": readonly ["POST", "/api/notifications/:id/diagnose"];
+    readonly "notifications.list": readonly ["GET", "/api/notifications"];
+    readonly "notifications.read": readonly ["POST", "/api/notifications/read"];
+    readonly "projects.create": readonly ["POST", "/api/projects"];
+    readonly "projects.delete": readonly ["DELETE", "/api/projects/:slug"];
+    readonly "projects.get": readonly ["GET", "/api/projects/:slug"];
+    readonly "projects.link": readonly ["POST", "/api/projects/:slug/links"];
+    readonly "projects.list": readonly ["GET", "/api/projects"];
+    readonly "projects.log": readonly ["POST", "/api/projects/:slug/log"];
+    readonly "projects.save": readonly ["PUT", "/api/projects/:slug"];
+    readonly "projects.saveLayout": readonly ["PUT", "/api/projects"];
+    readonly "protocol.get": readonly ["GET", "/api/protocol"];
+    readonly "repos.add": readonly ["POST", "/api/repos"];
+    readonly "repos.commit": readonly ["GET", "/api/repos/:slug/commits/:hash"];
+    readonly "repos.diff": readonly ["GET", "/api/repos/:slug/diff"];
+    readonly "repos.get": readonly ["GET", "/api/repos/:slug"];
+    readonly "repos.list": readonly ["GET", "/api/repos"];
+    readonly "repos.remove": readonly ["DELETE", "/api/repos/:slug"];
+    readonly "repos.update": readonly ["POST", "/api/repos/:slug/update"];
+    readonly "routines.list": readonly ["GET", "/api/routines"];
+    readonly "runs.decide": readonly ["POST", "/api/runs/:id/decision"];
+    readonly "runs.delete": readonly ["DELETE", "/api/runs/:id"];
+    readonly "runs.file": readonly ["GET", "/api/runs/:id/file", "raw"];
+    readonly "runs.fileText": readonly ["GET", "/api/runs/:id/text"];
+    readonly "runs.get": readonly ["GET", "/api/runs/:id"];
+    readonly "runs.list": readonly ["GET", "/api/runs"];
+    readonly "runs.stop": readonly ["POST", "/api/runs/:id/stop"];
+    readonly "search.agents": readonly ["GET", "/api/search/agents"];
+    readonly "server.restart": readonly ["POST", "/api/restart"];
+    readonly "settings.get": readonly ["GET", "/api/settings"];
+    readonly "settings.save": readonly ["PUT", "/api/settings"];
+    readonly "skills.get": readonly ["GET", "/api/skills/:name"];
+    readonly "skills.list": readonly ["GET", "/api/skills"];
+    readonly "trash.empty": readonly ["DELETE", "/api/trash"];
+    readonly "trash.list": readonly ["GET", "/api/trash"];
+    readonly "trash.purge": readonly ["POST", "/api/trash/purge"];
+    readonly "trash.restore": readonly ["POST", "/api/trash/restore"];
+    readonly "update.check": readonly ["GET", "/api/update-check"];
+    readonly "update.start": readonly ["POST", "/api/update"];
+    readonly "update.status": readonly ["GET", "/api/update"];
+    readonly "vibeables.create": readonly ["POST", "/api/vibeables"];
+    readonly "vibeables.delete": readonly ["DELETE", "/api/vibeables/:slug"];
+    readonly "vibeables.devStart": readonly ["POST", "/api/vibeables/:slug/dev/start"];
+    readonly "vibeables.devStop": readonly ["POST", "/api/vibeables/:slug/dev/stop"];
+    readonly "vibeables.events": readonly ["GET", "/api/vibeables/:slug/events", "raw"];
+    readonly "vibeables.get": readonly ["GET", "/api/vibeables/:slug"];
+    readonly "vibeables.list": readonly ["GET", "/api/vibeables"];
+    readonly "workflows.delete": readonly ["DELETE", "/api/workflows/:slug"];
+    readonly "workflows.get": readonly ["GET", "/api/workflows/:slug"];
+    readonly "workflows.list": readonly ["GET", "/api/workflows"];
+    readonly "workflows.run": readonly ["POST", "/api/workflows/:slug/run"];
+    readonly "workflows.runner": readonly ["GET", "/api/workflows/:slug/run"];
+    readonly "workspaces.forget": readonly ["POST", "/api/workspaces/forget"];
+    readonly "workspaces.list": readonly ["GET", "/api/workspaces"];
+    readonly "workspaces.start": readonly ["POST", "/api/workspaces/start"];
+    readonly "workspaces.stop": readonly ["POST", "/api/workspaces/stop"];
+};

package/dist/client/routes.js

@@ -0,0 +1,126 @@
+// Generated by scripts/gen-client-routes.ts from src/inspector/api — do not edit; run `npm run gen:client`.
+/** Route name → [method, path pattern, and "raw" (answers a stream or a file) or "upload" (sends file bytes): both HTTP only]. */
+export const ROUTES = {
+    "agents.addJournal": ["POST", "/api/agents/:slug/journal"],
+    "agents.archive": ["POST", "/api/agents/:slug/archive"],
+    "agents.create": ["POST", "/api/agents"],
+    "agents.delete": ["DELETE", "/api/agents/:slug"],
+    "agents.deleteRoutine": ["DELETE", "/api/agents/:slug/routines/:id"],
+    "agents.deleteSkill": ["DELETE", "/api/agents/:slug/skills/:name"],
+    "agents.get": ["GET", "/api/agents/:slug"],
+    "agents.journal": ["GET", "/api/agents/:slug/journal"],
+    "agents.list": ["GET", "/api/agents"],
+    "agents.routines": ["GET", "/api/agents/:slug/routines"],
+    "agents.runRoutine": ["POST", "/api/agents/:slug/routines/:id/run"],
+    "agents.save": ["PUT", "/api/agents/:slug"],
+    "agents.saveRoutine": ["POST", "/api/agents/:slug/routines"],
+    "agents.saveSkill": ["POST", "/api/agents/:slug/skills"],
+    "agents.sessions": ["GET", "/api/agent-sessions"],
+    "agents.skill": ["GET", "/api/agents/:slug/skills/:name"],
+    "agents.skills": ["GET", "/api/agents/:slug/skills"],
+    "agents.status": ["GET", "/api/agent-status"],
+    "attention.list": ["GET", "/api/attention"],
+    "channels.create": ["POST", "/api/channels"],
+    "channels.delete": ["DELETE", "/api/channels/:slug"],
+    "channels.fromChat": ["POST", "/api/channels/from-chat"],
+    "channels.get": ["GET", "/api/channels/:slug"],
+    "channels.list": ["GET", "/api/channels"],
+    "channels.save": ["PUT", "/api/channels/:slug"],
+    "chats.attach": ["POST", "/api/chats/:id/attachments", "upload"],
+    "chats.attachment": ["GET", "/api/chats/:id/attachments/:name", "raw"],
+    "chats.cancel": ["POST", "/api/chats/:id/cancel"],
+    "chats.config": ["POST", "/api/chats/:id/config"],
+    "chats.create": ["POST", "/api/chats"],
+    "chats.delete": ["DELETE", "/api/chats/:id"],
+    "chats.elicitation": ["POST", "/api/chats/:id/elicitation"],
+    "chats.events": ["GET", "/api/chats/:id/events", "raw"],
+    "chats.fork": ["POST", "/api/chats/:id/fork"],
+    "chats.get": ["GET", "/api/chats/:id"],
+    "chats.list": ["GET", "/api/chats"],
+    "chats.message": ["POST", "/api/chats/:id/message"],
+    "chats.permission": ["POST", "/api/chats/:id/permission"],
+    "chats.rename": ["PATCH", "/api/chats/:id"],
+    "chats.resetSession": ["POST", "/api/chats/:id/reset-session"],
+    "chats.setVibeable": ["POST", "/api/chats/:id/vibeable"],
+    "chats.steer": ["POST", "/api/chats/:id/steer"],
+    "chats.stopTask": ["POST", "/api/chats/:id/task-stop"],
+    "files.delete": ["DELETE", "/api/files"],
+    "files.list": ["GET", "/api/files/list"],
+    "files.mkdir": ["POST", "/api/files/folder"],
+    "files.move": ["POST", "/api/files/move"],
+    "files.raw": ["GET", "/api/files/raw", "raw"],
+    "files.recent": ["GET", "/api/files/recent"],
+    "files.scopes": ["GET", "/api/files"],
+    "files.upload": ["POST", "/api/files/upload", "upload"],
+    "git.commit": ["POST", "/api/git/commit"],
+    "git.diff": ["GET", "/api/git/diff"],
+    "git.fetch": ["POST", "/api/git/fetch"],
+    "git.pull": ["POST", "/api/git/pull"],
+    "git.push": ["POST", "/api/git/push"],
+    "git.status": ["GET", "/api/git"],
+    "knowledge.concept": ["GET", "/api/knowledge/:bundle/concept"],
+    "knowledge.create": ["POST", "/api/knowledge"],
+    "knowledge.delete": ["DELETE", "/api/knowledge/:bundle"],
+    "knowledge.get": ["GET", "/api/knowledge/:bundle"],
+    "knowledge.list": ["GET", "/api/knowledge"],
+    "knowledge.putConcept": ["POST", "/api/knowledge/:bundle/concept"],
+    "knowledge.verify": ["POST", "/api/knowledge/:bundle/verify"],
+    "meta.get": ["GET", "/api/meta"],
+    "notifications.clear": ["DELETE", "/api/notifications"],
+    "notifications.diagnose": ["POST", "/api/notifications/:id/diagnose"],
+    "notifications.list": ["GET", "/api/notifications"],
+    "notifications.read": ["POST", "/api/notifications/read"],
+    "projects.create": ["POST", "/api/projects"],
+    "projects.delete": ["DELETE", "/api/projects/:slug"],
+    "projects.get": ["GET", "/api/projects/:slug"],
+    "projects.link": ["POST", "/api/projects/:slug/links"],
+    "projects.list": ["GET", "/api/projects"],
+    "projects.log": ["POST", "/api/projects/:slug/log"],
+    "projects.save": ["PUT", "/api/projects/:slug"],
+    "projects.saveLayout": ["PUT", "/api/projects"],
+    "protocol.get": ["GET", "/api/protocol"],
+    "repos.add": ["POST", "/api/repos"],
+    "repos.commit": ["GET", "/api/repos/:slug/commits/:hash"],
+    "repos.diff": ["GET", "/api/repos/:slug/diff"],
+    "repos.get": ["GET", "/api/repos/:slug"],
+    "repos.list": ["GET", "/api/repos"],
+    "repos.remove": ["DELETE", "/api/repos/:slug"],
+    "repos.update": ["POST", "/api/repos/:slug/update"],
+    "routines.list": ["GET", "/api/routines"],
+    "runs.decide": ["POST", "/api/runs/:id/decision"],
+    "runs.delete": ["DELETE", "/api/runs/:id"],
+    "runs.file": ["GET", "/api/runs/:id/file", "raw"],
+    "runs.fileText": ["GET", "/api/runs/:id/text"],
+    "runs.get": ["GET", "/api/runs/:id"],
+    "runs.list": ["GET", "/api/runs"],
+    "runs.stop": ["POST", "/api/runs/:id/stop"],
+    "search.agents": ["GET", "/api/search/agents"],
+    "server.restart": ["POST", "/api/restart"],
+    "settings.get": ["GET", "/api/settings"],
+    "settings.save": ["PUT", "/api/settings"],
+    "skills.get": ["GET", "/api/skills/:name"],
+    "skills.list": ["GET", "/api/skills"],
+    "trash.empty": ["DELETE", "/api/trash"],
+    "trash.list": ["GET", "/api/trash"],
+    "trash.purge": ["POST", "/api/trash/purge"],
+    "trash.restore": ["POST", "/api/trash/restore"],
+    "update.check": ["GET", "/api/update-check"],
+    "update.start": ["POST", "/api/update"],
+    "update.status": ["GET", "/api/update"],
+    "vibeables.create": ["POST", "/api/vibeables"],
+    "vibeables.delete": ["DELETE", "/api/vibeables/:slug"],
+    "vibeables.devStart": ["POST", "/api/vibeables/:slug/dev/start"],
+    "vibeables.devStop": ["POST", "/api/vibeables/:slug/dev/stop"],
+    "vibeables.events": ["GET", "/api/vibeables/:slug/events", "raw"],
+    "vibeables.get": ["GET", "/api/vibeables/:slug"],
+    "vibeables.list": ["GET", "/api/vibeables"],
+    "workflows.delete": ["DELETE", "/api/workflows/:slug"],
+    "workflows.get": ["GET", "/api/workflows/:slug"],
+    "workflows.list": ["GET", "/api/workflows"],
+    "workflows.run": ["POST", "/api/workflows/:slug/run"],
+    "workflows.runner": ["GET", "/api/workflows/:slug/run"],
+    "workspaces.forget": ["POST", "/api/workspaces/forget"],
+    "workspaces.list": ["GET", "/api/workspaces"],
+    "workspaces.start": ["POST", "/api/workspaces/start"],
+    "workspaces.stop": ["POST", "/api/workspaces/stop"],
+};

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

@@ -0,0 +1,31 @@
+/** Agents (team members): definition, own skills, journal, routines. */
+export declare const agentRoutes: (import("./router.js").Route<"agents.addJournal", {
+    journal: string;
+}, "/api/agents/:slug/journal"> | import("./router.js").Route<"agents.archive", import("../agents.js").AgentDetail, "/api/agents/:slug/archive"> | import("./router.js").Route<"agents.create", import("../agents.js").AgentDetail, "/api/agents"> | import("./router.js").Route<"agents.delete", {
+    ok: boolean;
+}, "/api/agents/:slug"> | import("./router.js").Route<"agents.deleteRoutine", {
+    ok: boolean;
+}, "/api/agents/:slug/routines/:id"> | import("./router.js").Route<"agents.deleteSkill", {
+    ok: boolean;
+}, "/api/agents/:slug/skills/:name"> | import("./router.js").Route<"agents.get", import("../agents.js").AgentDetail, "/api/agents/:slug"> | import("./router.js").Route<"agents.journal", {
+    journal: string;
+}, "/api/agents/:slug/journal"> | import("./router.js").Route<"agents.list", {
+    root: string;
+    agents: import("../agents.js").Agent[];
+}, "/api/agents"> | import("./router.js").Route<"agents.routines", {
+    routines: import("../routines.js").RoutineStatus[];
+}, "/api/agents/:slug/routines"> | import("./router.js").Route<"agents.runRoutine", {
+    chatId: string;
+}, "/api/agents/:slug/routines/:id/run"> | import("./router.js").Route<"agents.save", import("../agents.js").AgentDetail, "/api/agents/:slug"> | import("./router.js").Route<"agents.saveRoutine", import("../routines.js").Routine, "/api/agents/:slug/routines"> | import("./router.js").Route<"agents.saveSkill", import("../skills.js").SkillInfo & {
+    content: string;
+}, "/api/agents/:slug/skills"> | import("./router.js").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"> | import("./router.js").Route<"agents.skills", {
+    skills: import("../skills.js").SkillInfo[];
+}, "/api/agents/:slug/skills">)[];