@timurproko/a1 0.2.6 → 0.2.7-dev.1221

package/dist/foundation/release/early-accent.d.ts

@@ -0,0 +1,12 @@
+type UiAccentColor = "blue" | "purple" | "cyan" | "green" | "orange" | "pink";
+export type EarlyAccentAppearance = "dark" | "light";
+export type EarlyAccentMode = "truecolor" | "256color";
+/** Read only global profile data, never project settings or the interactive resource pipeline. */
+export declare function resolveEarlyAccentColor(environment?: NodeJS.ProcessEnv, home?: () => string): UiAccentColor;
+export declare function earlyAccentPalette(color: UiAccentColor, appearance?: EarlyAccentAppearance, mode?: EarlyAccentMode): {
+    readonly accent: string;
+    readonly border: string;
+};
+export declare function earlyTerminalAppearance(environment?: NodeJS.ProcessEnv): EarlyAccentAppearance;
+export declare function earlyTerminalColorMode(environment?: NodeJS.ProcessEnv): EarlyAccentMode;
+export {};

package/dist/foundation/release/early-accent.js

@@ -0,0 +1,59 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { SHARED_PROGRESS_PALETTE } from "./progress-palette.generated.js";
+const MAX_SETTINGS_BYTES = 256 * 1024;
+/** Read only global profile data, never project settings or the interactive resource pipeline. */
+export function resolveEarlyAccentColor(environment = process.env, home = homedir) {
+    try {
+        const selectedHome = environment[PRODUCT_IDENTITY.environment.profileHome] ?? home();
+        if (!isAbsolute(selectedHome) || selectedHome.includes("\0"))
+            return "blue";
+        const file = join(selectedHome, PRODUCT_IDENTITY.state.piAgentProfile, "settings.json");
+        if (statSync(file).size > MAX_SETTINGS_BYTES)
+            return "blue";
+        const raw = readFileSync(file, "utf8");
+        if (Buffer.byteLength(raw, "utf8") > MAX_SETTINGS_BYTES)
+            return "blue";
+        const root = JSON.parse(raw.replace(/^\uFEFF/u, ""));
+        if (!isRecord(root))
+            return "blue";
+        const namespace = root[PRODUCT_IDENTITY.commandName];
+        if (!isRecord(namespace))
+            return "blue";
+        const value = namespace.accentColor;
+        if (value === "default")
+            return "purple"; // Compatibility: preserve explicitly saved legacy defaults.
+        return isAccentColor(value) ? value : "blue";
+    }
+    catch {
+        return "blue";
+    }
+}
+export function earlyAccentPalette(color, appearance = "dark", mode = "truecolor") {
+    return SHARED_PROGRESS_PALETTE[color][appearance][mode];
+}
+export function earlyTerminalAppearance(environment = process.env) {
+    const index = Number.parseInt((environment.COLORFGBG ?? "").split(";").at(-1) ?? "", 10);
+    return Number.isInteger(index) && (index === 7 || index === 15 || index >= 231) ? "light" : "dark";
+}
+export function earlyTerminalColorMode(environment = process.env) {
+    if (environment.PI_TRUE_COLOR === "1")
+        return "truecolor";
+    if (environment.PI_TRUE_COLOR === "0")
+        return "256color";
+    const program = (environment.TERM_PROGRAM ?? "").toLowerCase();
+    const known = ["kitty", "ghostty", "wezterm", "rex", "warpterminal", "iterm.app", "alacritty", "vscode", "zed"];
+    const trueColor = /^(truecolor|24bit)$/iu.test(environment.COLORTERM ?? "")
+        || (environment.TERM ?? "").endsWith("-direct")
+        || process.platform === "win32" || environment.WT_SESSION !== undefined
+        || known.includes(program);
+    return trueColor ? "truecolor" : "256color";
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isAccentColor(value) {
+    return typeof value === "string" && Object.hasOwn(SHARED_PROGRESS_PALETTE, value);
+}

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

@@ -15,13 +15,13 @@ export { PRODUCT_PACKAGE_NAME, createReleaseIdentity, deriveReleaseIdentity, dig
 export type { DiscoverReleasePayloadOptions, DiscoveredReleasePayload, ReleaseFileIdentity, ReleaseIdentity } from "./release.js";
 export { collectRelease, prepareReleaseCleanup, runBoundedReleaseCleanup, runReleaseCleanupWorker, scheduleReleaseCleanup } from "./release-gc.js";
 export type { ReleaseCleanupLimits, ReleaseCleanupOperations, ReleaseCleanupOptions, ReleaseCleanupResult, ReleaseCleanupWorkerOptions } from "./release-gc.js";
-export { RELEASE_MANIFEST_FILENAME, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease, } from "./release-store.js";
+export { RELEASE_MANIFEST_FILENAME, ReleaseRepairUnavailableError, assertCertifiedFilesPresent, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, repairMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease, } from "./release-store.js";
 export type { CertifiedReleaseRecord, MaterializeReleaseOptions, MaterializedRelease, ReadCertifiedReleaseManifestOptions, ReleaseContentOperation, ReleaseContentOperationEvent, VerifyMaterializedReleaseOptions, } from "./release-store.js";
 export { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument, restartSealDigest } from "./restart-certification.js";
 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, PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, isPackageLockError, lockedPackageDiagnostic, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.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 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 type { UpdateActivationCallbacks, UpdateActivationEvent, UpdateActivationRequest } from "./update-activation.js";

package/dist/foundation/release/index.js

@@ -7,10 +7,10 @@ export { listRecordedEndpoints, liveReleaseIds, probeOwnership, readEndpointMeta
 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";
-export { RELEASE_MANIFEST_FILENAME, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease, } from "./release-store.js";
+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, PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, isPackageLockError, lockedPackageDiagnostic, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.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 { 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/latest-release.d.ts

@@ -1,5 +1,6 @@
 /** Published release channels: stable `X.Y.Z` on dist-tag `latest`, development `X.Y.Z-dev.N` on `next`. */
 export type ReleaseChannel = "stable" | "development";
+export type StartupUpdateMode = "auto" | "notify" | "no";
 export interface DistTagVersions {
     readonly release: string | null;
     readonly develop: string | null;
@@ -20,6 +21,15 @@ export interface AvailableRelease {
 }
 export declare const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
 export declare const UPDATE_CHECK_INTERVAL_MS: number;
+/** One published version with the pull request its manifest records, when it records one. */
+export interface PublishedVersion {
+    readonly version: string;
+    readonly pullRequest: number | null;
+}
+export interface PublishedVersions {
+    readonly versions: readonly PublishedVersion[];
+    readonly error: string | null;
+}
 /**
  * The channel a running version updates on, or null for a version that was never published:
  * a bare `X.Y.Z-dev` only comes from a source checkout, which has nothing to update to.
@@ -31,6 +41,18 @@ export declare function distTagsUrl(registry?: string): string;
 /** Read `latest` (required) and `next` (optional) from a dist-tags object. */
 export declare function parseDistTags(metadata: unknown, source: string): DistTagVersions;
 export declare function queryRegistryDistTags(fetcher: RegistryFetcher, registry?: string): Promise<DistTagVersions>;
+export declare function packageDocumentUrl(registry?: string): string;
+/** The pull request a published or installed manifest records under `publication.pullRequest`, when valid. */
+export declare function recordedPullRequest(manifest: unknown): number | null;
+/**
+ * Every published version with its recorded pull request, read from the registry's full package
+ * document: its per-version manifests keep the publication metadata that version lists and the
+ * abbreviated install document leave out.
+ */
+export declare function queryPublishedVersions(fetcher: RegistryFetcher, registry?: string): Promise<PublishedVersions>;
+export declare function parsePublishedVersions(document: unknown): PublishedVersions;
+/** Forget the startup release check so the next interactive launch asks the registry again. */
+export declare function invalidateReleaseCheckCache(configDir: string): Promise<void>;
 export declare function unavailableDistTags(error: string): DistTagVersions;
 export declare function createRegistryFetcher(timeoutMs: number): RegistryFetcher;
 export interface StartupReleaseCheckOptions {
@@ -39,8 +61,8 @@ export interface StartupReleaseCheckOptions {
     readonly environment?: NodeJS.ProcessEnv;
     /** Whether standard output is an interactive terminal. */
     readonly interactive: boolean;
-    /** The bare-A1 `updateCheck` setting; comparison profiles omit it. */
-    readonly settingEnabled?: boolean;
+    /** The bare-A1 `updateCheck` setting; comparison profiles omit it and use auto. */
+    readonly settingMode?: StartupUpdateMode;
     readonly fetcher?: RegistryFetcher;
     readonly now?: () => number;
 }

package/dist/foundation/release/latest-release.js

@@ -9,6 +9,7 @@ const STARTUP_FETCH_TIMEOUT_MS = 3_000;
 const CACHE_FILENAME = "update-check.json";
 const CACHE_VERSION = 1;
 const MAX_CACHE_BYTES = 4096;
+const MAX_PACKAGE_DOCUMENT_BYTES = 32 * 1024 * 1024;
 const DEVELOPMENT_BUILD = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-dev\.(0|[1-9]\d*)$/u;
 const RELEASE_PAGE = "https://github.com/timurproko/a1/releases/tag/v";
 /**
@@ -57,6 +58,55 @@ export async function queryRegistryDistTags(fetcher, registry) {
         return unavailableDistTags(errorMessage(error));
     }
 }
+export function packageDocumentUrl(registry = DEFAULT_NPM_REGISTRY) {
+    return `${registry.replace(/\/+$/u, "")}/${encodeURIComponent(PRODUCT_TEXT.packageName)}`;
+}
+/** The pull request a published or installed manifest records under `publication.pullRequest`, when valid. */
+export function recordedPullRequest(manifest) {
+    if (typeof manifest !== "object" || manifest === null)
+        return null;
+    const publication = manifest.publication;
+    if (typeof publication !== "object" || publication === null)
+        return null;
+    const value = publication.pullRequest;
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+/**
+ * Every published version with its recorded pull request, read from the registry's full package
+ * document: its per-version manifests keep the publication metadata that version lists and the
+ * abbreviated install document leave out.
+ */
+export async function queryPublishedVersions(fetcher, registry) {
+    try {
+        const response = await fetcher(packageDocumentUrl(registry));
+        if (!response.ok)
+            return { versions: [], error: `registry responded with status ${response.status}` };
+        const text = await response.text();
+        if (text.length > MAX_PACKAGE_DOCUMENT_BYTES)
+            return { versions: [], error: "registry package document is oversized" };
+        return parsePublishedVersions(JSON.parse(text));
+    }
+    catch (error) {
+        return { versions: [], error: errorMessage(error) };
+    }
+}
+export function parsePublishedVersions(document) {
+    if (typeof document !== "object" || document === null || Array.isArray(document)) {
+        return { versions: [], error: "registry returned a non-object package document" };
+    }
+    const manifests = document.versions;
+    if (typeof manifests !== "object" || manifests === null || Array.isArray(manifests)) {
+        return { versions: [], error: "registry package document lists no versions" };
+    }
+    const versions = Object.entries(manifests)
+        .filter(([version]) => validSemver(version) === version)
+        .map(([version, manifest]) => ({ version, pullRequest: recordedPullRequest(manifest) }));
+    return { versions, error: null };
+}
+/** Forget the startup release check so the next interactive launch asks the registry again. */
+export async function invalidateReleaseCheckCache(configDir) {
+    await rm(join(configDir, CACHE_FILENAME), { force: true });
+}
 export function unavailableDistTags(error) {
     return { release: null, develop: null, error };
 }
@@ -74,7 +124,7 @@ export function startupReleaseCheckSkipReason(options) {
         return "ci";
     if (!options.interactive)
         return "not-interactive";
-    if (options.settingEnabled === false)
+    if (options.settingMode === "no")
         return "disabled-by-setting";
     if (releaseChannelOf(options.runningVersion) === null)
         return "unpublished-version";

package/dist/foundation/release/progress-palette.generated.d.ts

@@ -1,5 +1,139 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.1.0
- * (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from A1's named accent projection
+ * over pinned Pi 1.4.0 (MIT), commit 4a080252f06caf63a525d7873c5d94d3c23887e0. Do not edit directly.
  */
-export declare const SHARED_PROGRESS_ACCENT_ANSI = "\u001B[38;2;167;152;215m";
+export declare const SHARED_PROGRESS_PALETTE: Readonly<{
+    blue: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    purple: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    cyan: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    green: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    orange: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    pink: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+}>;
+export declare const SHARED_PROGRESS_ACCENT_ANSI: string;

package/dist/foundation/release/progress-palette.generated.js

@@ -1,5 +1,139 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.1.0
- * (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from A1's named accent projection
+ * over pinned Pi 1.4.0 (MIT), commit 4a080252f06caf63a525d7873c5d94d3c23887e0. Do not edit directly.
  */
-export const SHARED_PROGRESS_ACCENT_ANSI = "\u001b[38;2;167;152;215m";
+export const SHARED_PROGRESS_PALETTE = Object.freeze({
+    "blue": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;130;160;241m",
+                "border": "\u001b[38;2;116;102;197m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;111m",
+                "border": "\u001b[38;5;98m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;63;96;226m",
+                "border": "\u001b[38;2;83;67;154m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;62m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    },
+    "purple": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;167;152;215m",
+                "border": "\u001b[38;2;105;115;167m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;140m",
+                "border": "\u001b[38;5;61m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;116;89;180m",
+                "border": "\u001b[38;2;68;77;130m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;97m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    },
+    "cyan": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;93;179;186m",
+                "border": "\u001b[38;2;74;128;146m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;73m",
+                "border": "\u001b[38;5;66m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;40;122;129m",
+                "border": "\u001b[38;2;40;89;106m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;30m",
+                "border": "\u001b[38;5;23m"
+            }
+        }
+    },
+    "green": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;104;183;141m",
+                "border": "\u001b[38;2;75;132;120m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;72m",
+                "border": "\u001b[38;5;66m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;51;126;88m",
+                "border": "\u001b[38;2;41;93;82m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;65m",
+                "border": "\u001b[38;5;23m"
+            }
+        }
+    },
+    "orange": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;231;135;83m",
+                "border": "\u001b[38;2;178;89;79m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;173m",
+                "border": "\u001b[38;5;131m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;174;80;16m",
+                "border": "\u001b[38;2;133;57;49m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;130m",
+                "border": "\u001b[38;5;95m"
+            }
+        }
+    },
+    "pink": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;223;122;199m",
+                "border": "\u001b[38;2;150;91;171m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;176m",
+                "border": "\u001b[38;5;97m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;178;56;153m",
+                "border": "\u001b[38;2;114;61;131m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;132m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    }
+});
+export const SHARED_PROGRESS_ACCENT_ANSI = SHARED_PROGRESS_PALETTE.blue.dark.truecolor.accent;

package/dist/foundation/release/release-gc.d.ts

@@ -2,6 +2,7 @@ import { rename, rm } from "node:fs/promises";
 import { CohortStateStore, type ExternalReleaseHold, type OrphanReleaseDisposition } from "./cohort-state.js";
 import type { ProductPaths } from "../lifecycle/index.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
+import { type ResidentReleaseHoldReport } from "../resident-tabs/index.js";
 export interface ReleaseCleanupLimits {
     readonly maxItems: number;
     readonly maxDurationMs: number;
@@ -21,6 +22,8 @@ export interface ReleaseCleanupOptions {
     readonly operations?: ReleaseCleanupOperations;
     /** Process-start seam for scheduler and continuation tests. */
     readonly workerSpawner?: (entry: string, environment: NodeJS.ProcessEnv) => Promise<void>;
+    /** Resident-tab inspection seam; the default asks a verified installed terminal host. */
+    readonly residentHolds?: (dataDir: string, releaseRoots: readonly string[]) => Promise<ResidentReleaseHoldReport>;
 }
 export interface ReleaseCleanupWorkerOptions {
     readonly cleanup?: ReleaseCleanupOptions;

package/dist/foundation/release/release-gc.js

@@ -14,6 +14,7 @@ import { UpdateTransactionStore } from "./update-transaction.js";
 import { cleanupUpdateRecoveryCapsules } from "./update-recovery.js";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { collectCompileCaches, startupCompileCachePath } from "../startup/index.js";
+import { readResidentReleaseHolds } from "../resident-tabs/index.js";
 const DEFAULT_CANDIDATE_AGE_MS = 60 * 60 * 1_000;
 const DEFAULT_LIMITS = { maxItems: 8, maxDurationMs: 2_000, concurrency: 1 };
 const DEFAULT_WORKER_DURATION_MS = 10 * 60 * 1_000;
@@ -30,7 +31,7 @@ export async function prepareReleaseCleanup(dataDir, paths, options = {}) {
     const store = new CohortStateStore(dataDir);
     const discovered = await discoverCleanupInputs(dataDir, store, options);
     const transactionStore = options.transactionStore ?? new UpdateTransactionStore(dataDir);
-    await store.reconcileRetention(async () => await protectionInputs(paths, transactionStore, options.externalHolds ?? []), discovered.orphans);
+    await store.reconcileRetention(async () => await protectionInputs(dataDir, paths, transactionStore, options.externalHolds ?? [], options.residentHolds), discovered.orphans);
     for (const diagnostic of discovered.diagnostics.slice(0, 16)) {
         await store.recordCleanupFailure(diagnostic.releaseId, diagnostic.stage, diagnostic.error);
     }
@@ -77,7 +78,7 @@ export async function runBoundedReleaseCleanup(dataDir, paths, options = {}) {
             maximum -= 1;
             const certificationId = certificationReleaseId(artifact);
             if (certificationId !== null) {
-                const inputs = await protectionInputs(paths, transactionStore, options.externalHolds ?? []);
+                const inputs = await protectionInputs(dataDir, paths, transactionStore, options.externalHolds ?? [], options.residentHolds);
                 if (isProtectedDetachedRelease(await store.read(), inputs, certificationId))
                     continue;
             }
@@ -232,7 +233,7 @@ export async function collectRelease(store, dataDir, releaseId, externalReferenc
     const state = await store.read();
     if (!state.releases[releaseId])
         throw new Error(`unknown release ${releaseId}`);
-    await store.reconcileRetention(async () => ({ ...(await protectionInputs(paths, new UpdateTransactionStore(dataDir), holds)) }));
+    await store.reconcileRetention(async () => ({ ...(await protectionInputs(dataDir, paths, new UpdateTransactionStore(dataDir), holds)) }));
     const disposition = (await store.read()).cleanup.pending[releaseId];
     if (!disposition)
         throw new Error(`release ${releaseId} is still referenced and cannot be collected`);
@@ -243,7 +244,7 @@ export async function collectRelease(store, dataDir, releaseId, externalReferenc
 async function collectDisposition(store, dataDir, paths, disposition, options) {
     const releaseId = disposition.release.releaseId;
     try {
-        const inputs = await protectionInputs(paths, options.transactionStore ?? new UpdateTransactionStore(dataDir), options.externalHolds ?? []);
+        const inputs = await protectionInputs(dataDir, paths, options.transactionStore ?? new UpdateTransactionStore(dataDir), options.externalHolds ?? [], options.residentHolds);
         const current = await store.read();
         if (isProtectedDetachedRelease(current, inputs, releaseId))
             return false;
@@ -289,12 +290,62 @@ function isProtectedDetachedRelease(state, inputs, releaseId) {
         || (inputs.externalHolds ?? []).some(hold => hold.releaseId === releaseId)
         || (inputs.transaction?.status === "active" && inputs.transaction.priorActiveReleaseId === releaseId);
 }
-async function protectionInputs(paths, transactionStore, externalHolds) {
-    const [liveIds, transaction] = await Promise.all([
+async function protectionInputs(dataDir, paths, transactionStore, externalHolds, residentHolds) {
+    const [liveIds, transaction, resident] = await Promise.all([
         paths ? liveReleaseIds(paths) : Promise.resolve([]),
         transactionStore.read(),
+        residentReleaseHolds(dataDir, residentHolds),
     ]);
-    return { liveReleaseIds: liveIds, externalHolds, transaction: transactionReference(transaction) };
+    return { liveReleaseIds: liveIds, externalHolds: [...externalHolds, ...resident], transaction: transactionReference(transaction) };
+}
+/**
+ * Holds every release a live resident server, holder, or tab child runs from. Retention fails
+ * closed: an incomplete report, or a recorded root inside the release store that names no known
+ * release, holds every known release.
+ */
+async function residentReleaseHolds(dataDir, reader) {
+    const state = await new CohortStateStore(dataDir).read();
+    const records = [
+        ...Object.values(state.releases),
+        ...Object.values(state.cleanup.pending).map(disposition => disposition.release),
+    ];
+    const preferred = [state.references.active, state.references.rollback]
+        .flatMap(id => id && state.releases[id] ? [state.releases[id].releaseRoot] : []);
+    const roots = [...new Set([...preferred, ...Object.values(state.releases).map(record => record.releaseRoot)])];
+    const report = await (reader ?? ((directory, releaseRoots) => readResidentReleaseHolds({ dataDir: directory, releaseRoots })))(dataDir, roots);
+    const everything = () => [...new Set(records.map(record => record.releaseId))].map(releaseId => ({ authority: "resident", releaseId }));
+    if (!report.complete)
+        return everything();
+    if (report.releaseRoots.length === 0)
+        return [];
+    // Rationale: native Windows extended paths and Unix aliases must match the catalog's spelling.
+    const byRoot = new Map();
+    for (const record of records) {
+        const canonical = await realpath(record.releaseRoot).catch(() => record.releaseRoot);
+        byRoot.set(comparablePath(canonical), record.releaseId);
+    }
+    const directory = await realpath(resolve(dataDir, "releases")).catch(() => null);
+    if (directory === null)
+        return everything();
+    const store = comparablePath(directory);
+    const holds = new Set();
+    for (const root of report.releaseRoots) {
+        // Security: an unresolved live root may alias managed content; uncertainty must retain it.
+        const canonical = await realpath(root).catch(() => null);
+        if (canonical === null)
+            return everything();
+        const key = comparablePath(canonical);
+        const releaseId = byRoot.get(key);
+        if (releaseId)
+            holds.add(releaseId);
+        else if (key.startsWith(`${store}${sep}`))
+            return everything();
+    }
+    return [...holds].sort().map(releaseId => ({ authority: "resident", releaseId }));
+}
+function comparablePath(path) {
+    const absolute = resolve(path);
+    return process.platform === "win32" ? absolute.toLowerCase() : absolute;
 }
 function transactionReference(transaction) {
     return transaction === null ? null : { status: transaction.status, priorActiveReleaseId: transaction.priorActiveReleaseId };
@@ -745,7 +796,7 @@ function parseWorkerHolds(value) {
         if (!Array.isArray(parsed))
             return [];
         return parsed.filter((hold) => Boolean(hold) && typeof hold === "object"
-            && (hold.authority === "agent" || hold.authority === "migration")
+            && ["agent", "migration", "resident"].includes(hold.authority)
             && typeof hold.releaseId === "string");
     }
     catch {