@timurproko/a1 0.2.7-dev.1276 → 0.2.7-dev.1286

package/dist/foundation/release/update.js

@@ -136,10 +136,12 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             // its own to know. A tree that serves the contract activates itself with its own code;
             // a tree from before the contract is activated here, with the layout it had then.
             const contracts = await readActivationContracts(packageRoot, fileSystem.readFile);
-            if (contracts.includes(UPDATE_ACTIVATION_CONTRACT))
+            if (contracts.includes(UPDATE_ACTIVATION_CONTRACT)) {
                 await delegateActivation(request, callbacks);
-            else
-                await activateInstalledRelease(request, callbacks);
+                return "delegated";
+            }
+            await activateInstalledRelease(request, callbacks);
+            return "in-process";
         },
     };
 }
@@ -164,7 +166,7 @@ export function renderUpdateProgressBar(percent, accent = SHARED_PROGRESS_ACCENT
     // percentage retain the update meter's neutral treatment.
     const gray = "\u001b[38;2;128;128;128m";
     const track = "\u001b[38;2;102;102;102m";
-    return `${accent}${"━".repeat(filled)}${track}${"─".repeat(PROGRESS_BAR_WIDTH - filled)}${gray} ${bounded}%\u001b[39m`;
+    return `${accent}${"━".repeat(filled)}${track}${"━".repeat(PROGRESS_BAR_WIDTH - filled)}${gray} ${bounded}%\u001b[39m`;
 }
 function updateProgressAccent(environment) {
     return earlyAccentPalette(resolveEarlyAccentColor(environment), earlyTerminalAppearance(environment), earlyTerminalColorMode(environment)).accent;
@@ -416,13 +418,22 @@ async function withUpdateExecutionLease(input, options, output, installer, opera
         // back to the release that ran before it, so this request proceeds as an ordinary update of its
         // own target instead of reporting a dead attempt as in progress.
         const interrupted = lease.owner.targetVersion;
-        const rollback = await installer.rollback(lease.transaction.priorActiveReleaseId)
-            .catch(error => `rollback failed: ${errorMessage(error)}`);
         const store = new UpdateTransactionStore(input.dataDir);
-        await store.finish("rolled-back", `interrupted ${interrupted} update settled by ${input.targetVersion}; ${rollback}`);
-        await store.clearCompleted().catch(() => undefined);
-        await reclaimDeadLease(input.dataDir, lease.owner);
-        output.stdout(`${PRODUCT_TEXT.commandName} rolled back the interrupted ${interrupted} update: ${rollback}\n`);
+        if (lease.transaction.phase === "active-reference-committed") {
+            // Invariant: the interrupted update already committed its target; agents may run it, so it stays.
+            await store.finish("completed", `interrupted ${interrupted} update was already active; settled by ${input.targetVersion}`);
+            await store.clearCompleted().catch(() => undefined);
+            await reclaimDeadLease(input.dataDir, lease.owner);
+            output.stdout(`${PRODUCT_TEXT.commandName} settled the interrupted ${interrupted} update, which was already active\n`);
+        }
+        else {
+            const rollback = await installer.rollback(lease.transaction.priorActiveReleaseId)
+                .catch(error => `rollback failed: ${errorMessage(error)}`);
+            await store.finish("rolled-back", `interrupted ${interrupted} update settled by ${input.targetVersion}; ${rollback}`);
+            await store.clearCompleted().catch(() => undefined);
+            await reclaimDeadLease(input.dataDir, lease.owner);
+            output.stdout(`${PRODUCT_TEXT.commandName} rolled back the interrupted ${interrupted} update: ${rollback}\n`);
+        }
         lease = await acquireUpdateExecutionLease(input);
     }
     if (lease.status !== "acquired") {
@@ -533,7 +544,9 @@ async function runUpdateTransaction(plan) {
     const { packageRoot, npmCliRoot } = plan.installation;
     const run = { transaction: await transactionStore.read() };
     try {
-        if ((!run.transaction || run.transaction.status === "completed") && await lifecycle.targetIsActive(targetVersion)) {
+        // Rationale: a settled transaction, even one reported as failed after its commit, leaves nothing
+        // to install when its target is already active; reinstalling the same release would only churn.
+        if ((!run.transaction || run.transaction.status !== "active") && await lifecycle.targetIsActive(targetVersion)) {
             await installer.maintenance();
             await transactionStore.clearCompleted();
             output.stdout(`${PRODUCT_TEXT.commandName} is up to date — no update needed.\n`);
@@ -610,7 +623,7 @@ async function replaceUpdatePackage(plan, run, protection, npmCli) {
 }
 /** Activate the installed package, commit maintenance, and only then report success. */
 async function activateUpdate(plan, run) {
-    const { output, progress, transactionStore, now, onPhaseTiming, paths } = plan;
+    const { progress, transactionStore, now, onPhaseTiming } = plan;
     progress.set(70, MATERIALIZE_PROGRESS.from);
     let activationPhaseStartedAt = now();
     const recordActivationPhase = async (phase) => {
@@ -619,7 +632,7 @@ async function activateUpdate(plan, run) {
         progress.set(ACTIVATION_PROGRESS[phase].at, ACTIVATION_PROGRESS[phase].creepTo);
         activationPhaseStartedAt = now();
     };
-    await plan.lifecycle.activateInstalled(plan.installation.packageRoot, plan.targetVersion, recordActivationPhase, ({ completed, total }) => progress.set(MATERIALIZE_PROGRESS.from
+    const activation = await plan.lifecycle.activateInstalled(plan.installation.packageRoot, plan.targetVersion, recordActivationPhase, ({ completed, total }) => progress.set(MATERIALIZE_PROGRESS.from
         + (MATERIALIZE_PROGRESS.to - MATERIALIZE_PROGRESS.from) * (total > 0 ? Math.min(1, completed / total) : 0)), state => {
         if (state === "started") {
             activationPhaseStartedAt = now();
@@ -632,19 +645,39 @@ async function activateUpdate(plan, run) {
         }
     });
     const transactionStartedAt = now();
-    const transaction = run.transaction;
-    if (transaction?.recovery?.capsulePath)
-        await removeUpdateRecoveryCapsule(paths.dataDir, transaction.transactionId);
-    // Invariant: successful output follows the durable cleanup disposition. Slow recursive
-    // removal belongs to the detached worker started by this maintenance coordinator.
-    await plan.installer.maintenance();
+    const warnings = [];
+    // Invariant: a delegated tree owns the control state it just wrote and has already scheduled its
+    // own maintenance; this updater may be older and must not interpret that state. An in-process
+    // activation ran this updater's own code, so the updater remains the owner of its maintenance.
+    if (activation !== "delegated") {
+        // Rationale: the activation is committed, so cleanup trouble is retried later, never a failure.
+        await plan.installer.maintenance().catch(error => { warnings.push(`release cleanup will retry: ${errorMessage(error)}`); });
+    }
+    await completeCommittedUpdate(plan, run.transaction, warnings);
+    onPhaseTiming?.({ phase: "transaction-complete", durationMs: Math.max(0, now() - transactionStartedAt) });
+    return 0;
+}
+/**
+ * The active reference names the target, so the update has happened. Everything here is
+ * best-effort bookkeeping: it may warn, but it never fails the update and never rolls back.
+ */
+async function completeCommittedUpdate(plan, transaction, warnings) {
+    const { output, progress, transactionStore, paths } = plan;
+    if (transaction?.recovery?.capsulePath) {
+        await removeUpdateRecoveryCapsule(paths.dataDir, transaction.transactionId)
+            .catch(error => { warnings.push(`recovery evidence will be removed later: ${errorMessage(error)}`); });
+    }
     // Concurrency: this is the launch cutover. No failure-prone update work follows success.
-    await transactionStore.finish("completed");
+    await transactionStore.finish("completed", warnings.length === 0 ? null : warnings.join("; ").slice(0, 2_000))
+        .catch(error => { warnings.push(`update journal could not be settled: ${errorMessage(error)}`); });
     await Promise.all([transactionStore.clearCompleted(), invalidateReleaseCheckCache(paths.configDir)]).catch(() => undefined);
-    onPhaseTiming?.({ phase: "transaction-complete", durationMs: Math.max(0, now() - transactionStartedAt) });
     progress.finish();
     output.stdout(`${PRODUCT_TEXT.commandName} updated successfully to ${plan.targetVersion}\n`);
-    return 0;
+    for (const warning of warnings)
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`warning: ${singleLine(warning)}`)}\n`);
+}
+function singleLine(text) {
+    return text.replace(/[\r\n]+/gu, " ").slice(0, 400);
 }
 async function settleUpdateFailure(plan, transaction, error) {
     const { output, transactionStore } = plan;
@@ -654,6 +687,12 @@ async function settleUpdateFailure(plan, transaction, error) {
         output.stderr(`${PRODUCT_TEXT.diagnostic(`update could not start safely: ${message}. Nothing was changed. Retry with npm x -y -- ${PRODUCT_PACKAGE}-install`)}\n`);
         return 1;
     }
+    if (transaction?.status === "active" && transaction.phase === "active-reference-committed") {
+        // Invariant: once the active reference names the target, running agents may already use it.
+        // Rolling back would move the reference under them, so a later failure only warns.
+        await completeCommittedUpdate(plan, transaction, [`post-activation step failed: ${message}`]);
+        return 0;
+    }
     const rollback = await plan.installer.rollback(transaction?.priorActiveReleaseId ?? null)
         .catch(rollbackError => `rollback failed: ${errorMessage(rollbackError)}`);
     if (transaction)

package/dist/foundation/release/warmup.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawnReleaseEntry } from "./release-use.js";
 import { resolveReleaseEntryPoint } from "./release-store.js";
 import { releaseEnvironment } from "./bootstrap.js";
 import { launchContractTarget, launchEnvironmentKeys } from "../launch-context/index.js";
@@ -11,15 +11,13 @@ function warmupDiagnostics(text) {
 /** Import the exact immutable startup graph in a terminal-free bounded child process. */
 export async function warmMaterializedRelease(release, environment, timeoutMs = 30_000) {
     const entry = await resolveReleaseEntryPoint(release, "bin/warmup.js");
+    const child = await spawnReleaseEntry(entry, [], {
+        env: { ...releaseEnvironment(environment, release), [launchEnvironmentKeys(launchContractTarget(release)).immutableWarmup]: "1" },
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true,
+    });
     await new Promise((resolvePromise, rejectPromise) => {
-        // Rationale: the child still gets no terminal, but a discarded failure reason leaves an
-        // update reporting only an exit status. Its own diagnostics are read and bounded so the
-        // transaction journal records why the graph could not be imported.
-        const child = spawn(process.execPath, [entry], {
-            env: { ...releaseEnvironment(environment, release), [launchEnvironmentKeys(launchContractTarget(release)).immutableWarmup]: "1" },
-            stdio: ["ignore", "ignore", "pipe"],
-            windowsHide: true,
-        });
+        // Rationale: bounded diagnostics explain graph-import failures without attaching a terminal.
         let diagnostics = "";
         child.stderr?.setEncoding("utf8");
         child.stderr?.on("data", chunk => { diagnostics = `${diagnostics}${chunk}`.slice(-WARMUP_DIAGNOSTIC_LIMIT); });
@@ -44,4 +42,5 @@ export async function warmMaterializedRelease(release, environment, timeoutMs =
         }, timeoutMs);
         timer.unref?.();
     });
+    await child.releaseSettled;
 }

package/dist/foundation/session-writer-lock/index.d.ts

@@ -20,8 +20,8 @@ export interface SessionWriterHandle {
     release(): void;
 }
 /**
- * A crashed writer is not released by the kernel; its lock becomes stale once its holder stops
- * refreshing it. The bound keeps resume after a crash a matter of seconds.
+ * Heartbeats diagnose ownership loss, but never authorize takeover of a live writer.
+ * Dead owners are recovered by process absence; legacy or uncertain owners stay protected.
  */
 export declare const SESSION_WRITER_STALE_MS = 10000;
 /**

package/dist/foundation/session-writer-lock/index.js

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, realpathSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, realpathSync, statSync, readFileSync, writeFileSync, unlinkSync, rmdirSync, utimesSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import lockfile from "proper-lockfile";
 /** Reports that a canonical session identity already has a live writer. */
 export class SessionWriterConflict extends Error {
@@ -15,8 +15,8 @@ export class SessionWriterConflict extends Error {
     }
 }
 /**
- * A crashed writer is not released by the kernel; its lock becomes stale once its holder stops
- * refreshing it. The bound keeps resume after a crash a matter of seconds.
+ * Heartbeats diagnose ownership loss, but never authorize takeover of a live writer.
+ * Dead owners are recovered by process absence; legacy or uncertain owners stay protected.
  */
 export const SESSION_WRITER_STALE_MS = 10_000;
 let backendOverride;
@@ -35,15 +35,37 @@ export function lockfileBackend(root = join(tmpdir(), "a1-session-writer-locks")
     };
     const acquireAuthority = (path) => {
         mkdirSync(root, { recursive: true, mode: 0o700 });
-        // Rationale: the lock directory is the authority; no target file exists or is needed.
-        return lockfile.lockSync(path, {
-            realpath: false,
-            lockfilePath: path,
-            stale: staleMs,
-            // Rationale: a missed refresh means this process stalled; the next writer takes over, and the
-            // stalled one must not crash for it.
-            onCompromised: () => { },
+        // Compatibility: the nonempty owner record also prevents legacy heartbeat-only clients from reclaiming
+        // a stalled live writer: proper-lockfile removes directories non-recursively.
+        reclaimDeadWriter(path);
+        const release = lockfile.lockSync(path, {
+            realpath: false, lockfilePath: path, stale: staleMs,
+            onCompromised: () => { throw new Error("Session writer ownership was lost; execution has been stopped."); },
         });
+        const owner = { pid: process.pid, token: randomUUID() };
+        const stamp = statSync(path).mtime;
+        try {
+            writeFileSync(join(path, "owner.json"), JSON.stringify(owner), { flag: "wx", mode: 0o600 });
+            // Concurrency: creating the owner record must not masquerade as a foreign heartbeat.
+            utimesSync(path, stamp, stamp);
+        }
+        catch (error) {
+            try {
+                unlinkSync(join(path, "owner.json"));
+                release();
+            }
+            catch { /* Security: retain uncertain ownership. */ }
+            throw error;
+        }
+        return () => {
+            if (readWriterOwner(path)?.token !== owner.token)
+                throw new Error("Session writer ownership was lost");
+            // Concurrency: a legacy contender must not reclaim the short empty-directory release interval.
+            const now = new Date();
+            utimesSync(path, now, now);
+            unlinkSync(join(path, "owner.json"));
+            release();
+        };
     };
     return {
         acquire(requested) {
@@ -92,6 +114,54 @@ export function lockfileBackend(root = join(tmpdir(), "a1-session-writer-locks")
         },
     };
 }
+function readWriterOwner(path) {
+    try {
+        const source = readFileSync(join(path, "owner.json"), "utf8");
+        if (source.length > 1024)
+            return null;
+        const value = JSON.parse(source);
+        return Number.isSafeInteger(value.pid) && value.pid > 0 && typeof value.token === "string"
+            && /^[a-f0-9-]{36}$/.test(value.token) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writerAbsent(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error instanceof Error && "code" in error && error.code === "ESRCH";
+    }
+}
+function reclaimDeadWriter(path) {
+    if (!existsSync(path))
+        return;
+    const owner = readWriterOwner(path);
+    // Security: age and malformed/legacy records cannot prove that a writer is absent.
+    if (owner === null || !writerAbsent(owner.pid))
+        throw new Error("Session writer is live or unverifiable");
+    const gate = join(path, ".reclaim");
+    mkdirSync(gate);
+    try {
+        if (readWriterOwner(path)?.token !== owner.token || !writerAbsent(owner.pid))
+            throw new Error("Session writer changed during recovery");
+        const now = new Date();
+        utimesSync(path, now, now);
+        unlinkSync(join(path, "owner.json"));
+        rmdirSync(gate);
+        rmdirSync(path);
+    }
+    catch (error) {
+        try {
+            rmdirSync(gate);
+        }
+        catch { /* Security: a partial recovery remains conservatively blocked. */ }
+        throw error;
+    }
+}
 function backend() {
     return backendOverride ?? (cachedBackend ??= lockfileBackend());
 }

package/dist/foundation/startup/startup-descriptor.js

@@ -10,7 +10,7 @@ export const STARTUP_DESCRIPTOR = Object.freeze({
   ],
   "generatedArtifact": {
     "path": "dist/integrations/pi/startup-public.js",
-    "sha256": "e6a12f0ec3c5f2ada12bb29f8a02584f0724b37d107c29608b6629a4196cca13"
+    "sha256": "c1fca0ab0fe9d078a80faac1dad7d9f719cfc553645e38c2244a9c9ad381c205"
   },
   "dependencyLayerIdentity": {
     "source": "A1_RELEASE_LAYERS",
@@ -19,7 +19,7 @@ export const STARTUP_DESCRIPTOR = Object.freeze({
   "compileCacheNamespace": {
     "strategy": "node-abi-version-and-ordered-layer-sha256-v1"
   },
-  "identity": "1823698969cb8a551539b6351a7ba7b0756121369e6f9bf898347080d7892ece"
+  "identity": "3a54e70a22a20fa71dc2916cff394d4b06a3359677b3423002ff5b2dfbdccd70"
 });
 
 export function loadDeclaredStartupGraph() {

package/dist/foundation/terminal-cleanup/fatal-diagnostic.d.ts

@@ -0,0 +1,2 @@
+/** Loaded only on a failure; persistence must never impede terminal restoration. */
+export declare function writeFatalDiagnostic(directory: string, origin: string, error: unknown, releaseId?: string): Promise<string | null>;

package/dist/foundation/terminal-cleanup/fatal-diagnostic.js

@@ -0,0 +1,59 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/** Loaded only on a failure; persistence must never impede terminal restoration. */
+export async function writeFatalDiagnostic(directory, origin, error, releaseId) {
+    try {
+        // Security: only known classifications and code locations are retained, never private messages or objects.
+        const cleanupFailed = error instanceof AggregateError && error.cause instanceof Error;
+        const primary = cleanupFailed ? error.cause : error;
+        const classification = primary instanceof TypeError ? "TypeError" : primary instanceof RangeError ? "RangeError" : "Error";
+        const stack = primary instanceof Error && typeof primary.stack === "string" ? primary.stack.slice(0, 32768) : "";
+        const locations = stack.split("\n").slice(1).flatMap(line => {
+            const match = /\/(?:dist|src)\/([a-zA-Z0-9_./-]+\.[cm]?[jt]s):(\d+):(\d+)\)?$/.exec(line.replaceAll("\\", "/"));
+            return match ? [{ file: match[1].slice(0, 160), line: Number(match[2]), column: Number(match[3]) }] : [];
+        }).slice(0, 16);
+        const delivery = deliveryFailure(primary);
+        const record = {
+            timestamp: new Date().toISOString(),
+            origin: ["uncaughtException", "unhandledRejection", "entry", "delivery"].includes(origin) ? origin : "entry",
+            ...(delivery === null ? {} : { deliveryFailure: delivery }),
+            classification, cleanupFailed, locations, node: process.version, platform: process.platform,
+            releaseId: releaseId && /^[a-zA-Z0-9._-]{1,128}$/.test(releaseId) ? releaseId : "unknown",
+        };
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const name = `${origin === "delivery" ? "delivery" : "fatal"}-${Date.now()}-${randomUUID()}.json`;
+        const path = join(directory, name);
+        const text = JSON.stringify(record, null, 2);
+        if (Buffer.byteLength(text) > 16 * 1024)
+            return null;
+        await writeFile(path, text, { flag: "wx", mode: 0o600 });
+        const names = (await readdir(directory)).filter(file => /^(?:fatal|delivery)-\d+-[a-f0-9-]+\.json$/.test(file))
+            .sort((a, b) => Number(b.split("-")[1]) - Number(a.split("-")[1]));
+        await Promise.all(names.slice(10).map(file => unlink(join(directory, file)).catch(() => undefined)));
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+function deliveryFailure(error) {
+    if (!(error instanceof Error) || !("deliveryFailure" in error))
+        return null;
+    const value = error.deliveryFailure;
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (!["event-count", "retained-bytes", "listener"].includes(String(record.reason))
+        || !["snapshot", "session-view", "transcript-block", "session-lifecycle", "status", "editor-state", "terminal-surface",
+            "agent-run-started", "agent-run-settled", "assistant-message-completed", "command-outcome", "diagnostic"].includes(String(record.event)))
+        return null;
+    const result = { reason: String(record.reason), event: String(record.event) };
+    for (const key of ["generation", "pending", "bytes"]) {
+        const number = record[key];
+        if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0)
+            return null;
+        result[key] = number;
+    }
+    return result;
+}

package/dist/foundation/terminal-cleanup/fatal-exit.js

@@ -1,36 +1,8 @@
-import { randomUUID } from "node:crypto";
-import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
 import { writeSync } from "node:fs";
-import { join } from "node:path";
 import { boundedCleanup, restoreProcessTerminal } from "./terminal-reset.js";
 export async function writeFatalDiagnostic(directory, origin, error, releaseId) {
     try {
-        // Security: only known classifications and code locations are retained. Error messages,
-        // function names, arbitrary paths, and request objects are never persisted.
-        const cleanupFailed = error instanceof AggregateError && error.cause instanceof Error;
-        const primary = cleanupFailed ? error.cause : error;
-        const classification = primary instanceof TypeError ? "TypeError" : primary instanceof RangeError ? "RangeError" : "Error";
-        const stack = primary instanceof Error && typeof primary.stack === "string" ? primary.stack.slice(0, 32768) : "";
-        const locations = stack.split("\n").slice(1).flatMap(line => {
-            const match = /\/(?:dist|src)\/([a-zA-Z0-9_./-]+\.[cm]?[jt]s):(\d+):(\d+)\)?$/.exec(line.replaceAll("\\", "/"));
-            return match ? [{ file: match[1].slice(0, 160), line: Number(match[2]), column: Number(match[3]) }] : [];
-        }).slice(0, 16);
-        const record = {
-            timestamp: new Date().toISOString(),
-            origin: ["uncaughtException", "unhandledRejection", "entry"].includes(origin) ? origin : "entry",
-            classification, cleanupFailed, locations, node: process.version, platform: process.platform,
-            releaseId: releaseId && /^[a-zA-Z0-9._-]{1,128}$/.test(releaseId) ? releaseId : "unknown",
-        };
-        await mkdir(directory, { recursive: true, mode: 0o700 });
-        const name = `fatal-${Date.now()}-${randomUUID()}.json`;
-        const path = join(directory, name);
-        const text = JSON.stringify(record, null, 2);
-        if (Buffer.byteLength(text) > 16 * 1024)
-            return null;
-        await writeFile(path, text, { flag: "wx", mode: 0o600 });
-        const names = (await readdir(directory)).filter(file => /^fatal-\d+-[a-f0-9-]+\.json$/.test(file)).sort().reverse();
-        await Promise.all(names.slice(10).map(file => unlink(join(directory, file)).catch(() => undefined)));
-        return path;
+        return await (await import("./fatal-diagnostic.js")).writeFatalDiagnostic(directory, origin, error, releaseId);
     }
     catch {
         return null;

package/dist/integrations/pi/components/resources/builtin-themes.d.ts

@@ -1,6 +1,6 @@
 /**
- * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 1.5.1 (MIT),
- * commit dd30101cfc5b0609411dd80b6f93adbc14db14cf.
+ * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 1.5.2 (MIT),
+ * commit b4afdddf44e059c67ccf5097e5317d913521b470.
  * Upstream dark.json SHA-256: e1f96982f8cb7d2a48eca7db03c9cb282cb1e14a243680cd855638ecd6a251b6
  * Upstream light.json SHA-256: 2dee6a4be7f765e7fd7728166b7ebf8c29e4ce313f8ec6b38ae50699e3abc2f3
  * Modifications: removed upstream schema/export metadata; runtime color data is unchanged.

package/dist/integrations/pi/components/resources/builtin-themes.js

@@ -1,6 +1,6 @@
 /**
- * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 1.5.1 (MIT),
- * commit dd30101cfc5b0609411dd80b6f93adbc14db14cf.
+ * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 1.5.2 (MIT),
+ * commit b4afdddf44e059c67ccf5097e5317d913521b470.
  * Upstream dark.json SHA-256: e1f96982f8cb7d2a48eca7db03c9cb282cb1e14a243680cd855638ecd6a251b6
  * Upstream light.json SHA-256: 2dee6a4be7f765e7fd7728166b7ebf8c29e4ce313f8ec6b38ae50699e3abc2f3
  * Modifications: removed upstream schema/export metadata; runtime color data is unchanged.

package/dist/integrations/pi/components/share-operation-dialog.d.ts

@@ -1,8 +1,9 @@
+import type { ProgressSpinnerSource } from "../../../contracts/presentation/index.js";
 import { type PiShellComponentPort, type PiShellEditorOptions } from "./shell-shared-facade.js";
 export interface PiShellOperationLoaderPort extends PiShellComponentPort {
     readonly signal: AbortSignal;
     /** Relabels the running operation; the pinned comparison loader keeps its first label. */
     readonly setMessage?: (message: string) => void;
 }
-export declare function createPiShellShareOperationDialog(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, message: string): PiShellOperationLoaderPort;
+export declare function createPiShellShareOperationDialog(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, message: string, spinner?: ProgressSpinnerSource): PiShellOperationLoaderPort;
 export declare function createPiShellOperationLoader(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, message: string): PiShellOperationLoaderPort;

package/dist/integrations/pi/components/share-operation-dialog.js

@@ -1,5 +1,6 @@
 import { CancellableLoader, Spacer, Text, } from "@earendil-works/pi-tui";
 import { BorderedLoader, DynamicBorder } from "../startup-public.js";
+import { progressSpinnerFrame } from "../../../ui/components/index.js";
 import { adoptPiModalFrame, PiModalFrame } from "./modal-frame.js";
 import { DIALOG_CLOSE_SHORTCUT_HINT, paintPiBorder, piTheme, renderPiModalShortcutHints } from "./theme.js";
 import { componentPort, createTuiFacade, ensureTheme, } from "./shell-shared-facade.js";
@@ -7,26 +8,33 @@ import { componentPort, createTuiFacade, ensureTheme, } from "./shell-shared-fac
 class ShareOperationDialog {
     #loader;
     #frame;
-    constructor(runtime, message) {
+    #releaseSpinner;
+    constructor(runtime, message, spinner) {
         const theme = piTheme();
-        this.#loader = new CancellableLoader(createTuiFacade(runtime), text => theme.fg("accent", text), text => theme.fg("muted", text), message);
+        let phase = -1;
+        this.#loader = new CancellableLoader(createTuiFacade(runtime), currentFrame => {
+            phase += 1;
+            const glyph = progressSpinnerFrame(spinner?.snapshot() ?? "current", phase, currentFrame);
+            return glyph === "" ? "" : piTheme().fg("accent", glyph);
+        }, text => piTheme().fg("muted", text), message);
         this.#frame = new PiModalFrame(new DynamicBorder(paintPiBorder), [
             new Text(theme.fg("accent", theme.bold("Share")), 0, 0),
             this.#loader,
             new Spacer(1),
             new Text(renderPiModalShortcutHints([DIALOG_CLOSE_SHORTCUT_HINT]), 0, 0),
         ], new DynamicBorder(paintPiBorder));
+        this.#releaseSpinner = spinner?.onChange(() => this.#loader.invalidate());
     }
     get signal() { return this.#loader.signal; }
     setMessage(message) { this.#loader.setMessage(message); }
     invalidate() { this.#frame.invalidate(); }
     render(width) { return this.#frame.render(width); }
     handleInput(data) { this.#loader.handleInput(data); }
-    dispose() { this.#loader.dispose(); }
+    dispose() { this.#releaseSpinner?.(); this.#loader.dispose(); }
 }
-export function createPiShellShareOperationDialog(runtime, message) {
+export function createPiShellShareOperationDialog(runtime, message, spinner) {
     ensureTheme();
-    const dialog = new ShareOperationDialog(runtime, message);
+    const dialog = new ShareOperationDialog(runtime, message, spinner);
     return { ...componentPort(dialog), signal: dialog.signal, setMessage: message => dialog.setMessage(message) };
 }
 export function createPiShellOperationLoader(runtime, message) {

package/dist/integrations/pi/components/shell-footer-status.d.ts

@@ -1,8 +1,9 @@
 import type { OwnedUiShellKeybindings } from "../../../contracts/owned-ui/index.js";
+import type { ProgressSpinnerSource } from "../../../contracts/presentation/index.js";
 import type { OwnedUiSessionViewModel } from "../../../contracts/owned-ui/index.js";
 import { type PiShellViewComponentPort, type PiShellStatusPort, type PiShellProgressStatusPresentation, type PiShellQueuedInputPort, type PiShellHeaderPort, type PiShellResourceEntry, type PiShellLoadedResourcesPort, type PiShellHeaderOptions, type PiShellEditorOptions } from "./shell-shared-facade.js";
 export declare function createPiShellHeader(options?: PiShellHeaderOptions): PiShellHeaderPort;
 export declare function createPiShellLoadedResources(resources: readonly PiShellResourceEntry[], initialExpanded?: boolean): PiShellLoadedResourcesPort;
-export declare function createPiShellStatus(view: OwnedUiSessionViewModel, progressStatus: PiShellProgressStatusPresentation, runtime?: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">): PiShellStatusPort;
+export declare function createPiShellStatus(view: OwnedUiSessionViewModel, progressStatus: PiShellProgressStatusPresentation, runtime?: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, spinner?: ProgressSpinnerSource): PiShellStatusPort;
 export declare function createPiShellFooter(view: OwnedUiSessionViewModel, cwd: string, profile?: "pi" | "a1", showLevel?: () => boolean): PiShellViewComponentPort;
 export declare function createPiQueuedInputStatus(submissions: readonly string[], presentation?: "pinned" | "custom-viewport", getKeybindings?: () => OwnedUiShellKeybindings): PiShellQueuedInputPort;

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

@@ -1,3 +1,4 @@
+import { progressSpinnerFrame } from "../../../ui/components/progress-status.js";
 import { piKeybindings } from "./shell-shared-facade.js";
 import { rawKeyHint, VERSION } from "../startup-public.js";
 import { Spacer, Text, } from "@earendil-works/pi-tui";
@@ -74,7 +75,7 @@ export function createPiShellLoadedResources(resources, initialExpanded = false)
         invalidate() { },
     };
 }
-export function createPiShellStatus(view, progressStatus, runtime) {
+export function createPiShellStatus(view, progressStatus, runtime, spinner) {
     ensureTheme();
     const statusUi = createTuiFacade(runtime ?? { getColumns: () => 80, getRows: () => 24, requestRender() { } });
     let workingOverride;
@@ -83,7 +84,7 @@ export function createPiShellStatus(view, progressStatus, runtime) {
     let progressPresentation = "pinned";
     let placement = statusPlacement(view, workingOverride, workingOverrideActive);
     const liveStatusText = () => progressStatus.text(liveWorkingText(view, workingOverride, progressPresentation), progressPresentation);
-    let component = statusComponent(view, statusUi, outputPad, liveStatusText, placement, progressPresentation, progressStatus);
+    let component = statusComponent(view, statusUi, outputPad, liveStatusText, placement, progressPresentation, progressStatus, spinner);
     let signature = statusSignature(view, workingOverride, outputPad, placement, progressPresentation);
     const rebuild = () => {
         const nextPlacement = statusPlacement(view, workingOverride, workingOverrideActive);
@@ -105,8 +106,12 @@ export function createPiShellStatus(view, progressStatus, runtime) {
             component.dispose();
         placement = nextPlacement;
         signature = nextSignature;
-        component = statusComponent(view, statusUi, outputPad, liveStatusText, placement, progressPresentation, progressStatus);
+        component = statusComponent(view, statusUi, outputPad, liveStatusText, placement, progressPresentation, progressStatus, spinner);
     };
+    const releaseSpinner = spinner?.onChange(() => {
+        if (progressPresentation === "custom-viewport")
+            component?.invalidate();
+    });
     return {
         render: width => appendInstalledUpdateStatus(component?.render(width) ?? [], width, view, progressPresentation),
         renderDock: width => placement === "dock" ? component?.render(width) ?? [] : [],
@@ -131,6 +136,7 @@ export function createPiShellStatus(view, progressStatus, runtime) {
             rebuild();
         },
         dispose() {
+            releaseSpinner?.();
             if (component !== undefined && "dispose" in component && typeof component.dispose === "function")
                 component.dispose();
             component = undefined;
@@ -201,21 +207,22 @@ function liveWorkingText(view, workingOverride, progressPresentation) {
         : message;
 }
 class OwnedWorkingStatusIndicator extends StatusIndicator {
-    constructor(ui, message, frame) {
+    constructor(ui, message, frame, spinner) {
         let phase = -1;
-        super("working", ui, spinner => {
+        super("working", ui, defaultFrame => {
             phase += 1;
-            return piTheme().fg("accent", spinner);
+            const glyph = progressSpinnerFrame(spinner?.snapshot() ?? "current", phase, defaultFrame);
+            return glyph === "" ? "" : piTheme().fg("accent", glyph);
         }, text => frame(text, phase, {
             muted: value => piTheme().fg("muted", value),
             highlight: value => piTheme().fg("text", value),
         }), message);
     }
 }
-function statusComponent(view, ui, outputPad, liveStatusText, placement, progressPresentation, progressStatus) {
+function statusComponent(view, ui, outputPad, liveStatusText, placement, progressPresentation, progressStatus, spinner) {
     if (placement === "live") {
         return progressPresentation === "custom-viewport"
-            ? new OwnedWorkingStatusIndicator(ui, liveStatusText(), progressStatus.frame)
+            ? new OwnedWorkingStatusIndicator(ui, liveStatusText(), progressStatus.frame, spinner)
             : new WorkingStatusIndicator(ui, liveStatusText());
     }
     if (placement === "dock") {