@turri-dev/cli 0.1.17 → 0.1.18

package/dist/ask.d.ts

@@ -36,8 +36,13 @@ export type AskUser = (request: AskUserRequest) => Promise<string>;
  */
 export interface AskUserIO {
     /** `at`: the option the cursor starts on - the one just ticked, in a question of several. */
-    select(title: string, options: string[], context?: string, at?: number): Promise<string | undefined>;
-    input(title: string, context?: string): Promise<string | undefined>;
+    select(title: string, options: string[], context?: string, at?: number, asked?: DialogAsked): Promise<string | undefined>;
+    input(title: string, context?: string, asked?: DialogAsked): Promise<string | undefined>;
+}
+/** What a host's dialog is told beside its question. */
+export interface DialogAsked {
+    /** Aborted when the question is over without the dialog's answer - declined, or its turn stopped: the dialog is closed. */
+    signal: AbortSignal;
 }
 export declare const OTHER_OPTION = "Something else\u2026";
 export declare const CHAT_OPTION = "Chat about this";

package/dist/chat-scope.d.ts

@@ -7,6 +7,8 @@ export interface ChatScope {
     id: string;
     /** The stack this chat chose with /stack or the stack tool - none: the project's config alone. */
     stack: string | undefined;
+    /** The questions it asks now, each with what declines it: a host declines them with `Turri.decline`. */
+    readonly asking: Set<() => void>;
 }
 /** The chat this code runs for - undefined outside every chat: the command line, a test. */
 export declare function currentChat(): ChatScope | undefined;

package/dist/chats.d.ts

@@ -113,6 +113,8 @@ export interface TurriCore {
     chats(): ChatInfo[];
     /** The chat's pi session. */
     session(id: string): AgentSession | undefined;
+    /** The questions the chat asks now declined, as ctrl+c at one declines it - `none` when it asks nothing. */
+    decline(id: string): "declined" | "none" | "missing";
     /** The chat shown now. */
     shown(): string | undefined;
     /** Open a chat - fresh, or the saved one `sessionFile` is - shown at once unless `hidden`. */

package/dist/chats.js

@@ -109,7 +109,7 @@ export function createChats(options) {
         const id = randomUUID().slice(0, 8);
         const chat = {
             id,
-            scope: { id, stack: process.env.TURRI_STACK?.trim() || undefined },
+            scope: { id, stack: process.env.TURRI_STACK?.trim() || undefined, asking: new Set() },
             ...(title !== undefined ? { recordedTitle: title } : {}),
             working: false,
             unread: false,
@@ -155,6 +155,15 @@ export function createChats(options) {
         },
         chats: () => chats.map((chat) => ({ id: chat.id, title: titleFor(chat), status: statusOf(chat), shown: chat.id === shownId })),
         session: (id) => chats.find((chat) => chat.id === id)?.session,
+        decline(id) {
+            const chat = chats.find((candidate) => candidate.id === id);
+            if (chat === undefined)
+                return "missing";
+            const asking = [...chat.scope.asking];
+            for (const decline of asking)
+                decline();
+            return asking.length > 0 ? "declined" : "none";
+        },
         shown: () => shownId,
         shownChat: () => chats.find((chat) => chat.id === shownId),
         chatOfSession: (session) => chats.find((chat) => chat.session === session),

package/dist/extension.js

@@ -63,6 +63,7 @@ import { supersededByTurri } from "./chat-skills.js";
 import { conversationIdentity } from "./identity.js";
 import { setSurface, surfaceOf } from "./surface.js";
 import { createChats, scopedToChat } from "./chats.js";
+import { currentChat } from "./chat-scope.js";
 import { registerChats } from "./chat-commands.js";
 import { turriIdentity } from "./environment.js";
 import { conformanceChooser } from "./regenerate/choose-conformance.js";
@@ -95,15 +96,9 @@ dialogs) {
         if (dialogs === undefined && !ctx.hasUI) {
             return "No user is available to answer. Decide yourself, and say in your report what you assumed.";
         }
-        // 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 });
+        // Declined - ctrl+c at it, the host's decline, or the turn that asked it stopped: the dialog open is closed, no other is
+        // opened, and it comes back as DECLINED.
+        const { declining, decline, done } = asking(ctx.signal);
         // 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 = dialogs === undefined ? hookPeekKey(ctx) : () => { };
         if (dialogs === undefined)
@@ -119,19 +114,55 @@ dialogs) {
             return answer;
         }
         finally {
-            turn?.removeEventListener("abort", decline);
+            done();
             unhook();
             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. */
+/**
+ * A question being asked, until `done`: declined by `decline` - ctrl+c at it - by the host (`Turri.decline`, through the
+ * chat's `asking`) or by `turn` being stopped.
+ */
+function asking(turn) {
+    const declining = { declined: turn?.aborted === true, close: undefined };
+    const decline = () => {
+        declining.declined = true;
+        declining.close?.();
+    };
+    turn?.addEventListener("abort", decline, { once: true });
+    const open = currentChat()?.asking;
+    open?.add(decline);
+    return {
+        declining,
+        decline,
+        done: () => {
+            turn?.removeEventListener("abort", decline);
+            open?.delete(decline);
+        },
+    };
+}
+/**
+ * A host's dialogs, for a question that can be declined: the question over at once, its dialog told through its
+ * `signal` - the host's to close.
+ */
 function hostDialogs(dialogs, declining) {
-    const until = (asked) => declining.declined ? Promise.resolve(undefined) : Promise.race([asked(), new Promise((resolve) => (declining.close = () => resolve(undefined)))]);
+    const until = (asked) => {
+        if (declining.declined)
+            return Promise.resolve(undefined);
+        const over = new AbortController();
+        return Promise.race([
+            asked(over.signal),
+            new Promise((resolve) => (declining.close = () => {
+                over.abort();
+                resolve(undefined);
+            })),
+        ]);
+    };
     return {
-        select: (...args) => until(() => dialogs.select(...args)),
-        input: (...args) => until(() => dialogs.input(...args)),
+        select: (title, options, context, at) => until((signal) => dialogs.select(title, options, context, at, { signal })),
+        input: (title, context) => until((signal) => dialogs.input(title, context, { signal })),
     };
 }
 /**
@@ -753,8 +784,15 @@ function turriExtension(api, session, link) {
                 escalate: async ({ question, critique }) => {
                     if (dialogs !== undefined) {
                         const through = "Let it through";
-                        const answer = await dialogs.select(`Review gate: ${skill.name} - ${question}`, [through, "Keep the gate"], critique);
-                        return answer === through;
+                        // Declined, as any question in the host's dialogs can be: the gate stands.
+                        const asked = asking(signal);
+                        try {
+                            const answer = await hostDialogs(dialogs, asked.declining).select(`Review gate: ${skill.name} - ${question}`, [through, "Keep the gate"], critique);
+                            return !asked.declining.declined && answer === through;
+                        }
+                        finally {
+                            asked.done();
+                        }
                     }
                     if (!ctx.hasUI) {
                         push("  no UI available for human review - gate stands");

package/dist/host-session.d.ts

@@ -16,7 +16,11 @@ export interface TurriOptions extends Omit<TurriHost, "dialogs"> {
     sessionDir?: string;
     /** The host's own extensions, built into every chat after turri's. */
     extensions?: ExtensionFactory[];
-    /** The dialogs a chat's questions are put in - ask_user's, a skill's interview, a review gate's - by the chat's id. */
+    /**
+     * The dialogs a chat's questions are put in - ask_user's, a skill's interview, a review gate's - by the chat's id. Each
+     * is given a `signal`, aborted when its question is over without its answer - declined, or its turn stopped - for the
+     * host to close it.
+     */
     dialogs?: (chat: string) => AskUserIO | undefined;
     /** What a chat's other UI calls - its notices, its working line - come to, by the chat's id. */
     uiContext?: (chat: string) => ExtensionUIContext | undefined;
@@ -49,6 +53,13 @@ export interface Turri {
      * 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">;
+    /**
+     * ctrl+c at a question, as the terminal has it: the question the chat asks now - its ask_user, a skill's interview, a
+     * review gate's escalation - declined. The asker is told the person declined to answer and the turn goes on; the
+     * host's dialog for it is told through its `signal`. Each question it is called at, however many in a row - it never
+     * stops the turn. `none` when the chat asks nothing now, `missing` for a chat not open.
+     */
+    decline(id: string): Promise<"declined" | "none" | "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

@@ -66,6 +66,7 @@ export async function createTurri(options = {}) {
                 await dispose();
             return did;
         },
+        decline: async (id) => core.decline(id),
         onChats: (listener) => core.onChats(() => listener(core.chats())),
         dispose,
     };

package/docs/chats.md

@@ -42,7 +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)).
+- **`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)`, and `decline(id)` for a question ([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

@@ -77,7 +77,7 @@ process.chdir(project);                // the session is the project's in the pr
 const turri = await createTurri({
   onJobChange: (job) => {},            // a job started, moved on, did something, or ended - any chat's
   onPlanChange: () => {},              // what is planned changed with no job
-  dialogs: (chat) => ({ select, input }), // a chat's questions, put in the host's own dialogs
+  dialogs: (chat) => ({ select, input }), // a chat's questions, put in the host's own dialogs - each with a signal to close it
   uiContext: (chat) => uiContext,      // a chat's other UI calls - notices, the working line
   surface: SURFACE,                    // the host's UI, in its own words, told to the model in place of the terminal's
   systemPrompt: (prompt) => prompt,    // the last word on the whole system prompt, each turn
@@ -90,6 +90,7 @@ chat.session.subscribe((event) => {}); // pi's session: its events, prompt(), ab
 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"
+await turri.decline(chat.id);          // ctrl+c at a question: "declined", the turn going on - "none", "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
@@ -99,10 +100,11 @@ 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.
+- **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 - and its dialog's `signal` aborted, for the host to close it. 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.
+- **Declining a question.** `decline(id)` is ctrl+c at a question in turri's terminal: the question the chat asks now - its ask_user, a skill's interview, a review gate's escalation, whatever goes through the host's dialogs - declined. The asker is told "The user declined to answer the question." and the turn goes on; a review gate declined stands. It declines each question it is called at, however many in a row, and never stops the turn - that is `interrupt`. `none` when the chat asks nothing now, `missing` for a chat not open. A dialog that resolves with `undefined` is something else - dismissed, and in a question of several answers "done" with the boxes ticked so far.
 - **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.
+- **The questions.** `dialogs(chat)` gives a chat's two dialogs: `select(title, options, context, at, { signal })` and `input(title, context, { signal })`, each resolving with the answer, or undefined when the person dismissed it. `signal` is aborted when the question is over without the dialog's answer - declined by `decline`, or its turn stopped (`interrupt`, `session.abort()`): the host closes the dialog it opened for it, whatever it resolves with then being ignored. A host may leave it unread. 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.
 - **The surface.** What turri tells the model of where the person watches the work is the terminal's by default: regen, the side panel on `ctrl+h`, `/pulses`. In a host none of that is there, and the model would send the person to keys and panels that do not exist. `surface` is the host's own description of its UI - the views it has in place of the terminal's, what its marks and buttons mean, where questions appear - in its own words. Given, turri leaves every terminal instruction out of what the model is told and puts the surface in turri's identity, as a `<surface>` block, where the identity speaks of regen. It reaches the side questions and the tools' own words too: a pulse not found says the `pulses` tool lists them, not `/pulses`. Text only the person sees in the terminal - the job panel, the side panel - is the terminal's and stays as it is. Without `surface`, the prompt is the terminal's, byte for byte. What the conversation is to do once something is released belongs there too - open it in the host's preview, say what to test: after a pulse released under `release-after-pulse`, the conversation does what it was told to do once something is released.
 - **The system prompt.** `systemPrompt(prompt)` gets the whole system prompt for the turn - [pi](https://pi.dev)'s, turri's identity and blocks, the rules - after turri's own `before_agent_start` work, and returns what is sent. It is for what `surface` does not cover; to describe the UI, use `surface`, rather than words appended after turri's that contradict them.
 - **The mode.** Each chat is bound in [pi](https://pi.dev)'s `tui` mode: the work runs in the background and keeps the chat free, as the terminal does. Its other UI calls - its notices, its working line, a confirm - come to `uiContext(chat)`, as [pi](https://pi.dev)'s [SDK](https://github.com/earendil-works/pi) describes it.

package/package.json

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