@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

package/lib/types/ink/terminal.js

@@ -2,8 +2,7 @@ import { coerce } from 'semver';
 import { appendFileSync } from 'node:fs';
 import { env } from '../utils/env.js';
 import { gte } from '../utils/semver.js';
-import { getClearTerminalSequence } from './clearTerminal.js';
-import { cursorMove, cursorTo, eraseLines, SGR_RESET } from './termio/csi.js';
+import { CURSOR_HOME, cursorMove, cursorTo, ERASE_SCREEN, eraseLines, SGR_RESET, } from './termio/csi.js';
 import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js';
 import { link } from './termio/osc.js';
 /**
@@ -312,10 +311,31 @@ export function writeDiffToTerminal(terminal, diff, skipSyncMarkers = false) {
                 }
                 break;
             case 'clearTerminal':
-                // Pass the live row count: the blank only needs one viewport worth
-                // of scroll (see getClearTerminalSequence on why overshooting
-                // evicts the user's real scrollback).
-                buffer += getClearTerminalSequence(terminal.stdout.rows);
+                // Hard clear of screen + scrollback. MUST run OUTSIDE the BSU/ESU
+                // sync block: Windows Terminal snaps the viewport back to the top
+                // when 2J/3J execute inside a synchronized-update block
+                // (claude-code#35580) — the reason the scrollUp-based "soft" clear
+                // existed at all. Close the block, clear, reopen. Everything stays
+                // in the SAME write, so the terminal processes it with no
+                // intermediate paint. The hard clear actually removes the UI's
+                // scrollback snapshots (the duplicated whale-logo class of bugs);
+                // the old soft clear (CSI n S) PUSHED the live viewport into the
+                // scrollback instead, depositing a fresh full-UI copy per reset.
+                // Screen-only hard clear: 2J + home, NO 3J. Erasing the scrollback
+                // here destroyed the user's entire visible history on every settle
+                // shrink (the "context lost / cannot scroll" reports) — the inline
+                // transcript IS the scrollback; wiping it to avoid duplicate
+                // snapshots is never an acceptable trade. 2J clears the screen for
+                // the repaint while everything above the viewport survives.
+                // Executed OUTSIDE the DEC 2026 sync block (split begin/end): WT
+                // yanks the viewport to top when 2J runs inside a synchronized
+                // update (claude-code#35580).
+                buffer +=
+                    (useSync ? ESU : '') +
+                        SGR_RESET +
+                        ERASE_SCREEN +
+                        CURSOR_HOME +
+                        (useSync ? BSU : '');
                 break;
             case 'cursorHide':
                 buffer += HIDE_CURSOR;

package/lib/types/ink/wrapAnsi.d.ts

@@ -7,7 +7,7 @@ type WrapAnsiOptions = {
  * Wrap a string to a maximum column width, preserving ANSI escape sequences.
  *
  * Uses Bun.wrapAnsi when available; otherwise falls back to the wrap-ansi
- * package.
+ * package (with the incremental fast path for growing streaming inputs).
  * @param input - the string to wrap.
  * @param columns - the maximum width in columns.
  * @param options - wrap options: hard breaks long words, wordWrap splits on word boundaries, trim strips trailing whitespace.

package/lib/types/ink/wrapAnsi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapAnsi.d.ts","sourceRoot":"","sources":["../../../src/ink/wrapAnsi.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAOD;;;;;;;;;GASG;AACH,QAAA,MAAM,QAAQ,EAAE,CACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,KACtB,MAAmC,CAAA;AAExC,OAAO,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"wrapAnsi.d.ts","sourceRoot":"","sources":["../../../src/ink/wrapAnsi.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AA0DD;;;;;;;;;GASG;AACH,QAAA,MAAM,QAAQ,EAAE,CACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,KACtB,MAEmB,CAAA;AAExB,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/lib/types/ink/wrapAnsi.js

@@ -2,15 +2,42 @@ import wrapAnsiNpm from 'wrap-ansi';
 const wrapAnsiBun = typeof Bun !== 'undefined' && typeof Bun.wrapAnsi === 'function'
     ? Bun.wrapAnsi
     : null;
+const SLOT_MIN_LENGTH = 2048;
+let slot = null;
+function slotOptionsApply(options) {
+    return options?.hard === true && (options?.trim ?? false) === false;
+}
+function wrapAnsiNpmIncremental(input, columns, options) {
+    const slottable = input.length > SLOT_MIN_LENGTH && slotOptionsApply(options);
+    if (slottable && slot !== null && slot.columns === columns && input.startsWith(slot.input)) {
+        const suffix = input.slice(slot.input.length);
+        if (!suffix.includes('\x1b') && !slot.remainder.includes('\x1b')) {
+            const tail = wrapAnsiNpm(slot.remainder + suffix, columns, options).split('\n');
+            const rows = [...slot.headRows, ...tail];
+            slot = { columns, input, headRows: rows.slice(0, -1), remainder: rows[rows.length - 1] ?? '' };
+            return rows.join('\n');
+        }
+    }
+    const result = wrapAnsiNpm(input, columns, options);
+    if (slottable && !input.includes('\x1b')) {
+        const rows = result.split('\n');
+        slot = { columns, input, headRows: rows.slice(0, -1), remainder: rows[rows.length - 1] ?? '' };
+    }
+    else {
+        slot = null;
+    }
+    return result;
+}
 /**
  * Wrap a string to a maximum column width, preserving ANSI escape sequences.
  *
  * Uses Bun.wrapAnsi when available; otherwise falls back to the wrap-ansi
- * package.
+ * package (with the incremental fast path for growing streaming inputs).
  * @param input - the string to wrap.
  * @param columns - the maximum width in columns.
  * @param options - wrap options: hard breaks long words, wordWrap splits on word boundaries, trim strips trailing whitespace.
  * @returns the wrapped string.
  */
-const wrapAnsi = wrapAnsiBun ?? wrapAnsiNpm;
+const wrapAnsi = wrapAnsiBun ??
+    wrapAnsiNpmIncremental;
 export { wrapAnsi };

package/lib/types/plugin-host.d.ts

@@ -0,0 +1,15 @@
+export { name, apply } from './dsh-adapter/plugin-host.js';
+export type { TuiPluginHost } from './dsh-adapter/plugin-host.js';
+export type { GrantPrincipal, GrantStore } from './dsh-adapter/grants.js';
+export type { HostContract, HostDescriptor, ContractCoordinate, ContractRef, NegotiationDecision, PermissionEntry, PermissionRegistry } from './plugin-spec/types.js';
+export type { TuiPluginStorage, PluginStorageErrorCode, TuiPluginStorageRuntime } from './dsh-adapter/plugin-storage.js';
+export { PluginStorageError, STORAGE_KEY_MAX_LENGTH, STORAGE_MAX_BYTES, STORAGE_MAX_KEYS } from './dsh-adapter/plugin-storage.js';
+export { OBSERVE_CALLBACK_QUEUE_LIMIT, OBSERVE_CALLBACK_TIMEOUT_MS, OBSERVE_CONTENT_MAX_CHARS, OBSERVE_ID_MAX_CHARS, OBSERVE_IMAGE_BASE64_MAX_CHARS, OBSERVE_IMAGE_MAX_BYTES, OBSERVE_SCOPE_MAX_CHARS, OBSERVE_SUMMARY_CELLS, } from './dsh-adapter/message-observer.js';
+export type { MessagesObserveContentBlock, MessagesObserveEnvelope, MessagesObserveListener, MessagesObservePayload, TuiMessageObserverRuntime, } from './dsh-adapter/message-observer.js';
+export type { LedgerEntry, LedgerOperation, LedgerResult, TuiEffectLedgerRuntime } from './dsh-adapter/effect-ledger.js';
+export { COMMAND_ERROR_CODES, hasCommandErrorCode, mapCommandError, withCommandErrorMapping, } from './dsh-adapter/command-errors.js';
+export type { CommandErrorCode, CodedCommandError } from './dsh-adapter/command-errors.js';
+export { DECISION_EVENT_PERMISSIONS, } from './dsh-adapter/decision-guard.js';
+export { DECISION_HANDLER_TIMEOUT_MS, DECISION_TOTAL_TIMEOUT_MS, } from './dsh-adapter/extension-events.js';
+export { DECISION_EVENTS_COORDINATE, TUI_EXTENSION_API_VERSION, TUI_DECISION_EVENT_NAMES, TUI_EXTENSION_PERMISSION_NAMES, createAdmissionCatalog, } from './plugin-spec/tui-extension.js';
+//# sourceMappingURL=plugin-host.d.ts.map

package/lib/types/plugin-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-host.d.ts","sourceRoot":"","sources":["../../src/plugin-host.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACrK,YAAY,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACxH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAIjI,OAAO,EACL,4BAA4B,EAC5B,2BAA2B,EAC3B,yBAAyB,EACzB,oBAAoB,EACpB,8BAA8B,EAC9B,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,mCAAmC,CAAA;AAC1C,YAAY,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,mCAAmC,CAAA;AAE1C,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AACxH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,EACf,uBAAuB,GACxB,MAAM,iCAAiC,CAAA;AACxC,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAK1F,OAAO,EACL,0BAA0B,GAC3B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,gCAAgC,CAAA"}

package/lib/types/plugin-host.js

@@ -0,0 +1,17 @@
+// Public plugin-host shim. Keep the Cordis-backed implementation behind the
+// adapter boundary: plugin authors receive protocol types and mediated service
+// contracts, while loader-only admission, host ingress, mutable stores and
+// attribution registries remain adapter-internal. Type-only runtime exports
+// still load the adapter declarations so Context augmentation is available.
+export { name, apply } from './dsh-adapter/plugin-host.js';
+export { PluginStorageError, STORAGE_KEY_MAX_LENGTH, STORAGE_MAX_BYTES, STORAGE_MAX_KEYS } from './dsh-adapter/plugin-storage.js';
+// The host-only message ingress accessor stays in the adapter module. Plugin
+// authors receive the broker's subscribe surface and envelope vocabulary only.
+export { OBSERVE_CALLBACK_QUEUE_LIMIT, OBSERVE_CALLBACK_TIMEOUT_MS, OBSERVE_CONTENT_MAX_CHARS, OBSERVE_ID_MAX_CHARS, OBSERVE_IMAGE_BASE64_MAX_CHARS, OBSERVE_IMAGE_MAX_BYTES, OBSERVE_SCOPE_MAX_CHARS, OBSERVE_SUMMARY_CELLS, } from './dsh-adapter/message-observer.js';
+export { COMMAND_ERROR_CODES, hasCommandErrorCode, mapCommandError, withCommandErrorMapping, } from './dsh-adapter/command-errors.js';
+// Command attribution and decision registration are host-internal. Exposing
+// these functions would let a plugin inspect or rewrite another plugin's
+// checkpoint, or install an unmediated handler.
+export { DECISION_EVENT_PERMISSIONS, } from './dsh-adapter/decision-guard.js';
+export { DECISION_HANDLER_TIMEOUT_MS, DECISION_TOTAL_TIMEOUT_MS, } from './dsh-adapter/extension-events.js';
+export { DECISION_EVENTS_COORDINATE, TUI_EXTENSION_API_VERSION, TUI_DECISION_EVENT_NAMES, TUI_EXTENSION_PERMISSION_NAMES, createAdmissionCatalog, } from './plugin-spec/tui-extension.js';

package/lib/types/plugin-spec/negotiate.d.ts

@@ -0,0 +1,11 @@
+/** Five-state admission decision using dsh-std projection and ProtocolCatalog. */
+import type { ContractIndex } from './validate.js';
+import type { HostDescriptor, NegotiationDecision, PluginManifest } from './types.js';
+export interface GrantedPermission {
+    name: string;
+    scope: string;
+    /** Explicit effective answer. Omitted means a legacy positive grant row. */
+    granted?: boolean;
+}
+export declare function negotiate(index: ContractIndex, manifest: PluginManifest, host: HostDescriptor, grants?: readonly GrantedPermission[]): NegotiationDecision;
+//# sourceMappingURL=negotiate.d.ts.map

package/lib/types/plugin-spec/negotiate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiate.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/negotiate.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAIlF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,OAAO,KAAK,EAAE,cAAc,EAAsB,mBAAmB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAIzG,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,cAAc,EACpB,MAAM,GAAE,SAAS,iBAAiB,EAAO,GACxC,mBAAmB,CA6FrB"}

package/lib/types/plugin-spec/negotiate.js

@@ -0,0 +1,97 @@
+/** Five-state admission decision using dsh-std projection and ProtocolCatalog. */
+import { defineProtocolDeclaration } from '@dsh-std/core';
+import { projectManifest } from '@dsh-std/manifest';
+import { rawScopeCovers } from './permission-scope.js';
+const coordinateKey = (ref) => `${ref.apiVersion}#${ref.kind}`;
+export function negotiate(index, manifest, host, grants = []) {
+    const supported = new Map(host.contracts.map(contract => [coordinateKey(contract), contract]));
+    const required = manifest.requires.contracts.filter(reference => reference.optional !== true);
+    const optional = manifest.requires.contracts.filter(reference => reference.optional === true);
+    const unknown = manifest.requires.contracts.filter(reference => {
+        try {
+            return index.resolveContractRef(reference).unregisteredVersion;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (unknown.length > 0) {
+        return {
+            decision: 'unknown',
+            reasonCode: 'UNKNOWN_PROTOCOL_VERSION',
+            unknownContracts: unknown.map(coordinateKey),
+        };
+    }
+    if (!host.facetApiVersions.includes(manifest.facets.host.apiVersion)) {
+        return {
+            decision: 'rejected',
+            reasonCode: 'FACET_API_VERSION_UNAVAILABLE',
+            facetApiVersion: manifest.facets.host.apiVersion,
+            hostFacetApiVersions: host.facetApiVersions,
+        };
+    }
+    const missingRequired = required.filter(reference => !supported.has(coordinateKey(reference)));
+    const missingOptional = optional.filter(reference => !supported.has(coordinateKey(reference)));
+    if (missingRequired.length > 0) {
+        return {
+            decision: 'rejected',
+            reasonCode: 'REQUIRED_PROTOCOL_UNAVAILABLE',
+            missingRequired: missingRequired.map(coordinateKey),
+        };
+    }
+    const projected = projectManifest(manifest);
+    const facet = projected.spec.facets.find(candidate => candidate.name === 'host');
+    const supportedKeys = new Set(host.contracts.map(contract => coordinateKey(contract)));
+    const declaration = defineProtocolDeclaration({
+        participant: { id: manifest.id },
+        // An optional protocol that is absent is intentionally omitted from the
+        // evaluator input; its degraded state was already recorded above. This
+        // keeps ProtocolCatalog's required-support error meaningful for every
+        // remaining requirement.
+        requires: (facet?.protocols?.requires ?? []).filter(reference => reference.optional !== true || supportedKeys.has(coordinateKey(reference))),
+    });
+    const hostDeclaration = defineProtocolDeclaration({
+        participant: { id: host.hostId },
+        supports: host.contracts.map(contract => ({
+            apiVersion: contract.apiVersion,
+            kind: contract.kind,
+            ...(Object.hasOwn(contract, 'spec') ? { spec: contract.spec } : {}),
+        })),
+    });
+    const report = index.protocols.negotiate([declaration, hostDeclaration]);
+    if (!report.compatible) {
+        return {
+            decision: 'rejected',
+            reasonCode: 'PROTOCOL_NEGOTIATION_FAILED',
+            issues: report.issues,
+        };
+    }
+    const hostPermissions = new Set(host.contracts.flatMap(contract => contract.permissions));
+    const denied = manifest.permissions.filter((request) => {
+        if (!hostPermissions.has(request.name))
+            return true;
+        const definition = index.permissions.permissions.find(permission => permission.name === request.name);
+        if (definition === undefined)
+            return true;
+        const matching = grants.filter(grant => grant.name === request.name
+            && rawScopeCovers(grant.name, grant.scope, request.scope, manifest.id));
+        // Explicit revocation wins over an allow-default permission. This keeps
+        // admission diagnostics aligned with the runtime checkpoint instead of
+        // reporting a plugin as compatible until its first invocation fails.
+        if (matching.some(grant => grant.granted === false))
+            return true;
+        if (definition.default === 'allow')
+            return false;
+        return !matching.some(grant => grant.granted !== false);
+    });
+    if (denied.length > 0) {
+        return {
+            decision: 'waiting_authorization',
+            reasonCode: 'PERMISSION_NOT_GRANTED',
+            deniedPermissions: denied.map(request => `${request.name}@${request.scope}`),
+        };
+    }
+    return missingOptional.length > 0
+        ? { decision: 'compatible_degraded', missingOptional: missingOptional.map(coordinateKey) }
+        : { decision: 'compatible' };
+}

package/lib/types/plugin-spec/permission-scope.d.ts

@@ -0,0 +1,32 @@
+/** Permission scope normalization shared by admission and runtime checks. */
+export declare const STORAGE_PERMISSIONS: Set<string>;
+export declare const INTERCEPT_PERMISSIONS: Set<string>;
+/** The decision point controlled by each intercept permission.  Keeping this
+ * mapping in the scope adapter (rather than accepting every `tui/*` name for
+ * every permission) prevents a manifest or grant from silently crossing an
+ * event boundary. */
+export declare const INTERCEPT_EVENT_SCOPE_BY_PERMISSION: Readonly<Record<string, string>>;
+/** A session scope is carried through the message envelope and may also be
+ * used by an intercept grant. Keep the canonical bound here so admission,
+ * grant evaluation, and runtime delivery cannot disagree about whether a
+ * scope is executable. */
+export declare const SESSION_SCOPE_MAX_CHARS = 256;
+export type ScopeKind = 'component' | 'command' | 'session' | 'event';
+export interface NormalizedPermissionScope {
+    kind: ScopeKind;
+    value: string;
+}
+/** Return undefined when this adapter cannot enforce the supplied scope. */
+export declare function normalizePermissionScope(permission: string, scope: string, componentId: string): NormalizedPermissionScope | undefined;
+export declare function scopeCovers(declared: NormalizedPermissionScope, actual: NormalizedPermissionScope): boolean;
+/**
+ * Permission-aware containment.  An event-point grant is the parent scope of
+ * the sessions delivered through that point, while a session grant can never
+ * be promoted into an event-point grant.  This relation is also used for
+ * denies, so a narrow `session:<id>` deny wins over a broad event grant.
+ */
+export declare function permissionScopeCovers(permission: string, declared: NormalizedPermissionScope, actual: NormalizedPermissionScope): boolean;
+/** Decision permission scopes may be expressed as one named event point. */
+export declare const TUI_EVENT_SCOPE_NAMES: Set<string>;
+export declare function rawScopeCovers(permission: string, declared: string, actual: string, componentId: string): boolean;
+//# sourceMappingURL=permission-scope.d.ts.map

package/lib/types/plugin-spec/permission-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-scope.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/permission-scope.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAE7E,eAAO,MAAM,mBAAmB,aAAyD,CAAA;AACzF,eAAO,MAAM,qBAAqB,aAKhC,CAAA;AAEF;;;qBAGqB;AACrB,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK/E,CAAA;AAEF;;;0BAG0B;AAC1B,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAI1C,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;AAErE,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,SAAS,CA2BvC;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,yBAAyB,EAAE,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAI3G;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,yBAAyB,EACnC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAKT;AAED,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,aAOhC,CAAA;AAEF,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAMjH"}

package/lib/types/plugin-spec/permission-scope.js

@@ -0,0 +1,90 @@
+/** Permission scope normalization shared by admission and runtime checks. */
+export const STORAGE_PERMISSIONS = new Set(['storage.local.read', 'storage.local.write']);
+export const INTERCEPT_PERMISSIONS = new Set([
+    'session.input.intercept',
+    'session.rewind.intercept',
+    'session.switch.intercept',
+    'session.compact.intercept',
+]);
+/** The decision point controlled by each intercept permission.  Keeping this
+ * mapping in the scope adapter (rather than accepting every `tui/*` name for
+ * every permission) prevents a manifest or grant from silently crossing an
+ * event boundary. */
+export const INTERCEPT_EVENT_SCOPE_BY_PERMISSION = Object.freeze({
+    'session.input.intercept': 'tui/input',
+    'session.rewind.intercept': 'tui/rewind-prompt',
+    'session.switch.intercept': 'tui/session-switch',
+    'session.compact.intercept': 'tui/compact',
+});
+/** A session scope is carried through the message envelope and may also be
+ * used by an intercept grant. Keep the canonical bound here so admission,
+ * grant evaluation, and runtime delivery cannot disagree about whether a
+ * scope is executable. */
+export const SESSION_SCOPE_MAX_CHARS = 256;
+const CONTROL_CHARS = /[\x00-\x1f\x7f-\x9f]/u;
+/** Return undefined when this adapter cannot enforce the supplied scope. */
+export function normalizePermissionScope(permission, scope, componentId) {
+    if (typeof scope !== 'string' || scope === '')
+        return undefined;
+    if (STORAGE_PERMISSIONS.has(permission)) {
+        return scope === componentId ? { kind: 'component', value: componentId } : undefined;
+    }
+    if (permission === 'commands.invoke') {
+        return /^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u.test(scope)
+            ? { kind: 'command', value: scope }
+            : undefined;
+    }
+    if (INTERCEPT_PERMISSIONS.has(permission) && TUI_EVENT_SCOPE_NAMES.has(scope)) {
+        return INTERCEPT_EVENT_SCOPE_BY_PERMISSION[permission] === scope
+            ? { kind: 'event', value: scope }
+            : undefined;
+    }
+    if (permission === 'messages.observe.read' || INTERCEPT_PERMISSIONS.has(permission)) {
+        if (scope === 'session:*')
+            return { kind: 'session', value: scope };
+        if (scope.startsWith('session:')
+            && scope.length <= SESSION_SCOPE_MAX_CHARS
+            && scope.length > 'session:'.length
+            && !scope.includes('*')
+            && !CONTROL_CHARS.test(scope)) {
+            return { kind: 'session', value: scope };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+export function scopeCovers(declared, actual) {
+    if (declared.kind !== actual.kind)
+        return false;
+    return declared.value === actual.value
+        || (declared.kind === 'session' && declared.value === 'session:*' && actual.value.startsWith('session:'));
+}
+/**
+ * Permission-aware containment.  An event-point grant is the parent scope of
+ * the sessions delivered through that point, while a session grant can never
+ * be promoted into an event-point grant.  This relation is also used for
+ * denies, so a narrow `session:<id>` deny wins over a broad event grant.
+ */
+export function permissionScopeCovers(permission, declared, actual) {
+    if (scopeCovers(declared, actual))
+        return true;
+    return INTERCEPT_PERMISSIONS.has(permission)
+        && declared.kind === 'event'
+        && actual.kind === 'session';
+}
+/** Decision permission scopes may be expressed as one named event point. */
+export const TUI_EVENT_SCOPE_NAMES = new Set([
+    'tui/input',
+    'tui/rewind-prompt',
+    'tui/rewind-done',
+    'tui/session-switch',
+    'tui/session-switched',
+    'tui/compact',
+]);
+export function rawScopeCovers(permission, declared, actual, componentId) {
+    const normalizedDeclared = normalizePermissionScope(permission, declared, componentId);
+    const normalizedActual = normalizePermissionScope(permission, actual, componentId);
+    return normalizedDeclared !== undefined
+        && normalizedActual !== undefined
+        && permissionScopeCovers(permission, normalizedDeclared, normalizedActual);
+}

package/lib/types/plugin-spec/registry.d.ts

@@ -0,0 +1,23 @@
+/** Load and verify the pinned dsh-TUI admission profile. */
+import type { ContractRegistry, PermissionRegistry, RegistryEntry } from './types.js';
+export declare const DSH_STD_REVISION = "614dfa1ac168db79fcf4577cf0ebb34e2e3b944b";
+export declare const ECOSYSTEM_SPEC_REVISION = "e1b902b0f95f4280a8e68d414ec7a4d25d6ce106";
+export interface SpecData {
+    dir: string;
+    registry: ContractRegistry;
+    permissions: PermissionRegistry;
+    schemas: {
+        host: Record<string, unknown>;
+        ledger: Record<string, unknown>;
+        claim: Record<string, unknown>;
+    };
+}
+export declare function locateSpecDir(start?: string): string | undefined;
+export declare function loadSpecData(dir?: string | undefined): SpecData | undefined;
+export declare function registryEntries(registry: ContractRegistry): RegistryEntry[];
+export declare function digestFile(dir: string, relative: string): `sha256:${string}`;
+/** Verify definition availability and private profile digest pins. */
+export declare function verifyRegistry(data: SpecData): string[];
+/** Verify the TUI-owned definitions; public definitions live in dsh-std. */
+export declare function verifyContractProfiles(data: SpecData): string[];
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/plugin-spec/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/registry.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAO5D,OAAO,KAAK,EAAE,gBAAgB,EAAmB,kBAAkB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAEtG,eAAO,MAAM,gBAAgB,6CAA6C,CAAA;AAC1E,eAAO,MAAM,uBAAuB,6CAA6C,CAAA;AAEjF,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,WAAW,EAAE,kBAAkB,CAAA;IAC/B,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAC/B,CAAA;CACF;AAuBD,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAgD,GAAG,MAAM,GAAG,SAAS,CASzG;AAiFD,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAM,GAAG,SAA2B,GAAG,QAAQ,GAAG,SAAS,CAiB5F;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAI3E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,MAAM,EAAE,CAE5E;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAuCvD;AAED,4EAA4E;AAC5E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CA2C/D"}