@netnodeag/kraftwerk 0.42.1 → 0.44.0

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

@@ -1,4 +1,4 @@
-import type { ChatAgentId, ChatMeta, ChatScope, StoredChatEvent } from "./types.js";
+import type { Attachment, ChatAgentId, ChatMeta, ChatScope, ElicitationAnswer, StoredChatEvent } from "./types.js";
 import { type Channel } from "../channels.js";
 /** Server shutdown: no agent subprocess may outlive the inspector. */
 export declare function disposeAllBackends(): void;
@@ -21,6 +21,8 @@ export declare function createChat(opts: {
     scope: ChatScope;
     /** Preset title (e.g. routine runs); otherwise the first message names the chat. */
     title?: string;
+    /** Continue one of the agent's own sessions (from listAgentSessionsFor) instead of starting fresh. */
+    resume?: string;
 }): Promise<ChatMeta>;
 /** A permission request is waiting for a human in this chat (live state only — a restart drops it with the backend). */
 export declare function chatAwaitingApproval(id: string): boolean;
@@ -35,6 +37,7 @@ export declare function getChat(id: string): Promise<{
 } | null>;
 export declare function postMessage(id: string, text: string, opts?: {
     from?: string;
+    attachments?: Attachment[];
 }): Promise<{
     error?: string;
 }>;
@@ -62,6 +65,55 @@ export declare function setChatVibeable(id: string, slug: string | null): Promis
     status?: number;
     meta?: ChatMeta;
 }>;
+/**
+ * Fork a chat: a new chat with the same transcript whose agent continues
+ * from a copy of this session (session/fork) — try something without
+ * losing the original thread. Needs a session to fork: an agent that keeps
+ * one (claude, codex — pi has no ACP session) that has answered at least
+ * once. The source's process is (re)spawned if needed; the fork's own
+ * process starts with its first message and resumes the forked id.
+ */
+export declare function forkChat(id: string): Promise<{
+    error?: string;
+    status?: number;
+    meta?: ChatMeta;
+}>;
+/**
+ * Start over with the agent: drop the process and the stored session id so
+ * the next message opens a fresh session (the transcript stays, and goes
+ * back in as context). The way out of a session the harness reports as
+ * unusable — a "new_session" failure action.
+ */
+export declare function resetSession(id: string): Promise<{
+    error?: string;
+    status?: number;
+    meta?: ChatMeta;
+}>;
+export declare function answerElicitation(id: string, requestId: string, answer: ElicitationAnswer): Promise<{
+    error?: string;
+}>;
+/**
+ * Steer: hand a message into the agent's running turn instead of waiting
+ * for it to end. Shown in the thread like any message. When no turn is
+ * running (or the agent cannot take steering) it goes the ordinary way.
+ */
+export declare function steerChat(id: string, text: string, attachments?: Attachment[]): Promise<{
+    error?: string;
+}>;
+export declare function stopChatTask(id: string, taskId: string): Promise<{
+    error?: string;
+}>;
+/** Change a session setting (model, thinking depth, ...) on the chat's live agent. */
+export declare function setChatConfig(id: string, configId: string, value: string | boolean): Promise<{
+    error?: string;
+}>;
+/** The agent's own sessions in the project root (Claude Code / Codex transcripts), to continue one as a chat. */
+export declare function listAgentSessionsFor(agent: ChatAgentId): Promise<Array<{
+    sessionId: string;
+    title?: string;
+    updatedAt?: string;
+    cwd: string;
+}>>;
 export declare function resolvePermission(id: string, requestId: string, optionId: string | null): Promise<{
     error?: string;
 }>;
@@ -69,7 +121,13 @@ export declare function resolvePermission(id: string, requestId: string, optionI
 export declare function deleteChat(id: string): Promise<{
     error?: string;
 }>;
-export declare function cancelChat(id: string): Promise<{
+/**
+ * Interrupt the agent's turn — in a channel, one agent's (`agent` = its
+ * slug) or every agent's. Whatever the agent was waiting on from a human
+ * is dismissed, and an agent queued to run again when its turn ends is
+ * not woken after all.
+ */
+export declare function cancelChat(id: string, agent?: string): Promise<{
     error?: string;
 }>;
 /**

package/dist/inspector/chat/sessions.js

@@ -8,12 +8,12 @@ import { listWorkflows } from "../workflows.js";
 import { getAgent, listAgents } from "../agents.js";
 import { listRepos } from "../repos.js";
 import { resolveVibeable, vibeableStatus, VIBEABLE_CONFIG_FILE } from "../vibeables.js";
-import { startAcpBackend } from "./acp.js";
+import { deleteAgentSession, listAgentSessions, startAcpBackend } from "./acp.js";
 import { startPiBackend } from "./pi.js";
 import { UNATTENDED_PERMISSION_TIMEOUT_MS, declineOption, unattendedTimeoutLabel } from "./permissions.js";
 import { chatHref, dismissKey, pushNotification } from "../notifications.js";
 import { getChannel, mentionTargets } from "../channels.js";
-import { appendEvent, listChatMetas, newChatId, readEvents, readMeta, safeChatDir, writeMeta, } from "./store.js";
+import { appendEvent, attachmentPath, copyChatFiles, listChatMetas, newChatId, readEvents, readMeta, safeChatDir, writeMeta, } from "./store.js";
 const MAIN = "main";
 const states = new Map();
 const newSeat = (key, harness) => ({
@@ -78,6 +78,14 @@ function dropSeat(seat) {
     seat.backend?.dispose();
     seat.backend = null;
 }
+/** A turn failed: a resumed session that never took a prompt is gone for good — stop resuming it. */
+function forgetFailedResume(state, seat) {
+    if (!seat.backend?.resumeFailed || !state.meta.sessions?.[seat.key])
+        return;
+    const { [seat.key]: _gone, ...rest } = state.meta.sessions;
+    state.meta.sessions = rest;
+    emit(state, { type: "error", message: "the previous session could not be continued — the next message starts a fresh one" }, seatAuthor(seat));
+}
 /** Kill a chat's agent subprocess(es); the next message spawns fresh ones. */
 function dropBackend(state) {
     for (const seat of state.seats.values())
@@ -118,10 +126,75 @@ async function loadState(id) {
         subscribers: new Set(),
         seats: new Map(),
         pendingPermissions: new Map(),
+        pendingElicitations: new Map(),
+        pendingSeat: new Map(),
         writeChain: Promise.resolve(),
     };
     // Two racing loads: keep whichever registered first.
-    return states.get(id) ?? (states.set(id, state), state);
+    const registered = states.get(id) ?? (states.set(id, state), state);
+    if (registered === state)
+        closeInterruptedWork(state);
+    return registered;
+}
+/**
+ * A chat loaded from disk has no live process: whatever the transcript
+ * still shows as in flight died with the previous inspector (restart,
+ * relaunch after an update, crash). Left alone, the UI keeps rendering a
+ * permission card nobody can answer any more and a "working" lamp that
+ * never goes out. Close those out once, in the transcript itself, so
+ * every reader sees the same settled thread: dropped permission requests
+ * resolve to "dismissed", open turns end with an error that says why.
+ */
+function closeInterruptedWork(state) {
+    const pending = new Map();
+    const asked = new Map();
+    const open = new Map();
+    const key = (a) => (a?.kind === "agent" ? `agent:${a.slug}` : "main");
+    for (const e of state.events) {
+        switch (e.type) {
+            case "permission_request":
+                pending.set(e.requestId, e.from);
+                break;
+            case "permission_resolved":
+                pending.delete(e.requestId);
+                break;
+            case "elicitation_request":
+                asked.set(e.requestId, e.from);
+                break;
+            case "elicitation_resolved":
+                asked.delete(e.requestId);
+                break;
+            // Channels: a turn is bracketed by turn_start/turn_end per agent.
+            // Ordinary chats never emit turn_start: the user's message opens the
+            // turn, turn_end/error closes it.
+            case "user_message":
+                if (state.meta.scope.kind !== "channel")
+                    open.set("main", undefined);
+                break;
+            case "turn_start":
+                open.set(key(e.from), e.from);
+                break;
+            case "turn_end":
+            case "error":
+                open.delete(key(e.from));
+                break;
+        }
+    }
+    for (const [requestId, from] of pending) {
+        emit(state, { type: "permission_resolved", requestId, optionId: null }, from);
+        void dismissKey(`approval:${state.meta.id}:${requestId}`);
+    }
+    for (const [requestId, from] of asked) {
+        emit(state, { type: "elicitation_resolved", requestId, action: "cancel" }, from);
+        void dismissKey(`question:${state.meta.id}:${requestId}`);
+    }
+    for (const from of open.values()) {
+        const who = from?.kind === "agent" ? `@${from.slug}` : "the agent";
+        const how = state.meta.scope.kind === "channel" ? `mention ${who} again` : "send another message";
+        emit(state, { type: "error", message: `${who} was interrupted by an inspector restart — ${how} to continue` }, from);
+    }
+    if (pending.size || asked.size || open.size)
+        void writeMeta(state.meta).catch(() => { });
 }
 function emit(state, ev, from) {
     const stored = {
@@ -489,6 +562,10 @@ async function backendTuning(meta, seat) {
     // Routine runs: never a harness mode that skips asking (see unattendedMode in permissions.ts).
     if (isUnattended(scope))
         tuning.unattended = true;
+    // A seat that had a session before (restart, idle reaper) continues it.
+    const previous = meta.sessions?.[seat.key];
+    if (previous && agent !== "pi")
+        tuning.resume = previous;
     // pi loads skills only when told: hand it every visible skill folder.
     if (agent === "pi") {
         const skills = await availableSkills(scope);
@@ -514,10 +591,12 @@ async function ensureBackend(state, seat) {
                 const requestId = randomUUID();
                 const notifyKey = `approval:${state.meta.id}:${requestId}`;
                 let deadline;
+                state.pendingSeat.set(requestId, seat.key);
                 state.pendingPermissions.set(requestId, (optionId) => {
                     if (deadline)
                         clearTimeout(deadline);
                     state.pendingPermissions.delete(requestId);
+                    state.pendingSeat.delete(requestId);
                     emit(state, { type: "permission_resolved", requestId, optionId }, me);
                     void dismissKey(notifyKey);
                     resolve(optionId);
@@ -546,6 +625,48 @@ async function ensureBackend(state, seat) {
                 }
             });
         },
+        askElicitation: (message, fields) => {
+            // The agent wants to know something before it goes on. Same contract
+            // as permissions: the question waits in the thread for a human; an
+            // unattended session gets a deadline after which the question is
+            // declined (the agent is told the user skipped it), never answered.
+            return new Promise((resolve) => {
+                const requestId = randomUUID();
+                const notifyKey = `question:${state.meta.id}:${requestId}`;
+                let deadline;
+                state.pendingSeat.set(requestId, seat.key);
+                state.pendingElicitations.set(requestId, (answer) => {
+                    if (deadline)
+                        clearTimeout(deadline);
+                    state.pendingElicitations.delete(requestId);
+                    state.pendingSeat.delete(requestId);
+                    emit(state, { type: "elicitation_resolved", requestId, ...answer }, me);
+                    void dismissKey(notifyKey);
+                    resolve(answer);
+                });
+                emit(state, { type: "elicitation_request", requestId, message, fields }, me);
+                void pushNotification({
+                    kind: "approval",
+                    key: notifyKey,
+                    title: `${chatLabel(state.meta)}${me?.kind === "agent" ? ` · @${me.slug}` : ""} has a question`,
+                    body: message,
+                    href: chatHref(state.meta),
+                });
+                if (isUnattended(state.meta.scope)) {
+                    deadline = setTimeout(() => {
+                        const pending = state.pendingElicitations.get(requestId);
+                        if (!pending)
+                            return;
+                        emit(state, {
+                            type: "error",
+                            message: `nobody answered the agent's question within ${unattendedTimeoutLabel()} — skipped (unattended routine session)`,
+                        });
+                        pending({ action: "decline" });
+                    }, UNATTENDED_PERMISSION_TIMEOUT_MS);
+                    deadline.unref?.();
+                }
+            });
+        },
     };
     const agent = seat.harness;
     const cwd = await effectiveCwd(state.meta);
@@ -554,9 +675,14 @@ async function ensureBackend(state, seat) {
         agent === "pi"
             ? startPiBackend(cwd, hooks, tuning)
             : await startAcpBackend(agent, cwd, hooks, tuning);
-    // Fresh process = fresh context window: re-send scope context with the
-    // next prompt (matters for chats resumed after an inspector restart).
-    seat.needsContext = true;
+    if (seat.backend.sessionId) {
+        state.meta.sessions = { ...state.meta.sessions, [seat.key]: seat.backend.sessionId };
+        void writeMeta(state.meta).catch(() => { });
+    }
+    // A resumed session still has the conversation (and the scope context)
+    // in its window. A fresh process is a fresh context window: re-send the
+    // scope context with the next prompt.
+    seat.needsContext = !seat.backend.resumed;
     return seat.backend;
 }
 /* ---------- public API (used by server.ts) ---------- */
@@ -583,6 +709,7 @@ export async function createChat(opts) {
         title: opts.title ?? "",
         cwd,
         scope: opts.scope,
+        ...(opts.resume && opts.agent !== "pi" ? { sessions: { [MAIN]: opts.resume } } : {}),
         createdAt: now,
         updatedAt: now,
     };
@@ -593,6 +720,8 @@ export async function createChat(opts) {
         subscribers: new Set(),
         seats: new Map(),
         pendingPermissions: new Map(),
+        pendingElicitations: new Map(),
+        pendingSeat: new Map(),
         writeChain: Promise.resolve(),
     });
     return meta;
@@ -615,12 +744,15 @@ export async function getChat(id) {
         return null;
     return { meta: state.meta, events: state.events, busy: isBusy(state) };
 }
+/** Attachments as the backend gets them: with their path on disk. */
+const promptFiles = (id, attachments = []) => attachments.map((a) => ({ ...a, path: attachmentPath(id, a.name) }));
 export async function postMessage(id, text, opts = {}) {
     const state = await loadState(id);
     if (!state)
         return { error: "not found" };
+    const attachments = opts.attachments?.length ? opts.attachments : undefined;
     if (state.meta.scope.kind === "channel")
-        return postChannelMessage(state, state.meta.scope.slug, text, opts.from);
+        return postChannelMessage(state, state.meta.scope.slug, text, opts.from, attachments);
     const seat = mainSeat(state);
     if (seat.busy)
         return { error: "agent is still working — wait for the turn to finish" };
@@ -630,7 +762,7 @@ export async function postMessage(id, text, opts = {}) {
         state.meta.title = text.replace(/\s+/g, " ").trim().slice(0, 80);
         void writeMeta(state.meta).catch(() => { });
     }
-    const turnStart = emit(state, { type: "user_message", text }).seq;
+    const turnStart = emit(state, { type: "user_message", text, ...(attachments ? { attachments } : {}) }).seq;
     // The turn runs in the background; the HTTP request returns immediately
     // and the browser follows along on the SSE stream.
     void (async () => {
@@ -642,7 +774,7 @@ export async function postMessage(id, text, opts = {}) {
             // the thread keeps the short form the user typed.
             const body = await expandSkillInvocation(state.meta.scope, text);
             const promptText = context ? `<context>\n${context}\n</context>\n\n${body}` : body;
-            const stopReason = await backend.prompt(promptText);
+            const stopReason = await backend.prompt(promptText, promptFiles(id, attachments));
             emit(state, { type: "turn_end", stopReason });
             // Routine sessions are one-shot and unattended: release the agent
             // process as soon as the turn ends instead of waiting for the reaper,
@@ -672,6 +804,7 @@ export async function postMessage(id, text, opts = {}) {
             }
             // A failed turn may mean a dead subprocess; drop it so the next
             // message spawns a fresh agent (thread history stays on disk).
+            forgetFailedResume(state, seat);
             dropBackend(state);
         }
         finally {
@@ -688,12 +821,12 @@ export async function postMessage(id, text, opts = {}) {
  * parallel, never blocking the humans, who can keep posting. An agent that
  * is still busy is woken again when its turn ends, so nothing is lost.
  */
-async function postChannelMessage(state, slug, text, from) {
+async function postChannelMessage(state, slug, text, from, attachments) {
     const channel = await getChannel(slug).catch(() => null);
     if (!channel)
         return { error: `channel "${slug}" has no definition under channels/` };
     const name = (from ?? "").replace(/\s+/g, " ").trim().slice(0, 40) || "you";
-    emit(state, { type: "user_message", text }, { kind: "human", name });
+    emit(state, { type: "user_message", text, ...(attachments ? { attachments } : {}) }, { kind: "human", name });
     void writeMeta(state.meta).catch(() => { });
     for (const target of mentionTargets(text, channel))
         void wakeSeat(state, channel, target, 0);
@@ -735,7 +868,8 @@ function transcriptSince(state, afterSeq, beforeSeq, self) {
             continue;
         if (e.type === "user_message") {
             flush();
-            lines.push(`[${e.from?.kind === "human" ? e.from.name : "human"}]: ${e.text}`);
+            const files = e.attachments?.length ? `\n(attached: ${e.attachments.map((a) => attachmentPath(state.meta.id, a.name)).join(", ")})` : "";
+            lines.push(`[${e.from?.kind === "human" ? e.from.name : "human"}]: ${e.text}${files}`);
         }
         else if (e.type === "text" && e.from?.kind === "agent" && e.from.slug !== self) {
             if (open && open.slug !== e.from.slug)
@@ -791,6 +925,7 @@ async function runSeatTurn(state, channel, seat, hops) {
     }
     catch (err) {
         emit(state, { type: "error", message: err.message }, me);
+        forgetFailedResume(state, seat);
         dropSeat(seat);
     }
     finally {
@@ -834,6 +969,10 @@ export async function convertChatToChannel(chatId, channel) {
     seat.needsContext = true;
     seat.seenSeq = state.events[state.events.length - 1]?.seq ?? 0;
     state.seats.set(scope.slug, seat);
+    if (state.meta.sessions?.[MAIN]) {
+        const { [MAIN]: session, ...rest } = state.meta.sessions;
+        state.meta.sessions = { ...rest, [scope.slug]: session };
+    }
     state.meta.scope = { kind: "channel", slug: channel.slug };
     state.meta.title = channel.name;
     state.meta.updatedAt = new Date().toISOString();
@@ -890,11 +1029,155 @@ export async function setChatVibeable(id, slug) {
     }
     state.meta.updatedAt = new Date().toISOString();
     dropBackend(state);
+    // The agent's session belongs to the old folder: start over there.
+    delete state.meta.sessions;
     for (const seat of state.seats.values())
         seat.needsContext = true;
     await writeMeta(state.meta);
     return { meta: state.meta };
 }
+/**
+ * Fork a chat: a new chat with the same transcript whose agent continues
+ * from a copy of this session (session/fork) — try something without
+ * losing the original thread. Needs a session to fork: an agent that keeps
+ * one (claude, codex — pi has no ACP session) that has answered at least
+ * once. The source's process is (re)spawned if needed; the fork's own
+ * process starts with its first message and resumes the forked id.
+ */
+export async function forkChat(id) {
+    const state = await loadState(id);
+    if (!state)
+        return { error: "not found", status: 404 };
+    const { meta } = state;
+    if (meta.scope.kind === "channel")
+        return { error: "a channel cannot be forked", status: 409 };
+    if (meta.agent === "pi")
+        return { error: "pi chats have no session to fork", status: 409 };
+    if (meta.agent === "codex")
+        return { error: "fork is not supported by codex", status: 409 };
+    if (!meta.sessions?.[MAIN])
+        return { error: "nothing to fork yet — the agent has not answered in this chat", status: 409 };
+    if (isBusy(state))
+        return { error: "agent is still working — wait for the turn to finish", status: 409 };
+    const seat = mainSeat(state);
+    let forked;
+    try {
+        const backend = await ensureBackend(state, seat);
+        if (!backend.fork)
+            return { error: `${meta.agent} cannot fork sessions`, status: 409 };
+        forked = await backend.fork();
+    }
+    catch (err) {
+        return { error: err.message, status: 409 };
+    }
+    const now = new Date().toISOString();
+    const copy = {
+        ...meta,
+        id: newChatId(),
+        title: meta.title ? `${meta.title} (fork)` : "",
+        sessions: { [MAIN]: forked },
+        createdAt: now,
+        updatedAt: now,
+    };
+    await writeMeta(copy);
+    await copyChatFiles(meta.id, copy.id);
+    return { meta: copy };
+}
+/**
+ * Start over with the agent: drop the process and the stored session id so
+ * the next message opens a fresh session (the transcript stays, and goes
+ * back in as context). The way out of a session the harness reports as
+ * unusable — a "new_session" failure action.
+ */
+export async function resetSession(id) {
+    const state = await loadState(id);
+    if (!state)
+        return { error: "not found", status: 404 };
+    if (isBusy(state))
+        return { error: "agent is still working — wait for the turn to finish", status: 409 };
+    dropBackend(state);
+    delete state.meta.sessions;
+    for (const seat of state.seats.values())
+        seat.needsContext = true;
+    state.meta.updatedAt = new Date().toISOString();
+    await writeMeta(state.meta);
+    emit(state, { type: "error", message: "session reset — the next message starts a fresh one, with the conversation so far as context" });
+    return { meta: state.meta };
+}
+export async function answerElicitation(id, requestId, answer) {
+    const state = await loadState(id);
+    if (!state)
+        return { error: "not found" };
+    const resolve = state.pendingElicitations.get(requestId);
+    if (!resolve)
+        return { error: "no such pending question" };
+    resolve(answer);
+    return {};
+}
+/**
+ * Steer: hand a message into the agent's running turn instead of waiting
+ * for it to end. Shown in the thread like any message. When no turn is
+ * running (or the agent cannot take steering) it goes the ordinary way.
+ */
+export async function steerChat(id, text, attachments) {
+    const state = await loadState(id);
+    if (!state)
+        return { error: "not found" };
+    if (state.meta.scope.kind === "channel")
+        return { error: "channels take messages, not steering — @mention the agent" };
+    const seat = mainSeat(state);
+    const files = attachments?.length ? attachments : undefined;
+    if (!seat.busy || !seat.backend?.steer)
+        return postMessage(id, text, { attachments: files });
+    try {
+        const outcome = await seat.backend.steer(text, promptFiles(id, files));
+        if (outcome === "promptRequired")
+            return postMessage(id, text, { attachments: files });
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+    emit(state, { type: "user_message", text, steered: true, ...(files ? { attachments: files } : {}) });
+    void writeMeta(state.meta).catch(() => { });
+    return {};
+}
+export async function stopChatTask(id, taskId) {
+    const state = await loadState(id);
+    if (!state)
+        return { error: "not found" };
+    const backend = [...state.seats.values()].find((s) => s.backend?.stopTask)?.backend;
+    if (!backend?.stopTask)
+        return { error: "no running agent to stop the task on" };
+    try {
+        await backend.stopTask(taskId);
+        return {};
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+}
+/** Change a session setting (model, thinking depth, ...) on the chat's live agent. */
+export async function setChatConfig(id, configId, value) {
+    const state = await loadState(id);
+    if (!state)
+        return { error: "not found" };
+    const backend = mainSeat(state).backend;
+    if (!backend?.setConfig)
+        return { error: "the agent is not running — send a message first, the settings appear once it is up" };
+    try {
+        await backend.setConfig(configId, value);
+        return {};
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+}
+/** The agent's own sessions in the project root (Claude Code / Codex transcripts), to continue one as a chat. */
+export async function listAgentSessionsFor(agent) {
+    if (agent === "pi")
+        return [];
+    return listAgentSessions(agent, getProjectRoot());
+}
 export async function resolvePermission(id, requestId, optionId) {
     const state = await loadState(id);
     if (!state)
@@ -912,19 +1195,46 @@ export async function deleteChat(id) {
         return { error: "not found" };
     for (const resolve of state.pendingPermissions.values())
         resolve(null);
+    for (const resolve of state.pendingElicitations.values())
+        resolve({ action: "cancel" });
     dropBackend(state);
     states.delete(id);
     await fs.rm(safeChatDir(id), { recursive: true, force: true });
+    // The agent's own transcripts go with the chat (best effort, in the background).
+    const cwd = await effectiveCwd(state.meta);
+    for (const [seatKey, sessionId] of Object.entries(state.meta.sessions ?? {})) {
+        void (async () => {
+            const harness = seatKey === MAIN ? state.meta.agent : (await getAgent(seatKey).catch(() => null))?.harness;
+            if (harness && harness !== "pi")
+                await deleteAgentSession(harness, cwd, sessionId);
+        })().catch(() => { });
+    }
     return {};
 }
-export async function cancelChat(id) {
+/**
+ * Interrupt the agent's turn — in a channel, one agent's (`agent` = its
+ * slug) or every agent's. Whatever the agent was waiting on from a human
+ * is dismissed, and an agent queued to run again when its turn ends is
+ * not woken after all.
+ */
+export async function cancelChat(id, agent) {
     const state = await loadState(id);
     if (!state)
         return { error: "not found" };
-    for (const resolve of state.pendingPermissions.values())
-        resolve(null);
-    for (const seat of state.seats.values())
+    const seats = agent ? [state.seats.get(agent)].filter((s) => !!s) : [...state.seats.values()];
+    if (agent && seats.length === 0)
+        return { error: `@${agent} is not running in this chat` };
+    const mine = (requestId) => !agent || state.pendingSeat.get(requestId) === agent;
+    for (const [requestId, resolve] of state.pendingPermissions)
+        if (mine(requestId))
+            resolve(null);
+    for (const [requestId, resolve] of state.pendingElicitations)
+        if (mine(requestId))
+            resolve({ action: "cancel" });
+    for (const seat of seats) {
+        seat.wake = null;
         seat.backend?.cancel();
+    }
     return {};
 }
 /**

package/dist/inspector/chat/store.d.ts

@@ -3,6 +3,18 @@ export declare function safeChatDir(id: string): string;
 export declare function newChatId(): string;
 export declare function writeMeta(meta: ChatMeta): Promise<void>;
 export declare function readMeta(id: string): Promise<ChatMeta | null>;
+/** Where a chat keeps the files dropped into it. */
+export declare function attachmentsDir(id: string): string;
+/** A stored attachment's path; rejects names that could leave the folder. */
+export declare function attachmentPath(id: string, name: string): string;
+/** Store one uploaded file under the chat; returns the (deduplicated, sanitized) name it got. */
+export declare function saveAttachment(id: string, originalName: string, data: Buffer): Promise<string>;
+/**
+ * Copy one chat's transcript and attachments into another (a fork): the
+ * events as they are, the files so the copy never points at a chat that
+ * may be deleted. The target's meta.json must already exist.
+ */
+export declare function copyChatFiles(fromId: string, toId: string): Promise<void>;
 export declare function appendEvent(id: string, ev: StoredChatEvent): Promise<void>;
 export declare function readEvents(id: string): Promise<StoredChatEvent[]>;
 export declare function listChatMetas(): Promise<ChatMeta[]>;

package/dist/inspector/chat/store.js

@@ -44,6 +44,52 @@ function upgradeMeta(meta) {
     }
     return meta;
 }
+/** Where a chat keeps the files dropped into it. */
+export function attachmentsDir(id) {
+    return path.join(safeChatDir(id), "attachments");
+}
+const SAFE_NAME = /^[A-Za-z0-9._-]{1,120}$/;
+/** A stored attachment's path; rejects names that could leave the folder. */
+export function attachmentPath(id, name) {
+    if (!SAFE_NAME.test(name) || name.startsWith("."))
+        throw new Error("invalid attachment name");
+    return path.join(attachmentsDir(id), name);
+}
+/** Store one uploaded file under the chat; returns the (deduplicated, sanitized) name it got. */
+export async function saveAttachment(id, originalName, data) {
+    const dir = attachmentsDir(id);
+    await fs.mkdir(dir, { recursive: true });
+    const base = (originalName || "file").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "").slice(0, 80) || "file";
+    const ext = path.extname(base);
+    const stem = base.slice(0, base.length - ext.length) || "file";
+    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "").replace("T", "-");
+    let name = `${stamp}-${stem}${ext}`;
+    for (let n = 2;; n++) {
+        try {
+            await fs.writeFile(path.join(dir, name), data, { flag: "wx" });
+            return name;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            name = `${stamp}-${stem}-${n}${ext}`;
+        }
+    }
+}
+/**
+ * Copy one chat's transcript and attachments into another (a fork): the
+ * events as they are, the files so the copy never points at a chat that
+ * may be deleted. The target's meta.json must already exist.
+ */
+export async function copyChatFiles(fromId, toId) {
+    const events = await readEvents(fromId);
+    if (events.length)
+        await fs.writeFile(path.join(safeChatDir(toId), "events.jsonl"), events.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    await fs.cp(attachmentsDir(fromId), attachmentsDir(toId), { recursive: true }).catch((err) => {
+        if (err.code !== "ENOENT")
+            throw err;
+    });
+}
 export async function appendEvent(id, ev) {
     await fs.appendFile(path.join(safeChatDir(id), "events.jsonl"), JSON.stringify(ev) + "\n");
 }