@timurproko/a1 0.2.7-dev.820 → 0.2.7-dev.828

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

@@ -0,0 +1,265 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { valid as validSemver } from "semver";
+import { readLaunchContext } from "../launch-context/index.js";
+import { resolveProductPaths } from "../lifecycle/index.js";
+import { CohortStateStore } from "./cohort-state.js";
+import { processIsAlive } from "./process-cleanup.js";
+import { isNewerRelease, releaseChannelOf } from "./latest-release.js";
+import { readCertifiedReleaseManifest, resolveReleaseEntryPoint } from "./release-store.js";
+import { readUpdateExecutionOwner } from "./update-execution-lease.js";
+import { runSelfUpdate, 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;
+const AUTOMATIC_UPDATE_STATE_FILENAME = "automatic-update.json";
+const MAX_STATE_BYTES = 16_384;
+const OBSERVER_POLL_MS = 250;
+const WORKER_START_GRACE_MS = 5_000;
+export class AutomaticUpdateStateStore {
+    path;
+    constructor(dataDir) { this.path = resolve(dataDir, AUTOMATIC_UPDATE_STATE_FILENAME); }
+    async read() {
+        let source;
+        try {
+            source = await readFile(this.path, "utf8");
+        }
+        catch (error) {
+            if (hasCode(error, "ENOENT"))
+                return null;
+            throw error;
+        }
+        if (Buffer.byteLength(source, "utf8") > MAX_STATE_BYTES)
+            throw new Error("automatic update state is oversized");
+        const value = JSON.parse(source);
+        validateState(value);
+        return value;
+    }
+    async write(value) {
+        validateState(value);
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        const temporary = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
+        const file = await open(temporary, "wx", 0o600);
+        try {
+            await file.writeFile(`${JSON.stringify(value)}\n`);
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+        try {
+            await rename(temporary, this.path);
+        }
+        catch (error) {
+            await rm(temporary, { force: true });
+            throw error;
+        }
+    }
+}
+/** Start or observe one silent update and resolve with the active newer version once restart is useful. */
+export async function requestAutomaticUpdate(options) {
+    if (options.signal?.aborted)
+        return null;
+    const environment = options.environment ?? process.env;
+    const paths = resolveProductPaths(environment);
+    const now = options.now ?? Date.now;
+    const store = new AutomaticUpdateStateStore(paths.dataDir);
+    let existing;
+    try {
+        existing = await store.read();
+    }
+    catch {
+        return null;
+    }
+    const readActiveVersion = options.activeVersion ?? (async () => await activeNewerVersion(paths.dataDir, options.runningVersion));
+    const active = await readActiveVersion();
+    if (active !== null)
+        return active;
+    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))
+        return null;
+    let worker = options.worker;
+    if (worker === undefined) {
+        const launch = readLaunchContext(environment, "release");
+        const cohort = await new CohortStateStore(paths.dataDir).read();
+        const record = launch.releaseId === undefined ? undefined : cohort.releases[launch.releaseId];
+        if (!record || record.approval !== "approved" || record.releaseRoot !== launch.releaseRoot
+            || record.contentDigest !== launch.releaseDigest)
+            return null;
+        const selected = await readCertifiedReleaseManifest(record, resolve(paths.dataDir, "releases"));
+        worker = {
+            entry: await resolveReleaseEntryPoint(selected, "bin/automatic-update.js"),
+            packageRoot: selected.packageRoot,
+        };
+    }
+    const arguments_ = [
+        "--package-root", worker.packageRoot,
+        "--channel", options.release.channel,
+        "--target-version", options.release.version,
+        "--data-dir", paths.dataDir,
+    ];
+    let owner;
+    try {
+        owner = await readUpdateExecutionOwner(paths.dataDir);
+    }
+    catch {
+        return null;
+    }
+    if (owner === null || !processIsAlive(owner.pid)) {
+        await (options.spawnWorker ?? spawnAutomaticUpdateWorker)(worker.entry, arguments_, environment).catch(() => undefined);
+    }
+    const startedAt = now();
+    const sleep = options.sleep ?? (async (durationMs) => await new Promise(resolvePromise => {
+        const timer = setTimeout(resolvePromise, durationMs);
+        timer.unref?.();
+    }));
+    while (!options.signal?.aborted) {
+        const installed = await readActiveVersion();
+        if (installed !== null)
+            return installed;
+        const state = await store.read().catch(() => null);
+        if (state?.targetVersion === options.release.version && state.status === "failed" && state.attemptedAt >= startedAt)
+            return null;
+        const owner = await readUpdateExecutionOwner(paths.dataDir).catch(() => null);
+        if ((owner === null || !processIsAlive(owner.pid)) && now() - startedAt >= WORKER_START_GRACE_MS)
+            return null;
+        await sleep(OBSERVER_POLL_MS);
+    }
+    return null;
+}
+export async function runAutomaticUpdateWorker(argv, environment = process.env) {
+    const parsed = parseWorkerArguments(argv);
+    const paths = resolveProductPaths(environment);
+    if (!samePath(parsed.dataDir, paths.dataDir))
+        return 1;
+    const launch = readLaunchContext(environment, "release");
+    const cohort = await new CohortStateStore(paths.dataDir).read();
+    const record = launch.releaseId === undefined ? undefined : cohort.releases[launch.releaseId];
+    if (!record || record.approval !== "approved" || !samePath(record.releaseRoot, launch.releaseRoot ?? "")
+        || record.contentDigest !== launch.releaseDigest)
+        return 1;
+    const selected = await readCertifiedReleaseManifest(record, resolve(paths.dataDir, "releases"));
+    if (!samePath(selected.packageRoot, parsed.packageRoot))
+        return 1;
+    const store = new AutomaticUpdateStateStore(paths.dataDir);
+    const attemptedAt = Date.now();
+    const output = { stdout() { }, stderr() { } };
+    let acquired = false;
+    let runningWrite = Promise.resolve();
+    try {
+        const code = await runSelfUpdate({
+            packageRoot: parsed.packageRoot,
+            channel: parsed.channel === "stable" ? "stable" : "next",
+            resolvedTarget: parsed.targetVersion,
+            mode: "automatic",
+            environment,
+            output,
+            progress: false,
+            onLeaseAcquired: () => {
+                acquired = true;
+                runningWrite = store.write(state(parsed, "running", attemptedAt, null, null));
+            },
+        });
+        if (code === UPDATE_ALREADY_RUNNING_EXIT_CODE)
+            return 0;
+        if (code !== 0) {
+            await runningWrite;
+            await store.write(state(parsed, "failed", attemptedAt, null, `exit-${code}`));
+            return code;
+        }
+        const active = await activeRelease(paths.dataDir);
+        if (active === null || releaseChannelOf(active.packageVersion) !== parsed.channel
+            || (active.packageVersion !== parsed.targetVersion && !isNewerRelease(active.packageVersion, parsed.targetVersion))) {
+            if (acquired) {
+                await runningWrite;
+                await store.write(state(parsed, "failed", attemptedAt, null, "target-not-active"));
+            }
+            return 1;
+        }
+        await runningWrite;
+        await store.write(state(parsed, "installed", attemptedAt, active.packageVersion, null));
+        return 0;
+    }
+    catch (error) {
+        await runningWrite.catch(() => undefined);
+        await store.write(state(parsed, "failed", attemptedAt, null, errorMessage(error).slice(0, 512))).catch(() => undefined);
+        return 1;
+    }
+}
+async function spawnAutomaticUpdateWorker(entry, arguments_, environment) {
+    const child = spawn(process.execPath, [entry, ...arguments_], {
+        detached: true,
+        env: environment,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    await new Promise((resolvePromise, rejectPromise) => {
+        child.once("spawn", resolvePromise);
+        child.once("error", rejectPromise);
+    });
+    child.unref();
+}
+async function activeNewerVersion(dataDir, runningVersion) {
+    const active = await activeRelease(dataDir);
+    return active !== null && isNewerRelease(active.packageVersion, runningVersion) ? active.packageVersion : null;
+}
+async function activeRelease(dataDir) {
+    const cohort = await new CohortStateStore(dataDir).read();
+    const activeId = cohort.references.active;
+    if (activeId === null)
+        return null;
+    const active = cohort.releases[activeId];
+    return active?.approval === "approved" ? active : null;
+}
+function state(parsed, status, attemptedAt, installedVersion, failure) {
+    return {
+        schema: AUTOMATIC_UPDATE_STATE_SCHEMA,
+        channel: parsed.channel,
+        targetVersion: parsed.targetVersion,
+        status,
+        attemptedAt,
+        updatedAt: Date.now(),
+        installedVersion,
+        failure,
+    };
+}
+function parseWorkerArguments(argv) {
+    const values = new Map();
+    for (let index = 0; index < argv.length; index += 2) {
+        const key = argv[index];
+        const value = argv[index + 1];
+        if (!key?.startsWith("--") || value === undefined || values.has(key))
+            throw new Error("invalid automatic update worker arguments");
+        values.set(key, value);
+    }
+    const packageRoot = values.get("--package-root");
+    const channel = values.get("--channel");
+    const targetVersion = values.get("--target-version");
+    const dataDir = values.get("--data-dir");
+    if (!packageRoot || (channel !== "stable" && channel !== "development") || !targetVersion || !dataDir
+        || validSemver(targetVersion) === null)
+        throw new Error("incomplete automatic update worker arguments");
+    return { packageRoot, channel, targetVersion, dataDir };
+}
+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)
+        || !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))) {
+        throw new Error("invalid automatic update state");
+    }
+}
+function samePath(left, right) {
+    const canonicalLeft = resolve(left);
+    const canonicalRight = resolve(right);
+    return process.platform === "win32"
+        ? canonicalLeft.toLowerCase() === canonicalRight.toLowerCase()
+        : canonicalLeft === canonicalRight;
+}
+function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }

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

@@ -13,15 +13,7 @@ export interface BootstrapOptions {
     };
     readonly environment?: NodeJS.ProcessEnv;
     readonly output?: Pick<NodeJS.WriteStream, "write">;
-    /**
-     * Whether a materialized release copy is fit to launch. The active release
-     * is normally reused while its version matches the installation, but a copy
-     * can be broken in ways a version cannot see — materialized from a tree a
-     * blocked postinstall never finished repairing. The probe is injected from
-     * the bin entry because deciding it requires inspecting dependency
-     * resolution, which stays out of production code. Absent means every
-     * release is fit.
-     */
+    /** Optional package-resolution probe that excludes a damaged retained release. */
     readonly releaseIsLaunchable?: (releaseRoot: string) => boolean;
     /** Test seam for bounded maintenance scheduled after stale endpoint sweeping. */
     readonly scheduleMaintenance?: (dataDir: string, paths: ReturnType<typeof resolveProductPaths>) => Promise<void>;

package/dist/foundation/release/bootstrap.js

@@ -5,6 +5,7 @@ import { connect } from "node:net";
 import { resolve } from "node:path";
 import { selectCohortLaunch } from "./cohort-selection.js";
 import { selectOrdinaryLaunchReleaseId } from "./ordinary-launch-selection.js";
+import { releaseChannelOf } from "./latest-release.js";
 import { CohortStateStore } from "./cohort-state.js";
 import { assertLaunchProfileId, createSupervisorStartupAttempt, readSupervisorStartupResult, resolveCohortEndpoint, resolveProductPaths, sessionSelectionArguments } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
@@ -17,7 +18,7 @@ import { scheduleReleaseCleanup } from "./release-gc.js";
 import { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument } from "./restart-certification.js";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 import { markStartupPhase } from "../startup/index.js";
-import { isCurrentLaunchContract, launchContractTarget, readLaunchContext, withLaunchContext } from "../launch-context/index.js";
+import { PRIVATE_ENVIRONMENT, isCurrentLaunchContract, launchContractTarget, readLaunchContext, withLaunchContext } from "../launch-context/index.js";
 import { ensureTerminalHost, readResidentTabLaunchSettings, selectResidentHost } from "../resident-tabs/index.js";
 const RELEASE_RESELECTION_MESSAGE = "a1-release-reselection";
 export async function runBootstrap(options) {
@@ -124,6 +125,8 @@ async function runBootstrapAttempt(options, retriesRemaining) {
     }
     let probe = endpoint ? await probeOwnership(endpoint) : "dead";
     const installedVersion = await readInstalledVersion(options.packageRoot);
+    if (releaseChannelOf(installedVersion) !== null)
+        environment[PRIVATE_ENVIRONMENT.updateVersion] = installedVersion;
     const activeId = state.references.active;
     const active = activeId === null ? undefined : state.releases[activeId];
     let activeIsLaunchable = active === undefined || (options.releaseIsLaunchable?.(active.releaseRoot) ?? true);
@@ -434,14 +437,15 @@ async function launchUi(release, environment, sessionArgs, residentContext = {})
  * version instead of failing while an installation is being replaced.
  */
 export function releaseEnvironment(environment, release, profile) {
-    const launchMode = readLaunchContext(environment).launchMode;
+    const context = readLaunchContext(environment);
     return withLaunchContext(environment, {
         releaseId: release.releaseId,
         releaseLayers: (release.dependencyLayers ?? []).map(layer => layer.layerId).join(","),
         releaseRoot: release.releaseRoot,
         releaseDigest: release.contentDigest,
         ...(profile === undefined ? {} : { launchProfile: profile }),
-        ...(launchMode === undefined ? {} : { launchMode }),
+        ...(context.launchMode === undefined ? {} : { launchMode: context.launchMode }),
+        ...(context.updateVersion === undefined ? {} : { updateVersion: context.updateVersion }),
     }, process.platform, launchContractTarget(release));
 }
 export async function waitForVerifiedEndpoint(path, release, timeoutMs, startup) {

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

@@ -21,7 +21,7 @@ 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, 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

@@ -10,7 +10,7 @@ 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, 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;
@@ -39,8 +40,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

@@ -74,7 +74,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.4.0
- * (MIT), commit 4a080252f06caf63a525d7873c5d94d3c23887e0. 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;