@timurproko/a1 0.1.8-dev.226 → 0.1.8-dev.259

package/dist/features/owned-ui/session-fork-prompt.js

@@ -0,0 +1,34 @@
+import { createInterface } from "node:readline";
+/** Pre-resource, line-mode confirmation matching Pi's cross-project CLI fork decision. */
+export function createConsoleSessionForkPrompt(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    return async ({ sourceCwd }) => {
+        output.write(`Session found in different project: ${sourceCwd}\n`);
+        const wasFlowing = input.readableFlowing;
+        const readline = createInterface({ input, output });
+        try {
+            return await new Promise((resolve, reject) => {
+                const finish = (accepted) => { cleanup(); resolve(accepted); };
+                const cancel = () => finish(false);
+                const fail = (error) => { cleanup(); reject(error); };
+                const cleanup = () => {
+                    readline.off("close", cancel);
+                    readline.off("SIGINT", cancel);
+                    input.off("error", fail);
+                };
+                readline.once("close", cancel);
+                readline.once("SIGINT", cancel);
+                input.once("error", fail);
+                readline.question("Fork this session into current directory? [y/N] ", answer => {
+                    finish(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+                });
+            });
+        }
+        finally {
+            readline.close();
+            if (wasFlowing !== true)
+                input.pause();
+        }
+    };
+}

package/dist/foundation/launch-guardian/main.d.ts

@@ -1,4 +1,5 @@
 import type { LaunchInstanceStopIntent, LaunchProfileId, SupervisorCommand } from "../lifecycle/index.js";
+import { type SessionSelection } from "../lifecycle/index.js";
 import { type NativeProcessInspector, type ProcessContainment } from "../process-containment/index.js";
 interface GuardianControl {
     connect(endpoint: string, timeoutMs?: number): Promise<unknown>;
@@ -19,6 +20,7 @@ export interface LaunchGuardianOptions {
     readonly profileId: LaunchProfileId;
     readonly releaseRoot: string;
     readonly uiEntry: string;
+    readonly sessionSelection?: SessionSelection;
     readonly environment?: NodeJS.ProcessEnv;
     readonly cwd?: string;
     readonly helperPath?: string;

package/dist/foundation/launch-guardian/main.js

@@ -1,13 +1,16 @@
 import { randomUUID } from "node:crypto";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { resolve } from "node:path";
-import { assertLaunchProfileId } from "../lifecycle/index.js";
-import { closeVerifiedContainment, LinuxNativeProcessInspector, NativeGuardianContainment, resolveProcessGuardianPath, verifyProcessGuardianArtifact, WindowsNativeProcessInspector, } from "../process-containment/index.js";
+import { assertLaunchProfileId, sessionSelectionArguments } from "../lifecycle/index.js";
+import { closeVerifiedContainment, DarwinNativeProcessInspector, LinuxNativeProcessInspector, NativeGuardianContainment, resolveProcessGuardianPath, verifyProcessGuardianArtifact, WindowsNativeProcessInspector, } from "../process-containment/index.js";
 import { SupervisorClient } from "../protocol/index.js";
 import { resolveCohortEndpoint, resolveProductPaths } from "../supervision/index.js";
 import { markStartupPhase } from "../startup/index.js";
 export async function runLaunchGuardian(options) {
     assertLaunchProfileId(options.profileId);
+    const sessionArgs = sessionSelectionArguments(options.sessionSelection);
+    if (sessionArgs.length > 0 && options.profileId !== "a1")
+        throw new Error("session selection requires the normal A1 profile");
     const environment = { ...(options.environment ?? process.env) };
     const paths = resolveProductPaths(environment);
     const instanceId = randomUUID();
@@ -40,7 +43,7 @@ export async function runLaunchGuardian(options) {
         });
         let handle;
         try {
-            handle = await containment.spawn(process.execPath, [options.uiEntry], {
+            handle = await containment.spawn(process.execPath, [options.uiEntry, ...sessionArgs], {
                 cwd: options.cwd ?? process.cwd(),
                 environment: environmentEntries(environment),
                 ...(environment.TERM ? { terminalType: environment.TERM } : {}),
@@ -104,6 +107,8 @@ function platformInspector(helperPath) {
         return new WindowsNativeProcessInspector(helperPath);
     if (process.platform === "linux")
         return new LinuxNativeProcessInspector();
+    if (process.platform === "darwin")
+        return new DarwinNativeProcessInspector(helperPath);
     throw diagnosticError(`launch-instance process containment is unsupported on ${process.platform}`, "CONTAINMENT_UNSUPPORTED");
 }
 function stopRequests(client, instanceId) {

package/dist/foundation/lifecycle/index.d.ts

@@ -2,3 +2,5 @@ export * from "./commands.js";
 export * from "./launch-instance.js";
 export * from "./model.js";
 export * from "./paths.js";
+export * from "./session-selection.js";
+export * from "./supervisor-startup.js";

package/dist/foundation/lifecycle/index.js

@@ -2,3 +2,5 @@ export * from "./commands.js";
 export * from "./launch-instance.js";
 export * from "./model.js";
 export * from "./paths.js";
+export * from "./session-selection.js";
+export * from "./supervisor-startup.js";

package/dist/foundation/lifecycle/paths.d.ts

@@ -8,6 +8,8 @@ export interface ProductPaths {
     /** The metadata written by releases that predate cohort-scoped identity. */
     readonly endpointMetadataPath: string;
     readonly endpointsDir: string;
+    /** A short, A1-managed socket directory when the host imposes a small Unix-path limit. */
+    readonly endpointDirectory?: string | null;
     readonly supervisorLogPath: string;
 }
 /** Where one cohort listens, and where it records that it is listening. */

package/dist/foundation/lifecycle/paths.js

@@ -19,7 +19,7 @@ export function resolveCohortEndpoint(paths, releaseId, environment = process.en
     const token = createHash("sha256").update(releaseId).digest("hex").slice(0, 16);
     const endpoint = hostPlatform === "win32"
         ? `${paths.endpoint}-${token}`
-        : path.join(paths.runtimeDir, `${token}-${PRODUCT_IDENTITY.endpoint.unixSocketFilename}`);
+        : path.join(paths.endpointDirectory ?? paths.runtimeDir, `${token}-${PRODUCT_IDENTITY.endpoint.unixSocketFilename}`);
     return { endpoint, endpointMetadataPath: path.join(paths.endpointsDir, `${token}.json`) };
 }
 export function resolveProductPaths(environment = process.env, hostPlatform = platform(), fallbackHome = homedir()) {
@@ -46,10 +46,16 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
                 ? path.join(environment.XDG_RUNTIME_DIR, PRODUCT_IDENTITY.state.unixControlDirectory)
                 : path.join(dataDir, "runtime")));
     const namespace = createHash("sha256").update(runtimeDir.toLowerCase()).digest("hex").slice(0, 20);
+    // Platform: Darwin limits Unix-domain socket paths to roughly 104 bytes. Runtime roots
+    // under /var/folders can exceed that before the cohort suffix is added, so only socket
+    // files use a short owned namespace while metadata remains under the selected runtime.
+    const endpointDirectory = !endpointOverride && hostPlatform === "darwin"
+        ? posix.join("/tmp", `${PRODUCT_IDENTITY.state.unixControlDirectory}-${namespace}`)
+        : null;
     const endpoint = endpointOverride
         ?? (windows
             ? `\\\\.\\pipe\\${PRODUCT_IDENTITY.endpoint.windowsPipeStem}-${namespace}`
-            : path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.unixSocketFilename));
+            : path.join(endpointDirectory ?? runtimeDir, PRODUCT_IDENTITY.endpoint.unixSocketFilename));
     return {
         configDir,
         dataDir,
@@ -58,6 +64,7 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
         endpoint,
         endpointMetadataPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.metadataFilename),
         endpointsDir: path.join(runtimeDir, "endpoints"),
+        endpointDirectory,
         supervisorLogPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.supervisorLogFilename),
     };
 }

package/dist/foundation/lifecycle/session-selection.d.ts

@@ -0,0 +1,9 @@
+/** Invocation-scoped selection; never inferred from a parent's active-session environment. */
+export interface SessionSelection {
+    readonly target: string;
+    readonly sessionDir?: string;
+}
+/** Shared public/internal grammar, deliberately not arbitrary Pi argument passthrough. */
+export declare function parseSessionSelection(arguments_: readonly string[]): SessionSelection | undefined;
+/** Encode only validated values into separate argv entries; no shell quoting or evaluation. */
+export declare function sessionSelectionArguments(selection?: SessionSelection): string[];

package/dist/foundation/lifecycle/session-selection.js

@@ -0,0 +1,39 @@
+/** Shared public/internal grammar, deliberately not arbitrary Pi argument passthrough. */
+export function parseSessionSelection(arguments_) {
+    if (arguments_.length === 0)
+        return undefined;
+    let target;
+    let sessionDir;
+    for (let index = 0; index < arguments_.length; index += 2) {
+        const option = arguments_[index];
+        if (option !== "--session" && option !== "--session-dir")
+            throw new Error("expected --session <path|id> with optional --session-dir <dir>");
+        const value = arguments_[index + 1];
+        if (value === undefined || value.startsWith("-") || !validValue(value))
+            throw new Error(`${option} requires a nonempty value`);
+        if (option === "--session") {
+            if (target !== undefined)
+                throw new Error("--session may occur only once");
+            target = value;
+        }
+        else {
+            if (sessionDir !== undefined)
+                throw new Error("--session-dir may occur only once");
+            sessionDir = value;
+        }
+    }
+    if (target === undefined)
+        throw new Error("--session-dir requires --session <path|id>");
+    return Object.freeze({ target, ...(sessionDir === undefined ? {} : { sessionDir }) });
+}
+/** Encode only validated values into separate argv entries; no shell quoting or evaluation. */
+export function sessionSelectionArguments(selection) {
+    if (selection === undefined)
+        return [];
+    const args = [...(selection.sessionDir === undefined ? [] : ["--session-dir", selection.sessionDir]), "--session", selection.target];
+    parseSessionSelection(args);
+    return args;
+}
+function validValue(value) {
+    return value.trim().length > 0 && value.length <= 32_768 && !/[\u0000\r\n]/.test(value);
+}

package/dist/foundation/lifecycle/supervisor-startup.d.ts

@@ -0,0 +1,30 @@
+declare const STARTUP_SCHEMA = "a1-supervisor-startup-v1";
+export interface SupervisorStartupAttemptIdentity {
+    readonly attemptId: string;
+    readonly releaseId: string;
+    readonly resultPath: string;
+}
+export type SupervisorStartupResult = {
+    readonly schema: typeof STARTUP_SCHEMA;
+    readonly attemptId: string;
+    readonly releaseId: string;
+    readonly outcome: "ready";
+    readonly pid: number;
+} | {
+    readonly schema: typeof STARTUP_SCHEMA;
+    readonly attemptId: string;
+    readonly releaseId: string;
+    readonly outcome: "failure";
+    readonly stage: string;
+    readonly code: string | null;
+    readonly message: string;
+};
+/** Create one unguessable startup result authority under the protected runtime root. */
+export declare function createSupervisorStartupAttempt(runtimeDir: string, releaseId: string): Promise<SupervisorStartupAttemptIdentity>;
+export declare function supervisorStartupResultPath(runtimeDir: string, attemptId: string): string;
+/** Atomically publish the bounded result for one detached supervisor startup attempt. */
+export declare function publishSupervisorStartupResult(path: string, result: SupervisorStartupResult): Promise<void>;
+export declare function readSupervisorStartupResult(path: string, attemptId: string, releaseId: string): Promise<SupervisorStartupResult | null>;
+export declare function supervisorStartupFailure(error: unknown, attemptId: string, releaseId: string, stage: string): SupervisorStartupResult;
+export declare function supervisorStartupReady(attemptId: string, releaseId: string): SupervisorStartupResult;
+export {};

package/dist/foundation/lifecycle/supervisor-startup.js

@@ -0,0 +1,106 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const STARTUP_SCHEMA = "a1-supervisor-startup-v1";
+const MAX_RESULT_BYTES = 8 * 1024;
+const MAX_MESSAGE_LENGTH = 1_024;
+const MAX_RETAINED_RESULTS = 16;
+const MAX_RESULT_AGE_MS = 7 * 24 * 60 * 60 * 1_000;
+const ATTEMPT_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+/** Create one unguessable startup result authority under the protected runtime root. */
+export async function createSupervisorStartupAttempt(runtimeDir, releaseId) {
+    const attemptId = randomUUID();
+    const directory = resolve(runtimeDir, "supervisor-startup");
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await pruneSupervisorStartupResults(directory);
+    return { attemptId, releaseId, resultPath: supervisorStartupResultPath(runtimeDir, attemptId) };
+}
+export function supervisorStartupResultPath(runtimeDir, attemptId) {
+    if (!ATTEMPT_PATTERN.test(attemptId))
+        throw new TypeError("supervisor startup attempt identity is invalid");
+    return resolve(runtimeDir, "supervisor-startup", `${attemptId}.json`);
+}
+/** Atomically publish the bounded result for one detached supervisor startup attempt. */
+export async function publishSupervisorStartupResult(path, result) {
+    validateSupervisorStartupResult(result, result.attemptId, result.releaseId);
+    const body = `${JSON.stringify(result)}\n`;
+    if (Buffer.byteLength(body) > MAX_RESULT_BYTES)
+        throw new Error("supervisor startup result exceeds its size bound");
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, body, { encoding: "utf8", mode: 0o600 });
+    await rename(temporary, path);
+}
+export async function readSupervisorStartupResult(path, attemptId, releaseId) {
+    let metadata;
+    try {
+        metadata = await stat(path);
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT"))
+            return null;
+        throw error;
+    }
+    if (!metadata.isFile() || metadata.size > MAX_RESULT_BYTES)
+        throw new Error("supervisor startup result is invalid or oversized");
+    const value = JSON.parse(await readFile(path, "utf8"));
+    return validateSupervisorStartupResult(value, attemptId, releaseId);
+}
+export function supervisorStartupFailure(error, attemptId, releaseId, stage) {
+    const source = error instanceof Error ? error : new Error(String(error));
+    return {
+        schema: STARTUP_SCHEMA,
+        attemptId,
+        releaseId,
+        outcome: "failure",
+        stage: boundedToken(stage, "unknown"),
+        code: "code" in source && typeof source.code === "string" ? boundedToken(source.code, "UNKNOWN") : null,
+        message: sanitizeMessage(source.message),
+    };
+}
+export function supervisorStartupReady(attemptId, releaseId) {
+    return { schema: STARTUP_SCHEMA, attemptId, releaseId, outcome: "ready", pid: process.pid };
+}
+async function pruneSupervisorStartupResults(directory) {
+    const now = Date.now();
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = (await Promise.all(entries.filter(entry => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
+        const path = resolve(directory, entry.name);
+        const metadata = await stat(path).catch(() => null);
+        return metadata ? { path, modified: metadata.mtimeMs } : null;
+    }))).filter((file) => file !== null);
+    files.sort((left, right) => right.modified - left.modified);
+    await Promise.all(files.flatMap((file, index) => index >= MAX_RETAINED_RESULTS - 1 || now - file.modified > MAX_RESULT_AGE_MS
+        ? [rm(file.path, { force: true })]
+        : []));
+}
+function validateSupervisorStartupResult(value, attemptId, releaseId) {
+    if (!value || typeof value !== "object")
+        throw new Error("supervisor startup result is malformed");
+    const result = value;
+    if (result.schema !== STARTUP_SCHEMA || result.attemptId !== attemptId || result.releaseId !== releaseId) {
+        throw new Error("supervisor startup result does not match the selected attempt and release");
+    }
+    if (result.outcome === "ready" && Number.isSafeInteger(result.pid) && Number(result.pid) > 0)
+        return result;
+    if (result.outcome === "failure" && typeof result.stage === "string" && result.stage.length > 0 && result.stage.length <= 128
+        && (result.code === null || typeof result.code === "string") && typeof result.message === "string" && result.message.length <= MAX_MESSAGE_LENGTH) {
+        return result;
+    }
+    throw new Error("supervisor startup result is malformed");
+}
+function sanitizeMessage(message) {
+    let value = message.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/:\/\/[^\s/@:]+:[^\s/@]+@/g, "://<redacted>@");
+    for (const [name, secret] of Object.entries(process.env)) {
+        if (!secret || secret.length < 4 || !/(?:TOKEN|SECRET|PASSWORD|COOKIE|CREDENTIAL|AUTH)/i.test(name))
+            continue;
+        value = value.split(secret).join("<redacted>");
+    }
+    return value.trim().slice(0, MAX_MESSAGE_LENGTH) || "supervisor startup failed";
+}
+function boundedToken(value, fallback) {
+    const normalized = value.replace(/[^A-Za-z0-9_.:-]/g, "-").slice(0, 128);
+    return normalized || fallback;
+}
+function isNodeError(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}

package/dist/foundation/process-containment/darwin-process-inspector.d.ts

@@ -0,0 +1,5 @@
+import { WindowsNativeProcessInspector, type InspectorCommandRunner } from "./windows-process-inspector.js";
+/** Verifies Darwin process identity through the bounded native guardian inspection command. */
+export declare class DarwinNativeProcessInspector extends WindowsNativeProcessInspector {
+    constructor(helperPath: string, runner?: InspectorCommandRunner);
+}

package/dist/foundation/process-containment/darwin-process-inspector.js

@@ -0,0 +1,7 @@
+import { WindowsNativeProcessInspector } from "./windows-process-inspector.js";
+/** Verifies Darwin process identity through the bounded native guardian inspection command. */
+export class DarwinNativeProcessInspector extends WindowsNativeProcessInspector {
+    constructor(helperPath, runner) {
+        super(helperPath, runner, "darwin-proc-start:");
+    }
+}

package/dist/foundation/process-containment/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./artifact.js";
 export * from "./contracts.js";
+export * from "./darwin-process-inspector.js";
 export * from "./linux-process-inspector.js";
 export * from "./native-guardian-containment.js";
 export * from "./windows-process-inspector.js";

package/dist/foundation/process-containment/index.js

@@ -1,5 +1,6 @@
 export * from "./artifact.js";
 export * from "./contracts.js";
+export * from "./darwin-process-inspector.js";
 export * from "./linux-process-inspector.js";
 export * from "./native-guardian-containment.js";
 export * from "./windows-process-inspector.js";

package/dist/foundation/process-containment/windows-process-inspector.d.ts

@@ -12,7 +12,8 @@ export interface InspectorCommandRunner {
 export declare class WindowsNativeProcessInspector implements NativeProcessInspector {
     readonly helperPath: string;
     private readonly runner;
-    constructor(helperPath: string, runner?: InspectorCommandRunner);
+    private readonly identityPrefix;
+    constructor(helperPath: string, runner?: InspectorCommandRunner, identityPrefix?: string);
     observe(pid: number): Promise<NativeProcessIdentity | null>;
     matches(identity: NativeProcessIdentity): Promise<boolean>;
 }

package/dist/foundation/process-containment/windows-process-inspector.js

@@ -3,9 +3,11 @@ import { execFile } from "node:child_process";
 export class WindowsNativeProcessInspector {
     helperPath;
     runner;
-    constructor(helperPath, runner = defaultRunner) {
+    identityPrefix;
+    constructor(helperPath, runner = defaultRunner, identityPrefix = "windows-filetime:") {
         this.helperPath = helperPath;
         this.runner = runner;
+        this.identityPrefix = identityPrefix;
         if (!helperPath || helperPath.includes("\0"))
             throw new TypeError("process guardian helper path is invalid");
     }
@@ -26,7 +28,7 @@ export class WindowsNativeProcessInspector {
         catch {
             throw Object.assign(new Error("process guardian returned malformed identity data"), { code: "PROCESS_INSPECTION_INVALID" });
         }
-        if (!isIdentity(value) || value.pid !== pid || !value.startIdentity.startsWith("windows-filetime:")) {
+        if (!isIdentity(value) || value.pid !== pid || !value.startIdentity.startsWith(this.identityPrefix)) {
             throw Object.assign(new Error("process guardian returned mismatched identity data"), { code: "PROCESS_INSPECTION_INVALID" });
         }
         return value;

package/dist/foundation/release/bootstrap.d.ts

@@ -1,6 +1,6 @@
 import { type OwnershipProbe } from "./cohort-selection.js";
 import { type SupervisorEndpointMetadata } from "./cohort-state.js";
-import { resolveProductPaths, type LaunchProfileId } from "../lifecycle/index.js";
+import { resolveProductPaths, type SessionSelection, type LaunchProfileId, type SupervisorStartupAttemptIdentity } from "../lifecycle/index.js";
 import { cleanupProvenIdleOwner } from "./process-cleanup.js";
 import { type MaterializedRelease, type VerifyMaterializedReleaseOptions } from "./release-store.js";
 export interface BootstrapOptions {
@@ -8,6 +8,7 @@ export interface BootstrapOptions {
     readonly launchIntent?: {
         readonly kind: "interactive";
         readonly profileId: LaunchProfileId;
+        readonly sessionSelection?: SessionSelection;
     };
     readonly environment?: NodeJS.ProcessEnv;
     readonly output?: Pick<NodeJS.WriteStream, "write">;
@@ -26,9 +27,15 @@ export interface BootstrapOptions {
 }
 export declare function runBootstrap(options: BootstrapOptions): Promise<number>;
 export declare function certifyMaterializedRelease(release: MaterializedRelease, dataDir: string, verification?: VerifyMaterializedReleaseOptions): Promise<string>;
-export declare function startSupervisor(release: MaterializedRelease, environment: NodeJS.ProcessEnv): Promise<void>;
+export interface SupervisorStartupAttempt extends SupervisorStartupAttemptIdentity {
+    readonly childOutcome: Promise<{
+        readonly exitCode: number | null;
+        readonly signal: NodeJS.Signals | null;
+    }>;
+}
+export declare function startSupervisor(release: MaterializedRelease, environment: NodeJS.ProcessEnv): Promise<SupervisorStartupAttempt>;
 export declare function releaseEnvironment(environment: NodeJS.ProcessEnv, release: MaterializedRelease): NodeJS.ProcessEnv;
-export declare function waitForVerifiedEndpoint(path: string, release: MaterializedRelease, timeoutMs: number): Promise<void>;
+export declare function waitForVerifiedEndpoint(path: string, release: MaterializedRelease, timeoutMs: number, startup?: SupervisorStartupAttempt): Promise<void>;
 export declare function readEndpointMetadata(path: string): Promise<SupervisorEndpointMetadata | null>;
 export declare function probeOwnership(metadata: SupervisorEndpointMetadata): Promise<OwnershipProbe>;
 export declare function releaseVerifiedIdleOwner(metadata: SupervisorEndpointMetadata, dataDir: string, operations?: {

package/dist/foundation/release/bootstrap.js

@@ -1,16 +1,17 @@
 import { spawn } from "node:child_process";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { connect } from "node:net";
 import { platform } from "node:os";
 import { resolve } from "node:path";
 import { selectCohortLaunch } from "./cohort-selection.js";
 import { CohortStateStore } from "./cohort-state.js";
-import { assertLaunchProfileId, resolveCohortEndpoint, resolveProductPaths } from "../lifecycle/index.js";
+import { assertLaunchProfileId, createSupervisorStartupAttempt, readSupervisorStartupResult, resolveCohortEndpoint, resolveProductPaths, sessionSelectionArguments } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { cleanupProvenIdleOwner, processIsAlive } from "./process-cleanup.js";
 import { sweepDeadEndpoints } from "./endpoints.js";
 import { consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
 import { scheduleReleaseCleanup } from "./release-gc.js";
+import { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument } from "./restart-certification.js";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 import { markStartupPhase } from "../startup/index.js";
 export async function runBootstrap(options) {
@@ -18,6 +19,9 @@ export async function runBootstrap(options) {
     await markStartupPhase(environment, "bootstrap-start");
     const launchProfileId = options.launchIntent?.profileId ?? "a1";
     assertLaunchProfileId(launchProfileId);
+    const sessionArgs = sessionSelectionArguments(options.launchIntent?.sessionSelection);
+    if (sessionArgs.length > 0 && launchProfileId !== "a1")
+        throw new Error("session selection requires the normal A1 profile");
     environment[PRODUCT_IDENTITY.environment.launchProfile] = launchProfileId;
     const output = options.output ?? process.stderr;
     const paths = resolveProductPaths(environment);
@@ -60,16 +64,27 @@ export async function runBootstrap(options) {
             && endpoint.contentDigest === active.contentDigest;
         if (endpointMatches && probe === "live-verified") {
             const retained = await readCertifiedReleaseManifest(active, resolve(paths.dataDir, "releases"));
-            return await launchUi(retained, environment);
+            return await launchUi(retained, environment, sessionArgs);
         }
         if (endpoint === null || probe === "dead") {
             if (endpoint)
                 await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint);
-            const retained = await readMaterializedRelease(active.releaseRoot);
+            await markStartupPhase(environment, "durable-validation-start");
+            const retained = await readRestartCertifiedRelease(active, paths.dataDir).catch(async () => {
+                const verified = await readMaterializedRelease(active.releaseRoot, resolve(paths.dataDir, "releases"));
+                if (verified.releaseId !== active.releaseId || verified.contentDigest !== active.contentDigest || verified.packageVersion !== active.packageVersion) {
+                    throw new Error("completely verified release differs from the approved active record");
+                }
+                await certifyMaterializedRelease(verified, paths.dataDir);
+                return verified;
+            });
+            await markStartupPhase(environment, "durable-validation-complete");
             const retainedPaths = resolveCohortEndpoint(paths, retained.releaseId, environment);
-            await startSupervisor(retained, environment);
-            await waitForVerifiedEndpoint(retainedPaths.endpointMetadataPath, retained, 8_000);
-            return await launchUi(retained, environment);
+            await markStartupPhase(environment, "replacement-supervisor-start");
+            const startup = await startSupervisor(retained, environment);
+            await waitForVerifiedEndpoint(retainedPaths.endpointMetadataPath, retained, 8_000, startup);
+            await markStartupPhase(environment, "replacement-supervisor-ready");
+            return await launchUi(retained, environment, sessionArgs);
         }
     }
     const candidate = await materializeRelease(options.packageRoot, paths.dataDir);
@@ -126,7 +141,7 @@ export async function runBootstrap(options) {
         if (decision.recordPending && endpoint) {
             await stateStore.blockPending("candidate activation deferred by live non-resumable instances", endpoint.ownership.nonResumableInstanceIds);
         }
-        const code = await launchUi(retained, environment);
+        const code = await launchUi(retained, environment, sessionArgs);
         if (decision.recordPending)
             await activatePendingAfterBlockerExit(candidate, stateStore, paths, environment);
         return code;
@@ -163,9 +178,9 @@ export async function runBootstrap(options) {
     else {
         selected = await readMaterializedRelease(decision.releaseRoot);
     }
-    await startSupervisor(selected, environment);
-    await waitForVerifiedEndpoint(resolveCohortEndpoint(paths, selected.releaseId, environment).endpointMetadataPath, selected, 8_000);
-    return await launchUi(selected, environment);
+    const startup = await startSupervisor(selected, environment);
+    await waitForVerifiedEndpoint(resolveCohortEndpoint(paths, selected.releaseId, environment).endpointMetadataPath, selected, 8_000, startup);
+    return await launchUi(selected, environment, sessionArgs);
 }
 async function readInstalledVersion(packageRoot) {
     const manifest = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
@@ -179,34 +194,37 @@ export async function certifyMaterializedRelease(release, dataDir, verification
         await verifyMaterializedRelease(release.releaseRoot, release, resolve(dataDir, "releases"), verification);
     }
     const path = resolve(dataDir, `certification-${release.releaseId}.json`);
-    await writeFile(path, JSON.stringify({
-        schema: PRODUCT_IDENTITY.evidence.releaseCertificationSchema,
-        releaseId: release.releaseId,
-        contentDigest: release.contentDigest,
-        verifiedAt: new Date().toISOString(),
-        checks: [{ id: "immutable-content", passed: true }],
-    }, null, 2), { mode: 0o600 });
+    const restartSeal = await createRestartSeal(release, dataDir);
+    await chmod(path, 0o600).catch(() => { });
+    await writeFile(path, JSON.stringify(releaseCertificationDocument(release, restartSeal), null, 2), { mode: 0o600 });
+    await chmod(path, 0o400);
     return path;
 }
 export async function startSupervisor(release, environment) {
     const entry = await resolveReleaseEntryPoint(release, "bin/supervisor.js");
-    const child = spawn(process.execPath, [entry], {
+    const paths = resolveProductPaths(environment);
+    const attempt = await createSupervisorStartupAttempt(paths.runtimeDir, release.releaseId);
+    const child = spawn(process.execPath, [entry, "--startup-attempt", attempt.attemptId], {
         detached: true,
         env: releaseEnvironment(environment, release),
         stdio: "ignore",
         windowsHide: true,
     });
+    const childOutcome = new Promise(resolvePromise => {
+        child.once("close", (exitCode, signal) => resolvePromise({ exitCode, signal }));
+    });
     await new Promise((resolvePromise, rejectPromise) => {
         child.once("spawn", resolvePromise);
         child.once("error", rejectPromise);
     });
     child.unref();
+    return { ...attempt, childOutcome };
 }
-async function launchUi(release, environment) {
+async function launchUi(release, environment, sessionArgs) {
     await markStartupPhase(environment, "bootstrap-selected");
     const entry = await resolveReleaseEntryPoint(release, "bin/guardian.js");
     return await new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn(process.execPath, [entry], {
+        const child = spawn(process.execPath, [entry, ...sessionArgs], {
             env: releaseEnvironment(environment, release),
             stdio: "inherit",
             windowsHide: false,
@@ -224,12 +242,27 @@ export function releaseEnvironment(environment, release) {
         [PRODUCT_IDENTITY.environment.releaseDigest]: release.contentDigest,
     };
 }
-export async function waitForVerifiedEndpoint(path, release, timeoutMs) {
+export async function waitForVerifiedEndpoint(path, release, timeoutMs, startup) {
     const deadline = Date.now() + timeoutMs;
+    let childOutcome = null;
+    void startup?.childOutcome.then(outcome => { childOutcome = outcome; });
     while (Date.now() < deadline) {
         const metadata = await readEndpointMetadata(path);
-        if (metadata && metadata.releaseId === release.releaseId && await probeOwnership(metadata) === "live-verified")
+        if (metadata && metadata.releaseId === release.releaseId && await probeOwnership(metadata) === "live-verified") {
+            if (startup)
+                await rm(startup.resultPath, { force: true });
             return;
+        }
+        if (startup) {
+            const result = await readSupervisorStartupResult(startup.resultPath, startup.attemptId, startup.releaseId);
+            if (result?.outcome === "failure") {
+                throw Object.assign(new Error(PRODUCT_TEXT.diagnostic(`supervisor startup failed at ${result.stage}: ${result.message}`)), {
+                    code: result.code ?? "SUPERVISOR_STARTUP_FAILED",
+                });
+            }
+        }
+        if (childOutcome)
+            throw new Error(PRODUCT_TEXT.diagnostic(`supervisor exited before readiness: ${JSON.stringify(childOutcome)}`));
         await new Promise(resolvePromise => setTimeout(resolvePromise, 40));
     }
     throw new Error(PRODUCT_TEXT.diagnostic(`supervisor did not publish verified endpoint metadata within ${timeoutMs}ms`));
@@ -326,8 +359,8 @@ async function activatePendingAfterBlockerExit(candidate, stateStore, paths, env
         return;
     await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
     await stateStore.activate(candidate.releaseId);
-    await startSupervisor(candidate, environment);
-    await waitForVerifiedEndpoint(resolveCohortEndpoint(paths, candidate.releaseId, environment).endpointMetadataPath, candidate, 8_000);
+    const startup = await startSupervisor(candidate, environment);
+    await waitForVerifiedEndpoint(resolveCohortEndpoint(paths, candidate.releaseId, environment).endpointMetadataPath, candidate, 8_000, startup);
 }
 export async function releaseVerifiedIdleOwner(metadata, dataDir, operations = {}) {
     try {