@itookit/dsht 0.3.8 → 0.5.2

package/dist/session/telemetry.js

@@ -1,106 +1,120 @@
-/** Host projection values with per-key watermarks; snapshots never roll back newer updates. */
-import { array, object, string } from "../transport/wire.js";
-function queuedInputs(value) {
-    return array(value).map(value => {
-        const item = object(value);
-        if (!['queued', 'steering', 'context'].includes(string(item.placement)))
-            throw new Error('Invalid queue placement');
-        return { id: string(item.id), placement: item.placement,
-            text: array(object(item.message).content).map(object).map(block => block.type === 'text' ? string(block.text) : `[${string(block.type)}]`).join(' ') };
-    });
+const EMPTY_VALUES = Object.freeze({});
+const EMPTY_QUEUE = Object.freeze([]);
+const EMPTY_VIEW = Object.freeze({ values: EMPTY_VALUES, queued: undefined, jobs: undefined });
+/** Copy on admission, not on render; no published nested object aliases a wire frame. */
+function retain(value) {
+    const copy = structuredClone(value);
+    const pending = [copy];
+    while (pending.length) {
+        const item = pending.pop();
+        if (item === null || typeof item !== 'object' || Object.isFrozen(item))
+            continue;
+        Object.freeze(item);
+        for (const child of Object.values(item))
+            pending.push(child);
+    }
+    return copy;
+}
+function retainQueue(items) {
+    return Object.freeze(items.map(item => Object.freeze({ ...item })));
 }
 /** Generation-local projection, inbox and background-job data for every session. */
 export class Telemetry {
     retainedKeys;
     entries = new Map();
     queues = new Map();
+    views = new Map();
+    reader;
     jobs = new Map();
     ready = false;
     /** Optionally retain only projection capabilities consumed by this client. */
     constructor(retainedKeys) {
         this.retainedKeys = retainedKeys;
+        const telemetry = this;
+        this.reader = Object.freeze({
+            get ready() { return telemetry.ready; },
+            view: (id) => this.view(id), pending: (id) => this.pending(id),
+        });
     }
     /** Replace all control state on a new stream baseline, then accept replacement frames.
-     * @param value - One decoded session/control frame.
+     * @param frame - One normalized session/control frame.
      */
-    accept(value) {
-        const frame = object(value);
-        if (frame.type === 'baseline') {
-            const baseline = object(frame.value);
+    accept(frame) {
+        if (frame.kind === 'baseline') {
             this.entries.clear();
             this.queues.clear();
             this.jobs.clear();
-            for (const [id, projection] of Object.entries(object(baseline.projections)))
-                this.snapshot(id, projection);
-            for (const [id, items] of Object.entries(object(baseline.queues)))
-                this.queues.set(id, queuedInputs(items));
-            for (const [id, items] of Object.entries(object(baseline.jobs)))
-                this.jobs.set(id, activeJobs(items));
+            this.views.clear();
+            for (const [id, snapshot] of frame.projections)
+                this.snapshot(id, snapshot);
+            for (const [id, items] of frame.queues)
+                this.queues.set(id, retainQueue(items));
+            for (const [id, count] of frame.jobs)
+                this.jobs.set(id, count);
             this.ready = true;
             return;
         }
         if (!this.ready)
             throw new Error('Session control update before baseline');
-        const id = string(frame.sessionId);
-        if (frame.type === 'projection') {
-            const entry = this.entry(id);
-            const key = string(frame.key);
-            const seq = sequence(frame.seq);
-            if (seq < (entry.revisions.get(key) ?? entry.baseline))
+        if (frame.kind === 'projection') {
+            const entry = this.entry(frame.sessionId);
+            if (frame.seq < (entry.revisions.get(frame.key) ?? entry.baseline))
                 return;
-            if (frame.value === undefined)
-                throw new Error('Missing projection value');
-            if (this.retainedKeys && !this.retainedKeys.has(key))
+            if (this.retainedKeys && !this.retainedKeys.has(frame.key))
                 return;
-            entry.values[key] = frame.value;
-            entry.revisions.set(key, seq);
+            entry.values[frame.key] = retain(frame.value);
+            entry.revisions.set(frame.key, frame.seq);
         }
-        else if (frame.type === 'queue')
-            this.queues.set(id, queuedInputs(frame.items));
-        else if (frame.type === 'jobs')
-            this.jobs.set(id, activeJobs(frame.items));
+        else if (frame.kind === 'queue')
+            this.queues.set(frame.sessionId, retainQueue(frame.items));
         else
-            throw new Error('Unknown session control frame');
+            this.jobs.set(frame.sessionId, frame.count);
+        this.views.delete(frame.sessionId);
     }
     /** Merge a complete follow snapshot without restoring absent or older projection values.
      * @param id - Session identity.
-     * @param value - Projection baseline, when supplied by the host.
+     * @param baseline - Projection baseline, when supplied by the host.
      */
-    snapshot(id, value) {
-        if (value === undefined)
+    snapshot(id, baseline) {
+        if (baseline === undefined)
             return;
-        const baseline = object(value);
-        const seq = sequence(baseline.asOfSeq);
-        const values = object(baseline.values);
         const entry = this.entry(id);
-        if (seq < entry.baseline)
+        if (baseline.asOfSeq < entry.baseline)
             return;
-        for (const key of new Set([...Object.keys(entry.values), ...Object.keys(values)])) {
+        for (const key of new Set([...Object.keys(entry.values), ...Object.keys(baseline.values)])) {
             if (this.retainedKeys && !this.retainedKeys.has(key))
                 continue;
-            if ((entry.revisions.get(key) ?? -1) > seq)
+            if ((entry.revisions.get(key) ?? -1) > baseline.asOfSeq)
                 continue;
-            if (Object.hasOwn(values, key))
-                entry.values[key] = values[key];
+            if (Object.hasOwn(baseline.values, key))
+                entry.values[key] = retain(baseline.values[key]);
             else
                 delete entry.values[key];
             entry.revisions.delete(key);
         }
-        entry.baseline = seq;
+        entry.baseline = baseline.asOfSeq;
+        this.views.delete(id);
     }
     /** Read current values for one session; missing capabilities remain absent.
      * @param id - Selected session identity, if any.
      * @returns Projection values and known queue/job counts.
      */
     view(id) {
-        return { values: id ? this.entries.get(id)?.values ?? {} : {},
-            queued: id ? this.queues.get(id)?.length : undefined, jobs: id ? this.jobs.get(id) : undefined };
+        if (!id || !this.entries.has(id) && !this.queues.has(id) && !this.jobs.has(id))
+            return EMPTY_VIEW;
+        let view = this.views.get(id);
+        if (!view) {
+            view = Object.freeze({ values: Object.freeze({ ...this.entries.get(id)?.values }),
+                queued: this.queues.get(id)?.length, jobs: this.jobs.get(id) });
+            this.views.set(id, view);
+        }
+        return view;
     }
     /** Read the selected session's authoritative pending inputs; absence means no observed queue.
      * @param id - Session identity.
      * @returns Pending inputs in host order.
      */
-    pending(id) { return id ? this.queues.get(id) ?? [] : []; }
+    pending(id) { return id ? this.queues.get(id) ?? EMPTY_QUEUE : EMPTY_QUEUE; }
     entry(id) {
         let entry = this.entries.get(id);
         if (!entry) {
@@ -110,11 +124,3 @@ export class Telemetry {
         return entry;
     }
 }
-function sequence(value) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < -1)
-        throw new Error('Invalid projection watermark');
-    return value;
-}
-function activeJobs(value) {
-    return array(value).filter(item => ['running', 'stopping'].includes(string(object(item).status))).length;
-}

package/dist/session/transcript.d.ts

@@ -1,17 +1,15 @@
 import type { HistoryLimits } from './memory.ts';
-import type { PromptRecord } from './info.ts';
 import { type Json, type ObjectValue } from '../transport/wire.ts';
+/** A durable user prompt projected from the transcript, before recall retention. */
+export interface PromptRecord {
+    seq: number;
+    text: string;
+}
 interface ToolSummary {
     name: string;
     operation?: string;
     command?: string;
 }
-/** Fit a tool operation to one terminal row without exposing the result body.
- * @param text - Tool name, status icon and optional operation.
- * @param width - Available terminal columns.
- * @returns A single line with an ellipsis when shortened.
- */
-export declare function toolLine(text: string, width: number): string;
 /** Render known content blocks and preserve unknown plugin blocks as JSON.
  * @param content - Message content blocks.
  * @param tools - Tool summaries by call ID, when retained history provides them.

package/dist/session/transcript.js

@@ -1,6 +1,5 @@
-/** Human transcript projection from durable events and ephemeral assistant chunks. */
-import sliceAnsi from 'slice-ansi';
-import { array, object, safeText, string } from "../transport/wire.js";
+import { array, object, string } from "../transport/wire.js";
+import { safeText, toolLine } from "../text.js";
 function toolSummary(block) {
     let args = {};
     if (typeof block.arguments === 'string' && block.arguments.trimStart().startsWith('{')) {
@@ -19,18 +18,6 @@ function toolSummary(block) {
     return { name: string(block.name), ...(typeof operation === 'string' ? { operation } : {}),
         ...(typeof command === 'string' && command !== operation ? { command: command.split(/\r?\n/)[0] } : {}) };
 }
-/** Fit a tool operation to one terminal row without exposing the result body.
- * @param text - Tool name, status icon and optional operation.
- * @param width - Available terminal columns.
- * @returns A single line with an ellipsis when shortened.
- */
-export function toolLine(text, width) {
-    const clean = safeText(text).replace(/\s+/gu, ' ').trim();
-    if (width < 2)
-        return width === 1 ? '…' : '';
-    const clipped = sliceAnsi(clean, 0, width);
-    return clipped.length < clean.length ? sliceAnsi(clean, 0, width - 1) + '…' : clean;
-}
 /** Render known content blocks and preserve unknown plugin blocks as JSON.
  * @param content - Message content blocks.
  * @param tools - Tool summaries by call ID, when retained history provides them.

package/dist/session/types.d.ts

@@ -1,4 +1,5 @@
 /** Session-domain result types shared by the controller facade and the terminal UI. */
+import type { QuestionItem } from '../transport/events.ts';
 /** Resolved navigation-removal identity; empty marks a fresh blank, idle session eligible for immediate archival. */
 export interface RemovalTarget {
     kind: 'workspace' | 'session';
@@ -16,3 +17,27 @@ export interface HistorySearch {
     }[];
     truncated: boolean;
 }
+/** A structured question answer as the UI collects it; the host receives it inside an outcome. */
+export type AnswerValue = {
+    answers: {
+        id: string;
+        selected: string[];
+        custom?: string;
+    }[];
+};
+/** One unanswered host interaction of the selected session.
+ *
+ * A discriminated union rather than the raw waterfall: the UI switches on `kind` and reads named
+ * fields, so it never needs to know how the host shaped its request.
+ */
+export type PendingInteraction = {
+    kind: 'approval';
+    eventId: string;
+    sessionId: string;
+    description: string;
+} | {
+    kind: 'question';
+    eventId: string;
+    sessionId: string;
+    questions: readonly QuestionItem[];
+};

package/dist/session/types.js

@@ -1,2 +1 @@
-/** Session-domain result types shared by the controller facade and the terminal UI. */
 export {};

package/dist/session-title.d.ts

@@ -0,0 +1,9 @@
+/** Read a session summary's display title.
+ *
+ * Host rows carry their title inside a projection, and both the domain (matching a target by name)
+ * and the UI (labelling a row) need the same reading, so it lives in its own leaf rather than in
+ * either layer.
+ */
+import { type ObjectValue } from './json.ts';
+/** Resolve the host's title projection, falling back to the session ID. */
+export declare function sessionLabel(session: ObjectValue): string;

package/dist/session-title.js

@@ -0,0 +1,21 @@
+/** Read a session summary's display title.
+ *
+ * Host rows carry their title inside a projection, and both the domain (matching a target by name)
+ * and the UI (labelling a row) need the same reading, so it lives in its own leaf rather than in
+ * either layer.
+ */
+import { string } from "./json.js";
+import { safeText } from "./text.js";
+/** Resolve the host's title projection, falling back to the session ID. */
+export function sessionLabel(session) {
+    const projections = session.projections;
+    if (projections && typeof projections === 'object' && !Array.isArray(projections)) {
+        const values = projections.values;
+        const title = values && typeof values === 'object' && !Array.isArray(values) ? values.title : undefined;
+        if (typeof title === 'string' && safeText(title).trim())
+            return safeText(title).trim();
+        if (title && typeof title === 'object' && !Array.isArray(title) && typeof title.title === 'string' && safeText(title.title).trim())
+            return safeText(title.title).trim();
+    }
+    return string(session.sessionId);
+}

package/dist/shell/controller.d.ts

@@ -1,6 +1,17 @@
-/** One local command and the output retained for it. */
+/** Readable id of one `!` run's own output, so its transcript bar and its source entry agree. */
+export declare function localSourceId(id: number): string;
+/** One local command and the output retained for it.
+ *
+ * A block is either a `!` process (`shell`) or a client command echoed so its bar can be read and
+ * clicked (`note`). A note runs nothing; it carries the readable source its bar opens, which the
+ * application links once the thing it announced exists.
+ */
 export interface ShellBlock {
     id: number;
+    /** What produced the block: a local process, or a command echoed for reading. */
+    kind: 'shell' | 'note';
+    /** Readable source this block's bar opens: its own lines, or the session a note announces. */
+    source?: string;
     command: string;
     /** Retained output lines, oldest first. */
     lines: string[];
@@ -15,6 +26,11 @@ export interface ShellBlock {
     startedAt: number;
     endedAt?: number;
 }
+/** Plain read-only view of the local `!` runs, so the UI never reads the service object. */
+export interface ShellSnapshot {
+    running: boolean;
+    blocks: readonly ShellBlock[];
+}
 /** What one shell controller needs from its owner. */
 export interface ShellHost {
     /** Repaint after output or a status change. */
@@ -41,6 +57,8 @@ export declare class ShellController {
     get runs(): readonly ShellBlock[];
     /** Whether a command is still running. */
     get running(): boolean;
+    /** The plain snapshot `AppState.shell` publishes; blocks stay owned here. */
+    snapshot(): ShellSnapshot;
     /** Start one command.
      *
      * One command runs at a time: a second `!` while the first is live is refused rather than queued,
@@ -53,6 +71,18 @@ export declare class ShellController {
      * @returns Whether a run was stopped.
      */
     cancel(): boolean;
+    /** Echo one client command as a local block, so the transcript holds a bar for it.
+     *
+     * Nothing runs and nothing is retained: the bar exists to be read and clicked, and the application
+     * links it to a readable source afterwards (`link`). A command that only fills a composer frame
+     * never reaches here, so the transcript does not collect bars for forms that were never run.
+     * @param command - The command line as the operator submitted it.
+     * @param source - Readable source the bar opens, when one already exists; `link` adds a later one.
+     * @returns The block created for it.
+     */
+    note(command: string, source?: string): ShellBlock;
+    /** Point the newest note at a readable source, so its bar opens what the run is doing now. */
+    link(source: string): void;
     /** One run's retained output, with dropped lines made explicit.
      * @param id - Run to read; defaults to the newest.
      * @returns The text, or undefined when the run is unknown.

package/dist/shell/controller.js

@@ -14,6 +14,8 @@ const BLOCK_BYTES = 64 * 1024;
 const BLOCK_LIMIT = 20;
 /** Fastest repaint cadence while output streams; status changes always publish. */
 const PUBLISH_INTERVAL_MS = 80;
+/** Readable id of one `!` run's own output, so its transcript bar and its source entry agree. */
+export function localSourceId(id) { return `shell:${id}`; }
 /** Owns the `!` commands of this client process: one at a time, bounded, killable. */
 export class ShellController {
     host;
@@ -32,6 +34,8 @@ export class ShellController {
     get runs() { return this.blocks; }
     /** Whether a command is still running. */
     get running() { return this.blocks.some(block => block.status === 'running'); }
+    /** The plain snapshot `AppState.shell` publishes; blocks stay owned here. */
+    snapshot() { return { running: this.running, blocks: this.blocks }; }
     /** Start one command.
      *
      * One command runs at a time: a second `!` while the first is live is refused rather than queued,
@@ -44,8 +48,9 @@ export class ShellController {
             throw new Error('Shell commands are disabled (--no-shell or DSHT_NO_SHELL=1)');
         if (this.task)
             throw new Error('A shell command is already running; Ctrl+C stops it');
-        const block = { id: this.nextId++, command, lines: [], dropped: 0, status: 'running',
-            startedAt: Date.now(), anchor: this.host.anchor() };
+        const id = this.nextId++;
+        const block = { id, kind: 'shell', source: localSourceId(id), command, lines: [], dropped: 0,
+            status: 'running', startedAt: Date.now(), anchor: this.host.anchor() };
         this.blocks.push(block);
         while (this.blocks.length > BLOCK_LIMIT)
             this.blocks.shift();
@@ -84,6 +89,33 @@ export class ShellController {
         this.abort.abort();
         return true;
     }
+    /** Echo one client command as a local block, so the transcript holds a bar for it.
+     *
+     * Nothing runs and nothing is retained: the bar exists to be read and clicked, and the application
+     * links it to a readable source afterwards (`link`). A command that only fills a composer frame
+     * never reaches here, so the transcript does not collect bars for forms that were never run.
+     * @param command - The command line as the operator submitted it.
+     * @param source - Readable source the bar opens, when one already exists; `link` adds a later one.
+     * @returns The block created for it.
+     */
+    note(command, source) {
+        const block = { id: this.nextId++, kind: 'note', command, lines: [], dropped: 0,
+            status: 'exited', startedAt: Date.now(), endedAt: Date.now(), anchor: this.host.anchor(),
+            ...(source === undefined ? {} : { source }) };
+        this.blocks.push(block);
+        while (this.blocks.length > BLOCK_LIMIT)
+            this.blocks.shift();
+        this.publish(true);
+        return block;
+    }
+    /** Point the newest note at a readable source, so its bar opens what the run is doing now. */
+    link(source) {
+        const note = [...this.blocks].reverse().find(block => block.kind === 'note');
+        if (note === undefined || note.source === source)
+            return;
+        note.source = source;
+        this.publish(true);
+    }
     /** One run's retained output, with dropped lines made explicit.
      * @param id - Run to read; defaults to the newest.
      * @returns The text, or undefined when the run is unknown.

package/dist/shell/index.d.ts

@@ -1,5 +1,5 @@
 /** Shell domain: the local `!` command runner and the bounded blocks it produces. */
-export { ShellController } from './controller.ts';
-export type { ShellBlock, ShellHost } from './controller.ts';
-export { runShell } from './runner.ts';
+export { ShellController, localSourceId } from './controller.ts';
+export type { ShellBlock, ShellHost, ShellSnapshot } from './controller.ts';
+export { runProcess, runShell } from './runner.ts';
 export type { ShellExit, ShellRunOptions, ShellStream } from './runner.ts';

package/dist/shell/index.js

@@ -1,3 +1,3 @@
 /** Shell domain: the local `!` command runner and the bounded blocks it produces. */
-export { ShellController } from "./controller.js";
-export { runShell } from "./runner.js";
+export { ShellController, localSourceId } from "./controller.js";
+export { runProcess, runShell } from "./runner.js";

package/dist/shell/runner.d.ts

@@ -26,3 +26,13 @@ export interface ShellRunOptions {
  * @returns How the command ended.
  */
 export declare function runShell(command: string, options: ShellRunOptions): Promise<ShellExit>;
+/** Run one program with its own arguments, without a shell.
+ *
+ * A forked verifier is spawned this way: arguments reach the child verbatim, so a prompt can never be
+ * re-read as shell syntax.
+ * @param file - Program to run.
+ * @param args - Arguments, passed verbatim.
+ * @param options - Directory, environment, cancellation and the line sink.
+ * @returns How the program ended.
+ */
+export declare function runProcess(file: string, args: readonly string[], options: ShellRunOptions): Promise<ShellExit>;

package/dist/shell/runner.js

@@ -2,7 +2,8 @@
  *
  * `!cmd` executes on the machine this client runs on — the operator's laptop or a jump host — never
  * on the host the agent works in. The host's shell belongs to the model's own tools; this module is
- * a separate, local facility, and it is the only place in `src/` allowed to spawn a process.
+ * a separate, local facility, and it is the only place in `src/` allowed to spawn a process — including
+ * the `dsht` child that verifies a scored round in a session of its own.
  */
 import { spawn } from 'node:child_process';
 /** Longest single output line kept while it is still being assembled. */
@@ -45,15 +46,55 @@ function signalGroup(child, signal) {
  * @returns How the command ended.
  */
 export function runShell(command, options) {
+    return spawnLines(shellPath(), ['-c', command], options);
+}
+/** Run one program with its own arguments, without a shell.
+ *
+ * A forked verifier is spawned this way: arguments reach the child verbatim, so a prompt can never be
+ * re-read as shell syntax.
+ * @param file - Program to run.
+ * @param args - Arguments, passed verbatim.
+ * @param options - Directory, environment, cancellation and the line sink.
+ * @returns How the program ended.
+ */
+export function runProcess(file, args, options) {
+    return spawnLines(file, [...args], options);
+}
+/** Spawn one program, merge both pipes into a single line stream, and resolve when it closes.
+ * @param file - Program to run.
+ * @param args - Arguments, passed verbatim.
+ * @param options - Directory, environment, cancellation and the line sink.
+ * @returns How the program ended.
+ */
+function spawnLines(file, args, options) {
     return new Promise(resolve => {
-        const child = spawn(shellPath(), ['-c', command], {
+        // Nothing to cancel yet: never spawn a process the caller already abandoned.
+        if (options.signal.aborted) {
+            resolve({ code: null, signal: 'SIGTERM' });
+            return;
+        }
+        const child = spawn(file, [...args], {
             cwd: options.cwd, env: options.env, detached: true, stdio: ['ignore', 'pipe', 'pipe'],
         });
         const carry = { stdout: '', stderr: '' };
         const discarding = { stdout: false, stderr: false };
         let settled = false;
         let graceTimer;
-        /** Emit one assembled line, keeping the partial remainder for the next chunk. */
+        /** Emit one assembled line, truncated to the budget.
+         *
+         * The bound is applied to every emitted line, not only to a partial remainder that overflowed:
+         * pipe chunking decides whether one huge line arrives whole or in pieces, so a bound applied only
+         * to the remainder would make the client's memory depend on the operating system's read size.
+         */
+        const emit = (line, stream) => {
+            if (discarding[stream]) {
+                discarding[stream] = false;
+                return;
+            }
+            const clean = line.replace(/\r$/, '');
+            options.onLine(clean.length > MAX_LINE_CHARS ? `${clean.slice(0, MAX_LINE_CHARS)}…` : clean, stream);
+        };
+        /** Split one chunk into lines, keeping the partial remainder for the next chunk. */
         const feed = (stream, chunk) => {
             carry[stream] += chunk;
             for (;;) {
@@ -62,12 +103,10 @@ export function runShell(command, options) {
                     break;
                 const line = carry[stream].slice(0, newline);
                 carry[stream] = carry[stream].slice(newline + 1);
-                if (discarding[stream])
-                    discarding[stream] = false;
-                else
-                    options.onLine(line.replace(/\r$/, ''), stream);
+                emit(line, stream);
             }
             if (carry[stream].length > MAX_LINE_CHARS) {
+                // No newline in sight: emit the head once and drop the rest of this line.
                 if (!discarding[stream]) {
                     options.onLine(`${carry[stream].slice(0, MAX_LINE_CHARS)}…`, stream);
                     discarding[stream] = true;
@@ -76,8 +115,8 @@ export function runShell(command, options) {
             }
         };
         const flush = (stream) => {
-            if (carry[stream] !== '' && !discarding[stream])
-                options.onLine(carry[stream].replace(/\r$/, ''), stream);
+            if (carry[stream] !== '')
+                emit(carry[stream], stream);
             carry[stream] = '';
         };
         const finish = (exit) => {

package/dist/slash/index.d.ts

@@ -0,0 +1,10 @@
+/** Slash-command domain: the command catalog, its syntax and the completion helpers.
+ *
+ * A pure leaf: it imports nothing from the application, the features or the UI.
+ */
+export { COMMAND_HINTS, COMMAND_LABELS, COMMAND_LABEL_WIDTH, COMMANDS, COMMAND_POLICY, argumentHint, commandMatches, commonPrefix, completeCommand, resolveCommand, suggestedCommands } from './registry.ts';
+export type { CommandHint, CommandPolicy } from './registry.ts';
+export { parseCommand, loopNameQuery, validLoopOption, LOOP_ABORT_USAGE, LOOP_ANSWER_USAGE, LOOP_STOP_USAGE, LOOP_USAGE } from './parse.ts';
+export type { Command, LoopOptions } from './types.ts';
+export { interpret, normalize, authorize } from './pipeline.ts';
+export type { AuthorizeFacts, DeferReason, ExecutableSubmission, InterpretFacts, LineCommand, NormalizeFacts, Submission, UiAction, Verdict } from './pipeline.ts';

package/dist/slash/index.js

@@ -0,0 +1,7 @@
+/** Slash-command domain: the command catalog, its syntax and the completion helpers.
+ *
+ * A pure leaf: it imports nothing from the application, the features or the UI.
+ */
+export { COMMAND_HINTS, COMMAND_LABELS, COMMAND_LABEL_WIDTH, COMMANDS, COMMAND_POLICY, argumentHint, commandMatches, commonPrefix, completeCommand, resolveCommand, suggestedCommands } from "./registry.js";
+export { parseCommand, loopNameQuery, validLoopOption, LOOP_ABORT_USAGE, LOOP_ANSWER_USAGE, LOOP_STOP_USAGE, LOOP_USAGE } from "./parse.js";
+export { interpret, normalize, authorize } from "./pipeline.js";

package/dist/slash/parse.d.ts

@@ -0,0 +1,42 @@
+import type { Command } from './types.ts';
+export type { Command, LoopOptions } from './types.ts';
+/** The numeric options a flag can carry; `vars` is not one, so it stays out of the flag table. */
+type LoopNumberOption = 'from' | 'to' | 'score' | 'tries';
+/** Whether one numeric value is acceptable for one loop option.
+ *
+ * The command line and the interactive form share this rule, so a value the form accepts is exactly
+ * one the syntax would have accepted if it had been typed.
+ * @param key - Option being set.
+ * @param value - Candidate number.
+ * @returns True when the option may carry that value.
+ */
+export declare function validLoopOption(key: LoopNumberOption, value: number): boolean;
+/** The record name the composer is currently typing after `/loop`, if any.
+ *
+ * The loop-name menu appears while the line is `/loop` or `/loop <one unfinished token>`; a second
+ * token means the operator moved on to the flags, so the menu stays out of the way. A trailing space
+ * after a complete name still counts: the menu then confirms that name rather than filtering it out.
+ * @param line - Composer draft exactly as typed.
+ * @returns The unfinished name (empty when none was started), or undefined for any other line.
+ */
+export declare function loopNameQuery(line: string): string | undefined;
+/** The one message every malformed `/loop` line receives. */
+export declare const LOOP_USAGE = "Use /loop <name> [score] [tries] [--from N] [--to N] [--score X] [--tries N]";
+/** The one message a malformed `/loop stop` line receives. */
+export declare const LOOP_STOP_USAGE = "Use /loop stop (no arguments)";
+/** The one message a `/loop answer` line without an answer receives. */
+export declare const LOOP_ANSWER_USAGE = "Use /loop answer <text>";
+/** The one message a malformed `/loop abort` line receives. */
+export declare const LOOP_ABORT_USAGE = "Use /loop abort (no arguments)";
+/** Parse one composer line into a command without performing any of its effects.
+ *
+ * The order of the checks is the command precedence: the in-place panels, navigation and removal,
+ * then the session and host commands, then a plain prompt. Facts about the current screen or a
+ * pending interaction are deliberately absent: they decide whether a command may run, not what it is.
+ *
+ * A leading token that names exactly one command is resolved first, so `/pro Add tests` runs
+ * `/prompt Add tests`; an ambiguous token is left alone and reported with its candidates.
+ * @param line - Draft exactly as submitted.
+ * @returns The parsed command.
+ */
+export declare function parseCommand(line: string): Command;