@askdkc/dsh-cli 0.11.3

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

@@ -0,0 +1,465 @@
+/**
+ * Approval store — the UI-side answerer half of the DSH approval seam
+ * (`ctx.approval`). The harness's permission layer asks
+ * `ApprovalService.request()`, which dispatches an `approval/request`
+ * waterfall; the listener registered in plugin.ts parks the request here,
+ * surfaces one ask at a time to the TUI permission prompt, and settles the
+ * harness promise when the user decides, the
+ * asker's abort signal fires, or the plugin tears down.
+ *
+ * Queue semantics mirror QuestionStore: parallel tool calls can trigger
+ * several asks before any answer is given, so asks are drained FIFO.
+ * Outcomes are the protocol's closed set — `'allowed-once'` and
+ * `'rejected'` from the panel, `'cancelled'` on abort/teardown; there is
+ * no allow-always or feedback channel in the protocol.
+ */
+import { compositionRoot } from './host-access.js';
+import { assertCapabilityShadowPolicy, defaultAdapterRuntime, } from '../adapter/kernel/runtime.js';
+import { snapshotLiveSessionEvents } from './compat/liveSession.js';
+const approvalStores = new WeakMap();
+/** Host-only registration used by the TUI plugin bootstrap. */
+export function bindApprovalStore(ctx, store) {
+    const root = compositionRoot(ctx);
+    approvalStores.set(root, store);
+}
+/** Host-only lookup used by the presentation Port bridge. */
+export function getApprovalStore(ctx) {
+    const root = compositionRoot(ctx);
+    return approvalStores.get(root);
+}
+const COMMAND_CLIP = 500;
+/**
+ * Recover the gated command from the session log: the approval request
+ * links to an already-presented tool call via `callId`, so the arguments
+ * are not duplicated on the request. Mirrors the web client's `commandOf`.
+ * @param req - The pending approval request.
+ * @returns The `command` argument when present, else the raw arguments
+ *   string (clipped), else undefined when the call cannot be found.
+ */
+function commandOf(req) {
+    if (req.callId === undefined)
+        return undefined;
+    const events = snapshotLiveSessionEvents(req.agent.session);
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const event = events[i];
+        if (event.type !== 'tool/call')
+            continue;
+        if (String(event.data.callId) !== String(req.callId))
+            continue;
+        const raw = event.data.arguments;
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed !== null && typeof parsed === 'object' && 'command' in parsed) {
+                const command = parsed.command;
+                if (typeof command === 'string')
+                    return command;
+            }
+        }
+        catch {
+            // Not JSON — fall through to the raw string.
+        }
+        return raw.length <= COMMAND_CLIP ? raw : `${raw.slice(0, COMMAND_CLIP)}…`;
+    }
+    return undefined;
+}
+/**
+ * Whether the approval is anchored to a live, unresolved tool call of the
+ * session. The permission layer gates a call BEFORE it executes: at gating
+ * time the paired tool/call event exists and no tool/result for that callId
+ * has landed yet. A request without a callId, with a callId matching no
+ * event, or referencing an already-settled call therefore did not come from
+ * the agent's live execution — most plausibly a forged waterfall dispatch
+ * replaying real session text.
+ */
+function isLiveToolApproval(req) {
+    if (req.callId === undefined)
+        return false;
+    const events = snapshotLiveSessionEvents(req.agent.session);
+    let callIndex = -1;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const event = events[i];
+        if (event.type !== 'tool/call')
+            continue;
+        if (String(event.data.callId) !== String(req.callId))
+            continue;
+        callIndex = i;
+        break;
+    }
+    if (callIndex === -1)
+        return false;
+    for (let i = callIndex + 1; i < events.length; i += 1) {
+        const event = events[i];
+        if (event.type !== 'tool/result')
+            continue;
+        const resultCallId = event.data.message?.source?.callId;
+        if (String(resultCallId) === String(req.callId))
+            return false;
+    }
+    return true;
+}
+/** Composite consumed-set key: one agent domain per entry (see
+ * ApprovalStore.consumedCallIds). */
+function consumedKey(agentId, callId) {
+    return `${String(agentId)}::${String(callId)}`;
+}
+/**
+ * Approval store: parks asks from the harness's approval seam, surfaces
+ * one at a time to the TUI, and settles each ask when the user decides or
+ * the ask is withdrawn. The TUI subscribes for re-renders and decides via
+ * {@link ApprovalStore.decide}.
+ */
+export class ApprovalStore {
+    runtime;
+    constructor(runtime = defaultAdapterRuntime()) {
+        this.runtime = runtime;
+    }
+    queue = [];
+    active;
+    listeners = new Set();
+    seq = 0;
+    /**
+     * Cached snapshot: useSyncExternalStore requires a stable reference while
+     * nothing changed (a fresh object per call would loop re-renders).
+     */
+    snapshotCache = null;
+    /**
+     * Length of the session log at the last liveness evaluation of the active
+     * ask. Events only append, so an unchanged length means no verdict can
+     * have flipped — re-checks below this guard are skipped.
+     */
+    externalCheckedAtEvents = -1;
+    notifyQueued = false;
+    /**
+     * CallIds whose approval ask already settled (decided or cancelled).
+     * Together with the in-flight set this closes the park-after-decide gap:
+     * the first ask leaves the queue while its tool is still executing (the
+     * callId still reads live), so a twin parked in that window would dodge
+     * both the in-flight dedup and the liveness check. A consumed callId
+     * never legitimately comes back: the permission layer asks once per call.
+     * Fails toward the badge — a hypothetical genuine re-ask after a cancel
+     * shows the warning, never the reverse. Evicted when the paired
+     * tool/result lands (after that the liveness check marks the twin
+     * anyway), keeping the set bounded to in-flight tool executions.
+     * Keys are agent-scoped (`agentId::callId`): the store outlives agent
+     * switches (/resume, /new) and low-entropy callIds (provider fallback
+     * `call-<index>`) repeat across sessions — a bare-callId key would badge
+     * the next session's genuine ask with the previous session's residue.
+     */
+    consumedCallIds = new Set();
+    /**
+     * Subscribe to store changes (useSyncExternalStore contract).
+     * @param listener - Called after every mutation that changes the snapshot.
+     * @returns An unsubscribe function removing the listener.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * The approval the TUI should render now, or null when idle. Re-checks the
+     * active ask's source badge against the current session log (see
+     * {@link refreshActiveExternal}) so a badge that flips while the ask is on
+     * the panel surfaces without waiting for another store mutation.
+     * @returns The cached snapshot; the reference is stable between mutations.
+     */
+    getSnapshot() {
+        this.refreshActiveExternal();
+        return this.snapshotCache;
+    }
+    /**
+     * Session ids of every agent with a parked ask (active plus queued) — the
+     * agent view's "needs input" signal. Deduplicated, in park order.
+     * @returns One id per asking agent, or an empty array when none waits.
+     */
+    pendingAgentIds() {
+        const ids = [];
+        const seen = new Set();
+        for (const ask of [...(this.active === undefined ? [] : [this.active]), ...this.queue]) {
+            const id = ask.snapshot.agentId;
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            ids.push(id);
+        }
+        return ids;
+    }
+    /**
+     * The first parked ask's detail for one agent — the agent view's row
+     * summary while it needs input (the question it is blocked on).
+     * @param agentId - The asking session's id.
+     * @returns The ask's reason / gated command / tool name, or undefined
+     *   when the agent has no parked ask.
+     */
+    pendingAgentDetail(agentId) {
+        for (const ask of [...(this.active === undefined ? [] : [this.active]), ...this.queue]) {
+            if (ask.snapshot.agentId !== agentId)
+                continue;
+            const { toolName, reason, command } = ask.snapshot;
+            return { toolName, ...(reason === undefined ? {} : { reason }), ...(command === undefined ? {} : { command }) };
+        }
+        return undefined;
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
+    /** Notify on a microtask so a re-check triggered inside getSnapshot
+     * (during a React render) never fires listeners synchronously mid-render. */
+    scheduleNotify() {
+        if (this.notifyQueued)
+            return;
+        this.notifyQueued = true;
+        queueMicrotask(() => {
+            this.notifyQueued = false;
+            this.emit();
+        });
+    }
+    /** Rebuild the cached snapshot after any mutation of active. */
+    rebuildSnapshot() {
+        const pending = this.active;
+        this.snapshotCache = pending === undefined
+            ? null
+            : { key: pending.key, ...pending.snapshot };
+    }
+    /**
+     * Re-run the source-badge verdict for the active ask (P-4).
+     *
+     * The external flag computed at park() is only a point-in-time verdict. A
+     * forger can dispatch a second request carrying the SAME callId as a
+     * genuinely pending one — both look live at park time; once the first is
+     * allowed and its tool/result lands, the twin surfaces with a callId that
+     * no longer has an unresolved call and must not keep the unmarked panel
+     * data. Re-checked when an ask becomes active (promotion), whenever the
+     * snapshot is read (the result usually lands AFTER the twin was promoted),
+     * and on every session `tool/result` notification (see
+     * {@link noteSessionEvent}). The session log only appends, so the verdict
+     * can only flip live→external, never back — the badge may appear late but
+     * never falsely.
+     */
+    refreshActiveExternal() {
+        const pending = this.active;
+        if (pending === undefined || pending.snapshot.external === true)
+            return;
+        const events = snapshotLiveSessionEvents(pending.request.agent.session);
+        if (events.length === this.externalCheckedAtEvents)
+            return;
+        this.externalCheckedAtEvents = events.length;
+        if (isLiveToolApproval(pending.request))
+            return;
+        pending.snapshot.external = true;
+        this.rebuildSnapshot();
+        this.scheduleNotify();
+    }
+    /**
+     * Session-event notification inlet (wired by plugin.ts to the
+     * `session/event` firehose). React does not know the session log
+     * appended: a badge flip that only happens inside getSnapshot() surfaces
+     * solely when something ELSE re-renders the panel (a streaming spinner,
+     * say) — a silent render loop leaves the unmarked panel on screen. A
+     * landed `tool/result` is the only event type that can flip the active
+     * verdict live→external, so everything else is dropped here; the internal
+     * length memo then skips the recheck whenever the event belongs to a
+     * different session than the active ask's. The notification the SDK
+     * fires arrives after the event is already in the live session log, so the
+     * recheck sees the settled result.
+     * @param agentId - The emitting session's id (DSH shares agent/session identity).
+     * @param event - The appended session event.
+     */
+    noteSessionEvent(agentId, event) {
+        if (event.type !== 'tool/result')
+            return;
+        // Hygiene for {@link consumedCallIds}: once the paired result landed,
+        // the liveness check marks any future twin on its own, so the consumed
+        // entry can go.
+        const resultCallId = event.data.message?.source?.callId;
+        if (resultCallId !== undefined) {
+            // Low-entropy callIds repeat across agents. A different session's
+            // result must not reopen this agent's park-after-decide replay window.
+            this.consumedCallIds.delete(consumedKey(agentId, resultCallId));
+        }
+        this.refreshActiveExternal();
+    }
+    /**
+     * Whether another ask with this callId is already parked (active or
+     * queued). A genuine approval is raised once per gated tool call — the
+     * permission layer asks, waits, and never re-asks for the same callId —
+     * so a second ask reusing an in-flight callId is a forged twin dispatched
+     * through the in-process waterfall. This is a DETERMINISTIC verdict: it
+     * needs no tool/result to land, unlike {@link isLiveToolApproval}, whose
+     * twin-reveal window (result lands only after the first ask is allowed
+     * and the tool runs) is exactly when promotion-time rechecks still see no
+     * result. Derived from the live active+queue set on each park(), so
+     * settled asks free their callId automatically.
+     */
+    isCallIdInFlight(req) {
+        if (req.callId === undefined)
+            return false;
+        const agentKey = String(req.agent.id);
+        const key = String(req.callId);
+        const occupies = (pending) => String(pending.request.agent.id) === agentKey
+            && pending.request.callId !== undefined && String(pending.request.callId) === key;
+        return (this.active !== undefined && occupies(this.active)) || this.queue.some(occupies);
+    }
+    /**
+     * Answerer entry point — called by the `approval/request` waterfall
+     * listener for every ask in this process: the attached session's and any
+     * background session's alike, so an unattended session surfaces as
+     * "needs input" instead of failing closed with nobody to answer it.
+     * @param req - The approval request (agent, tool, callId, reason, signal).
+     * @returns A promise settling with the user's decision, or `'cancelled'`
+     *   when the ask is withdrawn or the plugin tears down.
+     */
+    park(req) {
+        assertCapabilityShadowPolicy('host.presentation.approve', this.runtime.mode, this.runtime.slices);
+        return new Promise(resolve => {
+            const command = commandOf(req);
+            // Source badge: park() is reached through the approval/request
+            // waterfall, which any in-process plugin can dispatch — the agent-id
+            // gate in plugin.ts says whose SESSION it names, not that a live tool
+            // call actually raised it. Mark everything not anchored to an
+            // unresolved tool call, plus any ask reusing a callId that is already
+            // in flight or already consumed (a legitimate call is asked about
+            // exactly once). A duplicate callId marks EVERY ask on it ambiguous
+            // (attacker-first: a forged ask parked before the genuine one looks
+            // clean on its own — see markCallIdAmbiguous), so the panel can warn.
+            const duplicate = this.isCallIdInFlight(req);
+            if (duplicate)
+                this.markCallIdAmbiguous(req.agent.id, req.callId);
+            const external = !isLiveToolApproval(req) || duplicate
+                || (req.callId !== undefined && this.consumedCallIds.has(consumedKey(req.agent.id, req.callId)));
+            const pending = {
+                key: String(++this.seq),
+                request: req,
+                snapshot: {
+                    agentId: String(req.agent.id),
+                    toolName: req.toolName,
+                    ...(req.reason !== undefined ? { reason: req.reason } : {}),
+                    ...(command !== undefined ? { command } : {}),
+                    ...(external ? { external: true } : {}),
+                },
+                resolve,
+                onAbort: () => {
+                    // A REAL controller.abort() sets `aborted` BEFORE dispatching the
+                    // event; a forged signal.dispatchEvent(new Event('abort')) fires
+                    // the listener with `aborted` still false. A forged abort must
+                    // not dequeue the genuine panel (abort-then-spoof: the attacker
+                    // empties the real ask in the same synchronous stack it parks a
+                    // same-callId twin, which then looks live) — badge it instead.
+                    if (req.signal !== undefined && !req.signal.aborted) {
+                        pending.snapshot.external = true;
+                        this.rebuildSnapshot();
+                        this.scheduleNotify();
+                        return;
+                    }
+                    if (this.active === pending) {
+                        this.active = undefined;
+                        this.rebuildSnapshot();
+                        pending.resolve('cancelled');
+                        this.startNext();
+                        return;
+                    }
+                    const at = this.queue.indexOf(pending);
+                    if (at >= 0)
+                        this.queue.splice(at, 1);
+                    pending.resolve('cancelled');
+                },
+            };
+            req.signal?.addEventListener('abort', pending.onAbort, { once: true });
+            this.queue.push(pending);
+            this.startNext();
+        });
+    }
+    /** Advance to the next queued ask, if any. The promoted ask's source
+     * badge is re-checked against the log that has kept appending since it
+     * was parked (P-4: a same-callId twin parked while live may surface long
+     * after its call settled). */
+    startNext() {
+        if (this.active !== undefined || this.queue.length === 0)
+            return;
+        this.active = this.queue.shift();
+        // Fresh active: force a fresh verdict regardless of the length memo.
+        this.externalCheckedAtEvents = -1;
+        this.refreshActiveExternal();
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /**
+     * The user decided on the current approval; settles it and drains the
+     * next queued ask if any. No-op when nothing is pending.
+     * @param outcome - `'allowed-once'` or `'rejected'`.
+     */
+    decide(outcome) {
+        const pending = this.active;
+        if (pending === undefined)
+            return;
+        this.noteConsumed(pending);
+        this.active = undefined;
+        this.rebuildSnapshot();
+        pending.resolve(outcome);
+        this.startNext();
+        this.emit();
+    }
+    /**
+     * Settle the active and all queued asks (plugin teardown). The panel
+     * unmounts as the snapshot clears.
+     * @param outcome - The outcome every pending ask resolves with.
+     */
+    settleAll(outcome) {
+        const active = this.active;
+        this.active = undefined;
+        if (active !== undefined)
+            this.noteConsumed(active);
+        this.rebuildSnapshot();
+        active?.resolve(outcome);
+        for (const pending of this.queue.splice(0)) {
+            this.noteConsumed(pending);
+            pending.resolve(outcome);
+        }
+        this.emit();
+    }
+    /**
+     * Record a settling ask's callId as consumed (see {@link consumedCallIds}).
+     * @param pending - The ask leaving the active/queue set.
+     */
+    noteConsumed(pending) {
+        const { callId } = pending.request;
+        if (callId !== undefined)
+            this.consumedCallIds.add(consumedKey(pending.request.agent.id, callId));
+    }
+    /**
+     * A same-callId duplicate just parked: every pending ask on that callId is
+     * now source-ambiguous. The forged-first order parks the fake ask clean
+     * (isLive true, no duplicate visible yet) and the genuine follow-up would
+     * carry the only badge — an inverted verdict. Flip them all, then rebuild
+     * + notify so an on-screen panel updates immediately. refreshActiveExternal
+     * early-returns on an existing external verdict, so the marking is
+     * monotonic and never erased. Deliberately badges instead of cancelling:
+     * cancelling both would hand the attacker a force-cancel primitive
+     * against genuine approvals.
+     * @param agentId - The agent domain owning the duplicated call id.
+     * @param callId - The duplicated call id (non-undefined by construction).
+     */
+    markCallIdAmbiguous(agentId, callId) {
+        const agentKey = String(agentId);
+        const key = String(callId);
+        const same = (pending) => String(pending.request.agent.id) === agentKey
+            && pending.request.callId !== undefined && String(pending.request.callId) === key;
+        let flipped = false;
+        if (this.active !== undefined && same(this.active) && this.active.snapshot.external !== true) {
+            this.active.snapshot.external = true;
+            flipped = true;
+        }
+        for (const pending of this.queue) {
+            if (same(pending) && pending.snapshot.external !== true) {
+                pending.snapshot.external = true;
+                flipped = true;
+            }
+        }
+        if (flipped) {
+            this.rebuildSnapshot();
+            this.scheduleNotify();
+        }
+    }
+}

package/lib/types/dsh-adapter/bundled-presets.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * 0.1.7 removed directory discovery. Consume the official bundle definitions
+ * through its registry, without copying or reimplementing their tool sets.
+ * Web/profile declarations own their seats even while still activating.
+ * Returns false on the legacy directory-backed roster or while absent. An
+ * absent service is watched through Cordis so a late registry is not missed.
+ */
+export declare function registerBundledPresets(ctx: Context): Promise<boolean>;
+//# sourceMappingURL=bundled-presets.d.ts.map

package/lib/types/dsh-adapter/bundled-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundled-presets.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/bundled-presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAwClD;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CA0C3E"}

package/lib/types/dsh-adapter/bundled-presets.js

@@ -0,0 +1,80 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parse } from 'yaml';
+import { packagedPresetRoot } from './packaged-presets.js';
+function declarativePresets(ctx) {
+    const service = ctx.get('agentPresets');
+    return service !== null && typeof service === 'object'
+        && 'register' in service && typeof service.register === 'function'
+        ? service
+        : undefined;
+}
+/** Preserve the Loader's expressions; only the owning plugin may evaluate them. */
+function readPresetPatch(path) {
+    const patches = parse(readFileSync(path, 'utf8'), {
+        customTags: [{ tag: 'tag:yaml.org,2002:js', resolve: (value) => ({ __jsExpr: value }) }],
+    });
+    if (Array.isArray(patches) && patches.length === 1) {
+        const row = patches[0]?.insert?.[0];
+        if (row?.name === '@deepseek-ai/dsh-agent-preset'
+            && typeof row.config?.id === 'string' && Array.isArray(row.config.plugins)) {
+            return row.config;
+        }
+    }
+    throw new Error(`dsh-tui: invalid upstream preset declaration: ${path}`);
+}
+/**
+ * 0.1.7 removed directory discovery. Consume the official bundle definitions
+ * through its registry, without copying or reimplementing their tool sets.
+ * Web/profile declarations own their seats even while still activating.
+ * Returns false on the legacy directory-backed roster or while absent. An
+ * absent service is watched through Cordis so a late registry is not missed.
+ */
+export async function registerBundledPresets(ctx) {
+    if (ctx.get('agentPresets') === undefined) {
+        ctx.inject(['agentPresets'], async (ready) => {
+            await registerBundledPresets(ready);
+        });
+        return false;
+    }
+    if (declarativePresets(ctx) === undefined)
+        return false;
+    const declared = new Set();
+    const loader = ctx.get('loader');
+    for (const entry of loader?.entries() ?? []) {
+        if (entry.disabled || entry.options.name !== '@deepseek-ai/dsh-agent-preset')
+            continue;
+        const config = entry.options.config;
+        if (config !== null && typeof config === 'object' && 'id' in config && typeof config.id === 'string') {
+            declared.add(config.id);
+        }
+    }
+    const require = createRequire(ctx.baseUrl ?? import.meta.url);
+    for (const id of ['standard', 'ptc', 'minimal', 'cordis']) {
+        if (declared.has(id))
+            continue;
+        const path = require.resolve(`@deepseek-ai/dsh-web-app/presets/${id}.patch.yml`);
+        const owner = ctx.extend({ baseUrl: pathToFileURL(path).href });
+        const dispose = await declarativePresets(owner).register(readPresetPatch(path));
+        ctx.effect(() => dispose);
+    }
+    if (!declared.has('liangshen')) {
+        const root = join(packagedPresetRoot(), 'liangshen');
+        const metadata = parse(readFileSync(join(root, 'preset.yml'), 'utf8'));
+        const dispose = await declarativePresets(ctx).register({
+            id: 'liangshen',
+            name: metadata.name,
+            description: metadata.description,
+            order: metadata.order,
+            plugins: [{
+                    id: 'liangshen-plugins',
+                    name: '@deepseek-ai/cordis-plugin-include',
+                    config: { path: pathToFileURL(join(root, 'agent.cordis.yml')).href },
+                }],
+        });
+        ctx.effect(() => dispose);
+    }
+    return true;
+}

package/lib/types/dsh-adapter/channel/action-readiness.d.ts

@@ -0,0 +1,20 @@
+import type { ChannelState } from './types.js';
+/**
+ * The Channel installs its effectful command delegates atomically after every
+ * specialist has been constructed.  Construction-time callers fail closed
+ * rather than receiving a plausible no-op while the Channel is incomplete.
+ */
+export type ChannelActionDelegates = Pick<ChannelState, 'commandCompletions' | 'loadOlder' | 'rewindTo' | 'rewindToNode' | 'forkSession' | 'resumeTo' | 'newSession' | 'listWorkspaces' | 'listWorkspaceRegistry' | 'removeWorkspace' | 'renameWorkspaceAt' | 'resolveWorkspace' | 'switchWorkspace' | 'renameWorkspace' | 'workspaceCommands' | 'runWorkspaceCommand' | 'switchModel' | 'listEfforts' | 'setEffort' | 'setDefaultEffort' | 'cycleMode' | 'runPermissionPreset' | 'clear' | 'setActivityFrames' | 'listPresets' | 'switchPreset' | 'listModels' | 'listProviders' | 'invalidateModelCompletion' | 'listSkills' | 'describeCredential' | 'balanceInfo' | 'sideQuestion' | 'listFileCandidates' | 'listFiles' | 'listSessions' | 'previewSession' | 'bindApprovalStore' | 'agentViewRows' | 'subscribeAgentView' | 'dispatchBackgroundAgent' | 'stopBackgroundAgent' | 'attachToAgent' | 'peekAgentSession' | 'replyToAgent' | 'backgroundCurrent' | 'setResumeTarget' | 'renameSession' | 'setSessionColor' | 'recapRecent' | 'deleteSession' | 'renameSessionTo' | 'compact' | 'runExternalCommand' | 'runExternalCommandOutcome' | 'pushLocal' | 'mcpStatus' | 'exportSession' | 'initWorkspace' | 'doctorInfo' | 'pluginsInfo' | 'listSubagents'> & {
+    runLocalCommand(command: string, includeInContext: boolean): Promise<void>;
+};
+type ChannelActionMethodName = Exclude<keyof ChannelActionDelegates, 'runLocalCommand'>;
+export type ChannelActionMethods = Pick<ChannelState, ChannelActionMethodName>;
+/** The ChannelState-facing half of the readiness cell is deliberately pure:
+ * one typed forwarding method per public action, with no service access. */
+export declare function createChannelActionMethods(getReadyActions: () => ChannelActionDelegates): ChannelActionMethods;
+export declare function createChannelActionReadiness(): {
+    install(next: ChannelActionDelegates): void;
+    getReadyActions(): ChannelActionDelegates;
+};
+export {};
+//# sourceMappingURL=action-readiness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action-readiness.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/action-readiness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,YAAY,EAClD,oBAAoB,GACpB,WAAW,GACX,UAAU,GACV,cAAc,GACd,aAAa,GACb,UAAU,GACV,YAAY,GACZ,gBAAgB,GAChB,uBAAuB,GACvB,iBAAiB,GACjB,mBAAmB,GACnB,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,GACjB,mBAAmB,GACnB,qBAAqB,GACrB,aAAa,GACb,aAAa,GACb,WAAW,GACX,kBAAkB,GAClB,WAAW,GACX,qBAAqB,GACrB,OAAO,GACP,mBAAmB,GACnB,aAAa,GACb,cAAc,GACd,YAAY,GACZ,eAAe,GACf,2BAA2B,GAC3B,YAAY,GACZ,oBAAoB,GACpB,aAAa,GACb,cAAc,GACd,oBAAoB,GACpB,WAAW,GACX,cAAc,GACd,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,GACf,oBAAoB,GACpB,yBAAyB,GACzB,qBAAqB,GACrB,eAAe,GACf,kBAAkB,GAClB,cAAc,GACd,mBAAmB,GACnB,iBAAiB,GACjB,eAAe,GACf,iBAAiB,GACjB,aAAa,GACb,eAAe,GACf,iBAAiB,GACjB,SAAS,GACT,oBAAoB,GACpB,2BAA2B,GAC3B,WAAW,GACX,WAAW,GACX,eAAe,GACf,eAAe,GACf,YAAY,GACZ,aAAa,GACb,eAAe,CAClB,GAAG;IACF,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3E,CAAA;AAED,KAAK,uBAAuB,GAAG,OAAO,CAAC,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,CAAA;AACvF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAA;AAE9E;4EAC4E;AAC5E,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,MAAM,sBAAsB,GAC5C,oBAAoB,CAoEtB;AAED,wBAAgB,4BAA4B;kBAG1B,sBAAsB,GAAG,IAAI;uBAIxB,sBAAsB;EAK5C"}