@timurproko/a1 0.1.8-dev.ece8cef → 0.2.0

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

@@ -0,0 +1,91 @@
+const BRACKETED_PASTE_START = "\u001b[200~";
+const BRACKETED_PASTE_END = "\u001b[201~";
+const SGR_MOUSE_REPORT_PATTERN = /\u001b\[<\d+;\d+;\d+[Mm]/g;
+/**
+ * Removes complete SGR mouse reports outside bracketed paste while preserving
+ * every adjacent byte in order. Incomplete reports remain available to the
+ * caller's framing boundary rather than being guessed at here.
+ */
+export function stripSgrMouseReports(data) {
+    if (!data.includes("\u001b[<"))
+        return data;
+    let output = "";
+    let from = 0;
+    while (from < data.length) {
+        const pasteStart = data.indexOf(BRACKETED_PASTE_START, from);
+        SGR_MOUSE_REPORT_PATTERN.lastIndex = from;
+        const report = SGR_MOUSE_REPORT_PATTERN.exec(data);
+        if (pasteStart >= 0 && (report === null || pasteStart < report.index)) {
+            output += data.slice(from, pasteStart);
+            const pasteEnd = data.indexOf(BRACKETED_PASTE_END, pasteStart + BRACKETED_PASTE_START.length);
+            if (pasteEnd < 0)
+                return output + data.slice(pasteStart);
+            const afterPaste = pasteEnd + BRACKETED_PASTE_END.length;
+            output += data.slice(pasteStart, afterPaste);
+            from = afterPaste;
+            continue;
+        }
+        if (report === null)
+            return output + data.slice(from);
+        output += data.slice(from, report.index);
+        from = report.index + report[0].length;
+    }
+    return output;
+}
+/**
+ * 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-24T06:13:26.421Z",
+  "capability": "supported",
+  "builtAt": "2026-09-25T08:45:59.617Z",
   "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-24T06:13:25.256Z",
+  "builtAt": "2026-09-25T08:45:41.109Z",
   "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-24T06:14:07.591Z",
+  "builtAt": "2026-09-25T08:46:32.399Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "1909fdcedc8f7ac0de4c8deca2bdb8307f6efe5de4d33ca6b0723740420530f9",
-    "size": 172544
+    "sha256": "ca9372c0bcf87ed605d89627990986b905b3c756244ce3dd1f51b0b324f77542",
+    "size": 178176
   },
   "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", "prFooterPreview", "profileHome", "runtimeDir", "startupTrace", "suggestionDiagnostics", "terminalSessionId"];
+declare const FILESYSTEM_KEYS: readonly ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
+declare const STATE_KEYS: readonly ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "sessionRepositoryDirectory"];
+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 {};

package/dist/product-identity.js

@@ -0,0 +1,119 @@
+import rawIdentity from "./product-identity.json" with { type: "json" };
+const ENVIRONMENT_KEYS = [
+    "clipboardDiagnostics", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint",
+    "paneId", "probeTrace", "processGuardianPath", "prFooterPreview", "profileHome", "runtimeDir", "startupTrace", "suggestionDiagnostics", "terminalSessionId",
+];
+const FILESYSTEM_KEYS = ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
+const STATE_KEYS = ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "sessionRepositoryDirectory"];
+const ENDPOINT_KEYS = ["windowsPipeStem", "unixSocketFilename", "metadataFilename", "supervisorLogFilename", "databaseFilename"];
+const MANIFEST_KEYS = ["releaseFilename", "packageFilename"];
+const PROTOCOL_KEYS = ["namespace", "controlEnvelope", "supervisorSchema", "nativeHostSchema", "structuredAgentSchema", "controlStoreSchema", "promptHistorySchema", "releaseCohortSchema", "updateJournalSchema"];
+const EVIDENCE_KEYS = ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema", "startupTraceSchema", "dependencyLayerSchema", "dependencyLayerCertificationSchema", "runtimePayloadSchema"];
+const ARTIFACT_KEYS = ["cliEntry", "supervisorEntry", "guardianEntry", "uiEntry", "nativeExecutable", "nativeCrate", "processGuardianExecutable", "releaseTarballStem", "diagnosticStem"];
+const ROOT_KEYS = ["schema", "displayName", "commandName", "packageName", "filesystem", "environment", "state", "endpoint", "manifest", "protocol", "evidence", "artifacts"];
+export function validateProductIdentity(value) {
+    const root = exactObject(value, ROOT_KEYS, "product identity");
+    const schema = stringValue(root.schema, "product identity schema");
+    const displayName = stringValue(root.displayName, "product display name");
+    const commandName = stringValue(root.commandName, "product command name");
+    const packageName = stringValue(root.packageName, "product package name");
+    const filesystem = stringObject(root.filesystem, FILESYSTEM_KEYS, "filesystem identity");
+    const environment = stringObject(root.environment, ENVIRONMENT_KEYS, "environment identity");
+    const state = stringObject(root.state, STATE_KEYS, "state identity");
+    const endpoint = stringObject(root.endpoint, ENDPOINT_KEYS, "endpoint identity");
+    const manifest = stringObject(root.manifest, MANIFEST_KEYS, "manifest identity");
+    const protocol = stringObject(root.protocol, PROTOCOL_KEYS, "protocol identity");
+    const evidence = stringObject(root.evidence, EVIDENCE_KEYS, "evidence identity");
+    const artifacts = stringObject(root.artifacts, ARTIFACT_KEYS, "artifact identity");
+    if (!/^[a-z][a-z0-9-]*$/.test(commandName))
+        throw new TypeError("product command name must be a lowercase command slug");
+    if (!/^@[a-z0-9-]+\/[a-z0-9-]+$/.test(packageName))
+        throw new TypeError("product package name must be a lowercase scoped npm package");
+    if (displayName.trim() !== displayName || displayName.length === 0)
+        throw new TypeError("product display name must be non-empty without surrounding whitespace");
+    if (schema !== `${commandName}-product-identity-v1`)
+        throw new TypeError("product identity schema must derive from the command name");
+    if (filesystem.slug !== commandName || filesystem.unixDirectory !== filesystem.slug || filesystem.windowsDirectory !== filesystem.slug) {
+        throw new TypeError("product filesystem identity must derive from the command name");
+    }
+    if (filesystem.temporaryPrefix !== `${filesystem.slug}-`)
+        throw new TypeError("product temporary prefix must derive from the filesystem slug");
+    if (state.windowsControlDirectory !== filesystem.windowsDirectory || state.unixControlDirectory !== filesystem.unixDirectory) {
+        throw new TypeError("product state directories must match the filesystem identity");
+    }
+    if (endpoint.windowsPipeStem !== filesystem.slug)
+        throw new TypeError("product endpoint stem must match the filesystem slug");
+    if (protocol.namespace !== commandName)
+        throw new TypeError("product protocol namespace must match the command name");
+    if (artifacts.diagnosticStem !== filesystem.slug)
+        throw new TypeError("product diagnostic stem must match the filesystem slug");
+    const environmentPrefix = `${commandName.toUpperCase()}_`;
+    const environmentValues = Object.values(environment);
+    if (new Set(environmentValues).size !== environmentValues.length)
+        throw new TypeError("product environment keys must be unique");
+    for (const key of environmentValues) {
+        if (!key.startsWith(environmentPrefix) || !/^[A-Z][A-Z0-9_]+$/.test(key)) {
+            throw new TypeError(`product environment key must use ${environmentPrefix}: ${key}`);
+        }
+    }
+    for (const [name, identifier] of Object.entries(protocol)) {
+        if (name !== "namespace" && !identifier.startsWith(`${protocol.namespace}-`)) {
+            throw new TypeError(`product protocol identifier must use ${protocol.namespace}: ${identifier}`);
+        }
+    }
+    for (const identifier of Object.values(evidence)) {
+        if (!identifier.startsWith(`${protocol.namespace}-`))
+            throw new TypeError(`product evidence identifier must use ${protocol.namespace}: ${identifier}`);
+    }
+    return deepFreeze({
+        schema,
+        displayName,
+        commandName,
+        packageName,
+        filesystem,
+        environment,
+        state,
+        endpoint,
+        manifest,
+        protocol,
+        evidence,
+        artifacts,
+    });
+}
+export function createProductIdentityText(identity) {
+    return Object.freeze({
+        displayName: identity.displayName,
+        commandName: identity.commandName,
+        packageName: identity.packageName,
+        diagnostic: (message) => `${identity.displayName} ${message}`,
+        usage: (forms) => `Usage: ${forms.map(form => `${identity.commandName}${form ? ` ${form}` : ""}`).join(" | ")}`,
+    });
+}
+export const PRODUCT_IDENTITY = validateProductIdentity(rawIdentity);
+export const PRODUCT_TEXT = createProductIdentityText(PRODUCT_IDENTITY);
+function exactObject(value, keys, name) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new TypeError(`${name} must be an object`);
+    const actualKeys = Object.keys(value).sort();
+    const expectedKeys = [...keys].sort();
+    if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
+        throw new TypeError(`${name} must contain exactly: ${expectedKeys.join(", ")}`);
+    }
+    return value;
+}
+function stringObject(value, keys, name) {
+    const object = exactObject(value, keys, name);
+    return Object.fromEntries(keys.map((key) => [key, stringValue(object[key], `${name}.${key}`)]));
+}
+function stringValue(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new TypeError(`${name} must be a non-empty string`);
+    return value;
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}

package/dist/product-identity.json

@@ -0,0 +1,87 @@
+{
+    "schema": "a1-product-identity-v1",
+    "displayName": "a1",
+    "commandName": "a1",
+    "packageName": "@timurproko/a1",
+    "filesystem": {
+        "slug": "a1",
+        "windowsDirectory": "a1",
+        "unixDirectory": "a1",
+        "temporaryPrefix": "a1-"
+    },
+    "environment": {
+        "clipboardDiagnostics": "A1_CLIPBOARD_DIAGNOSTICS",
+        "configDir": "A1_CONFIG_DIR",
+        "dataDir": "A1_DATA_DIR",
+        "databasePath": "A1_DATABASE_PATH",
+        "developmentInstanceId": "A1_DEV_INSTANCE_ID",
+        "developmentRoot": "A1_DEV_ROOT",
+        "endpoint": "A1_ENDPOINT",
+        "paneId": "A1_PANE_ID",
+        "probeTrace": "A1_PROBE_TRACE",
+        "processGuardianPath": "A1_PROCESS_GUARDIAN_PATH",
+        "prFooterPreview": "A1_PR_FOOTER_PREVIEW",
+        "profileHome": "A1_PROFILE_HOME",
+        "runtimeDir": "A1_RUNTIME_DIR",
+        "startupTrace": "A1_STARTUP_TRACE",
+        "suggestionDiagnostics": "A1_SUGGESTION_DIAGNOSTICS",
+        "terminalSessionId": "A1_TERMINAL_SESSION_ID"
+    },
+    "state": {
+        "windowsControlDirectory": "a1",
+        "unixControlDirectory": "a1",
+        "developmentDirectory": "a1-development",
+        "piAgentProfile": ".a1/agent",
+        "piVanillaProfile": ".pi/agent",
+        "sessionRepositoryDirectory": "session-repositories"
+    },
+    "endpoint": {
+        "windowsPipeStem": "a1",
+        "unixSocketFilename": "supervisor.sock",
+        "metadataFilename": "supervisor.json",
+        "supervisorLogFilename": "supervisor.log",
+        "databaseFilename": "control.sqlite3"
+    },
+    "manifest": {
+        "releaseFilename": ".a1-release.json",
+        "packageFilename": "package.json"
+    },
+    "protocol": {
+        "namespace": "a1",
+        "controlEnvelope": "a1-control-envelope",
+        "supervisorSchema": "a1-supervisor-v1",
+        "nativeHostSchema": "a1-native-host-v1",
+        "structuredAgentSchema": "a1-structured-agent-v1",
+        "controlStoreSchema": "a1-control-store-v1",
+        "promptHistorySchema": "a1-prompt-history-v1",
+        "releaseCohortSchema": "a1-release-cohort-v1",
+        "updateJournalSchema": "a1-update-journal-v1"
+    },
+    "evidence": {
+        "nativeSpikeSchema": "a1-native-host-spike-evidence-v1",
+        "terminalProvenanceSchema": "a1-terminal-host-provenance-v1",
+        "terminalProofSchema": "a1-terminal-host-proof-v1",
+        "stableReleaseSchema": "a1-stable-release-v1",
+        "previewReleaseSchema": "a1-preview-release-v1",
+        "releaseCertificationSchema": "a1-release-certification-v1",
+        "previewPlatformVerdictSchema": "a1-development-preview-platform-verdict-v2",
+        "piSourceLedgerSchema": "a1-pinned-pi-source-port-ledger-v1",
+        "piComponentParitySchema": "a1-pi-static-component-parity-v1",
+        "piEventFrameParitySchema": "a1-pi-event-frame-parity-v1",
+        "startupTraceSchema": "a1-startup-trace-v1",
+        "dependencyLayerSchema": "a1-dependency-layer-v1",
+        "dependencyLayerCertificationSchema": "a1-dependency-layer-certification-v1",
+        "runtimePayloadSchema": "a1-runtime-payload-v1"
+    },
+    "artifacts": {
+        "cliEntry": "bin/cli.js",
+        "supervisorEntry": "bin/supervisor.js",
+        "guardianEntry": "bin/guardian.js",
+        "uiEntry": "bin/ui.js",
+        "nativeExecutable": "terminal-host",
+        "nativeCrate": "terminal-host",
+        "processGuardianExecutable": "process-guardian",
+        "releaseTarballStem": "timurproko-a1",
+        "diagnosticStem": "a1"
+    }
+}