@timurproko/a1 0.1.8-dev.21b95d6 → 0.1.8-dev.224

package/dist/integrations/pi/tui-runtime/damage-aware-terminal.js

@@ -0,0 +1,240 @@
+export const PINNED_PI_TUI_DAMAGE_GRAMMAR = "@earendil-works/pi-tui@0.84.2:tui-alt-screen-one-write-v1";
+const BEGIN_SYNCHRONIZED_OUTPUT = "\u001b[?2026h";
+const END_SYNCHRONIZED_OUTPUT = "\u001b[?2026l";
+const ROW_MARKER = /\u001b\[(\d+);1H\u001b\[2K/gu;
+const CURSOR_SUFFIX = /\u001b\[(\d+);(\d+)H\u001b\[\?25[hl]\u001b\[\?2026l$/u;
+const OSC8 = /\u001b\]8;[^;\u0007\u001b]*;([^\u0007\u001b]*)(?:\u0007|\u001b\\)/gu;
+/**
+ * A fail-closed adapter for one pinned Pi fullscreen write grammar. Semantic
+ * viewport metadata authorizes a shift; bytes are inspected only to validate
+ * and preserve Pi's complete row paint and cursor syntax.
+ */
+export class DamageAwareTerminalAdapter {
+    inner;
+    options;
+    #rows = new Map();
+    #armed;
+    #lastConsumedFrameId = 0;
+    #cacheWidth = 0;
+    #cacheHeight = 0;
+    #decision = {
+        frameId: null,
+        transformed: false,
+        reason: "not-armed",
+        shiftRows: 0,
+        paintedRows: [],
+    };
+    constructor(inner, options) {
+        this.inner = inner;
+        this.options = options;
+    }
+    get columns() { return this.inner.columns; }
+    get rows() { return this.inner.rows; }
+    get kittyProtocolActive() { return this.inner.kittyProtocolActive; }
+    get lastDecision() { return this.#decision; }
+    arm(descriptor, safety) {
+        this.#armed = { descriptor, safety };
+    }
+    start(onInput, onResize) {
+        this.inner.start(onInput, () => {
+            this.#invalidateRows();
+            this.options.onResize?.();
+            onResize();
+        });
+    }
+    stop() {
+        this.#armed = undefined;
+        this.#invalidateRows();
+        this.inner.stop();
+    }
+    drainInput(maxMs, idleMs) { return this.inner.drainInput(maxMs, idleMs); }
+    write(data) {
+        const armed = this.#armed;
+        this.#armed = undefined;
+        const parsed = parsePinnedFullscreenWrite(data);
+        const decision = this.#decide(armed, parsed);
+        this.#decision = decision;
+        if (decision.reason === "suppressed-redundant-clear" && parsed !== null) {
+            this.inner.write(buildClearlessWrite(parsed));
+        }
+        else if (decision.transformed && armed !== undefined && parsed !== null) {
+            this.inner.write(buildDamageWrite(parsed, armed.descriptor, new Set(decision.paintedRows), this.#rows));
+        }
+        else {
+            this.inner.write(data);
+        }
+        this.#rememberFrame(armed?.descriptor, parsed, data);
+    }
+    moveBy(lines) { this.inner.moveBy(lines); }
+    hideCursor() { this.inner.hideCursor(); }
+    showCursor() { this.inner.showCursor(); }
+    clearLine() { this.#invalidateRows(); this.inner.clearLine(); }
+    clearFromCursor() { this.#invalidateRows(); this.inner.clearFromCursor(); }
+    clearScreen() { this.#invalidateRows(); this.inner.clearScreen(); }
+    setTitle(title) { this.inner.setTitle(title); }
+    setProgress(active) { this.inner.setProgress(active); }
+    #decide(armed, parsed) {
+        if (armed === undefined) {
+            return { frameId: null, transformed: false, reason: "not-armed", shiftRows: 0, paintedRows: [] };
+        }
+        const descriptor = armed.descriptor;
+        const base = {
+            frameId: descriptor.frameId,
+            transformed: false,
+            shiftRows: descriptor.verticalShiftRows,
+            paintedRows: [],
+        };
+        if (descriptor.frameId <= this.#lastConsumedFrameId)
+            return { ...base, reason: "stale-frame" };
+        this.#lastConsumedFrameId = descriptor.frameId;
+        if (parsed !== null && parsed.structuralPrefix === "\u001b[2J"
+            && this.#cacheWidth === descriptor.width && this.#cacheHeight === descriptor.height
+            && hasCompleteScreenRows(parsed.rows, descriptor.height) && !hasUnsafeTerminalContent(parsed)) {
+            return {
+                frameId: descriptor.frameId,
+                transformed: true,
+                reason: "suppressed-redundant-clear",
+                shiftRows: 0,
+                paintedRows: parsed.rows.map(row => row.row),
+            };
+        }
+        if (!descriptor.safeVerticalShift || armed.safety.overlayActive || armed.safety.selectionActive
+            || armed.safety.replacementSurfaceActive || descriptor.transcript === null) {
+            return { ...base, reason: "unsafe-frame" };
+        }
+        if (!this.options.regionalScroll)
+            return { ...base, reason: "unsupported-region-scroll" };
+        if (descriptor.width !== this.columns || descriptor.height !== this.rows
+            || descriptor.verticalShiftRows < 1
+            || descriptor.verticalShiftRows >= descriptor.transcript.rowEnd - descriptor.transcript.rowStart + 1) {
+            return { ...base, reason: "geometry-mismatch" };
+        }
+        if (parsed === null)
+            return { ...base, reason: "grammar-mismatch" };
+        if (parsed.structuralPrefix.length > 0 || hasUnsafeTerminalContent(parsed)) {
+            return { ...base, reason: "unsafe-terminal-content" };
+        }
+        const { rowStart, rowEnd } = descriptor.transcript;
+        const desired = new Map(parsed.rows.map(row => [row.row, row.content]));
+        for (let row = rowStart; row <= rowEnd; row += 1) {
+            if (!desired.has(row) && !this.#rows.has(row))
+                return { ...base, reason: "incomplete-prior-frame" };
+            if (row <= rowEnd - descriptor.verticalShiftRows && !this.#rows.has(row + descriptor.verticalShiftRows)) {
+                return { ...base, reason: "incomplete-prior-frame" };
+            }
+        }
+        for (const row of parsed.rows) {
+            const inTranscript = row.row >= rowStart && row.row <= rowEnd;
+            const inDock = descriptor.dock !== null && row.row >= descriptor.dock.rowStart && row.row <= descriptor.dock.rowEnd;
+            if (!inTranscript && !inDock)
+                return { ...base, reason: "grammar-mismatch" };
+        }
+        const painted = new Set();
+        for (let row = rowStart; row <= rowEnd; row += 1) {
+            const source = row + descriptor.verticalShiftRows;
+            const desiredContent = desired.get(row) ?? this.#rows.get(row);
+            if (source > rowEnd || desiredContent !== this.#rows.get(source))
+                painted.add(row);
+        }
+        for (const row of parsed.rows) {
+            if (descriptor.dock !== null && row.row >= descriptor.dock.rowStart && row.row <= descriptor.dock.rowEnd)
+                painted.add(row.row);
+        }
+        // Rationale: ordinary followed prose may change one active tail source row, expose
+        // the shifted suffix, and restyle one sticky boundary row. Larger changes indicate
+        // Markdown/theme/overlay reflow and fail closed.
+        if (painted.size > descriptor.verticalShiftRows + 2 + countDockRows(parsed.rows, descriptor.dock)) {
+            return { ...base, reason: "excessive-real-damage" };
+        }
+        return {
+            frameId: descriptor.frameId,
+            transformed: true,
+            reason: "transformed",
+            shiftRows: descriptor.verticalShiftRows,
+            paintedRows: [...painted].sort((left, right) => left - right),
+        };
+    }
+    #rememberFrame(descriptor, parsed, raw) {
+        if (raw.includes("\u001b[2J") || raw.includes("\u001b[?1049") || raw.includes("\u001b_G") || raw.includes("\u001bPq")) {
+            this.#invalidateRows();
+        }
+        if (parsed === null)
+            return;
+        if (descriptor !== undefined && (descriptor.width !== this.#cacheWidth || descriptor.height !== this.#cacheHeight)) {
+            this.#invalidateRows();
+            this.#cacheWidth = descriptor.width;
+            this.#cacheHeight = descriptor.height;
+        }
+        for (const row of parsed.rows)
+            this.#rows.set(row.row, row.content);
+    }
+    #invalidateRows() {
+        this.#rows.clear();
+        this.#cacheWidth = 0;
+        this.#cacheHeight = 0;
+    }
+}
+function parsePinnedFullscreenWrite(data) {
+    if (!data.startsWith(BEGIN_SYNCHRONIZED_OUTPUT) || !data.endsWith(END_SYNCHRONIZED_OUTPUT))
+        return null;
+    const suffix = data.match(CURSOR_SUFFIX);
+    if (suffix?.index === undefined)
+        return null;
+    const body = data.slice(BEGIN_SYNCHRONIZED_OUTPUT.length, suffix.index);
+    const matches = [...body.matchAll(ROW_MARKER)];
+    if (matches.length === 0)
+        return null;
+    const structuralPrefix = body.slice(0, matches[0].index);
+    if (structuralPrefix !== "" && structuralPrefix !== "\u001b[2J")
+        return null;
+    const rows = [];
+    let previousRow = 0;
+    for (let index = 0; index < matches.length; index += 1) {
+        const match = matches[index];
+        const row = Number.parseInt(match[1], 10);
+        if (!Number.isSafeInteger(row) || row < 1 || row <= previousRow)
+            return null;
+        previousRow = row;
+        const start = match.index;
+        const contentStart = start + match[0].length;
+        const end = matches[index + 1]?.index ?? body.length;
+        const content = body.slice(contentStart, end);
+        rows.push({ row, content, segment: body.slice(start, end) });
+    }
+    return { structuralPrefix, rows, cursorSuffix: data.slice(suffix.index) };
+}
+function hasUnsafeTerminalContent(parsed) {
+    const data = parsed.rows.map(row => row.content).join("");
+    if (data.includes("\u001b_G") || data.includes("\u001bPq") || data.includes("\u001b[2J"))
+        return true;
+    for (const match of data.matchAll(OSC8))
+        if ((match[1] ?? "").length > 0)
+            return true;
+    return false;
+}
+function buildDamageWrite(parsed, descriptor, paintedRows, previousRows) {
+    const transcript = descriptor.transcript;
+    const regionShift = `\u001b[${transcript.rowStart};${transcript.rowEnd}r`
+        + `\u001b[${transcript.rowStart};1H`
+        + `\u001b[${descriptor.verticalShiftRows}S`
+        + "\u001b[r";
+    const parsedRows = new Map(parsed.rows.map(row => [row.row, row]));
+    const rowPaint = [...paintedRows].sort((left, right) => left - right).map(row => {
+        const parsedRow = parsedRows.get(row);
+        if (parsedRow !== undefined)
+            return parsedRow.segment;
+        return `\u001b[${row};1H\u001b[2K${previousRows.get(row) ?? ""}`;
+    }).join("");
+    return `${BEGIN_SYNCHRONIZED_OUTPUT}${regionShift}${rowPaint}${parsed.cursorSuffix}`;
+}
+function buildClearlessWrite(parsed) {
+    return `${BEGIN_SYNCHRONIZED_OUTPUT}${parsed.rows.map(row => row.segment).join("")}${parsed.cursorSuffix}`;
+}
+function hasCompleteScreenRows(rows, height) {
+    return rows.length === height && rows.every((row, index) => row.row === index + 1);
+}
+function countDockRows(rows, dock) {
+    if (dock === null)
+        return 0;
+    return rows.filter(row => row.row >= dock.rowStart && row.row <= dock.rowEnd).length;
+}

package/dist/{src/foundation/pi-tui-runtime-adapter → integrations/pi/tui-runtime}/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./contracts.js";
+export * from "./damage-aware-terminal.js";
+export * from "./input-presentation-coordinator.js";
 export * from "./adapter.js";
 export * from "./conformance.js";
 export * from "./presentation-adapter.js";

package/dist/{src/foundation/pi-tui-runtime-adapter → integrations/pi/tui-runtime}/index.js

@@ -1,4 +1,6 @@
 export * from "./contracts.js";
+export * from "./damage-aware-terminal.js";
+export * from "./input-presentation-coordinator.js";
 export * from "./adapter.js";
 export * from "./conformance.js";
 export * 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/{src/foundation/pi-tui-runtime-adapter → integrations/pi/tui-runtime}/presentation-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { PresentationComponentPort, PresentationRuntimePort, PresentationTerminalPort } from "../presentation-contracts/index.js";
+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/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-25T08:21:01.149Z",
+  "builtAt": "2026-09-03T16:39:37.425Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

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

@@ -5,11 +5,11 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T08:20:57.618Z",
+  "builtAt": "2026-09-03T16:39:27.399Z",
   "artifact": {
     "filename": "process-guardian",
-    "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",
-    "size": 415696
+    "sha256": "ee8a00eaaf79c707459bbbfb52518e9739314967049fbe5fa625f36ce33db9ee",
+    "size": 414568
   },
   "provenance": {
     "language": "Rust",

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

@@ -5,11 +5,11 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T08:21:59.118Z",
+  "builtAt": "2026-09-03T16:40:47.022Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "82d4ad108c0e73f59b8bca207c751a7822e21045895c1453296fff6b649042ea",
-    "size": 172544
+    "sha256": "2fe463dcdeaedfbc9df817ac61e973f27500e9527d05bd781553da89d6767926",
+    "size": 177664
   },
   "provenance": {
     "language": "Rust",

package/dist/{src/product-identity.d.ts → product-identity.d.ts}

@@ -1,10 +1,10 @@
-declare const ENVIRONMENT_KEYS: readonly ["certificationTarball", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "fixture", "fixtureInput", "fixtureToken", "inputAcknowledgement", "internalPackaging", "launchArgumentsJson", "launchProfile", "nativePi", "paneId", "piParityIntentionalMutation", "piPortRoot", "piSourceLedgerPath", "piSourceScanRoot", "probeTrace", "processGuardianPath", "profileHome", "protocolVersion", "releaseDigest", "releaseId", "releaseRoot", "releaseRunnerLabel", "runtimeDir", "structuredFlowLimits", "terminalArgumentsJson", "terminalExecutable", "terminalSessionId"];
+declare const ENVIRONMENT_KEYS: readonly ["certificationTarball", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "fixture", "fixtureInput", "fixtureToken", "inputAcknowledgement", "immutableWarmup", "internalPackaging", "launchProfile", "nativePi", "paneId", "piParityIntentionalMutation", "piPortRoot", "piSourceLedgerPath", "piSourceScanRoot", "probeTrace", "processGuardianPath", "profileHome", "protocolVersion", "releaseDigest", "releaseId", "releaseLayers", "releaseRoot", "releaseRunnerLabel", "runtimeDir", "structuredFlowLimits", "startupTrace", "terminalArgumentsJson", "terminalExecutable", "terminalSessionId"];
 declare const FILESYSTEM_KEYS: readonly ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
-declare const STATE_KEYS: readonly ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "piSandboxProfile"];
+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", "releaseCohortSchema", "updateJournalSchema"];
-declare const EVIDENCE_KEYS: readonly ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema"];
+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;

package/dist/{src/product-identity.js → product-identity.js}

@@ -11,8 +11,8 @@ const ENVIRONMENT_KEYS = [
     "fixtureInput",
     "fixtureToken",
     "inputAcknowledgement",
+    "immutableWarmup",
     "internalPackaging",
-    "launchArgumentsJson",
     "launchProfile",
     "nativePi",
     "paneId",
@@ -26,20 +26,22 @@ const ENVIRONMENT_KEYS = [
     "protocolVersion",
     "releaseDigest",
     "releaseId",
+    "releaseLayers",
     "releaseRoot",
     "releaseRunnerLabel",
     "runtimeDir",
     "structuredFlowLimits",
+    "startupTrace",
     "terminalArgumentsJson",
     "terminalExecutable",
     "terminalSessionId",
 ];
 const FILESYSTEM_KEYS = ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
-const STATE_KEYS = ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "piSandboxProfile"];
+const STATE_KEYS = ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile"];
 const ENDPOINT_KEYS = ["windowsPipeStem", "unixSocketFilename", "metadataFilename", "supervisorLogFilename", "databaseFilename"];
 const MANIFEST_KEYS = ["releaseFilename", "packageFilename"];
 const PROTOCOL_KEYS = ["namespace", "controlEnvelope", "supervisorSchema", "nativeHostSchema", "structuredAgentSchema", "controlStoreSchema", "releaseCohortSchema", "updateJournalSchema"];
-const EVIDENCE_KEYS = ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema"];
+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) {
@@ -64,8 +66,8 @@ export function validateProductIdentity(value) {
         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 !== displayName) {
-        throw new TypeError("product filesystem identity must derive from display and command names");
+    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");

package/dist/{src/product-identity.json → product-identity.json}

@@ -5,7 +5,7 @@
     "packageName": "@timurproko/a1",
     "filesystem": {
         "slug": "a1",
-        "windowsDirectory": "A1",
+        "windowsDirectory": "a1",
         "unixDirectory": "a1",
         "temporaryPrefix": "a1-"
     },
@@ -21,8 +21,8 @@
         "fixtureInput": "A1_FIXTURE_INPUT",
         "fixtureToken": "A1_FIXTURE_TOKEN",
         "inputAcknowledgement": "A1_INPUT_ACK",
+        "immutableWarmup": "A1_IMMUTABLE_WARMUP",
         "internalPackaging": "A1_INTERNAL_PACKAGING",
-        "launchArgumentsJson": "A1_LAUNCH_ARGUMENTS_JSON",
         "launchProfile": "A1_LAUNCH_PROFILE",
         "nativePi": "A1_NATIVE_PI",
         "paneId": "A1_PANE_ID",
@@ -36,21 +36,22 @@
         "protocolVersion": "A1_PROTOCOL_VERSION",
         "releaseDigest": "A1_RELEASE_DIGEST",
         "releaseId": "A1_RELEASE_ID",
+        "releaseLayers": "A1_RELEASE_LAYERS",
         "releaseRoot": "A1_RELEASE_ROOT",
         "releaseRunnerLabel": "A1_RELEASE_RUNNER_LABEL",
         "runtimeDir": "A1_RUNTIME_DIR",
         "structuredFlowLimits": "A1_STRUCTURED_FLOW_LIMITS",
+        "startupTrace": "A1_STARTUP_TRACE",
         "terminalArgumentsJson": "A1_TERMINAL_ARGUMENTS_JSON",
         "terminalExecutable": "A1_TERMINAL_EXECUTABLE",
         "terminalSessionId": "A1_TERMINAL_SESSION_ID"
     },
     "state": {
-        "windowsControlDirectory": "A1",
+        "windowsControlDirectory": "a1",
         "unixControlDirectory": "a1",
         "developmentDirectory": "a1-development",
         "piAgentProfile": ".a1/agent",
-        "piVanillaProfile": ".pi/agent",
-        "piSandboxProfile": ".a1/sandbox"
+        "piVanillaProfile": ".pi/agent"
     },
     "endpoint": {
         "windowsPipeStem": "a1",
@@ -83,7 +84,11 @@
         "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"
+        "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",