@timurproko/a1 0.2.7-dev.1244 → 0.2.7-dev.1249

package/dist/features/owned-ui/settings-app.js

@@ -543,8 +543,8 @@ export class SettingsApp {
             flagDialog: entry.backend !== "a1" ? null
                 : entry.id === PLUS_MENU_SETTING_ID ? new PlusMenuDialog(entry.flags)
                     : entry.id === TAB_BAR_RIGHT_ITEMS_SETTING_ID ? new FlagToggleDialog(entry.flags, {
-                        title: "Right Side",
-                        description: "Choose what the right side of the tab bar shows.",
+                        title: "Widgets",
+                        description: "Choose which widgets the tab bar shows.",
                         empty: "No items match",
                     }) : null,
             filter: modelDialog === null ? null : new LineInput(""),

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

@@ -25,6 +25,11 @@ export interface SpawnContainedOptions {
 export interface ProcessGuardianAddon {
     version(): ProcessGuardianVersion;
     inspectProcessStart(pid: number): string | null;
+    /** Additive capability; older retained addons remain usable for containment, not recovery gates. */
+    tryAcquireProcessGate?(path: string): {
+        readonly acquired: boolean;
+        release(): void;
+    };
     captureTerminalModes(): string;
     restoreTerminalModes(encoded: string): void;
     deliverExitNotice(path: string, encodedModes: string): void;

package/dist/foundation/release/bootstrap.js

@@ -4,6 +4,7 @@ import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { connect } from "node:net";
 import { resolve } from "node:path";
 import { selectCohortLaunch } from "./cohort-selection.js";
+import { recoverSupervisorEndpoint } from "./endpoint-recovery.js";
 import { selectOrdinaryLaunchReleaseId } from "./ordinary-launch-selection.js";
 import { releaseChannelOf } from "./latest-release.js";
 import { CohortStateStore } from "./cohort-state.js";
@@ -22,7 +23,16 @@ import { PRIVATE_ENVIRONMENT, isCurrentLaunchContract, launchContractTarget, rea
 import { assertResidentContinuity, ensureTerminalHost, readResidentTabLaunchSettings, selectResidentHost } from "../resident-tabs/index.js";
 const RELEASE_RESELECTION_MESSAGE = "a1-release-reselection";
 export async function runBootstrap(options) {
-    return await runBootstrapAttempt(options, 1);
+    try {
+        return await runBootstrapAttempt(options, 1);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && typeof error.code === "string" && error.code.startsWith("SUPERVISOR_RECOVERY_")))
+            throw error;
+        // Rationale: actionable recovery failures are a single line, not an uncaught Node stack trace.
+        (options.output ?? process.stderr).write(`${PRODUCT_TEXT.diagnostic(error.message)}\n`);
+        return 1;
+    }
 }
 async function runBootstrapAttempt(options, retriesRemaining) {
     const launchProfileId = options.launchIntent?.profileId ?? "a1";
@@ -122,7 +132,7 @@ async function runBootstrapAttempt(options, retriesRemaining) {
         }
         if (endpoint === null || probe === "dead") {
             if (endpoint)
-                await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint);
+                await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint, endpoint);
             await markStartupPhase(environment, "durable-validation-start");
             const retained = await readRestartCertifiedRelease(active, paths.dataDir).catch(async () => {
                 let verified;
@@ -217,20 +227,12 @@ async function runBootstrapAttempt(options, retriesRemaining) {
     probe = endpoint ? await probeOwnership(endpoint) : "dead";
     let decision = selectCohortLaunch(candidate, state, endpoint, probe);
     if (decision.action === "blocked") {
-        await stateStore.blockPending(decision.reason, endpoint?.ownership.liveInstanceIds ?? []);
-        output.write(`${PRODUCT_TEXT.diagnostic(`startup is blocked to preserve uncertain live ownership: ${decision.reason}`)}\n`);
-        return 1;
-    }
-    if (decision.action === "clean-stale-owner" && endpoint) {
-        const diagnostics = await cleanupProvenIdleOwner(endpoint);
-        await writeFile(resolve(paths.dataDir, `cleanup-${Date.now()}.json`), JSON.stringify(diagnostics, null, 2));
-        if (!diagnostics.terminated)
-            throw new Error(`could not safely clean stale ${PRODUCT_TEXT.displayName} supervisor ${endpoint.pid}`);
-        await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint);
-        decision = selectCohortLaunch(candidate, await stateStore.read(), null, "dead");
+        // Concurrency: reread through the common recovery path rather than fail on an old snapshot.
+        await ensureSupervisor(candidate, environment);
+        return await launchSelected(candidate);
     }
-    else if (endpoint && probe === "dead") {
-        await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint);
+    if (endpoint && probe === "dead") {
+        await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint, endpoint);
     }
     if (decision.action === "launch-retained-ui") {
         const retainedRecord = state.releases[decision.releaseId];
@@ -259,7 +261,7 @@ async function runBootstrapAttempt(options, retriesRemaining) {
             output.write(`${PRODUCT_TEXT.diagnostic("could not complete bounded idle cohort shutdown; the candidate remains pending.")}\n`);
             return 1;
         }
-        await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint);
+        await removeEndpointArtifacts(endpointPaths.endpointMetadataPath, endpointPaths.endpoint, endpoint);
         await stateStore.activate(candidate.releaseId);
         decision = { action: "activate-candidate", releaseId: candidate.releaseId, releaseRoot: candidate.releaseRoot, reason: "idle cohort released ownership" };
     }
@@ -377,17 +379,15 @@ export async function recordParentCertifiedRelease(release, dataDir) {
 /** Reuse a verified owner, or join the winner if another launch starts the same cohort first. */
 export async function ensureSupervisor(release, environment) {
     const paths = resolveCohortEndpoint(resolveProductPaths(environment), release.releaseId, environment);
-    const metadata = await readEndpointMetadata(paths.endpointMetadataPath);
-    if (metadata) {
-        const probe = await probeOwnership(metadata);
-        if (probe !== "dead") {
-            if (probe === "live-verified" && endpointMatchesRelease(metadata, release))
-                return;
-            throw new Error(PRODUCT_TEXT.diagnostic(`refused duplicate supervisor startup: existing ownership is ${probe}`));
-        }
-    }
-    const startup = await startSupervisor(release, environment);
-    await waitForVerifiedEndpoint(paths.endpointMetadataPath, release, 8_000, startup);
+    await recoverSupervisorEndpoint({
+        metadataPath: paths.endpointMetadataPath,
+        endpoint: paths.endpoint,
+        matches: metadata => endpointMatchesRelease(metadata, release),
+        startAndWait: async () => {
+            const startup = await startSupervisor(release, environment);
+            await waitForVerifiedEndpoint(paths.endpointMetadataPath, release, 8_000, startup);
+        },
+    });
 }
 function endpointMatchesRelease(metadata, release) {
     return metadata.releaseId === release.releaseId && metadata.releaseRoot === release.releaseRoot
@@ -463,7 +463,7 @@ export async function waitForVerifiedEndpoint(path, release, timeoutMs, startup)
     void startup?.childOutcome.then(outcome => { childOutcome = outcome; });
     while (Date.now() < deadline) {
         const metadata = await readEndpointMetadata(path);
-        if (metadata && endpointMatchesRelease(metadata, release) && await probeOwnership(metadata) === "live-verified") {
+        if (metadata && endpointMatchesRelease(metadata, release) && await probeOwnership(metadata, { attempts: 1 }) === "live-verified") {
             if (startup)
                 await rm(startup.resultPath, { force: true });
             return;
@@ -507,18 +507,21 @@ async function activatePendingAfterBlockerExit(candidate, stateStore, paths, env
         return;
     if (!await releaseVerifiedIdleOwner(endpoint, paths.dataDir))
         return;
-    await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
+    await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint, endpoint);
     await stateStore.activate(candidate.releaseId);
     await ensureSupervisor(candidate, environment);
 }
 export async function releaseVerifiedIdleOwner(metadata, dataDir, operations = {}) {
     try {
+        // Protocol: the owner rechecks its boot nonce and live instances before cooperative exit.
+        // A durable idle snapshot alone never authorizes a signal to a still-live process.
+        await requestIdleOwnershipRelease(metadata, metadata.releaseId, 2_000);
         await (operations.waitForExit ?? waitForProcessExit)(metadata.pid, 3_000);
         return true;
     }
     catch {
-        // Security: the authenticated idle-release handshake authorizes bounded cleanup of
-        // this exact boot when a native handle outlives graceful shutdown.
+        // Security: a lingering Windows handle can keep numeric PID probes positive after exit.
+        // Native observation may retire that exact dead boot, but never signals a still-live owner.
         const diagnostics = await (operations.cleanup ?? cleanupProvenIdleOwner)(metadata);
         await writeFile(resolve(dataDir, `cleanup-${Date.now()}.json`), JSON.stringify(diagnostics, null, 2));
         return diagnostics.terminated;

package/dist/foundation/release/cohort-selection.d.ts

@@ -23,12 +23,6 @@ export type CohortLaunchDecision = {
     readonly releaseId: string;
     readonly releaseRoot: string;
     readonly reason: string;
-} | {
-    readonly action: "clean-stale-owner";
-    readonly releaseId: string;
-    readonly releaseRoot: string;
-    readonly reason: string;
-    readonly pid: number;
 } | {
     readonly action: "blocked";
     readonly releaseId: string;

package/dist/foundation/release/cohort-selection.js

@@ -30,20 +30,12 @@ export function selectCohortLaunch(candidate, state, endpoint, probe) {
         };
     }
     if (endpoint && probe === "unresponsive") {
-        if (endpoint.ownership.liveInstanceIds.length > 0 || endpoint.ownership.nonResumableInstanceIds.length > 0) {
-            return {
-                action: "blocked",
-                releaseId: endpoint.releaseId,
-                releaseRoot: endpoint.releaseRoot,
-                reason: "ownership of live launch instances is uncertain; preserving the unresponsive supervisor",
-                pid: endpoint.pid,
-            };
-        }
+        // Security: even an empty persisted list cannot authorize killing an unresponsive process.
         return {
-            action: "clean-stale-owner",
-            releaseId: candidate.releaseId,
-            releaseRoot: candidate.releaseRoot,
-            reason: "unresponsive owner has no recorded live generation and is safe for bounded cleanup",
+            action: "blocked",
+            releaseId: endpoint.releaseId,
+            releaseRoot: endpoint.releaseRoot,
+            reason: "the background service did not respond after automatic recovery; retry shortly",
             pid: endpoint.pid,
         };
     }

package/dist/foundation/release/cohort-state.d.ts

@@ -94,6 +94,8 @@ export interface SupervisorEndpointMetadata {
     readonly endpoint: string;
     readonly pid: number;
     readonly pidStartIdentity: string;
+    /** Exact OS creation token; absent on historical supervisor metadata. */
+    readonly nativeStartIdentity?: string;
     readonly bootNonce: string;
     readonly startedAt: string;
     readonly releaseId: string;

package/dist/foundation/release/endpoint-lock.d.ts

@@ -0,0 +1,2 @@
+/** Serialize endpoint publication and retirement using a lock released by the OS on process death. */
+export declare function withEndpointLock<T>(metadataPath: string, operation: () => Promise<T>): Promise<T>;

package/dist/foundation/release/endpoint-lock.js

@@ -0,0 +1,37 @@
+import { mkdir, realpath } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { acquireSupervisorGate } from "./supervisor-identity.js";
+/** Serialize endpoint publication and retirement using a lock released by the OS on process death. */
+export async function withEndpointLock(metadataPath, operation) {
+    let authority;
+    try {
+        await mkdir(dirname(metadataPath), { recursive: true, mode: 0o700 });
+        authority = join(await realpath(dirname(metadataPath)), `${basename(metadataPath)}.authority`);
+    }
+    catch (cause) {
+        throw Object.assign(new Error("cannot access A1 startup state; check runtime-directory permissions and free disk space", { cause }), { code: "SUPERVISOR_RECOVERY_UNAVAILABLE" });
+    }
+    const deadline = Date.now() + 3_000;
+    for (;;) {
+        let gate;
+        try {
+            gate = acquireSupervisorGate(authority);
+        }
+        catch (cause) {
+            throw Object.assign(new Error("cannot access A1 startup coordination; check installation and runtime-directory permissions", { cause }), { code: "SUPERVISOR_RECOVERY_UNAVAILABLE" });
+        }
+        if (gate.acquired) {
+            try {
+                return await operation();
+            }
+            finally {
+                gate.release();
+            }
+        }
+        gate.release();
+        if (Date.now() >= deadline)
+            throw Object.assign(new Error("another A1 startup is still preparing; retry shortly"), { code: "SUPERVISOR_RECOVERY_BUSY" });
+        await delay(20);
+    }
+}

package/dist/foundation/release/endpoint-recovery.d.ts

@@ -0,0 +1,10 @@
+import type { SupervisorEndpointMetadata } from "./cohort-state.js";
+interface SupervisorRecoveryOptions {
+    readonly metadataPath: string;
+    readonly endpoint: string;
+    readonly matches: (metadata: SupervisorEndpointMetadata) => boolean;
+    readonly startAndWait: () => Promise<void>;
+}
+/** Recover all launch routes identically; a retry never grants permission to kill a live process. */
+export declare function recoverSupervisorEndpoint(options: SupervisorRecoveryOptions): Promise<void>;
+export {};

package/dist/foundation/release/endpoint-recovery.js

@@ -0,0 +1,45 @@
+import { writeFile } from "node:fs/promises";
+import { probeOwnership, readEndpointMetadata, removeEndpointArtifacts } from "./endpoints.js";
+/** Recover all launch routes identically; a retry never grants permission to kill a live process. */
+export async function recoverSupervisorEndpoint(options) {
+    const { metadataPath, endpoint } = options;
+    let recovered = false;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const metadata = await readEndpointMetadata(metadataPath);
+        if (metadata) {
+            const probe = await probeOwnership(metadata);
+            if (probe === "live-verified" && options.matches(metadata)) {
+                if (recovered)
+                    await diagnostic(metadataPath, "recovered", attempt + 1);
+                return;
+            }
+            // Concurrency: another owner may have published while an earlier identity probe was pending.
+            if (JSON.stringify(await readEndpointMetadata(metadataPath)) !== JSON.stringify(metadata))
+                continue;
+            if (probe !== "dead") {
+                await diagnostic(metadataPath, probe, attempt + 1);
+                throw Object.assign(new Error(probe === "unresponsive"
+                    ? "A1's background service is not responding; retry shortly. Your sessions have been preserved."
+                    : "A1's background service identity changed; retry startup. Your sessions have been preserved."), {
+                    code: "SUPERVISOR_RECOVERY_BLOCKED",
+                });
+            }
+            recovered = true;
+            if (!await removeEndpointArtifacts(metadataPath, endpoint, metadata))
+                continue;
+            await diagnostic(metadataPath, "stale-owner-retired", attempt + 1);
+        }
+        // Concurrency: the child takes the same endpoint gate before binding/publication. If another launch wins,
+        // startAndWait joins its authenticated endpoint; it never unlinks that winner's socket.
+        await options.startAndWait();
+        if (recovered)
+            await diagnostic(metadataPath, "recovered", attempt + 1);
+        return;
+    }
+    await diagnostic(metadataPath, "ownership-changing", 3);
+    throw Object.assign(new Error("A1 startup changed repeatedly; retry shortly"), { code: "SUPERVISOR_RECOVERY_BUSY" });
+}
+async function diagnostic(path, reason, attempts) {
+    // Security: one bounded summary per endpoint, no raw metadata, user paths, or session content.
+    await writeFile(`${path}.recovery.json`, JSON.stringify({ reason, attempts, at: new Date().toISOString() }), { mode: 0o600 }).catch(() => undefined);
+}

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

@@ -1,4 +1,5 @@
 import type { OwnershipProbe } from "./cohort-selection.js";
+import { type ObserveSupervisorProcess } from "./supervisor-identity.js";
 import type { SupervisorEndpointMetadata } from "./cohort-state.js";
 import type { CohortEndpointPaths, ProductPaths } from "../lifecycle/index.js";
 export interface RecordedEndpoint {
@@ -20,5 +21,12 @@ export declare function sweepDeadEndpoints(paths: ProductPaths): Promise<readonl
 /** The releases that an identity-verified live cohort runs from and that must be retained. */
 export declare function liveReleaseIds(paths: ProductPaths): Promise<readonly string[]>;
 export declare function readEndpointMetadata(path: string): Promise<SupervisorEndpointMetadata | null>;
-export declare function probeOwnership(metadata: SupervisorEndpointMetadata): Promise<OwnershipProbe>;
-export declare function removeEndpointArtifacts(metadataPath: string, endpoint: string): Promise<void>;
+export interface OwnershipProbeOptions {
+    readonly observe?: ObserveSupervisorProcess;
+    readonly attempts?: number;
+    readonly timeoutMs?: number;
+}
+/** Reprobe transient failures; only native absence or a replaced generation establishes death. */
+export declare function probeOwnership(metadata: SupervisorEndpointMetadata, options?: OwnershipProbeOptions): Promise<OwnershipProbe>;
+/** Retire only a still-dead exact publication. Socket removal belongs to the gated listener. */
+export declare function removeEndpointArtifacts(metadataPath: string, endpoint: string, expected: SupervisorEndpointMetadata): Promise<boolean>;

package/dist/foundation/release/endpoints.js

@@ -1,10 +1,10 @@
 import { readdir, readFile, rm } from "node:fs/promises";
 import { connect } from "node:net";
-import { platform } from "node:os";
 import { resolve } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
-import { processIsAlive } from "./process-cleanup.js";
+import { supervisorProcessState } from "./supervisor-identity.js";
+import { withEndpointLock } from "./endpoint-lock.js";
 /**
  * Every endpoint recorded under this runtime directory: one per cohort, plus the single
  * endpoint published by releases that predate cohort-scoped identity. More than one can be
@@ -12,9 +12,12 @@ import { processIsAlive } from "./process-cleanup.js";
  */
 export async function listRecordedEndpoints(paths) {
     const recorded = [];
-    const legacy = await readEndpointMetadata(paths.endpointMetadataPath);
+    // Compatibility: a cohort listener passes its scoped paths here; legacy discovery still
+    // names the runtime directory's fixed metadata path, not that listener's own record.
+    const legacyPath = resolve(paths.runtimeDir, PRODUCT_IDENTITY.endpoint.metadataFilename);
+    const legacy = await readEndpointMetadata(legacyPath);
     if (legacy) {
-        recorded.push({ metadata: legacy, paths: { endpoint: paths.endpoint, endpointMetadataPath: paths.endpointMetadataPath } });
+        recorded.push({ metadata: legacy, paths: { endpoint: legacy.endpoint, endpointMetadataPath: legacyPath } });
     }
     const names = await readdir(paths.endpointsDir).catch(() => []);
     for (const name of names) {
@@ -35,10 +38,11 @@ export async function listRecordedEndpoints(paths) {
 export async function sweepDeadEndpoints(paths) {
     const swept = [];
     for (const recorded of await listRecordedEndpoints(paths)) {
-        if (processIsAlive(recorded.metadata.pid))
+        if (await supervisorProcessState(recorded.metadata) !== "gone")
             continue;
-        await removeEndpointArtifacts(recorded.paths.endpointMetadataPath, recorded.paths.endpoint);
-        swept.push(recorded.metadata.releaseId);
+        if (await removeEndpointArtifacts(recorded.paths.endpointMetadataPath, recorded.paths.endpoint, recorded.metadata)) {
+            swept.push(recorded.metadata.releaseId);
+        }
     }
     return swept;
 }
@@ -82,18 +86,24 @@ export async function readEndpointMetadata(path) {
         return null;
     }
 }
-export async function probeOwnership(metadata) {
-    if (!processIsAlive(metadata.pid))
-        return "dead";
-    const identity = await requestIdentity(metadata.endpoint, 500);
-    if (!identity)
-        return "unresponsive";
-    return identity.supervisorId === metadata.supervisorId
-        && identity.bootNonce === metadata.bootNonce
-        && identity.pidStartIdentity === metadata.pidStartIdentity
-        && identity.releaseId === metadata.releaseId
-        ? "live-verified"
-        : "identity-mismatch";
+/** Reprobe transient failures; only native absence or a replaced generation establishes death. */
+export async function probeOwnership(metadata, options = {}) {
+    const attempts = options.attempts ?? 3;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        const identity = await requestIdentity(metadata.endpoint, options.timeoutMs ?? 500);
+        if (identity) {
+            return identity.supervisorId === metadata.supervisorId
+                && identity.bootNonce === metadata.bootNonce
+                && identity.pidStartIdentity === metadata.pidStartIdentity
+                && identity.releaseId === metadata.releaseId
+                ? "live-verified" : "identity-mismatch";
+        }
+        if (await supervisorProcessState(metadata, options.observe) === "gone")
+            return "dead";
+        if (attempt + 1 < attempts)
+            await new Promise(resolvePromise => setTimeout(resolvePromise, 50));
+    }
+    return "unresponsive";
 }
 async function requestIdentity(endpoint, timeoutMs) {
     return await new Promise(resolvePromise => {
@@ -104,6 +114,7 @@ async function requestIdentity(endpoint, timeoutMs) {
             if (settled)
                 return;
             settled = true;
+            clearTimeout(timer);
             socket.destroy();
             resolvePromise(value);
         };
@@ -121,14 +132,21 @@ async function requestIdentity(endpoint, timeoutMs) {
                 finish(null);
             }
         });
-        setTimeout(() => finish(null), timeoutMs).unref();
+        const timer = setTimeout(() => finish(null), timeoutMs);
     });
 }
 function isStringArray(value) {
     return Array.isArray(value) && value.every(item => typeof item === "string" && item.length > 0);
 }
-export async function removeEndpointArtifacts(metadataPath, endpoint) {
-    await rm(metadataPath, { force: true });
-    if (platform() !== "win32")
-        await rm(endpoint, { force: true });
+/** Retire only a still-dead exact publication. Socket removal belongs to the gated listener. */
+export async function removeEndpointArtifacts(metadataPath, endpoint, expected) {
+    return await withEndpointLock(metadataPath, async () => {
+        const current = await readEndpointMetadata(metadataPath);
+        if (!current || current.endpoint !== endpoint || JSON.stringify(current) !== JSON.stringify(expected))
+            return false;
+        if (await supervisorProcessState(current) !== "gone" || await probeOwnership(current, { attempts: 1 }) !== "dead")
+            return false;
+        await rm(metadataPath, { force: true });
+        return true;
+    });
 }

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

@@ -8,6 +8,8 @@ export type { ActiveReleaseTransactionReference, CohortState, EndpointOwnership,
 export { DEPENDENCY_LAYER_MANIFEST, DEPENDENCY_LAYER_SCHEMA, RUNTIME_PAYLOAD_INVENTORY, dependencyLayerCertificationPath, dependencyReference, generateDependencyRuntimePayload, legacyDependencyLayerCertificationPath, materializeDependencyLayer, readCertifiedDependencyLayer, selectDependencyRuntimePayload, selectPublishedDependencyRuntimePayload, verifyDependencyLayer, } from "./dependency-layer.js";
 export type { DependencyLayerIdentity, DependencyLayerOperationEvent, DependencyLayerReference, GeneratedRuntimePayload, MaterializeDependencyLayerOptions, MaterializedDependencyLayer, PublishedRuntimeFileClassification, PublishedRuntimePayload, ReadCertifiedDependencyLayerOptions, RuntimePayloadExclusion, RuntimePayloadInventory, SelectedRuntimePayload, } from "./dependency-layer.js";
 export { listRecordedEndpoints, liveReleaseIds, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, sweepDeadEndpoints } from "./endpoints.js";
+export { currentSupervisorStartIdentity, observeSupervisorProcess, supervisorProcessState } from "./supervisor-identity.js";
+export { withEndpointLock } from "./endpoint-lock.js";
 export type { RecordedEndpoint } from "./endpoints.js";
 export { cleanupProvenIdleOwner, cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
 export type { CleanupDiagnostics } from "./process-cleanup.js";

package/dist/foundation/release/index.js

@@ -4,6 +4,8 @@ export { selectOrdinaryLaunchReleaseId } from "./ordinary-launch-selection.js";
 export { CohortStateStore, RELEASE_COHORT_SCHEMA, emptyState, planProtectedReleases } from "./cohort-state.js";
 export { DEPENDENCY_LAYER_MANIFEST, DEPENDENCY_LAYER_SCHEMA, RUNTIME_PAYLOAD_INVENTORY, dependencyLayerCertificationPath, dependencyReference, generateDependencyRuntimePayload, legacyDependencyLayerCertificationPath, materializeDependencyLayer, readCertifiedDependencyLayer, selectDependencyRuntimePayload, selectPublishedDependencyRuntimePayload, verifyDependencyLayer, } from "./dependency-layer.js";
 export { listRecordedEndpoints, liveReleaseIds, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, sweepDeadEndpoints } from "./endpoints.js";
+export { currentSupervisorStartIdentity, observeSupervisorProcess, supervisorProcessState } from "./supervisor-identity.js";
+export { withEndpointLock } from "./endpoint-lock.js";
 export { cleanupProvenIdleOwner, cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
 export { PRODUCT_PACKAGE_NAME, createReleaseIdentity, deriveReleaseIdentity, digestManifestFiles, discoverReleasePayload, packageRootFromModule, releaseFileIdentity, resolveWithin, } from "./release.js";
 export { collectRelease, prepareReleaseCleanup, runBoundedReleaseCleanup, runReleaseCleanupWorker, scheduleReleaseCleanup } from "./release-gc.js";

package/dist/foundation/release/process-cleanup.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { supervisorProcessState } from "./supervisor-identity.js";
 export function processIsAlive(pid) {
     if (!Number.isSafeInteger(pid) || pid <= 0)
         return false;
@@ -15,17 +16,26 @@ export async function cleanupProvenIdleOwner(metadata, graceMs = 1_500) {
 }
 export async function cleanupVerifiedOwner(metadata, options = {}) {
     const graceMs = options.graceMs ?? 1_500;
-    if (!options.allowLiveInstances && (metadata.ownership.liveInstanceIds.length > 0 || metadata.ownership.nonResumableInstanceIds.length > 0)) {
+    if (!options.allowLiveInstances && (metadata.ownership.liveInstanceIds.length > 0 || metadata.ownership.nonResumableInstanceIds.length > 0 || metadata.ownership.uncertainInstanceIds.length > 0)) {
         throw new Error("refusing to terminate an owner with recorded live generations");
     }
     const started = Date.now();
     const attempted = [];
-    if (!processIsAlive(metadata.pid))
+    const state = await supervisorProcessState(metadata);
+    if (state === "gone")
         return { pid: metadata.pid, attempted: ["owner-already-dead"], terminated: true, elapsedMs: Date.now() - started };
+    // Security: ordinary recovery never signals a live owner, even with an empty durable list.
+    // Explicit update cleanup also needs the exact native generation, not merely an old handshake.
+    if (!options.allowLiveInstances || state !== "same") {
+        return { pid: metadata.pid, attempted: ["live-owner-preserved"], terminated: false, elapsedMs: Date.now() - started };
+    }
     attempted.push("graceful-termination");
     await terminate(metadata.pid, false);
     if (await waitUntilDead(metadata.pid, graceMs))
         return { pid: metadata.pid, attempted, terminated: true, elapsedMs: Date.now() - started };
+    if (await supervisorProcessState(metadata) !== "same") {
+        return { pid: metadata.pid, attempted, terminated: await supervisorProcessState(metadata) === "gone", elapsedMs: Date.now() - started };
+    }
     attempted.push("forced-process-tree-termination");
     await terminate(metadata.pid, true);
     const terminated = await waitUntilDead(metadata.pid, graceMs);

package/dist/foundation/release/supervisor-identity.d.ts

@@ -0,0 +1,15 @@
+import type { NativeProcessIdentity } from "../lifecycle/index.js";
+import type { SupervisorEndpointMetadata } from "./cohort-state.js";
+export type SupervisorProcessState = "same" | "gone" | "unknown";
+export type ObserveSupervisorProcess = (pid: number) => Promise<NativeProcessIdentity | null>;
+/** Inspection code comes from this runtime, never from a path in a stale endpoint record. */
+export declare function observeSupervisorProcess(pid: number): Promise<NativeProcessIdentity | null>;
+/** New supervisors use a native creation token as their opaque handshake identity as well. */
+export declare function currentSupervisorStartIdentity(): string;
+/** The current runtime also owns the OS gate ABI; metadata cannot choose a different addon. */
+export declare function acquireSupervisorGate(path: string): {
+    readonly acquired: boolean;
+    release(): void;
+};
+/** A failed inspection is uncertainty, never permission to erase a possibly live owner. */
+export declare function supervisorProcessState(metadata: SupervisorEndpointMetadata, observe?: ObserveSupervisorProcess): Promise<SupervisorProcessState>;

package/dist/foundation/release/supervisor-identity.js

@@ -0,0 +1,63 @@
+import { fileURLToPath } from "node:url";
+import { createNativeProcessInspector, loadProcessGuardianAddon, resolveProcessGuardianPath } from "../process-containment/index.js";
+const ownRoot = fileURLToPath(new URL("../../../", import.meta.url));
+/** Inspection code comes from this runtime, never from a path in a stale endpoint record. */
+export async function observeSupervisorProcess(pid) {
+    return await (await createNativeProcessInspector(process.env, process.platform, ownRoot)).observe(pid);
+}
+/** New supervisors use a native creation token as their opaque handshake identity as well. */
+export function currentSupervisorStartIdentity() {
+    try {
+        const token = loadProcessGuardianAddon(resolveProcessGuardianPath(ownRoot, process.env)).inspectProcessStart(process.pid);
+        if (!validNativeToken(token))
+            throw new Error("native process identity is unavailable");
+        return token;
+    }
+    catch (cause) {
+        throw Object.assign(new Error("cannot verify A1's background service process; check installation and process-inspection permissions", { cause }), { code: "SUPERVISOR_RECOVERY_UNAVAILABLE" });
+    }
+}
+/** The current runtime also owns the OS gate ABI; metadata cannot choose a different addon. */
+export function acquireSupervisorGate(path) {
+    const addon = loadProcessGuardianAddon(resolveProcessGuardianPath(ownRoot, process.env));
+    if (!addon.tryAcquireProcessGate)
+        throw new Error("this installation lacks startup recovery support; update or repair A1");
+    return addon.tryAcquireProcessGate(path);
+}
+/** A failed inspection is uncertainty, never permission to erase a possibly live owner. */
+export async function supervisorProcessState(metadata, observe = observeSupervisorProcess) {
+    let identity;
+    try {
+        identity = await observe(metadata.pid);
+    }
+    catch {
+        return "unknown";
+    }
+    if (identity === null)
+        return "gone";
+    if (identity.pid !== metadata.pid)
+        return "unknown";
+    if (metadata.nativeStartIdentity !== undefined) {
+        // Compatibility: only compare tokens of the same native format, not an old Node timestamp.
+        if (!validNativeToken(metadata.nativeStartIdentity) || !validNativeToken(identity.startIdentity)
+            || identity.startIdentity.split(":")[0] !== metadata.nativeStartIdentity.split(":")[0])
+            return "unknown";
+        return identity.startIdentity === metadata.nativeStartIdentity ? "same" : "gone";
+    }
+    // Compatibility: legacy publication happened after process creation. A native creation time
+    // strictly later than that publication (with a one-second clock margin) disproves ownership;
+    // a near timestamp is NOT proof of ownership. Linux tick-only tokens cannot prove this.
+    const published = Date.parse(metadata.startedAt);
+    const created = nativeCreationTime(identity.startIdentity);
+    return Number.isFinite(published) && created !== null && created > published + 1_000 ? "gone" : "unknown";
+}
+function validNativeToken(value) {
+    return typeof value === "string" && /^(?:windows-filetime:\d{1,20}|linux-proc-start:\d{1,20}|darwin-proc-start:\d{1,20}:\d{1,6})$/.test(value);
+}
+function nativeCreationTime(identity) {
+    const windows = /^windows-filetime:(\d+)$/.exec(identity);
+    if (windows)
+        return Number(BigInt(windows[1]) / 10000n - 11644473600000n);
+    const darwin = /^darwin-proc-start:(\d+):(\d+)$/.exec(identity);
+    return darwin ? Number(darwin[1]) * 1_000 + Number(darwin[2]) / 1_000 : null;
+}

package/dist/foundation/release/update.js

@@ -155,7 +155,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             }
             const plan = planUpdateOwnership(ownership, await canonicalImmutableRoot(paths.dataDir, endpoint.releaseRoot));
             if (plan === "clean-dead-record") {
-                await removeEndpointArtifacts(owner.paths.endpointMetadataPath, owner.paths.endpoint);
+                await removeEndpointArtifacts(owner.paths.endpointMetadataPath, owner.paths.endpoint, endpoint);
                 return { priorActiveVersion };
             }
             // Rationale: leaving sessions alone is the expected outcome, and saying so mid-update tears
@@ -182,7 +182,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
                         throw new Error(`verified ${PRODUCT_TEXT.displayName} owner ${endpoint.pid} did not terminate`);
                 });
             }
-            await removeEndpointArtifacts(owner.paths.endpointMetadataPath, owner.paths.endpoint);
+            await removeEndpointArtifacts(owner.paths.endpointMetadataPath, owner.paths.endpoint, endpoint);
             return { priorActiveVersion };
         },
         async verifyPackageUnlocked(packageRoot) {

package/dist/foundation/storage/control-store.d.ts

@@ -5,14 +5,16 @@ export declare class ControlStore {
     #private;
     readonly database: DatabaseSync;
     readonly bootNonce: string | null;
-    constructor(path: string, bootNonce?: string | null);
+    constructor(path: string, bootNonce?: string | null, options?: {
+        readonly reconcileOnOpen?: boolean;
+    });
     migrate(): void;
     createLaunchInstance(instance: LaunchInstance): void;
     activateLaunchInstance(instanceId: LaunchInstanceId, ownerClientId: string, rootIdentity: NativeProcessIdentity, containmentIdentity: ProcessContainmentIdentity, activatedAt: string): boolean;
     beginLaunchInstanceStop(instanceId: LaunchInstanceId, ownerClientId: string, stoppingAt: string): boolean;
     completeLaunchInstance(instanceId: LaunchInstanceId, ownerClientId: string, terminalState: "completed" | "interrupted", outcome: LaunchInstanceOutcome, completedAt: string): boolean;
-    loadActiveLaunchInstances(): LaunchInstance[];
+    loadActiveLaunchInstances(bootNonce?: string): LaunchInstance[];
     loadLaunchInstance(instanceId: LaunchInstanceId): LaunchInstance | null;
-    reconcilePriorBootLaunchInstances(bootNonce: string, reconciledAt?: string): number;
+    reconcilePriorBootLaunchInstances(bootNonce: string, reconciledAt?: string, protectedBoots?: readonly string[]): number;
     close(): void;
 }