@timurproko/a1 0.1.1-dev.12 → 0.1.1-dev.14

package/README.md

@@ -10,13 +10,37 @@ npm install --global @timurproko/a1@latest
 
 ```sh
 a1              # A1-owned UI and profile: ~/.a1/agent
-a1 pi           # untouched vanilla Pi oracle: ~/.pi/agent
-a1 sandbox      # unchanged isolated vanilla Pi profile: ~/.a1/sandbox
 a1 version      # show Installed, Release (latest), and Next versions
 a1 update       # update to npm latest
 a1 update:next  # update to npm next
 ```
 
+Prerelease builds — what `a1 update:next` installs — add two development profiles
+for comparing against pinned Pi and for experimenting against an isolated profile.
+A release build does not carry them.
+
+```sh
+a1 pi           # untouched vanilla Pi oracle: ~/.pi/agent
+a1 sandbox      # unchanged isolated vanilla Pi profile: ~/.a1/sandbox
+```
+
+## Extensions
+
+Pi extension packages install into A1's own profile, so bare `a1` loads them and
+`a1 pi` and `a1 sandbox` do not. Sources are Pi's: `npm:`, git, or a local path.
+
+```sh
+a1 install npm:pi-mcp-adapter   # install a package into ~/.a1/agent
+a1 remove npm:pi-mcp-adapter    # remove it again (alias: a1 uninstall)
+a1 list                         # list packages installed for a1
+a1 update --extensions          # update every installed package
+a1 update npm:pi-mcp-adapter    # update one of them
+a1 update --models              # refresh model catalogs
+```
+
+A running session loads a newly installed package after a restart. Pi's own
+profile at `~/.pi/agent` is managed by Pi itself.
+
 ## Develop
 
 ```sh

package/bin/cli.js

@@ -2,7 +2,12 @@
 
 const packageRoot = new URL("..", import.meta.url);
 const { fileURLToPath } = await import("node:url");
-const { dispatchCli } = await import("../dist/src/cli/index.js");
+const { readFile } = await import("node:fs/promises");
+const { cliCapabilities, dispatchCli } = await import("../dist/src/cli/index.js");
+
+// Which commands this build exposes follows from the build's own version, so a
+// released a1 cannot be argued into offering the development profiles.
+const capabilities = cliCapabilities(JSON.parse(await readFile(new URL("package.json", packageRoot), "utf8")).version);
 
 process.exitCode = await dispatchCli(process.argv.slice(2), {
   launch: async intent => {
@@ -21,6 +26,13 @@ process.exitCode = await dispatchCli(process.argv.slice(2), {
     const { runSelfUpdate } = await import("../dist/src/foundation/release/index.js");
     return await runSelfUpdate({ packageRoot: fileURLToPath(packageRoot), channel });
   },
+  packages: async request => {
+    const [{ runPackageCommand }, { createPiPackagesPort }] = await Promise.all([
+      import("../dist/src/cli/index.js"),
+      import("../dist/src/foundation/pi-engine-adapter/index.js"),
+    ]);
+    return await runPackageCommand(request, { createPort: createPiPackagesPort });
+  },
 }, {
   stderr: message => process.stderr.write(message),
-});
+}, capabilities);

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-23T13:01:43.157Z",
+  "builtAt": "2026-08-23T14:54:52.984Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-23T13:01:56.341Z",
+  "builtAt": "2026-08-23T14:54:49.534Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-23T13:02:22.268Z",
+  "builtAt": "2026-08-23T14:55:13.661Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "f36ba90394ff9d7bd32612d8b89f96f23afa394e22260466271938ae27ee5c9f",
+    "sha256": "068b70d85658579b34c845f742cd9e209239f4b93fcfb4d39962fd1d4d19d226",
     "size": 172544
   },
   "provenance": {

package/dist/src/cli/capabilities.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `pi` and `sandbox` exist to compare A1 against pinned Pi and to try resources
+ * against an isolated profile. Both are development instruments rather than
+ * product, so a stable release does not carry them: what a released `a1` exposes
+ * is the product plus its maintenance and package commands.
+ *
+ * Which build this is comes from its own version. A prerelease version is a
+ * `next`-channel build, which is where that work happens; a release version is
+ * not. Nothing to configure, and no way for a released build to be talked into it.
+ */
+export interface CliCapabilities {
+    readonly developmentProfiles: boolean;
+}
+export declare function cliCapabilities(version: string): CliCapabilities;
+export declare function isPrereleaseVersion(version: string): boolean;

package/dist/src/cli/capabilities.js

@@ -0,0 +1,7 @@
+import { prerelease } from "semver";
+export function cliCapabilities(version) {
+    return Object.freeze({ developmentProfiles: isPrereleaseVersion(version) });
+}
+export function isPrereleaseVersion(version) {
+    return (prerelease(version)?.length ?? 0) > 0;
+}

package/dist/src/cli/dispatch.d.ts

@@ -1,15 +1,18 @@
 import { type InteractiveLaunchIntent, type LaunchProfileId } from "../features/launch/index.js";
+import type { CliCapabilities } from "./capabilities.js";
+import type { PackageCommandRequest } from "./packages.js";
 export type UpdateChannel = "stable" | "next";
 export interface CliHandlers {
     readonly launch: (intent: InteractiveLaunchIntent) => Promise<number>;
     readonly version: () => Promise<number>;
     readonly update: (channel: UpdateChannel) => Promise<number>;
+    readonly packages: (request: PackageCommandRequest) => Promise<number>;
 }
 export interface CliOutput {
     readonly stderr: (message: string) => void;
 }
-export declare const CLI_USAGE: string;
-export declare function dispatchCli(arguments_: readonly string[], handlers: CliHandlers, output: CliOutput): Promise<number>;
+export declare function cliUsage(capabilities: CliCapabilities): string;
+export declare function dispatchCli(arguments_: readonly string[], handlers: CliHandlers, output: CliOutput, capabilities: CliCapabilities): Promise<number>;
 export type CliCommand = {
     readonly kind: "launch";
     readonly profileId: LaunchProfileId;
@@ -18,8 +21,11 @@ export type CliCommand = {
 } | {
     readonly kind: "update";
     readonly channel: UpdateChannel;
+} | {
+    readonly kind: "packages";
+    readonly request: PackageCommandRequest;
 } | {
     readonly kind: "error";
     readonly message: string;
 };
-export declare function parseCliCommand(arguments_: readonly string[]): CliCommand;
+export declare function parseCliCommand(arguments_: readonly string[], capabilities: CliCapabilities): CliCommand;

package/dist/src/cli/dispatch.js

@@ -1,35 +1,123 @@
 import { interactiveLaunchIntent } from "../features/launch/index.js";
 import { PRODUCT_TEXT } from "../product-identity.js";
-export const CLI_USAGE = PRODUCT_TEXT.usage(["", "pi", "sandbox", "version", "update", "update:next"]);
-export async function dispatchCli(arguments_, handlers, output) {
-    const command = parseCliCommand(arguments_);
+export function cliUsage(capabilities) {
+    return PRODUCT_TEXT.usage([
+        "",
+        ...(capabilities.developmentProfiles ? ["pi", "sandbox"] : []),
+        "version",
+        "update [self|<source>|--extensions|--models]",
+        "update:next",
+        "install <source>",
+        "remove <source>",
+        "list",
+    ]);
+}
+const PROFILE_WORDS = new Set(["pi", "sandbox"]);
+export async function dispatchCli(arguments_, handlers, output, capabilities) {
+    const command = parseCliCommand(arguments_, capabilities);
     if (command.kind === "error") {
-        output.stderr(`${command.message}\n${CLI_USAGE}\n`);
+        output.stderr(`${command.message}\n${cliUsage(capabilities)}\n`);
         return 2;
     }
     if (command.kind === "launch")
         return await handlers.launch(interactiveLaunchIntent(command.profileId));
     if (command.kind === "version")
         return await handlers.version();
+    if (command.kind === "packages")
+        return await handlers.packages(command.request);
     return await handlers.update(command.channel);
 }
-export function parseCliCommand(arguments_) {
+export function parseCliCommand(arguments_, capabilities) {
     if (arguments_.length === 0)
         return { kind: "launch", profileId: "a1" };
-    if (arguments_.length > 1)
-        return { kind: "error", message: PRODUCT_TEXT.diagnostic("commands do not accept additional arguments.") };
-    const [command] = arguments_;
-    if (command === "pi" || command === "sandbox")
-        return { kind: "launch", profileId: command };
-    if (command === "ui")
-        return { kind: "error", message: `The ui subcommand was removed; run bare ${PRODUCT_TEXT.commandName} for the owned UI.` };
+    const [command, ...rest] = arguments_;
+    if (capabilities.developmentProfiles && (command === "pi" || command === "sandbox")) {
+        return withoutArguments(rest, { kind: "launch", profileId: command });
+    }
     if (command === "version")
-        return { kind: "version" };
-    if (command === "update")
-        return { kind: "update", channel: "stable" };
+        return withoutArguments(rest, { kind: "version" });
     if (command === "update:next")
-        return { kind: "update", channel: "next" };
+        return withoutArguments(rest, { kind: "update", channel: "next" });
+    if (command === "update")
+        return parseUpdate(rest);
+    if (command === "install" || command === "remove" || command === "uninstall") {
+        return parseSourceCommand(command === "install" ? "install" : "remove", rest);
+    }
+    if (command === "list")
+        return withoutArguments(rest, { kind: "packages", request: { verb: "list", source: null } });
+    if (command === "ui")
+        return { kind: "error", message: `The ui subcommand was removed; run bare ${PRODUCT_TEXT.commandName} for the owned UI.` };
     if (command === "agent")
         return { kind: "error", message: `Bare ${PRODUCT_TEXT.commandName} is the ${PRODUCT_TEXT.displayName} agent experience; there is no agent subcommand.` };
     return { kind: "error", message: PRODUCT_TEXT.diagnostic(`received an unknown command: ${command ?? ""}`) };
 }
+/**
+ * `update` carries both meanings pinned Pi gives it: itself by default, and the
+ * profile's packages when a target says so. Pi is refused as a target because A1
+ * certifies each release against one pinned Pi, so moving Pi underneath it would
+ * invalidate what was certified.
+ */
+function parseUpdate(rest) {
+    if (rest.length === 0)
+        return { kind: "update", channel: "stable" };
+    if (rest.length > 1)
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic("update accepts one target.") };
+    const [target] = rest;
+    if (target === "self")
+        return { kind: "update", channel: "stable" };
+    if (target === "pi") {
+        return {
+            kind: "error",
+            message: PRODUCT_TEXT.diagnostic(`pins the Pi version it was certified against; run ${PRODUCT_TEXT.commandName} update to move ${PRODUCT_TEXT.displayName} itself.`),
+        };
+    }
+    // A release channel is spelled with the colon. Taking the bare word as a package
+    // source would turn a near miss into a confident search for a package nobody has.
+    if (target === "next" || target === "stable") {
+        const form = target === "next" ? `${PRODUCT_TEXT.commandName} update:next` : `${PRODUCT_TEXT.commandName} update`;
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic(`selects a release channel with a colon; run ${form}.`) };
+    }
+    if (target === "--extensions")
+        return { kind: "packages", request: { verb: "update", source: null } };
+    if (target === "--models")
+        return { kind: "packages", request: { verb: "refresh-models", source: null } };
+    if (target === undefined || target.startsWith("-"))
+        return unknownOption(target ?? "", "update");
+    if (PROFILE_WORDS.has(target))
+        return profileRejection("update");
+    return { kind: "packages", request: { verb: "update", source: target } };
+}
+function parseSourceCommand(verb, rest) {
+    const flag = rest.find(argument => argument.startsWith("-"));
+    if (flag !== undefined)
+        return unknownOption(flag, verb);
+    if (rest.length === 0)
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic(`${verb} requires a package source.`) };
+    if (rest.length > 1)
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic(`${verb} accepts one package source.`) };
+    const [source] = rest;
+    if (source === undefined)
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic(`${verb} requires a package source.`) };
+    if (PROFILE_WORDS.has(source))
+        return profileRejection(verb);
+    return { kind: "packages", request: { verb, source } };
+}
+function withoutArguments(rest, command) {
+    if (rest.length === 0)
+        return command;
+    const [argument] = rest;
+    if (argument !== undefined && (PROFILE_WORDS.has(argument) || argument.startsWith("--profile")))
+        return profileRejection("list");
+    return { kind: "error", message: PRODUCT_TEXT.diagnostic("commands do not accept additional arguments.") };
+}
+function profileRejection(verb) {
+    return {
+        kind: "error",
+        message: PRODUCT_TEXT.diagnostic(`manages packages in its own profile, so ${verb} takes no profile; Pi manages Pi's own profile.`),
+    };
+}
+function unknownOption(option, verb) {
+    if (option.startsWith("--profile"))
+        return profileRejection(verb);
+    return { kind: "error", message: PRODUCT_TEXT.diagnostic(`received an unknown option for ${verb}: ${option}`) };
+}

package/dist/src/cli/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./capabilities.js";
 export * from "./dispatch.js";
+export * from "./packages.js";
 export * from "./version.js";
 export * from "./version-stats.js";

package/dist/src/cli/index.js

@@ -1,3 +1,5 @@
+export * from "./capabilities.js";
 export * from "./dispatch.js";
+export * from "./packages.js";
 export * from "./version.js";
 export * from "./version-stats.js";

package/dist/src/cli/packages.d.ts

@@ -0,0 +1,23 @@
+import { initializeProductProfile } from "../features/launch/index.js";
+import type { AgentPackageOutcome, AgentPackagesPort, AgentPackagesPortInput } from "../foundation/agent-engine-contracts/index.js";
+/**
+ * Package commands manage A1's own profile and nothing else, so no request carries
+ * a profile: `update` with no source means every installed package, and refreshing
+ * model catalogs is its own verb rather than a flag the caller has to remember to
+ * check.
+ */
+export type PackageCommandVerb = "install" | "remove" | "list" | "update" | "refresh-models";
+export interface PackageCommandRequest {
+    readonly verb: PackageCommandVerb;
+    readonly source: string | null;
+}
+export interface PackageCommandEnvironment {
+    readonly createPort: (input: AgentPackagesPortInput) => AgentPackagesPort;
+    readonly cwd?: string;
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly stdout?: (message: string) => void;
+    readonly stderr?: (message: string) => void;
+    readonly initializeProfile?: typeof initializeProductProfile;
+}
+export declare function runPackageCommand(request: PackageCommandRequest, environment: PackageCommandEnvironment): Promise<number>;
+export declare function renderPackageOutcome(outcome: AgentPackageOutcome, profileRoot: string): string;

package/dist/src/cli/packages.js

@@ -0,0 +1,84 @@
+import { configurationRootForProfile, initializeProductProfile, resolveLaunchProfilePaths } from "../features/launch/index.js";
+import { PRODUCT_TEXT } from "../product-identity.js";
+export async function runPackageCommand(request, environment) {
+    const stdout = environment.stdout ?? (message => process.stdout.write(message));
+    const stderr = environment.stderr ?? (message => process.stderr.write(message));
+    const cwd = environment.cwd ?? process.cwd();
+    const processEnvironment = environment.environment ?? process.env;
+    const paths = resolveLaunchProfilePaths({ environment: processEnvironment });
+    const profileRoot = configurationRootForProfile("a1", paths);
+    if (profileRoot === null)
+        throw new Error(PRODUCT_TEXT.diagnostic("has no profile root for package commands"));
+    try {
+        await (environment.initializeProfile ?? initializeProductProfile)(profileRoot);
+    }
+    catch (error) {
+        stderr(`${PRODUCT_TEXT.diagnostic(`could not prepare its profile at ${profileRoot}: ${message(error)}`)}\n`);
+        return 1;
+    }
+    const port = environment.createPort({
+        profileRoot,
+        cwd,
+        onProgress: progress => stdout(`${progress.message}\n`),
+    });
+    const outcome = await runVerb(port, request);
+    const rendered = renderPackageOutcome(outcome, profileRoot);
+    (outcome.status === "completed" ? stdout : stderr)(rendered);
+    return outcome.status === "completed" ? 0 : 1;
+}
+async function runVerb(port, request) {
+    if (request.verb === "list")
+        return await port.list();
+    if (request.verb === "refresh-models")
+        return await port.refreshModels();
+    if (request.verb === "update")
+        return await port.update(request.source ?? undefined);
+    if (request.source === null)
+        throw new Error(PRODUCT_TEXT.diagnostic(`requires a source for ${request.verb}`));
+    return request.verb === "install" ? await port.install(request.source) : await port.remove(request.source);
+}
+export function renderPackageOutcome(outcome, profileRoot) {
+    const name = PRODUCT_TEXT.displayName;
+    if (outcome.status === "failed") {
+        return `${PRODUCT_TEXT.diagnostic(`could not ${describeOperation(outcome.operation)}: ${outcome.detail ?? "unknown failure"}`)}\n`;
+    }
+    if (outcome.status === "not-found") {
+        return `${PRODUCT_TEXT.diagnostic(`found no package matching ${outcome.source ?? "that source"} in ${profileRoot}.`)}\n`;
+    }
+    switch (outcome.operation) {
+        case "install":
+            return `${name} installed ${outcome.source} into ${profileRoot}.\n`
+                + `Restart ${PRODUCT_TEXT.commandName} for a running session to load it.\n`;
+        case "remove":
+            return `${name} removed ${outcome.source} from ${profileRoot}.\n`;
+        case "update":
+            return outcome.source === null
+                ? `${name} updated the packages in ${profileRoot}.\n`
+                : `${name} updated ${outcome.source}.\n`;
+        case "refresh-models":
+            return `${name} refreshed the model catalogs in ${profileRoot}.\n`;
+        case "list":
+            return renderPackageList(outcome, profileRoot);
+    }
+}
+function renderPackageList(outcome, profileRoot) {
+    if (outcome.packages.length === 0)
+        return `${PRODUCT_TEXT.displayName} has no packages installed in ${profileRoot}.\n`;
+    const lines = [`Packages installed for ${PRODUCT_TEXT.commandName} in ${profileRoot}:`];
+    for (const entry of outcome.packages) {
+        lines.push(`  ${entry.source}${entry.filtered ? " (partly enabled)" : ""}`);
+        if (entry.installedPath !== null)
+            lines.push(`    ${entry.installedPath}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function describeOperation(operation) {
+    if (operation === "refresh-models")
+        return "refresh the model catalogs";
+    if (operation === "list")
+        return "list installed packages";
+    return `${operation} the package`;
+}
+function message(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
+}

package/dist/src/foundation/agent-engine-contracts/index.d.ts

@@ -2,6 +2,7 @@ export * from "./capability-ports.js";
 export * from "./domain.js";
 export * from "./domain-validation.js";
 export * from "./model.js";
+export * from "./package-ports.js";
 export * from "./ports.js";
 export * from "./validation.js";
 export * from "./serialization.js";

package/dist/src/foundation/agent-engine-contracts/index.js

@@ -2,6 +2,7 @@ export * from "./capability-ports.js";
 export * from "./domain.js";
 export * from "./domain-validation.js";
 export * from "./model.js";
+export * from "./package-ports.js";
 export * from "./ports.js";
 export * from "./validation.js";
 export * from "./serialization.js";

package/dist/src/foundation/agent-engine-contracts/package-ports.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Extension packages are managed outside any session: the command that installs
+ * one runs before the runtime exists, against a profile root chosen by the caller
+ * rather than by whatever session happens to be open. So this port stands apart
+ * from the session-scoped service ports and names only what a package operation
+ * needs — a root, a source, and an outcome a caller can render without knowing
+ * which engine performed it.
+ */
+export type AgentPackageOperation = "install" | "remove" | "update" | "refresh-models" | "list";
+/**
+ * Why an operation ended, kept separate from the prose so callers can branch on
+ * it. `not-found` is the one failure an engine can state structurally — the source
+ * is not configured in this profile — rather than only in a message.
+ */
+export type AgentPackageStatus = "completed" | "not-found" | "failed";
+export interface AgentPackageDescriptor {
+    readonly source: string;
+    readonly installedPath: string | null;
+    /** True when the profile enables only part of what the package provides. */
+    readonly filtered: boolean;
+}
+export interface AgentPackageOutcome {
+    readonly operation: AgentPackageOperation;
+    readonly status: AgentPackageStatus;
+    readonly source: string | null;
+    readonly packages: readonly AgentPackageDescriptor[];
+    readonly detail: string | null;
+}
+export interface AgentPackageProgress {
+    readonly operation: AgentPackageOperation;
+    readonly message: string;
+}
+export interface AgentPackagesPort {
+    readonly capabilities: {
+        readonly install: boolean;
+        readonly remove: boolean;
+        readonly update: boolean;
+        readonly refreshModels: boolean;
+    };
+    /** Absolute profile root every operation of this port acts on. */
+    readonly profileRoot: string;
+    list(): Promise<AgentPackageOutcome>;
+    install(source: string): Promise<AgentPackageOutcome>;
+    remove(source: string): Promise<AgentPackageOutcome>;
+    update(source?: string): Promise<AgentPackageOutcome>;
+    refreshModels(): Promise<AgentPackageOutcome>;
+}
+export interface AgentPackagesPortInput {
+    readonly profileRoot: string;
+    readonly cwd: string;
+    readonly onProgress?: (progress: AgentPackageProgress) => void;
+}
+export declare function assertAgentPackagesPort(port: AgentPackagesPort): void;
+export declare function agentPackageOutcome(operation: AgentPackageOperation, status: AgentPackageStatus, detail?: string | null, source?: string | null, packages?: readonly AgentPackageDescriptor[]): AgentPackageOutcome;

package/dist/src/foundation/agent-engine-contracts/package-ports.js

@@ -0,0 +1,31 @@
+/**
+ * Extension packages are managed outside any session: the command that installs
+ * one runs before the runtime exists, against a profile root chosen by the caller
+ * rather than by whatever session happens to be open. So this port stands apart
+ * from the session-scoped service ports and names only what a package operation
+ * needs — a root, a source, and an outcome a caller can render without knowing
+ * which engine performed it.
+ */
+export function assertAgentPackagesPort(port) {
+    if (typeof port?.capabilities !== "object" || port.capabilities === null)
+        throw new TypeError("packages port capabilities are required");
+    if (typeof port.profileRoot !== "string" || port.profileRoot.length === 0)
+        throw new TypeError("packages port requires an absolute profile root");
+    for (const operation of ["list", "install", "remove", "update", "refreshModels"]) {
+        if (typeof port[operation] !== "function")
+            throw new TypeError(`packages port requires ${operation}`);
+    }
+    for (const capability of ["install", "remove", "update", "refreshModels"]) {
+        if (typeof port.capabilities[capability] !== "boolean")
+            throw new TypeError(`packages capability ${capability} must be explicit`);
+    }
+}
+export function agentPackageOutcome(operation, status, detail, source, packages = []) {
+    return Object.freeze({
+        operation,
+        status,
+        source: source ?? null,
+        packages: Object.freeze([...packages]),
+        detail: detail ?? null,
+    });
+}

package/dist/src/foundation/pi-engine-adapter/index.d.ts

@@ -4,6 +4,7 @@ export * from "./runtime-integration.js";
 export * from "./session-integration.js";
 export * from "./model-auth-integration.js";
 export * from "./settings-integration.js";
+export * from "./package-integration.js";
 export * from "./resource-extension-integration.js";
 export * from "./workflow-controllers.js";
 export * from "./workflows.js";

package/dist/src/foundation/pi-engine-adapter/index.js

@@ -4,6 +4,7 @@ export * from "./runtime-integration.js";
 export * from "./session-integration.js";
 export * from "./model-auth-integration.js";
 export * from "./settings-integration.js";
+export * from "./package-integration.js";
 export * from "./resource-extension-integration.js";
 export * from "./workflow-controllers.js";
 export * from "./workflows.js";

package/dist/src/foundation/pi-engine-adapter/package-integration.d.ts

@@ -0,0 +1,13 @@
+import { type AgentPackagesPort, type AgentPackagesPortInput } from "../agent-engine-contracts/index.js";
+/**
+ * Pinned Pi's package manager already takes the profile root as an argument, so
+ * this binds it to the root A1 chose rather than to whatever the configuration-root
+ * environment variable happens to say. Pi's own package command handler is not used:
+ * it prints Pi's command names and ends the process, and both of those belong to
+ * whichever A1 command is running.
+ *
+ * The settings manager is created with project trust withheld, which is what keeps
+ * every operation to the user scope of the selected profile — a project-local
+ * `packages` list is never read, so it can never be written either.
+ */
+export declare function createPiPackagesPort(input: AgentPackagesPortInput): AgentPackagesPort;

package/dist/src/foundation/pi-engine-adapter/package-integration.js

@@ -0,0 +1,112 @@
+import { join } from "node:path";
+import { DefaultPackageManager, ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { agentPackageOutcome, } from "../agent-engine-contracts/index.js";
+const MODEL_REFRESH_TIMEOUT_MS = 15_000;
+/**
+ * Pinned Pi's package manager already takes the profile root as an argument, so
+ * this binds it to the root A1 chose rather than to whatever the configuration-root
+ * environment variable happens to say. Pi's own package command handler is not used:
+ * it prints Pi's command names and ends the process, and both of those belong to
+ * whichever A1 command is running.
+ *
+ * The settings manager is created with project trust withheld, which is what keeps
+ * every operation to the user scope of the selected profile — a project-local
+ * `packages` list is never read, so it can never be written either.
+ */
+export function createPiPackagesPort(input) {
+    const { profileRoot, cwd } = input;
+    const settingsManager = SettingsManager.create(cwd, profileRoot, { projectTrusted: false });
+    const packageManager = new DefaultPackageManager({ cwd, agentDir: profileRoot, settingsManager });
+    packageManager.setProgressCallback(event => {
+        if (event.type !== "start" || !event.message)
+            return;
+        input.onProgress?.({ operation: operationFor(event.action), message: event.message });
+    });
+    const configured = () => packageManager.listConfiguredPackages()
+        .filter(entry => entry.scope === "user")
+        .map(entry => Object.freeze({
+        source: entry.source,
+        installedPath: entry.installedPath ?? null,
+        filtered: entry.filtered,
+    }));
+    const isConfigured = (source) => configured().some(entry => entry.source === source || entry.source.startsWith(`${source}@`));
+    return Object.freeze({
+        capabilities: Object.freeze({ install: true, remove: true, update: true, refreshModels: true }),
+        profileRoot,
+        async list() {
+            return await attempt("list", null, async () => agentPackageOutcome("list", "completed", null, null, configured()));
+        },
+        async install(source) {
+            return await attempt("install", source, async () => {
+                await packageManager.installAndPersist(source);
+                return agentPackageOutcome("install", "completed", null, source, configured());
+            });
+        },
+        async remove(source) {
+            return await attempt("remove", source, async () => {
+                const removed = await packageManager.removeAndPersist(source);
+                if (!removed)
+                    return agentPackageOutcome("remove", "not-found", null, source);
+                return agentPackageOutcome("remove", "completed", null, source, configured());
+            });
+        },
+        async update(source) {
+            return await attempt("update", source ?? null, async () => {
+                // Asking first keeps "that package is not installed here" a structural
+                // answer rather than a string a caller would have to recognize.
+                if (source !== undefined && !isConfigured(source))
+                    return agentPackageOutcome("update", "not-found", null, source);
+                await packageManager.update(source);
+                return agentPackageOutcome("update", "completed", null, source ?? null, configured());
+            });
+        },
+        async refreshModels() {
+            return await attempt("refresh-models", null, async () => {
+                await refreshModelCatalogs(profileRoot);
+                return agentPackageOutcome("refresh-models", "completed");
+            });
+        },
+    });
+}
+async function attempt(operation, source, run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        return agentPackageOutcome(operation, "failed", describe(error), source);
+    }
+}
+async function refreshModelCatalogs(profileRoot) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MODEL_REFRESH_TIMEOUT_MS);
+    try {
+        const modelRuntime = await ModelRuntime.create({
+            authPath: join(profileRoot, "auth.json"),
+            modelsPath: join(profileRoot, "models.json"),
+            allowModelNetwork: false,
+            signal: controller.signal,
+        });
+        const result = await modelRuntime.refresh({ allowNetwork: true, force: true, signal: controller.signal });
+        if (result.aborted)
+            throw new Error(`model catalog refresh timed out after ${MODEL_REFRESH_TIMEOUT_MS}ms`);
+        if (result.errors.size > 0) {
+            throw new Error(Array.from(result.errors, ([provider, error]) => `${provider}: ${error.message}`).join("; "));
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function operationFor(action) {
+    if (action === "install")
+        return "install";
+    if (action === "remove")
+        return "remove";
+    return "update";
+}
+function describe(error) {
+    const message = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
+    if (message.length === 0)
+        return "unknown package failure";
+    return message.length > 600 ? `${message.slice(0, 597)}...` : message;
+}

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

@@ -44,13 +44,22 @@ export interface SelfUpdateOptions {
     now?: () => number;
 }
 export type UpdateActivationPhase = Extract<UpdateTransactionPhase, "materialized" | "certified" | "active-reference-committed">;
+/**
+ * Copying the release is the longest step with nothing to say for itself, so it
+ * reports the files it has written against the files it must write. A caller that
+ * shows progress can then move with the work instead of guessing at it.
+ */
+export interface UpdateMaterializationProgress {
+    readonly completed: number;
+    readonly total: number;
+}
 export interface UpdateLifecycleCoordinator {
     targetIsActive(targetVersion: string): Promise<boolean>;
     shutdownVerifiedOwners(targetVersion: string): Promise<{
         priorActiveVersion: string | null;
     }>;
     verifyPackageUnlocked(packageRoot: string): Promise<void>;
-    activateInstalled(packageRoot: string, targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>): Promise<void>;
+    activateInstalled(packageRoot: string, targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>, onMaterializing?: (progress: UpdateMaterializationProgress) => void): Promise<void>;
 }
 export interface UpdateTransactionJournal {
     readonly path: string;

package/dist/src/foundation/release/update.js

@@ -105,8 +105,21 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
                 throw new Error(PRODUCT_TEXT.diagnostic(`package remains locked after verified shutdown: ${errorMessage(error)}`));
             }
         },
-        async activateInstalled(packageRoot, targetVersion, phase) {
-            const candidate = await materializeRelease(packageRoot, paths.dataDir);
+        async activateInstalled(packageRoot, targetVersion, phase, onMaterializing) {
+            let total = 0;
+            let completed = 0;
+            const candidate = await materializeRelease(packageRoot, paths.dataDir, {
+                onProgress: event => {
+                    total = event.fileCount;
+                    onMaterializing?.({ completed, total });
+                },
+                onOperation: event => {
+                    if (event.operation !== "candidate-write")
+                        return;
+                    completed += 1;
+                    onMaterializing?.({ completed, total });
+                },
+            });
             if (candidate.packageVersion !== targetVersion)
                 throw new Error(`installed ${PRODUCT_TEXT.displayName} version ${candidate.packageVersion} does not match target ${targetVersion}`);
             await stateStore.recordCandidate(candidate);
@@ -123,10 +136,16 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
 }
 const PROGRESS_BAR_WIDTH = 39;
 const PROGRESS_TICK_MS = 200;
+/**
+ * Copying the release owns 78–92 and is reported file by file, so the bar crosses
+ * that span with the work rather than parking at its start. What follows is short,
+ * which is why the remaining milestones sit close together.
+ */
+const MATERIALIZE_PROGRESS = Object.freeze({ from: 78, to: 92 });
 const ACTIVATION_PROGRESS = {
-    materialized: { at: 85, creepTo: 90 },
-    certified: { at: 90, creepTo: 95 },
-    "active-reference-committed": { at: 95, creepTo: 99 },
+    materialized: { at: 92, creepTo: 94 },
+    certified: { at: 94, creepTo: 96 },
+    "active-reference-committed": { at: 96, creepTo: 99 },
 };
 function renderProgressBar(percent) {
     const bounded = Math.min(100, Math.max(0, Math.round(percent)));
@@ -163,9 +182,12 @@ function createUpdateProgress(output, enabled) {
             if (creepTo <= current)
                 return;
             // Creep asymptotically toward (but never reach) the next milestone so
-            // long opaque phases such as npm install still show visible motion.
+            // long opaque phases such as npm install still show visible motion. The
+            // ceiling stays a whole point below the milestone: settling on `creepTo`
+            // itself would render as that milestone and make arriving at it invisible,
+            // which is what a stalled bar looks like.
             timer = setInterval(() => {
-                current = Math.min(creepTo - 0.5, current + (creepTo - current) * 0.04);
+                current = Math.min(creepTo - 1, current + (creepTo - current) * 0.04);
                 draw();
             }, PROGRESS_TICK_MS);
             timer.unref?.();
@@ -293,13 +315,17 @@ export async function runSelfUpdate(options) {
         // example, if bare A1 is launched before the update is resumed). Recheck
         // immediately before activation so recovery cannot start a second cohort.
         await measure("ownership-release", async () => { await lifecycle.shutdownVerifiedOwners(targetVersion); });
-        progress.set(75, 85);
+        progress.set(75, MATERIALIZE_PROGRESS.from);
         let activationPhaseStartedAt = now();
         await lifecycle.activateInstalled(packageRoot, targetVersion, async (phase) => {
             options.onPhaseTiming?.({ phase, durationMs: Math.max(0, now() - activationPhaseStartedAt) });
             transaction = await transactionStore.advance(phase);
             progress.set(ACTIVATION_PROGRESS[phase].at, ACTIVATION_PROGRESS[phase].creepTo);
             activationPhaseStartedAt = now();
+        }, ({ completed, total }) => {
+            const span = MATERIALIZE_PROGRESS.to - MATERIALIZE_PROGRESS.from;
+            const done = total > 0 ? Math.min(1, completed / total) : 0;
+            progress.set(MATERIALIZE_PROGRESS.from + span * done);
         });
         options.onPhaseTiming?.({ phase: "supervisor-verified", durationMs: Math.max(0, now() - activationPhaseStartedAt) });
         const transactionStartedAt = now();

package/docs/features/launch-profiles.md

@@ -8,6 +8,8 @@
 | `a1 pi` | Untouched vanilla Pi fallback and comparison oracle | ordinary `~/.pi/agent` |
 | `a1 sandbox` | Unchanged isolated vanilla Pi profile for experiments | `~/.a1/sandbox` |
 
+`a1 pi` and `a1 sandbox` are development instruments: one compares A1 against pinned Pi, the other tries resources against an isolated profile. Prerelease builds — what `a1 update:next` installs — expose them. A release build does not, and does not recognize the words: what it exposes is bare `a1` plus the maintenance and package commands. Working in this repository is unaffected, because `npm start:pi` and `npm run start:sandbox` prepare the profile and launch directly rather than through the command line.
+
 There is no `a1 agent` command. The former `a1 ui` subcommand is removed. Bare `a1` is the owned agent product surface and remains the entry point when multi-agent UX is introduced.
 
 ## First launch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.1-dev.12",
+  "version": "0.1.1-dev.14",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",