@timurproko/a1 0.2.7-dev.794 → 0.2.7-dev.801

package/dist/app/session-shell/clipboard-diagnostics.js

@@ -39,7 +39,7 @@ export class ClipboardDiagnosticCapture {
         // Security: project only declared scalar fields. Never serialize the supplied event object or raw errors.
         this.#records.push({ source, phase: event.phase, atMs: scalar(event.atMs), request: event.request !== undefined && event.request < 0 ? -scalar(-event.request) : scalar(event.request), pending: scalar(event.pending), bytes: scalar(event.bytes), elapsedMs: scalar(event.elapsedMs),
             sourceUnits: scalar(event.sourceUnits), pendingBytes,
-            transport: ["native", "terminal", "provided", "injected"].includes(event.transport ?? "") ? event.transport : "none",
+            transport: ["native", "terminal", "platform", "provided", "injected"].includes(event.transport ?? "") ? event.transport : "none",
             outcome: ["ready", "failed", "canceled", "delivered", "submitted-unverified", "timed-out", "superseded"].includes(event.outcome ?? "") ? event.outcome : "none" });
         if (this.#records.length > 128)
             this.#records.shift();

package/dist/app/session-shell/response-copy-helper.js

@@ -1,5 +1,6 @@
 import { MAX_COPY_ROWS, MAX_COPY_SOURCE_UNITS, selectionCopyRowText } from "../../ui/components/index.js";
 import { COPY_CHUNK_UNITS, MAX_COPY_BYTES, MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
+const NATIVE_RETRY_DELAYS_MS = [20, 60];
 // Security: this isolated executor never inherits the UI terminal and never logs clipboard contents.
 let header;
 let fragments = [];
@@ -24,6 +25,14 @@ function nextOutput() {
     send({ kind: "data", text });
 }
 function send(message) { process.send?.(message); }
+function transientClipboardError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    const message = error instanceof Error ? error.message : String(error);
+    return /^(?:EAGAIN|EBUSY)$/iu.test(code) || /(?:busy|locked|contention|temporar|try again)/iu.test(message);
+}
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
 function finish(result, control) {
     if (finished)
         return;
@@ -97,13 +106,19 @@ async function receive(message) {
             return;
         }
         send({ kind: "phase", phase: "submitting", bytes });
-        try {
-            await native.setText(text);
-            finish({ outcome: "delivered" });
-        }
-        catch {
-            finish({ outcome: "failed", failure: "denied" });
+        for (let attempt = 0; attempt <= NATIVE_RETRY_DELAYS_MS.length; attempt++) {
+            try {
+                await native.setText(text);
+                finish({ outcome: "delivered" });
+                return;
+            }
+            catch (error) {
+                if (!transientClipboardError(error) || attempt === NATIVE_RETRY_DELAYS_MS.length)
+                    break;
+                await delay(NATIVE_RETRY_DELAYS_MS[attempt]);
+            }
         }
+        finish({ outcome: "failed", failure: "denied" });
         return;
     }
     else

package/dist/app/session-shell/response-copy-protocol.d.ts

@@ -19,7 +19,7 @@ export interface ResponseCopyEvent {
     readonly pending: number;
     readonly sourceUnits: number;
     readonly bytes?: number;
-    readonly transport?: "native" | "terminal" | "injected";
+    readonly transport?: "native" | "terminal" | "platform" | "injected";
     readonly outcome?: CopyOutcome;
 }
 /** One request per helper lifetime. Each source fragment is acknowledged before the next is sent. */

package/dist/app/session-shell/response-copy-transport.d.ts

@@ -7,7 +7,7 @@ export interface ResponseCopyJob {
     readonly stopped: Promise<void>;
     cancel(): void;
 }
-export type CopyPhaseObserver = (phase: "extracted" | "encoded" | "submitting", bytes: number, transport: "native" | "terminal" | "injected") => void;
+export type CopyPhaseObserver = (phase: "extracted" | "encoded" | "submitting", bytes: number, transport: "native" | "terminal" | "platform" | "injected") => void;
 export type ResponseCopyExecutor = (snapshot: SelectionCopySnapshot, phase: CopyPhaseObserver) => ResponseCopyJob;
 /** The production executor also holds a spare helper; the owner warms it at start and disposes it at shutdown unless the pool is shared. */
 export interface OwnedResponseCopyExecutor extends ResponseCopyExecutor {
@@ -22,17 +22,14 @@ export interface ResponseCopyTerminal {
 }
 /** Never substitute a remote host's native clipboard for the terminal user's clipboard. */
 export declare function responseCopyDestination(env: NodeJS.ProcessEnv): "native" | "terminal";
-/** Node documents synchronous POSIX TTY and Windows pipe writes; do not put clipboard traffic there. */
-export declare function hasAsyncClipboardOutput(platform?: NodeJS.Platform, stdout?: {
-    readonly isTTY?: boolean | undefined;
-    readonly fd?: number | undefined;
-}): boolean;
 /** Isolates preparation and native clipboard access; only the owner may submit terminal controls. */
 export declare function createResponseCopyExecutor(options?: {
     readonly terminal?: ResponseCopyTerminal;
     readonly destination?: "native" | "terminal";
     /** Explicit host seam: must be non-blocking and honor cancellation, or its unresolved lifetime is quarantined. */
     readonly writeText?: (text: string, signal: AbortSignal) => Promise<void>;
+    /** Platform/fault-test seam; production writes through the supported operating-system command. */
+    readonly platformWriteText?: (text: string, signal: AbortSignal) => Promise<boolean>;
     /** Package/fault-test seam: the production helper is always an emitted sibling. */
     readonly helper?: URL;
     /** Idle bound for the spare helper; production keeps the default. */

package/dist/app/session-shell/response-copy-transport.js

@@ -1,25 +1,58 @@
-import { fork } from "node:child_process";
-import { fstatSync } from "node:fs";
+import { execFile, fork } from "node:child_process";
 import { HelperPool } from "./helper-pool.js";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { COPY_CHUNK_UNITS, COPY_CLEANUP_MS, MAX_COPY_BYTES, MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
+const PLATFORM_WRITE_TIMEOUT_MS = 1_500;
 /** Never substitute a remote host's native clipboard for the terminal user's clipboard. */
 export function responseCopyDestination(env) {
-    return env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY || env.TMUX || env.STY || env.WSL_DISTRO_NAME
+    return env[PRODUCT_IDENTITY.environment.tabId] || env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY || env.TMUX || env.STY || env.WSL_DISTRO_NAME
         ? "terminal" : "native";
 }
-/** Node documents synchronous POSIX TTY and Windows pipe writes; do not put clipboard traffic there. */
-export function hasAsyncClipboardOutput(platform = process.platform, stdout = process.stdout) {
-    if (stdout.isTTY)
-        return platform === "win32";
-    if (platform === "win32")
-        return false;
-    try {
-        const stat = fstatSync(stdout.fd ?? -1);
-        return stat.isFIFO() || stat.isSocket();
-    }
-    catch {
-        return false;
+function platformClipboardCommands() {
+    if (process.platform === "win32")
+        return [{
+                command: "powershell.exe",
+                args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", "$value=[Console]::In.ReadToEnd(); Set-Clipboard -Value $value"],
+            }];
+    if (process.platform === "darwin")
+        return [{ command: "pbcopy", args: [] }];
+    return [
+        { command: "wl-copy", args: ["--type", "text/plain;charset=utf-8"] },
+        { command: "xclip", args: ["-selection", "clipboard", "-in"] },
+    ];
+}
+async function writePlatformClipboardText(text, signal) {
+    for (const route of platformClipboardCommands()) {
+        if (signal.aborted)
+            return false;
+        const delivered = await new Promise(resolve => {
+            let settled = false;
+            const done = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
+            const child = execFile(route.command, [...route.args], {
+                signal,
+                windowsHide: true,
+                timeout: PLATFORM_WRITE_TIMEOUT_MS,
+                killSignal: "SIGKILL",
+                maxBuffer: 1_024,
+            }, error => done(error === null));
+            child.once("error", () => done(false));
+            if (child.stdin === null) {
+                child.kill("SIGKILL");
+                done(false);
+                return;
+            }
+            child.stdin.once("error", () => { child.kill("SIGKILL"); done(false); });
+            child.stdin.end(text);
+        });
+        if (delivered)
+            return true;
     }
+    return false;
 }
 /** Isolates preparation and native clipboard access; only the owner may submit terminal controls. */
 export function createResponseCopyExecutor(options = {}) {
@@ -43,8 +76,18 @@ export function createResponseCopyExecutor(options = {}) {
             };
             let outcome = await execute(destination);
             // Concurrency: helper results settle only after exit; fallback cannot race an older native write.
-            if (!controller.signal.aborted && destination === "native" && outcome.result.failure === "unavailable" && options.terminal !== undefined) {
-                outcome = await execute("terminal");
+            if (!controller.signal.aborted && destination === "native" && outcome.result.outcome === "failed") {
+                const prepared = await execute("prepare");
+                if (prepared.result.outcome === "delivered" && prepared.text !== undefined) {
+                    phase("submitting", prepared.bytes ?? 0, "platform");
+                    const delivered = await (options.platformWriteText ?? writePlatformClipboardText)(prepared.text, controller.signal);
+                    outcome = { kind: "result", result: delivered ? { outcome: "delivered" } : { outcome: "failed", failure: "unavailable" } };
+                }
+                else
+                    outcome = { kind: "result", result: { outcome: "failed", failure: "transport" } };
+                if (!controller.signal.aborted && outcome.result.outcome === "failed" && options.terminal !== undefined) {
+                    outcome = await execute("terminal");
+                }
             }
             if (controller.signal.aborted)
                 return { outcome: "canceled" };

package/dist/app/session-shell/session-shell-root.js

@@ -438,6 +438,7 @@ export class OwnedUiSessionShellRoot {
             ? Math.max(0, dock.inputRows - 2)
             : 0;
         const copyableDockRows = [
+            ...dock.copyableMessageRows,
             ...Array.from({ length: promptCopyRows }, (_value, index) => ({
                 row: editorOffset + index + 1,
                 prompt: index === 0 ? "first" : "continuation",
@@ -620,7 +621,10 @@ export class OwnedUiSessionShellRoot {
     #renderDockLayout(width) {
         const queued = this.#customViewport ? [] : this.#renderQueued(width);
         const statusRows = this.#customViewport ? this.#status.renderDock(width) : this.#renderStatus(width);
-        const transientRows = [...queued, ...statusRows, ...this.#renderDockNotice(width)];
+        const noticeRows = this.#renderDockNotice(width);
+        const transientRows = [...queued, ...statusRows, ...noticeRows];
+        const messageStart = queued.length;
+        const copyableMessageRows = Array.from({ length: statusRows.length + noticeRows.length }, (_value, index) => ({ row: messageStart + index }));
         const aboveWidgets = this.#renderWidgets("aboveEditor", width);
         const input = this.#inputSurface.render(width);
         const body = this.usesDefaultInputSurface() ? this.editor.bodyGeometry?.() : undefined;
@@ -634,6 +638,7 @@ export class OwnedUiSessionShellRoot {
             editorOffset: inputOffset + (body?.rowOffset ?? 0),
             inputRows: body?.rowCount ?? input.length,
             footerRows: footer.length,
+            copyableMessageRows,
         };
     }
     #renderCopyAcknowledgement(width) {

package/dist/app/session-shell/session-shell.js

@@ -1,5 +1,5 @@
 import { ResponseCopyCoordinator } from "./response-copy-coordinator.js";
-import { createResponseCopyExecutor, hasAsyncClipboardOutput, responseCopyDestination } from "./response-copy-transport.js";
+import { createResponseCopyExecutor, responseCopyDestination } from "./response-copy-transport.js";
 import { MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
 import { PromptHistoryController } from "./prompt-history-controller.js";
 import { PRODUCT_TEXT } from "../../product-identity.js";
@@ -129,31 +129,24 @@ export class OwnedUiSessionPresenter {
         // throw releases them in reverse, so a shell that never finished constructing holds nothing.
         const constructed = [() => host.disconnect(this)];
         try {
-            const terminalCopy = terminal !== undefined || hasAsyncClipboardOutput();
             this.#responseCopy = this.#customViewport ? new ResponseCopyCoordinator({
                 execute: responseCopy?.execute ?? (this.#copyExecutor = createResponseCopyExecutor({
                     ...(sharedClipboard === undefined ? {} : { pool: sharedClipboard.copy }),
                     ...(terminal === undefined && clipboard === undefined ? {} : { destination: "terminal" }),
                     ...(clipboard?.writeText === undefined ? {} : { writeText: (text, signal) => clipboard.writeText(text, signal) }),
-                    ...(terminalCopy ? { terminal: { submit: async (control, signal) => {
-                                if (signal.aborted || this.#disposed || !this.#terminal.running)
-                                    throw new Error("Copy canceled");
-                                // Performance: never grow the real terminal's pending buffer with another clipboard payload.
-                                if (terminal === undefined && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
-                                    throw new Error("Clipboard terminal is busy");
-                                }
-                                this.#terminal.writeControl(control);
-                            } } } : {}),
+                    // Invariant: the owned host is the route contract. Resident and pseudoterminal children must not infer
+                    // clipboard reachability from Node's view of stdout, and inactive presenters are fenced here.
+                    terminal: { submit: async (control, signal) => {
+                            if (signal.aborted || this.#disposed || !this.#terminal.running || !this.#terminal.attached)
+                                throw new Error("Copy canceled");
+                            // Performance: never grow the real terminal's pending buffer with another clipboard payload.
+                            if (terminal === undefined && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
+                                throw new Error("Clipboard terminal is busy");
+                            }
+                            this.#terminal.writeControl(control);
+                        } },
                 })),
                 ...(responseCopy?.onEvent === undefined ? {} : { onEvent: responseCopy.onEvent }),
-                onFailure: result => {
-                    if (this.#disposed || !this.#terminal.running)
-                        return;
-                    this.root.appendWorkflowStatus(result.outcome === "timed-out" ? "Copy timed out; the clipboard did not respond."
-                        : result.failure === "size" ? "Selection exceeds this clipboard route's size limit."
-                            : "Could not copy the selection; the clipboard is unavailable.");
-                    this.#terminal.requestRender();
-                },
             }) : null;
             constructed.push(() => { this.#responseCopy?.dispose(); this.#copyExecutor?.dispose(); });
             const readClipboard = async (signal) => {

package/dist/app/session-shell/shell-host.js

@@ -1,6 +1,8 @@
 import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput } from "../../ui/components/mouse.js";
 import { readVisibleHyperlinks } from "../../ui/components/visible-hyperlinks.js";
 import { piCanvasBackgroundAnsi } from "../../integrations/pi/components/theme.js";
+import { residentFixtureControl } from "../../foundation/resident-tabs/fixture-control.js";
+import { residentProgressObserver } from "../../foundation/resident-tabs/progress-observation.js";
 import { DamageAwareTerminalAdapter, } from "../../integrations/pi/tui-runtime/damage-aware-terminal.js";
 import { PiTuiRuntimeAdapter } from "../../integrations/pi/tui-runtime/adapter.js";
 import { classifyPiTuiInput } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
@@ -47,6 +49,8 @@ export class OwnedUiTerminalHost {
         this.#customViewport = options.layout === "custom-viewport";
         this.#quitOutro = options.quitOutro;
         const input = options.input;
+        const fixtureControl = residentFixtureControl();
+        const progressObserver = residentProgressObserver();
         let damageTerminal;
         const surface = {
             render: width => this.#active?.render(width) ?? [],
@@ -72,6 +76,13 @@ export class OwnedUiTerminalHost {
                         inspectHyperlinks: readVisibleHyperlinks,
                         onResize: () => this.#active?.noteImmediatePresentation(),
                         onHyperlinkCleanupRequired: () => this.runtime?.requestRender(true),
+                        ...(fixtureControl === null ? {} : {
+                            allowWrite: () => !fixtureControl.stopped("child-render-write"),
+                            writeChunks: data => fixtureControl.fragmentChildWrite(data),
+                        }),
+                        ...(progressObserver === null ? {} : {
+                            onWrite: ({ bytes, fragments, transaction, frameId, cause }) => progressObserver.childRenderWrite(bytes, fragments, transaction, frameId, cause),
+                        }),
                     });
                     return damageTerminal;
                 },

package/dist/foundation/resident-tabs/fixture-control.d.ts

@@ -0,0 +1,7 @@
+export type ResidentFixtureStoppedStage = "child-render-write";
+export interface ResidentFixtureControlPort {
+    stopped(stage: ResidentFixtureStoppedStage): boolean;
+    fragmentChildWrite(data: string): readonly string[];
+}
+/** Returns the exact-artifact fixture control, or null for every ordinary resident child. */
+export declare function residentFixtureControl(environment?: NodeJS.ProcessEnv): ResidentFixtureControlPort | null;

package/dist/foundation/resident-tabs/fixture-control.js

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { residentProgressObserver } from "./progress-observation.js";
+/** Returns the exact-artifact fixture control, or null for every ordinary resident child. */
+export function residentFixtureControl(environment = process.env) {
+    const directory = environment[PRODUCT_IDENTITY.environment.residentFixtureControlDir];
+    if (environment === process.env)
+        delete process.env[PRODUCT_IDENTITY.environment.residentFixtureControlDir];
+    // Invariant: launch erases the bridge tab identity; the observer retains the observed one.
+    const tabId = residentProgressObserver(environment)?.tabId;
+    if (!directory || !tabId || !/^[a-z0-9-]{1,128}$/iu.test(tabId))
+        return null;
+    return {
+        stopped: stage => existsSync(join(directory, `${tabId}.${stage}.stop`)),
+        fragmentChildWrite: data => existsSync(join(directory, `${tabId}.child-render-fragments.enable`))
+            ? boundedFragments(data)
+            : [data],
+    };
+}
+function boundedFragments(data) {
+    const points = [...data];
+    if (points.length <= 1)
+        return [data];
+    if (points.length <= 16)
+        return points;
+    const fragments = points.slice(0, 8);
+    const middle = points.slice(8, -8);
+    const chunkSize = Math.max(1, Math.ceil(middle.length / 48));
+    for (let index = 0; index < middle.length; index += chunkSize) {
+        fragments.push(middle.slice(index, index + chunkSize).join(""));
+    }
+    fragments.push(...points.slice(-8));
+    return fragments;
+}

package/dist/foundation/resident-tabs/progress-observation.d.ts

@@ -0,0 +1,7 @@
+export interface ResidentProgressObserverPort {
+    readonly tabId: string;
+    engineDelivery(event: unknown): void;
+    childRenderWrite(bytes: number, fragments: number, transaction: "synchronized-output" | "ordinary", frameId?: number, renderCause?: string): void;
+}
+/** Returns the opt-in payload-free observer for a resident child, or null on ordinary launches. */
+export declare function residentProgressObserver(environment?: NodeJS.ProcessEnv): ResidentProgressObserverPort | null;

package/dist/foundation/resident-tabs/progress-observation.js

@@ -0,0 +1,119 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+const OBSERVATION_DIRECTORY_ENV = PRODUCT_IDENTITY.environment.residentProgressObservationDir;
+const OBSERVATION_RUN_ENV = PRODUCT_IDENTITY.environment.residentProgressRunId;
+const MAX_PENDING_BYTES = 256 * 1024;
+class ResidentProgressObserver {
+    #directory;
+    #runId;
+    #tabId;
+    #incarnation;
+    #processInstance;
+    #path;
+    #sequence = 0;
+    #engineSequence = 0;
+    #pendingBytes = 0;
+    #lost = 0;
+    #writing = Promise.resolve();
+    #failed = false;
+    get tabId() { return this.#tabId; }
+    constructor(directory, runId, tabId, incarnation) {
+        this.#directory = directory;
+        this.#runId = runId;
+        this.#tabId = tabId;
+        this.#incarnation = incarnation;
+        this.#processInstance = `${process.pid}-${randomUUID()}`;
+        this.#path = join(directory, `child-${this.#processInstance}.jsonl`);
+    }
+    engineDelivery(event) {
+        this.#engineSequence += 1;
+        this.#observe("engine-delivery", {
+            eventSequence: this.#engineSequence,
+            eventKind: eventKind(event),
+            count: 1,
+        });
+    }
+    childRenderWrite(bytes, fragments, transaction, frameId, renderCause) {
+        this.#observe("child-render-write", {
+            eventSequence: this.#engineSequence,
+            bytes,
+            count: 1,
+            fragmentCount: fragments,
+            transactionKind: transaction,
+            ...(frameId === undefined ? {} : { frameId }),
+            ...(renderCause === undefined ? {} : { renderCause }),
+        });
+    }
+    #observe(stage, fields) {
+        if (this.#failed)
+            return;
+        const lostBefore = this.#lost;
+        const record = {
+            schema: "a1-resident-progress-observation-v1",
+            runId: this.#runId,
+            role: "child",
+            stage,
+            pid: process.pid,
+            processInstance: this.#processInstance,
+            timestampUnixUs: Math.round((performance.timeOrigin + performance.now()) * 1_000),
+            // Rationale: timeOrigin is calibrated to the Unix epoch; retain a conservative cross-process error.
+            clockErrorUs: 1_000,
+            sequence: ++this.#sequence,
+            tabId: this.#tabId,
+            incarnation: this.#incarnation,
+            lostBefore,
+            ...fields,
+        };
+        const line = `${JSON.stringify(record)}\n`;
+        const length = Buffer.byteLength(line);
+        if (this.#pendingBytes + length > MAX_PENDING_BYTES) {
+            this.#lost = lostBefore + 1;
+            return;
+        }
+        this.#lost = 0;
+        this.#pendingBytes += length;
+        this.#writing = this.#writing.then(async () => {
+            await mkdir(this.#directory, { recursive: true });
+            await appendFile(this.#path, line, "utf8");
+        }).catch(() => {
+            this.#failed = true;
+        }).finally(() => {
+            this.#pendingBytes -= length;
+        });
+    }
+}
+let observer;
+/** Returns the opt-in payload-free observer for a resident child, or null on ordinary launches. */
+export function residentProgressObserver(environment = process.env) {
+    if (environment === process.env && observer !== undefined)
+        return observer;
+    const directory = environment[OBSERVATION_DIRECTORY_ENV];
+    const runId = environment[OBSERVATION_RUN_ENV];
+    const tabId = environment[PRODUCT_IDENTITY.environment.residentProgressTabId];
+    const incarnation = Number(environment[PRODUCT_IDENTITY.environment.residentProgressTabIncarnation]);
+    const value = directory && runId && runId.length <= 128 && tabId && Number.isSafeInteger(incarnation) && incarnation >= 0
+        ? new ResidentProgressObserver(directory, runId, tabId, incarnation)
+        : null;
+    if (environment === process.env) {
+        observer = value;
+        // Security: test evidence paths and tab identity are not child/tool configuration. Retain them only in
+        // this observer instance so extensions and spawned tools cannot append to the fixture trace.
+        for (const name of [
+            OBSERVATION_DIRECTORY_ENV,
+            OBSERVATION_RUN_ENV,
+            PRODUCT_IDENTITY.environment.residentProgressTabId,
+            PRODUCT_IDENTITY.environment.residentProgressTabIncarnation,
+        ])
+            delete process.env[name];
+    }
+    return value;
+}
+function eventKind(event) {
+    if (typeof event !== "object" || event === null)
+        return "unknown";
+    const value = event.type;
+    return typeof value === "string" && /^[a-z][a-z0-9_-]{0,63}$/iu.test(value) ? value : "unknown";
+}

package/dist/integrations/pi/engine/session-runtime.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { residentProgressObserver } from "../../../foundation/resident-tabs/progress-observation.js";
 import { observeCompactionProgress } from "./compaction-progress.js";
 import { createPiRuntimeIntegration } from "./runtime-integration.js";
 import { PiSessionCommandIntegration } from "./session-integration.js";
@@ -369,8 +370,10 @@ export class PiEngineRuntime {
             return;
         const generation = this.#sessionGeneration;
         this.#unsubscribe = session.subscribe(event => {
-            if (generation === this.#sessionGeneration && !this.#ports.disposed())
-                this.#ports.event(event);
+            if (generation !== this.#sessionGeneration || this.#ports.disposed())
+                return;
+            residentProgressObserver()?.engineDelivery(event);
+            this.#ports.event(event);
         });
     }
     /**

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

@@ -52,6 +52,17 @@ export interface DamageAwareTerminalOptions {
     };
     readonly onResize?: () => void;
     readonly onHyperlinkCleanupRequired?: () => void;
+    /** Exact-artifact fault controls evaluated before physical writes; absent in ordinary sessions. */
+    readonly allowWrite?: () => boolean;
+    readonly writeChunks?: (data: string) => readonly string[];
+    /** Optional payload-free observation after a terminal write returns. */
+    readonly onWrite?: (metadata: {
+        readonly bytes: number;
+        readonly fragments: number;
+        readonly transaction: "synchronized-output" | "ordinary";
+        readonly frameId?: number;
+        readonly cause?: string;
+    }) => void;
 }
 /**
  * A fail-closed adapter for one pinned Pi fullscreen write grammar. Semantic

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

@@ -166,7 +166,36 @@ export class DamageAwareTerminalAdapter {
         const forwarded = this.#canvasBackgroundAnsi === null
             ? output
             : paintTerminalCanvasFrame(output, this.#canvasBackgroundAnsi);
-        this.inner.write(forwarded);
+        let writeAllowed = true;
+        try {
+            writeAllowed = this.options.allowWrite?.() ?? true;
+        }
+        catch { /* Invariant: fixture controls fail open. */ }
+        if (!writeAllowed)
+            return;
+        let chunks = [forwarded];
+        try {
+            const controlled = this.options.writeChunks?.(forwarded);
+            if (controlled !== undefined && controlled.length > 0 && controlled.length <= 4_096
+                && controlled.join("") === forwarded)
+                chunks = controlled;
+        }
+        catch { /* Invariant: fixture controls fail open without corrupting the renderer write. */ }
+        for (const chunk of chunks)
+            this.inner.write(chunk);
+        try {
+            this.options.onWrite?.({
+                bytes: Buffer.byteLength(forwarded),
+                fragments: chunks.length,
+                transaction: forwarded.startsWith(BEGIN_SYNCHRONIZED_OUTPUT) && forwarded.endsWith(END_SYNCHRONIZED_OUTPUT)
+                    ? "synchronized-output" : "ordinary",
+                ...(armed === undefined ? {} : {
+                    frameId: armed.descriptor.frameId,
+                    cause: armed.descriptor.cause,
+                }),
+            });
+        }
+        catch { /* Invariant: observation never changes rendering or write completion. */ }
         if (epoch !== this.#epoch
             || (armed !== undefined && this.#lastConsumedFrameId !== armed.descriptor.frameId))
             return;

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

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:41:09.288Z",
+  "builtAt": "2026-10-19T06:24:29.067Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "a87eaaffcd986b624c8b044b756446cc1bdaf4334a1775b97820542fe34f9fb7",

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

@@ -9,11 +9,11 @@
   "architecture": "arm64",
   "target": "aarch64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:43:27.368Z",
+  "builtAt": "2026-10-19T06:27:25.061Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "af7b9fee2efa8478c728465031e73fb316b6b7012d11de0364130b0acd1b6e62",
-    "size": 5173904
+    "sha256": "54b4a6c6f4b8abf76afd0a65053dd9916653dcf7990639c716bdd0d0ee735ad2",
+    "size": 5710496
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:41:16.359Z",
+  "builtAt": "2026-10-19T06:24:37.379Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "783a65f0de287a1c02cd5429dbe97bc8633f4cc8a7b92e3e961180b9bdcff814",

package/dist/native/darwin-x64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:45:43.907Z",
+  "builtAt": "2026-10-19T06:30:00.884Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "1a5465ea12ecfe76d5f0c8fd5c11dee99597b4206a7e9ece01b37fc5c477c211",
-    "size": 5656912
+    "sha256": "c4c070744e7dd382532d11759533d5cc93acd53befd999e993b85ad17e848cd4",
+    "size": 6226880
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,7 +7,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:40:48.343Z",
+  "builtAt": "2026-10-19T06:24:11.933Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "118e5954e3864672bd8482ab7edf419cb27dcdf2533720316979b7f5cc5a53a5",

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

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-unknown-linux-gnu",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:43:45.076Z",
+  "builtAt": "2026-10-19T06:27:20.231Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "843b10ab29eddf859a74a97875ba646a90917d9ec78445474895bb64f6e0772a",
-    "size": 6353496
+    "sha256": "1e2d6d37ee740ee716aa67f5d37aaac6c193739eeae14ce19320fc8b34939d16",
+    "size": 6981672
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,10 +7,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:41:31.607Z",
+  "builtAt": "2026-10-19T06:24:34.859Z",
   "artifact": {
     "filename": "process-guardian.node",
-    "sha256": "6299956800f1ab62f2e5bb4a1e4d61dbd45ce70a7711cbb9aca8f23033bdbbaf",
+    "sha256": "24685c41544bb8e90fb5162f9ab9545cb698204530cf131644aaf6ee97159c6e",
     "size": 402432
   },
   "provenance": {

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

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-pc-windows-msvc",
   "capability": "supported",
-  "builtAt": "2026-10-18T08:44:54.428Z",
+  "builtAt": "2026-10-19T06:28:49.237Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "de82227898a90a6ec6bda0c8b503148388d3769ef4ab7f1176e56c8472b76232",
-    "size": 5617664
+    "sha256": "a4d34ff27229603c8f354607c2bff377506d34ac72f90886ffe6abea37fd2f88",
+    "size": 6212608
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/dist/product-identity.d.ts

@@ -1,10 +1,10 @@
-declare const ENVIRONMENT_KEYS: readonly ["clipboardDiagnostics", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "exitNoticePath", "paneId", "probeTrace", "processGuardianPath", "prFooterPreview", "profileHome", "runtimeDir", "sessionRuntimeId", "skipVersionCheck", "startupTrace", "suggestionDiagnostics", "tabEndpoint", "tabId", "tabToken", "tabsEndpoint", "terminalHostPath", "terminalSessionId"];
+declare const ENVIRONMENT_KEYS: readonly ["clipboardDiagnostics", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "exitNoticePath", "paneId", "probeTrace", "processGuardianPath", "prFooterPreview", "profileHome", "residentFixtureControlDir", "residentProgressObservationDir", "residentProgressRunId", "residentProgressTabId", "residentProgressTabIncarnation", "runtimeDir", "sessionRuntimeId", "skipVersionCheck", "startupTrace", "suggestionDiagnostics", "tabEndpoint", "tabId", "tabToken", "tabsEndpoint", "terminalHostPath", "terminalSessionId"];
 declare const FILESYSTEM_KEYS: readonly ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
 declare const STATE_KEYS: readonly ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "sessionRepositoryDirectory", "sessionWorktreeClaimDirectory"];
 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 EVIDENCE_KEYS: readonly ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "terminalTemporalSnapshotSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema", "startupTraceSchema", "dependencyLayerSchema", "dependencyLayerCertificationSchema", "runtimePayloadSchema"];
 declare const ARTIFACT_KEYS: readonly ["cliEntry", "supervisorEntry", "guardianEntry", "uiEntry", "terminalHostAddon", "terminalHostEntry", "nativeCrate", "processGuardianAddon", "releaseTarballStem", "diagnosticStem"];
 type StringRecord<Keys extends readonly string[]> = {
     readonly [Key in Keys[number]]: string;

package/dist/product-identity.js

@@ -1,14 +1,14 @@
 import rawIdentity from "./product-identity.json" with { type: "json" };
 const ENVIRONMENT_KEYS = [
     "clipboardDiagnostics", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "exitNoticePath",
-    "paneId", "probeTrace", "processGuardianPath", "prFooterPreview", "profileHome", "runtimeDir", "sessionRuntimeId", "skipVersionCheck", "startupTrace", "suggestionDiagnostics", "tabEndpoint", "tabId", "tabToken", "tabsEndpoint", "terminalHostPath", "terminalSessionId",
+    "paneId", "probeTrace", "processGuardianPath", "prFooterPreview", "profileHome", "residentFixtureControlDir", "residentProgressObservationDir", "residentProgressRunId", "residentProgressTabId", "residentProgressTabIncarnation", "runtimeDir", "sessionRuntimeId", "skipVersionCheck", "startupTrace", "suggestionDiagnostics", "tabEndpoint", "tabId", "tabToken", "tabsEndpoint", "terminalHostPath", "terminalSessionId",
 ];
 const FILESYSTEM_KEYS = ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
 const STATE_KEYS = ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "sessionRepositoryDirectory", "sessionWorktreeClaimDirectory"];
 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 EVIDENCE_KEYS = ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "terminalTemporalSnapshotSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema", "startupTraceSchema", "dependencyLayerSchema", "dependencyLayerCertificationSchema", "runtimePayloadSchema"];
 const ARTIFACT_KEYS = ["cliEntry", "supervisorEntry", "guardianEntry", "uiEntry", "terminalHostAddon", "terminalHostEntry", "nativeCrate", "processGuardianAddon", "releaseTarballStem", "diagnosticStem"];
 const ROOT_KEYS = ["schema", "displayName", "commandName", "packageName", "filesystem", "environment", "state", "endpoint", "manifest", "protocol", "evidence", "artifacts"];
 export function validateProductIdentity(value) {

package/dist/product-identity.json

@@ -23,6 +23,11 @@
         "processGuardianPath": "A1_PROCESS_GUARDIAN_PATH",
         "prFooterPreview": "A1_PR_FOOTER_PREVIEW",
         "profileHome": "A1_PROFILE_HOME",
+        "residentFixtureControlDir": "A1_RESIDENT_FIXTURE_CONTROL_DIR",
+        "residentProgressObservationDir": "A1_RESIDENT_PROGRESS_OBSERVATION_DIR",
+        "residentProgressRunId": "A1_RESIDENT_PROGRESS_RUN_ID",
+        "residentProgressTabId": "A1_RESIDENT_PROGRESS_TAB_ID",
+        "residentProgressTabIncarnation": "A1_RESIDENT_PROGRESS_TAB_INCARNATION",
         "runtimeDir": "A1_RUNTIME_DIR",
         "sessionRuntimeId": "A1_SESSION_RUNTIME_ID",
         "skipVersionCheck": "A1_SKIP_VERSION_CHECK",
@@ -70,6 +75,7 @@
         "nativeSpikeSchema": "a1-native-host-spike-evidence-v1",
         "terminalProvenanceSchema": "a1-terminal-host-provenance-v1",
         "terminalProofSchema": "a1-terminal-host-proof-v1",
+        "terminalTemporalSnapshotSchema": "a1-terminal-temporal-snapshot-v1",
         "stableReleaseSchema": "a1-stable-release-v1",
         "previewReleaseSchema": "a1-preview-release-v1",
         "releaseCertificationSchema": "a1-release-certification-v1",

package/docs/architecture/resident-tabs.md

@@ -223,13 +223,13 @@ The channels carry bounded generation-1 frames: a u32 little-endian length follo
   - The server sends `bridge.visibility{visible}`, so a hidden A1 throttles animation, and `bridge.rename`, so a strip rename sets the Pi session name.
   - The bridge is advisory. A missing or broken bridge degrades that tab to process-level status and never breaks the tab.
 - **Backpressure:**
-  - Each client connection has a reliable, bounded control lane and a **single-slot render lane**. A newer full current surface replaces an unsent one, so a client that drains never depends on a dropped intermediate revision.
-  - The server never blocks a holder, another client, or registry writes on a slow client.
+  - Each client connection has a reliable, bounded control lane and a **single-slot render lane**. A newer full current surface replaces an unsent one, so a client that drains never depends on a dropped intermediate revision. Structured surfaces are immutable `Arc` values while routed; encoding happens outside the routing mutex, decoded structured state is capped at 8 MiB, and a superseded holder socket cannot publish into a newer incarnation.
+  - The server never blocks a holder, another client, or registry writes on a slow client. Attach and holder hot loops yield after bounded frame, byte, and two-millisecond work quanta; completed outer writes, rather than offers, advance the presentation baseline.
   - Holders parse their PTY continuously, whether or not the tab is viewed, so a PTY is never throttled and a child never blocks on output.
 
 ### 6. Rendering, input, and outer-terminal fidelity
 
-- **Composition.** The attach client composes row 0 (the strip) and rows `1..N` (the viewed tab's surface). The tab PTY is sized `cols × (rows − 1)`. Composition reuses the proof's damage-aware composer and synchronized-output support, and falls back to a full repaint only when the layout changes.
+- **Composition.** The attach client composes row 0 (the strip) and rows `1..N` (the viewed tab's surface). The tab PTY is sized `cols × (rows − 1)`. Ghostty remains the sole child-terminal parser. Its stream parser reports synchronized-output begin/end/reset boundaries to the holder, which keeps mutable parser state separate from an immutable committed surface and never publishes an open transaction. A non-renewable 250 ms deadline publishes one typed recovery commit for a malformed transaction. The outer composer owns the only synchronized envelope and falls back to a full repaint only when identity, geometry generation, dimensions, or the structured base changes.
 - **Outer modes.** The client negotiates the outer terminal's modes: raw mode, alternate screen, bracketed paste, focus events, SGR mouse, kitty keyboard protocol where available, and synchronized output.
   - Child-requested modes are tracked in the holder's model. Input is re-encoded per child mode by libghostty-vt, which the proof already does.
   - Mouse rows are offset by the strip. Row 0 belongs to the client.
@@ -249,8 +249,8 @@ Direct `a1 solo` is the behavioural oracle for every viewed resident child. Only
 - **Typed effects.** The holder registers libghostty's clipboard-write callback, which normalizes OSC 52 and OSC 1337. A write from the viewed tab crosses as one bounded `terminal.effect`; attach writes one OSC 52 for it. A hidden tab's write is dropped, never replayed into a later view. Payloads are never logged.
 - **Modes and cursor.** Each surface carries the child's cursor cell and modes. Attach mirrors a cursor shape the child chose and resets it on detach or failure; a default block cursor is left to the outer terminal, as direct A1 leaves it.
 - **Shortcut projection.** The owned child projects the effective A1 keybindings plus `keybindings.json` into one assignment per tab action: a key an A1 action holds never becomes a tab shortcut, and the earlier declaration keeps a duplicated key. It publishes the projection as `bridge.shortcuts`; the server relays it as `tabs.shortcuts`, and attach dispatches and labels exactly that projection. `/hotkeys` renders the same projection. A shared case file is replayed by both resolvers.
-- **Committed presentation.** A requested view commits only with a topology that lists it and a complete target surface. Surfaces of the committed view apply in revision order, and revisions rise across holder incarnations. A retained re-offer is marked stale and parks for at most 120 ms while the fresh frame arrives. One compositor writes strip, body, overlay, and final cursor inside a single synchronized update, and refuses clear-only, blank, and cursor-less strip-only frames. Clock, hover, and title-animation damage repaints only the strip and restores the child's cursor.
-- **Evidence.** One interaction matrix drives three layers: an owned-shell oracle that records content-free observations, role fixtures that drive real server, holder, and attach processes with a certified parity child, and an exact-artifact harness, `verify-interaction-parity.mjs`, that compares the bytes the same child observes directly and through the built host on each platform. Observations carry digests and lengths, never content. Each platform's verdict stands alone.
+- **Committed presentation.** A requested view commits only with a topology that lists it and a complete target surface. Retained rows, palette/default colors, modes, and cursor are captured atomically; equal captures do not invent a revision. Surfaces of the committed view apply in revision order, and revisions rise across holder incarnations. A retained re-offer is marked stale from the request start and parks for at most 120 ms while the fresh frame arrives. One compositor writes strip, body, overlay, modes, and the viewport-clipped final cursor inside a single synchronized update. It erases suffix cells when a complete replacement row becomes shorter and restores the newest underlying surface when an overlay leaves. Clock, hover, and title-animation damage repaints only the strip and restores the child's cursor.
+- **Evidence.** One interaction matrix drives three layers: an owned-shell oracle that records content-free observations, role fixtures that drive real server, holder, and attach processes with a certified parity child, and exact-artifact harnesses. `verify-interaction-parity.mjs` compares the bytes the same child observes directly and through the built host. `verify-resident-parallel-progress.mjs` configures the real engine against a bounded loopback streaming provider and crosses all six first-response orders with all three initial views while every turn remains unfinished behind a completion barrier. At matching 100×29 child geometry, the same real-A1 prompt also runs through isolated direct-solo and resident profiles; the native Ghostty oracle compares a content-free digest of the intermediate fixture cells and their resolved styles together with normalized cursor and mode state. It advances only at parser-reported synchronized-output boundaries, rejects unbalanced transactions or disappearing intermediate cells, and excludes only the resident strip row rather than normalizing terminal semantics. Opt-in per-process JSONL observations identify engine delivery, completed child writes, PTY ingestion, distinct holder commits, attach receipt, and completed outer paint by run/tab/incarnation/process-instance/sequence without recording terminal or conversation content; queue loss, clock faults, duplicates, stale order, and missing stages fail the report. Named pressure variants keep all turns unfinished while exercising hidden progress, repeated switching, navigation input, rename overlays, tab-local resize, a bounded 35 ms attach-receipt delay, and a 900 ms paused outer sink; every tab must retain partial animation/progress before settlement and then present its final output. A detached/reconnect variant releases all three unfinished turns after terminating the authenticated attach and exact self-reported server identity; child writes, PTY ingestion, and holder commits must continue before a replacement server and attach present every retained final output. Separate isolated exact-artifact control markers stop one target tab at engine delivery, physical child rendering, holder commit, or outer paint; each control requires its upstream stages and the other tabs to advance, then removes the stop and requires final output from all three tabs. A fifth control fragments a real owned-shell synchronized write into at most 64 physical writes without changing its bytes, records the DEC private mode 2026 transaction classification, and requires ordinary complete holder commits without deadline recovery before final output. This characterizes the built PTY/ConPTY coherence path; a passing fragmented run does not by itself assign the historical stall to that path without a failing live reproduction. The marker path is absent in ordinary sessions and is scrubbed before extensions or tools inherit the child environment, while observation callbacks remain passive and cannot select a control. CI runs the vendored Ghostty VT tests and both exact-artifact harnesses on Windows x64, Linux x64, and macOS arm64. Each platform's verdict stands alone.
 
 ### 7. Status and attention come from the tab bridge
 
@@ -391,7 +391,9 @@ Every queue, buffer, file, and collection the resident roles keep has a declared
 | Bound | Cap | Enforced in | Test |
 |---|---|---|---|
 | Protocol frame | 2 MiB, nesting 64, 65,536 collection items | `native/terminal-host/src/protocol.rs`, `src/foundation/resident-tabs/protocol.ts` | `refuses_oversized_header_before_payload`; `refuses a frame header past 2 MiB before buffering its payload`, `refuses nesting past 64 levels`, `refuses a collection past 65,536 items` |
+| Structured complete surface | 512 × 256 geometry, 65,536 cells, 4,096 styles, 4,096 links, and 8 MiB decoded state | `protocol.rs` `StructuredSurface::validate` | `structured_surfaces_fail_closed_on_dimensions_indexes_and_control_injection` |
 | Input per message and holder input queue | 1 MiB | `protocol.rs`, `core/holder.rs`, `roles/holder.rs` | `over_capacity_paste_delivers_no_prefix` |
+| Holder PTY ingress and work round | 64 × 16 KiB lossless chunks; at most 256 KiB or 2 ms before yielding | `roles/holder.rs` | `verify-resident-parallel-progress.mjs` concurrent and stopped-stage cases |
 | Per-client control lane | 1,024 frames and 4 MiB | `roles/server.rs` | `control_lane_is_bounded_by_frames_and_bytes` |
 | Per-client render slot | one pending full surface; a newer one replaces it | `roles/server.rs` `Peer::offer_surface` | `stalled_client_gets_one_full_current_surface` |
 | Concurrent endpoint connections | 128 | `roles/server.rs` `admit_connection` | `connections_beyond_the_cap_are_refused_and_released_slots_are_reused` |
@@ -407,7 +409,9 @@ Every queue, buffer, file, and collection the resident roles keep has a declared
 | Session reconciliation read | 64 MiB | `src/foundation/resident-tabs/recovery.ts` | `refuses to scan a session past the 64 MiB reconciliation cap` |
 | Release-hold report | 32 uncertainty reasons; 1 MiB read | `roles/release_holds.rs`, `release-holds.ts`, `bounded-host-command.ts` | `uncertainty_reasons_stay_within_their_cap`; `fails a release-hold report that pushes past its byte cap without returning a prefix` |
 | Maintenance exchange | 5 s reads, 60 s stops, 4 MiB report | `roles/maintain.rs`, `maintenance.ts`, `bounded-host-command.ts` | `fails a maintenance report that pushes past its byte cap without returning a prefix`, `kills and rejects a command that outlives its deadline` |
-| Attach client | no outbound queue: input is written synchronously in chunks of at most 1 MiB; inbound frames at most 2 MiB; one coalesced wake | `roles/attach.rs` | `refuses_oversized_header_before_payload`, `over_capacity_paste_delivers_no_prefix` |
+| Attach server ingress | reader queue 64 frames/4 MiB; execution queue 8 frames/4 MiB; at most 64 KiB or 2 ms before yielding | `roles/attach.rs` | `verify-resident-parallel-progress.mjs` slow-receipt and switching cases |
+| Attach input | 1,024 parsed events; semantic input is emitted in at most 1 MiB chunks and target-bound while a view/create is pending | `roles/attach.rs` | `deferred_input_is_atomic_bounded_and_bound_to_the_requested_tab` |
+| Outer presentation writer | one replaceable complete desired state, 8 control/effect frames, and 4 MiB effect bytes | `roles/attach.rs` `OuterWriter` | `presentation_is_one_ordered_synchronized_write`; `verify-resident-parallel-progress.mjs` paused-sink case |
 | Doctor bundle | 25 MiB, oldest log generations dropped first | `src/foundation/resident-tabs/doctor.ts` | `drops the oldest log generations first to stay within its cap` |
 
 ### 13. Packaging and certification

package/docs/architecture/terminal-host-provenance.md

@@ -76,6 +76,6 @@ Unverified, mismatched, or unsigned/unattested artifacts are not eligible for co
 
 ## Release artifact
 
-`npm run build:terminal-host` (`scripts/development/build-terminal-host.mjs`) runs only on release and native validation runners. It builds the library once with `cargo build --release --locked --lib --features node-addon`, copies the cdylib as `terminal-host.node`, loads the addon in Node, and checks its `version()` report: protocol, generation, crate version, pinned `libghostty-vt` commit, and the absence of `fault-injection` and `resident-fixtures`. The macOS x64 cross build may use the recorded Mach-O architecture check when the arm64 runner cannot load the addon.
+`npm run build:terminal-host` (`scripts/development/build-terminal-host.mjs`) builds the library once with `cargo build --release --locked --lib --features node-addon`, copies the cdylib as `terminal-host.node`, loads the addon in Node, and checks its `version()` report: protocol, generation, crate version, pinned `libghostty-vt` commit, and the absence of `fault-injection` and `resident-fixtures`. Release and native validation runners invoke it with their pinned Zig toolchain. The normal developer `npm run build` invokes the same release-profile builder for the current platform; on Windows it links a manifest-verified terminal library exported by trusted CI and records the repository-pinned Zig producer version without invoking Zig on the workstation. The macOS x64 cross build may use the recorded Mach-O architecture check when the arm64 runner cannot load the addon.
 
 The generated `terminal-host.manifest.json` uses schema `a1-terminal-host-artifact-v2` and records `kind: "node-addon"`, Node-API 9, the addon's SHA-256 and size, the release-relative role-entry digest, the notices digest, target triple, Rust and Zig versions, and `Cargo.lock` digest. The role entry passes only the fixed role grammar and records `{ executable: process.execPath, entry, artifact: addonPath }` once in the addon; the explicit loaded artifact identity makes release-hold reporting independent of development environment propagation. Detached and WMI resident starts use the recorded Node-and-entry command and never resolve an A1-built executable. The publication `package` job refuses to pack unless every platform's process-guardian and terminal-host addons match their manifests, and A1 verifies the addon, entry, and notices before loading the host.

package/docs/architecture/toolchain.md

@@ -38,7 +38,9 @@ It contains no executable built from A1 sources, separate session-lock addon, br
 
 Source builds require Rust/Cargo 1.85 or newer; `rust-toolchain.toml` pins the exact version CI and publication install through `scripts/development/prepare-ci-rust.sh`, and rustup selects that version for Cargo commands inside the repository, installing it on first use. The Zig cache (`mlugg/setup-zig`, one entry per workflow and platform per run, bounded to 512 MiB) stays enabled: measured on 2026-10-16, a cold Zig build of `libghostty-vt` added about 40 to 60 seconds to a terminal-host test build (Linux 2m21s cold against 1m20s warm, Windows 2m05s against 1m26s), which the cache saves on every warm run.
 
-`npm run build` compiles `native/process-guardian` as the host platform's Node-API 9 addon, places `process-guardian.node` under `dist/native/<platform>-<architecture>/`, loads it to observe its version identity, and writes the v2 integrity manifest. Preview and stable candidate workflows build the addon on isolated Windows, Linux, and macOS arm64 runners, cross-compile the macOS x64 addon on the arm64 runner with `--target x86_64-apple-darwin`, and assemble all targets before packing. The same release runners compile TypeScript and run `npm run build:terminal-host`, which builds one Node-API 9 `terminal-host.node` containing the fixed roles and the session-writer lock. Its v2 manifest binds the addon, `dist/foundation/resident-tabs/host-entry.js`, and notices. The local `npm run build` does not build that addon because the Zig fetch for `libghostty-vt` is quarantined by workstation antivirus on Windows; local native iteration uses a verified terminal library downloaded from a CI lane (see [`terminal-host-provenance.md`](terminal-host-provenance.md) and [`resident-tabs.md`](resident-tabs.md)). Cross-compiled artifacts record a Mach-O architecture check when they cannot be loaded on the producing runner. Supported native code is always loaded by Node; an absent, incompatible, or unsupported addon fails before runtime startup rather than falling back to PID-only cleanup. The process-guardian addon inherits terminal handles but transports no terminal bytes. Its separate Node-hosted exit watcher restores terminal state after guardian failure, subject to the documented node-wide-kill gap. See [`process-guardian-provenance.md`](process-guardian-provenance.md).
+`npm run build` compiles `native/process-guardian` as the host platform's Node-API 9 addon, places `process-guardian.node` under `dist/native/<platform>-<architecture>/`, loads it to observe its version identity, and writes the v2 integrity manifest. It also builds the current platform's release-profile `terminal-host.node`, whose v2 manifest binds the addon, `dist/foundation/resident-tabs/host-entry.js`, and notices, so the ordinary `npm run build && ./scripts/dev` handoff exercises resident tabs without deployment. On Windows the normal build reuses a compatible ignored terminal-library cache or downloads the newest compatible library from the current branch or a successful CI run belonging to a pull request already merged into `develop`, then links it under the crate's manifest verification; it never silently invokes the quarantined Zig package fetch. An unavailable or mismatched prerequisite fails the build instead of leaving a nominally successful single-agent-only tree. The npm `prepare` lifecycle and validation preflight use the explicit core build because selected native lanes assemble and certify terminal hosts separately.
+
+Preview and stable candidate workflows build the addons on isolated Windows, Linux, and macOS arm64 runners, cross-compile the macOS x64 addons on the arm64 runner with `--target x86_64-apple-darwin`, and assemble all targets before packing. Those release runners retain their explicit `npm run build:terminal-host` step and pinned Zig input rather than consuming a workstation cache. Cross-compiled artifacts record a Mach-O architecture check when they cannot be loaded on the producing runner. Supported native code is always loaded by Node; an absent, incompatible, or unsupported addon fails before runtime startup rather than falling back to PID-only cleanup. The process-guardian addon inherits terminal handles but transports no terminal bytes. Its separate Node-hosted exit watcher restores terminal state after guardian failure, subject to the documented node-wide-kill gap. See [`process-guardian-provenance.md`](process-guardian-provenance.md), [`terminal-host-provenance.md`](terminal-host-provenance.md), and [`resident-tabs.md`](resident-tabs.md).
 
 ## Gates
 

package/docs/ci-release-runbook.md

@@ -193,7 +193,7 @@ validation; malformed, mixed, renamed, stale, or unavailable inputs fail closed.
 A legitimate generated baseline update remains outside the allowlist and follows the
 manually accepted mixed/code path.
 
-A new implementation-bound specification starts as OpenSpec-only artifacts in one normally named draft PR. Explicit approval to implement continues in that same worktree, branch, history, and PR; the plan does not merge first. Approved refinements reconcile planning before code. After implementation, add one to ten plain implementation-specific bullets under `## Acceptance` and mark the PR ready; the trusted `OpenSpec finalization` workflow conservatively synchronizes deltas, stages the dated archive plus conditional acceptance manifest, and commits them to the same branch, and exact-head CI validates that head. Auto-merge remains disabled: an authorized maintainer's manual merge accepts the listed scenarios and atomically integrates implementation, specs, and archive. No acceptance or archive follow-up PR is created. Closing an unmerged draft integrates nothing; cleanup still needs separate approval. See [delivery and archive handoff](openspec-archive-automation.md) for commands and legacy compatibility.
+A new implementation-bound specification starts as OpenSpec-only artifacts in one normally named draft PR. Explicit approval to implement continues in that same worktree, branch, history, and PR; the plan does not merge first. Approved refinements reconcile planning before code. After implementation, add one to ten plain implementation-specific bullets under `## Acceptance` and mark the PR ready; the trusted `OpenSpec finalization` workflow conservatively synchronizes deltas, stages the dated archive plus conditional acceptance manifest, and commits them to the same branch, and exact-head CI validates that head. Automation-owned auto-merge remains disabled: an authorized maintainer's direct merge, personal exact-head auto-merge arm, or explicit request for the active agent to expected-head squash-merge the currently eligible candidate accepts the listed scenarios and atomically integrates implementation, specs, and archive. No acceptance or archive follow-up PR is created. Closing an unmerged draft integrates nothing; cleanup still needs separate approval. See [delivery and archive handoff](openspec-archive-automation.md) for commands and legacy compatibility.
 
 ## Numbered development previews
 

package/docs/openspec-archive-automation.md

@@ -1,6 +1,6 @@
 # Atomic OpenSpec delivery and legacy archival
 
-New OpenSpec deliveries use one ordinary development pull request from draft planning through implementation, validation, acceptance, specification synchronization, and archival. An authorized maintainer chooses integration by manually merging the exact validated head or personally enabling GitHub native auto-merge for that unchanged head. Agents, Apps, bots, merge queue, and repository automation never arm or invoke implementation integration and never create a version-3 acceptance or archive follow-up PR.
+New OpenSpec deliveries use one ordinary development pull request from draft planning through implementation, validation, acceptance, specification synchronization, and archival. An authorized maintainer chooses integration by manually merging the exact validated head, personally enabling GitHub native auto-merge for that unchanged head, or explicitly asking the active agent to merge the identified currently eligible head. Agents never infer or independently choose integration; Apps, bots, merge queue, workflows, and repository automation receive no implementation authority, and no version-3 acceptance or archive follow-up PR is created.
 
 Unrelated standalone documentation remains separate: a non-draft unassociated PR changing only `openspec/**`, `docs/**`, and/or root `README.md` retains the existing CI-gated automatic route. A new active change, implementation association, malformed lifecycle data, or mixed path remains outside documentation-owned integration. Before finalization or without valid human provenance, any arm is disabled; a finalized version-3 human arm remains a separate maintainer-owned route.
 
@@ -14,9 +14,23 @@ Version-1 and version-2 deliveries and their existing comments, acceptance PRs,
 4. **Plain acceptance list:** before checking the final item, keep the body phase-free and add final `## Acceptance` with one to ten concise implementation-specific behavior-and-result bullets. Do not use checkboxes, generic review/CI/approval/archive statements, angle-bracket placeholders or HTML, URLs, mentions, or automated-test inventory.
 5. **Automatic readiness and finalization:** reconcile and push current `origin/develop`, run the [delivery body check](#delivery-body-check) on the intended final body, then check the final item. That checkbox update completes the agent-owned implementation job; agents never mark implementation PRs ready themselves. Trusted automation revalidates the exact fully complete version-3 task-list snapshot and all pre-finalization inputs, marks the PR ready, and then conservatively synchronizes all deltas, moves the active change into its dated archive, stages the conditional acceptance manifest, commits that to the same branch with the archive App identity, and writes the emitted paths into the body's implementation fence. It never checks tasks or infers completion. Running the [finalization command](#finalization-command) locally first is optional and yields the same bytes.
 6. **Validate:** one normal exact-head workflow validates the finalized head: implementation, synchronized specs, archive, manifest, tasks/evidence, exact PR-body list, and every selected product/governance scope before emitting the stable protected aggregate. A new commit or acceptance-list change re-finalizes automatically when needed and requires full renewed validation; no lifecycle body edit or second workflow run is required.
-7. **Maintainer integration accepts:** after reviewing the finalized candidate, an authorized human either manually merges the exact validated head after the stable protected aggregate succeeds or personally enables GitHub native auto-merge for that unchanged head so protected integration waits for the aggregate. That human action means the listed scenarios are accepted. Agents, Apps, bots, merge queue, automation-owned implementation arms, and documentation integration remain forbidden. A changed head, acceptance list, or finalization invalidates the earlier arm and requires the maintainer to choose again.
+7. **Maintainer integration accepts:** after reviewing the finalized candidate, an authorized human manually merges the exact validated head, personally enables GitHub native auto-merge for that unchanged head, or explicitly asks the active agent to merge that identified head while it is currently eligible. The agent route re-reads authoritative state, requires the exact finalized head and acceptance list, current `develop`, successful `Development validation required`, positive mergeability, and the maintainer's authenticated human `User`, then issues one protected squash merge with expected-head enforcement. It never waits, arms auto-merge, retries later, uses automation credentials or merge queue, or bypasses protection. Each route means the listed scenarios are accepted. A candidate change invalidates the decision and requires the maintainer to choose again.
 8. **Verify and clean:** trusted post-merge policy derives `Archived` and reports `accepted-and-archived` from committed bytes and immutable GitHub provenance without editing the accepted PR body. It publishes no lifecycle branch or PR. Shared exact-head remote cleanup may delete the unchanged topic ref; local cleanup remains separately ownership-controlled: the agent parks the worktree with `handoff` at step 7, and the next session's `sweep` removes it once the merge, archive, and remote-ref evidence verify (see [local cleanup](local-worktree-cleanup.md)).
 
+### Maintainer-requested agent merge
+
+The permission is one-shot and candidate-bound. A same-session instruction such as “merge it” is sufficient only when the conversation identifies one handed-off PR and head unambiguously; implementation approval, green CI, an earlier request, or a standing preference is not merge authority. If the PR is not currently eligible, report the blocker and stop. Do not poll, watch, arm native auto-merge, or retain the instruction for later.
+
+Immediately before mutation, refresh the PR and authenticated principal. Require an open non-draft same-repository PR into `develop`, the requested exact finalized head and acceptance list, `MERGEABLE`/`CLEAN` state, successful `Development validation required` for that head, and a human `User` with write, maintain, or admin repository permission. Then use the ordinary protected route with no `--admin` or `--auto`:
+
+```bash
+gh pr merge <pr> --repo <owner>/<repository> --squash --match-head-commit <exact-head-sha>
+```
+
+GitHub branch protection remains authoritative. A refusal, changed head, advanced target, stale finalization, failed or pending check, ambiguous identity, or unavailable read ends the attempt and needs a fresh maintainer request. After success, use the ordinary read-only accepted/archive verification and cleanup path.
+
+The policy PR introducing this route must integrate through the previously deployed maintainer-owned route. Only a later candidate may use a requested agent merge after this policy is present on `develop`.
+
 ### Complete-regression evidence ordering
 
 PR-attached Full regression is selected only for a repair that the trusted triage created from a failed Full regression: base policy verifies the immutable `openspec-ci` App author, generated candidate identity, and `regression-provenance.json`. Human-authored lookalikes, publishing or validation-authority changes, labels, Publish-only repairs, and successful-run persistent-overrun candidates retain bounded ordinary validation. Generated repair drafts run no Development test suites, including after implementation begins. Finish substantive implementation tasks, focused local evidence, pre-finalization observations, and known-gap disposition before checking the final Implementation item. The ready active head defers testing while trusted finalization publishes the candidate; the finalized head then receives all four native lanes as new full evidence, required by `Development validation required` alongside the existing gates.
@@ -153,7 +167,7 @@ node scripts/governance/check-delivery-body.mjs --body-file .artifacts/agent/pr-
 
 `--final` validates the body as if every Implementation item were checked, so it can run before the last marker changes. `--pr <n>` reads the current pull request body instead. A defect exits 1 and prints the same `draft-<code>` reason the finalization run would report. The check covers association, Implementation, layout, and Acceptance only; detailed tasks, evidence, and target state remain covered by the [finalization command](#finalization-command) inspection mode.
 
-The committed conditional manifest contains the same ordered text. Trusted policy validates membership but never checks or edits it and never claims that the scenarios passed. The authorized maintainer's manual merge or personal native auto-merge arm for the unchanged exact head is the acceptance decision; no acceptance comment, checkbox edit, review-approval requirement, JSON edit, acceptance PR, archive PR, or later command is needed.
+The committed conditional manifest contains the same ordered text. Trusted policy validates membership but never checks or edits it and never claims that the scenarios passed. The authorized maintainer's direct merge, personal native auto-merge arm, or explicit request for the active agent to merge the unchanged currently eligible exact head is the acceptance decision; no acceptance comment, checkbox edit, review-approval requirement, JSON edit, acceptance PR, archive PR, or later command is needed.
 
 If the body list changes, candidate validation reruns and compares it with the committed manifest. If the head changes, all prior exact-head CI is stale. If only the body changes to disagree with the manifest, integration remains blocked until the list and committed candidate agree again. No lifecycle body edit is needed after green CI.
 
@@ -214,7 +228,7 @@ Before a first finalization, canonical specs must still equal the selected targe
 
 ## Conditional acceptance and derived receipt
 
-`acceptance.md` truthfully says its verdict activates only when an authorized human manually merges the containing exact head after required current-head checks or personally arms native auto-merge for that unchanged head and GitHub integrates it after those checks. Its `openspec-delivery` block records stable pre-merge facts:
+`acceptance.md` truthfully says its verdict activates only when an authorized human directly merges the containing exact head after required current-head checks, explicitly asks the active agent to execute that protected exact-head merge while it is eligible, or personally arms native auto-merge for the unchanged head and GitHub integrates it after those checks. Its `openspec-delivery` block records stable pre-merge facts:
 
 - schema version, repository, change, and source PR;
 - archive and manifest paths and finalization date;
@@ -223,7 +237,7 @@ Before a first finalization, canonical specs must still equal the selected targe
 - archive, canonical-spec, task, and evidence digests; and
 - explicit known-gap dispositions.
 
-It does not predict source head, merge commit, merger, or merge time. The PR head contains the manifest, so required CI binds those bytes without a recursive self-hash. After merge, the shared reader combines the manifest with immutable GitHub source head, successful required run, authorized human actor and permission, integration route, merge commit/time, and `develop` ancestry. Direct manual integration requires no active automatic authority. Human-enabled native auto-merge additionally requires a matching final-head enable event and `auto_merge.enabled_by`, with no later candidate commit or disable event. Queue, App/Bot, automation-owned, stale, malformed, or differently authored authority remains invalid. A human enable followed by disable before a valid manual merge is an abandoned attempt, not contradictory provenance. That shared result is the durable version-3 receipt used by audit and cleanup.
+It does not predict source head, merge commit, merger, or merge time. The PR head contains the manifest, so required CI binds those bytes without a recursive self-hash. After merge, the shared reader combines the manifest with immutable GitHub source head, successful required run, authorized human actor and permission, integration route, merge commit/time, and `develop` ancestry. Direct integration, including an explicitly requested agent invocation through the maintainer's credential, requires no active automatic authority and retains the same authenticated-human merge provenance. Human-enabled native auto-merge additionally requires a matching final-head enable event and `auto_merge.enabled_by`, with no later candidate commit or disable event. Queue, App/Bot, automation-owned, stale, malformed, or differently authored authority remains invalid. A human enable followed by disable before a valid direct merge is an abandoned attempt, not contradictory provenance. That shared result is the durable version-3 receipt used by audit and cleanup.
 
 Unavailable, stale, automatic, unauthorized, conflicting, or contradictory provenance produces `invalid-provenance`/`blocked`, not acceptance. Post-merge code does not repair it by pushing `develop` or publishing another PR.
 
@@ -277,7 +291,7 @@ This bootstrap policy itself finishes under deployed version-2 authority. The fi
 - draft planning remaining unmerged;
 - explicit plan approval and same-PR implementation;
 - automated current-target finalization and exact-head CI;
-- authorized human integration, including manual merge and personally enabled exact-head native auto-merge, with plain acceptance scenarios;
+- authorized human integration, including direct merge, an explicit exact-head agent-merge request, and personally enabled exact-head native auto-merge, with plain acceptance scenarios;
 - integrated canonical specs/archive and no generated acceptance/archive PR;
 - read-only `accepted-and-archived` verification and exact-head branch cleanup;
 - stale head/body/base/arm, incomplete tasks/evidence, malformed manifest, and automated or unauthorized auto-merge refusal fixtures; and

package/docs/validation.md

@@ -126,7 +126,7 @@ Download these artifacts from the exact workflow run:
 
 For selected implementation candidates, record focused and pre-finalization full observations before finalization. Keep final head/run/selection identity in Actions and handoff rather than adding a post-success commit that invalidates that evidence. A successful selected PR run replaces an additional mandatory dispatch; standalone runs remain diagnostic, and numbered-package nightly recovery remains independent.
 
-Draft pull requests run no Development test suites. A ready version-3 PR whose body still identifies an active change defers testing and emits no protected aggregate while `OpenSpec finalization` publishes the candidate. A ready unassociated PR also fails closed when immutable base/head evidence shows that it introduces or restores active delivery content, or combines active-change edits with code or operational paths; it does not fall through to ordinary validation merely because its body fence is absent. Existing active-change documentation-only revisions and ordinary code PRs without active delivery paths retain their established routes. After finalization records the archive and acceptance manifest, the ordinary exact-head workflow runs selected product/governance lanes and `Finalized delivery validation` in parallel, then emits the stable protected `Development validation required` aggregate only when both authorities succeed. Green CI enables maintainer review and manual merge but does not claim human acceptance or merge automatically. The finalization fence update is the validation trigger, so no pre-finalization test run or later lifecycle body edit is required. Any subsequent eligible implementation commit changes the head and reruns applicable validation; any body change reruns readiness and finalized-record validation and must continue to match the committed manifest. Legacy acceptance-record-only PRs retain their separate trusted `Acceptance record validation` route. Queue availability remains explicitly unavailable inside a runner and is calculated from the Actions API during final run analysis rather than guessed.
+Draft pull requests run no Development test suites. A ready version-3 PR whose body still identifies an active change defers testing and emits no protected aggregate while `OpenSpec finalization` publishes the candidate. A ready unassociated PR also fails closed when immutable base/head evidence shows that it introduces or restores active delivery content, or combines active-change edits with code or operational paths; it does not fall through to ordinary validation merely because its body fence is absent. Existing active-change documentation-only revisions and ordinary code PRs without active delivery paths retain their established routes. After finalization records the archive and acceptance manifest, the ordinary exact-head workflow runs selected product/governance lanes and `Finalized delivery validation` in parallel, then emits the stable protected `Development validation required` aggregate only when both authorities succeed. Green CI enables maintainer review and an explicit integration decision but does not claim human acceptance or merge automatically. After green exact-head validation, the maintainer may directly merge, personally arm native auto-merge, or explicitly ask the active agent to perform one expected-head protected squash merge for that currently eligible candidate. The finalization fence update is the validation trigger, so no pre-finalization test run or later lifecycle body edit is required. Any subsequent eligible implementation commit changes the head and reruns applicable validation; any body change reruns readiness and finalized-record validation and must continue to match the committed manifest. Legacy acceptance-record-only PRs retain their separate trusted `Acceptance record validation` route. Queue availability remains explicitly unavailable inside a runner and is calculated from the Actions API during final run analysis rather than guessed.
 
 ## Rollback
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.2.7-dev.794",
+  "version": "0.2.7-dev.801",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",
@@ -23,7 +23,9 @@
   },
   "scripts": {
     "clean": "node scripts/clean.mjs",
-    "build": "node scripts/development/check-environment.mjs && npm run clean && tsc -p tsconfig.build.json && node scripts/release/generate-release-notes-resource.mjs && node scripts/pi/build-pi-settings-metadata.mjs && node scripts/pi/build-startup-public.mjs && node scripts/development/build-process-guardian.mjs && node scripts/release/generate-runtime-payload-inventory.mjs",
+    "build": "node scripts/development/check-environment.mjs && npm run build:managed && node scripts/development/prepare-local-terminal-host.mjs && node scripts/release/generate-runtime-payload-inventory.mjs",
+    "build:core": "node scripts/development/check-environment.mjs && npm run build:managed && node scripts/release/generate-runtime-payload-inventory.mjs",
+    "build:managed": "npm run clean && tsc -p tsconfig.build.json && node scripts/release/generate-release-notes-resource.mjs && node scripts/pi/build-pi-settings-metadata.mjs && node scripts/pi/build-startup-public.mjs && node scripts/development/build-process-guardian.mjs",
     "build:process-guardian": "node scripts/development/build-process-guardian.mjs",
     "build:terminal-host": "node scripts/development/build-terminal-host.mjs",
     "typecheck": "tsgo -p tsconfig.json --noEmit && tsgo -p tsconfig.bin.json",
@@ -51,6 +53,7 @@
     "test:full": "node scripts/release/run-validation-tier.mjs full-release",
     "test:release": "node scripts/release/run-release-gates.mjs",
     "test:terminal-host": "node scripts/development/run-terminal-host-probe.mjs",
+    "test:resident-parallel-progress": "node scripts/development/verify-resident-parallel-progress.mjs",
     "test:resident-chaos": "node scripts/development/run-resident-chaos.mjs --build",
     "test:pi-engine-conformance": "vitest run test/integrations/pi/engine/conformance.test.ts test/integrations/pi/engine/runtime-integration.test.ts test/integrations/pi/engine/session-integration.test.ts",
     "report:pi-engine-conformance": "npm run build --silent && node scripts/pi/run-pi-engine-conformance.mjs",
@@ -65,7 +68,7 @@
     "start:pi": "npm run build && node scripts/development/dev-launch.mjs pi",
     "prepack": "node scripts/release/validate-packaged-release-note.mjs && node scripts/release/prepack-gate.mjs",
     "prepublishOnly": "npm run test:release",
-    "prepare": "npm run build",
+    "prepare": "npm run build:core",
     "typecheck:bin": "tsgo -p tsconfig.bin.json"
   },
   "dependencies": {