@timurproko/a1 0.1.8-dev.235df0e → 0.1.8-dev.259

package/dist/{src/cli → cli}/version-stats.d.ts

@@ -3,6 +3,11 @@ interface VersionProcessResult {
     readonly stdout: string;
 }
 type VersionProcessRunner = (command: string, arguments_: readonly string[]) => Promise<VersionProcessResult>;
+type RegistryFetcher = (url: string) => Promise<{
+    readonly ok: boolean;
+    readonly status: number;
+    text(): Promise<string>;
+}>;
 interface VersionOutput {
     stdout(message: string): void;
     stderr(message: string): void;
@@ -11,6 +16,7 @@ export interface VersionStatsOptions {
     readonly packageRoot: string;
     readonly output?: VersionOutput;
     readonly runner?: VersionProcessRunner;
+    readonly fetcher?: RegistryFetcher;
 }
 export declare function runVersionStats(options: VersionStatsOptions): Promise<number>;
 export {};

package/dist/cli/version-stats.js

@@ -0,0 +1,112 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import crossSpawn from "cross-spawn";
+import { prerelease, valid as validSemver } from "semver";
+import { PRODUCT_TEXT } from "../product-identity.js";
+const defaultOutput = {
+    stdout(message) { process.stdout.write(message); },
+    stderr(message) { process.stderr.write(message); },
+};
+export async function runVersionStats(options) {
+    const output = options.output ?? defaultOutput;
+    const runner = options.runner ?? createVersionProcessRunner();
+    let installed;
+    try {
+        const manifest = JSON.parse(await readFile(resolve(options.packageRoot, "package.json"), "utf8"));
+        installed = parseVersion(manifest.version, "installed package");
+    }
+    catch (error) {
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not read its installed version: ${message(error)}`)}\n`);
+        return 1;
+    }
+    // Compatibility: match Pi's release behavior: stable builds print only their installed version.
+    // Development builds retain channel visibility for preview comparison and updates.
+    if (prerelease(installed) === null) {
+        output.stdout(`${installed}\n`);
+        return 0;
+    }
+    const remote = await queryDistTags(runner, options.fetcher ?? defaultRegistryFetcher);
+    output.stdout(`Current: ${installed}\nDevelop: ${remote.develop ?? "unavailable"}\nRelease: ${remote.release ?? "unavailable"}\n`);
+    if (remote.error)
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not resolve npm dist-tags: ${remote.error}`)}\n`);
+    return 0;
+}
+// Rationale: npm view respects the user's .npmrc registry and proxy, so it stays primary; the direct
+// registry fetch below covers npm CLI versions whose --json output shape we cannot parse.
+async function queryDistTags(runner, fetcher) {
+    const fromNpm = await queryDistTagsViaNpm(runner);
+    if (fromNpm.error === null)
+        return fromNpm;
+    const fromRegistry = await queryDistTagsViaRegistry(fetcher);
+    if (fromRegistry.error === null)
+        return fromRegistry;
+    return unavailable(`${fromNpm.error}; registry fallback failed: ${fromRegistry.error}`);
+}
+async function queryDistTagsViaNpm(runner) {
+    let result;
+    try {
+        result = await runner("npm", ["view", PRODUCT_TEXT.packageName, "dist-tags", "--json"]);
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+    if (result.code !== 0)
+        return unavailable(`npm exited with status ${result.code ?? "unknown"}`);
+    try {
+        const parsed = JSON.parse(result.stdout);
+        // Compatibility: npm 12 wraps `npm view <pkg> dist-tags --json` output in a one-element array; older npm returns the bare object.
+        const metadata = Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
+        return parseDistTags(metadata, "npm");
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+async function queryDistTagsViaRegistry(fetcher) {
+    try {
+        const response = await fetcher(`https://registry.npmjs.org/-/package/${encodeURIComponent(PRODUCT_TEXT.packageName)}/dist-tags`);
+        if (!response.ok)
+            return unavailable(`registry responded with status ${response.status}`);
+        return parseDistTags(JSON.parse(await response.text()), "registry");
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+function parseDistTags(metadata, source) {
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return unavailable(`${source} returned a non-object dist-tags value`);
+    }
+    try {
+        const tags = metadata;
+        const release = parseVersion(tags.latest, `${source} latest`);
+        const develop = tags.next === undefined ? null : parseVersion(tags.next, `${source} development channel`);
+        return { release, develop, error: null };
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+function unavailable(error) {
+    return { release: null, develop: null, error };
+}
+const defaultRegistryFetcher = async (url) => await fetch(url, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(10_000) });
+function createVersionProcessRunner() {
+    return async (command, arguments_) => await new Promise((resolvePromise, rejectPromise) => {
+        const child = process.platform === "win32"
+            ? crossSpawn(command, [...arguments_], { stdio: ["ignore", "pipe", "ignore"] })
+            : spawn(command, [...arguments_], { stdio: ["ignore", "pipe", "ignore"] });
+        const stdout = [];
+        child.stdout?.on("data", chunk => stdout.push(Buffer.from(chunk)));
+        child.once("error", rejectPromise);
+        child.once("close", code => resolvePromise({ code, stdout: Buffer.concat(stdout).toString("utf8") }));
+    });
+}
+function parseVersion(value, source) {
+    const parsed = typeof value === "string" ? validSemver(value) : null;
+    if (!parsed)
+        throw new Error(`${source} did not provide a valid semantic version`);
+    return parsed;
+}
+function message(error) { return error instanceof Error ? error.message : String(error); }

package/dist/composition/agent-engine-bridge.d.ts

@@ -0,0 +1,3 @@
+import { type AgentEnginePort } from "../contracts/agent-engine/index.js";
+import type { PiEngineAdapter } from "../integrations/pi/engine/index.js";
+export declare function createPiAgentEngineBridge(adapter: PiEngineAdapter, cwd: string): AgentEnginePort;

package/dist/composition/agent-engine-bridge.js

@@ -0,0 +1,108 @@
+import { AGENT_ENGINE_CONTRACT_VERSION, assertAgentCommand, } from "../contracts/agent-engine/index.js";
+const CAPABILITIES = {
+    contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
+    commands: ["prompt", "steer", "follow-up", "abort", "retry", "compact", "bash", "replace-session"],
+    events: ["lifecycle", "content", "command-outcome", "snapshot-invalidated", "diagnostic"],
+    snapshots: { supported: true, maxBytes: 1024 * 1024 },
+};
+export function createPiAgentEngineBridge(adapter, cwd) {
+    return new PiAgentEngineBridge(adapter, cwd);
+}
+class PiAgentEngineBridge {
+    adapter;
+    cwd;
+    capabilities = CAPABILITIES;
+    #session;
+    constructor(adapter, cwd) {
+        this.adapter = adapter;
+        this.cwd = cwd;
+    }
+    async createSession(input) {
+        if (this.#session)
+            return this.#session;
+        if (input.cwd !== this.cwd)
+            throw new TypeError("composed Pi engine cannot change working directory");
+        await this.adapter.start();
+        this.#session = new PiAgentSessionBridge(this.adapter, input.sessionId);
+        return this.#session;
+    }
+    async dispose() { await this.adapter.dispose(); }
+}
+class PiAgentSessionBridge {
+    adapter;
+    sessionId;
+    capabilities = CAPABILITIES;
+    lifecycle = "starting";
+    #listeners = new Set();
+    #unsubscribe;
+    constructor(adapter, sessionId) {
+        this.adapter = adapter;
+        this.sessionId = sessionId;
+        this.#unsubscribe = adapter.onEvent(event => {
+            const converted = convertEvent(event);
+            if (!converted)
+                return;
+            if (converted.type === "lifecycle")
+                this.lifecycle = converted.lifecycle;
+            for (const listener of this.#listeners)
+                listener(converted);
+        });
+        this.lifecycle = toLifecycle(adapter.snapshot().view.lifecycle);
+    }
+    async execute(command) {
+        assertAgentCommand(command, this.capabilities);
+        if (command.sessionId !== this.sessionId)
+            return "rejected";
+        if (command.type === "bash") {
+            const result = await this.adapter.executeBashWorkflow(command.command, false);
+            return !result.cancelled && result.exitCode === 0 ? "completed" : result.cancelled ? "cancelled" : "failed";
+        }
+        const result = await this.adapter.execute(toOwnedCommand(command));
+        return result.outcome === "timed-out" ? "failed" : result.outcome;
+    }
+    subscribe(listener) { this.#listeners.add(listener); return () => this.#listeners.delete(listener); }
+    async snapshot() {
+        const snapshot = this.adapter.snapshot();
+        return {
+            contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
+            snapshotId: snapshot.snapshotId,
+            sessionId: this.sessionId,
+            revision: snapshot.view.revision,
+            sequence: snapshot.sequence,
+            lifecycle: toLifecycle(snapshot.view.lifecycle),
+            content: snapshot.view.transcript.map(toMessage),
+            activeCommandIds: snapshot.view.activeCommandIds,
+            capabilities: this.capabilities,
+        };
+    }
+    async dispose() { this.#unsubscribe(); this.#listeners.clear(); await this.adapter.dispose(); this.lifecycle = "stopped"; }
+}
+function toOwnedCommand(command) {
+    const base = { correlationId: command.commandId, sessionId: command.sessionId };
+    if (command.type === "replace-session")
+        return command.source.kind === "new" ? { ...base, type: "new-session" } : { ...base, type: "resume-session", sessionPath: command.source.sessionPath };
+    if (command.type === "prompt" || command.type === "steer" || command.type === "follow-up")
+        return { ...base, type: command.type, text: command.text };
+    return { ...base, type: command.type };
+}
+function convertEvent(event) {
+    const base = { contractVersion: AGENT_ENGINE_CONTRACT_VERSION, sessionId: event.sessionId, sequence: event.sequence };
+    if (event.type === "session-lifecycle")
+        return { ...base, type: "lifecycle", lifecycle: toLifecycle(event.lifecycle), reason: event.reason };
+    if (event.type === "transcript-block")
+        return { ...base, type: "content", content: toMessage(event.block) };
+    if (event.type === "command-outcome")
+        return { ...base, type: "command-outcome", commandId: event.correlationId, outcome: event.outcome === "timed-out" ? "failed" : event.outcome, diagnostic: event.diagnostic };
+    if (event.type === "diagnostic")
+        return { ...base, type: "diagnostic", code: event.diagnostic.code, message: event.diagnostic.message, recoverable: event.diagnostic.recoverable };
+    if (event.type === "session-view")
+        return { ...base, type: "snapshot-invalidated", expectedRevision: event.view.revision };
+    return null;
+}
+function toLifecycle(lifecycle) {
+    return lifecycle === "suspended" ? "ready" : lifecycle;
+}
+function toMessage(block) {
+    const role = block.kind === "user" ? "user" : block.kind === "system" ? "system" : block.kind === "tool-call" || block.kind === "tool-result" ? "tool" : "assistant";
+    return { id: block.id, role, status: block.status === "live" ? "streaming" : "final", content: [{ kind: "text", text: block.text }] };
+}

package/dist/composition/index.d.ts

@@ -0,0 +1,3 @@
+export { composeOwnedUi, composeOwnedUiApplication, type OwnedUiComposition, type OwnedUiCompositionOptions, } from "./owned-ui.js";
+export { composeProcess, type ProcessComposition, type ProcessCompositionOptions, } from "./process.js";
+export { createOwnedRouteHost } from "./settings-route-host.js";

package/dist/composition/index.js

@@ -0,0 +1,3 @@
+export { composeOwnedUi, composeOwnedUiApplication, } from "./owned-ui.js";
+export { composeProcess, } from "./process.js";
+export { createOwnedRouteHost } from "./settings-route-host.js";

package/dist/composition/owned-ui.d.ts

@@ -0,0 +1,31 @@
+import { type SessionSelection } from "../foundation/lifecycle/index.js";
+import { type PiEngineAdapter, type PiProjectTrustPreflightPrompt, type PiSessionForkPrompt } from "../integrations/pi/engine/index.js";
+import { OwnedUiSettingsSession } from "../ui/settings/index.js";
+import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
+export interface OwnedUiCompositionOptions {
+    readonly cwd?: string;
+    readonly terminal?: PresentationTerminalPort;
+    readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+    /** Explicit file selection retained for SDK callers. Public CLI uses sessionSelection. */
+    readonly sessionPath?: string;
+    readonly sessionSelection?: SessionSelection;
+    readonly sessionForkPrompt?: PiSessionForkPrompt;
+    /**
+     * A1 profile whose settings this session reads and writes. Omitted keeps the
+     * session settings-free, which is what the pinned comparison paths use.
+     */
+    readonly profileId?: string;
+    /**
+     * Whether A1's product-specific surfaces are reachable. Comparison profiles
+     * use the same composition with those surfaces withheld.
+     */
+    readonly ownedSurfaces?: "on" | "off";
+    readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
+}
+export interface OwnedUiComposition {
+    readonly application: OwnedUiApplicationPort;
+    /** Present when a profile was supplied, so the caller can resolve settings before start. */
+    readonly settings: OwnedUiSettingsSession | null;
+}
+export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
+export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;

package/dist/composition/owned-ui.js

@@ -0,0 +1,66 @@
+import { resolveProductPaths } from "../foundation/lifecycle/index.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes } from "../integrations/pi/components/index.js";
+import { createPiEngineAdapter, } from "../integrations/pi/engine/index.js";
+import { OwnedUiSessionShell } from "../integrations/pi/session-ui/index.js";
+import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../ui/settings/index.js";
+import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/index.js";
+import { createOwnedRouteHost } from "./settings-route-host.js";
+export async function composeOwnedUiApplication(options = {}) {
+    return (await composeOwnedUi(options)).application;
+}
+export async function composeOwnedUi(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const adapter = options.createPiAdapter
+        ? await options.createPiAdapter()
+        : await createPiEngineAdapter({
+            cwd,
+            availableThemes: () => getAvailablePiThemes().map(theme => theme.name),
+            settingsProductMode: options.ownedSurfaces === "off" ? "comparison" : "bare",
+            ...(options.sessionPath === undefined ? {} : { sessionPath: options.sessionPath }),
+            ...(options.sessionSelection === undefined ? {} : { sessionSelection: options.sessionSelection }),
+            ...(options.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: options.sessionForkPrompt }),
+            ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+        });
+    const ownedSurfaces = options.ownedSurfaces !== "off";
+    const settings = options.profileId === undefined
+        ? null
+        : new OwnedUiSettingsSession({
+            store: new OwnedUiSettingsStore({ configDir: resolveProductPaths().configDir, profileId: options.profileId }),
+            agentProvider: () => adapter.settingsPort(),
+        });
+    // Compatibility: bare A1 intentionally ships one visual target while its UI is being completed:
+    // dark, regardless of terminal detection or a previously stored Pi theme. The
+    // comparison profile keeps Pi's configured theme behavior and settings surface.
+    applyConfiguredPiTheme(ownedSurfaces ? "dark" : adapter.configuredTheme());
+    const routeHost = settings === null || !ownedSurfaces ? null : createOwnedRouteHost(settings);
+    const viewportSettings = settings === null || !ownedSurfaces ? null : {
+        snapshot: () => viewportSettingsSnapshot(settings),
+        onChange: listener => settings.onChange(() => listener(viewportSettingsSnapshot(settings))),
+    };
+    const shell = new OwnedUiSessionShell({
+        backend: adapter,
+        cwd: adapter.cwd,
+        ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+        ...(routeHost === null ? {} : { routeHost }),
+        ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
+        ...(viewportSettings === null ? {} : { viewportSettings }),
+    });
+    const application = {
+        get disposed() { return adapter.disposed; },
+        start: () => shell.start(),
+        flush: () => adapter.flushEvents(),
+        waitUntilStopped: () => shell.waitUntilStopped(),
+        dispose: () => shell.dispose(),
+    };
+    return { application, settings };
+}
+function viewportSettingsSnapshot(settings) {
+    const appearance = settings.value("scrollbarAppearance");
+    const style = settings.value("scrollbarStyle");
+    const speed = settings.value("scrollbarSpeed");
+    return {
+        scrollbarAppearance: appearance === "always" || appearance === "hidden" ? appearance : "auto",
+        scrollbarStyle: style === "thick" ? "thick" : "thin",
+        scrollbarSpeed: speed === "high" ? "high" : speed === "fast" ? "fast" : "normal",
+    };
+}

package/dist/composition/process.d.ts

@@ -0,0 +1,16 @@
+import { type AgentEnginePort } from "../contracts/agent-engine/index.js";
+import { type PiEngineAdapter } from "../integrations/pi/engine/index.js";
+import { type PresentationComponentPort, type PresentationRuntimePort, type PresentationTerminalPort } from "../contracts/presentation/index.js";
+export interface ProcessCompositionOptions {
+    readonly cwd?: string;
+    readonly sessionId?: string;
+    readonly engine?: AgentEnginePort;
+    readonly presentationFactory?: (root: PresentationComponentPort, terminal: PresentationTerminalPort) => PresentationRuntimePort;
+    readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+}
+export interface ProcessComposition {
+    readonly engine: AgentEnginePort;
+    createPresentation(root: PresentationComponentPort, terminal: PresentationTerminalPort): PresentationRuntimePort;
+    dispose(): Promise<void>;
+}
+export declare function composeProcess(options?: ProcessCompositionOptions): Promise<ProcessComposition>;

package/dist/composition/process.js

@@ -0,0 +1,45 @@
+import { assertAgentCapabilityContract, } from "../contracts/agent-engine/index.js";
+import { createPiEngineAdapter } from "../integrations/pi/engine/index.js";
+import { createPiPresentationRuntime } from "../integrations/pi/tui-runtime/index.js";
+import { assertPresentationComponent, assertPresentationRuntime, } from "../contracts/presentation/index.js";
+import { createPiAgentEngineBridge } from "./agent-engine-bridge.js";
+export async function composeProcess(options = {}) {
+    let engine = options.engine;
+    if (!engine) {
+        const adapter = options.createPiAdapter
+            ? await options.createPiAdapter()
+            : await createPiEngineAdapter({
+                ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+                ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }),
+            });
+        engine = createPiAgentEngineBridge(adapter, options.cwd ?? process.cwd());
+    }
+    assertAgentCapabilityContract(engine.capabilities);
+    if (typeof engine.createSession !== "function" || typeof engine.dispose !== "function")
+        throw new TypeError("composed engine does not satisfy the neutral engine port");
+    const presentations = new Set();
+    let disposed = false;
+    return {
+        engine,
+        createPresentation(root, terminal) {
+            if (disposed)
+                throw new Error("process composition is disposed");
+            assertPresentationComponent(root);
+            const runtime = options.presentationFactory?.(root, terminal) ?? createPiPresentationRuntime(root, terminal);
+            assertPresentationRuntime(runtime);
+            presentations.add(runtime);
+            return runtime;
+        },
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            const failures = [];
+            for (const runtime of [...presentations].reverse())
+                await runtime.stop().catch(error => failures.push(error));
+            await engine.dispose().catch(error => failures.push(error));
+            if (failures.length)
+                throw new AggregateError(failures, "process composition disposal failed");
+        },
+    };
+}

package/dist/composition/settings-route-host.d.ts

@@ -0,0 +1,8 @@
+import type { OwnedUiSettingsSession } from "../ui/settings/index.js";
+import { type UiRouteHost } from "../ui/apps/index.js";
+/**
+ * Registers the A1-owned screens and adapts the app host to the shell's route
+ * seam. The shell mounts whatever surface it is handed and forwards keys; it
+ * never learns what an app is.
+ */
+export declare function createOwnedRouteHost(settings: OwnedUiSettingsSession): UiRouteHost;

package/dist/composition/settings-route-host.js

@@ -0,0 +1,75 @@
+import { SETTINGS_APP_ID, SETTINGS_ROUTE, SettingsApp } from "../features/owned-ui/index.js";
+import { piTheme } from "../integrations/pi/components/index.js";
+import { UiAppHost, UiAppRegistry, } from "../ui/apps/index.js";
+import { faint } from "../ui/components/index.js";
+/**
+ * Registers the A1-owned screens and adapts the app host to the shell's route
+ * seam. The shell mounts whatever surface it is handed and forwards keys; it
+ * never learns what an app is.
+ */
+export function createOwnedRouteHost(settings) {
+    const registry = new UiAppRegistry();
+    registry.register({ id: SETTINGS_APP_ID, route: SETTINGS_ROUTE, create: () => new SettingsApp(settings) });
+    return {
+        claims: route => registry.forRoute(route) !== null,
+        open: route => {
+            const registration = registry.forRoute(route);
+            if (registration === null)
+                return null;
+            let size = { width: 80, height: 24 };
+            let frame = [];
+            let closed = false;
+            let onRender = () => undefined;
+            let onExit = () => undefined;
+            const host = new UiAppHost({
+                registry,
+                closeOnInterrupt: true,
+                theme: pinnedTheme(),
+                surface: {
+                    size: () => size,
+                    requestRender: () => onRender(),
+                    exit: () => onExit(),
+                    present: lines => {
+                        if (lines === null)
+                            closed = true;
+                        else
+                            frame = lines;
+                    },
+                },
+            });
+            host.open(registration.id);
+            const surface = {
+                id: registration.id,
+                render: (width, height) => {
+                    size = { width, height };
+                    host.render();
+                    return frame.length === height ? frame : [...frame.slice(0, height), ...Array(Math.max(0, height - frame.length)).fill("")];
+                },
+                handleInput: data => host.handleInput(data).consumed,
+                handleMouse: event => host.handleMouse(event).consumed,
+                isClosed: () => closed || !host.isPresenting,
+                close: () => host.close(),
+                onRenderRequested: listener => { onRender = listener; },
+                onExitRequested: listener => { onExit = listener; },
+            };
+            return surface;
+        },
+    };
+}
+/** Maps A1 UI tokens onto the pinned Pi theme so owned screens match the shell. */
+function pinnedTheme() {
+    return {
+        fg: (token, text) => piTheme().fg(token, text),
+        bold: (text) => piTheme().bold(text),
+        // Rationale: unpainted, so a list reads against the terminal the reader actually has
+        // rather than against the background the configured theme was built for.
+        plain: (text) => text,
+        // Rationale: quiet, and quieter again: the terminal's own faint attribute over the
+        // dimmest colour the theme has.
+        disabled: (text) => faint(piTheme().fg("dim", text)),
+        // Rationale: physical review requires the shared value menu to read as a floating
+        // product surface instead of blending into the settings rows behind it.
+        highlight: (text) => `\u001b[48;2;82;82;82m\u001b[97m${text}\u001b[39m\u001b[49m`,
+        panel: (text) => `\u001b[48;2;55;55;55m${text}\u001b[49m`,
+    };
+}

package/dist/{src/foundation/agent-engine-contracts → contracts/agent-engine}/capability-ports.d.ts

@@ -1,4 +1,4 @@
-import type { AgentJsonValue, AgentModelDescriptor, AgentResourceDescriptor, AgentSettingDescriptor } from "./domain.js";
+import type { AgentJsonValue, AgentModelDescriptor, AgentSettingChangeOutcome, AgentResourceDescriptor, AgentSettingDescriptor } from "./domain.js";
 export interface AgentModelPort {
     readonly capabilities: {
         readonly selection: boolean;
@@ -26,7 +26,7 @@ export interface AgentSettingsPort {
     };
     listSettings(): Promise<readonly AgentSettingDescriptor[]>;
     readSetting(key: string): Promise<AgentJsonValue | undefined>;
-    writeSetting?(key: string, value: AgentJsonValue): Promise<void>;
+    writeSetting?(key: string, value: AgentJsonValue): Promise<AgentSettingChangeOutcome>;
     flush?(): Promise<void>;
 }
 export interface AgentResourcesPort {

package/dist/{src/foundation/agent-engine-contracts → contracts/agent-engine}/domain-validation.js

@@ -52,10 +52,28 @@ export function assertAgentUsage(value) { for (const amount of [value.inputToken
     nonNegative(amount, "usage token count"); if (value.cost !== null && (!(typeof value.cost === "number") || !Number.isFinite(value.cost) || value.cost < 0))
     throw new TypeError("usage cost is invalid"); }
 export function assertAgentModelDescriptor(value) { id(value.providerId, "model provider id"); id(value.modelId, "model id"); text(value.displayName, "model display name"); nonNegative(value.contextWindow, "model context window"); unique(value.thinkingLevels, undefined, "model thinking levels"); }
-export function assertAgentSettingDescriptor(value) { id(value.key, "setting key"); if (!["boolean", "number", "string", "enum", "json"].includes(value.valueType) || typeof value.writable !== "boolean")
-    throw new TypeError("setting descriptor is invalid"); if (value.choices)
-    for (const choice of value.choices)
-        json(choice, "setting choice"); }
+export function assertAgentSettingDescriptor(value) {
+    id(value.key, "setting key");
+    if (!["boolean", "number", "string", "enum", "json"].includes(value.valueType)
+        || typeof value.writable !== "boolean"
+        || !["live", "next-session", "next-start", "current-exit"].includes(value.application)
+        || !["agent", "shell", "terminal", "startup", "shutdown", "installation"].includes(value.owner)
+        || typeof value.available !== "boolean"
+        || !(value.limitationReason === null || typeof value.limitationReason === "string")) {
+        throw new TypeError("setting descriptor is invalid");
+    }
+    json(value.storedValue, "stored setting value");
+    json(value.effectiveValue, "effective setting value");
+    if ((value.available && value.limitationReason !== null)
+        || (!value.available && (value.limitationReason === null || value.limitationReason.length === 0))) {
+        throw new TypeError("setting descriptor availability is contradictory");
+    }
+    if (value.writable && !value.available)
+        throw new TypeError("unavailable setting cannot be writable");
+    if (value.choices)
+        for (const choice of value.choices)
+            json(choice, "setting choice");
+}
 export function assertAgentResourceDescriptor(value) { id(value.id, "resource id"); if (!["command", "prompt", "skill", "extension", "other"].includes(value.kind))
     throw new TypeError("resource kind is invalid"); text(value.label, "resource label"); json(value.metadata, "resource metadata"); }
 export function assertAgentThemeDescriptor(value) { id(value.id, "theme id"); text(value.label, "theme label"); if (!value.tokens || typeof value.tokens !== "object" || Object.values(value.tokens).some(token => typeof token !== "string"))

package/dist/{src/foundation/agent-engine-contracts → contracts/agent-engine}/domain.d.ts

@@ -48,10 +48,27 @@ export interface AgentModelDescriptor {
     readonly contextWindow: number;
     readonly thinkingLevels: readonly string[];
 }
+export type AgentSettingApplicationBoundary = "live" | "next-session" | "next-start" | "current-exit";
+export type AgentSettingOwner = "agent" | "shell" | "terminal" | "startup" | "shutdown" | "installation";
+export interface AgentSettingChangeOutcome {
+    readonly status: "applied" | "deferred" | "unavailable" | "failed";
+    readonly application: AgentSettingApplicationBoundary;
+    readonly storedValue: AgentJsonValue;
+    readonly effectiveValue: AgentJsonValue;
+    readonly failure: string | null;
+    readonly limitationReason: string | null;
+}
 export interface AgentSettingDescriptor {
     readonly key: string;
     readonly valueType: "boolean" | "number" | "string" | "enum" | "json";
+    /** A setting is writable only when its declared owner/effect is available. */
     readonly writable: boolean;
+    readonly application: AgentSettingApplicationBoundary;
+    readonly owner: AgentSettingOwner;
+    readonly available: boolean;
+    readonly limitationReason: string | null;
+    readonly storedValue: AgentJsonValue;
+    readonly effectiveValue: AgentJsonValue;
     readonly choices?: readonly AgentJsonValue[];
     /** Label the engine shows for this setting, when it has one. */
     readonly label?: string;

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

@@ -45,10 +45,16 @@ export interface AgentPackagesPort {
     update(source?: string): Promise<AgentPackageOutcome>;
     refreshModels(): Promise<AgentPackageOutcome>;
 }
+/** Recoverable operation diagnostics retain the engine's visible detail and order. */
+export interface AgentPackageDiagnostic {
+    readonly message: string;
+    readonly detail?: string;
+}
 export interface AgentPackagesPortInput {
     readonly profileRoot: string;
     readonly cwd: string;
     readonly onProgress?: (progress: AgentPackageProgress) => void;
+    readonly onDiagnostic?: (diagnostic: AgentPackageDiagnostic) => 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;