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

package/dist/foundation/lifecycle/native-claim-gate.d.ts

@@ -0,0 +1,5 @@
+export interface ClaimGateHandle {
+    release(): void;
+}
+/** No PID-file fallback: only the platform descriptor can prove upgraded-writer exclusion. */
+export declare function tryAcquireClaimGate(path: string): ClaimGateHandle | null;

package/dist/foundation/lifecycle/native-claim-gate.js

@@ -0,0 +1,41 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+let backend;
+/** No PID-file fallback: only the platform descriptor can prove upgraded-writer exclusion. */
+export function tryAcquireClaimGate(path) {
+    if (backend === undefined) {
+        const require = createRequire(import.meta.url);
+        // Security: resolve only this release's addon, never a binary supplied by tool cwd.
+        const own = resolve(fileURLToPath(new URL("../../../", import.meta.url)), "dist", "native", `${process.platform}-${process.arch}`, `${PRODUCT_IDENTITY.artifacts.terminalHostAddon}.node`);
+        const override = process.env[PRODUCT_IDENTITY.environment.developmentInstanceId]
+            ? process.env[PRODUCT_IDENTITY.environment.terminalHostPath] : undefined;
+        for (const candidate of override ? [override, own] : [own]) {
+            if (!existsSync(candidate))
+                continue;
+            try {
+                const loaded = require(candidate);
+                if (typeof loaded.SessionLock?.tryAcquireGate === "function") {
+                    backend = loaded.SessionLock;
+                    break;
+                }
+            }
+            catch { /* Compatibility: an unusable addon is unavailable, not contended. */ }
+        }
+    }
+    if (backend === undefined)
+        throw Object.assign(new Error("native worktree coordination is unavailable; repair or update this A1 installation and retry"), {
+            code: "worktree-coordination-unavailable",
+        });
+    try {
+        const handle = backend.tryAcquireGate(path);
+        return handle.acquired ? handle : null;
+    }
+    catch (cause) {
+        throw Object.assign(new Error("cannot access the worktree mutation gate; check A1 data-directory permissions and filesystem availability", { cause }), {
+            code: "worktree-coordination-io",
+        });
+    }
+}

package/dist/foundation/lifecycle/session-claim-lock.d.ts

@@ -0,0 +1,13 @@
+interface ClaimLockOptions {
+    readonly signal?: AbortSignal;
+    readonly lockTimeoutMs?: number;
+}
+/** Inventory is advisory and read-only, including when abandoned metadata needs recovery. */
+export declare function claimMutationPending(directory: string): Promise<boolean>;
+/**
+ * The persistent directory excludes legacy wx-file writers. Only native descriptor authority
+ * permits upgraded mutations; owner.json is disposable evidence, never a liveness oracle.
+ * Never remove the barrier or authority file: doing so would create a second lock universe.
+ */
+export declare function withSessionClaimLock<T>(directory: string, options: ClaimLockOptions, operation: () => Promise<T>): Promise<T>;
+export {};

package/dist/foundation/lifecycle/session-claim-lock.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, readdir, realpath, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { tryAcquireClaimGate } from "./native-claim-gate.js";
+const FILES = new Set(["owner.json", "owner.next", "recovery.json", "recovery.next"]);
+/** Inventory is advisory and read-only, including when abandoned metadata needs recovery. */
+export async function claimMutationPending(directory) {
+    try {
+        const barrier = join(directory, "mutation.lock");
+        const metadata = await lstat(barrier);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink())
+            return true;
+        const files = await readdir(barrier);
+        return files.some(name => name !== "recovery.json");
+    }
+    catch (error) {
+        return !hasCode(error, "ENOENT");
+    }
+}
+/**
+ * The persistent directory excludes legacy wx-file writers. Only native descriptor authority
+ * permits upgraded mutations; owner.json is disposable evidence, never a liveness oracle.
+ * Never remove the barrier or authority file: doing so would create a second lock universe.
+ */
+export async function withSessionClaimLock(directory, options, operation) {
+    options.signal?.throwIfAborted();
+    let canonical;
+    try {
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        canonical = await realpath(directory);
+    }
+    catch (cause) {
+        throw failure("worktree-coordination-io", "cannot access the A1 claim directory; check permissions and filesystem availability", cause);
+    }
+    const authority = join(canonical, "mutation.authority");
+    const barrier = join(canonical, "mutation.lock");
+    const deadline = Date.now() + (options.lockTimeoutMs ?? 2_000);
+    let gate;
+    while (gate === undefined) {
+        options.signal?.throwIfAborted();
+        const acquired = tryAcquireClaimGate(authority);
+        if (acquired !== null) {
+            gate = acquired;
+            break;
+        }
+        if (Date.now() >= deadline)
+            throw failure("worktree-claim-busy", "worktree mutation is temporarily busy; automatic runtime registration will retry, and linking can be retried");
+        await delay(Math.min(20, Math.max(1, deadline - Date.now())), undefined, { signal: options.signal });
+    }
+    let operationStarted = false;
+    try {
+        options.signal?.throwIfAborted();
+        try {
+            await mkdir(barrier, { mode: 0o700 });
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+        const metadata = await lstat(barrier);
+        if (metadata.isSymbolicLink() || (!metadata.isFile() && !metadata.isDirectory())) {
+            throw failure("worktree-coordination-boundary", "worktree mutation barrier is not a regular file or directory; retain it for inspection");
+        }
+        if (metadata.isFile()) {
+            // Security: a new OS gate proves nothing about an older writer that does not participate in it.
+            // Even a dead legacy PID does not exclude a competing legacy reclaimer's rename race.
+            throw failure("worktree-legacy-recovery-required", "legacy worktree lock prevents safe recovery; stop all older A1 processes, back up only session-worktree-claims/mutation.lock while stopped, then start the updated A1; do not delete sessions or worktree claims");
+        }
+        for (const name of await readdir(barrier)) {
+            const entry = await lstat(join(barrier, name));
+            if (!FILES.has(name) || !entry.isFile() || entry.isSymbolicLink()) {
+                throw failure("worktree-coordination-boundary", "unexpected worktree coordination entry; retain it for inspection rather than deleting the claim store");
+            }
+        }
+        const owner = join(barrier, "owner.json");
+        const pending = join(barrier, "owner.next");
+        if (await exists(owner) || await exists(pending)) {
+            // Security: keep one bounded summary, not an accumulating dump of potentially sensitive corrupt bytes.
+            await publish(barrier, "recovery", { reason: "abandoned-mutation-metadata", recoveredAt: new Date().toISOString() });
+            await rm(owner, { force: true });
+            await rm(pending, { force: true });
+        }
+        await publish(barrier, "owner", { generation: randomUUID(), acquiredAt: new Date().toISOString() });
+        try {
+            options.signal?.throwIfAborted();
+            operationStarted = true;
+            return await operation();
+        }
+        finally {
+            // Concurrency: authority is still held; no successor can publish until after this removal completes.
+            await rm(owner, { force: true });
+        }
+    }
+    catch (error) {
+        if (operationStarted)
+            throw error;
+        if (error instanceof Error && (error.name === "AbortError" || ("code" in error && String(error.code).startsWith("worktree-"))))
+            throw error;
+        throw failure("worktree-coordination-io", "worktree coordination I/O failed; check A1 data-directory permissions and filesystem availability, then retry", error);
+    }
+    finally {
+        gate.release();
+    }
+}
+async function publish(directory, name, value) {
+    const pending = join(directory, `${name}.next`);
+    await rm(pending, { force: true });
+    const handle = await open(pending, "wx", 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(value)}\n`);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await rename(pending, join(directory, `${name}.json`));
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+}
+function hasCode(error, code) { return error instanceof Error && "code" in error && error.code === code; }
+function failure(code, message, cause) { return Object.assign(new Error(message, { cause }), { code }); }

package/dist/foundation/lifecycle/session-repository-context.js

@@ -4,6 +4,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { resolveProductPaths } from "./paths.js";
+import { claimMutationPending, withSessionClaimLock } from "./session-claim-lock.js";
 const CONTEXT_SCHEMA = "a1-session-repository-context-v1";
 const RUNTIME_SCHEMA = "a1-session-runtime-v1";
 const CLAIM_SCHEMA = "a1-session-worktree-claim-v1";
@@ -11,8 +12,6 @@ const MAX_RECORD_BYTES = 16 * 1024;
 const MAX_HEADER_BYTES = 64 * 1024;
 const MAX_WORKTREES = 256;
 const GIT_TIMEOUT_MS = 5_000;
-const LOCK_TIMEOUT_MS = 2_000;
-const LOCK_RETRY_MS = 20;
 /** Records without an agent id were written by a single-agent release and belong to its one agent. */
 export const PRIMARY_SESSION_AGENT_ID = "primary";
 const RECORD_FORMAT_VERSION = 2;
@@ -444,104 +443,10 @@ async function executeGit(arguments_, cwd, maxBuffer, signal) {
     return await execute("git", [...arguments_], { cwd, windowsHide: true, timeout: GIT_TIMEOUT_MS, maxBuffer, encoding: "utf8", signal });
 }
 async function mutationLockExists(options) {
-    try {
-        await lstat(join(claimStoreRoot(options), "mutation.lock"));
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return false;
-        return true;
-    }
+    return await claimMutationPending(claimStoreRoot(options));
 }
 async function withClaimLock(options, operation) {
-    const directory = claimStoreRoot(options);
-    await mkdir(directory, { recursive: true, mode: 0o700 });
-    const path = join(directory, "mutation.lock");
-    const deadline = Date.now() + (options.lockTimeoutMs ?? LOCK_TIMEOUT_MS);
-    const holder = await lockHolderIdentity(options);
-    let handle;
-    for (let attempt = 0; handle === undefined; attempt++) {
-        try {
-            handle = await open(path, "wx", 0o600);
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
-                throw error;
-            if (attempt === 0 && await evictDeadLockHolder(path, options))
-                continue;
-            if (Date.now() >= deadline)
-                throw contextError("worktree claim mutation is busy", "worktree-claim-busy");
-            await new Promise(resolvePromise => setTimeout(resolvePromise, LOCK_RETRY_MS));
-        }
-    }
-    try {
-        const record = {
-            pid: process.pid,
-            ...(holder === null ? {} : { startIdentity: holder.startIdentity }),
-            acquiredAt: new Date().toISOString(),
-            nonce: randomUUID(),
-        };
-        await handle.writeFile(`${JSON.stringify(record)}\n`);
-        return await operation();
-    }
-    finally {
-        await handle.close().catch(() => undefined);
-        await rm(path, { force: true }).catch(() => undefined);
-    }
-}
-const lockHolderIdentities = new WeakMap();
-/** This process's identity as recorded in the lock; null leaves the lock unevictable, never wrongly evictable. */
-async function lockHolderIdentity(options) {
-    if (options.runtimeIdentity?.pid === process.pid)
-        return options.runtimeIdentity;
-    const inspection = options.inspectProcess;
-    if (inspection === undefined)
-        return null;
-    let identity = lockHolderIdentities.get(inspection);
-    if (identity === undefined) {
-        identity = inspection(process.pid)
-            .then(observed => observed !== null && observed.pid === process.pid ? observed : null)
-            .catch(() => null);
-        lockHolderIdentities.set(inspection, identity);
-    }
-    return await identity;
-}
-/**
- * Evict the mutation lock only when its recorded holder is proven dead: the pid is gone or now names a process
- * with another start identity. A lock without a holder identity, or a holder that cannot be inspected, is kept.
- */
-async function evictDeadLockHolder(path, options) {
-    const inspection = options.inspectProcess;
-    if (inspection === undefined)
-        return false;
-    const holder = await readJsonRecord(path, isMutationLockRecord);
-    if (holder === null || holder.startIdentity === undefined || holder.pid === process.pid)
-        return false;
-    let observed;
-    try {
-        observed = await inspection(holder.pid);
-    }
-    catch {
-        return false;
-    }
-    if (observed !== null && observed.pid === holder.pid && observed.startIdentity === holder.startIdentity)
-        return false;
-    const evicted = `${path}.${randomUUID()}.evicted`;
-    try {
-        await rename(path, evicted);
-    }
-    catch {
-        return false;
-    }
-    const moved = await readJsonRecord(evicted, isMutationLockRecord);
-    if (moved?.nonce !== holder.nonce) {
-        // Concurrency: another waiter evicted first and a live holder took the lock since; hand it back untouched.
-        await rename(evicted, path).catch(() => undefined);
-        return false;
-    }
-    await rm(evicted, { force: true });
-    return true;
+    return await withSessionClaimLock(claimStoreRoot(options), options, operation);
 }
 async function atomicWrite(path, value) {
     const directory = dirname(path);
@@ -668,12 +573,6 @@ function isStoredClaimRecord(value) {
         && typeof value.startIdentity === "string" && value.startIdentity.length > 0 && value.startIdentity.length <= 512
         && !value.startIdentity.includes("\0") && typeof value.updatedAt === "string";
 }
-function isMutationLockRecord(value) {
-    return isRecord(value) && Number.isSafeInteger(value.pid) && Number(value.pid) > 0
-        && (value.startIdentity === undefined || (typeof value.startIdentity === "string" && value.startIdentity.length > 0
-            && value.startIdentity.length <= 512 && !value.startIdentity.includes("\0")))
-        && typeof value.acquiredAt === "string" && typeof value.nonce === "string" && value.nonce.length > 0;
-}
 function validRecordVersion(value) {
     if (value.formatVersion === undefined)
         return value.agentId === undefined;

package/dist/foundation/release/automatic-update.d.ts

@@ -1,7 +1,7 @@
 import { type AvailableRelease, type ReleaseChannel } from "./latest-release.js";
 export declare const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export declare const AUTOMATIC_UPDATE_RETRY_MS: number;
-export declare const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS: number;
+export declare const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS = 15000;
 export declare const ACTIVE_RELEASE_FALLBACK_MS = 5000;
 export interface AutomaticUpdateState {
     readonly schema: typeof AUTOMATIC_UPDATE_STATE_SCHEMA;

package/dist/foundation/release/automatic-update.js

@@ -15,7 +15,7 @@ import { UpdateTransactionStore } from "./update-transaction.js";
 import { runSelfUpdate, UPDATE_ACTIVATION_BLOCKED_EXIT_CODE, UPDATE_ALREADY_RUNNING_EXIT_CODE } from "./update.js";
 export const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export const AUTOMATIC_UPDATE_RETRY_MS = 24 * 60 * 60_000;
-export const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS = 15 * 60_000;
+export const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS = 15_000;
 const AUTOMATIC_UPDATE_STATE_FILENAME = "automatic-update.json";
 const MAX_STATE_BYTES = 16_384;
 const OBSERVER_POLL_MS = 250;

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

@@ -26,7 +26,7 @@ export type { ProcessRequest, ProcessResult, SelfUpdateOptions, UpdateActivation
 export { UPDATE_ACTIVATION_CONTRACT, UPDATE_ACTIVATION_ENTRY, UPDATE_ACTIVATION_MANIFEST_FIELD, UpdateActivationBlockedError, activateInstalledRelease, delegateActivation, readActivationContracts, runActivationEntry, } from "./update-activation.js";
 export type { UpdateActivationCallbacks, UpdateActivationEvent, UpdateActivationRequest } from "./update-activation.js";
 export { selectSupervisorLaunchReleaseId, selectUpdateLaunchRelease } from "./update-launch.js";
-export { UPDATE_RECOVERY_SCHEMA, cleanupUpdateRecoveryCapsules, inspectUpdateLauncherSet, npmPrefixForGlobalRoot, prepareUpdateRecoveryCapsule, readUpdateRecoveryCapsule, removeUpdateRecoveryCapsule, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
+export { UPDATE_RECOVERY_SCHEMA, cleanupUpdateRecoveryCapsules, inspectUpdateLauncherSet, npmPrefixForGlobalRoot, prepareUpdateRecoveryCapsule, readUpdateRecoveryCapsule, removeUpdateRecoveryCapsule, resolveNpmCli, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
 export type { ProtectedPackageReplacementOptions, ProtectedPackageReplacementResult, UpdateRecoveryCapsule, UpdateRecoveryResult } from "./update-recovery.js";
 export { UPDATE_JOURNAL_SCHEMA, UpdateTransactionStore } from "./update-transaction.js";
 export type { UpdateRecoveryState, UpdateTransaction, UpdateTransactionPhase } from "./update-transaction.js";

package/dist/foundation/release/index.js

@@ -13,6 +13,6 @@ export { STABLE_RELEASE_SCHEMA, createStableReleaseEvidence, verifyStableRegistr
 export { PACKAGE_UNLOCK_PATIENCE_MS, UPDATE_ACTIVATION_BLOCKED_EXIT_CODE, UPDATE_ALREADY_RUNNING_EXIT_CODE, PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, isPackageLockError, lockedPackageDiagnostic, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.js";
 export { UPDATE_ACTIVATION_CONTRACT, UPDATE_ACTIVATION_ENTRY, UPDATE_ACTIVATION_MANIFEST_FIELD, UpdateActivationBlockedError, activateInstalledRelease, delegateActivation, readActivationContracts, runActivationEntry, } from "./update-activation.js";
 export { selectSupervisorLaunchReleaseId, selectUpdateLaunchRelease } from "./update-launch.js";
-export { UPDATE_RECOVERY_SCHEMA, cleanupUpdateRecoveryCapsules, inspectUpdateLauncherSet, npmPrefixForGlobalRoot, prepareUpdateRecoveryCapsule, readUpdateRecoveryCapsule, removeUpdateRecoveryCapsule, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
+export { UPDATE_RECOVERY_SCHEMA, cleanupUpdateRecoveryCapsules, inspectUpdateLauncherSet, npmPrefixForGlobalRoot, prepareUpdateRecoveryCapsule, readUpdateRecoveryCapsule, removeUpdateRecoveryCapsule, resolveNpmCli, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
 export { UPDATE_JOURNAL_SCHEMA, UpdateTransactionStore } from "./update-transaction.js";
 export { warmMaterializedRelease } from "./warmup.js";

package/dist/foundation/release/update.js

@@ -757,7 +757,7 @@ export async function runSelfUpdate(options) {
             const message = errorMessage(error);
             if (error instanceof UpdateAutomaticDeferred)
                 return 1;
-            const blockedExit = await preparedActivationExit(error, transaction, mode, output, transactionStore);
+            const blockedExit = await preparedActivationExit(error, transaction, mode, output, transactionStore, targetVersion, paths.configDir);
             if (blockedExit !== null)
                 return blockedExit;
             if (error instanceof UpdatePreflightFailure) {
@@ -769,7 +769,7 @@ export async function runSelfUpdate(options) {
                 : await rollbackPriorCohort(paths.dataDir, environment, transaction?.priorActiveReleaseId ?? null).catch(rollbackError => `rollback failed: ${errorMessage(rollbackError)}`);
             if (transaction)
                 await transactionStore.finish(rollback === "rolled back" ? "rolled-back" : "failed", `${message}; ${rollback}`);
-            output.stderr(`${PRODUCT_TEXT.diagnostic(`update failed: ${message}. ${rollback}. Diagnostics: ${transactionStore.path}`)}\n`);
+            output.stderr(updateFailureLine(message, rollback, transactionStore.path));
             return error instanceof UpdateFailure ? error.exitCode : 1;
         }
     });
@@ -869,13 +869,22 @@ async function activateUpdateTransaction(lifecycle, transaction, packageRoot, ta
     else
         await lifecycle.activateInstalled(packageRoot, targetVersion, phase, materializing, warmup);
 }
-async function preparedActivationExit(error, transaction, mode, output, journal) {
+async function preparedActivationExit(error, transaction, mode, output, journal, targetVersion, configDir) {
     if (!(error instanceof UpdateActivationBlockedError) || transaction === null || phaseBefore(transaction.phase, "certified"))
         return null;
-    if (mode === "manual")
-        output.stderr(`${PRODUCT_TEXT.diagnostic(`update prepared, but activation is blocked: ${error.message}. The prior client remains selected; run the update again after the resident blocker clears.`)}\n`);
     await journal.recordActiveError?.(error.message);
-    return UPDATE_ACTIVATION_BLOCKED_EXIT_CODE;
+    if (mode === "automatic")
+        return UPDATE_ACTIVATION_BLOCKED_EXIT_CODE;
+    // Invariant: a certified candidate waiting only for resident continuity is an installed update;
+    // the next startup check retries activation without another installation.
+    await invalidateReleaseCheckCache(configDir).catch(() => undefined);
+    output.stdout(`${PRODUCT_TEXT.commandName} updated to ${targetVersion}; it takes over automatically once running Agents can switch\n`);
+    return 0;
+}
+/** One reason and one next step; routine rollback detail stays in the journal. */
+function updateFailureLine(message, rollback, journalPath) {
+    const note = rollback.startsWith("rollback failed") ? ` (${rollback})` : "";
+    return `${PRODUCT_TEXT.diagnostic(`update failed: ${message}${note}. Run ${PRODUCT_TEXT.commandName} update to retry. Details: ${journalPath}`)}\n`;
 }
 function phaseBefore(current, target) {
     const phases = ["shutdown-intent", "ownership-released", "package-installed", "materialized", "certified", "active-reference-committed", "supervisor-verified"];

package/dist/foundation/resident-tabs/boot-identity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mirrors the native boot matching rule. Legacy `macos-boot:<sec>:<usec>` records drift on clock
+ * corrections, so two of them match within the tolerance; only the native host can prove one
+ * against a current identity.
+ */
+export declare function sameBootIdentity(left: string, right: string): boolean;

package/dist/foundation/resident-tabs/boot-identity.js

@@ -0,0 +1,16 @@
+/** Seconds a legacy clock-derived boot identity may drift and still name the same boot. */
+const LEGACY_BOOT_TOLERANCE_SECONDS = 2;
+const LEGACY_MACOS_BOOT = /^macos-boot:(\d+):\d+$/u;
+/**
+ * Mirrors the native boot matching rule. Legacy `macos-boot:<sec>:<usec>` records drift on clock
+ * corrections, so two of them match within the tolerance; only the native host can prove one
+ * against a current identity.
+ */
+export function sameBootIdentity(left, right) {
+    if (left === right)
+        return true;
+    const first = LEGACY_MACOS_BOOT.exec(left)?.[1];
+    const second = LEGACY_MACOS_BOOT.exec(right)?.[1];
+    return first !== undefined && second !== undefined
+        && Math.abs(Number(first) - Number(second)) <= LEGACY_BOOT_TOLERANCE_SECONDS;
+}

package/dist/foundation/resident-tabs/bounded-host-command.d.ts

@@ -2,6 +2,8 @@ import type { TerminalHostCommand } from "./ensure-terminal-host.js";
 export interface BoundedHostCommandResult {
     readonly code: number;
     readonly stdout: string;
+    /** The command's last diagnostic line, bounded and stripped of control characters; never parsed. */
+    readonly stderr: string;
 }
 export interface BoundedHostCommandLimits {
     /** Output beyond this many bytes fails the exchange instead of being parsed. */

package/dist/foundation/resident-tabs/bounded-host-command.js

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+/** Diagnostics beyond this many bytes are dropped rather than buffered. */
+const MAX_STDERR_BYTES = 4096;
 /**
  * Runs one terminal-host command whose report is small. An oversized report kills the command and
  * reports a failed exchange; a command that outlives its deadline is killed and rejected.
@@ -8,9 +10,18 @@ export async function runBoundedHostCommand(command, arguments_, limits) {
         const child = spawn(command.executable, [command.entry, ...arguments_], {
             env: limits.environment,
             windowsHide: true,
-            stdio: ["ignore", "pipe", "ignore"],
+            stdio: ["ignore", "pipe", "pipe"],
         });
         const stdout = [];
+        const stderr = [];
+        let stderrSize = 0;
+        child.stderr.on("data", (chunk) => {
+            if (stderrSize >= MAX_STDERR_BYTES)
+                return;
+            const kept = chunk.subarray(0, MAX_STDERR_BYTES - stderrSize);
+            stderrSize += kept.length;
+            stderr.push(Buffer.from(kept));
+        });
         let size = 0;
         let overflowed = false;
         child.stdout.on("data", chunk => {
@@ -26,9 +37,10 @@ export async function runBoundedHostCommand(command, arguments_, limits) {
         child.once("error", rejectPromise);
         child.once("close", code => {
             clearTimeout(timer);
+            const diagnostic = lastDiagnosticLine(Buffer.concat(stderr).toString("utf8"));
             resolvePromise(overflowed
-                ? { code: code === 0 || code === null ? 1 : code, stdout: "" }
-                : { code: code ?? 1, stdout: Buffer.concat(stdout).toString("utf8") });
+                ? { code: code === 0 || code === null ? 1 : code, stdout: "", stderr: diagnostic }
+                : { code: code ?? 1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: diagnostic });
         });
         const timer = setTimeout(() => {
             child.kill("SIGKILL");
@@ -37,3 +49,14 @@ export async function runBoundedHostCommand(command, arguments_, limits) {
         timer.unref();
     });
 }
+/** Keeps one terminal-safe line: the native host reports its reason last. */
+function lastDiagnosticLine(text) {
+    const lines = text.split(/\r?\n/u)
+        // Security: diagnostics never carry terminal controls into a later message.
+        .map(line => line
+        .replace(/\u001b\[[0-?]*[ -/]*[@-~]/gu, "")
+        .replace(/[\u0000-\u001f\u007f-\u009f]/gu, "")
+        .trim())
+        .filter(line => line.length > 0);
+    return (lines.at(-1) ?? "").slice(0, 300);
+}

package/dist/foundation/resident-tabs/continuity.js

@@ -10,7 +10,7 @@ export async function assertResidentContinuity(options) {
     const first = await inspect(context);
     const second = await inspect(context);
     if (first !== second && second !== await inspect(context)) {
-        throw new Error("Resident workspace changed during update readiness; the prior client remains selected.");
+        throw new Error("Resident workspace changed during update readiness");
     }
 }
 /** Native inspection/import is read-only toward execution and never starts or stops a source. */
@@ -40,16 +40,24 @@ export async function inspectResidentContinuity(options) {
         "workspace-check", "--profile", options.profileRoot,
         "--data-dir", options.dataDir, "--runtime-dir", options.runtimeDir,
     ], { label: "resident continuity check", maxStdoutBytes: 4096, timeoutMs: 8_000, environment: options.environment });
+    const unverified = new Error(continuityFailure(result.stderr));
     let report;
     try {
         report = JSON.parse(result.stdout.trim());
     }
     catch {
-        throw new Error("Resident control compatibility could not be verified; the prior client remains selected.");
+        throw unverified;
     }
     if (result.code !== 0 || report.schema !== "resident-workspace-check-v1" || report.compatible !== true
         || typeof report.fingerprint !== "string" || !/^[a-f0-9]{64}$/u.test(report.fingerprint)) {
-        throw new Error("Resident control compatibility could not be verified; the prior client remains selected.");
+        throw unverified;
     }
     return report.fingerprint;
 }
+/** Names the native reason when the host reported one, without the host's own prefix. */
+function continuityFailure(diagnostic) {
+    const reason = diagnostic.replace(/^a1-terminal-host:\s*/u, "").replace(/[.\s]+$/u, "");
+    return reason.length > 0
+        ? `Resident control compatibility could not be verified: ${reason}`
+        : "Resident control compatibility could not be verified";
+}

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

@@ -1,3 +1,4 @@
+import { sameBootIdentity } from "./boot-identity.js";
 import { runTerminalHostMaintenance } from "./maintenance.js";
 /** Mandatory native control semantics; optional methods never establish source authority. */
 export const RUNTIME_CONTROL_API = "resident-control-v1";
@@ -21,7 +22,7 @@ export function assessRuntimeControl(value, expected) {
         return blocked("invalid-contract");
     }
     if (value.releaseId !== expected.releaseId || value.scope !== expected.scope
-        || value.bootId !== expected.bootId || value.osSessionId !== expected.osSessionId)
+        || !sameBootIdentity(value.bootId, expected.bootId) || value.osSessionId !== expected.osSessionId)
         return blocked("source-mismatch");
     if (value.epoch !== expected.epoch)
         return blocked("stale-epoch");

package/dist/integrations/pi/components/shell-footer-status.js

@@ -7,7 +7,7 @@ import { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
 import { StatusIndicator, WorkingStatusIndicator } from "./upstream/components/status-indicator.js";
 import { protectPiPromptChipPresentation } from "./prompt-chip-presentation.js";
 import { PINNED_PI_LAYOUT, piTheme, } from "./theme.js";
-import { createTuiFacade, ensureTheme, renderPiShellBlockedUpdateStatus, renderPiShellInstalledUpdateStatus, piShellVisibleWidth, } from "./shell-shared-facade.js";
+import { createTuiFacade, ensureTheme, renderPiShellInstalledUpdateStatus, piShellVisibleWidth, } from "./shell-shared-facade.js";
 export function createPiShellHeader(options = {}) {
     ensureTheme();
     let expanded = options.expanded ?? false;
@@ -233,9 +233,7 @@ function appendInstalledUpdateStatus(rows, width, view, progressPresentation) {
         return rows;
     const status = view.diagnostics.some(diagnostic => diagnostic.code === "release-update-installed")
         ? renderPiShellInstalledUpdateStatus(width)
-        : view.diagnostics.some(diagnostic => diagnostic.code === "release-update-blocked")
-            ? renderPiShellBlockedUpdateStatus(width)
-            : "";
+        : "";
     if (status.length === 0)
         return rows;
     const statusWidth = piShellVisibleWidth(status);

package/dist/integrations/pi/components/shell-shared-facade.d.ts

@@ -9,11 +9,8 @@ import { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
 export declare const piShellVisibleWidth: typeof visibleWidth;
 export declare const piShellTruncateToWidth: (text: string, width: number) => string;
 export declare const INSTALLED_UPDATE_STATUS_TEXT = "Update installed, restart to update";
-export declare const BLOCKED_UPDATE_STATUS_TEXT = "Update prepared; activation blocked";
 /** Shared green restart notice for the pinned status and bare-A1 prompt overlay. */
 export declare function renderPiShellInstalledUpdateStatus(width: number): string;
-/** Sanitized warning for a certified candidate that cannot yet preserve resident continuity. */
-export declare function renderPiShellBlockedUpdateStatus(width: number): string;
 /** A clickable URL in pinned Pi's grammar: an OSC 8 link where the terminal supports one, the plain URL otherwise. */
 export declare const piShellHyperlink: (url: string, text?: string) => string;
 export interface PiShellComponentPort extends PresentationComponentPort {

package/dist/integrations/pi/components/shell-shared-facade.js

@@ -5,7 +5,6 @@ import { ensurePiTheme, piTheme, } from "./theme.js";
 export const piShellVisibleWidth = visibleWidth;
 export const piShellTruncateToWidth = (text, width) => truncateToWidth(text, width, "");
 export const INSTALLED_UPDATE_STATUS_TEXT = "Update installed, restart to update";
-export const BLOCKED_UPDATE_STATUS_TEXT = "Update prepared; activation blocked";
 /** Shared green restart notice for the pinned status and bare-A1 prompt overlay. */
 export function renderPiShellInstalledUpdateStatus(width) {
     if (width <= 0)
@@ -13,13 +12,6 @@ export function renderPiShellInstalledUpdateStatus(width) {
     ensurePiTheme();
     return piShellTruncateToWidth(piTheme().fg("success", INSTALLED_UPDATE_STATUS_TEXT), width);
 }
-/** Sanitized warning for a certified candidate that cannot yet preserve resident continuity. */
-export function renderPiShellBlockedUpdateStatus(width) {
-    if (width <= 0)
-        return "";
-    ensurePiTheme();
-    return piShellTruncateToWidth(piTheme().fg("warning", BLOCKED_UPDATE_STATUS_TEXT), width);
-}
 /** A clickable URL in pinned Pi's grammar: an OSC 8 link where the terminal supports one, the plain URL otherwise. */
 export const piShellHyperlink = (url, text = url) => hyperlink(url, text);
 // Provenance: pinned from packages/coding-agent/src/core/slash-commands.ts at 914cf14.