@timurproko/a1 0.2.6-dev.727 → 0.2.6-dev.734

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.2.6-dev.727",
+  "version": "0.2.6-dev.734",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",

package/dist/contracts/agent-engine/model.d.ts

@@ -1,78 +0,0 @@
-import type { AgentMessage } from "./domain.js";
-export declare const AGENT_ENGINE_CONTRACT_VERSION: 1;
-export type AgentSessionId = string;
-export type AgentCommandId = string;
-export type AgentEventSequence = number;
-export type AgentSessionLifecycle = "starting" | "ready" | "busy" | "stopping" | "stopped" | "failed";
-export type AgentCommandCapability = "prompt" | "steer" | "follow-up" | "abort" | "retry" | "compact" | "bash" | "replace-session";
-export type AgentEventCapability = "lifecycle" | "content" | "command-outcome" | "snapshot-invalidated" | "diagnostic";
-export interface AgentCapabilityContract {
-    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
-    readonly commands: readonly AgentCommandCapability[];
-    readonly events: readonly AgentEventCapability[];
-    readonly snapshots: {
-        readonly supported: boolean;
-        readonly maxBytes: number;
-    };
-}
-interface AgentCommandEnvelope {
-    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
-    readonly commandId: AgentCommandId;
-    readonly sessionId: AgentSessionId;
-}
-export type AgentCommand = (AgentCommandEnvelope & {
-    readonly type: "prompt" | "steer" | "follow-up";
-    readonly text: string;
-}) | (AgentCommandEnvelope & {
-    readonly type: "abort" | "retry" | "compact";
-}) | (AgentCommandEnvelope & {
-    readonly type: "bash";
-    readonly command: string;
-}) | (AgentCommandEnvelope & {
-    readonly type: "replace-session";
-    readonly source: {
-        readonly kind: "new";
-    } | {
-        readonly kind: "resume";
-        readonly sessionPath: string;
-    };
-});
-export type AgentCommandOutcome = "accepted" | "completed" | "rejected" | "failed" | "cancelled";
-interface AgentEventEnvelope {
-    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
-    readonly sessionId: AgentSessionId;
-    readonly sequence: AgentEventSequence;
-}
-export type AgentEvent = (AgentEventEnvelope & {
-    readonly type: "lifecycle";
-    readonly lifecycle: AgentSessionLifecycle;
-    readonly reason: string | null;
-}) | (AgentEventEnvelope & {
-    readonly type: "content";
-    readonly content: AgentMessage;
-}) | (AgentEventEnvelope & {
-    readonly type: "command-outcome";
-    readonly commandId: AgentCommandId;
-    readonly outcome: AgentCommandOutcome;
-    readonly diagnostic: string | null;
-}) | (AgentEventEnvelope & {
-    readonly type: "snapshot-invalidated";
-    readonly expectedRevision: number;
-}) | (AgentEventEnvelope & {
-    readonly type: "diagnostic";
-    readonly code: string;
-    readonly message: string;
-    readonly recoverable: boolean;
-});
-export interface AgentSnapshot {
-    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
-    readonly snapshotId: string;
-    readonly sessionId: AgentSessionId;
-    readonly revision: number;
-    readonly sequence: AgentEventSequence;
-    readonly lifecycle: AgentSessionLifecycle;
-    readonly content: readonly AgentMessage[];
-    readonly activeCommandIds: readonly AgentCommandId[];
-    readonly capabilities: AgentCapabilityContract;
-}
-export {};

package/dist/contracts/agent-engine/model.js

@@ -1 +0,0 @@
-export const AGENT_ENGINE_CONTRACT_VERSION = 1;

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

@@ -1,18 +0,0 @@
-import type { AgentCapabilityContract, AgentCommand, AgentCommandOutcome, AgentEvent, AgentSessionId, AgentSessionLifecycle, AgentSnapshot } from "./model.js";
-export interface AgentSessionPort {
-    readonly sessionId: AgentSessionId;
-    readonly lifecycle: AgentSessionLifecycle;
-    readonly capabilities: AgentCapabilityContract;
-    execute(command: AgentCommand): Promise<AgentCommandOutcome>;
-    subscribe(listener: (event: AgentEvent) => void): () => void;
-    snapshot(): Promise<AgentSnapshot>;
-    dispose(): Promise<void>;
-}
-export interface AgentEnginePort {
-    readonly capabilities: AgentCapabilityContract;
-    createSession(input: {
-        readonly sessionId: AgentSessionId;
-        readonly cwd: string;
-    }): Promise<AgentSessionPort>;
-    dispose(): Promise<void>;
-}

package/dist/contracts/agent-engine/serialization.d.ts

@@ -1,7 +0,0 @@
-import type { AgentCapabilityContract, AgentCommand, AgentEvent, AgentSnapshot } from "./model.js";
-export declare function encodeAgentCommand(command: AgentCommand, capabilities?: AgentCapabilityContract): string;
-export declare function decodeAgentCommand(source: string, capabilities?: AgentCapabilityContract): AgentCommand;
-export declare function encodeAgentEvent(event: AgentEvent, capabilities?: AgentCapabilityContract): string;
-export declare function decodeAgentEvent(source: string, capabilities?: AgentCapabilityContract): AgentEvent;
-export declare function encodeAgentSnapshot(snapshot: AgentSnapshot): string;
-export declare function decodeAgentSnapshot(source: string): AgentSnapshot;

package/dist/contracts/agent-engine/serialization.js

@@ -1,58 +0,0 @@
-import { assertAgentCommand, assertAgentEvent, assertAgentSnapshot } from "./validation.js";
-const MAX_ENVELOPE_BYTES = 1024 * 1024;
-export function encodeAgentCommand(command, capabilities) {
-    assertAgentCommand(command, capabilities);
-    return encode(command);
-}
-export function decodeAgentCommand(source, capabilities) {
-    const value = decode(source);
-    assertAgentCommand(value, capabilities);
-    return value;
-}
-export function encodeAgentEvent(event, capabilities) {
-    assertAgentEvent(event, capabilities);
-    return encode(event);
-}
-export function decodeAgentEvent(source, capabilities) {
-    const value = decode(source);
-    assertAgentEvent(value, capabilities);
-    return value;
-}
-export function encodeAgentSnapshot(snapshot) {
-    assertAgentSnapshot(snapshot);
-    const encoded = encode(snapshot);
-    if (Buffer.byteLength(encoded, "utf8") > snapshot.capabilities.snapshots.maxBytes)
-        throw new RangeError("agent snapshot exceeds negotiated byte limit");
-    return encoded;
-}
-export function decodeAgentSnapshot(source) {
-    const value = decode(source);
-    assertAgentSnapshot(value);
-    if (Buffer.byteLength(source, "utf8") > value.capabilities.snapshots.maxBytes)
-        throw new RangeError("agent snapshot exceeds negotiated byte limit");
-    return value;
-}
-function encode(value) {
-    let encoded;
-    try {
-        encoded = JSON.stringify(value);
-    }
-    catch (error) {
-        throw new TypeError("agent contract value must be JSON serializable", { cause: error });
-    }
-    if (encoded === undefined)
-        throw new TypeError("agent contract value must be JSON serializable");
-    if (Buffer.byteLength(encoded, "utf8") > MAX_ENVELOPE_BYTES)
-        throw new RangeError("agent contract envelope exceeds its byte limit");
-    return encoded;
-}
-function decode(source) {
-    if (typeof source !== "string" || Buffer.byteLength(source, "utf8") > MAX_ENVELOPE_BYTES)
-        throw new RangeError("agent contract envelope exceeds its byte limit");
-    try {
-        return JSON.parse(source);
-    }
-    catch (error) {
-        throw new TypeError("agent contract envelope is invalid JSON", { cause: error });
-    }
-}

package/dist/contracts/agent-engine/validation.d.ts

@@ -1,5 +0,0 @@
-import { type AgentCapabilityContract, type AgentCommand, type AgentEvent, type AgentSnapshot } from "./model.js";
-export declare function assertAgentCapabilityContract(value: AgentCapabilityContract): void;
-export declare function assertAgentCommand(command: AgentCommand, capabilities?: AgentCapabilityContract): void;
-export declare function assertAgentEvent(event: AgentEvent, capabilities?: AgentCapabilityContract): void;
-export declare function assertAgentSnapshot(snapshot: AgentSnapshot): void;

package/dist/contracts/agent-engine/validation.js

@@ -1,128 +0,0 @@
-import { AGENT_ENGINE_CONTRACT_VERSION, } from "./model.js";
-import { assertAgentMessage } from "./domain-validation.js";
-const COMMANDS = new Set(["prompt", "steer", "follow-up", "abort", "retry", "compact", "bash", "replace-session"]);
-const EVENTS = new Set(["lifecycle", "content", "command-outcome", "snapshot-invalidated", "diagnostic"]);
-const LIFECYCLES = new Set(["starting", "ready", "busy", "stopping", "stopped", "failed"]);
-const OUTCOMES = new Set(["accepted", "completed", "rejected", "failed", "cancelled"]);
-const MAX_TEXT_BYTES = 256 * 1024;
-const MAX_COLLECTION = 10_000;
-export function assertAgentCapabilityContract(value) {
-    assertVersion(value.contractVersion);
-    assertUniqueEnum(value.commands, COMMANDS, "agent command capabilities");
-    assertUniqueEnum(value.events, EVENTS, "agent event capabilities");
-    if (typeof value.snapshots?.supported !== "boolean" || !Number.isSafeInteger(value.snapshots.maxBytes) || value.snapshots.maxBytes < 1024) {
-        throw new TypeError("agent snapshot capability is invalid");
-    }
-}
-export function assertAgentCommand(command, capabilities) {
-    assertVersion(command.contractVersion);
-    assertId(command.commandId, "agent command id");
-    assertId(command.sessionId, "agent command session id");
-    if (!COMMANDS.has(command.type))
-        throw new TypeError("agent command type is unknown");
-    if (capabilities !== undefined) {
-        assertAgentCapabilityContract(capabilities);
-        if (!capabilities.commands.includes(command.type))
-            throw new TypeError(`agent command capability is unavailable: ${command.type}`);
-    }
-    if (command.type === "prompt" || command.type === "steer" || command.type === "follow-up")
-        assertText(command.text, "agent command text");
-    if (command.type === "bash")
-        assertText(command.command, "agent bash command");
-    if (command.type === "replace-session" && command.source.kind === "resume")
-        assertText(command.source.sessionPath, "agent resume path");
-}
-export function assertAgentEvent(event, capabilities) {
-    assertVersion(event.contractVersion);
-    assertId(event.sessionId, "agent event session id");
-    assertNonNegative(event.sequence, "agent event sequence");
-    if (!EVENTS.has(event.type))
-        throw new TypeError("agent event type is unknown");
-    if (capabilities !== undefined) {
-        assertAgentCapabilityContract(capabilities);
-        if (!capabilities.events.includes(event.type))
-            throw new TypeError(`agent event capability is unavailable: ${event.type}`);
-    }
-    switch (event.type) {
-        case "lifecycle":
-            if (!LIFECYCLES.has(event.lifecycle))
-                throw new TypeError("agent lifecycle is invalid");
-            if (event.reason !== null)
-                assertText(event.reason, "agent lifecycle reason");
-            return;
-        case "content":
-            assertAgentMessage(event.content);
-            return;
-        case "command-outcome":
-            assertId(event.commandId, "agent outcome command id");
-            if (!OUTCOMES.has(event.outcome))
-                throw new TypeError("agent command outcome is invalid");
-            if (event.diagnostic !== null)
-                assertText(event.diagnostic, "agent outcome diagnostic");
-            return;
-        case "snapshot-invalidated":
-            assertNonNegative(event.expectedRevision, "agent expected snapshot revision");
-            return;
-        case "diagnostic":
-            assertId(event.code, "agent diagnostic code");
-            assertText(event.message, "agent diagnostic message");
-            if (typeof event.recoverable !== "boolean")
-                throw new TypeError("agent diagnostic recovery flag is invalid");
-    }
-}
-export function assertAgentSnapshot(snapshot) {
-    assertVersion(snapshot.contractVersion);
-    assertId(snapshot.snapshotId, "agent snapshot id");
-    assertId(snapshot.sessionId, "agent snapshot session id");
-    assertNonNegative(snapshot.revision, "agent snapshot revision");
-    assertNonNegative(snapshot.sequence, "agent snapshot sequence");
-    if (!LIFECYCLES.has(snapshot.lifecycle))
-        throw new TypeError("agent snapshot lifecycle is invalid");
-    assertAgentCapabilityContract(snapshot.capabilities);
-    if (!Array.isArray(snapshot.content) || snapshot.content.length > MAX_COLLECTION)
-        throw new RangeError("agent snapshot content collection is invalid");
-    for (const content of snapshot.content)
-        assertAgentEvent({ contractVersion: AGENT_ENGINE_CONTRACT_VERSION, sessionId: snapshot.sessionId, sequence: snapshot.sequence, type: "content", content });
-    if (!Array.isArray(snapshot.activeCommandIds) || snapshot.activeCommandIds.length > MAX_COLLECTION)
-        throw new RangeError("agent active command collection is invalid");
-    const ids = new Set();
-    for (const id of snapshot.activeCommandIds) {
-        assertId(id, "agent active command id");
-        if (ids.has(id))
-            throw new TypeError(`duplicate agent active command id: ${id}`);
-        ids.add(id);
-    }
-}
-function assertVersion(version) {
-    if (version !== AGENT_ENGINE_CONTRACT_VERSION)
-        throw new TypeError("unsupported agent engine contract version");
-}
-function assertUniqueEnum(values, allowed, label) {
-    if (!Array.isArray(values))
-        throw new TypeError(`${label} must be an array`);
-    const unique = new Set();
-    for (const value of values) {
-        if (!allowed.has(value))
-            throw new TypeError(`${label} contains an unknown value: ${String(value)}`);
-        if (unique.has(value))
-            throw new TypeError(`${label} contains a duplicate value: ${String(value)}`);
-        unique.add(value);
-    }
-}
-function assertId(value, label) {
-    if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value))
-        throw new TypeError(`${label} is invalid`);
-}
-function assertText(value, label) {
-    if (typeof value !== "string" || value.length === 0)
-        throw new TypeError(`${label} is invalid`);
-    assertPossiblyEmptyText(value, label);
-}
-function assertPossiblyEmptyText(value, label) {
-    if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > MAX_TEXT_BYTES)
-        throw new RangeError(`${label} exceeds its byte limit`);
-}
-function assertNonNegative(value, label) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new TypeError(`${label} is invalid`);
-}

package/dist/integrations/pi/components/upstream/theme/system-theme.d.ts

@@ -1,61 +0,0 @@
-/**
- * Provenance: @earendil-works/pi-coding-agent 1.1.0 (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7,
- * packages/coding-agent/src/modes/interactive/theme/system-theme.ts.
- * Modifications: Copied the system palette generator with ESM import remapping and strict
- * indexed-access assertions; A1 retains explicit owned theme selection.
- * Deviations: none.
- */
-/**
- * The `system` theme: pi's colors derived from the terminal's own theme.
- *
- * Every token belongs to a color family (its hue) and has contrast rules: it must reach a contrast level
- * on the background and on the panels it is drawn on. Hue and saturation come from the terminal's palette
- * color for the family's ANSI slot, or from the family's own hue when the terminal reports no palette.
- * Lightness comes from the rules alone. Colors are built in OKHSL, whose saturation is relative to the
- * sRGB gamut, and fade toward gray near black and white. A palette color never gains OKLCH chroma when it
- * moves to another lightness, so pastel palettes stay pastel.
- *
- * A contrast level is a target-lightness curve: the OKLab lightness a token needs, given the lightness of
- * the surface below it. The curves were fitted to the reference theme design from the "Pi themes: system
- * and light/dark" review. On dark backgrounds they aim for nearly fixed lightness; on light backgrounds the
- * required difference grows as the background darkens.
- *
- * Depending on what the terminal reports, the theme is generated in one of three tiers:
- * - background and palette: hues from the palette, lightness from the background;
- * - background only: the families' own hues, lightness from the background;
- * - nothing: ANSI palette indices and the default colors, which the terminal renders itself.
- */
-import { type RgbColor } from "@earendil-works/pi-tui";
-import type { ThemeAppearance, ThemeColor, ThemeToken } from "./theme.js";
-export declare const SYSTEM_THEME_NAME = "system";
-export interface SystemThemeInput {
-    foreground?: RgbColor;
-    background?: RgbColor;
-    /** ANSI colors 0-15. */
-    palette?: RgbColor[];
-    /** Saturation multiplier from 0 (grayscale) to 1. The first frame renders in grayscale until colors arrive. */
-    saturation?: number;
-    /** Appearance when the terminal did not report its background, e.g. from its light/dark report or COLORFGBG. */
-    appearanceHint?: ThemeAppearance;
-}
-export interface SystemThemeColors {
-    /** Hex colors, ANSI palette indices, or "" for the terminal default. */
-    colors: Record<ThemeToken, string | number>;
-    /** Foreground tokens rendered faint (SGR 2), for terminals that did not report colors. */
-    dim: ThemeColor[];
-    appearance: ThemeAppearance | undefined;
-}
-/** WCAG 2 relative luminance. */
-export declare function relativeLuminance({ r, g, b }: RgbColor): number;
-/** WCAG 2 contrast ratio, 1-21. */
-export declare function wcagContrast(first: RgbColor, second: RgbColor): number;
-/**
- * Whether a terminal is dark or light, from its reported colors: the direction of its own foreground
- * when text can be readable that way, otherwise dark when white text has more contrast on the
- * background than black text.
- */
-export declare function terminalAppearance(background: RgbColor, foreground?: RgbColor): ThemeAppearance;
-/**
- * Generate the system theme's colors from the terminal's reported colors.
- */
-export declare function generateSystemThemeColors(input: SystemThemeInput): SystemThemeColors;