@deepseek-harness-tui/dsh-tui 0.8.1 → 0.8.2

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

@@ -7,211 +7,328 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { basename, isAbsolute, resolve } from 'node:path';
 import { Service } from '@deepseek-ai/cordis';
+import { activationFiber, bindCallerEffect, compositionRoot, concreteService, requirePluginCaller } from './host-access.js';
 export const name = 'dsh-tui-workspaces';
+/** Bound every provider promise so one plugin cannot park workspace flows. */
+export const WORKSPACE_PROVIDER_TIMEOUT_MS = 2000;
+async function providerWithBudget(task, signal, timeoutMs = WORKSPACE_PROVIDER_TIMEOUT_MS) {
+    signal?.throwIfAborted();
+    let timer;
+    const work = Promise.resolve().then(task);
+    const timeout = new Promise(resolveTimeout => {
+        timer = setTimeout(() => resolveTimeout(undefined), timeoutMs);
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 /** Registry and local fallback shared by the TUI and workspace plugins. */
 export class TuiWorkspaceRuntime extends Service {
-    providers = new Set();
-    providerWaiters = new Set();
     constructor(ctx) {
         super(ctx, 'tuiWorkspaces');
+        const runtime = this;
+        const state = {
+            hostContext: compositionRoot(ctx),
+            providers: new Set(),
+            providerOwners: new Map(),
+            providerWaiters: new Set(),
+            host: undefined,
+        };
+        state.host = Object.freeze({
+            list: (currentCwd, signal) => listWorkspaces(runtime, currentCwd, signal, undefined),
+            resolve: (reference, currentCwd, signal) => resolveWorkspace(runtime, reference, currentCwd ?? process.cwd(), signal, undefined),
+            describe: (cwd) => describeWorkspace(runtime, cwd, undefined),
+            commandShell: (cwd) => commandShellFor(runtime, cwd, undefined),
+            rename: (cwd, title) => renameWorkspace(runtime, cwd, title, undefined),
+            commands: () => workspaceCommands(runtime, undefined),
+            runCommand: (name, input, cwd, signal) => runWorkspaceCommand(runtime, name, input, cwd, signal, undefined),
+        });
+        workspaceStates.set(this, state);
     }
     register(provider) {
-        this.providers.add(provider);
+        const caller = requirePluginCaller(this.ctx, 'tuiWorkspaces.register', this);
+        const state = workspaceStateFor(this);
+        state.providers.add(provider);
+        const owner = activationFiber(caller);
+        if (owner === undefined) {
+            state.providers.delete(provider);
+            throw new Error('dsh-tui: tuiWorkspaces.register requires a live activation');
+        }
+        state.providerOwners.set(provider, owner);
         this.notifyProviderWaiters();
-        return () => {
-            this.providers.delete(provider);
+        const dispose = () => {
+            state.providers.delete(provider);
+            state.providerOwners.delete(provider);
             this.notifyProviderWaiters();
         };
+        bindCallerEffect(caller, dispose);
+        return dispose;
     }
     async list(currentCwd, signal) {
-        signal?.throwIfAborted();
-        const targets = new Map();
-        for (const provider of this.providers) {
-            try {
-                for (const target of await provider.list(signal))
-                    targets.set(target.uri, this.withStoredTitle(target));
-            }
-            catch (error) {
-                this.ctx.logger.warn(`dsh-tui: workspace provider list failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // The official registry is the durable catalog. Provider-owned aliases
-        // have already been added above with richer URI/badge metadata; remaining
-        // records are ordinary local workspaces.
-        for (const workspace of this.workspaceRegistry()?.list() ?? []) {
-            if ([...targets.values()].some(target => sameCwd(target.cwd, workspace.path)))
-                continue;
-            targets.set(localWorkspaceUri(workspace.path), {
-                ...localWorkspaceTarget(workspace.path),
-                label: workspace.title,
-            });
-        }
-        // The current local directory is always selectable, even in a bare TUI
-        // composition without dsh-workspace or another provider.
-        if (![...targets.values()].some(target => sameCwd(target.cwd, currentCwd))) {
-            const local = localWorkspaceTarget(currentCwd);
-            targets.set(local.uri, local);
-        }
-        return [...targets.values()].sort((left, right) => {
-            if (left.kind !== right.kind)
-                return left.kind === 'local' ? -1 : 1;
-            return left.label.localeCompare(right.label);
-        });
+        const owner = workspaceCaller(this, 'tuiWorkspaces.list');
+        return listWorkspaces(this, currentCwd, signal, owner);
     }
     /** Resolve a URI, briefly allowing concurrently mounted providers to register. */
     async resolve(reference, currentCwd = process.cwd(), signal) {
-        if (isAbsolute(reference))
-            return localWorkspaceTarget(reference);
-        const deadline = Date.now() + 5000;
-        const scheme = uriScheme(reference);
-        if (scheme === undefined) {
-            const owner = [...this.providers].find((provider) => {
-                try {
-                    return provider.describe(currentCwd) !== undefined;
-                }
-                catch {
-                    return false;
-                }
-            });
-            if (owner !== undefined)
-                return owner.resolvePath?.(reference, currentCwd, signal);
-            return localWorkspaceTarget(resolve(currentCwd, reference));
-        }
-        const local = parseLocalWorkspaceReference(reference);
-        if (local !== undefined)
-            return local;
-        for (;;) {
-            signal?.throwIfAborted();
-            const owners = [...this.providers].filter(provider => provider.schemes.some(candidate => candidate.toLowerCase() === scheme));
-            for (const provider of owners) {
-                const target = await provider.resolve(reference, signal);
-                if (target !== undefined)
-                    return target;
-            }
-            if (owners.length > 0)
-                return undefined;
-            if (Date.now() >= deadline)
-                return undefined;
-            await this.waitForProvider(Math.min(100, deadline - Date.now()), signal);
-        }
+        const owner = workspaceCaller(this, 'tuiWorkspaces.resolve');
+        return resolveWorkspace(this, reference, currentCwd, signal, owner);
     }
     describe(cwd) {
-        for (const provider of this.providers) {
-            let target;
-            try {
-                target = provider.describe(cwd);
-            }
-            catch (error) {
-                this.ctx.logger.warn(`dsh-tui: workspace provider describe failed: ${error instanceof Error ? error.message : String(error)}`);
-                continue;
-            }
-            if (target !== undefined)
-                return this.withStoredTitle(target);
-        }
-        return this.withStoredTitle(localWorkspaceTarget(cwd));
+        const owner = workspaceCaller(this, 'tuiWorkspaces.describe');
+        return describeWorkspace(this, cwd, owner);
     }
     async commandShell(cwd) {
-        for (const provider of this.providers) {
-            let shell;
-            try {
-                shell = await provider.commandShell?.(cwd);
-            }
-            catch (error) {
-                this.ctx.logger.warn(`dsh-tui: workspace provider commandShell failed: ${error instanceof Error ? error.message : String(error)}`);
+        const owner = workspaceCaller(this, 'tuiWorkspaces.commandShell');
+        return commandShellFor(this, cwd, owner);
+    }
+    async rename(cwd, title) {
+        const owner = workspaceCaller(this, 'tuiWorkspaces.rename');
+        return renameWorkspace(this, cwd, title, owner);
+    }
+    commands() {
+        const owner = workspaceCaller(this, 'tuiWorkspaces.commands');
+        return workspaceCommands(this, owner);
+    }
+    async runCommand(name, input, cwd, signal) {
+        const owner = workspaceCaller(this, 'tuiWorkspaces.runCommand');
+        return runWorkspaceCommand(this, name, input, cwd, signal, owner);
+    }
+    notifyProviderWaiters() {
+        const state = workspaceStateFor(this);
+        for (const waiter of state.providerWaiters)
+            waiter();
+        state.providerWaiters.clear();
+    }
+}
+const workspaceStates = new WeakMap();
+function workspaceStateFor(runtime) {
+    const state = workspaceStates.get(concreteService(runtime));
+    if (state === undefined)
+        throw new Error('tuiWorkspaces host state is unavailable');
+    return state;
+}
+/** Resolve the host-only facade for channel/plugin bootstrap code. */
+export function getHostWorkspaceRuntime(runtime) {
+    if (runtime === undefined)
+        return undefined;
+    try {
+        return workspaceStateFor(runtime).host;
+    }
+    catch {
+        return undefined;
+    }
+}
+function workspaceCaller(runtime, capability) {
+    const caller = requirePluginCaller(runtimeContext(runtime), capability, runtime);
+    const owner = activationFiber(caller);
+    if (owner === undefined)
+        throw new Error(`dsh-tui: ${capability} requires a live activation`);
+    return owner;
+}
+function runtimeContext(runtime) {
+    return runtime.ctx;
+}
+function providersFor(state, owner) {
+    if (owner === undefined)
+        return [...state.providers];
+    return [...state.providers].filter(provider => state.providerOwners.get(provider) === owner);
+}
+async function listWorkspaces(runtime, currentCwd, signal, owner) {
+    signal?.throwIfAborted();
+    const state = workspaceStateFor(runtime);
+    const targets = new Map();
+    for (const provider of providersFor(state, owner)) {
+        try {
+            const listed = await providerWithBudget(() => provider.list(signal), signal);
+            if (listed === undefined)
                 continue;
-            }
-            if (shell !== undefined)
-                return shell;
+            for (const target of listed)
+                targets.set(target.uri, withStoredTitle(runtime, target));
+        }
+        catch (error) {
+            runtimeContext(runtime).logger.warn(`dsh-tui: workspace provider list failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return undefined;
     }
-    async rename(cwd, title) {
-        const normalizedTitle = title.trim();
-        if (normalizedTitle.length === 0)
-            throw new Error('workspace title must not be empty');
-        for (const provider of this.providers) {
-            let owned = false;
+    for (const workspace of workspaceRegistry(runtime)?.list() ?? []) {
+        if ([...targets.values()].some(target => sameCwd(target.cwd, workspace.path)))
+            continue;
+        targets.set(localWorkspaceUri(workspace.path), {
+            ...localWorkspaceTarget(workspace.path),
+            label: workspace.title,
+        });
+    }
+    if (![...targets.values()].some(target => sameCwd(target.cwd, currentCwd))) {
+        const local = localWorkspaceTarget(currentCwd);
+        targets.set(local.uri, local);
+    }
+    return [...targets.values()].sort((left, right) => {
+        if (left.kind !== right.kind)
+            return left.kind === 'local' ? -1 : 1;
+        return left.label.localeCompare(right.label);
+    });
+}
+async function resolveWorkspace(runtime, reference, currentCwd, signal, owner) {
+    const state = workspaceStateFor(runtime);
+    const providers = () => providersFor(state, owner);
+    if (isAbsolute(reference))
+        return localWorkspaceTarget(reference);
+    const deadline = Date.now() + 5000;
+    const scheme = uriScheme(reference);
+    if (scheme === undefined) {
+        const provider = providers().find(candidate => {
             try {
-                owned = provider.describe(cwd) !== undefined;
+                return candidate.describe(currentCwd) !== undefined;
             }
             catch {
-                continue;
+                return false;
             }
-            if (!owned)
-                continue;
-            // A provider without rename (or returning undefined) falls through to
-            // the local durable ledger below — the title stays visible everywhere
-            // this runtime runs. A rename that THROWS propagates to the caller's
-            // failure notification instead of silently writing a local record.
-            const renamed = await provider.rename?.(cwd, normalizedTitle);
-            if (renamed !== undefined)
-                return this.withStoredTitle(renamed);
-            break;
+        });
+        if (provider !== undefined) {
+            return provider.resolvePath === undefined
+                ? undefined
+                : providerWithBudget(() => provider.resolvePath(reference, currentCwd, signal), signal);
         }
-        const registry = this.workspaceRegistry();
-        if (registry === undefined)
-            throw new Error('workspace registry is unavailable');
-        const workspace = registry.list().find(candidate => sameCwd(candidate.path, cwd))
-            ?? await registry.create(cwd, normalizedTitle);
-        await workspace.setTitle(normalizedTitle);
-        return { ...this.describe(cwd), label: normalizedTitle };
+        return localWorkspaceTarget(resolve(currentCwd, reference));
     }
-    commands() {
-        return [...this.providers].flatMap(provider => provider.commands ?? []).map(command => ({
-            name: command.name,
-            aliases: command.aliases,
-            description: command.description,
-        }));
+    const local = parseLocalWorkspaceReference(reference);
+    if (local !== undefined)
+        return local;
+    for (;;) {
+        signal?.throwIfAborted();
+        const owners = providers().filter(provider => provider.schemes.some(candidate => candidate.toLowerCase() === scheme));
+        for (const provider of owners) {
+            const target = await providerWithBudget(() => provider.resolve(reference, signal), signal, Math.max(1, deadline - Date.now()));
+            if (target !== undefined)
+                return target;
+        }
+        if (owners.length > 0)
+            return undefined;
+        if (Date.now() >= deadline)
+            return undefined;
+        await waitForProvider(runtime, Math.min(100, deadline - Date.now()), signal);
     }
-    async runCommand(name, input, cwd, signal) {
-        const normalized = name.toLowerCase();
-        for (const provider of this.providers) {
-            const command = provider.commands?.find(candidate => candidate.name.toLowerCase() === normalized
-                || candidate.aliases?.some(alias => alias.toLowerCase() === normalized));
-            if (command !== undefined)
-                return command.run(input, { cwd }, signal);
+}
+function describeWorkspace(runtime, cwd, owner) {
+    const state = workspaceStateFor(runtime);
+    for (const provider of providersFor(state, owner)) {
+        let target;
+        try {
+            target = provider.describe(cwd);
         }
-        return undefined;
+        catch (error) {
+            runtimeContext(runtime).logger.warn(`dsh-tui: workspace provider describe failed: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        if (target !== undefined)
+            return withStoredTitle(runtime, target);
     }
-    workspaceRegistry() {
-        return this.ctx.get('workspaceRegistry');
+    return withStoredTitle(runtime, localWorkspaceTarget(cwd));
+}
+async function commandShellFor(runtime, cwd, owner) {
+    const state = workspaceStateFor(runtime);
+    for (const provider of providersFor(state, owner)) {
+        let shell;
+        try {
+            shell = await providerWithBudget(() => provider.commandShell?.(cwd), undefined);
+        }
+        catch (error) {
+            runtimeContext(runtime).logger.warn(`dsh-tui: workspace provider commandShell failed: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        if (shell !== undefined)
+            return shell;
     }
-    withStoredTitle(target) {
-        const workspace = this.workspaceRegistry()?.list().find(candidate => sameCwd(candidate.path, target.cwd));
-        return workspace === undefined ? target : { ...target, label: workspace.title };
+    return undefined;
+}
+async function renameWorkspace(runtime, cwd, title, owner) {
+    const normalizedTitle = title.trim();
+    if (normalizedTitle.length === 0)
+        throw new Error('workspace title must not be empty');
+    const state = workspaceStateFor(runtime);
+    let providerOwned = false;
+    for (const provider of providersFor(state, owner)) {
+        let owned = false;
+        try {
+            owned = provider.describe(cwd) !== undefined;
+        }
+        catch {
+            continue;
+        }
+        if (!owned)
+            continue;
+        providerOwned = true;
+        const renamed = await providerWithBudget(() => provider.rename?.(cwd, normalizedTitle), undefined);
+        if (renamed !== undefined)
+            return withStoredTitle(runtime, renamed);
+        break;
     }
-    notifyProviderWaiters() {
-        for (const waiter of this.providerWaiters)
-            waiter();
-        this.providerWaiters.clear();
+    // A plugin may only mutate the durable title ledger for a workspace it
+    // owns. Host callers retain the historical local-registry behavior.
+    if (owner !== undefined && !providerOwned) {
+        throw new Error('workspace is not owned by the calling activation');
     }
-    waitForProvider(timeoutMs, signal) {
-        if (timeoutMs <= 0)
-            return Promise.resolve();
-        return new Promise((resolveWait, reject) => {
-            let settled = false;
-            const finish = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                signal?.removeEventListener('abort', abort);
-                this.providerWaiters.delete(finish);
-                resolveWait();
-            };
-            const abort = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                this.providerWaiters.delete(finish);
-                reject(signal?.reason instanceof Error ? signal.reason : new Error('workspace resolution aborted'));
-            };
-            const timer = setTimeout(finish, timeoutMs);
-            this.providerWaiters.add(finish);
-            signal?.addEventListener('abort', abort, { once: true });
-        });
+    const registry = workspaceRegistry(runtime);
+    if (registry === undefined)
+        throw new Error('workspace registry is unavailable');
+    const workspace = registry.list().find(candidate => sameCwd(candidate.path, cwd))
+        ?? await registry.create(cwd, normalizedTitle);
+    await workspace.setTitle(normalizedTitle);
+    return { ...describeWorkspace(runtime, cwd, owner), label: normalizedTitle };
+}
+function workspaceCommands(runtime, owner) {
+    return providersFor(workspaceStateFor(runtime), owner).flatMap(provider => provider.commands ?? []).map(command => ({
+        name: command.name,
+        aliases: command.aliases,
+        description: command.description,
+    }));
+}
+async function runWorkspaceCommand(runtime, name, input, cwd, signal, owner) {
+    const normalized = name.toLowerCase();
+    for (const provider of providersFor(workspaceStateFor(runtime), owner)) {
+        const command = provider.commands?.find(candidate => candidate.name.toLowerCase() === normalized
+            || candidate.aliases?.some(alias => alias.toLowerCase() === normalized));
+        if (command !== undefined)
+            return providerWithBudget(() => command.run(input, { cwd }, signal), signal);
     }
+    return undefined;
+}
+function workspaceRegistry(runtime) {
+    return workspaceStateFor(runtime).hostContext.get('workspaceRegistry');
+}
+function withStoredTitle(runtime, target) {
+    const workspace = workspaceRegistry(runtime)?.list().find(candidate => sameCwd(candidate.path, target.cwd));
+    return workspace === undefined ? target : { ...target, label: workspace.title };
+}
+function waitForProvider(runtime, timeoutMs, signal) {
+    if (timeoutMs <= 0)
+        return Promise.resolve();
+    return new Promise((resolveWait, reject) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            workspaceStateFor(runtime).providerWaiters.delete(finish);
+            resolveWait();
+        };
+        const abort = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            workspaceStateFor(runtime).providerWaiters.delete(finish);
+            reject(signal?.reason instanceof Error ? signal.reason : new Error('workspace resolution aborted'));
+        };
+        const timer = setTimeout(finish, timeoutMs);
+        workspaceStateFor(runtime).providerWaiters.add(finish);
+        signal?.addEventListener('abort', abort, { once: true });
+    });
 }
 /** Local-only fallback for direct embedders that call createChannel() without
  * mounting the optional workspace registry/provider service. */

package/lib/types/extensions.d.ts

@@ -1,8 +1,13 @@
 export * from './dsh-adapter/extensions.js';
-export * from './dsh-adapter/extension-events.js';
-export * from './dsh-adapter/dialogs.js';
-export * from './dsh-adapter/status.js';
-export * from './dsh-adapter/shortcuts.js';
-export * from './dsh-adapter/renderers.js';
+export { DECISION_HANDLER_TIMEOUT_MS, DECISION_TOTAL_TIMEOUT_MS, normalizeCancelDecision, } from './dsh-adapter/extension-events.js';
+export type { TuiDecisionContext, TuiInputEvent, TuiInputDecision, TuiRewindPromptEvent, TuiRewindMode, TuiRewindPromptDecision, TuiRewindDoneEvent, TuiSessionSwitchEvent, TuiSessionSwitchDecision, TuiSessionSwitchedEvent, TuiCompactEvent, TuiCompactDecision, } from './dsh-adapter/extension-events.js';
+export { DIALOG_DEFAULT_TIMEOUT_MS, INPUT_CELLS, TuiDialogRuntime, TuiDialogStore, } from './dsh-adapter/dialogs.js';
+export type { TuiDialogAnswer, TuiDialogBase, TuiDialogConfirmRequest, TuiDialogInputRequest, TuiDialogSelectOption, TuiDialogSelectRequest, TuiDialogSnapshot, } from './dsh-adapter/dialogs.js';
+export { TuiStatusRuntime, TuiStatusStore } from './dsh-adapter/status.js';
+export type { TuiStatusEntry } from './dsh-adapter/status.js';
+export { matchShortcut, parseShortcutCombo, TuiShortcutRuntime } from './dsh-adapter/shortcuts.js';
+export type { TuiShortcutKey, TuiShortcutOptions } from './dsh-adapter/shortcuts.js';
+export { TuiRendererRuntime } from './dsh-adapter/renderers.js';
+export type { TuiEntryRenderer, TuiEntryRenderResult } from './dsh-adapter/renderers.js';
 export { DECISION_EVENT_PERMISSIONS } from './dsh-adapter/decision-guard.js';
 //# sourceMappingURL=extensions.d.ts.map

package/lib/types/extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../src/extensions.ts"],"names":[],"mappings":"AAMA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAG1C,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../src/extensions.ts"],"names":[],"mappings":"AAMA,cAAc,6BAA6B,CAAA;AAI3C,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,mCAAmC,CAAA;AAC1C,YAAY,EACV,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,eAAe,EACf,kBAAkB,GACnB,MAAM,mCAAmC,CAAA;AAI1C,OAAO,EACL,yBAAyB,EACzB,WAAW,EACX,gBAAgB,EAChB,cAAc,GACf,MAAM,0BAA0B,CAAA;AACjC,YAAY,EACV,eAAe,EACf,aAAa,EACb,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC1E,YAAY,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAClG,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAC/D,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAGxF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA"}

package/lib/types/extensions.js

@@ -5,11 +5,17 @@
 // applies the `declare module '@deepseek-ai/cordis'` augmentation for the
 // decision events and the four service properties on Context.
 export * from './dsh-adapter/extensions.js';
-export * from './dsh-adapter/extension-events.js';
-export * from './dsh-adapter/dialogs.js';
-export * from './dsh-adapter/status.js';
-export * from './dsh-adapter/shortcuts.js';
-export * from './dsh-adapter/renderers.js';
+// Decision dispatch is a host/channel operation.  Export only the event
+// vocabulary and safe normalizers; dispatching an arbitrary payload through
+// this module would let a plugin trigger every other plugin's handlers.
+export { DECISION_HANDLER_TIMEOUT_MS, DECISION_TOTAL_TIMEOUT_MS, normalizeCancelDecision, } from './dsh-adapter/extension-events.js';
+// Keep host accessors out of the plugin-facing export. The implementation
+// modules expose them only so the TUI host can wire Chat/channel; exporting
+// them here would let a plugin recover the private queue/store/dispatcher.
+export { DIALOG_DEFAULT_TIMEOUT_MS, INPUT_CELLS, TuiDialogRuntime, TuiDialogStore, } from './dsh-adapter/dialogs.js';
+export { TuiStatusRuntime, TuiStatusStore } from './dsh-adapter/status.js';
+export { matchShortcut, parseShortcutCombo, TuiShortcutRuntime } from './dsh-adapter/shortcuts.js';
+export { TuiRendererRuntime } from './dsh-adapter/renderers.js';
 // The D-7 permission vocabulary (which grant each decision event needs) is
 // part of the plugin-facing contract too.
 export { DECISION_EVENT_PERMISSIONS } from './dsh-adapter/decision-guard.js';

package/lib/types/force-production-react.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=force-production-react.d.ts.map

package/lib/types/force-production-react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"force-production-react.d.ts","sourceRoot":"","sources":["../../src/force-production-react.ts"],"names":[],"mappings":""}

package/lib/types/force-production-react.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * React-reconciler selects its dev/production build at require time from
+ * NODE_ENV; the dev build records one performance.measure() per render into
+ * an unbounded buffer — the 4 GB long-session OOM (b1e06d8). Every launcher
+ * forces production, but a direct `dsh --profile dsh-tui` boot loads this
+ * plugin without one and silently regressed to the dev build. This module
+ * must stay the FIRST import of the package entry so its body runs before
+ * any module in the plugin graph requires react. `??=` keeps an explicit
+ * environment choice (a debugging session) in control.
+ */
+process.env.NODE_ENV ??= 'production';

package/lib/types/i18n.d.ts

@@ -439,6 +439,14 @@ declare const dict: {
         readonly zh: "已加载上下文";
         readonly en: "Context loaded";
     };
+    readonly 'context-panel-expand': {
+        readonly zh: "展开";
+        readonly en: "Expand";
+    };
+    readonly 'context-panel-collapse': {
+        readonly zh: "折叠";
+        readonly en: "Collapse";
+    };
     readonly 'copied-chars': {
         readonly zh: "已复制 {{n}} 个字符";
         readonly en: "Copied {{n}} characters";
@@ -807,6 +815,10 @@ declare const dict: {
         readonly zh: "镜像 registry 滞后：本次安装 v{{latest}}；官方最新 v{{authoritative}}，镜像同步后可再 /update。";
         readonly en: "Mirror registry lag: installing v{{latest}} now; official latest is v{{authoritative}} — run /update again once the mirror syncs.";
     };
+    readonly 'streaming-folded': {
+        readonly zh: "…（前 {{count}} 字符流式期间已折叠，落定后完整显示）";
+        readonly en: "…(first {{count}} chars folded while streaming; full text renders once the turn settles)";
+    };
     readonly 'vim-not-implemented': {
         readonly zh: "vim 模式暂未实现";
         readonly en: "vim mode not implemented yet";
@@ -1315,10 +1327,6 @@ declare const dict: {
         readonly zh: "无法读取会话列表 · {{err}}";
         readonly en: "Could not read the session list · {{err}}";
     };
-    readonly 'session-resume-refused': {
-        readonly zh: "无法恢复这个会话——原因已记录在对话里（模型正在工作时无法切换）";
-        readonly en: "That session could not be resumed — the reason is in the conversation (switching is refused while the model is working)";
-    };
     readonly 'session-resume-failed': {
         readonly zh: "恢复会话失败 · {{err}}";
         readonly en: "Resuming the session failed · {{err}}";
@@ -1664,8 +1672,8 @@ declare const dict: {
         readonly en: "Not parseable JSON: {{err}}";
     };
     readonly 'plugins-check-spec-unavailable': {
-        readonly zh: "vendored 规范数据不可用（ecosystem-spec/），无法校验。";
-        readonly en: "Vendored spec data unavailable (ecosystem-spec/); cannot validate.";
+        readonly zh: "vendored 规范数据不可用（dsh-ecosystem-spec/），无法校验。";
+        readonly en: "Vendored spec data unavailable (dsh-ecosystem-spec/); cannot validate.";
     };
     readonly 'plugins-check-schema-failed': {
         readonly zh: "schema 校验失败：{{err}}";

package/lib/types/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAI9B,+DAA+D;AAC/D,eAAO,MAAM,KAAK,uBAAwB,CAAA;AAE1C,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmtBA,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,IAAI,CAAA;AACvC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;AAUxD,uEAAuE;AACvE,KAAK,QAAQ,GAAG,MAAM,IAAI,CAAA;AAG1B,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI,CAG5D;AAED,qCAAqC;AACrC,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED,yDAAyD;AACzD,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAGxC;AAED,iDAAiD;AACjD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,UAAe,GAAG,MAAM,CAM/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzD;AAID;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAS5D;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAkB,GAAG,IAAI,GAAG,SAAS,CAMtE;AAED,iDAAiD;AACjD,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAQ1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAavC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAIzC"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAI9B,+DAA+D;AAC/D,eAAO,MAAM,KAAK,uBAAwB,CAAA;AAE1C,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqtBA,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,IAAI,CAAA;AACvC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;AAUxD,uEAAuE;AACvE,KAAK,QAAQ,GAAG,MAAM,IAAI,CAAA;AAG1B,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI,CAG5D;AAED,qCAAqC;AACrC,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED,yDAAyD;AACzD,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAGxC;AAED,iDAAiD;AACjD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,UAAe,GAAG,MAAM,CAM/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzD;AAID;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAS5D;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAkB,GAAG,IAAI,GAAG,SAAS,CAMtE;AAED,iDAAiD;AACjD,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAQ1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAavC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAIzC"}