@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.1

package/lib/types/dsh-adapter/channel/owner.js

@@ -0,0 +1,73 @@
+/** Channel lifetime plus binding fences for work that crosses an await. */
+export function createChannelOwner() {
+    let active = true;
+    let externalCheck = () => true;
+    const cleanups = new Set();
+    const controller = new AbortController();
+    const current = () => {
+        if (!active)
+            return false;
+        try {
+            return externalCheck();
+        }
+        catch {
+            return false;
+        }
+    };
+    const assertActive = () => {
+        if (!current())
+            throw new Error('dsh-tui: Channel lifetime has ended');
+    };
+    return {
+        current, assertActive,
+        get cleanupCount() { return cleanups.size; },
+        signal: controller.signal,
+        bind(check) { externalCheck = check; },
+        own(cleanup) {
+            let released = false;
+            const release = () => {
+                if (released)
+                    return;
+                released = true;
+                cleanups.delete(release);
+                cleanup();
+            };
+            if (active)
+                cleanups.add(release);
+            else
+                release();
+            return release;
+        },
+        dispose() {
+            if (!active)
+                return;
+            active = false;
+            controller.abort();
+            const failures = [];
+            // Every registered resource gets one cleanup attempt. A throwing
+            // external disposer must not strand later subscriptions or handles.
+            for (const cleanup of [...cleanups]) {
+                try {
+                    cleanup();
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, 'dsh-tui: Channel cleanup failed');
+        },
+    };
+}
+const owners = new WeakMap();
+export function registerChannelOwner(channel, owner) { owners.set(channel, owner); }
+export function bindChannelOwner(channel, check) { owners.get(channel)?.bind(check); }
+export function channelOwnerCurrent(channel) { return owners.get(channel)?.current() ?? false; }
+/** Register work that must be revoked whenever this Channel owner releases. */
+export function onChannelOwnerDispose(channel, cleanup) {
+    const owner = owners.get(channel);
+    return owner === undefined ? (() => undefined) : owner.own(cleanup);
+}
+export function disposeChannelOwner(channel) { owners.get(channel)?.dispose(); }

package/lib/types/dsh-adapter/channel/paths.d.ts

@@ -0,0 +1,31 @@
+import { type FileCandidate } from '../../utils/fileSuggestions.js';
+import type { FileSuggestionFs } from './types.js';
+/** Trailing path segment (`C:/a/b` → `b`). */
+export declare function basename(path: string): string;
+/** Normalize a cwd for comparison: forward slashes, no trailing slash; case
+ *  folded when the platform's filesystem semantics are case-insensitive. */
+export declare function normalizeCwd(path: string, caseInsensitive: boolean): string;
+/**
+ * `/resume` project filter (issue #96): exact cwd match, PLUS sessions
+ * recorded in a subdirectory — pre-upgrade launches recorded the launch
+ * subdirectory as the header cwd, and with the cwd default now resolving to
+ * the git worktree root an exact match would hide those sessions forever.
+ * They belong to the same workspace, so they stay listed. Comparison follows
+ * the platform's filesystem semantics (case-insensitive on Windows — a
+ * pre-upgrade header may record `C:\Repo` where the current launch resolves
+ * `c:\repo`). `caseInsensitive` is a parameter (not a platform read) so the
+ * verifier can exercise both modes on any host. Exported for
+ * scripts/verify-session-cwd.mjs.
+ *
+ * Boundary rule (issue #153): container directories are nobody's workspace.
+ * $HOME and the Windows root forms — plain drive roots (`C:`), UNC share
+ * roots (`//server/share`), and extended-length roots (`//?/C:`,
+ * `//?/UNC/server/share`) — are ancestors of unrelated projects, so the
+ * descendant rules below would list every session on the machine from `~`
+ * (and every session on the drive/share from those roots). At these
+ * boundaries, in either direction, only an exact match passes.
+ */
+export declare function sessionCwdMatches(stateCwd: string, headerCwd: string, caseInsensitive?: boolean): boolean;
+export declare function listPathCandidates(fs: FileSuggestionFs, cwd: string, query: string, signal: AbortSignal | undefined, topK: number): Promise<FileCandidate[]>;
+export declare function listFilesDeepCandidates(fs: FileSuggestionFs | undefined, root: string, signal?: AbortSignal): Promise<FileCandidate[]>;
+//# sourceMappingURL=paths.d.ts.map

package/lib/types/dsh-adapter/channel/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/paths.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAEvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,8CAA8C;AAC9C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;4EAC4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,MAAM,CAG3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,eAAe,GAAE,OAAsC,GACtD,OAAO,CAwBT;AAED,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAyBlK;AAED,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,gBAAgB,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAmD5I"}

package/lib/types/dsh-adapter/channel/paths.js

@@ -0,0 +1,147 @@
+import { join } from 'node:path';
+import { rankFileCandidates } from '../../utils/fileSuggestions.js';
+import { homeDir } from '../../utils/paths.js';
+/** Trailing path segment (`C:/a/b` → `b`). */
+export function basename(path) {
+    const parts = path.split(/[\\/]/);
+    return parts[parts.length - 1] ?? path;
+}
+/** Normalize a cwd for comparison: forward slashes, no trailing slash; case
+ *  folded when the platform's filesystem semantics are case-insensitive. */
+export function normalizeCwd(path, caseInsensitive) {
+    const normalized = path.replace(/\\/g, '/').replace(/\/+$/, '');
+    return caseInsensitive ? normalized.toLowerCase() : normalized;
+}
+/**
+ * `/resume` project filter (issue #96): exact cwd match, PLUS sessions
+ * recorded in a subdirectory — pre-upgrade launches recorded the launch
+ * subdirectory as the header cwd, and with the cwd default now resolving to
+ * the git worktree root an exact match would hide those sessions forever.
+ * They belong to the same workspace, so they stay listed. Comparison follows
+ * the platform's filesystem semantics (case-insensitive on Windows — a
+ * pre-upgrade header may record `C:\Repo` where the current launch resolves
+ * `c:\repo`). `caseInsensitive` is a parameter (not a platform read) so the
+ * verifier can exercise both modes on any host. Exported for
+ * scripts/verify-session-cwd.mjs.
+ *
+ * Boundary rule (issue #153): container directories are nobody's workspace.
+ * $HOME and the Windows root forms — plain drive roots (`C:`), UNC share
+ * roots (`//server/share`), and extended-length roots (`//?/C:`,
+ * `//?/UNC/server/share`) — are ancestors of unrelated projects, so the
+ * descendant rules below would list every session on the machine from `~`
+ * (and every session on the drive/share from those roots). At these
+ * boundaries, in either direction, only an exact match passes.
+ */
+export function sessionCwdMatches(stateCwd, headerCwd, caseInsensitive = process.platform === 'win32') {
+    const cwd = normalizeCwd(stateCwd, caseInsensitive);
+    const recorded = normalizeCwd(headerCwd, caseInsensitive);
+    if (recorded === '' || cwd === '')
+        return false;
+    const home = normalizeCwd(homeDir(), caseInsensitive);
+    // Paths below arrive backslash-normalized (`\\server\share` →
+    // `//server/share`, `\\?\C:\` → `//?/C:`), trailing slashes stripped.
+    const isContainer = (path) => (home !== '' && path === home) ||
+        /^[a-z]:$/i.test(path) || // drive root: C:
+        /^\/\/[^/]+\/[^/]+$/.test(path) || // UNC share root: //server/share
+        /^\/\/\?\/[a-z]:$/i.test(path) || // extended drive root: //?/C:
+        /^\/\/\?\/unc\/[^/]+\/[^/]+$/i.test(path); // extended UNC root: //?/UNC/server/share
+    if (isContainer(cwd) || isContainer(recorded))
+        return recorded === cwd;
+    return (recorded === cwd ||
+        // Pre-upgrade subdirectory session of this workspace.
+        recorded.startsWith(`${cwd}/`) ||
+        // Resumed INTO a pre-upgrade subdirectory session (state.cwd adopted its
+        // recorded subdirectory): the workspace-root sessions it belongs with
+        // must stay visible, or /resume looks like it lost them for the rest of
+        // the process lifetime (review leftover).
+        cwd.startsWith(`${recorded}/`));
+}
+export async function listPathCandidates(fs, cwd, query, signal, topK) {
+    const normalized = query.replaceAll('\\', '/');
+    const slash = normalized.lastIndexOf('/');
+    // `.` / `..` without a trailing separator are whole-directory queries too.
+    const bareDir = slash < 0 && (normalized === '.' || normalized === '..' || normalized === '~');
+    const directoryPart = slash < 0 ? (bareDir ? `${normalized}/` : '') : normalized.slice(0, slash + 1);
+    const nameQuery = slash < 0 || bareDir ? '' : normalized.slice(slash + 1);
+    // `~/` expands against the host home (matches the cwd resolution rules);
+    // drive-letter and POSIX-absolute prefixes pass through untouched.
+    const expanded = directoryPart === '~/'
+        ? `${homeDir()}/`
+        : directoryPart.startsWith('/') || /^[A-Za-z]:\//.test(directoryPart)
+            ? directoryPart
+            : join(cwd, directoryPart || '.');
+    try {
+        if (signal?.aborted)
+            return [];
+        const target = await fs.resolve(expanded);
+        const entries = (await fs.listDir(target)).slice().sort((a, b) => a.name.localeCompare(b.name));
+        return rankFileCandidates(entries.filter(entry => entry.type === 'file' || entry.type === 'directory').map(entry => {
+            const path = `${directoryPart}${entry.name}${entry.type === 'directory' ? '/' : ''}`;
+            return { id: path, path, displayPath: path, name: entry.name, kind: entry.type, score: 0 };
+        }), nameQuery, topK);
+    }
+    catch {
+        return [];
+    }
+}
+export async function listFilesDeepCandidates(fs, root, signal) {
+    if (!fs)
+        return [];
+    const out = [];
+    const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', '.DS_Store', 'dist']);
+    const BUILD_DIR = /^(?:build(?:[-_].*)?|cmake-build(?:[-_].*)?)$/i;
+    const queue = [{ dir: root, prefix: '', index: 0 }];
+    const visited = new Set();
+    const maxFiles = 100;
+    const maxDirectories = 100;
+    let fileCount = 0;
+    let dirCount = 0;
+    // Round-robin: each directory yields ONE non-skipped entry per visit before
+    // it re-queues, so a large early sibling (e.g. `generated/` with 120 files)
+    // cannot starve `src/` out of the per-kind budgets. This is the regression
+    // contract pinned by scripts/verify-file-completion.mjs.
+    while (queue.length && fileCount < maxFiles && dirCount < maxDirectories) {
+        if (signal?.aborted)
+            return [];
+        const current = queue.shift();
+        if (!current.entries) {
+            try {
+                const target = await fs.resolve(current.dir);
+                if (visited.has(target.displayPath))
+                    continue;
+                visited.add(target.displayPath);
+                current.entries = (await fs.listDir(target)).slice().sort((a, b) => a.name.localeCompare(b.name));
+            }
+            catch {
+                continue;
+            }
+        }
+        let entry;
+        while (current.index < current.entries.length) {
+            const candidate = current.entries[current.index++];
+            if (SKIP.has(candidate.name) || BUILD_DIR.test(candidate.name))
+                continue;
+            entry = candidate;
+            break;
+        }
+        if (!entry)
+            continue;
+        if (current.index < current.entries.length)
+            queue.push(current);
+        const path = current.prefix ? `${current.prefix}/${entry.name}` : entry.name;
+        if (entry.type === 'directory') {
+            if (dirCount >= maxDirectories)
+                continue;
+            out.push({ id: `${path}/`, path: `${path}/`, displayPath: `${path}/`, name: entry.name, kind: 'directory', score: 0 });
+            dirCount += 1;
+            queue.push({ dir: entry.target?.displayPath ?? join(current.dir, entry.name), prefix: path, index: 0 });
+        }
+        else if (entry.type === 'file') {
+            if (fileCount >= maxFiles)
+                continue;
+            out.push({ id: path, path, displayPath: path, name: entry.name, kind: 'file', score: 0 });
+            fileCount += 1;
+        }
+    }
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}

package/lib/types/dsh-adapter/channel/permissions.d.ts

@@ -0,0 +1,40 @@
+import { type SessionModeSpec } from '../../sessionModes.js';
+import type { PermissionPresetOption, PermissionPresetService, PermissionPresetSnapshot } from './types.js';
+export declare const PERMISSION_PRESET_CUSTOM = "custom";
+export declare const PERMISSION_PRESET_NAME_CELLS = 120;
+export declare const PERMISSION_PRESET_DESCRIPTION_CELLS = 400;
+/** The mounted registry may expose seams this package's declared contract
+ *  does not name yet: `resolve` (atom bundles) and `set` (the write path the
+ *  official `/permission` command drives). Read structurally, never assumed. */
+export interface PermissionPresetRuntime extends PermissionPresetService {
+    resolve?: (name: string) => unknown;
+    set?: (subject: unknown, name: string) => unknown;
+}
+/** One runtime preset's resolved atom bundle. */
+export interface PermissionPresetBundle {
+    readonly value: string;
+    readonly sandbox?: SessionModeSpec['sandbox'];
+    readonly approval?: SessionModeSpec['approval'];
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Narrow a raw service read to the structural registry surface. */
+export declare function permissionPresetRuntime(service: unknown): PermissionPresetRuntime | undefined;
+/** Keep a permission roster read-only after it crosses the adapter boundary.
+ *  The registry may reuse and mutate its option objects between reads; callers
+ *  must observe one stable snapshot instead of a live view into that service. */
+export declare function freezePermissionPresetSnapshot(snapshot: PermissionPresetSnapshot): PermissionPresetSnapshot;
+export declare function legacyPermissionPresetOptions(): readonly PermissionPresetOption[];
+export declare function legacyPermissionPresetSnapshot(sandbox: SessionModeSpec['sandbox']): PermissionPresetSnapshot;
+export declare function unavailablePermissionPresetSnapshot(): PermissionPresetSnapshot;
+export declare function normalizePermissionPresetOption(value: unknown): PermissionPresetOption | undefined;
+/** Atom bundles the deployment's preset table resolves (value →
+ *  sandbox/approval). Empty when the service is absent or exposes no
+ *  `resolve` seam — canonical resolution then falls back to the stock
+ *  bundles (see `canonicalPresetFor`). */
+export declare function permissionBundlesFromService(service: unknown): readonly PermissionPresetBundle[];
+/** The registry's current readback for one subject. Real harness registries
+ *  resolve `current(session)` through their session-projections seam; earlier
+ *  contract versions folded a raw event log. Try the subject as given, then
+ *  the event-log shape it may carry. */
+export declare function permissionPresetSnapshotFromService(service: unknown, subject: unknown): PermissionPresetSnapshot;
+//# sourceMappingURL=permissions.d.ts.map

package/lib/types/dsh-adapter/channel/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/permissions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE3G,eAAO,MAAM,wBAAwB,WAAW,CAAA;AAEhD,eAAO,MAAM,4BAA4B,MAAM,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;gFAEgF;AAChF,MAAM,WAAW,uBAAwB,SAAQ,uBAAuB;IACtE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IACnC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAClD;AAED,iDAAiD;AACjD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAC,UAAU,CAAC,CAAA;CAChD;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,oEAAoE;AACpE,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,uBAAuB,GAAG,SAAS,CAE7F;AAED;;iFAEiF;AACjF,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,wBAAwB,GAAG,wBAAwB,CAQ3G;AAED,wBAAgB,6BAA6B,IAAI,SAAS,sBAAsB,EAAE,CAkBjF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,wBAAwB,CAU5G;AAED,wBAAgB,mCAAmC,IAAI,wBAAwB,CAE9E;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,GAAG,SAAS,CAclG;AAED;;;0CAG0C;AAC1C,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,sBAAsB,EAAE,CAwBhG;AAED;;;wCAGwC;AACxC,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,GACf,wBAAwB,CAqE1B"}

package/lib/types/dsh-adapter/channel/permissions.js

@@ -0,0 +1,184 @@
+import { t } from '../../i18n.js';
+import { cleanRenderText } from '../sanitize.js';
+export const PERMISSION_PRESET_CUSTOM = 'custom';
+export const PERMISSION_PRESET_NAME_CELLS = 120;
+export const PERMISSION_PRESET_DESCRIPTION_CELLS = 400;
+export function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}
+/** Narrow a raw service read to the structural registry surface. */
+export function permissionPresetRuntime(service) {
+    return isRecord(service) ? service : undefined;
+}
+/** Keep a permission roster read-only after it crosses the adapter boundary.
+ *  The registry may reuse and mutate its option objects between reads; callers
+ *  must observe one stable snapshot instead of a live view into that service. */
+export function freezePermissionPresetSnapshot(snapshot) {
+    const options = Object.freeze(snapshot.options.map(option => Object.freeze({ ...option })));
+    const current = snapshot.current === undefined ? undefined : Object.freeze({ ...snapshot.current });
+    return Object.freeze({
+        availability: snapshot.availability,
+        options,
+        ...(current === undefined ? {} : { current }),
+    });
+}
+export function legacyPermissionPresetOptions() {
+    return [
+        {
+            value: 'read-only',
+            name: t('permission-preset-readonly'),
+            description: t('permission-preset-readonly-desc'),
+        },
+        {
+            value: 'workspace-write',
+            name: t('permission-preset-workspace-write'),
+            description: t('permission-preset-workspace-write-desc'),
+        },
+        {
+            value: 'danger-full-access',
+            name: t('permission-preset-full-access'),
+            description: t('permission-preset-full-access-desc'),
+        },
+    ];
+}
+export function legacyPermissionPresetSnapshot(sandbox) {
+    const options = legacyPermissionPresetOptions();
+    const currentOption = sandbox === undefined ? undefined : options.find(option => option.value === sandbox);
+    return freezePermissionPresetSnapshot({
+        availability: 'legacy',
+        options,
+        ...(currentOption === undefined
+            ? {}
+            : { current: { ...currentOption, kind: 'preset' } }),
+    });
+}
+export function unavailablePermissionPresetSnapshot() {
+    return freezePermissionPresetSnapshot({ availability: 'unavailable', options: [] });
+}
+export function normalizePermissionPresetOption(value) {
+    if (!isRecord(value) || typeof value.value !== 'string' || typeof value.name !== 'string')
+        return undefined;
+    const name = cleanRenderText(value.name, PERMISSION_PRESET_NAME_CELLS);
+    if (name === '')
+        return undefined;
+    if (value.description !== undefined && typeof value.description !== 'string')
+        return undefined;
+    const description = value.description === undefined
+        ? undefined
+        : cleanRenderText(value.description, PERMISSION_PRESET_DESCRIPTION_CELLS);
+    if (value.description !== undefined && description === '')
+        return undefined;
+    return {
+        value: value.value,
+        name,
+        ...(description === undefined || description === '' ? {} : { description }),
+    };
+}
+/** Atom bundles the deployment's preset table resolves (value →
+ *  sandbox/approval). Empty when the service is absent or exposes no
+ *  `resolve` seam — canonical resolution then falls back to the stock
+ *  bundles (see `canonicalPresetFor`). */
+export function permissionBundlesFromService(service) {
+    const runtime = permissionPresetRuntime(service);
+    const resolve = runtime?.resolve;
+    if (typeof resolve !== 'function')
+        return [];
+    const names = Array.isArray(runtime?.names) ? runtime.names : [];
+    const bundles = [];
+    for (const name of names) {
+        if (typeof name !== 'string')
+            continue;
+        try {
+            const spec = resolve(name);
+            if (!isRecord(spec))
+                continue;
+            const sandbox = spec.sandbox;
+            const approval = spec.approval;
+            if ((sandbox === 'read-only' || sandbox === 'workspace-write' || sandbox === 'danger-full-access')
+                && (approval === 'ask' || approval === 'never')) {
+                bundles.push({ value: name, sandbox, approval });
+            }
+        }
+        catch {
+            // Optional resolution; a broken entry just does not extend the table.
+        }
+    }
+    return bundles;
+}
+/** The registry's current readback for one subject. Real harness registries
+ *  resolve `current(session)` through their session-projections seam; earlier
+ *  contract versions folded a raw event log. Try the subject as given, then
+ *  the event-log shape it may carry. */
+export function permissionPresetSnapshotFromService(service, subject) {
+    const runtime = permissionPresetRuntime(service);
+    if (runtime === undefined)
+        return unavailablePermissionPresetSnapshot();
+    try {
+        const capturedNames = Array.isArray(runtime.names) ? runtime.names : [];
+        const current = runtime.current;
+        const optionOf = runtime.optionOf;
+        if (capturedNames.length === 0)
+            return unavailablePermissionPresetSnapshot();
+        if (typeof current !== 'function' || typeof optionOf !== 'function')
+            return unavailablePermissionPresetSnapshot();
+        const names = [];
+        for (const name of capturedNames) {
+            if (typeof name !== 'string' || name.trim() === '' || name === PERMISSION_PRESET_CUSTOM || names.includes(name)) {
+                return unavailablePermissionPresetSnapshot();
+            }
+            names.push(name);
+        }
+        const seen = new Set(names);
+        const options = [];
+        for (const name of names) {
+            const option = normalizePermissionPresetOption(optionOf(name));
+            if (option === undefined || option.value !== name)
+                return unavailablePermissionPresetSnapshot();
+            options.push({ ...option });
+        }
+        let currentValue;
+        try {
+            currentValue = current(subject);
+        }
+        catch {
+            currentValue = undefined;
+        }
+        if (typeof currentValue !== 'string') {
+            // Second chance for the other contract shape: a subject that carries an
+            // event log, or a raw log handed in directly.
+            const fallback = subject?.events ?? subject;
+            try {
+                currentValue = current(fallback);
+            }
+            catch {
+                if (typeof currentValue !== 'string')
+                    return unavailablePermissionPresetSnapshot();
+            }
+        }
+        if (typeof currentValue !== 'string' || (currentValue !== PERMISSION_PRESET_CUSTOM && !seen.has(currentValue))) {
+            return unavailablePermissionPresetSnapshot();
+        }
+        const currentOption = normalizePermissionPresetOption(optionOf(currentValue));
+        if (currentOption === undefined || currentOption.value !== currentValue)
+            return unavailablePermissionPresetSnapshot();
+        if (currentValue !== PERMISSION_PRESET_CUSTOM) {
+            const rosterOption = options.find(option => option.value === currentValue);
+            if (rosterOption === undefined
+                || rosterOption.name !== currentOption.name
+                || rosterOption.description !== currentOption.description) {
+                return unavailablePermissionPresetSnapshot();
+            }
+        }
+        return freezePermissionPresetSnapshot({
+            availability: 'runtime',
+            options,
+            current: {
+                ...currentOption,
+                kind: currentValue === PERMISSION_PRESET_CUSTOM ? 'custom' : 'preset',
+            },
+        });
+    }
+    catch {
+        return unavailablePermissionPresetSnapshot();
+    }
+}

package/lib/types/dsh-adapter/channel/preferences.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelState } from '../channel/types.js';
+export declare function createPreferences(getState: () => Pick<ChannelState, 'diffLayout' | 'thinkingFold' | 'toolBackground' | 'scrollGutter' | 'pageMargin' | 'foldTerminalCommand' | 'promptSessionLabel' | 'expandEditor' | 'smoothStreaming' | 'statusBar' | 'whale' | 'whaleIdle' | 'minimal' | 'emit'>): Pick<ChannelState, 'setDiffLayout' | 'setThinkingFold' | 'setToolBackground' | 'setScrollGutter' | 'setPageMargin' | 'setFoldTerminalCommand' | 'setPromptSessionLabel' | 'setExpandEditor' | 'setSmoothStreaming' | 'setStatusBar' | 'setWhale' | 'setWhaleIdle' | 'setMinimal'>;
+//# sourceMappingURL=preferences.d.ts.map

package/lib/types/dsh-adapter/channel/preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/preferences.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,cAAc,GAAG,YAAY,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,cAAc,GAAG,iBAAiB,GAAG,WAAW,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,eAAe,GAAG,iBAAiB,GAAG,mBAAmB,GAAG,iBAAiB,GAAG,eAAe,GAAG,wBAAwB,GAAG,uBAAuB,GAAG,iBAAiB,GAAG,oBAAoB,GAAG,cAAc,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CAAC,CAsGxjB"}

package/lib/types/dsh-adapter/channel/preferences.js

@@ -0,0 +1,103 @@
+import { setMinimalMode } from '../../minimalMode.js';
+import { normalizePageMargin, normalizeScrollGutter, normalizeStatusBar, normalizeToolBackground } from '../../tuiDisplayPrefs.js';
+export function createPreferences(getState) {
+    return {
+        setDiffLayout(layout) {
+            const state = getState();
+            if (layout === state.diffLayout)
+                return;
+            state.diffLayout = layout;
+            state.emit();
+        },
+        setThinkingFold(mode) {
+            const state = getState();
+            if (mode === state.thinkingFold)
+                return;
+            state.thinkingFold = mode;
+            state.emit();
+        },
+        setToolBackground(background) {
+            const state = getState();
+            const normalized = normalizeToolBackground(background);
+            if (normalized === state.toolBackground)
+                return;
+            state.toolBackground = normalized;
+            state.emit();
+        },
+        setScrollGutter(mode) {
+            const state = getState();
+            const normalized = normalizeScrollGutter(mode);
+            if (normalized === state.scrollGutter)
+                return;
+            state.scrollGutter = normalized;
+            state.emit();
+        },
+        setPageMargin(setting) {
+            const state = getState();
+            const normalized = normalizePageMargin(setting);
+            if (normalized === state.pageMargin)
+                return;
+            state.pageMargin = normalized;
+            state.emit();
+        },
+        setFoldTerminalCommand(enabled) {
+            const state = getState();
+            if (enabled === state.foldTerminalCommand)
+                return;
+            state.foldTerminalCommand = enabled;
+            state.emit();
+        },
+        setPromptSessionLabel(enabled) {
+            const state = getState();
+            if (enabled === state.promptSessionLabel)
+                return;
+            state.promptSessionLabel = enabled;
+            state.emit();
+        },
+        setExpandEditor(enabled) {
+            const state = getState();
+            if (enabled === state.expandEditor)
+                return;
+            state.expandEditor = enabled;
+            state.emit();
+        },
+        setSmoothStreaming(enabled) {
+            const state = getState();
+            if (enabled === state.smoothStreaming)
+                return;
+            state.smoothStreaming = enabled;
+            state.emit();
+        },
+        setStatusBar(config) {
+            const state = getState();
+            const next = normalizeStatusBar({ ...state.statusBar, ...config });
+            const changed = Object.keys(next).some(key => next[key] !== state.statusBar[key]);
+            if (!changed)
+                return;
+            state.statusBar = next;
+            state.emit();
+        },
+        setWhale(visible) {
+            const state = getState();
+            if (visible === state.whale)
+                return;
+            state.whale = visible;
+            state.emit();
+        },
+        setWhaleIdle(enabled) {
+            const state = getState();
+            if (enabled === state.whaleIdle)
+                return;
+            state.whaleIdle = enabled;
+            state.emit();
+        },
+        setMinimal(enabled) {
+            const state = getState();
+            setMinimalMode(enabled);
+            if (enabled === state.minimal)
+                return;
+            state.minimal = enabled;
+            state.emit();
+        }
+    };
+}

package/lib/types/dsh-adapter/channel/projection-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { TodoPanelItem } from './types.js';
+export declare function isSubagentToolName(name: string): boolean;
+/** Extract `job_id` from a job_output call's raw args (JSON), or undefined. */
+export declare function parseJobOutputId(argsFull: string | undefined): string | undefined;
+/** Extract the command that launched a background job from its tool args
+ *  (`command` for the shell tools, `text` for terminal_send). The registry
+ *  label is the friendly description; the command is the actual invocation. */
+export declare function toolCommandOf(argsFull: string | undefined): string | undefined;
+/** The ack a shell tool returns for `run_in_background: true`. */
+export declare const BACKGROUND_START_ACK: RegExp;
+/** Narrow an optional plugin event without importing its module augmentation. */
+export declare function todoPanelItems(data: unknown): TodoPanelItem[] | undefined;
+//# sourceMappingURL=projection-helpers.d.ts.map

package/lib/types/dsh-adapter/channel/projection-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-helpers.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/projection-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAY/C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAQjF;AAED;;+EAE+E;AAC/E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAa9E;AAED,kEAAkE;AAClE,eAAO,MAAM,oBAAoB,QAAkC,CAAA;AAEnE,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,EAAE,GAAG,SAAS,CAWzE"}