@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/status.js

@@ -0,0 +1,435 @@
+/**
+ * Keyed status contributions above the prompt.
+ *
+ * `set(key, text)` remains pi's scalar `ctx.ui.setStatus` seam: the host
+ * sanitizes and joins every text contribution into one line. `registerView`
+ * is the bounded rich companion for compact, pointer-only surfaces that need
+ * host React and themed cells (for example a progress card). It deliberately
+ * receives no input, channel, or raw-terminal capability.
+ *
+ * Same split as the dialogs seam: a cordis-free store the chat screen
+ * subscribes to, and a thin cordis service validating untrusted input.
+ */
+import { Service } from '@deepseek-ai/cordis';
+import { cleanScalarText } from './sanitize.js';
+import { activationFiber, assertCallerContext, bindCallerEffect, compositionRoot, concreteService, requirePluginCaller } from './host-access.js';
+import { componentIdentityOf } from './component-identity.js';
+import { assertCapabilityShadowPolicy, } from '../adapter/kernel/runtime.js';
+import { adapterRuntimeFor } from '../adapter/kernel/runtime-context.js';
+// Colon-separated segments are the documented namespacing convention
+// (`plugin:sub-item`); each segment stays a lowercase slug.
+const KEY_PATTERN = /^[a-z][a-z0-9_-]*(:[a-z][a-z0-9_-]*)*$/u;
+const TEXT_CELLS = 200;
+const MAX_ENTRIES = 20;
+const MAX_VIEW_ROWS = 3;
+const MAX_VIEW_ROW_BUDGET = 6;
+const HOST_STATUS_OWNER = Object.freeze({ kind: 'host-status-owner' });
+/** Cordis-free text + view store. Render order is first-set/register order
+ * (Map insertion order), so plugin contributions do not jump on updates. */
+export class TuiStatusStore {
+    onViewError;
+    listeners = new Set();
+    // Each write carries a token: a disposer compares TOKENS, not text —
+    // value comparison has an ABA hole (set 'x', set 'x' again, the first
+    // disposer would wipe the second write, e.g. a hot reload restoring the
+    // same status text).
+    entries = new Map();
+    views = new Map();
+    // useSyncExternalStore requires a referentially stable snapshot between
+    // emits — a fresh array per call would re-render in an infinite loop.
+    snapshot = [];
+    viewSnapshot = [];
+    constructor(onViewError) {
+        this.onViewError = onViewError;
+    }
+    /** Set or clear (undefined/empty) one key. */
+    set(key, text, token = 0, owner = HOST_STATUS_OWNER) {
+        const had = this.entries.has(key);
+        if (text === undefined || text === '') {
+            if (!had)
+                return;
+            this.entries.delete(key);
+        }
+        else {
+            const existing = this.entries.get(key);
+            if (existing?.text === text) {
+                // Same text, new write: adopt the new token so the newest disposer
+                // is the one that owns the line (no re-emit — nothing visible changed).
+                existing.token = token;
+                return;
+            }
+            this.entries.set(key, { text, token, owner });
+        }
+        this.snapshot = [...this.entries].map(([entryKey, entry]) => ({ key: entryKey, text: entry.text }));
+        this.emit();
+    }
+    /** Current contributions, first-set first (stable between changes). */
+    getSnapshot() {
+        return this.snapshot;
+    }
+    /** Current rich contributions, first-registration first and referentially
+     * stable between mutations for `useSyncExternalStore`. */
+    getViewSnapshot() {
+        return this.viewSnapshot;
+    }
+    /** Host runtime uses this to enforce that one activation cannot rewrite or
+     * clear another activation's keyed contribution. */
+    ownerOf(key) {
+        return this.entries.get(key)?.owner;
+    }
+    viewOwnerOf(key) {
+        return this.views.get(key)?.owner;
+    }
+    addView(view, token, owner) {
+        this.views.set(view.key, { view, token, owner });
+        this.viewSnapshot = [...this.views.values()].map(entry => entry.view);
+        this.emit();
+    }
+    clearViewIf(key, token, owner) {
+        const current = this.views.get(key);
+        if (owner !== undefined && current?.owner !== owner)
+            return false;
+        if (current?.token !== token)
+            return false;
+        this.views.delete(key);
+        this.viewSnapshot = [...this.views.values()].map(entry => entry.view);
+        this.emit();
+        return true;
+    }
+    /** Called only by the host-side error boundary. */
+    reportViewError(key, error) {
+        this.onViewError?.(key, error);
+    }
+    /** Clear `key` only while it still holds the write tagged `token` — a
+     *  stale disposer must not wipe a newer contribution (even one with
+     *  identical text). Returns true when this call actually cleared. */
+    clearIf(key, token, owner) {
+        if (owner !== undefined && this.entries.get(key)?.owner !== owner)
+            return false;
+        if (this.entries.get(key)?.token !== token)
+            return false;
+        this.entries.delete(key);
+        this.snapshot = [...this.entries].map(([entryKey, entry]) => ({ key: entryKey, text: entry.text }));
+        this.emit();
+        return true;
+    }
+    /** Drop everything (teardown). */
+    clear() {
+        if (this.entries.size === 0 && this.views.size === 0)
+            return;
+        this.entries.clear();
+        this.views.clear();
+        this.snapshot = [];
+        this.viewSnapshot = [];
+        this.emit();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+/**
+ * `ctx.tuiStatus` — plugin-facing status contributions. Invalid keys and
+ * oversized text are rejected with a logger warning instead of throwing:
+ * a status contribution must never take the TUI down.
+ */
+export class TuiStatusRuntime extends Service {
+    constructor(ctx) {
+        super(ctx, 'tuiStatus');
+        compositionRoot(ctx);
+        // Keep host state out of the traceable service object. A WeakMap also
+        // works with Cordis's caller-bound method proxy (unlike `#private`).
+        const state = {
+            store: new TuiStatusStore((key, error) => {
+                ctx.logger.warn(`dsh-tui: status view "${key}" crashed and was hidden: %o`, error);
+            }),
+            nextToken: 1,
+            runtime: adapterRuntimeFor(ctx),
+        };
+        hostStatusStores.set(this, state);
+        ctx.effect(() => () => state.store.clear());
+    }
+    /**
+     * Set (or clear with `undefined`) the contribution for `key`. Keys are
+     * plugin-namespaced by convention (`my-plugin`, `my-plugin:detail`);
+     * control chars are stripped and text is capped at 200 cells. Text is
+     * scalar-only: string/number/boolean are coerced to string, anything else
+     * is refused with a warning (never rendered as "[object Object]", never
+     * silently treated as a clear).
+     *
+     * Returns a disposer that clears the contribution IF the key still holds
+     * exactly this write (a later set — even of identical text — wins over a
+     * stale disposer). The host also removes that disposer from the caller's
+     * Cordis effect list when it is invoked explicitly. Clearing with
+     * `undefined` or empty text happens immediately and returns a no-op without
+     * registering an owner effect.
+     *
+     * The optional trailing `identity` (the plugin's own ctx) only feeds the
+     * effect ledger's pluginId — omitting it records `undeclared`, never a
+     * guess (C-060 honest identity).
+     */
+    set(key, text, identity) {
+        assertCapabilityShadowPolicy('host.status.set', statusStateFor(this).runtime.mode, statusStateFor(this).runtime.slices);
+        const noop = () => { };
+        let caller;
+        try {
+            caller = requirePluginCaller(this.ctx, 'tuiStatus.set', this);
+        }
+        catch {
+            this.ctx.logger.warn('dsh-tui: tuiStatus.set requires a live non-root plugin activation');
+            return noop;
+        }
+        const state = statusStateFor(this);
+        const store = state.store;
+        const callerIdentity = componentIdentityOf(caller);
+        const suppliedIdentity = identity === undefined ? callerIdentity : componentIdentityOf(identity);
+        if (identity !== undefined) {
+            try {
+                assertCallerContext(caller, identity, 'tuiStatus.set');
+            }
+            catch {
+                caller.logger.warn('dsh-tui: tuiStatus.set rejected an identity belonging to another activation');
+                return noop;
+            }
+        }
+        const owner = activationFiber(caller);
+        if (owner === undefined) {
+            caller.logger.warn('dsh-tui: tuiStatus.set requires a live activation owner');
+            return noop;
+        }
+        let normalized;
+        try {
+            normalized = String(key ?? '').trim().toLowerCase();
+        }
+        catch {
+            caller.logger.warn('dsh-tui: tuiStatus.set rejected an uncoercible key');
+            return noop;
+        }
+        if (!KEY_PATTERN.test(normalized)) {
+            caller.logger.warn('dsh-tui: tuiStatus.set rejected an invalid key');
+            return noop;
+        }
+        if (text !== undefined && !store.getSnapshot().some(e => e.key === normalized)) {
+            // New key beyond the cap: the line is one row of terminal — an
+            // unbounded count would push the prompt off screen.
+            if (store.getSnapshot().length >= MAX_ENTRIES) {
+                caller.logger.warn(`dsh-tui: tuiStatus.set rejected "${normalized}": ${MAX_ENTRIES} contributions already shown`);
+                return noop;
+            }
+        }
+        let cleaned;
+        if (text !== undefined) {
+            // Scalar-only coercion (Track A contract): a non-scalar text (an
+            // object would otherwise render as "[object Object]") is REFUSED with
+            // a warning — it must not silently become a clear, either.
+            if (typeof text !== 'string' && typeof text !== 'number' && typeof text !== 'boolean') {
+                caller.logger.warn(`dsh-tui: tuiStatus.set rejected non-scalar text for "${normalized}"`);
+                return noop;
+            }
+            cleaned = cleanScalarText(text, TEXT_CELLS);
+        }
+        if (cleaned !== undefined && store.viewOwnerOf(normalized) !== undefined) {
+            caller.logger.warn(`dsh-tui: tuiStatus.set rejected "${normalized}" — the key already owns a rich view`);
+            return noop;
+        }
+        const had = store.getSnapshot().some(entry => entry.key === normalized);
+        if (store.ownerOf(normalized) !== undefined && store.ownerOf(normalized) !== owner) {
+            caller.logger.warn(`dsh-tui: tuiStatus.set rejected "${normalized}" — the contribution belongs to another activation`);
+            return noop;
+        }
+        const ledger = caller.get('tuiEffectLedger');
+        if (cleaned === undefined || cleaned === '') {
+            store.set(normalized, undefined, 0, owner);
+            if (had)
+                ledger?.record({ operation: 'release', resource: { kind: 'status', id: normalized }, result: 'applied' }, identity);
+            return noop;
+        }
+        const token = state.nextToken++;
+        store.set(normalized, cleaned, token, owner);
+        let disposed = false;
+        let ledgerApplied = false;
+        let ownerCleanup;
+        const dispose = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            if (store.clearIf(normalized, token, owner) && ledgerApplied) {
+                caller.get('tuiEffectLedger')?.record({ operation: 'release', resource: { kind: 'status', id: normalized }, result: 'applied' }, identity);
+            }
+            const cleanup = ownerCleanup;
+            ownerCleanup = undefined;
+            cleanup?.();
+        };
+        const bound = bindCallerEffect(caller, dispose, cleanup => {
+            ownerCleanup = cleanup;
+        });
+        if (!bound)
+            return noop;
+        ledger?.record({
+            operation: had ? 'replace' : 'bind',
+            resource: { kind: 'status', id: normalized },
+            result: 'applied',
+            ...(had ? { replaces: { resourceId: normalized } } : {}),
+        }, identity);
+        ledgerApplied = true;
+        return dispose;
+    }
+    /**
+     * Register a compact React view above the prompt. The component receives
+     * the host's React plus a pointer-only UI kit; it owns its live data via an
+     * external store and is clipped by the host to `maxRows` (one by default,
+     * three at most). Registrations share the text key namespace, preserve
+     * first-registration order, and consume a six-row aggregate budget.
+     *
+     * Successful registrations return a cleanup-aware disposer. Refused
+     * registrations warn and return `undefined`, so feature-detecting callers
+     * can distinguish admission from rejection. The optional identity has the
+     * same attribution-only meaning as `set()`.
+     */
+    registerView(descriptor, identity) {
+        assertCapabilityShadowPolicy('host.status.register-view', statusStateFor(this).runtime.mode, statusStateFor(this).runtime.slices);
+        let caller;
+        try {
+            caller = requirePluginCaller(this.ctx, 'tuiStatus.registerView', this);
+        }
+        catch {
+            this.ctx.logger.warn('dsh-tui: tuiStatus.registerView requires a live non-root plugin activation');
+            return undefined;
+        }
+        if (identity !== undefined) {
+            try {
+                assertCallerContext(caller, identity, 'tuiStatus.registerView');
+            }
+            catch {
+                caller.logger.warn('dsh-tui: tuiStatus.registerView rejected an identity belonging to another activation');
+                return undefined;
+            }
+        }
+        const owner = activationFiber(caller);
+        if (owner === undefined) {
+            caller.logger.warn('dsh-tui: tuiStatus.registerView requires a live activation owner');
+            return undefined;
+        }
+        if (typeof descriptor !== 'object' || descriptor === null || Array.isArray(descriptor)) {
+            caller.logger.warn('dsh-tui: tuiStatus.registerView rejected an invalid descriptor');
+            return undefined;
+        }
+        const raw = descriptor;
+        let normalized;
+        try {
+            normalized = String(raw.key ?? '').trim().toLowerCase();
+        }
+        catch {
+            caller.logger.warn('dsh-tui: tuiStatus.registerView rejected an uncoercible key');
+            return undefined;
+        }
+        if (!KEY_PATTERN.test(normalized)) {
+            caller.logger.warn('dsh-tui: tuiStatus.registerView rejected an invalid key');
+            return undefined;
+        }
+        const maxRows = raw.maxRows ?? 1;
+        if (typeof maxRows !== 'number' || !Number.isInteger(maxRows) || maxRows < 1 || maxRows > MAX_VIEW_ROWS) {
+            caller.logger.warn(`dsh-tui: tuiStatus.registerView rejected "${normalized}" — maxRows must be an integer from 1 to ${MAX_VIEW_ROWS}`);
+            return undefined;
+        }
+        if (typeof raw.component !== 'function') {
+            caller.logger.warn(`dsh-tui: tuiStatus.registerView rejected "${normalized}" — component must be a function`);
+            return undefined;
+        }
+        const state = statusStateFor(this);
+        const store = state.store;
+        if (store.ownerOf(normalized) !== undefined || store.viewOwnerOf(normalized) !== undefined) {
+            caller.logger.warn(`dsh-tui: tuiStatus.registerView rejected "${normalized}" — the key is already registered`);
+            caller.get('tuiEffectLedger')?.record({
+                operation: 'bind',
+                resource: { kind: 'status', id: normalized },
+                result: 'failed',
+                errorCode: 'DUPLICATE_CONTRIBUTION_ID',
+            }, identity);
+            return undefined;
+        }
+        const requestedRows = store.getViewSnapshot().reduce((rows, view) => rows + view.maxRows, maxRows);
+        if (requestedRows > MAX_VIEW_ROW_BUDGET) {
+            caller.logger.warn(`dsh-tui: tuiStatus.registerView rejected "${normalized}" — rich status views are limited to ${MAX_VIEW_ROW_BUDGET} rows total`);
+            return undefined;
+        }
+        const token = state.nextToken++;
+        const view = Object.freeze({
+            key: normalized,
+            maxRows: maxRows,
+            component: raw.component,
+            registrationId: token,
+        });
+        store.addView(view, token, owner);
+        let disposed = false;
+        let ledgerApplied = false;
+        let ownerCleanup;
+        const dispose = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            if (store.clearViewIf(normalized, token, owner) && ledgerApplied) {
+                caller.get('tuiEffectLedger')?.record({ operation: 'release', resource: { kind: 'status', id: normalized }, result: 'applied' }, identity);
+            }
+            const cleanup = ownerCleanup;
+            ownerCleanup = undefined;
+            cleanup?.();
+        };
+        const bound = bindCallerEffect(caller, dispose, cleanup => {
+            ownerCleanup = cleanup;
+        });
+        if (!bound)
+            return undefined;
+        caller.get('tuiEffectLedger')?.record({ operation: 'bind', resource: { kind: 'status', id: normalized }, result: 'applied' }, identity);
+        ledgerApplied = true;
+        return dispose;
+    }
+    /**
+     * Subscribe to status-line changes. Kept on the plugin-visible service so
+     * the shadow-policy gate covers this subscription effect too.
+     */
+    subscribe(listener) {
+        assertCapabilityShadowPolicy('host.status.subscribe', statusStateFor(this).runtime.mode, statusStateFor(this).runtime.slices);
+        const caller = requirePluginCaller(this.ctx, 'tuiStatus.subscribe', this);
+        const owner = activationFiber(caller);
+        if (owner === undefined)
+            return () => { };
+        if (typeof listener !== 'function')
+            return () => { };
+        const wrapped = () => {
+            try {
+                listener();
+            }
+            catch (error) {
+                caller.logger.warn(`dsh-tui: tuiStatus listener failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        };
+        const dispose = statusStateFor(this).store.subscribe(wrapped);
+        bindCallerEffect(caller, dispose);
+        return dispose;
+    }
+}
+const hostStatusStores = new WeakMap();
+function statusStateFor(runtime) {
+    const store = hostStatusStores.get(concreteService(runtime));
+    if (store === undefined)
+        throw new Error('tuiStatus host store is unavailable');
+    return store;
+}
+export function getHostStatusStore(runtime) {
+    if (runtime === undefined)
+        return undefined;
+    try {
+        return hostStatusStores.get(concreteService(runtime))?.store;
+    }
+    catch {
+        return undefined;
+    }
+}
+export default TuiStatusRuntime;

package/lib/types/dsh-adapter/subagents.d.ts

@@ -0,0 +1,64 @@
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
+import type { SubagentState, SubagentOutputKind, SubagentToolCall } from '../adapter/ports/channel-view.js';
+export type { SubagentState, SubagentStatus, SubagentOutputLine, SubagentOutputKind, SubagentToolCall, SubagentTokenUsage } from '../adapter/ports/channel-view.js';
+export declare class SubagentActivityStore {
+    private states;
+    private sessionToAgent;
+    private listeners;
+    private streams;
+    private commitLine;
+    private pushLine;
+    onSpawned(agentId: string, provider?: string, model?: string, info?: Partial<SubagentState>): void;
+    /** Durable discovery (`subagent/catalog`, workflow member events, registry
+     * back-fill): register a child WITHOUT disturbing an already-tracked run.
+     * `live` marks a child the agents registry currently holds, which keeps the
+     * row running; an idle historical child shows as `unknown` (the parent log
+     * alone cannot prove how its last epoch ended). */
+    onDiscovered(agentId: string, info?: {
+        label?: string;
+        childCreatedAt?: number;
+        live?: boolean;
+        provider?: string;
+        model?: string;
+    }): void;
+    linkSession(agentId: string, session: unknown): void;
+    getSubagentIdBySession(session: unknown): string | undefined;
+    has(agentId: string): boolean;
+    appendOutput(agentId: string, text: string, kind?: SubagentOutputKind): void;
+    /** Mark the streaming tail line complete (run settlement). */
+    flushOutput(agentId: string): void;
+    /** 0.1.5 live stream: transient attempt frames replace `assistant/chunk`
+     *  session events (the durable settlement keeps flowing as session events). */
+    onStreamFrame(agentId: string, frame: AssistantStreamFrame): void;
+    private restoreAttempt;
+    private settleAssistant;
+    onSessionEvent(agentId: string, event: unknown): void;
+    /** Merge partial updates (model discovery, session id) into one subagent. */
+    patch(agentId: string, partial: Partial<SubagentState>): void;
+    /** One-line preview of a tool-result content block (text or item list). */
+    private previewOf;
+    recordTool(agentId: string, input: Partial<SubagentToolCall> & {
+        name?: string;
+    }): void;
+    setTokens(agentId: string, usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        input?: number;
+        output?: number;
+        total?: number;
+        context?: number;
+    }): void;
+    onCompleted(agentId: string, summary?: string, stopReason?: string, endedAt?: number): void;
+    onFailed(agentId: string, error: string, endedAt?: number): void;
+    onCancelled(agentId: string, reason?: string, summary?: string, endedAt?: number): void;
+    private finish;
+    /** Drop all tracked subagents and session links (session swap: the old
+     * session's children were disposed with their parent — nothing may keep
+     * routing events of a session the channel no longer projects). */
+    reset(): void;
+    snapshot(): SubagentState[];
+    get(agentId: string): SubagentState | undefined;
+    subscribe(listener: () => void): () => void;
+    private notify;
+}
+//# sourceMappingURL=subagents.d.ts.map

package/lib/types/dsh-adapter/subagents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/subagents.ts"],"names":[],"mappings":"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"}