@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/panels/panel-manager.js

@@ -0,0 +1,481 @@
+// ---------------------------------------------------------------------------
+// PanelManager — central manager for panel lifecycle, navigation, and split
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// PanelManager
+// ---------------------------------------------------------------------------
+export class PanelManager {
+    registry = [];
+    retainedPanels = new Map();
+    _visible = false;
+    _splitRatio = 0.6;
+    // Two panes for the top/bottom split within the panel area
+    topPane = { panels: [], activeIndex: 0 };
+    bottomPane = { panels: [], activeIndex: 0 };
+    _focusedPane = 'top';
+    _verticalSplitRatio = 0.5; // top gets 50% of panel height
+    _bottomPaneVisible = false;
+    // -------------------------------------------------------------------------
+    // Registration
+    // -------------------------------------------------------------------------
+    registerType(registration) {
+        const existing = this.registry.findIndex(r => r.id === registration.id);
+        if (existing >= 0) {
+            this.registry[existing] = registration;
+        }
+        else {
+            this.registry.push(registration);
+        }
+    }
+    getRegisteredTypes() {
+        return [...this.registry];
+    }
+    getTypesByCategory() {
+        const map = new Map();
+        for (const reg of this.registry) {
+            const list = map.get(reg.category) ?? [];
+            list.push(reg);
+            map.set(reg.category, list);
+        }
+        return map;
+    }
+    prewarmRegistered() {
+        for (const registration of this.registry) {
+            if (!registration.preload)
+                continue;
+            if (this.getPanel(registration.id) || this.retainedPanels.has(registration.id))
+                continue;
+            const panel = registration.factory();
+            this.retainedPanels.set(registration.id, panel);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Panel lifecycle — operates on a specific pane (defaults to focused)
+    // -------------------------------------------------------------------------
+    open(panelId, pane) {
+        const existingPane = this._findPaneOf(panelId);
+        if (existingPane) {
+            this._activateByIdInPane(panelId, existingPane);
+            this._visible = true;
+            this._focusedPane = existingPane;
+            if (existingPane === 'bottom')
+                this._bottomPaneVisible = true;
+            return this._getPane(existingPane).panels[this._getPane(existingPane).activeIndex];
+        }
+        const targetPane = pane ?? this._focusedPane;
+        const p = this._getPane(targetPane);
+        const oldPanel = p.panels[p.activeIndex];
+        if (oldPanel)
+            oldPanel.onDeactivate();
+        const panel = this._obtainPanel(panelId);
+        p.panels.push(panel);
+        p.activeIndex = p.panels.length - 1;
+        this._visible = true;
+        // If opening into bottom pane, also make it visible
+        if (targetPane === 'bottom') {
+            this._bottomPaneVisible = true;
+            this._focusedPane = 'bottom';
+        }
+        else {
+            this._focusedPane = 'top';
+        }
+        panel.onActivate();
+        return panel;
+    }
+    close(panelId) {
+        // Search both panes
+        for (const which of ['top', 'bottom']) {
+            const p = this._getPane(which);
+            const index = p.panels.findIndex(panel => panel.id === panelId);
+            if (index < 0)
+                continue;
+            const panel = p.panels[index];
+            const wasActive = index === p.activeIndex;
+            if (wasActive)
+                panel.onDeactivate();
+            if (this._shouldRetain(panelId)) {
+                this.retainedPanels.set(panelId, panel);
+            }
+            else {
+                panel.onDestroy();
+            }
+            p.panels.splice(index, 1);
+            if (p.panels.length === 0) {
+                p.activeIndex = 0;
+                if (which === 'bottom') {
+                    this._bottomPaneVisible = false;
+                    // Move focus to top if we were focused on empty bottom
+                    if (this._focusedPane === 'bottom')
+                        this._focusedPane = 'top';
+                }
+            }
+            else {
+                p.activeIndex = Math.min(p.activeIndex, p.panels.length - 1);
+                if (wasActive) {
+                    const newActive = p.panels[p.activeIndex];
+                    if (newActive)
+                        newActive.onActivate();
+                }
+            }
+            // Hide sidebar if no panels remain in either pane
+            if (this.topPane.panels.length === 0 && this.bottomPane.panels.length === 0) {
+                this._visible = false;
+            }
+            return;
+        }
+    }
+    /**
+     * Move a panel to a specific pane. If panelId is omitted, moves the active
+     * panel from the currently focused pane.
+     */
+    moveToPane(dest, panelId) {
+        const srcPaneName = panelId
+            ? this._findPaneOf(panelId) ?? this._focusedPane
+            : this._focusedPane;
+        if (srcPaneName === dest)
+            return; // already there
+        const dstPaneName = dest;
+        this._moveBetweenPanes(srcPaneName, dstPaneName, panelId);
+    }
+    /**
+     * Move a panel to the other pane. If panelId is omitted, moves the active
+     * panel from the currently focused pane.
+     */
+    moveToOtherPane(panelId) {
+        const srcPaneName = panelId
+            ? this._findPaneOf(panelId) ?? this._focusedPane
+            : this._focusedPane;
+        const dstPaneName = srcPaneName === 'top' ? 'bottom' : 'top';
+        this._moveBetweenPanes(srcPaneName, dstPaneName, panelId);
+    }
+    // -------------------------------------------------------------------------
+    // Navigation — operates on focused pane
+    // -------------------------------------------------------------------------
+    nextPanel() {
+        const p = this._getFocusedPane();
+        if (p.panels.length === 0)
+            return;
+        const oldPanel = p.panels[p.activeIndex];
+        if (oldPanel)
+            oldPanel.onDeactivate();
+        p.activeIndex = (p.activeIndex + 1) % p.panels.length;
+        const newPanel = p.panels[p.activeIndex];
+        if (newPanel)
+            newPanel.onActivate();
+    }
+    nextWorkspaceTab() {
+        this._cycleWorkspaceTab(1);
+    }
+    prevWorkspaceTab() {
+        this._cycleWorkspaceTab(-1);
+    }
+    prevPanel() {
+        const p = this._getFocusedPane();
+        if (p.panels.length === 0)
+            return;
+        const oldPanel = p.panels[p.activeIndex];
+        if (oldPanel)
+            oldPanel.onDeactivate();
+        p.activeIndex = (p.activeIndex - 1 + p.panels.length) % p.panels.length;
+        const newPanel = p.panels[p.activeIndex];
+        if (newPanel)
+            newPanel.onActivate();
+    }
+    activateByIndex(index) {
+        const p = this._getFocusedPane();
+        if (index < 0 || index >= p.panels.length)
+            return;
+        if (index === p.activeIndex)
+            return;
+        const oldPanel = p.panels[p.activeIndex];
+        if (oldPanel)
+            oldPanel.onDeactivate();
+        p.activeIndex = index;
+        const newPanel = p.panels[p.activeIndex];
+        if (newPanel)
+            newPanel.onActivate();
+    }
+    activateById(panelId) {
+        const which = this._findPaneOf(panelId);
+        if (!which)
+            return;
+        this._activateByIdInPane(panelId, which);
+    }
+    // -------------------------------------------------------------------------
+    // Pane focus control
+    // -------------------------------------------------------------------------
+    focusPane(pane) {
+        if (pane === 'bottom' && !this._bottomPaneVisible)
+            return;
+        this._focusedPane = pane;
+    }
+    getFocusedPane() {
+        return this._focusedPane;
+    }
+    /** Get the currently active (focused) panel, or null if none. */
+    getActivePanel() {
+        const p = this._getFocusedPane();
+        return p.panels[p.activeIndex] ?? null;
+    }
+    togglePaneFocus() {
+        if (!this._bottomPaneVisible || this.bottomPane.panels.length === 0)
+            return;
+        this._focusedPane = this._focusedPane === 'top' ? 'bottom' : 'top';
+    }
+    // -------------------------------------------------------------------------
+    // Pane visibility
+    // -------------------------------------------------------------------------
+    toggleBottomPane() {
+        if (this._bottomPaneVisible) {
+            this._bottomPaneVisible = false;
+            if (this._focusedPane === 'bottom')
+                this._focusedPane = 'top';
+        }
+        else {
+            this._bottomPaneVisible = true;
+            // If bottom pane is empty, populate it
+            if (this.bottomPane.panels.length === 0) {
+                if (this.topPane.panels.length > 1) {
+                    // Move last panel from top to bottom
+                    const panel = this.topPane.panels.pop();
+                    if (this.topPane.activeIndex >= this.topPane.panels.length) {
+                        this.topPane.activeIndex = Math.max(0, this.topPane.panels.length - 1);
+                    }
+                    this.bottomPane.panels.push(panel);
+                    this.bottomPane.activeIndex = 0;
+                }
+                else {
+                    // Open a default panel in bottom pane
+                    const firstType = this.registry[0];
+                    if (firstType) {
+                        this.open(firstType.id, 'bottom');
+                    }
+                }
+            }
+            this._focusedPane = 'bottom';
+        }
+    }
+    isBottomPaneVisible() {
+        return this._bottomPaneVisible && this.bottomPane.panels.length > 0;
+    }
+    // -------------------------------------------------------------------------
+    // Pane state accessors
+    // -------------------------------------------------------------------------
+    getTopPane() {
+        return this.topPane;
+    }
+    getBottomPane() {
+        return this.bottomPane;
+    }
+    // -------------------------------------------------------------------------
+    // Backward-compatible accessors (operate on focused pane)
+    // -------------------------------------------------------------------------
+    getOpen() {
+        const p = this._getFocusedPane();
+        return [...p.panels];
+    }
+    /**
+     * Returns all panels across both panes (top then bottom).
+     * Use this when you need to know if any panels exist at all.
+     */
+    getAllOpen() {
+        return [...this.topPane.panels, ...this.bottomPane.panels];
+    }
+    getActive() {
+        const p = this._getFocusedPane();
+        if (p.panels.length === 0)
+            return null;
+        return p.panels[p.activeIndex] ?? null;
+    }
+    getPanel(panelId) {
+        return this.topPane.panels.find((panel) => panel.id === panelId)
+            ?? this.bottomPane.panels.find((panel) => panel.id === panelId)
+            ?? null;
+    }
+    getPaneOf(panelId) {
+        return this._findPaneOf(panelId);
+    }
+    getWorkspaceTabs() {
+        const focusedPanelId = this.getActivePanel()?.id;
+        const topTabs = this.topPane.panels.map((panel) => ({
+            id: panel.id,
+            name: panel.name,
+            icon: panel.icon,
+            pane: 'top',
+            active: panel.id === focusedPanelId,
+            focused: panel.id === focusedPanelId,
+        }));
+        const bottomTabs = this.bottomPane.panels.map((panel) => ({
+            id: panel.id,
+            name: panel.name,
+            icon: panel.icon,
+            pane: 'bottom',
+            active: panel.id === focusedPanelId,
+            focused: panel.id === focusedPanelId,
+        }));
+        return [...topTabs, ...bottomTabs];
+    }
+    activateWorkspaceIndex(index) {
+        const tabs = this.getWorkspaceTabs();
+        if (index < 0 || index >= tabs.length)
+            return;
+        const tab = tabs[index];
+        this._focusedPane = tab.pane;
+        if (tab.pane === 'bottom')
+            this._bottomPaneVisible = true;
+        this._activateByIdInPane(tab.id, tab.pane);
+    }
+    // -------------------------------------------------------------------------
+    // Visibility
+    // -------------------------------------------------------------------------
+    toggle() {
+        this._visible = !this._visible;
+        // Auto-open a default panel if toggling visible with nothing open
+        if (this._visible && this.topPane.panels.length === 0 && this.bottomPane.panels.length === 0) {
+            const defaultPanel = this._getRegistration('panel-list') ?? this.registry[0];
+            if (defaultPanel)
+                this.open(defaultPanel.id);
+        }
+    }
+    show() {
+        this._visible = true;
+    }
+    hide() {
+        this._visible = false;
+    }
+    isVisible() {
+        return this._visible;
+    }
+    // -------------------------------------------------------------------------
+    // Horizontal split control (left/right)
+    // -------------------------------------------------------------------------
+    getSplitRatio() {
+        return this._splitRatio;
+    }
+    setSplitRatio(ratio) {
+        this._splitRatio = Math.max(0.3, Math.min(0.85, ratio));
+    }
+    widenLeft() {
+        this.setSplitRatio(this._splitRatio + 0.05);
+    }
+    widenRight() {
+        this.setSplitRatio(this._splitRatio - 0.05);
+    }
+    getLeftWidth(totalWidth) {
+        return Math.floor(totalWidth * this._splitRatio);
+    }
+    getRightWidth(totalWidth) {
+        return totalWidth - this.getLeftWidth(totalWidth);
+    }
+    // -------------------------------------------------------------------------
+    // Vertical split control (top/bottom within panel area)
+    // -------------------------------------------------------------------------
+    getVerticalSplitRatio() {
+        return this._verticalSplitRatio;
+    }
+    setVerticalSplitRatio(ratio) {
+        this._verticalSplitRatio = Math.max(0.2, Math.min(0.8, ratio));
+    }
+    // -------------------------------------------------------------------------
+    // Cleanup
+    // -------------------------------------------------------------------------
+    destroyAll() {
+        for (const panel of [...this.topPane.panels, ...this.bottomPane.panels, ...this.retainedPanels.values()]) {
+            panel.onDestroy();
+        }
+        this.topPane = { panels: [], activeIndex: 0 };
+        this.bottomPane = { panels: [], activeIndex: 0 };
+        this.retainedPanels.clear();
+        this.registry = [];
+        this._focusedPane = 'top';
+        this._bottomPaneVisible = false;
+        this._visible = false;
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    _getPane(which) {
+        return which === 'top' ? this.topPane : this.bottomPane;
+    }
+    _getFocusedPane() {
+        return this._getPane(this._focusedPane);
+    }
+    _findPaneOf(panelId) {
+        if (this.topPane.panels.some(p => p.id === panelId))
+            return 'top';
+        if (this.bottomPane.panels.some(p => p.id === panelId))
+            return 'bottom';
+        return null;
+    }
+    _moveBetweenPanes(srcPaneName, dstPaneName, panelId) {
+        const src = this._getPane(srcPaneName);
+        const dst = this._getPane(dstPaneName);
+        const id = panelId ?? src.panels[src.activeIndex]?.id;
+        if (!id)
+            return;
+        const index = src.panels.findIndex(p => p.id === id);
+        if (index < 0)
+            return;
+        const panel = src.panels[index];
+        const wasActive = index === src.activeIndex;
+        if (wasActive)
+            panel.onDeactivate();
+        src.panels.splice(index, 1);
+        src.activeIndex = Math.min(src.activeIndex, Math.max(0, src.panels.length - 1));
+        if (wasActive && src.panels.length > 0) {
+            src.panels[src.activeIndex]?.onActivate();
+        }
+        // Deactivate current active in dest
+        const oldDstActive = dst.panels[dst.activeIndex];
+        if (oldDstActive)
+            oldDstActive.onDeactivate();
+        dst.panels.push(panel);
+        dst.activeIndex = dst.panels.length - 1;
+        panel.onActivate();
+        if (dstPaneName === 'bottom') {
+            this._bottomPaneVisible = true;
+        }
+        this._focusedPane = dstPaneName;
+    }
+    _cycleWorkspaceTab(direction) {
+        const tabs = this.getWorkspaceTabs();
+        if (tabs.length === 0)
+            return;
+        const currentIndex = tabs.findIndex((tab) => tab.focused);
+        const nextIndex = currentIndex < 0
+            ? 0
+            : (currentIndex + direction + tabs.length) % tabs.length;
+        this.activateWorkspaceIndex(nextIndex);
+    }
+    _obtainPanel(panelId) {
+        const retained = this.retainedPanels.get(panelId);
+        if (retained) {
+            this.retainedPanels.delete(panelId);
+            return retained;
+        }
+        const registration = this._getRegistration(panelId);
+        if (!registration) {
+            throw new Error(`No panel type registered with id: ${panelId}`);
+        }
+        return registration.factory();
+    }
+    _getRegistration(panelId) {
+        return this.registry.find((registration) => registration.id === panelId);
+    }
+    _shouldRetain(panelId) {
+        return this._getRegistration(panelId)?.preload === true;
+    }
+    _activateByIdInPane(panelId, which) {
+        const p = this._getPane(which);
+        const index = p.panels.findIndex(panel => panel.id === panelId);
+        if (index >= 0 && index !== p.activeIndex) {
+            const oldPanel = p.panels[p.activeIndex];
+            if (oldPanel)
+                oldPanel.onDeactivate();
+            p.activeIndex = index;
+            const newPanel = p.panels[p.activeIndex];
+            if (newPanel)
+                newPanel.onActivate();
+        }
+    }
+}

package/dist/_internal/platform/panels/types.d.ts

@@ -0,0 +1,30 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import type { PanelResourceContract, PanelHealthState } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-contracts';
+export type PanelCategory = 'development' | 'agent' | 'monitoring' | 'session' | 'ai';
+export interface Panel {
+    id: string;
+    name: string;
+    icon: string;
+    category: PanelCategory;
+    onActivate(): void;
+    onDeactivate(): void;
+    onDestroy(): void;
+    render(width: number, height: number): Line[];
+    isTransient: boolean;
+    isPinned: boolean;
+    needsRender: boolean;
+    resourceContract?: Readonly<PanelResourceContract>;
+    healthState?: Readonly<PanelHealthState>;
+    handleInput?(key: string): boolean;
+}
+export interface PanelRegistration extends Pick<Panel, 'id' | 'name' | 'icon' | 'category'> {
+    factory: () => Panel;
+    description: string;
+    /**
+     * Instantiate this panel during bootstrap and retain the instance when it is
+     * closed so its background data continues to accumulate before the user
+     * actively opens the workspace.
+     */
+    preload?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/platform/panels/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/panels/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2CAA2C,CAAC;AACtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,6DAA6D,CAAC;AAE3H,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,GAAG,IAAI,CAAC;AAEtF,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,aAAa,CAAC;IAGxB,UAAU,IAAI,IAAI,CAAC;IACnB,YAAY,IAAI,IAAI,CAAC;IACrB,SAAS,IAAI,IAAI,CAAC;IAGlB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,CAAC;IAG9C,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IAGrB,gBAAgB,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;IAGnD,WAAW,CAAC,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAGzC,WAAW,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,iBAAkB,SAAQ,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;IACzF,OAAO,EAAE,MAAM,KAAK,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/dist/_internal/platform/panels/types.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/platform/permissions/briefs/build.d.ts

@@ -0,0 +1,5 @@
+import type { PermissionPromptRequest } from '../prompt.js';
+import type { PermissionApprovalBrief } from '@pellux/goodvibes-sdk/platform/permissions/briefs/types';
+export declare function getDisplayArg(_tool: string, args: Record<string, unknown>): string;
+export declare function buildPermissionApprovalBrief(request: PermissionPromptRequest): PermissionApprovalBrief;
+//# sourceMappingURL=build.d.ts.map

package/dist/_internal/platform/permissions/briefs/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/permissions/briefs/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAG5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yDAAyD,CAAC;AAGvG,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAMlF;AA+DD,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,uBAAuB,GAAG,uBAAuB,CAYtG"}

package/dist/_internal/platform/permissions/briefs/build.js

@@ -0,0 +1,82 @@
+import { classifyPermissionRiskFamily } from '@pellux/goodvibes-sdk/platform/runtime/permissions/risk-model';
+import { explainPermissionRiskFamily } from '@pellux/goodvibes-sdk/platform/runtime/permissions/risk-language';
+export function getDisplayArg(_tool, args) {
+    if (typeof args['path'] === 'string')
+        return args['path'];
+    if (typeof args['command'] === 'string')
+        return args['command'];
+    if (typeof args['pattern'] === 'string')
+        return args['pattern'];
+    const first = Object.values(args)[0];
+    return typeof first === 'string' ? first : JSON.stringify(args).slice(0, 60);
+}
+function fallbackAnalysis(request) {
+    return request.analysis ?? {
+        classification: request.category,
+        riskLevel: request.category === 'read' ? 'low' : request.category === 'write' ? 'medium' : 'high',
+        summary: `Review ${request.tool} request`,
+        reasons: ['Inspect the target and intent before approving this action.'],
+        target: getDisplayArg(request.tool, request.args),
+        targetKind: 'generic',
+    };
+}
+function subjectLabel(analysis) {
+    switch (analysis.targetKind) {
+        case 'command': return 'Command';
+        case 'path': return 'Path';
+        case 'url': return 'URL';
+        case 'task': return 'Task';
+        default: return 'Target';
+    }
+}
+function titleForRisk(decisionModeLabel) {
+    const TITLES = {
+        delegation: 'Agent Delegation Approval',
+        'shell-read': 'Shell Execution Approval',
+        'shell-execution': 'Shell Execution Approval',
+        'network-egress': 'Network Access Approval',
+        'external-access': 'Network Access Approval',
+        'config-mutation': 'Configuration Mutation Approval',
+        'mcp-escalation': 'MCP Trust Escalation Approval',
+    };
+    const mapped = TITLES[decisionModeLabel];
+    if (mapped)
+        return mapped;
+    const headline = decisionModeLabel.replace(/-/g, ' ');
+    return headline.replace(/\b\w/g, (char) => char.toUpperCase()) + ' Approval';
+}
+function decisionModeLabelForRisk(family) {
+    switch (family) {
+        case 'shell-read':
+        case 'shell-mutation':
+        case 'shell-destructive':
+            return 'shell-execution';
+        case 'network-egress':
+            return 'external-access';
+        default:
+            return family;
+    }
+}
+function checklistForDecision(family, decisionModeLabel) {
+    switch (decisionModeLabel) {
+        case 'shell-execution':
+            return explainPermissionRiskFamily('shell-mutation');
+        case 'external-access':
+            return explainPermissionRiskFamily('network-egress');
+        default:
+            return explainPermissionRiskFamily(family);
+    }
+}
+export function buildPermissionApprovalBrief(request) {
+    const analysis = fallbackAnalysis(request);
+    const risk = classifyPermissionRiskFamily(request.tool, request.args, analysis);
+    const decisionModeLabel = decisionModeLabelForRisk(risk.family);
+    return {
+        title: titleForRisk(decisionModeLabel),
+        subjectLabel: subjectLabel(analysis),
+        subjectValue: String(analysis.target ?? getDisplayArg(request.tool, request.args)),
+        decisionModeLabel,
+        checklist: checklistForDecision(risk.family, decisionModeLabel),
+        risk,
+    };
+}

package/dist/_internal/platform/permissions/manager.d.ts

@@ -0,0 +1,52 @@
+import { getConfigSnapshot } from '../config/index.js';
+import type { PermissionRequestHandler } from './prompt.js';
+import type { PolicyRuntimeState } from '../runtime/permissions/policy-runtime.js';
+import type { HookDispatcher } from '../hooks/index.js';
+import type { ConfigManager } from '../config/manager.js';
+import type { PermissionCategory, PermissionCheckResult } from '@pellux/goodvibes-sdk/platform/permissions/types';
+export type { PermissionMode } from '@pellux/goodvibes-sdk/platform/config/schema';
+export type { PermissionCategory, PermissionRiskLevel, PermissionDecisionSource, PermissionDecisionReasonCode, PermissionRequestAnalysis, PermissionCheckResult, } from '@pellux/goodvibes-sdk/platform/permissions/types';
+type PermissionConfigSnapshot = ReturnType<typeof getConfigSnapshot>;
+export interface PermissionConfigReader {
+    isAutoApproveEnabled(): boolean;
+    getSnapshot(): PermissionConfigSnapshot;
+    getWorkingDirectory(): string | null;
+}
+export declare function createPermissionConfigReader(configManager: Pick<ConfigManager, 'get' | 'getRaw' | 'getWorkingDirectory'>): PermissionConfigReader;
+/**
+ * PermissionManager - Controls tool execution approval.
+ *
+ * Approval logic (priority order):
+ *   1. --no-worries-just-vibes flag OR mode='allow-all' -> auto-approve everything
+ *   2. mode='custom' -> check per-tool config action ('allow'/'prompt'/'deny')
+ *   3. mode='prompt' (default) -> auto-approve reads, prompt for writes/execute/delegate
+ *   4. Session approval cache hit -> use cached decision
+ *   5. Ask the shell-owned permission controller and block until user responds
+ */
+export declare class PermissionManager {
+    private sessionApprovals;
+    private readonly requestPermission;
+    private readonly configReader;
+    private readonly hookDispatcher;
+    private readonly policyRuntimeState;
+    constructor(requestPermission: PermissionRequestHandler | undefined, configReader: PermissionConfigReader, policyRuntimeState: Pick<PolicyRuntimeState, 'recordPermissionRequest' | 'recordPermissionDecision' | 'getRegistry'>, hookDispatcher?: Pick<HookDispatcher, 'fire'> | null);
+    /**
+     * check - Returns a Promise that resolves to true (approved) or false (denied).
+     * Blocks orchestrator until the user responds when a prompt is needed.
+     */
+    check(toolName: string, args: Record<string, unknown>): Promise<boolean>;
+    checkDetailed(toolName: string, args: Record<string, unknown>): Promise<PermissionCheckResult>;
+    /** Returns the permission category for a tool name. Unknown tools default to 'delegate'. */
+    getCategory(toolName: string, args?: Record<string, unknown>): PermissionCategory;
+    /**
+     * getApprovalKey - Stable key for session-level "always approve" decisions.
+     * Includes the most meaningful argument to distinguish different invocations.
+     */
+    private getApprovalKey;
+    private result;
+    private evaluateRuntimePolicy;
+    private mapEvaluatorDecision;
+    private emitAndReturn;
+    private fireHook;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/_internal/platform/permissions/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/permissions/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAwB,MAAM,oBAAoB,CAAC;AAE7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAGnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EAGtB,MAAM,kDAAkD,CAAC;AAC1D,YAAY,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AACnF,YAAY,EACV,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,kDAAkD,CAAC;AAE1D,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAErE,MAAM,WAAW,sBAAsB;IACrC,oBAAoB,IAAI,OAAO,CAAC;IAChC,WAAW,IAAI,wBAAwB,CAAC;IACxC,mBAAmB,IAAI,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,QAAQ,GAAG,qBAAqB,CAAC,GAC3E,sBAAsB,CAMxB;AAyCD;;;;;;;;;GASG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA2B;IAC7D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsC;IACrE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAmG;gBAGpI,iBAAiB,EAAE,wBAAwB,YAAqD,EAChG,YAAY,EAAE,sBAAsB,EACpC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,EAAE,yBAAyB,GAAG,0BAA0B,GAAG,aAAa,CAAC,EACpH,cAAc,GAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,IAAW;IAQ5D;;;OAGG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAKxE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAkGpG,4FAA4F;IAC5F,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,kBAAkB;IAOrF;;;OAGG;IACH,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,MAAM;IAgBd,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,oBAAoB;IAiC5B,OAAO,CAAC,aAAa;YA0BP,QAAQ;CAsBvB"}