@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/integrations/pi/tui-runtime/index.d.ts

@@ -0,0 +1,9 @@
+export type { PiTuiComponentPort, PiTuiInputDiagnosticsEvent, PiTuiInputDiagnosticsPhase, PiTuiInputListener, PiTuiInputListenerResult, PiTuiLayoutEntry, PiTuiLayoutNode, PiTuiOverlayAnchor, PiTuiOverlayHandle, PiTuiOverlayMargin, PiTuiOverlayOptions, PiTuiOverlayUnfocusOptions, PiTuiPointerSurface, PiTuiPreInputListener, PiTuiRuntimeAdapterOptions, PiTuiRuntimeState, PiTuiScrollState, PiTuiSizeValue, PiTuiStopOptions, PiTuiTerminalPort, PiTuiViewport, } from "./contracts.js";
+export { samePointerSurfaces } from "./overlay-geometry.js";
+export { DamageAwareTerminalAdapter, PINNED_PI_TUI_DAMAGE_GRAMMAR } from "./damage-aware-terminal.js";
+export type { DamageAwareTerminalOptions, PiTuiDamageDecision, PiTuiDamageDecisionReason, PiTuiDamageFrameDescriptor, PiTuiDamageFrameSafety, } from "./damage-aware-terminal.js";
+export { InputPresentationCoordinator, classifyPiTuiInput } from "./input-presentation-coordinator.js";
+export type { InputPresentationCoordinatorOptions, PiTuiInputCoordinationDecision, PiTuiInputCoordinationScheduler, PiTuiInputCoordinationTrace, PiTuiInputSurfaceKind, } from "./input-presentation-coordinator.js";
+export { PiTuiRuntimeAdapter, PiTuiRuntimeError } from "./adapter.js";
+export type { PiTuiRuntimeErrorStage } from "./adapter.js";
+export { createPiPresentationRuntime, createPiTerminalBridge } from "./presentation-adapter.js";

package/dist/integrations/pi/tui-runtime/index.js

@@ -0,0 +1,5 @@
+export { samePointerSurfaces } from "./overlay-geometry.js";
+export { DamageAwareTerminalAdapter, PINNED_PI_TUI_DAMAGE_GRAMMAR } from "./damage-aware-terminal.js";
+export { InputPresentationCoordinator, classifyPiTuiInput } from "./input-presentation-coordinator.js";
+export { PiTuiRuntimeAdapter, PiTuiRuntimeError } from "./adapter.js";
+export { createPiPresentationRuntime, createPiTerminalBridge } from "./presentation-adapter.js";

package/dist/integrations/pi/tui-runtime/input-presentation-coordinator.d.ts

@@ -0,0 +1,39 @@
+export type PiTuiInputCoordinationDecision = "safe" | "barrier";
+export type PiTuiInputSurfaceKind = "editor" | "owned" | "opaque";
+export interface PiTuiInputCoordinationScheduler {
+    scheduleImmediate(callback: () => void): ReturnType<typeof setImmediate>;
+    cancelImmediate(handle: ReturnType<typeof setImmediate>): void;
+}
+export interface PiTuiInputCoordinationTrace {
+    readonly phase: "receipt" | "semantic-start" | "semantic-end";
+    readonly revision: number;
+    readonly atMs: number;
+    readonly pendingDepth: number;
+    readonly pendingPresentationDepth: 0 | 1;
+    readonly appliedRevision: number;
+}
+export interface InputPresentationCoordinatorOptions {
+    readonly classify: (data: string) => PiTuiInputCoordinationDecision;
+    readonly deliver: (data: string) => void;
+    readonly onReceipt?: () => void;
+    readonly onTrace?: (event: PiTuiInputCoordinationTrace) => void;
+    readonly now?: () => number;
+    readonly scheduler?: PiTuiInputCoordinationScheduler;
+}
+/**
+ * Delivers complete terminal chunks in their original order while allowing Pi
+ * TUI's existing pending-render guard to present one current state per event
+ * loop turn. Unknown or effectful input is an immediate ordering barrier.
+ */
+export declare class InputPresentationCoordinator {
+    #private;
+    constructor(options: InputPresentationCoordinatorOptions);
+    get pendingDepth(): number;
+    get appliedRevision(): number;
+    get pendingPresentation(): boolean;
+    accept(data: string): void;
+    flush(): void;
+    dispose(deliverPending?: boolean): void;
+}
+/** Finite fail-closed grammar for input whose semantic handlers may run in one ordered drain. */
+export declare function classifyPiTuiInput(data: string, surface: PiTuiInputSurfaceKind): PiTuiInputCoordinationDecision;

package/dist/integrations/pi/tui-runtime/input-presentation-coordinator.js

@@ -0,0 +1,139 @@
+const SYSTEM_SCHEDULER = {
+    scheduleImmediate: callback => setImmediate(callback),
+    cancelImmediate: handle => clearImmediate(handle),
+};
+/**
+ * Delivers complete terminal chunks in their original order while allowing Pi
+ * TUI's existing pending-render guard to present one current state per event
+ * loop turn. Unknown or effectful input is an immediate ordering barrier.
+ */
+export class InputPresentationCoordinator {
+    #classify;
+    #deliver;
+    #onReceipt;
+    #onTrace;
+    #now;
+    #scheduler;
+    #pending = [];
+    #scheduled;
+    #nextRevision = 1;
+    #appliedRevision = 0;
+    #disposed = false;
+    constructor(options) {
+        this.#classify = options.classify;
+        this.#deliver = options.deliver;
+        this.#onReceipt = options.onReceipt;
+        this.#onTrace = options.onTrace;
+        this.#now = options.now ?? (() => performance.now());
+        this.#scheduler = options.scheduler ?? SYSTEM_SCHEDULER;
+    }
+    get pendingDepth() { return this.#pending.length; }
+    get appliedRevision() { return this.#appliedRevision; }
+    get pendingPresentation() { return this.#scheduled !== undefined; }
+    accept(data) {
+        if (this.#disposed || data.length === 0)
+            return;
+        const input = { revision: this.#nextRevision++, data };
+        this.#onReceipt?.();
+        if (this.#classify(data) === "barrier") {
+            this.#trace("receipt", input.revision);
+            this.flush();
+            this.#deliverOne(input);
+            return;
+        }
+        this.#pending.push(input);
+        if (this.#scheduled === undefined) {
+            this.#scheduled = this.#scheduler.scheduleImmediate(() => {
+                this.#scheduled = undefined;
+                this.#drain();
+            });
+        }
+        this.#trace("receipt", input.revision);
+    }
+    flush() {
+        if (this.#scheduled !== undefined)
+            this.#scheduler.cancelImmediate(this.#scheduled);
+        this.#scheduled = undefined;
+        this.#drain();
+    }
+    dispose(deliverPending = true) {
+        if (this.#disposed)
+            return;
+        if (deliverPending)
+            this.flush();
+        else {
+            if (this.#scheduled !== undefined)
+                this.#scheduler.cancelImmediate(this.#scheduled);
+            this.#scheduled = undefined;
+            this.#pending.length = 0;
+        }
+        this.#disposed = true;
+    }
+    #drain() {
+        while (this.#pending.length > 0)
+            this.#deliverOne(this.#pending.shift());
+    }
+    #deliverOne(input) {
+        this.#trace("semantic-start", input.revision);
+        try {
+            this.#deliver(input.data);
+        }
+        finally {
+            this.#appliedRevision = input.revision;
+            this.#trace("semantic-end", input.revision);
+        }
+    }
+    #trace(phase, revision) {
+        this.#onTrace?.({
+            phase,
+            revision,
+            atMs: this.#now(),
+            pendingDepth: this.#pending.length,
+            pendingPresentationDepth: this.#scheduled === undefined ? 0 : 1,
+            appliedRevision: this.#appliedRevision,
+        });
+    }
+}
+const SAFE_EDITING_INPUTS = new Set([
+    "\b",
+    "\u007f",
+    "\u001b[A",
+    "\u001b[B",
+    "\u001b[C",
+    "\u001b[D",
+    "\u001b[1;2A",
+    "\u001b[1;2B",
+    "\u001b[1;5C",
+    "\u001b[1;5D",
+    "\u001b[3~",
+    "\u001b[H",
+    "\u001b[F",
+    "\u001b[1~",
+    "\u001b[4~",
+]);
+const MAX_SAFE_TEXT_DELIVERY = 4096;
+/** Finite fail-closed grammar for input whose semantic handlers may run in one ordered drain. */
+export function classifyPiTuiInput(data, surface) {
+    if (surface === "opaque" || data.length === 0 || data.length > MAX_SAFE_TEXT_DELIVERY)
+        return "barrier";
+    if (SAFE_EDITING_INPUTS.has(data))
+        return "safe";
+    if (data.includes("\u001b") || data.includes("\r") || data.includes("\n") || data.includes("\u0003"))
+        return "barrier";
+    for (let index = 0; index < data.length; index += 1) {
+        const code = data.charCodeAt(index);
+        if (code < 0x20 || code === 0x7f)
+            return "barrier";
+        if (code >= 0xd800 && code <= 0xdbff) {
+            if (index + 1 >= data.length)
+                return "barrier";
+            const next = data.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return "barrier";
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff)
+            return "barrier";
+    }
+    return "safe";
+}

package/dist/integrations/pi/tui-runtime/mouse-report-input.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Keeps mouse reports and adjacent keyboard input in physical delivery order.
+ * ProcessTerminal already frames escape/paste sequences; this also handles hosts
+ * that batch reports or split an SGR report after its introducer. Paste payloads
+ * are opaque and never interpreted as pointer input.
+ */
+export declare class MouseReportInput {
+    #private;
+    readonly deliver: (data: string) => void;
+    constructor(deliver: (data: string) => void);
+    accept(chunk: string): void;
+    reset(): void;
+}

package/dist/integrations/pi/tui-runtime/mouse-report-input.js

@@ -0,0 +1,57 @@
+/**
+ * Keeps mouse reports and adjacent keyboard input in physical delivery order.
+ * ProcessTerminal already frames escape/paste sequences; this also handles hosts
+ * that batch reports or split an SGR report after its introducer. Paste payloads
+ * are opaque and never interpreted as pointer input.
+ */
+export class MouseReportInput {
+    #pending = "";
+    #paste = false;
+    deliver;
+    constructor(deliver) { this.deliver = deliver; }
+    accept(chunk) {
+        const data = this.#pending + chunk;
+        this.#pending = "";
+        if (this.#paste) {
+            const end = data.indexOf("\u001b[201~");
+            if (end < 0) {
+                this.deliver(data);
+                return;
+            }
+            this.#paste = false;
+            this.deliver(data.slice(0, end + 6));
+            if (end + 6 < data.length)
+                this.accept(data.slice(end + 6));
+            return;
+        }
+        const pattern = /\u001b\[200~|\u001b\[<\d+;\d+;\d+[Mm]/g;
+        let from = 0;
+        for (const match of data.matchAll(pattern)) {
+            if (match.index > from)
+                this.deliver(data.slice(from, match.index));
+            if (match[0] === "\u001b[200~") {
+                const end = data.indexOf("\u001b[201~", match.index + 6);
+                this.#paste = end < 0;
+                this.deliver(data.slice(match.index, end < 0 ? undefined : end + 6));
+                if (end >= 0 && end + 6 < data.length)
+                    this.accept(data.slice(end + 6));
+                return;
+            }
+            this.deliver(match[0]);
+            from = match.index + match[0].length;
+        }
+        const rest = data.slice(from);
+        const partial = /\u001b\[<[\d;]*$/.exec(rest);
+        if (partial !== null && partial[0].length <= 64) {
+            this.#pending = partial[0];
+            if (partial.index > 0)
+                this.deliver(rest.slice(0, partial.index));
+        }
+        else if (rest.length > 0)
+            this.deliver(rest);
+    }
+    reset() {
+        this.#pending = "";
+        this.#paste = false;
+    }
+}

package/dist/integrations/pi/tui-runtime/overlay-geometry.d.ts

@@ -0,0 +1,32 @@
+import { TuiAltScreen, type Component, type OverlayHandle, type OverlayOptions } from "@earendil-works/pi-tui";
+import type { PresentationComponentPort, PresentationPointerSurface } from "../../../contracts/presentation/index.js";
+import type { PiTuiOverlayOptions } from "./contracts.js";
+/** Observes public component renders in compositor order, without accessing renderer state. */
+export declare class OverlayGeometryTracker {
+    #private;
+    readonly ports: WeakMap<Component, PresentationComponentPort>;
+    readonly publish: (surfaces: readonly PresentationPointerSurface[] | null) => void;
+    constructor(publish: (surfaces: readonly PresentationPointerSurface[] | null) => void);
+    invalidate(): void;
+    begin(columns: number, rows: number): void;
+    record(component: PresentationComponentPort, options: PiTuiOverlayOptions | undefined, width: number, height: number): void;
+    end(): void;
+}
+/** The protected composition hook brackets the actual visible, focus-ordered overlay renders. */
+export declare class GeometryObservedAltScreen extends TuiAltScreen {
+    #private;
+    geometry: OverlayGeometryTracker | undefined;
+    get overlayFocused(): boolean;
+    setFocus(component: Component | null): void;
+    showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+    hideOverlay(): void;
+    protected compositeOverlays(lines: string[], width: number, height: number): string[];
+}
+/** Compare only geometry and ownership, never animation content or transcript position. */
+export declare function samePointerSurfaces(a: readonly PresentationPointerSurface[], b: readonly PresentationPointerSurface[]): boolean;
+/**
+ * Resolve the pinned public overlay options against the actual render width/height.
+ * The runtime still owns layout and painting. Independent terminal-cell tests certify
+ * this option-to-hit-region projection against its compositor, including clipping.
+ */
+export declare function overlayPointerSurface(component: PresentationComponentPort, options: PiTuiOverlayOptions | undefined, width: number, renderedHeight: number, columns: number, rows: number): PresentationPointerSurface | undefined;

package/dist/integrations/pi/tui-runtime/overlay-geometry.js

@@ -0,0 +1,158 @@
+import { TuiAltScreen, isFocusable } from "@earendil-works/pi-tui";
+/** Observes public component renders in compositor order, without accessing renderer state. */
+export class OverlayGeometryTracker {
+    #frame = [];
+    #pending;
+    #columns = 0;
+    #rows = 0;
+    ports = new WeakMap();
+    publish;
+    constructor(publish) { this.publish = publish; }
+    invalidate() {
+        if (this.#frame === null)
+            return;
+        this.#frame = null;
+        this.publish(null);
+    }
+    begin(columns, rows) {
+        this.#columns = columns;
+        this.#rows = rows;
+        this.#pending = [];
+    }
+    record(component, options, width, height) {
+        if (this.#pending === undefined)
+            return;
+        const region = overlayPointerSurface(component, options, width, height, this.#columns, this.#rows);
+        if (region !== undefined)
+            this.#pending.push(region);
+    }
+    end() {
+        const next = this.#pending ?? [];
+        this.#pending = undefined;
+        if (this.#frame !== null && samePointerSurfaces(this.#frame, next))
+            return;
+        this.#frame = next;
+        this.publish(next);
+    }
+}
+/** The protected composition hook brackets the actual visible, focus-ordered overlay renders. */
+export class GeometryObservedAltScreen extends TuiAltScreen {
+    geometry;
+    #overlayComponents = new WeakMap();
+    get overlayFocused() {
+        return this.isOverlayFocused();
+    }
+    setFocus(component) {
+        super.setFocus(component === null ? null : this.#overlayComponents.get(component) ?? component);
+    }
+    showOverlay(component, options) {
+        // Compatibility: all overlay entries cross the public method, including the runtime's search
+        // dialog. Observe a wrapper, never replace a method on an installed component.
+        const geometry = this.geometry;
+        const port = geometry?.ports.get(component) ?? component;
+        const wrapper = {
+            get focused() { return isFocusable(component) && component.focused; },
+            set focused(value) { if (isFocusable(component))
+                component.focused = value; },
+            get wantsKeyRelease() { return component.wantsKeyRelease ?? false; },
+            render(width) {
+                const lines = component.render(width);
+                geometry?.record(port, options, width, lines.length);
+                return lines;
+            },
+            invalidate: () => component.invalidate(),
+            handleInput: data => component.handleInput?.(data),
+        };
+        this.#overlayComponents.set(component, wrapper);
+        geometry?.invalidate();
+        const handle = super.showOverlay(wrapper, options);
+        return {
+            hide: () => { geometry?.invalidate(); handle.hide(); this.#overlayComponents.delete(component); },
+            setHidden: hidden => {
+                if (hidden !== handle.isHidden())
+                    geometry?.invalidate();
+                handle.setHidden(hidden);
+            },
+            isHidden: () => handle.isHidden(),
+            focus: () => { geometry?.invalidate(); handle.focus(); },
+            unfocus: target => {
+                geometry?.invalidate();
+                if (target === undefined)
+                    handle.unfocus();
+                else
+                    handle.unfocus({ target: target.target === null ? null : this.#overlayComponents.get(target.target) ?? target.target });
+            },
+            isFocused: () => handle.isFocused(),
+            getBounds: () => handle.getBounds(),
+        };
+    }
+    hideOverlay() {
+        this.geometry?.invalidate();
+        super.hideOverlay();
+    }
+    compositeOverlays(lines, width, height) {
+        this.geometry?.begin(width, height);
+        const result = super.compositeOverlays(lines, width, height);
+        this.geometry?.end();
+        return result;
+    }
+}
+/** Compare only geometry and ownership, never animation content or transcript position. */
+export function samePointerSurfaces(a, b) {
+    return a.length === b.length && a.every((surface, index) => {
+        const other = b[index];
+        return surface.component === other.component && surface.columnStart === other.columnStart
+            && surface.columnEnd === other.columnEnd && surface.rowStart === other.rowStart && surface.rowEnd === other.rowEnd;
+    });
+}
+/**
+ * Resolve the pinned public overlay options against the actual render width/height.
+ * The runtime still owns layout and painting. Independent terminal-cell tests certify
+ * this option-to-hit-region projection against its compositor, including clipping.
+ */
+export function overlayPointerSurface(component, options, width, renderedHeight, columns, rows) {
+    const opt = options ?? {};
+    const margin = typeof opt.margin === "number"
+        ? { top: opt.margin, right: opt.margin, bottom: opt.margin, left: opt.margin }
+        : opt.margin ?? {};
+    const top = Math.max(0, margin.top ?? 0);
+    const right = Math.max(0, margin.right ?? 0);
+    const bottom = Math.max(0, margin.bottom ?? 0);
+    const left = Math.max(0, margin.left ?? 0);
+    const availableHeight = Math.max(1, rows - top - bottom);
+    const availableWidth = Math.max(1, columns - left - right);
+    const limit = size(opt.maxHeight, rows);
+    const height = limit === undefined ? renderedHeight : Math.min(renderedHeight, Math.floor(Math.max(1, Math.min(limit, availableHeight))));
+    const anchor = opt.anchor ?? "center";
+    const anchorRow = anchor.startsWith("top-") ? top
+        : anchor.startsWith("bottom-") ? top + availableHeight - height
+            : top + Math.floor((availableHeight - height) / 2);
+    const anchorColumn = anchor.endsWith("-left") || anchor === "left-center" ? left
+        : anchor.endsWith("-right") || anchor === "right-center" ? left + availableWidth - width
+            : left + Math.floor((availableWidth - width) / 2);
+    const row = Math.max(top, Math.min(position(opt.row, top, availableHeight, height, anchorRow) + (opt.offsetY ?? 0), rows - bottom - height));
+    const column = Math.max(left, Math.min(position(opt.col, left, availableWidth, width, anchorColumn) + (opt.offsetX ?? 0), columns - right - width));
+    if (height <= 0 || row >= rows || column >= columns)
+        return undefined;
+    return {
+        component,
+        rowStart: row + 1,
+        rowEnd: Math.min(rows, row + height),
+        columnStart: column + 1,
+        columnEnd: Math.min(columns, column + width),
+    };
+}
+function size(value, extent) {
+    if (typeof value !== "string")
+        return value;
+    const match = /^(\d+(?:\.\d+)?)%$/.exec(value);
+    return match === null ? undefined : Math.floor(extent * Number(match[1]) / 100);
+}
+function position(value, margin, available, extent, anchor) {
+    if (value === undefined)
+        return anchor;
+    if (typeof value === "number")
+        return value;
+    const percent = size(value, Math.max(0, available - extent));
+    return percent === undefined ? margin + Math.floor((available - extent) / 2) : margin + percent;
+}

package/dist/integrations/pi/tui-runtime/presentation-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { PresentationComponentPort, PresentationRuntimePort, PresentationTerminalPort } from "../../../contracts/presentation/index.js";
+import type { PiTuiTerminalPort } from "./contracts.js";
+export declare function createPiPresentationRuntime(root: PresentationComponentPort, terminal: PresentationTerminalPort): PresentationRuntimePort;
+export declare function createPiTerminalBridge(terminal: PresentationTerminalPort): PiTuiTerminalPort;

package/dist/integrations/pi/tui-runtime/presentation-adapter.js

@@ -0,0 +1,48 @@
+import { PiTuiRuntimeAdapter } from "./adapter.js";
+export function createPiPresentationRuntime(root, terminal) {
+    return new PresentationRuntimeAdapter(root, terminal);
+}
+class PresentationRuntimeAdapter {
+    #runtime;
+    terminal;
+    constructor(root, terminal) {
+        this.terminal = terminal;
+        this.#runtime = new PiTuiRuntimeAdapter({ root, terminal: createPiTerminalBridge(terminal), mouse: false });
+    }
+    get state() { return this.#runtime.state; }
+    start() { this.#runtime.start(); }
+    render(force) { this.#runtime.renderNow(force); }
+    showOverlay(component, options) {
+        const handle = this.#runtime.showOverlay(component, {
+            anchor: options.anchor === "top" ? "top-center" : options.anchor === "bottom" ? "bottom-center" : "center",
+            ...(options.width === undefined ? {} : { width: options.width }),
+        });
+        return {
+            get visible() { return !handle.isHidden(); },
+            hide: () => handle.hide(),
+            show: () => handle.setHidden(false),
+            focus: () => handle.focus(),
+            dispose: () => handle.hide(),
+        };
+    }
+    async stop() { await this.#runtime.stop(); }
+}
+export function createPiTerminalBridge(terminal) {
+    return {
+        get columns() { return terminal.columns; },
+        get rows() { return terminal.rows; },
+        get kittyProtocolActive() { return terminal.enhancedKeyboard; },
+        start: (input, resize) => terminal.start(input, resize),
+        stop: () => terminal.stop(),
+        drainInput: (max, idle) => terminal.drainInput(max, idle),
+        write: data => terminal.write(data),
+        moveBy: lines => terminal.moveBy(lines),
+        hideCursor: () => terminal.hideCursor(),
+        showCursor: () => terminal.showCursor(),
+        clearLine: () => terminal.clearLine(),
+        clearFromCursor: () => terminal.clearFromCursor(),
+        clearScreen: () => terminal.clearScreen(),
+        setTitle: title => terminal.setTitle(title),
+        setProgress: active => terminal.setProgress(active),
+    };
+}

package/dist/native/darwin-arm64/manifest.json

@@ -4,12 +4,12 @@
   "crateVersion": "0.1.0-dev",
   "platform": "darwin",
   "architecture": "arm64",
-  "capability": "unsupported",
-  "builtAt": "2026-08-24T07:29:22.956Z",
+  "capability": "supported",
+  "builtAt": "2026-09-19T15:53:23.936Z",
   "artifact": {
     "filename": "process-guardian",
-    "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",
-    "size": 356368
+    "sha256": "9db1726bbe3fc2e8292f2ead1e7e9d0fd4d7d0dc9217b372582bf354b0f565dc",
+    "size": 393152
   },
   "provenance": {
     "language": "Rust",

package/dist/native/linux-x64/manifest.json

@@ -5,11 +5,11 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-24T07:29:31.242Z",
+  "builtAt": "2026-09-19T15:52:58.722Z",
   "artifact": {
     "filename": "process-guardian",
-    "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",
-    "size": 415696
+    "sha256": "d8cda6b0c7cb36c0cc41e90802aceebf6c02eaebbc08a83d7d963d2e918dbd7a",
+    "size": 414536
   },
   "provenance": {
     "language": "Rust",

package/dist/native/win32-x64/manifest.json

@@ -5,11 +5,11 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-24T07:29:57.484Z",
+  "builtAt": "2026-09-19T15:53:36.014Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "363e40ed0f9b1c8306bba5abbec2dd37569085df211ed725735432dd3a5c4a7f",
-    "size": 172544
+    "sha256": "fe9e1240327ceef82fab7d679637b3cc66b18bb529783fa24d98c4f3ff11c1ec",
+    "size": 177664
   },
   "provenance": {
     "language": "Rust",

package/dist/product-identity.d.ts

@@ -0,0 +1,37 @@
+declare const ENVIRONMENT_KEYS: readonly ["clipboardDiagnostics", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "paneId", "probeTrace", "processGuardianPath", "profileHome", "runtimeDir", "startupTrace", "suggestionDiagnostics", "terminalSessionId"];
+declare const FILESYSTEM_KEYS: readonly ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
+declare const STATE_KEYS: readonly ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile"];
+declare const ENDPOINT_KEYS: readonly ["windowsPipeStem", "unixSocketFilename", "metadataFilename", "supervisorLogFilename", "databaseFilename"];
+declare const MANIFEST_KEYS: readonly ["releaseFilename", "packageFilename"];
+declare const PROTOCOL_KEYS: readonly ["namespace", "controlEnvelope", "supervisorSchema", "nativeHostSchema", "structuredAgentSchema", "controlStoreSchema", "promptHistorySchema", "releaseCohortSchema", "updateJournalSchema"];
+declare const EVIDENCE_KEYS: readonly ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema", "startupTraceSchema", "dependencyLayerSchema", "dependencyLayerCertificationSchema", "runtimePayloadSchema"];
+declare const ARTIFACT_KEYS: readonly ["cliEntry", "supervisorEntry", "guardianEntry", "uiEntry", "nativeExecutable", "nativeCrate", "processGuardianExecutable", "releaseTarballStem", "diagnosticStem"];
+type StringRecord<Keys extends readonly string[]> = {
+    readonly [Key in Keys[number]]: string;
+};
+export interface ProductIdentity {
+    readonly schema: string;
+    readonly displayName: string;
+    readonly commandName: string;
+    readonly packageName: string;
+    readonly filesystem: StringRecord<typeof FILESYSTEM_KEYS>;
+    readonly environment: StringRecord<typeof ENVIRONMENT_KEYS>;
+    readonly state: StringRecord<typeof STATE_KEYS>;
+    readonly endpoint: StringRecord<typeof ENDPOINT_KEYS>;
+    readonly manifest: StringRecord<typeof MANIFEST_KEYS>;
+    readonly protocol: StringRecord<typeof PROTOCOL_KEYS>;
+    readonly evidence: StringRecord<typeof EVIDENCE_KEYS>;
+    readonly artifacts: StringRecord<typeof ARTIFACT_KEYS>;
+}
+export declare function validateProductIdentity(value: unknown): ProductIdentity;
+export interface ProductIdentityText {
+    readonly displayName: string;
+    readonly commandName: string;
+    readonly packageName: string;
+    readonly diagnostic: (message: string) => string;
+    readonly usage: (forms: readonly string[]) => string;
+}
+export declare function createProductIdentityText(identity: Pick<ProductIdentity, "displayName" | "commandName" | "packageName">): ProductIdentityText;
+export declare const PRODUCT_IDENTITY: ProductIdentity;
+export declare const PRODUCT_TEXT: ProductIdentityText;
+export {};