@timurproko/a1 0.2.4-dev.663 → 0.2.4-dev.667

package/README.md

@@ -1,81 +1,231 @@
-# A1
+<p align="center">
+  <a href="https://agentnumberone.dev"><img src="docs/assets/readme/mark.svg" alt="a1" width="112"></a>
+</p>
+
+<p align="center">
+  An open-source AI coding agent for the terminal, built on the pi engine.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@timurproko/a1"><img alt="npm" src="https://img.shields.io/npm/v/@timurproko/a1?style=flat-square&color=2638d2"></a>
+  <a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-2638d2?style=flat-square"></a>
+  <a href="https://agentnumberone.dev"><img alt="Website" src="https://img.shields.io/badge/web-agentnumberone.dev-2638d2?style=flat-square"></a>
+</p>
 
 ## Install
 
+Release:
+
+```sh
+npm x -y -- @timurproko/a1-install
+```
+
+Develop:
+
 ```sh
-npm x -y -- @timurproko/a1-install                           # release
-npm x -y -- @timurproko/a1-install --develop                 # develop
-npm x -y -- @timurproko/a1-install --develop 107             # preview number
-npm x -y -- @timurproko/a1-install --develop 0.1.8-dev.107   # exact preview
+npm x -y -- @timurproko/a1-install --develop
 ```
 
+Preview number:
+
+```sh
+npm x -y -- @timurproko/a1-install --develop 107
+```
+
+Exact preview:
+
+```sh
+npm x -y -- @timurproko/a1-install --develop 0.1.8-dev.107
+```
+
+<p align="center"><picture><img src="docs/assets/readme/terminal.svg" alt="" width="240"></picture></p>
+
 ## Use
 
+Launch A1 (profile: `~/.a1/agent`):
+
+```sh
+a1
+```
+
+Show all commands:
+
+```sh
+a1 help
+```
+
+Show the current and latest versions:
+
+```sh
+a1 version
+```
+
+Vanilla Pi oracle (`~/.pi/agent`):
+
+```sh
+a1 pi
+```
+
+### Update
+
+Install the release:
+
 ```sh
-a1                                      # launch A1 (profile: ~/.a1/agent)
-a1 help                                 # show all commands
-a1 version                              # show the current and latest versions
-a1 pi                                   # vanilla Pi oracle: ~/.pi/agent
+a1 update
 ```
 
-Update:
+Install develop:
 
 ```sh
-a1 update                               # install the release
-a1 update --develop                     # install develop
-a1 update --develop 107                 # install preview 107
-a1 update --develop 0.1.8-dev.107       # install that exact preview
-a1 update --models                      # refresh A1's model catalogs
+a1 update --develop
 ```
 
-On interactive startup A1 checks, at most once a day, whether a newer release exists on its own channel and shows an `Update Available` notice with the command to run. It never installs anything. Turn it off with the `Update check` setting (Generic section), or set `A1_SKIP_VERSION_CHECK=1`; it is also skipped when `PI_OFFLINE` or `CI` is set, or when output is not a terminal. The check reads the public npm registry, or `npm_config_registry` when set.
+Install preview 107:
+
+```sh
+a1 update --develop 107
+```
+
+Install that exact preview:
+
+```sh
+a1 update --develop 0.1.8-dev.107
+```
+
+Refresh A1's model catalogs:
+
+```sh
+a1 update --models
+```
+
+Stuck on `0.2.2` and `a1 update` fails? Run the installer once, then use `a1 update` as usual:
+
+```sh
+npm x -y -- @timurproko/a1-install
+```
+
+A1 shows an `Update Available` notice at most once a day and never installs anything by itself. Turn it off in Settings (`Update check`) or with `A1_SKIP_VERSION_CHECK=1`.
+
+<p align="center"><picture><img src="docs/assets/readme/plugins.svg" alt="" width="240"></picture></p>
 
 ## Extensions
 
+Install a package:
+
 ```sh
-a1 install npm:pi-mcp-adapter          # install a package
-a1 remove npm:pi-mcp-adapter           # remove it (alias: a1 uninstall)
-a1 list                                # list installed packages
+a1 install npm:pi-mcp-adapter
 ```
 
-Update:
+Remove it (alias: `a1 uninstall`):
 
 ```sh
-a1 update --extensions                 # update every installed package
-a1 update npm:pi-mcp-adapter           # update one
+a1 remove npm:pi-mcp-adapter
 ```
 
+List installed packages:
+
+```sh
+a1 list
+```
+
+Update every installed package:
+
+```sh
+a1 update --extensions
+```
+
+Update one:
+
+```sh
+a1 update npm:pi-mcp-adapter
+```
+
+<p align="center"><picture><img src="docs/assets/readme/gears.svg" alt="" width="240"></picture></p>
+
 ## Develop
 
+Install exact locked dependencies:
+
 ```sh
-npm ci                                  # install exact locked dependencies
-npm run build                           # compile TypeScript and the process guardian into dist
-npm start                               # build and launch a source `a1`
-npm run start:pi                        # build and launch a source `a1 pi`
-npm run test:fast                       # typecheck + fast suite (alias: npm test)
-npm run test:full                       # complete non-physical suite
-npm run doctor                          # report Node, npm, git, Rust, and dependency readiness
+npm ci
 ```
 
+Compile TypeScript and the process guardian into `dist`:
+
+```sh
+npm run build
+```
+
+Build and launch a source `a1`:
+
+```sh
+npm start
+```
+
+Build and launch a source `a1 pi`:
+
+```sh
+npm run start:pi
+```
+
+Typecheck + fast suite (alias: `npm test`):
+
+```sh
+npm run test:fast
+```
+
+Complete non-physical suite:
+
+```sh
+npm run test:full
+```
+
+Report Node, npm, git, Rust, and dependency readiness:
+
+```sh
+npm run doctor
+```
+
+Preview the README as GitHub renders it, in your browser (needs `gh`):
+
+```sh
+npm run preview:readme
+```
+
+<p align="center"><picture><img src="docs/assets/readme/rocket.svg" alt="" width="240"></picture></p>
+
 ## Publish
 
 ### Develop
 
+Request the preview publish:
+
 ```sh
-npm run develop                         # request the preview publish
+npm run develop
 ```
 
 ### Release
 
 ```sh
 npm run release -- patch               # 0.1.8-dev -> 0.1.8
+```
+
+```sh
 npm run release -- minor               # 0.1.8-dev -> 0.2.0
+```
+
+```sh
 npm run release -- major               # 0.1.8-dev -> 1.0.0
+```
+
+```sh
 npm run release -- 0.4.0               # prepare an exact stable version
 ```
 
-The command creates the draft, starts validation of its source, prints the progress
-link, and waits. When validation passes it prints the draft link: edit the Pi-style
-`## [version] - YYYY-MM-DD` changelog, then choose
-GitHub's native **Publish release** button: that publishes both packages to npm. If
-publication fails before npm, the Release returns to draft so you can publish it again.
+Once validation passes, open the printed draft link, edit the `## [version] - YYYY-MM-DD` changelog, and press **Publish release** to publish to npm. Details: [release runbook](docs/ci-release-runbook.md).
+
+<br>
+
+<p align="center">
+  <picture><img src="docs/assets/readme/waves.svg" alt="" width="100%"></picture>
+</p>

package/dist/app/session-shell/exit-notice.d.ts

@@ -0,0 +1,14 @@
+import { type SessionResumeCommandMetadata } from "./session-shell.js";
+export interface ExitNoticeSource {
+    readonly sessionGeneration: number;
+    currentSessionResumeMetadata(): SessionResumeCommandMetadata | null;
+    onEvent(listener: (event: {
+        readonly type: string;
+    }) => void): () => void;
+}
+export interface ArmedExitNotice {
+    clear(): void;
+}
+export declare function uncleanExitNoticeLines(resume: SessionResumeCommandMetadata | null): string[];
+/** Arms the notice and keeps its resume command following the bound session until cleared. */
+export declare function armExitNotice(source: ExitNoticeSource, path: string): ArmedExitNotice;

package/dist/app/session-shell/exit-notice.js

@@ -0,0 +1,59 @@
+/**
+ * The runtime's half of the unclean-exit protocol with the native process guardian. While the
+ * notice is armed, the guardian treats the runtime's end as unclean: it restores the terminal and
+ * prints these lines, so a killed session still leaves its resume command behind. A clean shutdown
+ * clears the notice after the terminal is restored.
+ */
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { formatSessionResumeCommand } from "./session-shell.js";
+export function uncleanExitNoticeLines(resume) {
+    return [
+        `${PRODUCT_IDENTITY.displayName} was stopped unexpectedly.`,
+        ...(resume === null ? [] : [`To resume this session: ${formatSessionResumeCommand(resume)}`]),
+    ];
+}
+/** Arms the notice and keeps its resume command following the bound session until cleared. */
+export function armExitNotice(source, path) {
+    let current = null;
+    let cleared = false;
+    let generation = source.sessionGeneration;
+    const write = () => {
+        if (cleared)
+            return;
+        // Protocol: plain text only; the guardian strips control characters, so styling would be lost.
+        const text = `${uncleanExitNoticeLines(source.currentSessionResumeMetadata()).join("\n")}\n`;
+        if (text === current)
+            return;
+        try {
+            // Invariant: the guardian may read at any instant, so it sees the previous or the next notice, never half of one.
+            const temporary = `${path}.${process.pid}.tmp`;
+            writeFileSync(temporary, text, { mode: 0o600 });
+            renameSync(temporary, path);
+            current = text;
+        }
+        catch { }
+    };
+    write();
+    const unsubscribe = source.onEvent(event => {
+        // Rationale: a session is persisted by its first response and replaced by /new or /resume;
+        // these events cover both without touching the per-chunk stream.
+        const replaced = source.sessionGeneration !== generation;
+        if (!replaced && event.type !== "session-lifecycle" && event.type !== "assistant-message-completed")
+            return;
+        generation = source.sessionGeneration;
+        write();
+    });
+    return {
+        clear() {
+            if (cleared)
+                return;
+            cleared = true;
+            unsubscribe();
+            try {
+                rmSync(path, { force: true });
+            }
+            catch { }
+        },
+    };
+}

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

@@ -1094,7 +1094,7 @@ export class OwnedUiSessionShell {
     showLoginProviderSelector(authType, initialSearchInput) {
         const options = this.backend.pinnedLoginOptions(authType);
         if (options.length === 0) {
-            this.root.appendWorkflowStatus(authType === "oauth" ? "No subscription providers available." : authType === "api_key" ? "No API key providers available." : "No login providers available.");
+            this.root.appendWorkflowStatus(authType === "oauth" ? "No account providers available." : authType === "api_key" ? "No API key providers available." : "No login providers available.");
             this.runtime.requestRender();
             return;
         }

package/dist/composition/owned-ui.js

@@ -184,9 +184,17 @@ export async function composeOwnedUi(options = {}) {
         if (release !== null)
             adapter.announceReleaseUpdate(release);
     };
+    const exitNoticePath = process.env[PRODUCT_IDENTITY.environment.exitNoticePath];
+    // Security: tools the agent runs must never see, or rewrite, this instance's notice.
+    delete process.env[PRODUCT_IDENTITY.environment.exitNoticePath];
+    let exitNotice = Promise.resolve(null);
     const application = {
         get disposed() { return adapter.disposed; },
         start: () => {
+            // Performance: the guardian notice loads beside first paint, never on the startup path.
+            if (exitNoticePath)
+                exitNotice = import("../app/session-shell/exit-notice.js")
+                    .then(module => module.armExitNotice(adapter, exitNoticePath), () => null);
             shell.start();
             void announceNewerRelease().catch(() => undefined);
         },
@@ -195,6 +203,8 @@ export async function composeOwnedUi(options = {}) {
         dispose: async () => {
             try {
                 await shell.dispose();
+                // Invariant: cleared only once the terminal is restored; a failed dispose leaves it armed.
+                (await exitNotice)?.clear();
                 await releaseNoteAcknowledgement?.catch(() => undefined);
             }
             finally {

package/dist/foundation/launch-guardian/main.js

@@ -30,7 +30,7 @@ export async function runLaunchGuardian(options) {
         : paths.endpoint;
     await client.connect(endpoint);
     await markStartupPhase(environment, "guardian-connected");
-    const containment = options.containment ?? new NativeGuardianContainment(instanceId, helperPath, resolve(paths.runtimeDir, "launch-instances", `${instanceId}.ready.json`));
+    const containment = options.containment ?? new NativeGuardianContainment(instanceId, helperPath, resolve(paths.runtimeDir, "launch-instances", `${instanceId}.ready.json`), resolve(paths.runtimeDir, "launch-instances", `${instanceId}.exit-notice`));
     const stop = stopRequests(client, instanceId);
     let rootIdentity = null;
     try {

package/dist/foundation/process-containment/native-guardian-containment.d.ts

@@ -6,7 +6,8 @@ export declare class NativeGuardianContainment implements ProcessContainment {
     readonly instanceId: string;
     readonly helperPath: string;
     readonly statusPath: string;
-    constructor(instanceId: string, helperPath: string, statusPath: string);
+    readonly exitNoticePath: string | null;
+    constructor(instanceId: string, helperPath: string, statusPath: string, exitNoticePath?: string | null);
     get identity(): ProcessContainmentIdentity;
     spawn(executable: string, arguments_: readonly string[], options: ContainedSpawnOptions): Promise<ContainedProcessHandle>;
     contains(identity: NativeProcessIdentity): Promise<boolean>;

package/dist/foundation/process-containment/native-guardian-containment.js

@@ -11,10 +11,12 @@ export class NativeGuardianContainment {
     instanceId;
     helperPath;
     statusPath;
-    constructor(instanceId, helperPath, statusPath) {
+    exitNoticePath;
+    constructor(instanceId, helperPath, statusPath, exitNoticePath = null) {
         this.instanceId = instanceId;
         this.helperPath = helperPath;
         this.statusPath = statusPath;
+        this.exitNoticePath = exitNoticePath;
         this.#identity = { provider: "native-guardian-pending", token: instanceId };
     }
     get identity() {
@@ -25,14 +27,22 @@ export class NativeGuardianContainment {
             throw new Error("process containment already has a root runtime");
         await mkdir(dirname(this.statusPath), { recursive: true, mode: 0o700 });
         await rm(this.statusPath, { force: true });
+        if (this.exitNoticePath)
+            await rm(this.exitNoticePath, { force: true });
         const helper = spawn(this.helperPath, [
             "--parent-pid", String(process.pid),
             "--instance", this.instanceId,
             "--status-file", this.statusPath,
+            ...(this.exitNoticePath ? ["--exit-notice", this.exitNoticePath] : []),
             "--", executable, ...arguments_,
         ], {
             cwd: options.cwd,
-            env: { ...options.environment, ...(options.terminalType ? { TERM: options.terminalType } : {}) },
+            env: {
+                ...options.environment,
+                ...(options.terminalType ? { TERM: options.terminalType } : {}),
+                // Protocol: the runtime arms this notice and the guardian prints it if the runtime dies unclean.
+                ...(this.exitNoticePath ? { [PRODUCT_IDENTITY.environment.exitNoticePath]: this.exitNoticePath } : {}),
+            },
             shell: false,
             stdio: "inherit",
             windowsHide: false,
@@ -79,6 +89,8 @@ export class NativeGuardianContainment {
             helper.kill("SIGKILL");
         await this.waitForEmpty(1_500);
         await rm(this.statusPath, { force: true });
+        if (this.exitNoticePath)
+            await rm(this.exitNoticePath, { force: true });
     }
 }
 export function resolveProcessGuardianPath(releaseRoot, environment = process.env, platform = process.platform, architecture = process.arch) {

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

@@ -41,6 +41,8 @@ export interface ProtectedPackageReplacementOptions {
     readonly globalRoot: string;
     /** Root used only to locate the active npm implementation; installation remains pinned to globalRoot. */
     readonly npmCliRoot?: string;
+    /** Canonical entry established before update lifecycle mutation and revalidated when the capsule is committed. */
+    readonly npmCli?: string;
     readonly packageRoot: string;
     readonly transaction: UpdateTransaction;
     readonly priorRelease: {

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

@@ -119,7 +119,9 @@ export async function prepareUpdateRecoveryCapsule(options) {
         const prefix = npmPrefixForGlobalRoot(canonicalGlobal, platform);
         const launcherRoot = platform === "win32" ? prefix : resolve(prefix, "bin");
         const npmCliRoot = await realpath(options.npmCliRoot ?? canonicalGlobal);
-        const npmCli = await resolveNpmCli(npmCliRoot, options.environment ?? process.env, platform);
+        const npmCli = options.npmCli === undefined
+            ? await resolveNpmCli(npmCliRoot, options.environment ?? process.env, platform)
+            : await requireCanonicalNpmCli(options.npmCli);
         const capsule = {
             schema: UPDATE_RECOVERY_SCHEMA,
             launchContract: PRIVATE_LAUNCH_CONTRACT,
@@ -300,7 +302,10 @@ async function spawnRecoveryWorker(entry, manifestPath, environment) {
     child.unref();
 }
 export async function resolveNpmCli(globalRoot, environment, platform = process.platform, nodeExecutable = process.execPath) {
-    const candidates = [environment.npm_execpath, resolve(globalRoot, "npm", "bin", "npm-cli.js")]
+    const declaredNpmEntry = platform === "win32"
+        ? windowsEnvironmentValue(environment, "npm_execpath")
+        : environment.npm_execpath;
+    const candidates = [declaredNpmEntry, resolve(globalRoot, "npm", "bin", "npm-cli.js")]
         .filter((value) => typeof value === "string" && value.length > 0);
     for (const candidate of candidates) {
         const canonical = await canonicalRegularFile(candidate);
@@ -342,12 +347,20 @@ async function windowsNpmCliFromPath(environment) {
     return null;
 }
 function windowsEnvironmentValue(environment, name) {
+    if (Object.hasOwn(environment, name))
+        return environment[name];
     const key = Object.keys(environment).find(candidate => candidate.toLowerCase() === name.toLowerCase());
     return key ? environment[key] : undefined;
 }
 function unquoteWindowsPathEntry(value) {
     return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
 }
+async function requireCanonicalNpmCli(path) {
+    const canonical = await canonicalRegularFile(path);
+    if (!canonical)
+        throw new Error("preflight npm JavaScript entry is no longer a regular file");
+    return canonical;
+}
 async function canonicalRegularFile(path) {
     const canonical = await realpath(path).catch(() => null);
     if (!canonical)

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

@@ -1,7 +1,7 @@
 import type { UpdateChannel } from "./types.js";
 import { type UpdateActivationPhase, type UpdateMaterializationProgress } from "./update-activation.js";
 import { type UpdateRecoveryState, type UpdateTransaction, type UpdateTransactionPhase } from "./update-transaction.js";
-import { type ProtectedPackageReplacementResult } from "./update-recovery.js";
+import { resolveNpmCli, type ProtectedPackageReplacementResult } from "./update-recovery.js";
 export declare const PRODUCT_PACKAGE: string;
 export type { UpdateChannel } from "./types.js";
 export interface ProcessRequest {
@@ -69,6 +69,8 @@ export interface SelfUpdateOptions {
     transactionStore?: UpdateTransactionJournal;
     /** Test seam for protected global package replacement. */
     packageReplacement?: (input: UpdatePackageReplacementInput) => Promise<ProtectedPackageReplacementResult>;
+    /** Test seam for proving replacement-authority preflight ordering. */
+    npmCliResolver?: typeof resolveNpmCli;
     /** Test or embedding seam for post-activation release maintenance. */
     maintenance?: () => Promise<void>;
     progress?: boolean;
@@ -102,6 +104,7 @@ export interface UpdatePackageReplacementInput {
     readonly dataDir: string;
     readonly globalRoot: string;
     readonly npmCliRoot: string;
+    readonly npmCli?: string;
     readonly packageRoot: string;
     readonly transaction: UpdateTransaction;
     readonly priorRelease: {

package/dist/foundation/release/update.js

@@ -16,7 +16,7 @@ import { materializeRelease, readMaterializedRelease } from "./release-store.js"
 import { scheduleReleaseCleanup } from "./release-gc.js";
 import { UPDATE_ACTIVATION_CONTRACT, activateInstalledRelease, delegateActivation, readActivationContracts, } from "./update-activation.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
-import { npmPrefixForGlobalRoot, removeUpdateRecoveryCapsule, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
+import { npmPrefixForGlobalRoot, removeUpdateRecoveryCapsule, resolveNpmCli, runProtectedPackageReplacement, updateLauncherPaths, updateNpmInstallArguments, } from "./update-recovery.js";
 export const PRODUCT_PACKAGE = PRODUCT_TEXT.packageName;
 const UPDATE_DIST_TAGS = { stable: "latest", next: "next" };
 const defaultFileSystem = {
@@ -520,6 +520,7 @@ export async function runSelfUpdate(options) {
         ? async () => { }
         : async () => await scheduleReleaseCleanup(paths.dataDir, paths));
     let transaction = await transactionStore.read();
+    let npmCli;
     try {
         if ((!transaction || transaction.status === "completed") && await lifecycle.targetIsActive(targetVersion)) {
             await maintenance();
@@ -527,7 +528,17 @@ export async function runSelfUpdate(options) {
             output.stdout(`${PRODUCT_TEXT.commandName} is up to date — no update needed.\n`);
             return 0;
         }
-        // Rationale: the bar first appears here so a no-change run never flashes it.
+        const preflightRequired = options.npmCliResolver !== undefined
+            || options.packageReplacement === undefined && options.runner === undefined;
+        if (preflightRequired) {
+            try {
+                npmCli = await (options.npmCliResolver ?? resolveNpmCli)(npmCliRoot, environment);
+            }
+            catch (error) {
+                throw new UpdatePreflightFailure(errorMessage(error));
+            }
+        }
+        // Rationale: the bar first appears only after every non-mutating replacement prerequisite passes.
         progress.set(3, 15);
         const cohortStore = new CohortStateStore(paths.dataDir);
         let cohortState = await cohortStore.read();
@@ -573,6 +584,7 @@ export async function runSelfUpdate(options) {
                     dataDir: paths.dataDir,
                     globalRoot,
                     npmCliRoot,
+                    ...(npmCli === undefined ? {} : { npmCli }),
                     packageRoot,
                     transaction: replacementTransaction,
                     priorRelease,
@@ -655,6 +667,10 @@ export async function runSelfUpdate(options) {
     catch (error) {
         progress.clear();
         const message = errorMessage(error);
+        if (error instanceof UpdatePreflightFailure) {
+            output.stderr(`${PRODUCT_TEXT.diagnostic(`update could not start safely: ${message}. Nothing was changed. Retry with npm x -y -- ${PRODUCT_PACKAGE}-install`)}\n`);
+            return 1;
+        }
         const rollback = options.lifecycle
             ? "previous test lifecycle retained"
             : await rollbackPriorCohort(paths.dataDir, environment, transaction?.priorActiveReleaseId ?? null).catch(rollbackError => `rollback failed: ${errorMessage(rollbackError)}`);
@@ -760,6 +776,8 @@ class UpdateFailure extends Error {
     exitCode;
     constructor(exitCode, message) { super(message); this.exitCode = exitCode; }
 }
+class UpdatePreflightFailure extends Error {
+}
 async function canonicalImmutableRoot(dataDir, releaseRoot) {
     try {
         const [store, selected] = await Promise.all([realpath(resolve(dataDir, "releases")), realpath(releaseRoot)]);

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": "10be6744beda393db760b38cb367f047881b6c5e72819c2b0f07d196088e7813"
+    "sha256": "cb2331c550009704bce2614f2f7fb6e1b45ed00403be804da3b83c1ea90a17c4"
   },
   "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": "14172049798e27f0442cad5289bbabb876c9c9490fd750b77af0ce0f8bd5adbb"
+  "identity": "54cea64be46c7a0d36ab6a1889206f79813dba6b9884387b391440fe30a1fdee"
 });
 
 export function loadDeclaredStartupGraph() {

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 0.99.2 (MIT),
- * commit 005af57d88ee23b33778f343a9595b32e67ff788.
+ * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 1.0.0 (MIT),
+ * commit a13d35a742c6ef8462812a28fbe1d8c8b7431c32.
  * Upstream dark.json SHA-256: c11a588b714d35300293079b425fb09a3693d4b2d453585d211b08163c648b75
  * Upstream light.json SHA-256: f590c51c2bc8b238891efd0e983473ed2e2a6487b6692cc1d4b2845165e703f7
  * 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 0.99.2 (MIT),
- * commit 005af57d88ee23b33778f343a9595b32e67ff788.
+ * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 1.0.0 (MIT),
+ * commit a13d35a742c6ef8462812a28fbe1d8c8b7431c32.
  * Upstream dark.json SHA-256: c11a588b714d35300293079b425fb09a3693d4b2d453585d211b08163c648b75
  * Upstream light.json SHA-256: f590c51c2bc8b238891efd0e983473ed2e2a6487b6692cc1d4b2845165e703f7
  * Modifications: removed upstream schema/export metadata; runtime color data is unchanged.

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

@@ -1,7 +1,7 @@
 import { rawKeyHint, VERSION } from "../startup-public.js";
 import { Spacer, Text, } from "@earendil-works/pi-tui";
 import { SessionFooter } from "./upstream/components/session-footer.js";
-import { piLogoLines } from "./upstream/components/pi-logo.js";
+import { piLogoLines, piWordmark, supportsPiLogo, } from "./upstream/components/pi-logo.js";
 import { ThemedText } from "./upstream/components/themed-text.js";
 import { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
 import { StatusIndicator, WorkingStatusIndicator } from "./upstream/components/status-indicator.js";
@@ -300,8 +300,11 @@ function expandedHeaderText(bindings) {
     return `${headerWithLogo(instructions)}\n\n${onboarding}`;
 }
 function headerWithLogo(hints) {
+    const version = piTheme().fg("dim", `v${VERSION}`);
+    if (!supportsPiLogo())
+        return `${piWordmark()} ${version}\n${hints}`;
     const [top, bottom] = piLogoLines();
-    return `${top} ${piTheme().fg("dim", `v${VERSION}`)}\n${bottom} ${hints}`;
+    return `${top} ${version}\n${bottom} ${hints}`;
 }
 function noticeText(notice) {
     const theme = piTheme();

package/dist/integrations/pi/components/upstream/adjacent/core/keybindings.d.ts

@@ -1,5 +1,5 @@
 /**
- * Provenance: @earendil-works/pi-coding-agent 0.99.2 (MIT), commit 005af57d88ee23b33778f343a9595b32e67ff788,
+ * Provenance: @earendil-works/pi-coding-agent 1.0.0 (MIT), commit a13d35a742c6ef8462812a28fbe1d8c8b7431c32,
  * packages/coding-agent/src/core/keybindings.ts.
  * Modifications: Mechanical source port with Node import prefixes, public package-root agent-directory
  * resolution, and an opt-in bare-A1 input profile including Ctrl+L level cycling, unbound model