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

package/lib/types/dsh-adapter/channel/mode-actions.js

@@ -0,0 +1,247 @@
+import { t } from '../../i18n.js';
+import { modeDisplayName } from '../../sessionModes.js';
+import { assertShadowPolicy } from '../../adapter/kernel/runtime.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+/** Durable session-mode folds and transitions. Construction is inert; root wires it after state construction. */
+export function createModeActions(ctx, state, deps) {
+    const { owner, runtime, binding, sessionModes, commandService, executeRegistryCommand, notify } = deps;
+    const current = (capture) => owner.current() && binding.isCurrent(capture);
+    const capturedSession = (capture) => capture.agent.session;
+    // Session-mode folds: last-wins projections over the session log. The
+    // event types are registered by dsh-plan-mode / dsh-sandbox-policy /
+    // dsh-user-approval and are NOT in this package's typed SessionEvent
+    // union, so they are matched by name through casts — the same pattern as
+    // `agent-preset/selected` in renderEvent and the goal projection above.
+    const foldPlanActive = (events) => {
+        let active = false;
+        for (const event of events) {
+            if (event.type === 'plan/mode') {
+                active = event.data.active === true;
+            }
+        }
+        return active;
+    };
+    const foldSandboxMode = (events) => {
+        let mode;
+        for (const event of events) {
+            if (event.type === 'sandbox/mode') {
+                const value = event.data.mode;
+                if (typeof value === 'string')
+                    mode = value;
+            }
+        }
+        return mode;
+    };
+    const foldApprovalPolicy = (events) => {
+        let policy;
+        for (const event of events) {
+            if (event.type === 'approval/policy') {
+                const value = event.data.policy;
+                if (typeof value === 'string')
+                    policy = value;
+            }
+        }
+        return policy;
+    };
+    /** First configured mode whose declared atoms all match the folds;
+     *  undeclared atoms are wildcards; no match → index 0 (the base mode).
+     *  Matching is exact: a fresh session has no `approval/policy` event, so
+     *  a mode declaring `approval: 'ask'` never falsely matches it. */
+    const deriveModeIndex = (events) => {
+        const index = sessionModes.findIndex(spec => (spec.plan === undefined || foldPlanActive(events) === spec.plan) &&
+            (spec.sandbox === undefined || foldSandboxMode(events) === spec.sandbox) &&
+            (spec.approval === undefined || foldApprovalPolicy(events) === spec.approval));
+        return index >= 0 ? index : 0;
+    };
+    /** Re-derive the current mode from the live session log (boot, every
+     *  agent re-bind, and after mode-affecting session events). */
+    const refreshMode = () => {
+        state.modeIndex = deriveModeIndex(snapshotLiveSessionEvents(binding.agent.session));
+        state.mode = sessionModes[state.modeIndex];
+    };
+    // Session.append rejects observer reentry; restore after publication
+    // unwinds. These are channel-scoped so a disposed/recreated Channel cannot
+    // inherit deferred work from a former owner.
+    const pendingPlanExitRestores = new Map();
+    const prePlanModes = new WeakMap();
+    // An in-turn /plan off commits at pre-step, after the command has returned.
+    const explicitPlanExits = new WeakSet();
+    const modePermissions = (events) => {
+        const sandbox = foldSandboxMode(events);
+        const approval = foldApprovalPolicy(events);
+        return {
+            id: 'restore',
+            ...(sandbox === 'read-only' || sandbox === 'workspace-write' || sandbox === 'danger-full-access'
+                ? { sandbox } : {}),
+            ...(approval === 'ask' || approval === 'never' ? { approval } : {}),
+        };
+    };
+    /** Recover a resumed plan's snapshot before /plan ran, not before its
+     *  deferred plan/mode event. Unknown historical atoms stay untouched. */
+    const prePlanModeSpec = (log) => {
+        let active = false;
+        let start = -1;
+        let command;
+        for (let index = 0; index < log.length - 1; index += 1) {
+            const event = log[index];
+            const type = event.type;
+            const data = event.data;
+            if (!active && type === 'command/run' && data.name === 'plan' && typeof data.args === 'string') {
+                if (data.args.trim() === 'off')
+                    command = undefined;
+                else
+                    command ??= { index, id: data.commandId };
+            }
+            if (type === 'command/done' && data.commandId === command?.id && data.kind !== 'success') {
+                command = undefined;
+            }
+            if (type === 'plan/mode') {
+                if (data.active === true && !active)
+                    start = command?.index ?? index;
+                active = data.active === true;
+                command = undefined;
+            }
+        }
+        return active && start >= 0 ? modePermissions(log.slice(0, start)) : undefined;
+    };
+    const applyModeAtoms = (spec, capture) => {
+        if (!current(capture))
+            return;
+        const agent = capture.agent;
+        const session = capturedSession(capture);
+        // The durable sandbox override is one session event (dsh-sandbox-policy's
+        // own write path); the session/event arm picks it up immediately.
+        if (spec.sandbox !== undefined && foldSandboxMode(snapshotLiveSessionEvents(session)) !== spec.sandbox) {
+            ;
+            session.append('sandbox/mode', { mode: spec.sandbox });
+        }
+        if (!current(capture))
+            return;
+        // Prefer the approval service (it narrates the switch to the model);
+        // the raw durable event is the fallback when it is unmounted.
+        if (spec.approval !== undefined && foldApprovalPolicy(snapshotLiveSessionEvents(session)) !== spec.approval) {
+            const approval = ctx.get('approval');
+            approval?.setPolicy(agent, spec.approval);
+            if (!current(capture))
+                return;
+            // The service may no-op when its configured default already matches.
+            if (foldApprovalPolicy(snapshotLiveSessionEvents(session)) !== spec.approval) {
+                ;
+                session.append('approval/policy', { policy: spec.approval });
+            }
+        }
+    };
+    /** Apply the configured atoms; an explicit exit owns its target mode. */
+    const applyMode = async (spec, capture = binding.capture()) => {
+        if (!current(capture))
+            return;
+        // This action writes durable session policy. The runtime snapshot comes
+        // from composition and is immutable for this Channel lifetime, so an
+        // observed plan exit cannot bypass the renderer/Port shadow guard.
+        assertShadowPolicy('mutate', runtime.mode);
+        const agent = capture.agent;
+        const session = capturedSession(capture);
+        pendingPlanExitRestores.delete(session);
+        const planMode = ctx.get('planMode');
+        const planActive = foldPlanActive(snapshotLiveSessionEvents(session));
+        // Reconcile a stale explicit-exit marker before acting. The marker only
+        // legitimately survives while a deferred exit awaits its plan/mode:false
+        // (foldPlanActive && pending === false). If plan is still logged active
+        // with no pending intent, that awaited event was abandoned (e.g. an
+        // aborted pre-step) — drop the orphan so it cannot suppress a later restore
+        // such as an approved exit_plan_mode.
+        if (planActive && planMode?.get?.(agent).pending === undefined) {
+            explicitPlanExits.delete(session);
+        }
+        if (spec.plan !== undefined && (planMode?.get?.(agent).pending ?? planActive) !== spec.plan) {
+            if (commandService?.find(agent, 'plan') === undefined) {
+                notify(t('mode-plan-unavailable'), { color: 'warning' });
+                return;
+            }
+            if (spec.plan && !planActive && !prePlanModes.has(session)) {
+                const previous = modePermissions(snapshotLiveSessionEvents(session));
+                const sandbox = ctx.get('sandboxPolicy');
+                const approval = ctx.get('approval');
+                const base = previous.sandbox === undefined && previous.approval === undefined ? sessionModes[0] : undefined;
+                previous.sandbox ??= sandbox?.defaultMode ?? base?.sandbox;
+                previous.approval ??= approval?.effectivePolicy?.(session) ?? base?.approval;
+                prePlanModes.set(session, previous);
+                // Persist missing defaults before /plan, so resume can recover them.
+                applyModeAtoms(previous, capture);
+            }
+            if (!spec.plan)
+                explicitPlanExits.add(session);
+            try {
+                const text = await executeRegistryCommand('plan', spec.plan ? '' : ' off');
+                if (!current(capture) || session !== capturedSession(capture))
+                    return;
+                if (text === undefined) {
+                    notify(t('mode-plan-unavailable'), { color: 'warning' });
+                    return;
+                }
+            }
+            finally {
+                if (current(capture) && session === capturedSession(capture)) {
+                    const pending = planMode?.get?.(agent).pending;
+                    if (!foldPlanActive(snapshotLiveSessionEvents(session)) || pending !== false)
+                        explicitPlanExits.delete(session);
+                    if (!foldPlanActive(snapshotLiveSessionEvents(session)) && pending !== true)
+                        prePlanModes.delete(session);
+                }
+            }
+        }
+        if (!current(capture))
+            return;
+        applyModeAtoms(spec, capture);
+        if (!current(capture))
+            return;
+        refreshMode();
+        if (!current(capture))
+            return;
+        notify(t('mode-switched', { name: modeDisplayName(state.mode) }));
+        state.emit();
+    };
+    /** Shift+Tab: advance to the next configured session mode. Cycling starts
+     *  from the mode DERIVED from the session log (never a stored index), so
+     *  manual `/plan` use can never desync the cycle. */
+    const cycleMode = async () => {
+        const capture = binding.capture();
+        if (!current(capture))
+            return;
+        const index = deriveModeIndex(snapshotLiveSessionEvents(capturedSession(capture)));
+        await applyMode(sessionModes[(index + 1) % sessionModes.length], capture);
+    };
+    const onSessionEvent = (session, event) => {
+        const capture = binding.capture();
+        if (!current(capture) || session !== capturedSession(capture))
+            return;
+        const eventType = event.type;
+        if (eventType === 'plan/mode' || eventType === 'sandbox/mode' || eventType === 'approval/policy') {
+            refreshMode();
+        }
+        if (eventType !== 'plan/mode' || event.data.active !== false)
+            return;
+        const target = prePlanModes.get(session) ?? prePlanModeSpec(snapshotLiveSessionEvents(session));
+        prePlanModes.delete(session);
+        if (explicitPlanExits.delete(session) || target === undefined)
+            return;
+        const queued = pendingPlanExitRestores.has(session);
+        pendingPlanExitRestores.set(session, { capture, target });
+        if (queued)
+            return;
+        queueMicrotask(() => {
+            const restore = pendingPlanExitRestores.get(session);
+            pendingPlanExitRestores.delete(session);
+            if (restore === undefined || !current(restore.capture) || session !== capturedSession(restore.capture) || foldPlanActive(snapshotLiveSessionEvents(session)))
+                return;
+            // Shadow still projects the observed plan/mode event above, but never
+            // schedules a compensating sandbox/approval write into the real log.
+            if (runtime.mode === 'passive-shadow' || runtime.mode === 'replay-shadow')
+                return;
+            applyMode(restore.target, restore.capture).catch(error => {
+                ctx.logger.warn(`dsh-tui: plan-exit mode restore failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        });
+    };
+    return { refreshMode, cycleMode, applyMode, onSessionEvent };
+}

package/lib/types/dsh-adapter/channel/mode-permission-actions.d.ts

@@ -0,0 +1,35 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type SessionModeSpec } from '../../sessionModes.js';
+import type { createChannelBinding } from './binding.js';
+import { createModeActions } from './mode-actions.js';
+import { type PermissionIdentity } from './mode-permission.js';
+import type { PermissionModeRoster } from './mode-roster.js';
+import type { ChannelState } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+type ModeState = Pick<ChannelState, 'mode' | 'modeIndex' | 'emit'>;
+type ModeCapture = ReturnType<Binding['capture']>;
+/** The composition seam `createModeActions` owns; this factory forwards every
+ *  member verbatim so both stay in lockstep. */
+type BaseModeActionDeps = Parameters<typeof createModeActions>[2];
+/**
+ * Permission-aware session-mode actions: main's mode transition (plan
+ * exclusivity, atom application, plan-exit restore) composed with the durable
+ * permission identity, on top of the refactored `createModeActions`.
+ *
+ * Construction is inert. The returned shape is a superset of
+ * `ReturnType<typeof createModeActions>`, so the composition root and
+ * `createBindingEvents` can consume it unchanged, plus
+ * `runPermissionPreset` for the public `ChannelUi` surface.
+ */
+export declare function createPermissionModeActions(ctx: Context, state: ModeState, deps: Pick<BaseModeActionDeps, 'owner' | 'runtime' | 'binding' | 'sessionModes' | 'commandService' | 'executeRegistryCommand' | 'notify'> & {
+    roster: PermissionModeRoster;
+}): {
+    refreshMode(): void;
+    cycleMode(): Promise<void>;
+    applyMode(spec: SessionModeSpec, capture?: ModeCapture): Promise<void>;
+    onSessionEvent(session: unknown, event: unknown): void;
+    runPermissionPreset(name: string): Promise<boolean>;
+    permission: PermissionIdentity;
+};
+export {};
+//# sourceMappingURL=mode-permission-actions.d.ts.map

package/lib/types/dsh-adapter/channel/mode-permission-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-permission-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/mode-permission-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAKlD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAkD,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtD,KAAK,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC,CAAA;AAClE,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;AACjD;gDACgD;AAChD,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAA;AAmEjE;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,IAAI,CACR,kBAAkB,EAClB,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,cAAc,GAAG,gBAAgB,GAAG,wBAAwB,GAAG,QAAQ,CAC1G,GAAG;IAAE,MAAM,EAAE,oBAAoB,CAAA;CAAE,GACnC;IACD,WAAW,IAAI,IAAI,CAAA;IACnB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,SAAS,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtE,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IACtD,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACnD,UAAU,EAAE,kBAAkB,CAAA;CAC/B,CAuHA"}

package/lib/types/dsh-adapter/channel/mode-permission-actions.js

@@ -0,0 +1,199 @@
+import { assertShadowPolicy } from '../../adapter/kernel/runtime.js';
+import { t } from '../../i18n.js';
+import { modeDisplayName } from '../../sessionModes.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+import { createModeActions } from './mode-actions.js';
+import { createPermissionIdentity, foldPermissionPreset } from './mode-permission.js';
+// Atom folds mirrored from mode-actions.ts: `createModeActions` does not
+// export them, and the permission-aware derive below must reproduce its
+// atom fallback exactly to stay the single source of the indicator.
+const foldPlanActive = (events) => {
+    let active = false;
+    for (const event of events) {
+        if (event.type === 'plan/mode') {
+            active = event.data.active === true;
+        }
+    }
+    return active;
+};
+const foldSandboxMode = (events) => {
+    let mode;
+    for (const event of events) {
+        if (event.type === 'sandbox/mode') {
+            const value = event.data.mode;
+            if (typeof value === 'string')
+                mode = value;
+        }
+    }
+    return mode;
+};
+const foldApprovalPolicy = (events) => {
+    let policy;
+    for (const event of events) {
+        if (event.type === 'approval/policy') {
+            const value = event.data.policy;
+            if (typeof value === 'string')
+                policy = value;
+        }
+    }
+    return policy;
+};
+/**
+ * Durable-identity-first mode index. A durable permission identity is
+ * STRONGER than the derived sandbox/approval atoms: it keeps a runtime preset
+ * (including one that maps to the same atoms as a static mode) selected after
+ * resume or manual commands instead of snapping to a look-alike static mode.
+ * Permission-only dynamic specs declare no atoms and would wildcard-match ANY
+ * session state, so they can only be selected through the identity branch —
+ * never through the atom fallback.
+ */
+function derivePermissionModeIndex(modes, events) {
+    const identity = foldPermissionPreset(events);
+    if (identity !== undefined) {
+        const permissionIndex = modes.findIndex(spec => spec.permission === identity
+            && (spec.plan === undefined || foldPlanActive(events) === spec.plan));
+        if (permissionIndex >= 0)
+            return permissionIndex;
+    }
+    const index = modes.findIndex(spec => spec.permission === undefined
+        && (spec.plan === undefined || foldPlanActive(events) === spec.plan)
+        && (spec.sandbox === undefined || foldSandboxMode(events) === spec.sandbox)
+        && (spec.approval === undefined || foldApprovalPolicy(events) === spec.approval));
+    return index >= 0 ? index : 0;
+}
+/**
+ * Permission-aware session-mode actions: main's mode transition (plan
+ * exclusivity, atom application, plan-exit restore) composed with the durable
+ * permission identity, on top of the refactored `createModeActions`.
+ *
+ * Construction is inert. The returned shape is a superset of
+ * `ReturnType<typeof createModeActions>`, so the composition root and
+ * `createBindingEvents` can consume it unchanged, plus
+ * `runPermissionPreset` for the public `ChannelUi` surface.
+ */
+export function createPermissionModeActions(ctx, state, deps) {
+    const { owner, binding, sessionModes, roster, commandService, executeRegistryCommand, notify } = deps;
+    const base = createModeActions(ctx, state, {
+        owner,
+        runtime: deps.runtime,
+        binding,
+        sessionModes,
+        commandService,
+        executeRegistryCommand,
+        notify,
+    });
+    const permission = createPermissionIdentity(ctx, {
+        agent: () => binding.agent,
+        roster,
+        commandService,
+        executeRegistryCommand,
+        notify,
+    });
+    // An in-turn /plan off commits at pre-step, after the command has returned.
+    const explicitPlanExits = new WeakSet();
+    /** Re-derive the roster and the current mode. The roster rebuild rides on
+     *  every refresh: a registry mount/unmount and a re-bind both land here. */
+    const refreshMode = () => {
+        roster.rebuild(binding.agent);
+        const index = derivePermissionModeIndex(sessionModes, snapshotLiveSessionEvents(binding.agent.session));
+        state.modeIndex = index;
+        state.mode = sessionModes[index];
+    };
+    /** Apply the configured atoms; an explicit exit owns its target mode.
+     *  Permission identity is applied BEFORE plan and atom changes: dynamic
+     *  presets use the official command path (or the service write fallback)
+     *  and are confirmed by event/registry readback; the TUI never manufactures
+     *  permission events. */
+    const applyMode = async (spec, capture = binding.capture()) => {
+        if (!owner.current() || !binding.isCurrent(capture))
+            return;
+        // This action writes durable session policy; the permission switch writes
+        // the same kind of durable identity, so it is under the same guard.
+        assertShadowPolicy('mutate', deps.runtime.mode);
+        const agent = capture.agent;
+        const session = agent.session;
+        const planMode = ctx.get('planMode');
+        const planActive = foldPlanActive(snapshotLiveSessionEvents(session));
+        const planChange = spec.plan !== undefined && (planMode?.get?.(agent).pending ?? planActive) !== spec.plan;
+        if (planActive && planMode?.get?.(agent).pending === undefined) {
+            explicitPlanExits.delete(session);
+        }
+        // Capture the pre-plan preset identity BEFORE any permission
+        // canonicalization can append replacement events.
+        if (planChange && spec.plan === true && !planActive) {
+            permission.rememberPrePlanIdentity(session);
+        }
+        if (planChange && spec.plan === false) {
+            // An explicit switch away from plan owns its target mode; the
+            // remembered pre-plan identity no longer applies.
+            explicitPlanExits.add(session);
+            permission.forgetPrePlanIdentity(session);
+        }
+        if (spec.permission !== undefined) {
+            if (!(await permission.applyPermissionIdentity(spec.permission)))
+                return;
+        }
+        else if (!(await permission.canonicalizeForMode(spec, session))) {
+            return;
+        }
+        if (!owner.current() || !binding.isCurrent(capture) || session !== agent.session)
+            return;
+        await base.applyMode(spec, capture);
+        if (!owner.current() || !binding.isCurrent(capture))
+            return;
+        const before = state.modeIndex;
+        refreshMode();
+        if (state.modeIndex !== before)
+            state.emit();
+    };
+    /** Shift+Tab: advance from the mode DERIVED from the session log (never a
+     *  stored index), so manual `/plan` use can never desync the cycle. */
+    const cycleMode = async () => {
+        const capture = binding.capture();
+        if (!owner.current() || !binding.isCurrent(capture))
+            return;
+        const index = derivePermissionModeIndex(sessionModes, snapshotLiveSessionEvents(capture.agent.session));
+        await applyMode(sessionModes[(index + 1) % sessionModes.length], capture);
+    };
+    const onSessionEvent = (session, event) => {
+        const subject = session;
+        const sessionEvent = event;
+        base.onSessionEvent(subject, sessionEvent);
+        const type = sessionEvent.type;
+        if (type === 'permission/preset')
+            refreshMode();
+        if (type !== 'plan/mode' || sessionEvent.data.active !== false)
+            return;
+        const remembered = permission.prePlanPermissionIdentity(subject);
+        const explicit = explicitPlanExits.delete(subject);
+        permission.forgetPrePlanIdentity(subject);
+        if (explicit || remembered === undefined)
+            return;
+        if (subject !== binding.agent.session)
+            return;
+        // The atom restore is queued by the base actions in this same turn; the
+        // identity restore runs after it and re-seats the user on their own
+        // preset. Both write the same atom values, so the order cannot diverge.
+        queueMicrotask(() => {
+            if (subject !== binding.agent.session || foldPlanActive(snapshotLiveSessionEvents(subject)))
+                return;
+            void permission.applyPermissionIdentity(remembered).then((ok) => {
+                if (!ok || subject !== binding.agent.session)
+                    return;
+                refreshMode();
+                notify(t('mode-switched', { name: modeDisplayName(state.mode) }));
+                state.emit();
+            }).catch(() => {
+                // Best-effort; failures already surfaced through applyPermissionIdentity.
+            });
+        });
+    };
+    return {
+        refreshMode,
+        cycleMode,
+        applyMode,
+        onSessionEvent,
+        runPermissionPreset: name => permission.runPermissionPreset(name),
+        permission,
+    };
+}

package/lib/types/dsh-adapter/channel/mode-permission.d.ts

@@ -0,0 +1,58 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import { type SessionModeSpec } from '../../sessionModes.js';
+import type { PermissionModeRoster } from './mode-roster.js';
+import type { ChannelState } from './types.js';
+/** Last durable permission preset identity (`permission/preset`), if any.
+ *  Registered by the harness permission preset service, never manufactured
+ *  by the TUI. */
+export declare function foldPermissionPreset(events: readonly SessionEvent[]): string | undefined;
+/** Effective sandbox of a mode target: its explicit atom, else the folded
+ *  session value, else the sandbox-policy service default. Unknown means the
+ *  bundle is not safely mappable. */
+export declare function effectiveSandboxForMode(ctx: Context, spec: SessionModeSpec, events: readonly SessionEvent[]): SessionModeSpec['sandbox'] | undefined;
+/** Effective approval policy of a mode target: its explicit atom, else the
+ *  folded session value, else the approval service configuration. */
+export declare function effectiveApprovalForMode(ctx: Context, spec: SessionModeSpec, session: Agent['session']): SessionModeSpec['approval'] | undefined;
+/** Durable permission identity operations for one channel. */
+export interface PermissionIdentity {
+    /** Folded durable identity of one session log. */
+    foldPermissionPreset(session: Agent['session']): string | undefined;
+    /** Canonical preset for a mode's effective sandbox/approval bundle, when
+     *  the deployment's runtime table (or the stock built-ins) has one. */
+    canonicalPermissionForMode(spec: SessionModeSpec, session: Agent['session']): string | undefined;
+    /** True when the durable identity OR a runtime registry readback reports
+     *  the target. */
+    permissionTargetConfirmed(target: string, session: Agent['session']): boolean;
+    /** Poll fold/registry readback for the target within a grace window. */
+    confirmPermissionTarget(target: string, session: Agent['session'], timeoutMs: number): Promise<boolean>;
+    /** Official `/permission <preset>` switch (or the service write fallback),
+     *  then confirmation. The TUI never fabricates permission events. */
+    applyPermissionIdentity(target: string): Promise<boolean>;
+    /** Static-mode guard: canonicalize a durable identity BEFORE atoms, and
+     *  fail closed when no canonical preset exists for the target bundle. */
+    canonicalizeForMode(spec: SessionModeSpec, session: Agent['session']): Promise<boolean>;
+    /** Capture the preset the user is on before plan mode runs. */
+    rememberPrePlanIdentity(session: Agent['session']): void;
+    /** The captured pre-plan identity, if one is still pending. */
+    prePlanPermissionIdentity(session: Agent['session']): string | undefined;
+    forgetPrePlanIdentity(session: Agent['session']): void;
+    /** `ChannelUi.runPermissionPreset` (see the public Channel type). */
+    runPermissionPreset(name: string): Promise<boolean>;
+}
+/**
+ * Durable `permission/preset` identity: readback, canonical mapping, the
+ * official switch path, and the pre-plan identity memory. Construction is
+ * inert — it acquires nothing and subscribes to nothing.
+ */
+export declare function createPermissionIdentity(ctx: Context, deps: {
+    agent: () => Agent;
+    roster: PermissionModeRoster;
+    commandService?: {
+        find(agent: Agent, name: string): unknown;
+    };
+    executeRegistryCommand(name: string, input: string): Promise<string | undefined>;
+    notify: ChannelState['notify'];
+}): PermissionIdentity;
+//# sourceMappingURL=mode-permission.d.ts.map

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

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