@haywoodmarx/agent-pager 0.1.0

package/dist/src/tui/theme.d.ts

@@ -0,0 +1,49 @@
+/** Renderer-independent color value accepted by a presentation adapter. */
+export type TuiThemeColor = string;
+/**
+ * A role that paints nothing, leaving whatever is already in the cell.
+ *
+ * A terminal cell has no alpha, so a fill is the only way to change a background; this is the way to
+ * decline one and let the surface below stay as it is.
+ */
+export declare const TUI_NO_FILL = "transparent";
+/** Semantic color roles shared by TUI screens and renderer adapters. */
+export interface TuiTheme {
+    /** Structural and textual presentation roles. */
+    readonly structure: {
+        readonly background: TuiThemeColor;
+        readonly selection: {
+            readonly background: TuiThemeColor;
+            readonly text: TuiThemeColor;
+        };
+        readonly dimBackdrop: TuiThemeColor;
+        readonly rulesAndLabels: TuiThemeColor;
+        readonly bodyText: TuiThemeColor;
+        readonly emphasis: TuiThemeColor;
+    };
+    /** Stable palette slots assigned to agent identities. */
+    readonly agents: readonly [TuiThemeColor, TuiThemeColor, TuiThemeColor, TuiThemeColor, TuiThemeColor, TuiThemeColor];
+    /** Message and operation lifecycle roles. */
+    readonly states: {
+        readonly complete: TuiThemeColor;
+        readonly inProgress: TuiThemeColor;
+        readonly failed: TuiThemeColor;
+        readonly expired: TuiThemeColor;
+    };
+}
+/**
+ * Preserve one semantic theme as an immutable renderer-independent value.
+ * @param theme - Complete semantic role mapping supplied by the presentation authority.
+ * @returns Frozen theme value safe to share across renderer adapters.
+ */
+export declare function defineTuiTheme(theme: TuiTheme): Readonly<TuiTheme>;
+/**
+ * Collapse every foreground role onto the backdrop colour so content behind an overlay recedes.
+ *
+ * A terminal cell carries one foreground and one background, so a backdrop is a recolour rather
+ * than an opacity: the panes keep their layout and their text, and lose every distinction the
+ * overlay is not about.
+ * @param theme - Semantic palette in normal use.
+ * @returns Frozen palette carrying the same structure with backdrop-coloured content.
+ */
+export declare function dimTuiTheme(theme: Readonly<TuiTheme>): Readonly<TuiTheme>;

package/dist/src/tui/theme.js

@@ -0,0 +1,55 @@
+/**
+ * A role that paints nothing, leaving whatever is already in the cell.
+ *
+ * A terminal cell has no alpha, so a fill is the only way to change a background; this is the way to
+ * decline one and let the surface below stay as it is.
+ */
+export const TUI_NO_FILL = "transparent";
+/**
+ * Preserve one semantic theme as an immutable renderer-independent value.
+ * @param theme - Complete semantic role mapping supplied by the presentation authority.
+ * @returns Frozen theme value safe to share across renderer adapters.
+ */
+export function defineTuiTheme(theme) {
+    return Object.freeze({
+        structure: Object.freeze({
+            ...theme.structure,
+            selection: Object.freeze({ ...theme.structure.selection }),
+        }),
+        agents: Object.freeze([
+            theme.agents[0],
+            theme.agents[1],
+            theme.agents[2],
+            theme.agents[3],
+            theme.agents[4],
+            theme.agents[5],
+        ]),
+        states: Object.freeze({ ...theme.states }),
+    });
+}
+/**
+ * Collapse every foreground role onto the backdrop colour so content behind an overlay recedes.
+ *
+ * A terminal cell carries one foreground and one background, so a backdrop is a recolour rather
+ * than an opacity: the panes keep their layout and their text, and lose every distinction the
+ * overlay is not about.
+ * @param theme - Semantic palette in normal use.
+ * @returns Frozen palette carrying the same structure with backdrop-coloured content.
+ */
+export function dimTuiTheme(theme) {
+    const backdrop = theme.structure.dimBackdrop;
+    return defineTuiTheme({
+        structure: {
+            background: theme.structure.background,
+            // Dimming is a recolour, so a selection behind an overlay recedes with everything else instead
+            // of keeping the one fill on screen.
+            selection: { background: TUI_NO_FILL, text: backdrop },
+            dimBackdrop: backdrop,
+            rulesAndLabels: backdrop,
+            bodyText: backdrop,
+            emphasis: backdrop,
+        },
+        agents: [backdrop, backdrop, backdrop, backdrop, backdrop, backdrop],
+        states: { complete: backdrop, inProgress: backdrop, failed: backdrop, expired: backdrop },
+    });
+}

package/dist/src/tui/transport.d.ts

@@ -0,0 +1,31 @@
+import { type OperatorDiagnostic, type OperatorEventEnvelope, type OperatorSnapshot } from "../operator/protocol.js";
+/** Receives atomic snapshots, ordered events, or a recovery request from a TUI transport consumer. */
+export type TuiTransportActions = {
+    replace(snapshot: OperatorSnapshot, replacement: boolean): void;
+    event(envelope: OperatorEventEnvelope): void;
+    recover(): void;
+    incompatible(): void;
+    diagnostic(diagnostic: OperatorDiagnostic): void;
+    live(): void;
+    awaitReplacement(): void;
+    replacementProgress(): void;
+};
+/** Validates and atomically assembles operator stream frames without a renderer dependency. */
+export declare class TuiOperatorTransportController {
+    #private;
+    private readonly actions;
+    /**
+     * Construct a frame reducer with explicit model actions.
+     * @param actions - Model boundary: snapshots and events arrive complete and validated, and progress, pending-replacement and recovery signals as they occur.
+     */
+    constructor(actions: TuiTransportActions);
+    /**
+     * Consume one untrusted server frame.
+     *
+     * A frame that fails validation asks the model to recover rather than throwing, as does one arriving in
+     * a phase that cannot accept it, except a heartbeat while a replacement is owed, which is dropped. Once
+     * the stream is incompatible, every frame is ignored.
+     * @param value - Candidate operator transport frame, as parsed from one line of the stream.
+     */
+    receive(value: unknown): void;
+}

package/dist/src/tui/transport.js

@@ -0,0 +1,255 @@
+import { OPERATOR_PROTOCOL_VERSION, OPERATOR_SNAPSHOT_CHUNK_BYTES, OPERATOR_SNAPSHOT_TOTAL_LIMIT_BYTES, } from "../operator/protocol.js";
+import { validateOperatorCursor, validateOperatorDiagnostic, validateOperatorEventEnvelope, validateOperatorSnapshot, } from "../operator/validation.js";
+import { exactFields, isPlainObject } from "../shared/guards.js";
+const MAX_CHUNK_BASE64_BYTES = Math.ceil(OPERATOR_SNAPSHOT_CHUNK_BYTES / 3) * 4;
+/** Validates and atomically assembles operator stream frames without a renderer dependency. */
+export class TuiOperatorTransportController {
+    actions;
+    #phase = { type: "idle" };
+    /**
+     * Construct a frame reducer with explicit model actions.
+     * @param actions - Model boundary: snapshots and events arrive complete and validated, and progress, pending-replacement and recovery signals as they occur.
+     */
+    constructor(actions) {
+        this.actions = actions;
+    }
+    /**
+     * Consume one untrusted server frame.
+     *
+     * A frame that fails validation asks the model to recover rather than throwing, as does one arriving in
+     * a phase that cannot accept it, except a heartbeat while a replacement is owed, which is dropped. Once
+     * the stream is incompatible, every frame is ignored.
+     * @param value - Candidate operator transport frame, as parsed from one line of the stream.
+     */
+    receive(value) {
+        if (this.#phase.type === "incompatible")
+            return;
+        try {
+            const frame = readFrame(value);
+            switch (frame.type) {
+                case "incompatible_version":
+                    this.#phase = { type: "incompatible" };
+                    this.actions.incompatible();
+                    return;
+                case "diagnostic":
+                    this.actions.diagnostic(frame.diagnostic);
+                    return;
+                case "heartbeat":
+                    if (this.#owedReplacement())
+                        return;
+                    this.actions.live();
+                    return;
+                case "resync_required":
+                    // A gap or an epoch change is the server's answer to a resume request, and the replacement
+                    // snapshot for it follows on this same connection. Only an unavailable stream is terminal.
+                    if (frame.reason === "stream_unavailable") {
+                        this.#fail();
+                        return;
+                    }
+                    this.#phase = { type: "awaiting_replacement" };
+                    this.actions.awaitReplacement();
+                    return;
+                case "event":
+                    if (this.#phase.type !== "idle") {
+                        this.#fail();
+                        return;
+                    }
+                    this.actions.event(frame.envelope);
+                    return;
+                case "snapshot_begin":
+                    if (this.#phase.type === "transferring") {
+                        this.#fail();
+                        return;
+                    }
+                    if ((frame.mode === "replacement") !== (this.#phase.type === "awaiting_replacement")) {
+                        this.#fail();
+                        return;
+                    }
+                    this.#phase = { type: "transferring", transfer: { ...frame, chunks: [] } };
+                    return;
+                case "snapshot_chunk": {
+                    if (this.#phase.type !== "transferring") {
+                        this.#fail();
+                        return;
+                    }
+                    const transfer = this.#phase.transfer;
+                    if (frame.index !== transfer.chunks.length || frame.index >= transfer.chunkCount) {
+                        this.#fail();
+                        return;
+                    }
+                    if (frame.bytes.byteLength !==
+                        (frame.index + 1 === transfer.chunkCount
+                            ? transfer.totalBytes - frame.index * OPERATOR_SNAPSHOT_CHUNK_BYTES
+                            : OPERATOR_SNAPSHOT_CHUNK_BYTES)) {
+                        this.#fail();
+                        return;
+                    }
+                    transfer.chunks.push(frame.bytes);
+                    if (transfer.mode === "replacement")
+                        this.actions.replacementProgress();
+                    return;
+                }
+                case "snapshot_end":
+                    this.#finish(frame);
+            }
+        }
+        catch {
+            this.#fail();
+        }
+    }
+    #owedReplacement() {
+        return (this.#phase.type === "awaiting_replacement" ||
+            (this.#phase.type === "transferring" && this.#phase.transfer.mode === "replacement"));
+    }
+    #finish(end) {
+        if (this.#phase.type !== "transferring") {
+            this.#fail();
+            return;
+        }
+        const transfer = this.#phase.transfer;
+        this.#phase = { type: "idle" };
+        if (!sameCursor(transfer.cursor, end.cursor) ||
+            transfer.totalBytes !== end.totalBytes ||
+            transfer.chunkCount !== end.chunkCount ||
+            transfer.chunks.length !== end.chunkCount) {
+            this.#fail();
+            return;
+        }
+        const bytes = Buffer.concat(transfer.chunks);
+        if (bytes.byteLength !== transfer.totalBytes) {
+            this.#fail();
+            return;
+        }
+        try {
+            const snapshot = validateOperatorSnapshot(JSON.parse(bytes.toString("utf8")));
+            if (!sameCursor(snapshot.cursor, transfer.cursor)) {
+                this.#fail();
+                return;
+            }
+            this.actions.replace(snapshot, transfer.mode === "replacement");
+        }
+        catch {
+            this.#fail();
+        }
+    }
+    #fail() {
+        // The terminal latch, once set, is never reopened: a throwing `incompatible` action reaches this
+        // through the catch in `receive` after the latch is already set, and must not undo it.
+        if (this.#phase.type === "incompatible")
+            return;
+        this.#phase = { type: "idle" };
+        this.actions.recover();
+    }
+}
+function readFrame(value) {
+    const record = exactRecord(value);
+    if (typeof record.type !== "string")
+        throw new Error("frame type");
+    switch (record.type) {
+        case "snapshot_begin": {
+            exact(record, ["type", "protocolVersion", "mode", "cursor", "encoding", "totalBytes", "chunkCount"]);
+            const totalBytes = boundedBytes(record.totalBytes);
+            const chunkCount = boundedCount(record.chunkCount, totalBytes);
+            if (record.protocolVersion !== OPERATOR_PROTOCOL_VERSION ||
+                (record.mode !== "initial" && record.mode !== "replacement") ||
+                record.encoding !== "base64")
+                throw new Error("begin");
+            return {
+                type: "snapshot_begin",
+                mode: record.mode,
+                cursor: validateOperatorCursor(record.cursor),
+                totalBytes,
+                chunkCount,
+            };
+        }
+        case "snapshot_chunk": {
+            exact(record, ["type", "protocolVersion", "index", "data"]);
+            const index = record.index;
+            const data = record.data;
+            if (record.protocolVersion !== OPERATOR_PROTOCOL_VERSION ||
+                typeof index !== "number" ||
+                !Number.isSafeInteger(index) ||
+                index < 0 ||
+                typeof data !== "string" ||
+                data.length > MAX_CHUNK_BASE64_BYTES ||
+                !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(data))
+                throw new Error("chunk");
+            const bytes = Buffer.from(data, "base64");
+            if (bytes.byteLength > OPERATOR_SNAPSHOT_CHUNK_BYTES || bytes.toString("base64") !== data)
+                throw new Error("chunk encoding");
+            return { type: "snapshot_chunk", index, bytes };
+        }
+        case "snapshot_end":
+            exact(record, ["type", "protocolVersion", "cursor", "totalBytes", "chunkCount"]);
+            if (record.protocolVersion !== OPERATOR_PROTOCOL_VERSION)
+                throw new Error("end");
+            {
+                const totalBytes = boundedBytes(record.totalBytes);
+                return {
+                    type: "snapshot_end",
+                    cursor: validateOperatorCursor(record.cursor),
+                    totalBytes,
+                    chunkCount: boundedCount(record.chunkCount, totalBytes),
+                };
+            }
+        case "event":
+            exact(record, ["type", "envelope"]);
+            return { type: "event", envelope: validateOperatorEventEnvelope(record.envelope) };
+        case "diagnostic":
+            exact(record, ["type", "diagnostic"]);
+            return { type: "diagnostic", diagnostic: validateOperatorDiagnostic(record.diagnostic) };
+        case "resync_required":
+            exact(record, ["type", "reason"]);
+            if (record.reason !== "cursor_gap" && record.reason !== "epoch_changed" && record.reason !== "stream_unavailable")
+                throw new Error("resync");
+            return { type: "resync_required", reason: record.reason };
+        case "incompatible_version":
+            exact(record, ["type", "supportedVersion", "receivedVersion"]);
+            // `supportedVersion` is the refusing peer's own version, so it differs from this build's by
+            // definition and is checked for shape only.
+            if (!Number.isSafeInteger(record.supportedVersion) || !Number.isSafeInteger(record.receivedVersion))
+                throw new Error("incompatible");
+            return { type: "incompatible_version" };
+        case "heartbeat":
+            exact(record, ["type", "cursor", "sentAt"]);
+            if (!Number.isSafeInteger(record.sentAt))
+                throw new Error("heartbeat");
+            validateOperatorCursor(record.cursor);
+            return { type: "heartbeat" };
+        default:
+            throw new Error("frame type");
+    }
+}
+function exactRecord(value) {
+    if (!isPlainObject(value))
+        throw new Error("record");
+    return value;
+}
+function exact(value, keys) {
+    exactFields({
+        record: value,
+        required: keys,
+        optional: [],
+        path: "frame",
+        fail: (_path, reason) => {
+            throw new Error(reason);
+        },
+    });
+}
+function boundedBytes(value) {
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < 1 ||
+        value > OPERATOR_SNAPSHOT_TOTAL_LIMIT_BYTES)
+        throw new Error("bytes");
+    return value;
+}
+function boundedCount(value, total) {
+    const expected = Math.ceil(total / OPERATOR_SNAPSHOT_CHUNK_BYTES);
+    if (!Number.isSafeInteger(value) || value !== expected)
+        throw new Error("count");
+    return value;
+}
+function sameCursor(left, right) {
+    return left.epoch === right.epoch && left.sequence === right.sequence;
+}

package/dist/src/version.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read the version a package manifest declares.
+ *
+ * Throws for a manifest without one, which would otherwise build `agent-pager@undefined`.
+ * @param contents - Manifest text as read from disk.
+ * @param source - Manifest path named in the rejection.
+ * @returns - The declared version.
+ */
+export declare function manifestVersion(contents: string, source: string): string;
+/** Names the published package version, read once from the nearest `package.json`. */
+export declare const PAGER_VERSION: string;

package/dist/src/version.js

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isPlainObject } from "./shared/guards.js";
+/**
+ * Read the version a package manifest declares.
+ *
+ * Throws for a manifest without one, which would otherwise build `agent-pager@undefined`.
+ * @param contents - Manifest text as read from disk.
+ * @param source - Manifest path named in the rejection.
+ * @returns - The declared version.
+ */
+export function manifestVersion(contents, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch {
+        throw new Error(`package.json is not valid JSON: ${source}`);
+    }
+    if (!isPlainObject(parsed) || typeof parsed.version !== "string" || parsed.version.length === 0) {
+        throw new Error(`package.json declares no version: ${source}`);
+    }
+    return parsed.version;
+}
+/**
+ * Read the published package version from the nearest `package.json` above this file.
+ *
+ * Walks up rather than using one fixed relative path: this module runs both directly from `src/`
+ * (Bun executing TypeScript unbuilt) and from the compiled `dist/src/` tree, one directory deeper, so
+ * no single relative path reaches `package.json` in both.
+ * @returns - The version field from the nearest ancestor `package.json`.
+ */
+function readPackageVersion() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        try {
+            const path = join(directory, "package.json");
+            return manifestVersion(readFileSync(path, "utf8"), path);
+        }
+        catch (error) {
+            if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT"))
+                throw error;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error(`package.json not found above ${import.meta.url}`);
+        directory = parent;
+    }
+}
+/** Names the published package version, read once from the nearest `package.json`. */
+export const PAGER_VERSION = readPackageVersion();

package/package.json

@@ -0,0 +1,142 @@
+{
+  "name": "@haywoodmarx/agent-pager",
+  "version": "0.1.0",
+  "description": "Durable local messaging between agent implementations.",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "packageManager": "bun@1.4.2",
+  "engines": {
+    "bun": ">=1.4.2"
+  },
+  "bin": {
+    "pager": "dist/src/launch/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "bun": "./dist/src/index.js",
+      "import": "./dist/src/index.js"
+    },
+    "./implementation/opencode": {
+      "types": "./dist/src/implementations/opencode/plugin.d.ts",
+      "bun": "./dist/src/implementations/opencode/plugin.js",
+      "import": "./dist/src/implementations/opencode/plugin.js"
+    }
+  },
+  "files": [
+    "dist",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./dist/src/implementations/pi/extension.js"
+    ]
+  },
+  "scripts": {
+    "prepare": "bun install --frozen-lockfile --ignore-scripts && bun run build && husky",
+    "build": "bun scripts/tooling/build.mjs",
+    "prepack": "bun run build",
+    "check:client-boundary": "bun scripts/tooling/client-boundary-self-test.mjs && bun scripts/tooling/client-boundary.mjs",
+    "check:broker-writes": "bun scripts/tooling/broker-writes-self-test.mjs && bun scripts/tooling/broker-writes.mjs",
+    "check:fixture-checksums": "bun scripts/tooling/fixture-checksums.mjs",
+    "check:skill-limits": "bun scripts/tooling/skill-limits-check.mjs",
+    "format:check": "bun run --bun prettier --check 'src/**/*.{ts,tsx}' 'tests/**/*.{ts,tsx,mjs}' 'scripts/**/*.{mjs,mts}' '*.md' 'docs/**/*.{md,json}' 'skills/**/*.md' '.claude/skills/final-review/**/*.md' 'fixtures/implementations/**/*.json' '**/*.{json,js,ts,tsx,cjs}'",
+    "lint": "bun run --bun eslint . --report-unused-disable-directives --max-warnings=0",
+    "lint:target": "bun scripts/tooling/lint-target.mjs",
+    "gate": "bun scripts/tooling/gate.mjs",
+    "mutation:verify": "bun scripts/tooling/mutation-verify.mjs",
+    "seed:tui": "bun scripts/tooling/seed-tui.mjs",
+    "seed:conversations": "bun scripts/tooling/seed-conversations.mjs",
+    "test": "bun run test:unit",
+    "test:unit": "bun test tests/unit",
+    "test:coverage": "bun run build && bun scripts/tooling/coverage-inventory.mjs",
+    "test:implementation-contracts": "bun run build && bun scripts/implementations/contracts/adapter-contract.mjs",
+    "test:package": "bun scripts/tooling/package-smoke.mjs",
+    "test:package:npm-compat": "bun scripts/tooling/package-smoke.mjs --npm",
+    "typecheck": "bun run --bun tsc --noEmit && bun run --bun tsc --noEmit -p tsconfig.scripts-tooling.json",
+    "live:configs": "bun scripts/implementations/acceptance/live-configs.mjs",
+    "live:mcp": "bun run build && bun scripts/implementations/acceptance/live-mcp-server.mjs",
+    "test:live-implementations": "bun run build && bun scripts/implementations/acceptance/message-lifecycle.mjs",
+    "test:integration": "bun run build && bun test tests/integration",
+    "test:live-terminal": "bun run build && bun scripts/implementations/acceptance/terminal-message-lifecycle.mjs",
+    "test:live-launch": "bun run build && bun scripts/implementations/acceptance/launch-lifecycle.mjs",
+    "test:live-wrapper-launch": "bun run build && bun scripts/implementations/acceptance/wrapper-launch.mjs",
+    "test:live-production": "bun run build && bun scripts/implementations/acceptance/production-lifecycle.mjs",
+    "test:live-pi": "bun run build && bun scripts/implementations/acceptance/pi-lifecycle.mjs",
+    "test:live-editor-push": "bun run build && bun scripts/implementations/acceptance/editor-push.mjs",
+    "test:live-editor-close": "bun run build && bun scripts/implementations/acceptance/editor-self-close.mjs",
+    "test:live-claude": "bun run build && bun scripts/implementations/acceptance/claude-observer.mjs",
+    "test:terminal-provider": "bun run build && bun scripts/implementations/acceptance/terminal-provider.mjs"
+  },
+  "gateSteps": [
+    "check:client-boundary",
+    "check:broker-writes",
+    "check:fixture-checksums",
+    "check:skill-limits",
+    "typecheck",
+    "lint",
+    "format:check",
+    "test",
+    "test:integration",
+    "test:coverage",
+    "build",
+    "test:package",
+    "test:implementation-contracts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/haywoodmarx/agent-pager.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "agents",
+    "messaging",
+    "orchestration",
+    "pi-package"
+  ],
+  "author": "Haywood-Marx",
+  "license": "MIT",
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.7.2",
+    "@eslint/js": "^10.0.1",
+    "@types/bun": "^1.3.14",
+    "@types/node": "^26.1.2",
+    "@types/react": "^19.2.17",
+    "eslint": "^10.8.0",
+    "eslint-plugin-jsdoc": "^63.3.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.2.0",
+    "prettier": "^3.9.6",
+    "typebox": "1.3.3",
+    "typescript": "6.0.3",
+    "typescript-eslint": "^8.65.0"
+  },
+  "dependencies": {
+    "@opentui/core": "0.5.10",
+    "@opentui/react": "0.5.10",
+    "@modelcontextprotocol/client": "2.0.0",
+    "@modelcontextprotocol/server": "2.0.0",
+    "react": "^19.2.8"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "^1.3.3"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  },
+  "overrides": {
+    "brace-expansion": "5.0.9"
+  }
+}