@kortix/ui 0.0.0-stage → 0.14.4

package/dist/session/prompts/session-approval-review.js

@@ -0,0 +1,176 @@
+/** Fields that answer "what does this touch?" — surfaced first, in this order. */
+const PRIORITY_ARGS = ['to', 'recipient', 'recipients', 'channel', 'url', 'subject'];
+/** How many `key: value` pairs the one-line collapsed summary shows. */
+const SUMMARY_FIELDS = 2;
+/** A gated action still awaiting a human decision (unresolved `pending_approval`). */
+function pendingByStatus(action) {
+    return action.status === 'pending_approval' && !action.resolved_at;
+}
+/**
+ * The REDACTED arguments the gateway recorded on the row. Null for a row
+ * written before arg previews existed — callers then show the tool name alone.
+ */
+export function approvalArgsPreview(action) {
+    const summary = action.result_summary;
+    if (!summary || typeof summary !== 'object')
+        return null;
+    const preview = summary.args_preview;
+    if (!preview || typeof preview !== 'object' || Array.isArray(preview))
+        return null;
+    return preview;
+}
+/** One-line "where is this going?" rendering for a collapsed row. */
+export function approvalArgsSummary(action, 
+/** Bound Slack conversation ids → names: the summary reads the name. */
+channelNames) {
+    return previewArgsSummary(approvalArgsPreview(action), channelNames);
+}
+/** `approvalArgsSummary` for a preview record already in hand (a Review
+ *  Center item's resolved or raw arguments). */
+export function previewArgsSummary(preview, channelNames) {
+    if (!preview)
+        return null;
+    const rank = (key) => {
+        const index = PRIORITY_ARGS.indexOf(key.toLowerCase());
+        return index === -1 ? PRIORITY_ARGS.length : index;
+    };
+    const entries = Object.entries(preview).sort((left, right) => rank(left[0]) - rank(right[0]));
+    const parts = [];
+    for (const [key, value] of entries) {
+        // '[redacted]' is the server's marker for a credential-shaped field; showing
+        // it would add noise without adding information.
+        if (value === null || value === undefined || value === '[redacted]')
+            continue;
+        // A nested object reads as compact JSON, never `[object Object]`.
+        const text = (item) => item !== null && typeof item === 'object' ? JSON.stringify(item) : String(item);
+        const rendered = Array.isArray(value) ? value.map(text).join(', ') : text(value);
+        if (!rendered)
+            continue;
+        parts.push(`${key}: ${(typeof value === 'string' && channelNames?.get(value)) || rendered}`);
+        if (parts.length === SUMMARY_FIELDS)
+            break;
+    }
+    return parts.length > 0 ? parts.join(' · ') : null;
+}
+/** The summary of the content Kortix resolved, else of the call's own
+ *  arguments. An empty resolved preview (`{}`) falls through. An email (the
+ *  resolved content merged over the arguments has a recipient) reads
+ *  `to · subject`, never the sender the server loaded. */
+export function reviewArgsSummary(resolvedPreview, argsPreview) {
+    const merged = { ...argsPreview, ...resolvedPreview };
+    const to = merged.to ?? merged.recipient_email ?? merged.recipients;
+    if (to !== undefined) {
+        const text = (value) => Array.isArray(value) ? value.join(', ') : value === null || value === undefined ? '' : String(value);
+        const parts = [text(to), text(merged.subject)].filter(Boolean);
+        if (parts.length > 0)
+            return parts.join(' · ');
+    }
+    return previewArgsSummary(resolvedPreview) ?? previewArgsSummary(argsPreview);
+}
+/**
+ * Can a human actually judge this call from what we recorded?
+ *
+ * TRUNCATION IS NOT BLINDNESS. `reviewComplete` (server:
+ * `args_preview_complete`) goes false whenever the preview builder elided
+ * ANYTHING — an 11th recipient, a 96-char URL, a fourth nesting level, an
+ * attachment body — and every elision is written into the preview the human
+ * reads (`[+3 more]`, `[204800 chars omitted]`). Gating the decision on it made
+ * an ordinary "email this PDF" call permanently un-approvable: a disabled
+ * button beside a warning, with Deny as the only possible answer.
+ *
+ * Reviewability is the narrower question: is there anything to look at? A call
+ * that shows its parameters is decidable, elisions and all. One that shows none
+ * is not — and no approve path is offered for it, rather than a dead control.
+ *
+ * Content Kortix read from the provider (`resolvedPreview`) is reviewable on
+ * its own. Mirrors `approvalPreviewReviewable` in apps/api
+ * (connectors/args-preview.ts), which enforces the same rule on
+ * POST /approvals/:executionId.
+ */
+export function approvalReviewable(argsPreview, reviewComplete, resolvedPreview) {
+    if (argsPreview && Object.keys(argsPreview).length > 0)
+        return true;
+    if (resolvedPreview && Object.keys(resolvedPreview).length > 0)
+        return true;
+    // No preview is still reviewable when the server confirms nothing was
+    // withheld — an argument-less call hides nothing.
+    return reviewComplete !== false;
+}
+/** Row → the shape every approval surface renders. */
+export function approvalRequestFromAction(action, pending = pendingByStatus(action)) {
+    const summary = action.result_summary;
+    const decision = summary?.decision;
+    return {
+        action: action.action,
+        risk: action.risk,
+        requestedAt: action.at,
+        argsPreview: approvalArgsPreview(action),
+        approvalContext: typeof summary?.approval_context === 'string' ? summary.approval_context : null,
+        // Content the server loaded for a reference-only call (the draft behind a
+        // `draft_id`), labelled with the connector part of the action path.
+        resolvedPreview: summary?.resolved_preview && typeof summary.resolved_preview === 'object' && !Array.isArray(summary.resolved_preview)
+            ? summary.resolved_preview
+            : null,
+        resolvedError: typeof summary?.resolved_error === 'string' ? summary.resolved_error : null,
+        // `!summary` used to count as complete, so a pending row that recorded
+        // NOTHING offered an Approve button the server answers with 409
+        // (`APPROVAL_PREVIEW_UNAVAILABLE`) — the client and the gate disagreed. A
+        // pending row is complete only when it says so.
+        reviewComplete: !pending || summary?.args_preview_complete === true,
+        resolution: decision === 'approve' || decision === 'deny' ? decision : null,
+        pending,
+        // Absent from an API older than KRTX-1724: keep offering the decision.
+        canResolve: action.can_resolve !== false,
+        resolvers: action.resolvers ?? null,
+        status: action.status,
+        resolvedAt: action.resolved_at,
+    };
+}
+/**
+ * Who besides a project manager decides this session's calls today: the
+ * person who started it (KRTX-1724). Null when that is not a person who can
+ * decide — a service account, or a backend wrapper whose `created_by` names
+ * nobody — or when the session row does not name its owner yet.
+ */
+export function approvalLauncherName(session) {
+    if (!session || session.owner_type !== 'user' || session.origin === 'backend')
+        return null;
+    return session.owner_name || session.owner_email || null;
+}
+/**
+ * What the in-session notice renders: every unresolved approval, plus the ones
+ * this browser just decided (so the card confirms the outcome in place instead
+ * of vanishing mid-click). Newest first, matching the API's own ordering.
+ */
+export function approvalNoticeRows(actions, decided) {
+    const rows = new Map();
+    for (const action of actions) {
+        if (!pendingByStatus(action))
+            continue;
+        rows.set(action.execution_id, { action, decision: null });
+    }
+    for (const [executionId, entry] of Object.entries(decided)) {
+        rows.set(executionId, { action: entry.action, decision: entry.decision });
+    }
+    return [...rows.values()].sort((left, right) => {
+        const delta = Date.parse(right.action.at) - Date.parse(left.action.at);
+        if (delta !== 0)
+            return delta;
+        return left.action.execution_id.localeCompare(right.action.execution_id);
+    });
+}
+/** Headline for the notice. `hint` is null once nothing is left to decide. */
+export function approvalNoticeHeadline(pendingCount, tI18nComplete) {
+    if (pendingCount === 0)
+        return { title: tI18nComplete.raw('text6f1de8b7c3e5'), hint: null };
+    if (pendingCount === 1) {
+        return {
+            title: tI18nComplete.raw('textd24f71ceadfb'),
+            hint: tI18nComplete.raw('textce033f75c938'),
+        };
+    }
+    return {
+        title: tI18nComplete('text54d14f0b67f3', { value0: pendingCount }),
+        hint: tI18nComplete('text5726504025dc', { value0: pendingCount }),
+    };
+}

package/dist/session/prompts/session-permission-prompt.d.ts

@@ -0,0 +1,19 @@
+import { type PermissionRequest } from '../../internal/session-types/types.js';
+import type { PermissionConfig, PermissionRule } from '@kortix/sdk';
+/**
+ * An agent's permission rules with `type` allowed: a bare action becomes the
+ * `*` fallback of the object form, and `*` ("always allow everything") also
+ * flattens every existing rule, so no leftover `ask`/`deny` outranks it.
+ */
+export declare function permissionRulesAllowing(current: PermissionConfig | undefined, type: string): Record<string, PermissionRule>;
+interface SessionPermissionPromptProps {
+    /** The runtime session id (what `PermissionRequest.sessionID` carries). */
+    sessionId: string;
+    /** The agent the session runs: "Allow in config" writes its rules. Absent, the footer hides. */
+    agentName?: string;
+    permissions: PermissionRequest[];
+    /** Must reject on failure so busy states reset and the card stays actionable. */
+    onReply: (requestId: string, reply: 'once' | 'always' | 'reject') => Promise<void>;
+}
+export declare function SessionPermissionPrompt({ sessionId, agentName, permissions, onReply, }: SessionPermissionPromptProps): import("react").JSX.Element | null;
+export {};

package/dist/session/prompts/session-permission-prompt.js

@@ -0,0 +1,223 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslations } from '../../i18n/index.js';
+/**
+ * Inline "agent needs your permission" prompt, pinned above the composer — the
+ * runtime tool-permission twin of `SessionApprovalPrompt` (connector
+ * approvals). Answering resumes the agent's already-blocked turn in place (the
+ * runtime holds the tool call open until `/permission/{id}/reply`), so no
+ * follow-up "continue" message is ever needed. A request names a capability
+ * (`bash`, `edit`, …), not a harness's tool.
+ *
+ * Three decision scopes, visually separated by how long they last:
+ *  - per request: Deny / Allow once / Allow for session (the `always` reply —
+ *    this capability or pattern, rest of this session)
+ *  - per session: "Allow everything" writes a blanket allow ruleset onto the
+ *    runtime session (survives tab close) + auto-approves anything already
+ *    pending; a client-side auto-approver backstops any ask that still arrives.
+ *  - persistent (footer, gated on `project.agent.write` and an editable v2
+ *    agent): writes `allow` into the session agent's permission rules (its
+ *    `.md`, through the agent-config route) — sessions started after the
+ *    commit stop asking; this one allows the capability for the rest of its run.
+ */
+import { Button } from '../../primitives/button.js';
+import Loading from '../../primitives/loading.js';
+import { errorToast, successToast } from '../../primitives/toast.js';
+import { useAgentConfig, useUpdateAgentConfig } from '../../internal/hooks/projects/use-agent-config.js';
+import { PROJECT_ACTIONS } from '../../internal/lib/project-actions.js';
+import { useProjectPageCans } from '../../internal/lib/use-project-can.js';
+import { cn } from '../../lib/utils.js';
+import { PERMISSION_LABELS } from '../../internal/session-types/types.js';
+import { allowAllPermissionsForSession, resetSessionPermissions, useRuntimePendingStore, } from '@kortix/sdk/react';
+import { CaretDownIcon, ShieldWarningIcon as ShieldAlert, ShieldCheckIcon as ShieldCheck, } from '@phosphor-icons/react';
+import { useSessionIds } from '../../providers/session-ids.js';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+/**
+ * An agent's permission rules with `type` allowed: a bare action becomes the
+ * `*` fallback of the object form, and `*` ("always allow everything") also
+ * flattens every existing rule, so no leftover `ask`/`deny` outranks it.
+ */
+export function permissionRulesAllowing(current, type) {
+    const base = typeof current === 'string' ? { '*': current } : current ? { ...current } : {};
+    if (type !== '*')
+        return { ...base, [type]: 'allow' };
+    return Object.fromEntries([...Object.keys(base), '*'].map((key) => [key, 'allow']));
+}
+/** Full-text review is only worth an extra click for a detail that won't fit
+ * on one line — short commands stay flat, no chevron. */
+const EXPANDABLE_DETAIL_LENGTH = 64;
+function permissionLabel(p) {
+    return PERMISSION_LABELS[p.permission] || p.permission;
+}
+/** The concrete thing being gated — the request's match patterns (e.g. the
+ * bash command), falling back to a metadata title if the runtime sent none. */
+function permissionDetail(p) {
+    if (p.patterns?.length)
+        return p.patterns.join('  ');
+    const title = p.metadata?.title;
+    return typeof title === 'string' ? title : null;
+}
+/** Wraps a permission detail: a real toggle when there is more to reveal,
+ *  inert markup when the detail already fits on one line. */
+function DetailShell({ expandable, expanded, onToggle, children, }) {
+    if (!expandable) {
+        return _jsx("div", { className: "mt-0.5 flex w-full items-start gap-1 text-left", children: children });
+    }
+    return (_jsx("button", { type: "button", "aria-expanded": expanded, onClick: onToggle, className: "mt-0.5 flex w-full cursor-pointer items-start gap-1 text-left", children: children }));
+}
+/**
+ * A button label that swaps to a spinner IN PLACE.
+ *
+ * Inserting a spinner alongside the label widens the button mid-press. On this
+ * card the three decision buttons sit shoulder to shoulder, so a widening
+ * "Deny" slides "Allow once" under a cursor that is still on its way down — a
+ * mis-click here grants access. Keeping the label in flow (`invisible`, not
+ * unmounted) holds the button at exactly its resting width while the reply is
+ * in flight.
+ */
+function PendingLabel({ pending, children }) {
+    return (_jsxs("span", { className: "relative inline-flex items-center justify-center", children: [_jsx("span", { className: cn('inline-flex items-center', pending && 'invisible'), children: children }), pending ? (_jsx("span", { className: "absolute inset-0 inline-flex items-center justify-center", children: _jsx(Loading, { className: "size-3 shrink-0" }) })) : null] }));
+}
+export function SessionPermissionPrompt({ sessionId, agentName, permissions, onReply, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    // Only the /projects/[id]/sessions/[sessionId] route has a project in scope —
+    // on plain /sessions/[id], `id` IS the session, so no config surface.
+    const ids = useSessionIds();
+    const projectId = ids.sessionId ? ids.projectId : undefined;
+    const canWriteConfig = useProjectPageCans(projectId)[PROJECT_ACTIONS.PROJECT_AGENT_WRITE];
+    const autoApprove = useRuntimePendingStore((s) => !!s.autoApproveAllSessions[sessionId]);
+    const setAutoApproveAll = useRuntimePendingStore((s) => s.setAutoApproveAll);
+    const { data: agentConfig } = useAgentConfig(canWriteConfig.allowed ? projectId : undefined, agentName);
+    const updateAgentConfig = useUpdateAgentConfig(projectId ?? '', agentName ?? '');
+    const agentBlock = agentConfig?.editable ? agentConfig.block : null;
+    // Which button is loading: `${requestId}:once|always|reject`, 'session-all',
+    // or `config:${type}` / 'config:*'.
+    const [busy, setBusy] = useState(null);
+    // Request ids currently showing their full (untruncated) detail text.
+    const [expandedRows, setExpandedRows] = useState(new Set());
+    const toggleExpanded = useCallback((requestId) => {
+        setExpandedRows((current) => {
+            const next = new Set(current);
+            if (next.has(requestId))
+                next.delete(requestId);
+            else
+                next.add(requestId);
+            return next;
+        });
+    }, []);
+    const reply = useCallback(async (requestId, kind) => {
+        setBusy(`${requestId}:${kind}`);
+        try {
+            await onReply(requestId, kind);
+        }
+        catch (e) {
+            errorToast(e instanceof Error ? e.message : tI18nComplete.raw('text088abd95f7eb'));
+        }
+        finally {
+            setBusy(null);
+        }
+    }, [onReply, tI18nComplete]);
+    const allowAllForSession = useCallback(async () => {
+        setBusy('session-all');
+        try {
+            // Server-side grant first (survives the tab closing). Best-effort: if the
+            // runtime rejects the session ruleset, the client-side auto-approver
+            // below still delivers the behavior while this tab is open.
+            try {
+                await allowAllPermissionsForSession(sessionId);
+            }
+            catch {
+                // fall through to the client-side backstop
+            }
+            setAutoApproveAll(sessionId, true);
+            // The ruleset only stops FUTURE asks — approve what's already pending.
+            await Promise.all(permissions.map((p) => onReply(p.id, 'once')));
+            successToast(tI18nComplete.raw('text672a76cd238a'));
+        }
+        catch (e) {
+            errorToast(e instanceof Error ? e.message : tI18nComplete.raw('text292fd30cb1b5'));
+        }
+        finally {
+            setBusy(null);
+        }
+    }, [setAutoApproveAll, sessionId, permissions, tI18nComplete, onReply]);
+    const turnOffAutoApprove = useCallback(async () => {
+        setAutoApproveAll(sessionId, false);
+        try {
+            await resetSessionPermissions(sessionId);
+        }
+        catch {
+            // The flag is already off; a stale session ruleset just means fewer asks.
+        }
+    }, [sessionId, setAutoApproveAll]);
+    /** Persist an allow into the session agent's permission rules (the agent
+     * editor's surface), then release the pending asks it covers with `always`:
+     * the running session keeps the config it started with. `type === '*'` =
+     * always allow everything. */
+    const allowInConfig = useCallback(async (type) => {
+        if (!agentBlock)
+            return;
+        setBusy(`config:${type}`);
+        try {
+            const { opencode: _legacyBehavior, ...block } = agentBlock;
+            const behavior = block.behavior ?? {};
+            const next = permissionRulesAllowing(behavior.permission, type);
+            await updateAgentConfig.mutateAsync({
+                ...block,
+                behavior: { ...behavior, permission: next },
+            });
+            const covered = permissions.filter((p) => type === '*' || p.permission === type);
+            await Promise.all(covered.map((p) => onReply(p.id, 'always')));
+            successToast(type === '*'
+                ? tI18nComplete.raw('texte5776302ca62')
+                : tI18nComplete('text51a4eefaba47', { value0: PERMISSION_LABELS[type] || type }));
+        }
+        catch (e) {
+            errorToast(e instanceof Error ? e.message : tI18nComplete.raw('text14085878939d'));
+        }
+        finally {
+            setBusy(null);
+        }
+    }, [agentBlock, updateAgentConfig, permissions, tI18nComplete, onReply]);
+    // Client-side backstop for "allow everything this session": auto-approve any
+    // ask that still arrives (e.g. the runtime ignored the session ruleset).
+    const autoRepliedRef = useRef(new Set());
+    useEffect(() => {
+        if (!autoApprove)
+            return;
+        for (const p of permissions) {
+            if (autoRepliedRef.current.has(p.id))
+                continue;
+            autoRepliedRef.current.add(p.id);
+            void onReply(p.id, 'once').catch(() => {
+                // Let a later effect run retry it (e.g. a transient network blip).
+                autoRepliedRef.current.delete(p.id);
+            });
+        }
+    }, [autoApprove, permissions, onReply]);
+    // A manifest `skills:` grant outranks the `skill` rule, so writing one would change nothing.
+    const uniqueTypes = useMemo(() => [...new Set(permissions.map((p) => p.permission))].filter((type) => !(type === 'skill' && agentBlock?.skills !== undefined)), [permissions, agentBlock]);
+    if (autoApprove) {
+        return (_jsxs("div", { className: "border-border bg-popover flex w-full items-center gap-2 rounded-md border px-3 py-2", children: [_jsx(ShieldCheck, { className: "text-kortix-green size-4" }), _jsx("span", { className: "text-muted-foreground flex-1 text-xs", children: tI18nComplete.raw('text60d3eb13fad7') }), _jsx(Button, { size: "xs", variant: "ghost", onClick: () => void turnOffAutoApprove(), children: tI18nComplete.raw('text06f0e210b27d') })] }));
+    }
+    if (permissions.length === 0)
+        return null;
+    return (
+    // `w-full`: the composer strip is an `items-center` flex column, which
+    // sizes a child to its content unless it says otherwise (composer.tsx).
+    _jsxs("div", { className: "bg-popover border-kortix-orange/25 w-full overflow-hidden rounded-md border", children: [_jsxs("div", { className: "border-kortix-orange/20 flex items-center gap-2 border-b px-3 py-2", children: [_jsx(ShieldAlert, { className: "text-kortix-orange size-4" }), _jsx("span", { className: "text-foreground text-xs font-medium", children: permissions.length === 1
+                            ? tI18nComplete.raw('text9ef61f308b40')
+                            : tI18nComplete('textc49ce59d0871', { value0: permissions.length }) }), _jsx("span", { className: "text-muted-foreground text-xs", children: tI18nComplete.raw('text9532a08e3f63') })] }), _jsx("ul", { className: "divide-border divide-y", children: permissions.map((p) => {
+                    const detail = permissionDetail(p);
+                    const expandable = !!detail && detail.length > EXPANDABLE_DETAIL_LENGTH;
+                    const expanded = expandedRows.has(p.id);
+                    return (_jsxs("li", { className: "flex items-start gap-2 px-3 py-2", children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("div", { className: "flex items-center gap-1.5", children: _jsx("span", { className: "text-foreground text-xs font-medium", children: permissionLabel(p) }) }), detail ? (
+                                    // Only a detail that actually expands is a control. Rendering
+                                    // the flat case as a `<button>` too put a dead stop in the tab
+                                    // order of every permission row.
+                                    _jsxs(DetailShell, { expandable: expandable, expanded: expanded, onToggle: () => toggleExpanded(p.id), children: [_jsx("code", { title: expandable ? undefined : detail, className: cn('text-muted-foreground font-mono text-xs', expanded ? 'wrap-break-word whitespace-pre-wrap' : 'truncate'), children: detail }), expandable ? (_jsx(CaretDownIcon, { className: cn('text-muted-foreground mt-0.5 size-3 shrink-0 transition-transform duration-150', expanded && 'rotate-180') })) : null] })) : null] }), _jsxs("div", { className: "flex shrink-0 items-center gap-1.5", children: [_jsx(Button, { size: "xs", variant: "outline", disabled: !!busy, onClick: () => void reply(p.id, 'reject'), children: _jsx(PendingLabel, { pending: busy === `${p.id}:reject`, children: tI18nComplete.raw('text05a2d7332eb9') }) }), _jsx(Button, { size: "xs", variant: "muted", title: tI18nComplete.raw('text403595dd63ea'), disabled: !!busy, onClick: () => void reply(p.id, 'always'), children: _jsx(PendingLabel, { pending: busy === `${p.id}:always`, children: tI18nComplete.raw('textec9f8a9109ec') }) }), _jsx(Button, { size: "xs", variant: "default", disabled: !!busy, onClick: () => void reply(p.id, 'once'), children: _jsx(PendingLabel, { pending: busy === `${p.id}:once`, children: tI18nComplete.raw('text168511d24d9e') }) })] })] }, p.id));
+                }) }), _jsxs("div", { className: "border-border flex items-center gap-2 border-t px-3 py-2", children: [_jsx("span", { className: "text-muted-foreground text-xs", children: tI18nComplete.raw('text16324ed5894b') }), _jsx(Button, { size: "xs", variant: "ghost", className: "text-muted-foreground hover:text-foreground", title: tI18nComplete.raw('text2c1a881dfca8'), disabled: !!busy, onClick: () => void allowAllForSession(), children: _jsx(PendingLabel, { pending: busy === 'session-all', children: tI18nComplete.raw('text1f05c7f5b64d') }) })] }), canWriteConfig.allowed && agentBlock ? (
+            // Deliberately set apart from the one-off buttons above: these WRITE the
+            // project's permission config — every future session stops asking.
+            _jsxs("div", { className: "bg-muted/40 border-border flex flex-wrap items-center gap-2 border-t px-3 py-2", children: [_jsxs("span", { className: "text-muted-foreground text-xs", children: [tI18nComplete.raw('text689997c79ba6'), ' ', _jsx("span", { className: "opacity-70", children: tI18nComplete.raw('textea73705db65f') }), ":"] }), uniqueTypes.map((type) => (_jsx(Button, { size: "xs", variant: "ghost", className: "text-muted-foreground hover:text-foreground", disabled: !!busy, onClick: () => void allowInConfig(type), children: _jsxs(PendingLabel, { pending: busy === `config:${type}`, children: [tI18nComplete.raw('text78facd7b499c'), PERMISSION_LABELS[type] || type, "\""] }) }, type))), _jsx(Button, { size: "xs", variant: "ghost", className: "text-muted-foreground hover:text-foreground", disabled: !!busy, onClick: () => void allowInConfig('*'), children: _jsx(PendingLabel, { pending: busy === 'config:*', children: tI18nComplete.raw('text84f8c40b31a7') }) })] })) : null] }));
+}

package/dist/session/scope/create-scoped-session.d.ts

@@ -0,0 +1,12 @@
+import type { SessionScope, SessionScopeInput } from '@kortix/sdk';
+import { type SessionScopeAvailability, type SessionScopeDraft } from './session-scope-model.js';
+interface CreateScopedSessionInput {
+    create: () => Promise<string>;
+    draft?: SessionScopeDraft;
+    availability?: SessionScopeAvailability;
+    readScope: (sessionId: string) => Promise<SessionScope>;
+    replaceScope: (sessionId: string, replacement: SessionScopeInput) => Promise<unknown>;
+    onReady: (sessionId: string) => void | Promise<void>;
+}
+export declare function createScopedSession(input: CreateScopedSessionInput): Promise<string>;
+export {};

package/dist/session/scope/create-scoped-session.js

@@ -0,0 +1,28 @@
+import { buildSessionScopeReplacement, scopeReplacementIsFreshDefault, } from './session-scope-model.js';
+function hasDraftReplacement(draft) {
+    if (!draft)
+        return false;
+    return ((Object.hasOwn(draft, 'secrets') && draft.secrets !== undefined) ||
+        (Object.hasOwn(draft, 'connector_bindings') && draft.connector_bindings !== undefined));
+}
+export async function createScopedSession(input) {
+    const sessionId = await input.create();
+    if (hasDraftReplacement(input.draft)) {
+        // The session was just created, so its scope IS the fresh default. A
+        // replacement that only restates that default replaces nothing — skip the
+        // read + write instead of spending two serial round trips between the
+        // warm-claim and /start on every untouched send. Built without a previous
+        // scope on purpose: at creation there is no previous scope beyond the
+        // default, and the draft carries every axis it intends to set.
+        const provisional = buildSessionScopeReplacement(input.draft, undefined, input.availability);
+        if (!scopeReplacementIsFreshDefault(provisional)) {
+            const currentScope = await input.readScope(sessionId);
+            const replacement = buildSessionScopeReplacement(input.draft, currentScope, input.availability);
+            if (Object.keys(replacement).length > 0) {
+                await input.replaceScope(sessionId, replacement);
+            }
+        }
+    }
+    await input.onReady(sessionId);
+    return sessionId;
+}

package/dist/session/scope/session-scope-control.d.ts

@@ -0,0 +1,31 @@
+import { type SessionScopeDraft, type SessionScopeSelectionCatalog } from './session-scope-model.js';
+export interface SessionScopeEditorProps {
+    draft: SessionScopeDraft;
+    catalog: SessionScopeSelectionCatalog;
+    disabled?: boolean;
+    /** The catalog has not answered yet; nothing is known to be unavailable. */
+    loading?: boolean;
+    onChange: (draft: SessionScopeDraft) => void;
+}
+export declare function setAllSessionSecrets(draft: SessionScopeDraft, allowAll: boolean): SessionScopeDraft;
+export declare function toggleSessionSecret(draft: SessionScopeDraft, catalog: SessionScopeSelectionCatalog, identifier: string, allowed: boolean): SessionScopeDraft;
+export declare function setSessionConnectorConnection(draft: SessionScopeDraft, connectorConnection: string, connectionId: string | null): SessionScopeDraft;
+/**
+ * The way OUT of an override. An override you cannot switch off is a trap: the
+ * session keeps a frozen selection while the project's own defaults move on.
+ *
+ * Rendered by the overrides panel BESIDE an axis editor, never inside it: an
+ * empty catalog must not be able to hide the only way back to the default.
+ */
+export declare function ResetAxisButton({ disabled, onReset, label, }: {
+    disabled?: boolean;
+    onReset: () => void;
+    /** Names where the default comes from — "Reset to agent default" etc. */
+    label?: string;
+}): import("react").JSX.Element;
+/**
+ * The secrets checklist. `null` (every box checked) is the INHERITED state, not
+ * "all selected by hand" — unchecking one converts the axis into an explicit
+ * allowlist, which is the only way an override is ever created here.
+ */
+export declare function SessionSecretsEditor({ draft, catalog, disabled, loading, onChange, }: SessionScopeEditorProps): import("react").JSX.Element;

package/dist/session/scope/session-scope-control.js

@@ -0,0 +1,83 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import { Checkbox } from '../../primitives/checkbox.js';
+import { InfoBanner } from '../../primitives/info-banner.js';
+import Loading from '../../primitives/loading.js';
+import { ArrowCounterClockwiseIcon as ArrowCounterClockwise } from '@phosphor-icons/react';
+import { useTranslations } from '../../i18n/index.js';
+export function setAllSessionSecrets(draft, allowAll) {
+    return {
+        ...draft,
+        secrets: allowAll ? null : [],
+    };
+}
+export function toggleSessionSecret(draft, catalog, identifier, allowed) {
+    if (catalog.secrets.status !== 'ready')
+        return draft;
+    if (draft.secrets === null) {
+        if (allowed)
+            return draft;
+        const secrets = [];
+        for (const secret of catalog.secrets.items) {
+            if (secret.identifier !== identifier)
+                secrets.push(secret.identifier);
+        }
+        return {
+            ...draft,
+            secrets,
+        };
+    }
+    const current = draft.secrets ?? [];
+    const next = allowed
+        ? Array.from(new Set([...current, identifier]))
+        : current.filter((candidate) => candidate !== identifier);
+    return {
+        ...draft,
+        secrets: next,
+    };
+}
+export function setSessionConnectorConnection(draft, connectorConnection, connectionId) {
+    const connectorBindings = { ...(draft.connector_bindings ?? {}) };
+    if (connectionId === null) {
+        delete connectorBindings[connectorConnection];
+    }
+    else {
+        connectorBindings[connectorConnection] = { connection_id: connectionId };
+    }
+    return {
+        ...draft,
+        connector_bindings: connectorBindings,
+        connector_bindings_inherited: false,
+    };
+}
+/**
+ * The way OUT of an override. An override you cannot switch off is a trap: the
+ * session keeps a frozen selection while the project's own defaults move on.
+ *
+ * Rendered by the overrides panel BESIDE an axis editor, never inside it: an
+ * empty catalog must not be able to hide the only way back to the default.
+ */
+export function ResetAxisButton({ disabled = false, onReset, label, }) {
+    const t = useTranslations('sessionScope');
+    return (_jsxs(Button, { type: "button", variant: "ghost", size: "sm", disabled: disabled, className: "text-muted-foreground -ml-1 h-8", onClick: onReset, children: [_jsx(ArrowCounterClockwise, { className: "size-3.5 shrink-0" }), label ?? t('resetDefault')] }));
+}
+/**
+ * The secrets checklist. `null` (every box checked) is the INHERITED state, not
+ * "all selected by hand" — unchecking one converts the axis into an explicit
+ * allowlist, which is the only way an override is ever created here.
+ */
+export function SessionSecretsEditor({ draft, catalog, disabled = false, loading = false, onChange, }) {
+    const t = useTranslations('sessionScope');
+    if (loading) {
+        return (_jsxs("div", { role: "status", className: "text-muted-foreground flex min-h-10 items-center gap-2 text-xs", children: [_jsx(Loading, { variant: "spokes", className: "size-3.5 shrink-0" }), t('secrets.loading')] }));
+    }
+    if (catalog.secrets.status === 'unavailable') {
+        return (_jsx(InfoBanner, { tone: "neutral", title: t('secrets.unavailableTitle'), children: t('secrets.unavailableDescription') }));
+    }
+    const selectedSecrets = new Set(draft.secrets ?? []);
+    return (_jsxs("div", { className: "space-y-1", children: [_jsx(Checkbox, { checked: draft.secrets === null, disabled: disabled, className: "min-h-10", label: t('secrets.useProjectDefault'), onCheckedChange: (checked) => onChange(setAllSessionSecrets(draft, checked === true)) }), catalog.secrets.items.length > 0 ? (_jsx("div", { className: "border-border border-t pt-1", children: catalog.secrets.items.map((secret) => {
+                    const checked = draft.secrets === null || selectedSecrets.has(secret.identifier);
+                    return (_jsx(Checkbox, { checked: checked, disabled: disabled, className: "min-h-10", label: _jsxs("span", { className: "flex min-w-0 flex-col gap-0.5", children: [_jsx("span", { className: "text-foreground truncate", children: secret.name }), secret.name !== secret.identifier ? (_jsx("code", { className: "text-muted-foreground truncate text-xs", children: secret.identifier })) : null] }), onCheckedChange: (nextChecked) => onChange(toggleSessionSecret(draft, catalog, secret.identifier, nextChecked === true)) }, secret.identifier));
+                }) })) : (_jsx("p", { className: "text-muted-foreground border-border border-t px-1 py-3 text-xs text-pretty", children: t('secrets.empty') }))] }));
+}