@timurproko/a1 0.2.6-dev.736 → 0.2.7-dev.1221

package/dist/foundation/release/dependency-certification.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { immutablePlatformPolicy } from "./immutable-platform.js";
 export const DEPENDENCY_CERTIFICATIONS_DIRECTORY = "dependency-certifications";
@@ -194,7 +194,8 @@ async function releasePublicationLock(path, token) {
     while (true) {
         try {
             if (!retired) {
-                await assertPublicationLockOwner(path, token);
+                if (!await assertPublicationLockOwner(path, token))
+                    return;
                 await rename(path, released);
                 retired = true;
             }
@@ -218,24 +219,58 @@ async function releasePublicationLock(path, token) {
 }
 /** Ownership uncertainty is never authority to retire a missing, linked, or replaced generation. */
 async function assertPublicationLockOwner(path, token) {
-    try {
-        const metadata = await lstat(path);
-        if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
-            throw new Error("invalid lock directory");
-        const ownerPath = resolve(path, "owner.json");
-        const ownerMetadata = await lstat(ownerPath);
-        if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
-            throw new Error("invalid owner file");
-        const owner = JSON.parse(await readFile(ownerPath, "utf8"));
-        if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
-            || owner.pid !== process.pid || owner.token !== token)
-            throw new Error("owner generation differs");
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            const metadata = await lstat(path);
+            if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
+                throw new Error("invalid lock directory");
+            const ownerPath = resolve(path, "owner.json");
+            const ownerMetadata = await lstat(ownerPath);
+            if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
+                throw new Error("invalid owner file");
+            const owner = JSON.parse(await readFile(ownerPath, "utf8"));
+            if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
+                || owner.pid !== process.pid || owner.token !== token)
+                throw new Error("owner generation differs");
+            return true;
+        }
+        catch (error) {
+            // Platform: Windows can briefly hide a directory immediately after a successful rename
+            // when independent publishers are contending. Re-read the complete identity; never treat
+            // absence as ownership and never retire a generation whose token differs.
+            if (hasCode(error, "ENOENT") && attempt < 3) {
+                await new Promise(resolvePromise => setTimeout(resolvePromise, 20 * attempt));
+                continue;
+            }
+            // Concurrency: a delayed abandoned-owner reclaimer can move a successor generation after
+            // reading the predecessor. If our exact token is now in a managed tombstone, no active
+            // generation belongs to this release call and returning without mutation is fail-safe.
+            if (hasCode(error, "ENOENT") && await publicationLockWasRetired(path, token))
+                return false;
+            if (isReleaseContention(error))
+                throw error;
+            throw new Error("publication lease release ownership could not be verified", { cause: error });
+        }
     }
-    catch (error) {
-        if (isReleaseContention(error))
-            throw error;
-        throw new Error("publication lease release ownership could not be verified", { cause: error });
+}
+async function publicationLockWasRetired(path, token) {
+    const directory = dirname(path);
+    const prefix = `${basename(path)}.`;
+    const entries = await readdir(directory, { withFileTypes: true });
+    if (entries.length > 256)
+        return false;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith(prefix)
+            || (!entry.name.includes(".abandoned-") && !entry.name.includes(".released-")))
+            continue;
+        const ownerPath = resolve(directory, entry.name, "owner.json");
+        const owner = await readFile(ownerPath, "utf8")
+            .then(source => JSON.parse(source))
+            .catch(() => null);
+        if (owner?.pid === process.pid && owner.token === token)
+            return true;
     }
+    return false;
 }
 function isReleaseContention(error) {
     return ["EPERM", "EACCES", "EBUSY"].some(code => hasCode(error, code));

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;