@itookit/dsht 0.5.1 → 0.6.0

package/dist/cli/verifier.d.ts

@@ -51,10 +51,14 @@ export declare class ProcessVerifier implements VerifierPort {
     private readonly options;
     /** This client forks itself, so the harness that judges is this one. */
     readonly name = "dsht";
+    private readonly tasks;
     constructor(options: ProcessVerifierOptions);
     /** @param request - Round identity, prompt and verdict path.
      *  @param signal - Cancels the child; the run also stops at its own deadline.
      *  @returns The verdict read back from the file, or a note explaining its absence.
      */
     verify(request: VerifierRequest, signal: AbortSignal): Promise<VerifierOutcome>;
+    /** Keep host cancellation available until every child has completed its bounded cleanup. */
+    settle(): Promise<void>;
+    private runVerification;
 }

package/dist/cli/verifier.js

@@ -66,6 +66,7 @@ export class ProcessVerifier {
     options;
     /** This client forks itself, so the harness that judges is this one. */
     name = 'dsht';
+    tasks = new Set();
     constructor(options) {
         this.options = options;
     }
@@ -74,6 +75,18 @@ export class ProcessVerifier {
      *  @returns The verdict read back from the file, or a note explaining its absence.
      */
     async verify(request, signal) {
+        const task = this.runVerification(request, signal);
+        this.tasks.add(task);
+        try {
+            return await task;
+        }
+        finally {
+            this.tasks.delete(task);
+        }
+    }
+    /** Keep host cancellation available until every child has completed its bounded cleanup. */
+    async settle() { await Promise.allSettled([...this.tasks]); }
+    async runVerification(request, signal) {
         const run = this.options.run ?? runProcess;
         const file = request.file;
         // Cancelled before anything happened: no session, no child, no verdict file.
@@ -125,10 +138,18 @@ export class ProcessVerifier {
                     ? { note: 'host cannot cancel', stopped: false }
                     : { note: 'no verifier session to cancel', stopped: true };
             }
-            const settled = await Promise.race([
-                confirmation.then(() => true),
-                new Promise(resolve => { const wait = setTimeout(() => resolve(false), CANCEL_CONFIRM_MS); wait.unref(); }),
-            ]);
+            let timer;
+            let settled;
+            try {
+                settled = await Promise.race([
+                    confirmation.then(() => true),
+                    // This bounded wait is part of verify()/settle(), so it must keep the process alive.
+                    new Promise(resolve => { timer = setTimeout(() => resolve(false), CANCEL_CONFIRM_MS); }),
+                ]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
             if (!settled)
                 return { note: `remote cancel unconfirmed after ${CANCEL_CONFIRM_MS} ms`, stopped: false };
             return confirmed === true
@@ -197,8 +218,10 @@ export class ProcessVerifier {
                 cwd: this.options.cwd, env: this.options.env, signal: controller.signal, onLine,
             });
             // A cancelled review decides nothing, and is not a verifier outage either.
-            if (cancelled)
+            if (cancelled) {
+                await cancelNote();
                 return { type: 'cancelled' };
+            }
             // The child stopped because the host wants a human: cancel the turn it left waiting (bounded,
             // reported), and hand the request to the caller instead of retrying into the same block.
             if (human !== undefined) {

package/dist/contracts.d.ts

@@ -12,11 +12,26 @@ export type { LivePhase, Message } from './session/transcript.ts';
 export type { FileReference } from './references.ts';
 export type { HistorySearch, RemovalTarget } from './session/types.ts';
 export type { QueuedInput } from './session/telemetry.ts';
-export type { ModelState, PanelState } from './session/info.ts';
 export type { CostTotal, Coverage } from './cost/index.ts';
 export type { ShellBlock } from './shell/index.ts';
-import type { ModelState, PanelState } from './session/info.ts';
-import type { RemovalTarget } from './session/types.ts';
+import type { HistorySearch, RemovalTarget } from './session/types.ts';
+import type { ObjectValue } from './json.ts';
+/** Data delivered to dialogs; visibility and keyboard ownership belong to the UI. */
+export interface ModelState {
+    catalog: ObjectValue;
+    provider?: string;
+    model?: ObjectValue;
+}
+export interface HistoryPanel {
+    query: string;
+    contentSearch: boolean;
+    matches?: HistorySearch;
+}
+export interface SearchPanel {
+    query: string;
+    items: ObjectValue[];
+    hasMore: boolean;
+}
 /** One user-saved shortcut prompt; the client owns the list, no session or host does. */
 export interface SavedPrompt {
     id: string;
@@ -24,6 +39,26 @@ export interface SavedPrompt {
 }
 /** One panel-like surface the reader can see; the application names it, the UI renders it. */
 export type PanelName = 'help' | 'cost' | 'status' | 'queue' | 'prompts' | 'thoughts' | 'history' | 'search' | 'model' | 'removal' | 'loop';
+/** Where the loop records one client runs came from.
+ *
+ * The shipped file travels with the package and a user file may layer over it, so a record list is no
+ * longer one file's content: this says which files were read and which records the user's own file
+ * replaced or added. The warnings are the client's own notes — a shipped file it could not read, or a
+ * record the user overrides that the package has since changed — and the UI shows them rather than
+ * acting on them.
+ */
+export interface LoopSourceInfo {
+    /** Shipped `loop.yaml` that was read; absent when the compiled-in records were used instead. */
+    builtin?: string;
+    /** User file layered over the shipped records; absent when there is none. */
+    file?: string;
+    /** Shipped records the user's file replaced, in that file's order. */
+    overridden: readonly string[];
+    /** Records the user's file added. */
+    added: readonly string[];
+    /** Notes to show the operator, in the order they were discovered. */
+    warnings: readonly string[];
+}
 /** One `loop.yaml` record as the record list offers it.
  *
  * The name is what `/loop` runs; the rest is what a chooser shows about it, plus the defaults a run
@@ -49,6 +84,8 @@ export interface LoopRecord {
      * document under review, a target, a threshold) is retargeted without editing `loop.yaml`.
      */
     vars: Readonly<Record<string, string>>;
+    /** Set when this record came from the user's own file rather than from the shipped one. */
+    fromFile?: true;
 }
 /** The four numbers one loop run uses.
  *
@@ -263,10 +300,10 @@ export type ViewEffect =
 /** Payload that opens its own panel. */
  | {
     kind: 'history';
-    history: PanelState['history'];
+    history: HistoryPanel | undefined;
 } | {
     kind: 'search';
-    search: PanelState['search'];
+    search: SearchPanel | undefined;
 } | {
     kind: 'model';
     model: ModelState;

package/dist/controller/connection-streams.d.ts

@@ -0,0 +1,22 @@
+/** Event/control subscriptions and their startup deadlines belong to one connection generation. */
+import { Client } from '../transport/client.ts';
+import { type HostEvent } from '../transport/events.ts';
+export interface StreamHost {
+    identified(clientId: string): void;
+    event(event: HostEvent): boolean;
+    changed(): void;
+    degraded(message: string): void;
+    fail(error: Error): void;
+}
+export declare class ConnectionStreams {
+    private readonly client;
+    private readonly host;
+    private readonly subscriptions;
+    private readonly abort;
+    private readonly signal;
+    constructor(client: Client, host: StreamHost, signal: AbortSignal);
+    start(): Promise<void>;
+    close(): void;
+    /** Resolve the first usable frame while retaining the stream until this generation ends. */
+    private follow;
+}

package/dist/controller/connection-streams.js

@@ -0,0 +1,105 @@
+/** Event/control subscriptions and their startup deadlines belong to one connection generation. */
+import { RemoteError } from "../transport/client.js";
+import { controlFrame, hostEvent } from "../transport/events.js";
+import { errorText, object, string } from "../transport/wire.js";
+export class ConnectionStreams {
+    client;
+    host;
+    subscriptions = new Set();
+    abort = new AbortController();
+    signal;
+    constructor(client, host, signal) {
+        this.client = client;
+        this.host = host;
+        this.signal = AbortSignal.any([signal, this.abort.signal]);
+    }
+    async start() {
+        let clientId = '';
+        await this.follow('$events', 'Host ready timed out', value => {
+            const frame = object(value);
+            if (frame.type === 'ready') {
+                clientId = string(frame.clientId);
+                this.host.identified(clientId);
+                return true;
+            }
+            const event = hostEvent(frame);
+            if (event && !this.host.event(event) && 'eventId' in event) {
+                // Unknown waterfalls still need a result so the host's event chain can continue.
+                void this.client.call('$events/result', { clientId, eventId: event.eventId, outcome: { kind: 'next' } })
+                    .catch(error => this.host.fail(new Error(errorText(error))));
+            }
+            return false;
+        });
+        await this.follow('session/control', 'Session control baseline timed out', value => {
+            try {
+                this.host.event({ kind: 'control', frame: controlFrame(value) });
+                this.host.changed();
+            }
+            catch (error) {
+                // Missing live metrics must not blind a running conversation.
+                this.host.degraded(`Live metrics degraded: ${errorText(error)}`);
+            }
+            return true;
+        }, error => {
+            if (!(error instanceof RemoteError) || error.code !== 'gateway/method-unavailable')
+                return false;
+            this.host.degraded('Live metrics unavailable on this host');
+            return true;
+        });
+    }
+    close() {
+        this.abort.abort();
+        for (const subscription of this.subscriptions)
+            subscription.cancel();
+        this.subscriptions.clear();
+    }
+    /** Resolve the first usable frame while retaining the stream until this generation ends. */
+    follow(endpoint, timeout, item, unavailable) {
+        this.signal.throwIfAborted();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.signal.removeEventListener('abort', cancelled);
+                if (error === undefined)
+                    resolve();
+                else
+                    reject(error);
+            };
+            const cancelled = () => finish(this.signal.reason);
+            const timer = setTimeout(() => finish(new Error(timeout)), this.client.timeoutMs);
+            this.signal.addEventListener('abort', cancelled, { once: true });
+            try {
+                const subscription = this.client.subscribe(endpoint, {}, {
+                    item: value => {
+                        if (this.signal.aborted)
+                            return;
+                        if (item(value))
+                            finish();
+                    },
+                    end: error => {
+                        if (this.signal.aborted)
+                            return;
+                        if (unavailable?.(error)) {
+                            finish();
+                            return;
+                        }
+                        const reason = error ?? new Error(`${endpoint} stream ended`);
+                        finish(reason);
+                        this.host.fail(reason);
+                    },
+                });
+                if (this.signal.aborted)
+                    subscription.cancel();
+                else
+                    this.subscriptions.add(subscription);
+            }
+            catch (error) {
+                finish(error);
+            }
+        });
+    }
+}

package/dist/controller/connection.d.ts

@@ -1,9 +1,20 @@
 import { Client } from '../transport/client.ts';
 import { type Json } from '../transport/wire.ts';
-import { type HostEvent } from '../transport/events.ts';
+import type { HostEvent } from '../transport/events.ts';
 import type { HostAccess } from '../transport/host.ts';
 import type { ConnectionView } from '../session/connection-view.ts';
-import type { ControllerStore } from '../state.ts';
+/** Connection publication cannot replace session, navigation, catalog or shell state. */
+export interface ConnectionStore {
+    readonly state: {
+        readonly online: boolean;
+    };
+    update(patch: Partial<{
+        online: boolean;
+        status: string;
+        lastFailure: string;
+        controlError: string | undefined;
+    }>): void;
+}
 /** Connection inputs resolved by the CLI or a library consumer. */
 export interface ConnectionOptions {
     base: string;
@@ -40,7 +51,7 @@ export declare class ConnectionController implements HostAccess, ConnectionView
     private readonly abort;
     private runTask;
     private generationFailed;
-    constructor(store: ControllerStore, options: ConnectionOptions, listener: ConnectionListener);
+    constructor(store: ConnectionStore, options: ConnectionOptions, listener: ConnectionListener);
     /** Start one retry loop, with a fresh snapshot generation after every disconnect. */
     start(): void;
     /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */

package/dist/controller/connection.js

@@ -1,9 +1,9 @@
 /** Owns the physical connection, its generations, and the host event subscriptions. */
 import { setTimeout as delay } from 'node:timers/promises';
 import { AuthenticationRequired } from "../transport/auth.js";
-import { HttpError, RemoteError } from "../transport/client.js";
-import { errorText, object, string } from "../transport/wire.js";
-import { controlFrame, hostEvent } from "../transport/events.js";
+import { HttpError } from "../transport/client.js";
+import { errorText } from "../transport/wire.js";
+import { ConnectionStreams } from "./connection-streams.js";
 /** Owns the physical connection: reconnects, subscriptions and generation lifecycle.
  *
  * Host running state, projections and interactions belong to the session domain; this class only
@@ -56,90 +56,61 @@ export class ConnectionController {
         let attempt = 0;
         while (!this.abort.signal.aborted) {
             this.listener.begin();
+            if (this.abort.signal.aborted)
+                break;
             const client = this.options.makeClient();
             this.current = client;
+            const generation = new AbortController();
+            const signal = AbortSignal.any([this.abort.signal, generation.signal]);
+            let disconnect;
+            const disconnected = new Promise(resolve => { disconnect = resolve; });
+            const fail = (error) => {
+                if (generation.signal.aborted)
+                    return;
+                generation.abort(error);
+                disconnect(error);
+                // End HTTP as well as streams, including requests the ready callback is awaiting.
+                void client.close();
+            };
+            this.generationFailed = fail;
+            const streams = new ConnectionStreams(client, {
+                identified: id => { this.clientId = id; }, event: event => this.listener.event(event),
+                changed: () => this.store.update({}), degraded: controlError => this.store.update({ controlError }), fail,
+            }, signal);
             try {
+                signal.throwIfAborted();
                 await this.options.authenticate(client);
+                signal.throwIfAborted();
                 await client.connect();
-                let fail;
-                const disconnected = new Promise(resolve => { fail = resolve; });
-                this.generationFailed = fail;
-                const ready = new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => reject(new Error('Host ready timed out')), client.timeoutMs);
-                    client.subscribe('$events', {}, {
-                        item: value => {
-                            const frame = object(value);
-                            if (frame.type === 'ready') {
-                                this.clientId = string(frame.clientId);
-                                clearTimeout(timer);
-                                resolve();
-                                return;
-                            }
-                            const event = hostEvent(frame);
-                            if (!event)
-                                return;
-                            if (this.listener.event(event))
-                                return;
-                            // An unanswered waterfall would block the host's event chain, so it is always settled.
-                            if ('eventId' in event) {
-                                void client.call('$events/result', { clientId: this.clientId,
-                                    eventId: event.eventId, outcome: { kind: 'next' } }).catch(error => fail(new Error(errorText(error))));
-                            }
-                        },
-                        end: error => { clearTimeout(timer); const reason = error ?? new Error('Event stream ended'); reject(reason); fail(reason); },
-                    });
-                });
-                await ready;
-                await new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => reject(new Error('Session control baseline timed out')), client.timeoutMs);
-                    client.subscribe('session/control', {}, {
-                        item: value => {
-                            try {
-                                this.listener.event({ kind: 'control', frame: controlFrame(value) });
-                                this.store.update({});
-                                clearTimeout(timer);
-                                resolve();
-                            }
-                            catch (error) {
-                                // Live metrics are not worth the connection: a frame this client cannot decode is
-                                // reported and skipped, because failing the generation would blind a running turn.
-                                clearTimeout(timer);
-                                this.store.update({ controlError: `Live metrics degraded: ${errorText(error)}` });
-                                resolve();
-                            }
-                        },
-                        end: error => {
-                            clearTimeout(timer);
-                            if (error instanceof RemoteError && error.code === 'gateway/method-unavailable') {
-                                this.store.update({ controlError: 'Live metrics unavailable on this host' });
-                                resolve();
-                            }
-                            else {
-                                const reason = error ?? new Error('Session control stream ended');
-                                reject(reason);
-                                fail(reason);
-                            }
-                        },
-                    });
-                });
+                signal.throwIfAborted();
+                await streams.start();
+                signal.throwIfAborted();
                 await this.listener.ready();
+                signal.throwIfAborted();
                 attempt = 0;
                 const error = await disconnected;
                 if (!this.abort.signal.aborted)
                     throw error;
             }
             catch (error) {
-                if (error instanceof AuthenticationRequired || error instanceof HttpError && [401, 403].includes(error.status)) {
-                    this.store.update({ lastFailure: `${errorText(error)}. Set DSH_TOKEN and restart to log in.`, status: 'Login required' });
+                if (this.abort.signal.aborted)
+                    break;
+                const reason = generation.signal.aborted ? generation.signal.reason : error;
+                if (reason instanceof AuthenticationRequired || reason instanceof HttpError && [401, 403].includes(reason.status)) {
+                    this.store.update({ lastFailure: `${errorText(reason)}. Set DSH_TOKEN and restart to log in.`, status: 'Login required' });
                     return;
                 }
-                if (!this.abort.signal.aborted)
-                    this.store.update({ lastFailure: errorText(error), status: 'Reconnecting…' });
+                this.store.update({ lastFailure: errorText(reason), status: 'Reconnecting…' });
             }
             finally {
                 this.generationFailed = undefined;
-                this.store.update({ online: false, pending: [] });
+                generation.abort();
+                streams.close();
+                this.clientId = '';
+                this.store.update({ online: false });
                 await client.close();
+                if (this.current === client)
+                    this.current = undefined;
                 await this.listener.ended();
             }
             if (!this.abort.signal.aborted) {