@turri-dev/cli 0.1.17-next.1ecfd4f → 0.1.17

package/dist/ask.d.ts

@@ -46,6 +46,8 @@ export declare const DONE_OPTION = "Done \u2014 that's all of them";
 export declare const TICKED = "\u2611";
 export declare const UNTICKED = "\u2610";
 export declare const DISMISSED = "The user dismissed the question without answering.";
+/** ctrl+c at a question: the person would not answer it - or stopped the turn that asked it. */
+export declare const DECLINED = "The user declined to answer the question.";
 /** How an answer that is no answer starts: the person chose to talk about the question first. */
 export declare const CHAT_PREFIX = "The user has not answered this question yet: they chose to talk about it first.";
 /** What comes back when the person chose "Chat about this": what they said, and what they had picked so far. */

package/dist/ask.js

@@ -13,6 +13,8 @@ export const DONE_OPTION = "Done — that's all of them";
 export const TICKED = "☑";
 export const UNTICKED = "☐";
 export const DISMISSED = "The user dismissed the question without answering.";
+/** ctrl+c at a question: the person would not answer it - or stopped the turn that asked it. */
+export const DECLINED = "The user declined to answer the question.";
 /** How an answer that is no answer starts: the person chose to talk about the question first. */
 export const CHAT_PREFIX = "The user has not answered this question yet: they chose to talk about it first.";
 /** What comes back when the person chose "Chat about this": what they said, and what they had picked so far. */

package/dist/chat-terminal.d.ts

@@ -1,5 +1,23 @@
 import type { RunRecord } from "./chat-records.ts";
-import { type TurriCore } from "./chats.ts";
+import { type Stoppable, type TurriCore } from "./chats.ts";
+/** What ctrl+c reaches of pi's screen: the chat shown, its editor, and leaving. */
+export interface CtrlCScreen {
+    session: Stoppable;
+    editor: {
+        getText(): string;
+    };
+    clearEditor(): void;
+    /** Its queued messages back in the editor - and, with `abort`, the turn stopped: pi's own esc. */
+    restoreQueuedMessagesToEditor(options?: {
+        abort?: boolean;
+    }): number;
+    shutdown(): Promise<void>;
+}
+/**
+ * ctrl+c, in the chat shown: what it is doing stopped, the other chats left as they are (`interruptChat`). In a chat
+ * doing nothing it clears a draft in the editor, and with none leaves turri, every chat with it.
+ */
+export declare function pressCtrlC(screen: CtrlCScreen, lastStop: number, now?: number): "stopped" | "ignored" | "cleared" | "left";
 export declare function driveTerminal(core: TurriCore, options?: {
     restore?: RunRecord;
 }): void;

package/dist/chat-terminal.js

@@ -1,5 +1,24 @@
 import { AgentSessionRuntime, InteractiveMode, SessionManager } from "@earendil-works/pi-coding-agent";
-import { terminalUi } from "./chats.js";
+import { interruptChat, terminalUi } from "./chats.js";
+/**
+ * ctrl+c, in the chat shown: what it is doing stopped, the other chats left as they are (`interruptChat`). In a chat
+ * doing nothing it clears a draft in the editor, and with none leaves turri, every chat with it.
+ */
+export function pressCtrlC(screen, lastStop, now = Date.now()) {
+    return interruptChat(screen.session, {
+        lastStop,
+        now,
+        stopTurn: () => void screen.restoreQueuedMessagesToEditor({ abort: true }),
+        idle: () => {
+            if (screen.editor.getText().trim() !== "") {
+                screen.clearEditor();
+                return "cleared";
+            }
+            void screen.shutdown();
+            return "left";
+        },
+    });
+}
 export function driveTerminal(core, options = {}) {
     let screen;
     let runtime;
@@ -54,6 +73,14 @@ export function driveTerminal(core, options = {}) {
             return { cancelled: true };
         }
     };
+    // ctrl+c: pi's clears the editor and leaves on a second press; here it stops what the chat shown is doing, and leaves
+    // when it is doing nothing.
+    let lastStop = 0;
+    prototype.handleCtrlC = function () {
+        const did = pressCtrlC(this, lastStop);
+        if (did === "stopped")
+            lastStop = Date.now();
+    };
     // /new: a fresh chat beside the others.
     const newSession = runtimes.newSession;
     runtimes.newSession = function (asked) {

package/dist/chats.d.ts

@@ -166,6 +166,22 @@ export interface CoreOptions {
     /** The host's dialogs, a chat's own. */
     dialogs?: (chat: string) => AskUserIO | undefined;
 }
+/** A chat's session, as stopping what it does reaches it. */
+export type Stoppable = Pick<AgentSession, "isStreaming" | "isCompacting" | "isRetrying" | "isBashRunning" | "abort" | "abortBash">;
+/** A second interrupt this soon after one that stopped something stops nothing more and ends nothing: one pressed twice to be sure. */
+export declare const INTERRUPT_SETTLE_MS = 500;
+/**
+ * ctrl+c in a chat, the terminal's or a host's: what the chat is doing stopped - its turn, a skill or a tool in it, a
+ * `!` command, a compaction, a retry - and nothing in the other chats. `stopTurn` ends its turn: pi's own esc in the
+ * terminal. A chat doing nothing gets `idle`'s answer - the session ended - unless the last interrupt, at `lastStop`,
+ * stopped something a moment ago: then it is `ignored`.
+ */
+export declare function interruptChat<R>(session: Stoppable, asked: {
+    lastStop: number;
+    now?: number;
+    stopTurn?: () => void;
+    idle: () => R;
+}): "stopped" | "ignored" | R;
 export declare function createChats(options: CoreOptions): TurriCore;
 /**
  * pi's extension API for a chat: every tool, command, shortcut and handler the extension registers runs inside the

package/dist/chats.js

@@ -24,6 +24,28 @@ import { record } from "./regenerate/ledger.js";
 export const MAX_CHATS = 9;
 /** What a chat is called until something is said in it. */
 export const NEW_CHAT_TITLE = "new chat";
+/** A second interrupt this soon after one that stopped something stops nothing more and ends nothing: one pressed twice to be sure. */
+export const INTERRUPT_SETTLE_MS = 500;
+/**
+ * ctrl+c in a chat, the terminal's or a host's: what the chat is doing stopped - its turn, a skill or a tool in it, a
+ * `!` command, a compaction, a retry - and nothing in the other chats. `stopTurn` ends its turn: pi's own esc in the
+ * terminal. A chat doing nothing gets `idle`'s answer - the session ended - unless the last interrupt, at `lastStop`,
+ * stopped something a moment ago: then it is `ignored`.
+ */
+export function interruptChat(session, asked) {
+    if (session.isBashRunning || session.isStreaming || session.isCompacting || session.isRetrying) {
+        if (session.isBashRunning)
+            session.abortBash();
+        if (session.isStreaming)
+            (asked.stopTurn ?? (() => void session.abort()))();
+        else if (session.isCompacting || session.isRetrying)
+            void session.abort();
+        return "stopped";
+    }
+    if ((asked.now ?? Date.now()) - asked.lastStop < INTERRUPT_SETTLE_MS)
+        return "ignored";
+    return asked.idle();
+}
 /** A chat's title from what it says: its name, else its first message, short. */
 function titleOf(session) {
     if (session === undefined)

package/dist/extension.js

@@ -44,7 +44,7 @@ import { createJobsTreeState, selectJob } from "./regenerate/jobs-tree.js";
 import { describeDiagnosis, diagnoseFailure } from "./regenerate/diagnose.js";
 import { HISTORY_DIR, historyLog, historyShow } from "./regenerate/lineage.js";
 import { defaultBuildDir } from "./regenerate/paths.js";
-import { describeTurnIncident, describeUsage, onModelEvent } from "./regenerate/activity.js";
+import { describeTurnIncident, describeUsage, JobStoppedError, onModelEvent } from "./regenerate/activity.js";
 import { ledgerWanted, startLedger } from "./regenerate/ledger.js";
 import { describePastPulse, describeRuns, earlierPulses, ledgerProjects } from "./regenerate/ledger-view.js";
 import { doctorTool } from "./doctor-tool.js";
@@ -55,7 +55,7 @@ import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./qui
 import { loadRules, renderRulesBlock } from "./rules.js";
 import { registerTurriConfig } from "./config-command.js";
 import { describeStdlib } from "./stdlib.js";
-import { peekKeyListener, runAsk } from "./ask.js";
+import { DECLINED, peekKeyListener, runAsk } from "./ask.js";
 import { QuestionDialog } from "./question-dialog.js";
 import { registerStacks } from "./stacks.js";
 import { catalogueLine, chosenCommand, createCommandGate, startPicked, discoverSkills, leftOutNote, startedByCommandOnly } from "./skills.js";
@@ -92,57 +92,81 @@ aside,
 /** A host's own dialogs (TurriHost.dialogs), the question put in them instead of the terminal's. */
 dialogs) {
     return async (request) => {
-        if (dialogs !== undefined) {
-            const asking = (asked) => runAsk(asked, dialogs);
-            const bare = { ...request, said: undefined };
-            const answer = aside !== undefined ? await askWithAsides(bare, asking, aside) : await asking(bare);
-            onExchange(request.question, answer, [request.context, request.said].map((part) => part?.trim() ?? "").filter((part) => part !== "").join("\n\n") || undefined);
-            return answer;
-        }
-        if (!ctx.hasUI) {
+        if (dialogs === undefined && !ctx.hasUI) {
             return "No user is available to answer. Decide yourself, and say in your report what you assumed.";
         }
-        ctx.ui.setWorkingMessage("waiting for your answer");
+        // Declined - ctrl+c at it, or the turn that asked it stopped: the dialog open is closed, no other is opened, and it
+        // comes back as DECLINED.
+        const turn = ctx.signal;
+        const declining = { declined: turn?.aborted === true, close: undefined };
+        const decline = () => {
+            declining.declined = true;
+            declining.close?.();
+        };
+        turn?.addEventListener("abort", decline, { once: true });
         // The question has the keys: ctrl+h is caught here, or it would never reach the shortcut, which only the chat's editor sees.
-        const unhook = hookPeekKey(ctx);
+        const unhook = dialogs === undefined ? hookPeekKey(ctx) : () => { };
+        if (dialogs === undefined)
+            ctx.ui.setWorkingMessage("waiting for your answer");
         try {
-            // The question, with what the asker gives to read for it - a brief to confirm - above it; what it said of its work
-            // before asking is kept in its record, never put in the dialog.
-            // A dialog of turri's own: a long brief scrolls above the question, and the options always show (question-dialog.ts).
-            const dialog = (question, context, options, selected) => ctx.ui.custom((tui, theme, _keybindings, done) => {
-                const shown = new QuestionDialog({
-                    question,
-                    ...(context !== undefined ? { context } : {}),
-                    ...(options !== undefined ? { options } : {}),
-                    ...(selected !== undefined ? { selected } : {}),
-                    rows: () => paddedRows(tui.terminal.rows),
-                    style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
-                    done: (answer) => {
-                        if (questionShown === shown)
-                            questionShown = undefined;
-                        done(answer);
-                    },
-                    requestRender: () => tui.requestRender(),
-                });
-                questionShown = shown;
-                return shown;
-            });
-            const asking = (asked) => runAsk(asked, {
-                select: (title, options, context, at) => dialog(title, context, options, at),
-                input: (title, context) => dialog(title, context),
-            });
+            const io = dialogs !== undefined ? hostDialogs(dialogs, declining) : terminalDialogs(ctx, declining, decline);
+            const asking = (asked) => runAsk(asked, io);
             const bare = { ...request, said: undefined };
-            const answer = aside !== undefined ? await askWithAsides(bare, asking, aside) : await asking(bare);
+            const given = declining.declined ? DECLINED : aside !== undefined ? await askWithAsides(bare, asking, aside) : await asking(bare);
+            const answer = declining.declined ? DECLINED : given;
             // Kept: what was shown with it, and what it said before it.
             onExchange(request.question, answer, [request.context, request.said].map((part) => part?.trim() ?? "").filter((part) => part !== "").join("\n\n") || undefined);
             return answer;
         }
         finally {
+            turn?.removeEventListener("abort", decline);
             unhook();
-            ctx.ui.setWorkingMessage();
+            if (dialogs === undefined)
+                ctx.ui.setWorkingMessage();
         }
     };
 }
+/** A host's dialogs, for a question that can be declined: its dialog stays the host's to close, the question over all the same. */
+function hostDialogs(dialogs, declining) {
+    const until = (asked) => declining.declined ? Promise.resolve(undefined) : Promise.race([asked(), new Promise((resolve) => (declining.close = () => resolve(undefined)))]);
+    return {
+        select: (...args) => until(() => dialogs.select(...args)),
+        input: (...args) => until(() => dialogs.input(...args)),
+    };
+}
+/**
+ * The terminal's dialogs: turri's own, a long brief scrolling above the question and the options always showing
+ * (question-dialog.ts). ctrl+c declines the question - each one it is pressed at, however many in a row; what asked
+ * goes on. The turn, and a skill asking in it, is stopped by ctrl+c with no question open.
+ */
+function terminalDialogs(ctx, declining, decline) {
+    const dialog = (question, context, options, selected) => declining.declined
+        ? Promise.resolve(undefined)
+        : ctx.ui.custom((tui, theme, _keybindings, done) => {
+            const shown = new QuestionDialog({
+                question,
+                ...(context !== undefined ? { context } : {}),
+                ...(options !== undefined ? { options } : {}),
+                ...(selected !== undefined ? { selected } : {}),
+                rows: () => paddedRows(tui.terminal.rows),
+                style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
+                done: (answer) => {
+                    if (questionShown === shown)
+                        questionShown = undefined;
+                    done(answer);
+                },
+                requestRender: () => tui.requestRender(),
+                interrupt: decline,
+            });
+            declining.close = () => shown.dismiss();
+            questionShown = shown;
+            return shown;
+        });
+    return {
+        select: (title, options, context, at) => dialog(title, context, options, at),
+        input: (title, context) => dialog(title, context),
+    };
+}
 /** The side panel, as a question open in the chat reaches it: set once the extension has its panel. */
 let questionPeek;
 /**
@@ -574,7 +598,7 @@ function turriExtension(api, session, link) {
                 description: "Start a new run even though an interrupted one exists here, discarding it.",
             })),
         }),
-        async execute(_id, params, _signal, onUpdate, ctx) {
+        async execute(_id, params, signal, onUpdate, ctx) {
             const skill = skills.find((s) => s.name === params.skill);
             if (!skill) {
                 return {
@@ -690,8 +714,10 @@ function turriExtension(api, session, link) {
             const ended = skillRunStarted({ skill: skill.name, dir: skill.dir, step: () => live.step, trace: () => [...trace], runDir });
             // From here the time to first regeneration is counted, for a skill that writes spec diffs: its first pulse started.
             const began = Date.now();
-            const { result, output: captured } = await captureConsole(() => runSkill({
+            const ran = await captureConsole(() => runSkill({
                 skillDir: skill.dir,
+                // The chat's turn stopped - ctrl+c, esc - stops the run with it.
+                signal,
                 cwd,
                 runDir,
                 resume: params.resume === true && interrupted !== undefined,
@@ -736,12 +762,23 @@ function turriExtension(api, session, link) {
                     }
                     return ctx.ui.confirm(`Review gate: ${skill.name}`, `${critique}\n\n${question}`);
                 },
-            })).finally(() => {
+            }))
+                .catch((error) => {
+                if (!(error instanceof JobStoppedError))
+                    throw error;
+                return undefined;
+            })
+                .finally(() => {
                 ended();
                 clearInterval(ticker);
                 if (ctx.hasUI)
                     ctx.ui.setWidget("turri-skill", undefined);
             });
+            if (ran === undefined) {
+                const text = [`${skill.name}: stopped by the person, in its ${live.step || "first"} step. It can be continued with resume: true.`, "", "<trace>", ...trace, "</trace>"].join("\n");
+                return { content: [{ type: "text", text }], details: { stopped: true } };
+            }
+            const { result, output: captured } = ran;
             const noise = describeCaptured(captured);
             if (noise !== null)
                 push(noise);

package/dist/genome.d.ts

@@ -17,12 +17,7 @@ export interface RunSkillResult {
     /** The last step's artifact - what the caller usually wants. */
     output: string;
 }
-/**
- * Run one skill to completion. The only entry point: the CLI and the Pi extension
- * both go through here, so a skill behaves identically whether a human launched it
- * or a conversational agent decided to.
- */
-export declare function runSkill(opts: {
+export interface RunSkillOptions {
     skillDir: string;
     cwd: string;
     runDir: string;
@@ -51,7 +46,18 @@ export declare function runSkill(opts: {
     loopTools?: ToolDefinition[];
     /** The jobs the render queue runs, for a skill that waits for its builds and reads what they recorded. */
     jobs?: JobRegistry;
-}): Promise<RunSkillResult>;
+    /**
+     * Stops the run: its agents end their turns and it throws JobStoppedError, its manifest left as it was - an
+     * interrupted run, for `resume` to pick up. What it started on the work loop goes on.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Run one skill to completion. The only entry point: the CLI and the Pi extension
+ * both go through here, so a skill behaves identically whether a human launched it
+ * or a conversational agent decided to.
+ */
+export declare function runSkill(opts: RunSkillOptions): Promise<RunSkillResult>;
 /** Whether there is a run of this skill here that was interrupted, and could be resumed. */
 export declare function interruptedRun(runDir: string, skillName: string): {
     step?: string;

package/dist/genome.js

@@ -4,11 +4,11 @@ import { Command, MemorySaver } from "@langchain/langgraph";
 import { compileSkill } from "./graph.js";
 import { createExecutor } from "./pi.js";
 import { toolchainsBlock } from "./stack.js";
-import { describeToolCall, describeToolResult } from "./regenerate/activity.js";
+import { clearOfStop, describeToolCall, describeToolResult, withStopSignal } from "./regenerate/activity.js";
 import { createLiveReviewer } from "./review/live.js";
 import { loadSkill, readRubric } from "./skill.js";
 import { createAskUserTool, createEndQuestionsTool, createReviewTools, createWriteArtifactTool, withReviewNote } from "./tools.js";
-import { DISMISSED } from "./ask.js";
+import { DECLINED, DISMISSED } from "./ask.js";
 import { createQuestioning, levelOf, questioningQuestion } from "./questioning.js";
 import { createSpecDiffTools } from "./spec-tools.js";
 import { createMatureTools, MATURE_TOOLS } from "./mature-tools.js";
@@ -23,6 +23,16 @@ const SAID_MAX = 6000;
  * or a conversational agent decided to.
  */
 export async function runSkill(opts) {
+    if (opts.signal === undefined)
+        return runStoppable(opts);
+    return withStopSignal(opts.signal, () => runStoppable({
+        ...opts,
+        ...(opts.renderQueue !== undefined ? { renderQueue: clearOfStop(opts.renderQueue) } : {}),
+        ...(opts.jobs !== undefined ? { jobs: clearOfStop(opts.jobs) } : {}),
+        ...(opts.loopTools !== undefined ? { loopTools: opts.loopTools.map(clearOfStop) } : {}),
+    }));
+}
+async function runStoppable(opts) {
     const skill = loadSkill(opts.skillDir);
     const runDir = resolve(opts.runDir);
     // A resumed run keeps its folder - the artifacts are in it - and starts where it stopped.
@@ -102,7 +112,7 @@ export async function runSkill(opts) {
         customTools.push(createAskUserTool(opts.askUser, (answer, confirmsPhase) => {
             said = "";
             // A phase's confirmation, or a question dismissed, owes the spec nothing.
-            diffs?.pace.answered(!confirmsPhase && answer !== DISMISSED);
+            diffs?.pace.answered(!confirmsPhase && answer !== DISMISSED && answer !== DECLINED);
         }, () => said, holdsQuestions ? questions : undefined));
         if (capsQuestions)
             customTools.push(createEndQuestionsTool(questions));

package/dist/host-session.d.ts

@@ -1,6 +1,6 @@
 import { type AgentSession, type ExtensionFactory, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import type { AskUserIO } from "./ask.ts";
-import type { ChatInfo, TurriHost } from "./chats.ts";
+import { type ChatInfo, type TurriHost } from "./chats.ts";
 import type { JobRegistry } from "./regenerate/jobs.ts";
 import type { WorkLoop } from "./regenerate/loop.ts";
 /**
@@ -42,6 +42,13 @@ export interface Turri {
     closeChat(id: string): Promise<void>;
     /** The chat the person looks at now. */
     focus(id: string): void;
+    /**
+     * ctrl+c in a chat, as the terminal has it: what the chat is doing stopped - its turn, a skill or a tool in it, a `!`
+     * command, a compaction - and nothing in the others (`stopped`). In a chat doing nothing the session ends - every
+     * chat let go and what activate started stopped, as `dispose` does - for the host to close what showed it (`ended`).
+     * A second interrupt straight after one that stopped something does nothing (`ignored`); `missing` for a chat not open.
+     */
+    interrupt(id: string): Promise<"stopped" | "ignored" | "ended" | "missing">;
     /** Told when a chat is opened, closed, renamed, or starts or stops working. */
     onChats(listener: (chats: ChatInfo[]) => void): () => void;
     /** Every chat let go, and what activate started stopped. */

package/dist/host-session.js

@@ -1,5 +1,6 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from "@earendil-works/pi-coding-agent";
 import { lastRun } from "./chat-records.js";
+import { interruptChat } from "./chats.js";
 import { createTurriCore, sessionLoop } from "./extension.js";
 import { stopDeployed } from "./regenerate/release.js";
 /** turri's session in a host, in the process's working folder - the project's. */
@@ -36,6 +37,11 @@ export async function createTurri(options = {}) {
         if (first !== undefined)
             await core.show(first.id);
     }
+    let lastStop = 0;
+    const dispose = async () => {
+        await core.dispose();
+        await stopDeployed();
+    };
     return {
         jobs: core.jobs,
         get loop() {
@@ -49,10 +55,18 @@ export async function createTurri(options = {}) {
         },
         closeChat: (id) => core.close(id),
         focus: (id) => void core.show(id),
-        onChats: (listener) => core.onChats(() => listener(core.chats())),
-        async dispose() {
-            await core.dispose();
-            await stopDeployed();
+        async interrupt(id) {
+            const session = core.session(id);
+            if (session === undefined)
+                return "missing";
+            const did = interruptChat(session, { lastStop, idle: () => "ended" });
+            if (did === "stopped")
+                lastStop = Date.now();
+            if (did === "ended")
+                await dispose();
+            return did;
         },
+        onChats: (listener) => core.onChats(() => listener(core.chats())),
+        dispose,
     };
 }

package/dist/question-dialog.d.ts

@@ -25,6 +25,8 @@ export interface QuestionDialogOptions {
     style: DialogStyle;
     /** The answer - an option, or what was typed - or undefined, dismissed. */
     done: (answer: string | undefined) => void;
+    /** ctrl+c: the question declined, the asker deciding what that stops (askUserVia). Without it, dismissed as esc is. */
+    interrupt?: () => void;
     /** Draw again: a key changed what shows. */
     requestRender: () => void;
 }
@@ -42,6 +44,8 @@ export declare class QuestionDialog implements Component, Focusable {
     constructor(options: QuestionDialogOptions);
     get focused(): boolean;
     set focused(value: boolean);
+    /** Closed, no answer given: the question declined from outside - its turn stopped. */
+    dismiss(): void;
     private finish;
     private scrollBy;
     render(width: number): string[];

package/dist/question-dialog.js

@@ -36,6 +36,10 @@ export class QuestionDialog {
         if (this.input !== undefined)
             this.input.focused = value;
     }
+    /** Closed, no answer given: the question declined from outside - its turn stopped. */
+    dismiss() {
+        this.finish(undefined);
+    }
     finish(answer) {
         if (this.answered)
             return;
@@ -65,8 +69,8 @@ export class QuestionDialog {
                     return index === this.selected ? style.accent(shown) : shown;
                 }));
         const hint = this.input !== undefined
-            ? "enter answers · esc dismisses"
-            : "↑↓ choose · enter picks · esc dismisses";
+            ? "enter answers · esc dismisses · ctrl+c declines"
+            : "↑↓ choose · enter picks · esc dismisses · ctrl+c declines";
         // The brief gets what the question, the options and the hints leave of the screen.
         const fixed = question.length + body.length + 5;
         const room = Math.max(3, this.options.rows() - KEPT_ABOVE - fixed);
@@ -89,6 +93,13 @@ export class QuestionDialog {
         return lines;
     }
     handleInput(data) {
+        if (matchesKey(data, "ctrl+c")) {
+            if (this.options.interrupt !== undefined)
+                this.options.interrupt();
+            else
+                this.finish(undefined);
+            return;
+        }
         // The brief scrolls whatever has the keys.
         if (matchesKey(data, "pageDown"))
             return this.scrollBy(Math.max(1, this.window - 1));

package/dist/regenerate/activity.d.ts

@@ -84,8 +84,15 @@ export declare function reportSpecConflict(conflict: SpecConflict): void;
 export declare class JobStoppedError extends Error {
     constructor();
 }
-/** The stop signal of the job this code is running for, if it is running for one. */
+/** The stop signal of the job this code is running for - else of the work outside a job it runs for - if there is one. */
 export declare function currentStopSignal(): AbortSignal | undefined;
+/** Run work for no job that `signal` stops: every agent under it ends its turn, and the work unwinds with JobStoppedError. */
+export declare function withStopSignal<T>(signal: AbortSignal | undefined, run: () => Promise<T>): Promise<T>;
+/**
+ * What work under withStopSignal hands on to the session - the work loop, the job registry - with each of its methods
+ * run clear of that signal: a pulse or a plan started from a skill outlives the skill being stopped.
+ */
+export declare function clearOfStop<T extends object>(given: T): T;
 /** The job this code is running for, if it is running for one. */
 export declare function currentJob(): {
     id: string;

package/dist/regenerate/activity.js

@@ -14,9 +14,30 @@ export class JobStoppedError extends Error {
         this.name = "JobStoppedError";
     }
 }
-/** The stop signal of the job this code is running for, if it is running for one. */
+/** What stops work that runs for no job - a skill run, stopped with the chat's turn that runs it (withStopSignal). */
+const stops = new AsyncLocalStorage();
+/** The stop signal of the job this code is running for - else of the work outside a job it runs for - if there is one. */
 export function currentStopSignal() {
-    return store.getStore()?.signal;
+    const sink = store.getStore();
+    return sink !== undefined ? sink.signal : stops.getStore();
+}
+/** Run work for no job that `signal` stops: every agent under it ends its turn, and the work unwinds with JobStoppedError. */
+export function withStopSignal(signal, run) {
+    return stops.run(signal, run);
+}
+/**
+ * What work under withStopSignal hands on to the session - the work loop, the job registry - with each of its methods
+ * run clear of that signal: a pulse or a plan started from a skill outlives the skill being stopped.
+ */
+export function clearOfStop(given) {
+    return new Proxy(given, {
+        get(target, key, receiver) {
+            const value = Reflect.get(target, key, receiver);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => stops.run(undefined, () => value.apply(target, args));
+        },
+    });
 }
 /** The job this code is running for, if it is running for one. */
 export function currentJob() {

package/docs/chats.md

@@ -33,6 +33,7 @@ A pulse's end is told to the chat that asked for it, shown or not - its agent re
 | `/chat` | a list of the chats, to pick one - or a new one |
 | `/new` | the same as `/chat new` |
 | `/resume` | a saved chat, opened as a chat of its own beside the others - or shown, when it is open |
+| `ctrl+c` | what the chat shown is doing, stopped - its turn, a skill or a tool in it, a `!` command, a compaction; in a chat doing nothing, a draft in the editor cleared, else turri left, every chat with it |
 
 A line above the editor names each chat once there are two, a `│` between them: its number, its title - "new chat" until something is said in it, then its first message, until `/name` gives it one - and, after it, what it is doing: a spinner while it works, `?` while a question waits in it, `•` when it said something since you last looked. The chat shown is in the accent colour.
 
@@ -41,6 +42,7 @@ On macOS, `alt` is Option (⌥), and reaches turri only when the terminal sends
 - **A hidden chat's questions** wait until you show it, then come up one after another. What it says in passing is said as you show it; what it keeps on the screen - a skill's progress, the job panel - is put back each time; what you had typed in its editor and not sent is still there.
 - **The side panel** (`ctrl+h`) is the session's, not a chat's: docked beside the chat or over it, it stays as another chat is shown, and opening it from any chat finds it as it was left.
 - **A long command** - `/regenerate`, planning a module from scratch - does its work in the background once it is under way: the chat, and switching to another, stay free while the planner plans.
+- **`ctrl+c`** reaches the chat shown and nothing else: another chat's turn and skill go on, and so do the pulses - `/halt` stops one. A skill stopped keeps its run, for the model to continue with `resume`. At a question - the chat's `ask_user`, a skill's interview - `ctrl+c` declines it, and the asker is told so and goes on - each question it is pressed at, however many in a row. A skill is stopped by `ctrl+c` with no question open. A second press straight after one that stopped something does nothing, so pressing twice to be sure does not leave turri; once the chat is doing nothing, the next one does - with what every other chat is doing. A host has the same as `interrupt(id)` ([hosting](hosting.md)).
 - **The last chat** is not closed: `/quit` leaves turri.
 - **`/fork`** and **`/reload`** work on the chat shown, as [pi](https://pi.dev)'s do: the chat's history forked, or turri's extension rebuilt in it.
 - **A chat shown mid-turn** draws its reply as far as it is written, and follows it from there.

package/docs/hosting.md

@@ -89,6 +89,7 @@ const chat = await turri.openChat();   // { id, title, status, shown, session }:
 chat.session.subscribe((event) => {}); // pi's session: its events, prompt(), abort()
 await chat.session.prompt("add a cart to the shop");
 turri.focus(other.id);                 // the chat the person looks at now
+await turri.interrupt(chat.id);        // ctrl+c: "stopped" what it was doing, else "ended" the session - "ignored", "missing"
 turri.chats();                         // [{ id, title, status: "idle" | "working" | "question" | "unread", shown }]
 turri.onChats((chats) => {});          // a chat opened, closed, renamed, working or done
 await turri.closeChat(chat.id);        // its turn stopped, its conversation deleted - its pulses run on
@@ -98,6 +99,7 @@ await turri.dispose();                 // every chat let go, what activate start
 ```
 
 - **The chats.** Up to nine, each its own history, model, thinking level and stack, all on the session's one job registry and work loop - see [chats](chats.md). `openChat({ sessionFile })` reopens a saved one. A pulse's end is told to the chat that asked for it, its agent reacting there; to the chat `focus` last named when that one is closed. A chat is never hidden from turri's side: what the host does not show, it still runs, and its questions go to the host's dialogs at once - the host decides where they wait. `status` says a turn is running (`working`) or that it said something since it was last focused (`unread`).
+- **Interrupting.** `interrupt(id)` is the terminal's ctrl+c for a host's key or button: it stops what that chat is doing - its turn, a skill or a tool in it, a `!` command, a compaction - and nothing in the other chats (`stopped`). A skill stopped keeps its run, to be continued. A question of the chat's open in the host's dialogs when its turn is stopped is over - declined - though its dialog is the host's to close. A chat doing nothing ends the session, every chat with it, as `dispose` does (`ended`): turri never exits the host's process, so the host closes what showed it. An interrupt straight after one that stopped something is `ignored`, so pressing twice to be sure ends nothing. `session.abort()` is the chat's turn alone, and never ends the session.
 - **The record.** The chats are recorded in `.turri/chats.json` as the terminal records them, and `restore: true` reopens the last ended session's - without it, a host starts with none and deletes nothing. A chat closed is deleted; a session's chats are kept until five newer sessions have recorded theirs.
 - **The jobs.** The host is told of each job as it changes, and has the registry and the loop themselves, so it shows the very jobs the chats run. Its buttons are best a chat's commands - `session.prompt("/regenerate app.plain")` - so the plan is the chats'.
 - **The questions.** `dialogs(chat)` gives a chat's two dialogs: `select(title, options, context, at)` and `input(title, context)`, each resolving with the answer, or undefined when the person dismissed it. The chat's questions, a skill's interview and a review gate's escalation are put in them; without them, in the `uiContext`'s own dialogs.

package/docs/skills-and-gates.md

@@ -43,7 +43,7 @@ A skill declares its steps with a `## Steps` section whose `###` headings are th
 
 `questioning:` under `metadata:` names the steps the questioning level caps (`src/questioning.ts`) - `brood`'s `[stack, product]`, `bud`'s `[product]`. When there are any and someone to ask, the harness itself asks the first question of the first step: how many questions those steps may ask - light (3), medium (5), thorough (10) or best judgement - and tells the agent the answer beside each step's instructions, with how broad each question is to be: broad at light, a whole area at once, narrow at thorough, an edge case at a time. Every level covers the same ground, in less or more depth. In a capped step `ask_user` refuses a question past the cap; the step's closing confirmation, asked with `confirms_phase: true`, is never counted. `end_questions` ends the step's questions sooner - best judgement's only end. What the questions leave open, the agent decides itself and says what it chose. The level, and how many questions each step has asked, are kept in the run's `run.json`, so a resumed run keeps them. A step it does not name, or a run with nobody to ask, is not capped.
 
-`change-plain-per-answer:` under `metadata:` names the steps where every answer is a \*\*\*plain change - `brood`'s and `bud`'s `[product]`, at every questioning level. There `ask_user` refuses the next question until the last answer is written with `change_plain` (a confirmation, or a question dismissed, owes nothing), and `change_plain` no longer waits for an answer before a change: the agent writes as many as the step needs, those it decides itself included. The level limits the questions, never the \*\*\*plain changes.
+`change-plain-per-answer:` under `metadata:` names the steps where every answer is a \*\*\*plain change - `brood`'s and `bud`'s `[product]`, at every questioning level. There `ask_user` refuses the next question until the last answer is written with `change_plain` (a confirmation, or a question dismissed or declined, owes nothing), and `change_plain` no longer waits for an answer before a change: the agent writes as many as the step needs, those it decides itself included. The level limits the questions, never the \*\*\*plain changes.
 
 A step ends when its agent's turn does. A turn that ends on a question in the reply would end the step there, half done, on a question no one reads - the person sees only what `ask_user` asks. So such a step is sent back, twice at most: to ask with `ask_user` if the question is truly the person's, or, in an unpaced skill, to decide it itself - then to carry on until the step is done.
 
@@ -81,7 +81,7 @@ A gate can also have a `continuous` reviewer: a read-only agent that re-reads th
 - **Regenerate, and conform.** A skill that names them in `allowed-tools` gets the conversation's own `regenerate`, `drift`, `halt` and `conform`, on its loop: `conform` schedules a conformance pulse for functional specs not built yet, as it does from the chat. The skill never waits for them.
 - **Choose the model that regenerates**, when the user says so - `engine`, the same tool the conversation has.
 
-The harness still owns the sequence. A step chooses what to ask; it does not choose whether the gate afterwards runs. A run is saved as it goes, so an interrupted one can be resumed where it stopped.
+The harness still owns the sequence. A step chooses what to ask; it does not choose whether the gate afterwards runs. A run is saved as it goes, so an interrupted one can be resumed where it stopped - a run stopped with the chat's turn (`ctrl+c`, `esc`) too: its agents end their turns there, and what it started on the work loop goes on.
 
 While a skill runs in the chat, `cultivate`'s output leads with what its agent is doing now: the skill, its step and how long each has taken, its last few tool calls, and the end of what it is saying, refreshed every few seconds. [pi](https://pi.dev) shows only a running tool's first lines, and a step can take many minutes without a new line in the trace. The result the conversation gets back keeps the trace alone.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.17-next.1ecfd4f",
+  "version": "0.1.17",
   "license": "MIT",
   "type": "module",
   "repository": {