@timurproko/a1 0.2.7-dev.1234 → 0.2.7-dev.1236

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

@@ -1,7 +1,7 @@
 import { COPY_ACKNOWLEDGEMENT_DURATION_MS } from "../../ui/components/selection-copy.js";
 import { renderPiShellCommandMessage, renderPiShellReleaseUpdateBanner, renderPiShellStatusText, } from "../../integrations/pi/components/shell-presenters-info.js";
 import { PINNED_PI_LAYOUT, piTheme } from "../../integrations/pi/components/upstream/theme/theme.js";
-import { piShellTruncateToWidth, renderPiShellInstalledUpdateStatus } from "../../integrations/pi/components/shell-shared-facade.js";
+import { piShellTruncateToWidth, renderPiShellBlockedUpdateStatus, renderPiShellInstalledUpdateStatus } from "../../integrations/pi/components/shell-shared-facade.js";
 import { parseReleaseUpdateDiagnostic } from "./transcript-document.js";
 /**
  * The transient chrome around bare A1's dock: the one command notice above the editor, the release
@@ -84,9 +84,13 @@ export class DockChrome {
         const acknowledgement = this.renderCopyAcknowledgement(width);
         if (acknowledgement !== undefined)
             return acknowledgement;
-        if (!diagnostics.some(diagnostic => diagnostic.code === "release-update-installed"))
-            return undefined;
-        return renderPiShellInstalledUpdateStatus(width) || undefined;
+        if (diagnostics.some(diagnostic => diagnostic.code === "release-update-installed")) {
+            return renderPiShellInstalledUpdateStatus(width) || undefined;
+        }
+        if (diagnostics.some(diagnostic => diagnostic.code === "release-update-blocked")) {
+            return renderPiShellBlockedUpdateStatus(width) || undefined;
+        }
+        return undefined;
     }
     renderReleaseBanner(diagnostics, width) {
         if (this.#releaseDismissed)

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

@@ -261,6 +261,7 @@ export class TranscriptDocument {
         rows.push(...diagnostics
             .filter(diagnostic => diagnostic.code !== "engine-startup" && diagnostic.code !== "project-trust"
             && diagnostic.code !== "release-update" && diagnostic.code !== "release-update-installed"
+            && diagnostic.code !== "release-update-blocked"
             && diagnostic.code !== "package-updates" && diagnostic.code !== "changelog-collapsed"
             && diagnostic.code !== "changelog-expanded")
             .slice(-3)

package/dist/composition/release-update-observation.js

@@ -41,14 +41,22 @@ class ReleaseUpdateObservation {
         }
         if (input.mode !== "auto")
             return;
+        const announce = (status, version) => {
+            const actual = input.clientVersion?.();
+            const key = `${status}:${version}`;
+            if (key === this.#announced || this.#controller.signal.aborted
+                || status !== "blocked-cleared" && actual && !releases.isNewerRelease(version, actual))
+                return;
+            this.#announced = key;
+            input.backend.extensions.announceReleaseUpdate({ status, version });
+        };
         const installed = await import("../foundation/release/automatic-update.js")
-            .then(module => module.requestAutomaticUpdate({ release, runningVersion, signal: this.#controller.signal }));
-        const actual = input.clientVersion?.();
-        if (installed === null || installed === this.#announced || this.#controller.signal.aborted
-            || actual && !releases.isNewerRelease(installed, actual))
-            return;
-        this.#announced = installed;
-        input.backend.extensions.announceReleaseUpdate({ status: "installed", version: installed });
+            .then(module => module.requestAutomaticUpdate({
+            release, runningVersion, signal: this.#controller.signal,
+            onActivationBlocked: version => announce(version === null ? "blocked-cleared" : "blocked", version ?? release.version),
+        }));
+        if (installed !== null)
+            announce("installed", installed);
     }
     async #run() {
         if (this.#running) {

package/dist/contracts/owned-ui/session-workflows.d.ts

@@ -347,6 +347,6 @@ export type OwnedUiReleaseUpdate = {
     readonly command: string;
     readonly changelogUrl: string | null;
 } | {
-    readonly status: "installed";
+    readonly status: "blocked" | "blocked-cleared" | "installed";
     readonly version: string;
 };

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

@@ -1,11 +1,12 @@
 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 interface AutomaticUpdateState {
     readonly schema: typeof AUTOMATIC_UPDATE_STATE_SCHEMA;
     readonly channel: ReleaseChannel;
     readonly targetVersion: string;
-    readonly status: "running" | "installed" | "failed";
+    readonly status: "running" | "blocked" | "installed" | "failed";
     readonly attemptedAt: number;
     readonly updatedAt: number;
     readonly installedVersion: string | null;
@@ -31,6 +32,7 @@ export interface AutomaticUpdateRequestOptions {
         readonly packageRoot: string;
     };
     readonly activeVersion?: () => Promise<string | null>;
+    readonly onActivationBlocked?: (version: string | null) => void;
 }
 /** Start or observe one silent update and resolve with the active newer version once restart is useful. */
 export declare function requestAutomaticUpdate(options: AutomaticUpdateRequestOptions): Promise<string | null>;

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

@@ -11,9 +11,10 @@ import { isNewerRelease, releaseChannelOf } from "./latest-release.js";
 import { readCertifiedReleaseManifest, resolveReleaseEntryPoint } from "./release-store.js";
 import { acquireUpdateExecutionLease, readUpdateExecutionOwner } from "./update-execution-lease.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
-import { runSelfUpdate, UPDATE_ALREADY_RUNNING_EXIT_CODE } from "./update.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;
 const AUTOMATIC_UPDATE_STATE_FILENAME = "automatic-update.json";
 const MAX_STATE_BYTES = 16_384;
 const OBSERVER_POLL_MS = 250;
@@ -104,6 +105,14 @@ export async function requestAutomaticUpdate(options) {
             await store.write(existing).catch(() => undefined);
         }
     }
+    const blockedUpdatedAt = existing?.status === "blocked" && existing.channel === options.release.channel
+        && existing.targetVersion === options.release.version ? existing.updatedAt : null;
+    const observedBlocked = blockedUpdatedAt !== null;
+    if (observedBlocked) {
+        options.onActivationBlocked?.(options.release.version);
+        if (now() - blockedUpdatedAt >= 0 && now() - blockedUpdatedAt < AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS)
+            return null;
+    }
     if (existing?.status === "failed" && existing.channel === options.release.channel && now() - existing.attemptedAt >= 0
         && now() - existing.attemptedAt < AUTOMATIC_UPDATE_RETRY_MS
         && !isNewerRelease(options.release.version, existing.targetVersion))
@@ -136,6 +145,8 @@ export async function requestAutomaticUpdate(options) {
             // Invariant: no worker began this attempt. Do not invent a successful install or an owner.
             await store.write(state({ packageRoot: worker.packageRoot, channel: options.release.channel,
                 targetVersion: options.release.version, dataDir: paths.dataDir }, "failed", now(), null, "worker-start-failed")).catch(() => undefined);
+            if (observedBlocked)
+                options.onActivationBlocked?.(null);
             return null;
         }
     }
@@ -149,8 +160,15 @@ export async function requestAutomaticUpdate(options) {
         if (installed !== null)
             return installed;
         const state = await store.read().catch(() => null);
-        if (state?.targetVersion === options.release.version && state.status === "failed" && state.attemptedAt >= startedAt)
+        if (state?.targetVersion === options.release.version && state.status === "blocked") {
+            options.onActivationBlocked?.(state.targetVersion);
             return null;
+        }
+        if (state?.targetVersion === options.release.version && state.status === "failed" && state.attemptedAt >= startedAt) {
+            if (observedBlocked)
+                options.onActivationBlocked?.(null);
+            return null;
+        }
         const owner = await readUpdateExecutionOwner(paths.dataDir).catch(() => null);
         if ((owner === null || !processIsAlive(owner.pid)) && now() - startedAt >= WORKER_START_GRACE_MS)
             return null;
@@ -200,6 +218,12 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
         });
         if (code === UPDATE_ALREADY_RUNNING_EXIT_CODE)
             return 0;
+        if (code === UPDATE_ACTIVATION_BLOCKED_EXIT_CODE) {
+            await runningWrite;
+            if (acquired)
+                await store.write(state(parsed, "blocked", attemptedAt, null, "resident-continuity-blocked"));
+            return code;
+        }
         if (code !== 0) {
             await runningWrite;
             if (acquired)
@@ -313,10 +337,11 @@ function parseWorkerArguments(argv) {
 }
 function validateState(value) {
     if (value.schema !== AUTOMATIC_UPDATE_STATE_SCHEMA || (value.channel !== "stable" && value.channel !== "development")
-        || validSemver(value.targetVersion) === null || !["running", "installed", "failed"].includes(value.status)
+        || validSemver(value.targetVersion) === null || !["running", "blocked", "installed", "failed"].includes(value.status)
         || !Number.isFinite(value.attemptedAt) || !Number.isFinite(value.updatedAt)
         || (value.installedVersion !== null && validSemver(value.installedVersion) === null)
-        || (value.failure !== null && (typeof value.failure !== "string" || value.failure.length > 512))) {
+        || (value.failure !== null && (typeof value.failure !== "string" || value.failure.length > 512))
+        || value.status === "blocked" && (value.installedVersion !== null || value.failure !== "resident-continuity-blocked")) {
         throw new Error("invalid automatic update state");
     }
 }

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

@@ -21,9 +21,9 @@ export { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDoc
 export type { RestartSeal, RestartValidationEvent } from "./restart-certification.js";
 export { STABLE_RELEASE_SCHEMA, createStableReleaseEvidence, verifyStableRegistry } from "./stable-release.js";
 export type { StableRegistryState, StableRegistryVerificationOptions, StableReleaseEvidence, StableReleaseEvidenceInput } from "./stable-release.js";
-export { PACKAGE_UNLOCK_PATIENCE_MS, UPDATE_ALREADY_RUNNING_EXIT_CODE, PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, isPackageLockError, lockedPackageDiagnostic, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.js";
+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 type { ProcessRequest, ProcessResult, SelfUpdateOptions, UpdateActivationPhase, UpdateChannel, UpdateFileMetadata, UpdateFileSystem, UpdateLifecycleCoordinator, UpdateMaterializationProgress, UpdateMeasuredPhase, UpdateOutput, UpdateOwnershipAction, UpdatePackageReplacementInput, UpdatePerformanceEvidence, UpdatePhaseTimingEvent, UpdateProcessRunner, UpdateTransactionJournal, UpdateUnlockPatience, } from "./update.js";
-export { UPDATE_ACTIVATION_CONTRACT, UPDATE_ACTIVATION_ENTRY, UPDATE_ACTIVATION_MANIFEST_FIELD, activateInstalledRelease, delegateActivation, readActivationContracts, runActivationEntry, } from "./update-activation.js";
+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";

package/dist/foundation/release/index.js

@@ -10,8 +10,8 @@ export { collectRelease, prepareReleaseCleanup, runBoundedReleaseCleanup, runRel
 export { RELEASE_MANIFEST_FILENAME, ReleaseRepairUnavailableError, assertCertifiedFilesPresent, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, repairMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease, } from "./release-store.js";
 export { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument, restartSealDigest } from "./restart-certification.js";
 export { STABLE_RELEASE_SCHEMA, createStableReleaseEvidence, verifyStableRegistry } from "./stable-release.js";
-export { PACKAGE_UNLOCK_PATIENCE_MS, 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, activateInstalledRelease, delegateActivation, readActivationContracts, runActivationEntry, } from "./update-activation.js";
+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_JOURNAL_SCHEMA, UpdateTransactionStore } from "./update-transaction.js";

package/dist/foundation/release/prepared-update-activation.d.ts

@@ -0,0 +1,3 @@
+import { type UpdateActivationCallbacks, type UpdateActivationRequest } from "./update-activation.js";
+/** Retry only the selection boundary for an exact candidate already materialized and certified. */
+export declare function activatePreparedRelease(request: Omit<UpdateActivationRequest, "packageRoot">, callbacks: UpdateActivationCallbacks): Promise<void>;

package/dist/foundation/release/prepared-update-activation.js

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { assertContinuityOrBlock } from "./update-activation.js";
+import { ensureSupervisor } from "./bootstrap.js";
+import { CohortStateStore } from "./cohort-state.js";
+import { resolveProductPaths } from "../lifecycle/index.js";
+import { readCertifiedReleaseManifest } from "./release-store.js";
+/** Retry only the selection boundary for an exact candidate already materialized and certified. */
+export async function activatePreparedRelease(request, callbacks) {
+    const stateStore = new CohortStateStore(request.dataDir);
+    const state = await stateStore.read();
+    const releaseId = state.references.pending;
+    const record = releaseId === null ? undefined : state.releases[releaseId];
+    if (record === undefined || record.approval !== "approved" || record.packageVersion !== request.targetVersion
+        || state.references.approved !== releaseId) {
+        throw new Error(`no certified prepared release matches target ${request.targetVersion}`);
+    }
+    const candidate = await readCertifiedReleaseManifest(record, resolve(request.dataDir, "releases"));
+    const paths = resolveProductPaths(request.environment);
+    const continuity = { releaseRoot: candidate.releaseRoot, dataDir: request.dataDir, environment: request.environment,
+        profileRoot: request.environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir, runtimeDir: paths.runtimeDir };
+    await assertContinuityOrBlock(continuity);
+    await ensureSupervisor(candidate, request.environment);
+    await assertContinuityOrBlock(continuity);
+    await stateStore.activate(candidate.releaseId);
+    await callbacks.phase("active-reference-committed");
+}

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

@@ -1,3 +1,4 @@
+import type { ContinuityOptions } from "../resident-tabs/index.js";
 /**
  * The one activation contract an installed tree can offer the updater that installed it.
  * The updater knows nothing else about the tree: the manifest names the contracts the tree
@@ -8,6 +9,10 @@ export declare const UPDATE_ACTIVATION_ENTRY = "bin/activate.js";
 /** Manifest field listing the activation contracts an installed tree serves. */
 export declare const UPDATE_ACTIVATION_MANIFEST_FIELD = "updateActivationContracts";
 export type UpdateActivationPhase = "materialized" | "certified" | "active-reference-committed";
+/** A certified candidate is safe to retain, but resident control continuity blocks selection. */
+export declare class UpdateActivationBlockedError extends Error {
+    readonly code: "resident-continuity-blocked";
+}
 /**
  * Copying the release is the longest step with nothing to say for itself, so it
  * reports the files it has written against the files it must write. A caller that
@@ -44,6 +49,7 @@ export type UpdateActivationEvent = {
 } | {
     readonly event: "failed";
     readonly message: string;
+    readonly code?: UpdateActivationBlockedError["code"];
 };
 /**
  * Activate the installed tree at `packageRoot` with this process's own release code:
@@ -70,3 +76,4 @@ export declare function delegateActivation(request: UpdateActivationRequest, cal
 export declare function runActivationEntry(argv: readonly string[], entryUrl: string, io?: {
     write(line: string): void;
 }, environment?: NodeJS.ProcessEnv): Promise<number>;
+export declare function assertContinuityOrBlock(context: ContinuityOptions): Promise<void>;

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

@@ -19,6 +19,10 @@ export const UPDATE_ACTIVATION_ENTRY = "bin/activate.js";
 /** Manifest field listing the activation contracts an installed tree serves. */
 export const UPDATE_ACTIVATION_MANIFEST_FIELD = "updateActivationContracts";
 const ACTIVATION_DIAGNOSTIC_LIMIT = 2_000;
+/** A certified candidate is safe to retain, but resident control continuity blocks selection. */
+export class UpdateActivationBlockedError extends Error {
+    code = "resident-continuity-blocked";
+}
 /**
  * Activate the installed tree at `packageRoot` with this process's own release code:
  * materialize it into the immutable store, certify, warm, verify supervision, and only
@@ -51,14 +55,16 @@ export async function activateInstalledRelease(request, callbacks) {
     callbacks.onWarmup?.("started");
     await warmMaterializedRelease(candidate, request.environment);
     callbacks.onWarmup?.("completed");
-    const { assertResidentContinuity } = await import("../resident-tabs/index.js");
+    await completeActivation(candidate, request, callbacks, stateStore);
+}
+async function completeActivation(candidate, request, callbacks, stateStore) {
     const paths = resolveProductPaths(request.environment);
     const continuity = { releaseRoot: candidate.releaseRoot, dataDir: request.dataDir, environment: request.environment,
         profileRoot: request.environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir, runtimeDir: paths.runtimeDir };
-    await assertResidentContinuity(continuity);
+    await assertContinuityOrBlock(continuity);
     await ensureSupervisor(candidate, request.environment);
     // Invariant: revalidate after supervision, before committing client activation or restart readiness.
-    await assertResidentContinuity(continuity);
+    await assertContinuityOrBlock(continuity);
     await stateStore.activate(candidate.releaseId);
     await callbacks.phase("active-reference-committed");
 }
@@ -102,14 +108,14 @@ export async function delegateActivation(request, callbacks) {
             events = decoder.push(chunk);
         }
         catch (error) {
-            failure ??= errorMessage(error);
+            failure ??= new Error(errorMessage(error));
             return;
         }
         for (const event of events) {
             relay = relay.then(async () => {
                 const parsed = parseActivationEvent(event);
                 if (!parsed) {
-                    failure ??= `unrecognized activation event ${JSON.stringify(event).slice(0, 200)}`;
+                    failure ??= new Error(`unrecognized activation event ${JSON.stringify(event).slice(0, 200)}`);
                     return;
                 }
                 if (parsed.event === "materializing")
@@ -121,8 +127,10 @@ export async function delegateActivation(request, callbacks) {
                 else if (parsed.event === "completed")
                     completed = true;
                 else
-                    failure ??= parsed.message;
-            }).catch(error => { failure ??= errorMessage(error); });
+                    failure ??= parsed.code === "resident-continuity-blocked"
+                        ? new UpdateActivationBlockedError(parsed.message)
+                        : new Error(parsed.message);
+            }).catch(error => { failure ??= new Error(errorMessage(error)); });
         }
     });
     const exit = await new Promise((resolvePromise, rejectPromise) => {
@@ -131,7 +139,7 @@ export async function delegateActivation(request, callbacks) {
     });
     await relay;
     if (failure)
-        throw new Error(failure);
+        throw failure;
     if (exit.code !== 0 || !completed) {
         const status = exit.code === null ? exit.signal ?? "unknown status" : `status ${exit.code}`;
         throw new Error(`installed release activation exited with ${status}${summarize(diagnostics)}`);
@@ -160,7 +168,7 @@ export async function runActivationEntry(argv, entryUrl, io = { write: line => p
         return 0;
     }
     catch (error) {
-        emit({ event: "failed", message: errorMessage(error) });
+        emit({ event: "failed", message: errorMessage(error), ...(error instanceof UpdateActivationBlockedError ? { code: error.code } : {}) });
         return 1;
     }
 }
@@ -198,11 +206,22 @@ function parseActivationEvent(value) {
         case "completed":
             return { event: "completed" };
         case "failed":
-            return typeof record.message === "string" ? { event: "failed", message: record.message } : null;
+            return typeof record.message === "string" && (record.code === undefined || record.code === "resident-continuity-blocked")
+                ? { event: "failed", message: record.message, ...(record.code === undefined ? {} : { code: record.code }) }
+                : null;
         default:
             return null;
     }
 }
+export async function assertContinuityOrBlock(context) {
+    const { assertResidentContinuity } = await import("../resident-tabs/index.js");
+    try {
+        await assertResidentContinuity(context);
+    }
+    catch (error) {
+        throw new UpdateActivationBlockedError(errorMessage(error), { cause: error });
+    }
+}
 function summarize(text) {
     const lines = text.split(/\r?\n/).map(line => line.trim()).filter(line => line.length > 0);
     return lines.length === 0 ? "" : `: ${lines.slice(0, 4).join(" | ")}`;

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

@@ -37,6 +37,7 @@ export declare class UpdateTransactionStore {
     }): Promise<UpdateTransaction>;
     advance(phase: UpdateTransactionPhase): Promise<UpdateTransaction>;
     setRecovery(recovery: UpdateRecoveryState): Promise<UpdateTransaction>;
+    recordActiveError(error: string): Promise<UpdateTransaction>;
     finish(status: "completed" | "rolled-back" | "failed", error?: string | null): Promise<UpdateTransaction>;
     clearCompleted(): Promise<void>;
 }

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

@@ -49,6 +49,10 @@ export class UpdateTransactionStore {
         const current = await this.#requiredActive();
         return await this.#write({ ...current, recovery, updatedAt: new Date().toISOString() });
     }
+    async recordActiveError(error) {
+        const current = await this.#requiredActive();
+        return await this.#write({ ...current, error: error.replace(/[\r\n]+/gu, " ").slice(0, 2_000), updatedAt: new Date().toISOString() });
+    }
     async finish(status, error = null) {
         const current = await this.read();
         if (!current)
@@ -89,6 +93,7 @@ function validate(value) {
     if (value.schema !== UPDATE_JOURNAL_SCHEMA || typeof value.transactionId !== "string" || !["stable", "next"].includes(value.channel)
         || typeof value.targetVersion !== "string" || typeof value.packageRoot !== "string" || typeof value.startedAt !== "string"
         || typeof value.updatedAt !== "string" || phaseOrder(value.phase) < 0 || !["active", "completed", "rolled-back", "failed"].includes(value.status)
+        || (value.error !== null && (typeof value.error !== "string" || value.error.length > 2_000))
         || (value.recovery !== undefined && !validRecovery(value.recovery))) {
         throw new Error(`invalid ${PRODUCT_TEXT.displayName} update transaction journal`);
     }

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

@@ -95,6 +95,7 @@ export interface UpdateLifecycleCoordinator {
     }>;
     verifyPackageUnlocked(packageRoot: string): Promise<void>;
     activateInstalled(packageRoot: string, targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>, onMaterializing?: (progress: UpdateMaterializationProgress) => void, onWarmup?: (state: "started" | "completed") => void): Promise<void>;
+    activatePrepared?(targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>): Promise<void>;
 }
 export interface UpdateTransactionJournal {
     readonly path: string;
@@ -107,6 +108,7 @@ export interface UpdateTransactionJournal {
     }): Promise<UpdateTransaction>;
     advance(phase: UpdateTransactionPhase): Promise<UpdateTransaction>;
     setRecovery?(recovery: UpdateRecoveryState): Promise<UpdateTransaction>;
+    recordActiveError?(error: string): Promise<UpdateTransaction>;
     finish(status: "completed" | "rolled-back" | "failed", error?: string | null): Promise<UpdateTransaction>;
     clearCompleted(): Promise<void>;
 }
@@ -134,6 +136,7 @@ export interface UpdatePackageReplacementInput {
  */
 export declare const PACKAGE_UNLOCK_PATIENCE_MS = 15000;
 export declare const UPDATE_ALREADY_RUNNING_EXIT_CODE = 75;
+export declare const UPDATE_ACTIVATION_BLOCKED_EXIT_CODE = 76;
 /** Whether a rename failure means something holds the tree, as opposed to the tree being wrong. */
 export declare function isPackageLockError(error: unknown): boolean;
 /** What the user reads when the package stayed held for the whole patience window. */

package/dist/foundation/release/update.js

@@ -16,7 +16,7 @@ import { CohortStateStore } from "./cohort-state.js";
 import { cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
 import { materializeRelease, readMaterializedRelease } from "./release-store.js";
 import { scheduleReleaseCleanup } from "./release-gc.js";
-import { UPDATE_ACTIVATION_CONTRACT, activateInstalledRelease, delegateActivation, readActivationContracts, } from "./update-activation.js";
+import { UPDATE_ACTIVATION_CONTRACT, UpdateActivationBlockedError, activateInstalledRelease, delegateActivation, readActivationContracts, } from "./update-activation.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
 import { acquireUpdateExecutionLease, reclaimDeadLease } from "./update-execution-lease.js";
 import { npmPrefixForGlobalRoot, removeUpdateRecoveryCapsule, resolveNpmCli, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
@@ -37,6 +37,7 @@ const defaultFileSystem = {
  */
 export const PACKAGE_UNLOCK_PATIENCE_MS = 15_000;
 export const UPDATE_ALREADY_RUNNING_EXIT_CODE = 75;
+export const UPDATE_ACTIVATION_BLOCKED_EXIT_CODE = 76;
 /** A named preview reads the registry's whole package document, which is larger than a dist-tag lookup. */
 const PREVIEW_LOOKUP_TIMEOUT_MS = 30_000;
 const PACKAGE_UNLOCK_INITIAL_DELAY_MS = 100;
@@ -225,11 +226,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         },
         async activateInstalled(packageRoot, targetVersion, phase, onMaterializing, onWarmup) {
             const request = { packageRoot, dataDir: paths.dataDir, targetVersion, environment };
-            const callbacks = {
-                phase,
-                ...(onMaterializing ? { onMaterializing } : {}),
-                ...(onWarmup ? { onWarmup } : {}),
-            };
+            const callbacks = { phase, ...(onMaterializing ? { onMaterializing } : {}), ...(onWarmup ? { onWarmup } : {}) };
             // Compatibility: the tree npm just installed is newer than this updater, so its layout is
             // its own to know. A tree that serves the contract activates itself with its own code;
             // a tree from before the contract is activated here, with the layout it had then.
@@ -239,8 +236,13 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             else
                 await activateInstalledRelease(request, callbacks);
         },
+        async activatePrepared(targetVersion, phase) { await retryPreparedActivation(paths.dataDir, environment, targetVersion, phase); },
     };
 }
+async function retryPreparedActivation(dataDir, environment, targetVersion, phase) {
+    await (await import("./prepared-update-activation.js"))
+        .activatePreparedRelease({ dataDir, targetVersion, environment }, { phase });
+}
 const PROGRESS_BAR_WIDTH = 38;
 const PROGRESS_TICK_MS = 200;
 /**
@@ -716,16 +718,14 @@ export async function runSelfUpdate(options) {
             await measure("ownership-release", async () => { await lifecycle.shutdownVerifiedOwners(targetVersion); });
             progress.set(75, MATERIALIZE_PROGRESS.from);
             let activationPhaseStartedAt = now();
-            await lifecycle.activateInstalled(packageRoot, targetVersion, async (phase) => {
+            const recordActivationPhase = async (phase) => {
                 options.onPhaseTiming?.({ phase, durationMs: Math.max(0, now() - activationPhaseStartedAt) });
                 transaction = await transactionStore.advance(phase);
                 progress.set(ACTIVATION_PROGRESS[phase].at, ACTIVATION_PROGRESS[phase].creepTo);
                 activationPhaseStartedAt = now();
-            }, ({ completed, total }) => {
-                const span = MATERIALIZE_PROGRESS.to - MATERIALIZE_PROGRESS.from;
-                const done = total > 0 ? Math.min(1, completed / total) : 0;
-                progress.set(MATERIALIZE_PROGRESS.from + span * done);
-            }, state => {
+            };
+            await activateUpdateTransaction(lifecycle, transaction, packageRoot, targetVersion, recordActivationPhase, ({ completed, total }) => progress.set(MATERIALIZE_PROGRESS.from
+                + (MATERIALIZE_PROGRESS.to - MATERIALIZE_PROGRESS.from) * (total > 0 ? Math.min(1, completed / total) : 0)), state => {
                 if (state === "started") {
                     activationPhaseStartedAt = now();
                     progress.set(98, 99);
@@ -757,6 +757,9 @@ export async function runSelfUpdate(options) {
             const message = errorMessage(error);
             if (error instanceof UpdateAutomaticDeferred)
                 return 1;
+            const blockedExit = await preparedActivationExit(error, transaction, mode, output, transactionStore);
+            if (blockedExit !== null)
+                return blockedExit;
             if (error instanceof UpdatePreflightFailure) {
                 output.stderr(`${PRODUCT_TEXT.diagnostic(`update could not start safely: ${message}. Nothing was changed. Retry with npm x -y -- ${PRODUCT_PACKAGE}-install`)}\n`);
                 return 1;
@@ -859,6 +862,21 @@ async function rollbackPriorCohort(dataDir, environment, priorReleaseId) {
     await ensureSupervisor(release, environment);
     return "rolled back";
 }
+async function activateUpdateTransaction(lifecycle, transaction, packageRoot, targetVersion, phase, materializing, warmup) {
+    if (!phaseBefore(transaction.phase, "certified") && phaseBefore(transaction.phase, "active-reference-committed")
+        && lifecycle.activatePrepared !== undefined)
+        await lifecycle.activatePrepared(targetVersion, phase);
+    else
+        await lifecycle.activateInstalled(packageRoot, targetVersion, phase, materializing, warmup);
+}
+async function preparedActivationExit(error, transaction, mode, output, journal) {
+    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;
+}
 function phaseBefore(current, target) {
     const phases = ["shutdown-intent", "ownership-released", "package-installed", "materialized", "certified", "active-reference-committed", "supervisor-verified"];
     return phases.indexOf(current) < phases.indexOf(target);

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, renderPiShellInstalledUpdateStatus, piShellVisibleWidth, } from "./shell-shared-facade.js";
+import { createTuiFacade, ensureTheme, renderPiShellBlockedUpdateStatus, renderPiShellInstalledUpdateStatus, piShellVisibleWidth, } from "./shell-shared-facade.js";
 export function createPiShellHeader(options = {}) {
     ensureTheme();
     let expanded = options.expanded ?? false;
@@ -229,10 +229,15 @@ function statusSignature(view, workingOverride, outputPad, placement, progressPr
     return `${placement}\u0000${outputPad}\u0000${view.lifecycle}\u0000${progressPresentation}\u0000${message}\u0000${view.status.diagnostics.at(-1) ?? ""}`;
 }
 function appendInstalledUpdateStatus(rows, width, view, progressPresentation) {
-    if (progressPresentation === "custom-viewport" || width <= 0
-        || !view.diagnostics.some(diagnostic => diagnostic.code === "release-update-installed"))
+    if (progressPresentation === "custom-viewport" || width <= 0)
+        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 status = renderPiShellInstalledUpdateStatus(width);
     const statusWidth = piShellVisibleWidth(status);
     const target = rows.findLastIndex(row => piShellVisibleWidth(row.trimEnd()) > 0);
     if (target < 0)

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

@@ -9,8 +9,11 @@ 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,6 +5,7 @@ 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)
@@ -12,6 +13,13 @@ 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.

package/dist/integrations/pi/engine/adapter.js

@@ -217,9 +217,17 @@ export class PiEngineAdapter {
             return;
         }
         if (release.status === "installed") {
+            this.#state.diagnosticsState.clearCodes(["release-update-installed", "release-update-blocked"]);
             this.#addDiagnostic("info", "release-update-installed", `Update ${release.version} installed; restart to update.`, true);
         }
-        else {
+        else if (release.status === "blocked") {
+            this.#state.diagnosticsState.clearCodes(["release-update-installed", "release-update-blocked"]);
+            this.#addDiagnostic("info", "release-update-blocked", `Update ${release.version} prepared; activation blocked.`, true);
+        }
+        else if (release.status === "blocked-cleared") {
+            this.#state.diagnosticsState.clearCodes(["release-update-blocked"]);
+        }
+        else if (release.status === undefined || release.status === "available") {
             const changelog = release.changelogUrl === null ? "" : `\nChangelog: ${release.changelogUrl}`;
             this.#addDiagnostic("info", "release-update", `New version ${release.version} is available. Run ${release.command}${changelog}`, true);
         }

package/dist/integrations/pi/engine/diagnostics-state.d.ts

@@ -5,5 +5,6 @@ export declare class EngineDiagnostics {
     get values(): readonly OwnedUiDiagnostics[];
     get messages(): readonly string[];
     record(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): OwnedUiDiagnostics;
+    clearCodes(codes: readonly string[]): boolean;
     acknowledgeClientVersion(version: string): boolean;
 }

package/dist/integrations/pi/engine/diagnostics-state.js

@@ -14,14 +14,27 @@ export class EngineDiagnostics {
         this.#messages = [...this.#messages, message].slice(-8);
         return diagnostic;
     }
+    clearCodes(codes) {
+        const selected = new Set(codes);
+        return this.#remove(diagnostic => selected.has(diagnostic.code));
+    }
     acknowledgeClientVersion(version) {
         if (validSemver(version) === null)
             return false;
+        return this.#remove(diagnostic => {
+            const target = diagnostic.code === "release-update-installed"
+                ? /^Update (\S+) installed; restart to update\.$/u.exec(diagnostic.message)?.[1]
+                : diagnostic.code === "release-update-blocked"
+                    ? /^Update (\S+) prepared; activation blocked\.$/u.exec(diagnostic.message)?.[1]
+                    : undefined;
+            return target !== undefined && validSemver(target) !== null && gte(version, target);
+        });
+    }
+    #remove(predicate) {
         const removed = new Set();
         for (let index = this.#values.length - 1; index >= 0; index--) {
             const diagnostic = this.#values[index];
-            const installed = diagnostic.code === "release-update-installed" ? /^Update (\S+) installed; restart to update\.$/u.exec(diagnostic.message)?.[1] : undefined;
-            if (installed !== undefined && validSemver(installed) !== null && gte(version, installed)) {
+            if (predicate(diagnostic)) {
                 removed.add(diagnostic.message);
                 this.#values.splice(index, 1);
             }

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

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:20:07.813Z",
+  "builtAt": "2026-11-03T12:34:41.201Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "a87eaaffcd986b624c8b044b756446cc1bdaf4334a1775b97820542fe34f9fb7",

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

@@ -9,11 +9,11 @@
   "architecture": "arm64",
   "target": "aarch64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:22:58.021Z",
+  "builtAt": "2026-11-03T12:38:29.199Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "61ed28a1cb8a7e65c8b963a672917864b607f12b418468700e214663b9506b61",
-    "size": 6566864
+    "sha256": "f340571d5eef45a551e7c53f8c31d91dd75c948fe11c97bda0c23a2d9bbfa2a4",
+    "size": 6585248
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:20:14.161Z",
+  "builtAt": "2026-11-03T12:34:49.251Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "783a65f0de287a1c02cd5429dbe97bc8633f4cc8a7b92e3e961180b9bdcff814",

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

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:25:42.863Z",
+  "builtAt": "2026-11-03T12:41:50.549Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "4e257b645cda56dce14b3c442b673da98049ec91fa7d8c7cd7d265ddd61d9c5b",
-    "size": 7159480
+    "sha256": "92cceb0cf8a8b955b86762fc677396586f0e32569923827a96281fc5a29a3add",
+    "size": 7173680
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,7 +7,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:19:45.383Z",
+  "builtAt": "2026-11-03T12:33:48.123Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "118e5954e3864672bd8482ab7edf419cb27dcdf2533720316979b7f5cc5a53a5",

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

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-unknown-linux-gnu",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:23:17.644Z",
+  "builtAt": "2026-11-03T12:37:02.302Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "913e106efd96c5d59b33cdeea2261873a1e4a1bb73b3e94fbb847c6af5f941ba",
-    "size": 7936048
+    "sha256": "e5d97e8f613e7ca960f541861f9ae61435fb5e1cff1a5e80e34000665e5afecf",
+    "size": 7954680
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,10 +7,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:20:55.204Z",
+  "builtAt": "2026-11-03T12:34:57.755Z",
   "artifact": {
     "filename": "process-guardian.node",
-    "sha256": "f20404d4aba004e8c9e48150360f88c2d1a82814ef63205fa36927073f0d5feb",
+    "sha256": "037cc7426ed420a010993dcd7fda7001707fc87d0c6104f93c01e32c789bd748",
     "size": 402432
   },
   "provenance": {

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

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-pc-windows-msvc",
   "capability": "supported",
-  "builtAt": "2026-11-03T09:24:46.830Z",
+  "builtAt": "2026-11-03T12:36:35.360Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "e2f95819afd458d162b02a28f0d27f021609451dd87e98822aa05a443650972c",
-    "size": 7048192
+    "sha256": "2dd46801648d082efbf5c6122ed76a059a6fee052ca0364dea517ddb3f1f6ba9",
+    "size": 7071232
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.2.7-dev.1234",
+  "version": "0.2.7-dev.1236",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",
@@ -123,7 +123,7 @@
     "@mariozechner/clipboard": "^0.3.9"
   },
   "publication": {
-    "source": "47164524aec4085b000995eb692875e4ab80b190",
-    "pullRequest": 859
+    "source": "ebe579aafe67e84a7d77b1769d8e8a972d5a30dc",
+    "pullRequest": 861
   }
 }