@timurproko/a1 0.1.8-dev.544 → 0.1.8-dev.558

package/dist/foundation/lifecycle/session-repository-context.js

@@ -0,0 +1,173 @@
+import { createHash, randomUUID } from "node:crypto";
+import { open, lstat, mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { resolveProductPaths } from "./paths.js";
+const SCHEMA = "a1-session-repository-context-v1";
+const MAX_RECORD_BYTES = 16 * 1024;
+const MAX_HEADER_BYTES = 64 * 1024;
+const GIT_TIMEOUT_MS = 5_000;
+/** Persist one explicit same-repository worktree association for a stable Pi session. */
+export async function setSessionRepositoryContext(identity, worktreePath, options = {}) {
+    const header = await readSessionHeader(identity);
+    const startup = await readGitWorktreeIdentity(header.cwd, false, options.signal);
+    const selected = await readGitWorktreeIdentity(worktreePath, true, options.signal);
+    if (!samePath(startup.commonDir, selected.commonDir)) {
+        throw new Error("associated worktree belongs to a different Git repository");
+    }
+    const record = {
+        schema: SCHEMA,
+        sessionId: header.id,
+        sessionFile: header.file,
+        startupRoot: startup.root,
+        startupCommonDir: startup.commonDir,
+        worktreeRoot: selected.root,
+        worktreeCommonDir: selected.commonDir,
+        worktreeGitDir: selected.gitDir,
+        updatedAt: new Date().toISOString(),
+    };
+    const destination = recordPath(header, options);
+    const directory = dirname(destination);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await rename(temporary, destination);
+    }
+    finally {
+        await rm(temporary, { force: true }).catch(() => undefined);
+    }
+    return { cwd: selected.root, branch: requireBranch(selected) };
+}
+/** Remove only the association belonging to the supplied stable session. */
+export async function clearSessionRepositoryContext(identity, options = {}) {
+    const header = await readSessionHeader(identity);
+    await rm(recordPath(header, options), { force: true });
+}
+/** Read and revalidate a persisted association; malformed or stale state fails closed to absence. */
+export async function readSessionRepositoryContext(identity, options = {}) {
+    let header;
+    try {
+        header = await readSessionHeader(identity);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const path = recordPath(header, options);
+        const metadata = await lstat(path);
+        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size === 0 || metadata.size > MAX_RECORD_BYTES)
+            return null;
+        const bytes = await readFile(path, { signal: options.signal });
+        const value = JSON.parse(bytes.toString("utf8"));
+        if (!isRecord(value)
+            || value.schema !== SCHEMA
+            || value.sessionId !== header.id
+            || value.sessionFile !== header.file
+            || !validPath(value.startupRoot)
+            || !validPath(value.startupCommonDir)
+            || !validPath(value.worktreeRoot)
+            || !validPath(value.worktreeCommonDir)
+            || !validPath(value.worktreeGitDir)
+            || typeof value.updatedAt !== "string")
+            return null;
+        const startup = await readGitWorktreeIdentity(header.cwd, false, options.signal);
+        const selected = await readGitWorktreeIdentity(value.worktreeRoot, true, options.signal);
+        if (!samePath(startup.root, value.startupRoot)
+            || !samePath(startup.commonDir, value.startupCommonDir)
+            || !samePath(selected.root, value.worktreeRoot)
+            || !samePath(selected.commonDir, value.worktreeCommonDir)
+            || !samePath(selected.gitDir, value.worktreeGitDir)
+            || !samePath(startup.commonDir, selected.commonDir))
+            return null;
+        return { cwd: selected.root, branch: requireBranch(selected) };
+    }
+    catch {
+        return null;
+    }
+}
+async function readSessionHeader(identity) {
+    if (!validSessionId(identity.sessionId) || !validPath(identity.sessionFile))
+        throw new Error("active session identity is unavailable");
+    const file = await realpath(resolve(identity.sessionFile));
+    const handle = await open(file, "r");
+    try {
+        const buffer = Buffer.alloc(MAX_HEADER_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, 0);
+        const newline = buffer.subarray(0, bytesRead).indexOf(0x0a);
+        if (newline < 0)
+            throw new Error("session header is unavailable");
+        const value = JSON.parse(buffer.subarray(0, newline).toString("utf8"));
+        if (!isRecord(value) || value.type !== "session" || value.id !== identity.sessionId || !validPath(value.cwd)) {
+            throw new Error("active session identity does not match its session file");
+        }
+        return { id: identity.sessionId, cwd: await realpath(resolve(value.cwd)), file };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function readGitWorktreeIdentity(path, requireWorktreeRoot, signal) {
+    if (!validPath(path))
+        throw new Error("associated worktree path is invalid");
+    const cwd = await realpath(resolve(path));
+    const { stdout } = await executeGit(["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir", "--git-dir"], cwd, MAX_RECORD_BYTES, signal);
+    const lines = stdout.split(/\r?\n/u).filter(Boolean);
+    if (lines.length !== 3)
+        throw new Error("associated worktree identity is invalid");
+    const [rootValue, commonValue, gitValue] = lines;
+    if (!rootValue || !commonValue || !gitValue)
+        throw new Error("associated worktree identity is incomplete");
+    const root = await realpath(rootValue);
+    if (requireWorktreeRoot && !samePath(root, cwd))
+        throw new Error("associated path must be a Git worktree root");
+    const commonDir = await realpath(commonValue);
+    const gitDir = await realpath(gitValue);
+    let branch = null;
+    if (requireWorktreeRoot) {
+        const branchResult = await executeGit(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd, 4_096, signal);
+        branch = branchResult.stdout.trim();
+        if (branch.length === 0 || branch.length > 256)
+            throw new Error("associated worktree has a detached or invalid branch");
+    }
+    return { root, commonDir, gitDir, branch };
+}
+async function executeGit(arguments_, cwd, maxBuffer, signal) {
+    const { execFile } = await import("node:child_process");
+    const execute = promisify(execFile);
+    return await execute("git", [...arguments_], {
+        cwd,
+        windowsHide: true,
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer,
+        encoding: "utf8",
+        signal,
+    });
+}
+function requireBranch(identity) {
+    if (identity.branch === null)
+        throw new Error("associated worktree branch is unavailable");
+    return identity.branch;
+}
+function recordPath(header, options) {
+    const dataDir = options.dataDir ?? resolveProductPaths().dataDir;
+    const digest = createHash("sha256").update(header.id).update("\0").update(pathKey(header.file)).digest("hex");
+    return join(dataDir, PRODUCT_IDENTITY.state.sessionRepositoryDirectory, `${digest}.json`);
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function pathKey(value) {
+    const normalized = resolve(value);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function validSessionId(value) {
+    return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u.test(value);
+}
+function validPath(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 32_768 && !value.includes("\0") && isAbsolute(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -20,8 +20,8 @@ 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 { PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, 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, } from "./update.js";
+export { PACKAGE_UNLOCK_PATIENCE_MS, 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";
 export { selectSupervisorLaunchReleaseId, selectUpdateLaunchRelease } from "./update-launch.js";

package/dist/foundation/release/index.js

@@ -9,7 +9,7 @@ export { collectRelease, prepareReleaseCleanup, runBoundedReleaseCleanup, runRel
 export { RELEASE_MANIFEST_FILENAME, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, 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 { PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.js";
+export { PACKAGE_UNLOCK_PATIENCE_MS, 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/update.d.ts

@@ -23,6 +23,16 @@ export interface UpdateFileSystem {
     realpath(path: string): Promise<string>;
     lstat?(path: string): Promise<UpdateFileMetadata>;
     access?(path: string): Promise<void>;
+    rename?(from: string, to: string): Promise<void>;
+}
+/**
+ * How long the update keeps checking that nothing holds the package tree, and the clock it
+ * checks with. Tests inject a clock; the product waits in real time.
+ */
+export interface UpdateUnlockPatience {
+    readonly windowMs?: number;
+    readonly sleep?: (durationMs: number) => Promise<void>;
+    readonly now?: () => number;
 }
 export interface UpdateOutput {
     stdout(message: string): void;
@@ -103,6 +113,17 @@ export interface UpdatePackageReplacementInput {
     readonly environment: NodeJS.ProcessEnv;
     readonly onRecoveryState: (state: UpdateRecoveryState) => Promise<void>;
 }
+/**
+ * The package tree is checked for holders by renaming it and renaming it back, because on
+ * Windows that is the one operation that fails while any file under it is open. A holder is
+ * usually brief: a scanner, an indexer, a file browser, or a session still shutting down.
+ * The update therefore keeps checking for this long before it calls the package locked.
+ */
+export declare const PACKAGE_UNLOCK_PATIENCE_MS = 15000;
+/** Whether a rename failure means something holds the tree, as opposed to the tree being wrong. */
+export declare function isPackageLockError(error: unknown): boolean;
+/** What the user reads when the package stayed held for the whole patience window. */
+export declare function lockedPackageDiagnostic(packageRoot: string, waitedMs: number, attempts: number, error: unknown): string;
 /** Bound on the child diagnostics an update keeps: enough for npm's failure reason, never a log. */
 export declare const CHILD_DIAGNOSTIC_LIMIT = 8000;
 export declare function createNpmProcessRunner(platform?: NodeJS.Platform): UpdateProcessRunner;
@@ -114,7 +135,7 @@ export type UpdateOwnershipAction = "clean-dead-record" | "leave-running" | "end
  * because that installation is exactly what is about to be replaced under it.
  */
 export declare function planUpdateOwnership(ownership: "live-verified" | "dead", runsFromRetainedRelease: boolean): UpdateOwnershipAction;
-export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput): UpdateLifecycleCoordinator;
+export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput, patience?: UpdateUnlockPatience): UpdateLifecycleCoordinator;
 /** Renders the terminal-only update meter; the visual preview shares this exact frame. */
 export declare function renderUpdateProgressBar(percent: number): string;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;

package/dist/foundation/release/update.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { access, lstat, readFile, realpath } from "node:fs/promises";
+import { access, lstat, readFile, realpath, rename } from "node:fs/promises";
 import { connect } from "node:net";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import crossSpawn from "cross-spawn";
@@ -23,7 +23,32 @@ const defaultFileSystem = {
     realpath,
     lstat,
     access,
+    rename,
 };
+/**
+ * The package tree is checked for holders by renaming it and renaming it back, because on
+ * Windows that is the one operation that fails while any file under it is open. A holder is
+ * usually brief: a scanner, an indexer, a file browser, or a session still shutting down.
+ * The update therefore keeps checking for this long before it calls the package locked.
+ */
+export const PACKAGE_UNLOCK_PATIENCE_MS = 15_000;
+const PACKAGE_UNLOCK_INITIAL_DELAY_MS = 100;
+const PACKAGE_UNLOCK_MAX_DELAY_MS = 1_000;
+// Platform: Windows reports a held directory as EPERM or EBUSY; EACCES and ENOTEMPTY are the other
+// spellings a rename gives to a tree something is using. Anything else is not a lock.
+const PACKAGE_LOCK_CODES = new Set(["EPERM", "EACCES", "EBUSY", "ENOTEMPTY"]);
+const defaultSleep = async (durationMs) => await new Promise(resolvePromise => setTimeout(resolvePromise, durationMs));
+/** Whether a rename failure means something holds the tree, as opposed to the tree being wrong. */
+export function isPackageLockError(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string" && PACKAGE_LOCK_CODES.has(error.code);
+}
+/** What the user reads when the package stayed held for the whole patience window. */
+export function lockedPackageDiagnostic(packageRoot, waitedMs, attempts, error) {
+    const seconds = Math.max(1, Math.round(waitedMs / 1_000));
+    return PRODUCT_TEXT.diagnostic(`package remained locked for ${seconds}s after verified shutdown (${attempts} checks): ${errorMessage(error)}. `
+        + `Another program is holding a file under ${packageRoot}: an antivirus scan, a file browser or terminal open inside it, `
+        + `or a session still shutting down. Close it and run the update again; nothing was changed.`);
+}
 const defaultOutput = {
     stdout(message) { process.stdout.write(message); },
     stderr(message) { process.stderr.write(message); },
@@ -79,7 +104,7 @@ async function readActiveEndpoint(paths, activeReleaseId, environment) {
     const legacy = await readEndpointMetadata(legacyPaths.endpointMetadataPath);
     return legacy ? { metadata: legacy, paths: legacyPaths } : null;
 }
-export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem, output = defaultOutput) {
+export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem, output = defaultOutput, patience = {}) {
     const paths = resolveProductPaths(environment);
     const stateStore = new CohortStateStore(paths.dataDir);
     return {
@@ -139,16 +164,40 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             if (fileSystem.access)
                 await fileSystem.access(packageRoot);
             const probe = `${packageRoot}.${PRODUCT_IDENTITY.filesystem.slug}-unlock-probe`;
-            const { rename } = await import("node:fs/promises");
-            try {
-                await rename(packageRoot, probe);
-                await rename(probe, packageRoot);
-            }
-            catch (error) {
-                // Invariant: best-effort rollback runs if the first rename succeeded and the second did not.
-                await rename(probe, packageRoot).catch(() => { });
-                throw new Error(PRODUCT_TEXT.diagnostic(`package remains locked after verified shutdown: ${errorMessage(error)}`));
-            }
+            const renameTree = fileSystem.rename ?? rename;
+            const windowMs = patience.windowMs ?? PACKAGE_UNLOCK_PATIENCE_MS;
+            const now = patience.now ?? Date.now;
+            const sleep = patience.sleep ?? defaultSleep;
+            const startedAt = now();
+            let delay = PACKAGE_UNLOCK_INITIAL_DELAY_MS;
+            let attempts = 0;
+            // Rationale: a holder found right after ownership was released is almost always transient,
+            // so one failed rename is a reason to look again, not to abandon an update that has not
+            // yet changed anything. The wait is bounded so a genuine lock still fails clearly.
+            const withPatience = async (from, to, describeFailure) => {
+                while (true) {
+                    attempts += 1;
+                    try {
+                        await renameTree(from, to);
+                        return;
+                    }
+                    catch (error) {
+                        const elapsed = now() - startedAt;
+                        if (!isPackageLockError(error) || elapsed >= windowMs)
+                            throw describeFailure(error);
+                        // Rationale: the last pause is cut to the window's edge so the wait ends when promised.
+                        await sleep(Math.min(delay, windowMs - elapsed));
+                        delay = Math.min(PACKAGE_UNLOCK_MAX_DELAY_MS, delay * 2);
+                    }
+                }
+            };
+            await withPatience(packageRoot, probe, error => isPackageLockError(error)
+                ? new Error(lockedPackageDiagnostic(packageRoot, now() - startedAt, attempts, error))
+                : new Error(PRODUCT_TEXT.diagnostic(`could not verify that the package is unlocked: ${errorMessage(error)}`)));
+            // Invariant: the package tree is put back under its own name before this returns; a holder
+            // that appears while it wears the probe name is waited out the same way, and if it never
+            // lets go the diagnostic names where the tree is so the user can restore it.
+            await withPatience(probe, packageRoot, error => new Error(PRODUCT_TEXT.diagnostic(`could not restore the package after checking it was unlocked: ${errorMessage(error)}. The package is at ${probe}; rename it back to ${packageRoot} before running the update again.`)));
         },
         async activateInstalled(packageRoot, targetVersion, phase, onMaterializing, onWarmup) {
             const request = { packageRoot, dataDir: paths.dataDir, targetVersion, environment };

package/dist/integrations/pi/components/models-dialog.js

@@ -1,5 +1,5 @@
 import { Input, Key, getKeybindings, matchesKey, truncateToWidth, } from "@earendil-works/pi-tui";
-import { piTheme } from "./theme.js";
+import { piTheme, renderPiModalShortcutHints } from "./theme.js";
 const MAX_VISIBLE_ROWS = 10;
 const MODELS_TITLE = "Models";
 function fullModelId(model) {
@@ -228,7 +228,7 @@ export class ModelsDialogComponent {
         push();
         if (this.#refreshStatus !== undefined)
             push(theme.fg(this.#refreshStatus.kind, `  ${this.#refreshStatus.message}`));
-        push(theme.fg("dim", `  ${this.#hints().join(" · ")}`));
+        push(renderPiModalShortcutHints(this.#hints()));
         push(border);
         return lines;
     }
@@ -237,13 +237,13 @@ export class ModelsDialogComponent {
         const confirm = keyLabel("tui.select.confirm");
         const save = keyLabel("app.models.save");
         return [
-            "type to search",
-            "↑↓ navigate",
-            ...(tab.length === 0 ? [] : [`${tab} filter`]),
-            ...(confirm.length === 0 ? [] : [`${confirm} switch`]),
-            "space scope",
-            ...(save.length === 0 ? [] : [`${save} save`]),
-            "esc close",
+            { action: "type to search" },
+            { key: "↑↓", action: "navigate" },
+            ...(tab.length === 0 ? [] : [{ key: tab, action: "filter" }]),
+            ...(confirm.length === 0 ? [] : [{ key: confirm, action: "switch" }]),
+            { key: "space", action: "scope" },
+            ...(save.length === 0 ? [] : [{ key: save, action: "save" }]),
+            { key: "esc", action: "close" },
         ];
     }
     #emptyText() {

package/dist/integrations/pi/components/shell-editor-autocomplete.d.ts

@@ -16,14 +16,8 @@ export declare const PINNED_PI_BUILTIN_SLASH_COMMANDS: ({
 export declare const OWNED_BUILTIN_SLASH_COMMANDS: ({
     readonly name: "thinking";
     readonly description: "Set thinking level";
-    readonly argumentHint: "<level>";
-} | {
-    name: string;
-    description: string;
-    argumentHint?: never;
 } | {
     name: string;
     description: string;
-    argumentHint: string;
 })[];
 export declare function createPiShellEditor(options: PiShellEditorOptions): PiShellEditorPort;

package/dist/integrations/pi/components/shell-editor-autocomplete.js

@@ -9,12 +9,14 @@ import { createTuiFacade, ensureTheme, isAutocompleteProvider, } from "./shell-s
 import { SKILLS_COMMAND_NAME, collapseSkillCommands, createSkillsTunnelProvider, } from "./skills-command.js";
 /** A selected autocomplete row: the accent primary column, then the aligned description. */
 const SELECTED_DESCRIBED_ROW = /^(→ .*?\S)(\s{2,}.*)$/u;
-const THINKING_SLASH_COMMAND = { name: "thinking", description: "Set thinking level", argumentHint: "<level>" };
+const PINNED_THINKING_SLASH_COMMAND = { name: "thinking", description: "Set thinking level", argumentHint: "<level>" };
+const OWNED_THINKING_SLASH_COMMAND = { name: "thinking", description: "Set thinking level" };
+const OWNED_LOGIN_SLASH_COMMAND = { name: "login", description: "Configure provider authentication" };
 export const PINNED_PI_BUILTIN_SLASH_COMMANDS = [
     { name: "settings", description: "Open settings menu" },
     { name: "model", description: "Select model (opens selector UI)", argumentHint: "<provider/model>" },
     { name: "tree", description: "Navigate session tree (switch branches)" },
-    THINKING_SLASH_COMMAND,
+    PINNED_THINKING_SLASH_COMMAND,
     { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
     { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
     { name: "import", description: "Import and resume a session from a JSONL file" },
@@ -36,9 +38,16 @@ export const PINNED_PI_BUILTIN_SLASH_COMMANDS = [
     { name: "quit", description: "Quit" },
 ];
 /** Bare A1's built-in catalog: `models` replaces the pinned pair and is followed by `thinking`. */
-export const OWNED_BUILTIN_SLASH_COMMANDS = PINNED_PI_BUILTIN_SLASH_COMMANDS.flatMap(command => command.name === "model"
-    ? [{ name: "models", description: "Switch models and manage scoped model cycling" }, THINKING_SLASH_COMMAND]
-    : command.name === "thinking" || command.name === "scoped-models" ? [] : [command]);
+export const OWNED_BUILTIN_SLASH_COMMANDS = PINNED_PI_BUILTIN_SLASH_COMMANDS.flatMap(command => {
+    if (command.name === "model") {
+        return [{ name: "models", description: "Switch models and manage scoped model cycling" }, OWNED_THINKING_SLASH_COMMAND];
+    }
+    if (command.name === "thinking" || command.name === "scoped-models")
+        return [];
+    if (command.name === "login")
+        return [OWNED_LOGIN_SLASH_COMMAND];
+    return [command];
+});
 export function createPiShellEditor(options) {
     ensureTheme();
     const tui = createTuiFacade(options);
@@ -132,9 +141,17 @@ export function createPiShellEditor(options) {
         const commands = collapsed.commands;
         const additions = new Map(commands.map(command => [command.name, command]));
         const builtInNames = new Set(builtInCatalog.map(command => command.name));
-        const builtIns = builtInCatalog.map(command => autocompleteCommand(command, additions.get(command.name)));
-        // Invariant: the engine's built-in additions only decorate this profile's catalog; they never surface as resources.
-        const resources = commands.filter(command => command.source !== "builtin" && !builtInNames.has(command.name)).map(command => autocompleteCommand(command));
+        const builtIns = builtInCatalog.flatMap(command => [
+            autocompleteCommand(command, additions.get(command.name)),
+            // Rationale: the collapsed browser is a primary bare-A1 command, not a resource after quit.
+            ...(command.name === "settings" && collapsed.collapsedCommand !== undefined
+                ? [autocompleteCommand(collapsed.collapsedCommand)]
+                : []),
+        ]);
+        // Invariant: built-in additions and the promoted collapsed browser never reappear as resources.
+        const resources = commands
+            .filter(command => command.name !== collapsed.collapsedCommand?.name && command.source !== "builtin" && !builtInNames.has(command.name))
+            .map(command => autocompleteCommand(command));
         const combined = new CombinedAutocompleteProvider([...builtIns, ...resources], options.cwd ?? process.cwd());
         autocompleteProvider = tunnelSkills.length === 0 ? combined : createSkillsTunnelProvider(combined, tunnelSkills);
         editor.setAutocompleteProvider(autocompleteProvider);
@@ -229,10 +246,26 @@ export function createPiShellEditor(options) {
             if (editorUx !== undefined && matchesKey(data, "shift+tab")
                 && !Object.values(keybindings.getEffectiveConfig()).some(keys => (Array.isArray(keys) ? keys : [keys]).some(key => key !== undefined && matchesKey(data, key))))
                 return;
+            const hadDraft = editor.getText().length > 0;
             if (editorUx === undefined)
                 editor.handleInput(data);
             else
                 editorUx.handleInput(data);
+            if (editorUx === undefined || !hadDraft || editor.getText().length > 0)
+                return;
+            // Invariant: Pi's deletion paths can leave a visible or debounced autocomplete request owned by
+            // the removed draft. Reapplying empty text cancels both forms without a duplicate change notice.
+            const onChange = editor.onChange;
+            delete editor.onChange;
+            try {
+                editor.setText("");
+            }
+            finally {
+                if (onChange === undefined)
+                    delete editor.onChange;
+                else
+                    editor.onChange = onChange;
+            }
         },
         invalidate: () => editor.invalidate(),
         setFocused: focused => {

package/dist/integrations/pi/components/shell-extension-ui.js

@@ -1,5 +1,7 @@
-import { ExtensionInputComponent, ExtensionSelectorComponent, getSelectListTheme, } from "../startup-public.js";
-import { ExtensionEditorComponent, } from "./upstream/components/extension-editor.js";
+import { getSelectListTheme, } from "../startup-public.js";
+import { ExtensionEditorComponent } from "./upstream/components/extension-editor.js";
+import { ExtensionInputComponent } from "./upstream/components/extension-input.js";
+import { ExtensionSelectorComponent } from "./upstream/components/extension-selector.js";
 import { setKeybindings, Text, } from "@earendil-works/pi-tui";
 import { KeybindingsManager, } from "./upstream/adjacent/core/keybindings.js";
 import { PINNED_PI_LAYOUT, applyPiTheme, applyPiThemeInstance, getAvailablePiThemes, loadPiTheme, piTheme, } from "./theme.js";

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

@@ -165,7 +165,7 @@ function liveWorkingText(view, workingOverride, progressPresentation) {
     const message = workingOverride ?? view.status.workingMessage ?? "Working";
     const progress = view.status.workingProgress;
     return workingOverride === undefined && progressPresentation === "custom-viewport" && typeof progress === "number"
-        ? `${message} (${progress}%)`
+        ? `${message}(${progress}%)`
         : message;
 }
 function statusComponent(view, ui, outputPad, liveStatusText, placement) {

package/dist/integrations/pi/components/shell-presenters-transcript.js

@@ -191,9 +191,11 @@ export function renderPiShellPackageUpdateNotice(packages, width) {
 function transcriptComponent(block, cwd, expanded, extensions, submittedPrompt, outputPad, hideThinkingBlock, mermaidRenderingMode, showImages, imageWidthCells, imageAssets, tui) {
     switch (block.kind) {
         case "user": {
-            const skill = parseSkillBlock(block.text);
+            const visibleBlock = submittedPrompt === undefined || block.userPresentation === undefined ? block
+                : { ...block, text: block.userPresentation.visibleText };
+            const skill = parseSkillBlock(visibleBlock.text);
             if (!skill)
-                return submittedPrompt ? createPiSubmittedPromptComponent(block, submittedPrompt) : new UserMessageComponent(block.text);
+                return submittedPrompt ? createPiSubmittedPromptComponent(visibleBlock, submittedPrompt) : new UserMessageComponent(visibleBlock.text);
             const invocation = new SkillInvocationMessageComponent(skill, getMarkdownTheme());
             invocation.setExpanded(expanded);
             if (!skill.userMessage)

package/dist/integrations/pi/components/skills-command.d.ts

@@ -11,6 +11,8 @@ export interface PiShellSkillSummary {
 }
 export interface PiShellCollapsedSkillCommands {
     readonly commands: readonly PiShellAutocompleteCommand[];
+    /** The synthetic command replacing the withheld entries, when skill commands were present. */
+    readonly collapsedCommand?: PiShellAutocompleteCommand;
     /** The skills withheld from the top-level menu, in the engine's discovery order. */
     readonly skills: readonly PiShellSkillSummary[];
 }

package/dist/integrations/pi/components/skills-command.js

@@ -27,6 +27,15 @@ export function collapseSkillCommands(commands) {
     if (skills.length === 0)
         return { commands, skills };
     const collapsed = [];
+    const collapsedCommand = {
+        name: SKILLS_COMMAND_NAME,
+        description: SKILLS_COMMAND_DESCRIPTION,
+        argumentOptions: skills.map(skill => ({
+            id: skill.name,
+            label: skill.name,
+            ...(skill.description.length === 0 ? {} : { description: skill.description }),
+        })),
+    };
     let inserted = false;
     for (const command of commands) {
         if (!command.name.startsWith(SKILL_COMMAND_PREFIX)) {
@@ -36,17 +45,9 @@ export function collapseSkillCommands(commands) {
         if (inserted)
             continue;
         inserted = true;
-        collapsed.push({
-            name: SKILLS_COMMAND_NAME,
-            description: SKILLS_COMMAND_DESCRIPTION,
-            argumentOptions: skills.map(skill => ({
-                id: skill.name,
-                label: skill.name,
-                ...(skill.description.length === 0 ? {} : { description: skill.description }),
-            })),
-        });
+        collapsed.push(collapsedCommand);
     }
-    return { commands: collapsed, skills };
+    return { commands: collapsed, collapsedCommand, skills };
 }
 /** Case-insensitive substring match on the name or description; a leading `skill:`/`skills:` in the query is ignored for the name. */
 export function skillMatchesQuery(skill, query) {

package/dist/integrations/pi/components/skills-dialog.js

@@ -1,6 +1,6 @@
-import { DynamicBorder, keyHint, rawKeyHint } from "../startup-public.js";
+import { DynamicBorder } from "../startup-public.js";
 import { Container, getKeybindings, Input, Spacer, Text } from "@earendil-works/pi-tui";
-import { PINNED_PI_LAYOUT, piTheme } from "./theme.js";
+import { PINNED_PI_LAYOUT, piTheme, renderPiModalShortcutHints } from "./theme.js";
 import { componentPort, ensureTheme, piShellTruncateToWidth, piShellVisibleWidth } from "./shell-shared-facade.js";
 import { SKILL_COMMAND_PREFIX, skillMatchesQuery } from "./skills-command.js";
 /** A single line clipped at the viewport width: no wrap, no ellipsis, padded to the full width. */
@@ -44,7 +44,12 @@ class SkillsSelectorComponent extends Container {
         this.addChild(new Spacer(1));
         this.addChild(this.#listContainer);
         this.addChild(new Spacer(1));
-        this.addChild(new Text(`  ${rawKeyHint("↑↓", "navigate")}  ${keyHint("tui.select.confirm", "select")}  ${keyHint("tui.select.cancel", "cancel")}`, 0, 0));
+        const bindings = getKeybindings();
+        this.addChild(new Text(renderPiModalShortcutHints([
+            { key: "↑↓", action: "navigate" },
+            { key: bindings.getKeys("tui.select.confirm").join("/"), action: "select" },
+            { key: bindings.getKeys("tui.select.cancel").join("/"), action: "cancel" },
+        ]), 0, 0));
         this.addChild(new DynamicBorder());
         this.#updateList();
     }

package/dist/integrations/pi/components/theme.d.ts

@@ -1 +1,5 @@
+import { type SemanticShortcutHint } from "../../../contracts/presentation/index.js";
 export * from "./upstream/theme/theme.js";
+export type PiModalShortcutHint = SemanticShortcutHint;
+/** The common bare-A1 modal footer: quiet display-cased keys, muted names, and whitespace-only gaps. */
+export declare function renderPiModalShortcutHints(entries: readonly PiModalShortcutHint[], indent?: number): string;

package/dist/integrations/pi/components/theme.js

@@ -1 +1,11 @@
+import { renderSemanticShortcutHints, } from "../../../contracts/presentation/index.js";
+import { piTheme } from "./upstream/theme/theme.js";
 export * from "./upstream/theme/theme.js";
+/** The common bare-A1 modal footer: quiet display-cased keys, muted names, and whitespace-only gaps. */
+export function renderPiModalShortcutHints(entries, indent = 0) {
+    const theme = piTheme();
+    return renderSemanticShortcutHints(entries, {
+        key: text => theme.fg("dim", text),
+        action: text => theme.fg("muted", text),
+    }, indent);
+}