@maiaos/cli 0.1.0-canary.2

package/dist/terminal/output/compact-list.js

@@ -0,0 +1,152 @@
+const projectCleanup = (cleanup) => cleanup.state === "unknown"
+    ? { reason: cleanup.reason, state: cleanup.state }
+    : { state: cleanup.state };
+const projectOptionalCleanup = (cleanup) => cleanup.state === "pending" ? {} : { cleanup: projectCleanup(cleanup) };
+const projectExit = (exit) => ({
+    ...(exit.code === undefined ? {} : { code: exit.code }),
+    observedAt: exit.observedAt,
+    ...(exit.signal === undefined ? {} : { signal: exit.signal }),
+});
+const projectOptionalExit = (terminal) => "exit" in terminal && terminal.exit !== undefined
+    ? { exit: projectExit(terminal.exit) }
+    : {};
+const projectUnavailableTerminal = (terminal) => ({
+    id: terminal.id,
+    projectId: terminal.projectId,
+    revision: terminal.revision,
+    state: terminal.state,
+    unavailability: terminal.unavailability,
+    workspaceId: terminal.workspaceId,
+    workspaceRevision: terminal.workspaceRevision,
+});
+const projectLiveTerminal = (terminal, includeViewport, audience) => ({
+    ...(audience === "human"
+        ? { capability: { tier: terminal.capability.tier } }
+        : {}),
+    ...projectOptionalCleanup(terminal.cleanup),
+    ...projectOptionalExit(terminal),
+    generation: terminal.generation,
+    id: terminal.id,
+    projectId: terminal.projectId,
+    revision: terminal.revision,
+    state: terminal.state,
+    ...(includeViewport
+        ? {
+            viewport: {
+                columns: terminal.viewport.columns,
+                rows: terminal.viewport.rows,
+            },
+        }
+        : {}),
+    workspaceId: terminal.workspaceId,
+    workspaceRevision: terminal.workspaceRevision,
+});
+export const terminalOutputAudience = (json) => json ? "json" : "human";
+export const projectTerminalListItem = (terminal, audience = "json") => (terminal.state === "unavailable"
+    ? projectUnavailableTerminal(terminal)
+    : projectLiveTerminal(terminal, false, audience));
+const projectTerminalShowTerminal = (terminal, audience = "json") => (terminal.state === "unavailable"
+    ? projectUnavailableTerminal(terminal)
+    : projectLiveTerminal(terminal, true, audience));
+export const projectTerminalListResult = (value, workspaceId, audience = "json") => ({
+    command: "terminal.list",
+    count: value.items.length,
+    items: value.items.map((item) => projectTerminalListItem(item, audience)),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+    workspaceId: value.items[0]?.workspaceId ?? workspaceId,
+});
+export const projectTerminalShowResult = (value, audience = "json") => ({
+    command: "terminal.show",
+    terminal: projectTerminalShowTerminal(value.terminal, audience),
+});
+const projectLegacyEvent = (event, audience) => ({
+    cursor: event.terminalCursor,
+    ...(audience === "human" ? { globalCursor: event.globalCursor } : {}),
+    type: event.eventType,
+    unavailability: {
+        code: event.payload.code,
+        platform: event.payload.platform,
+    },
+});
+const projectCleanupEvent = (event) => ({
+    cleanup: projectCleanup(event.cleanup),
+    cursor: event.cursor,
+    type: "cleanup",
+});
+const projectControllerRevokedEvent = (event) => ({
+    cursor: event.cursor,
+    leaseId: event.leaseId,
+    reason: event.reason,
+    type: "controller-revoked",
+});
+const projectExitEvent = (event) => ({
+    cursor: event.cursor,
+    exit: projectExit(event.exit),
+    type: "exit",
+});
+const projectGapEvent = (event) => ({
+    cursor: event.cursor,
+    headCursor: event.headCursor,
+    oldestAvailableCursor: event.oldestAvailableCursor,
+    reason: event.reason,
+    recovery: event.recovery,
+    ...(event.requestedAfterCursor === undefined
+        ? {}
+        : { requestedAfterCursor: event.requestedAfterCursor }),
+    type: "gap",
+});
+const projectLifecycleEvent = (event, audience) => ({
+    cursor: event.cursor,
+    previousCleanup: projectCleanup(event.previousCleanup),
+    previousGeneration: event.previousGeneration,
+    previousRevision: event.previousRevision,
+    previousState: event.previousState,
+    terminal: projectTerminalListItem(event.terminal, audience),
+    transition: event.transition,
+    type: "lifecycle-transition",
+});
+const projectLiveEvent = (event, audience) => {
+    switch (event.type) {
+        case "cleanup":
+            return projectCleanupEvent(event);
+        case "controller-revoked":
+            return projectControllerRevokedEvent(event);
+        case "exit":
+            return projectExitEvent(event);
+        case "gap":
+            return projectGapEvent(event);
+        case "lifecycle-transition":
+            return projectLifecycleEvent(event, audience);
+        case "output":
+            return { cursor: event.cursor, type: "output" };
+    }
+};
+export const projectTerminalEvent = (event, audience = "json") => "eventType" in event
+    ? projectLegacyEvent(event, audience)
+    : projectLiveEvent(event, audience);
+export const projectTerminalEventsResult = (value, audience = "json") => ({
+    command: "terminal.events",
+    count: value.items.length,
+    headCursor: value.headTerminalCursor,
+    items: value.items.map((event) => projectTerminalEvent(event, audience)),
+    ...(value.nextTerminalCursor === undefined
+        ? {}
+        : { nextCursor: value.nextTerminalCursor }),
+    terminalId: value.terminalId,
+});
+export const projectTerminalChunk = (chunk) => ({
+    bytesBase64: chunk.bytesBase64,
+    cursor: chunk.cursor,
+    ...("generation" in chunk ? { generation: chunk.generation } : {}),
+});
+export const projectTerminalReadResult = (value) => ({
+    command: "terminal.read",
+    count: value.items.length,
+    headChunkCursor: value.headChunkCursor,
+    items: value.items.map(projectTerminalChunk),
+    ...(value.nextChunkCursor === undefined
+        ? {}
+        : { nextChunkCursor: value.nextChunkCursor }),
+    terminalId: value.terminalId,
+});
+//# sourceMappingURL=compact-list.js.map

package/dist/terminal/output/human.d.ts

@@ -0,0 +1,59 @@
+import type { LiveTerminalCloseResult, LiveTerminalControllerAcquireResult, LiveTerminalControllerReleaseResult, LiveTerminalControllerRequestResult, LiveTerminalControllerRequestShowResult, LiveTerminalResizeResult, LiveTerminalSignalResult, LiveTerminalWriteResult, TerminalCreateResult, TerminalListResult } from "@maiaos/sdk";
+import { type CliIo } from "../../command-line/index.js";
+import type { CliNodeResult } from "../../local-node/index.js";
+import type { CliOutputAudience, CliTerminalEventsResult, CliTerminalListResult, CliTerminalReadResult, CliTerminalShowResult } from "./compact-list.js";
+type UnavailableTerminal = Extract<TerminalListResult["items"][number], {
+    readonly state: "unavailable";
+}>;
+type UnavailableTerminalCreateResult = Extract<TerminalCreateResult, {
+    readonly accepted: false;
+}>;
+type InteractiveTerminalCreateResult = Exclude<TerminalCreateResult, UnavailableTerminalCreateResult>;
+export type CliTerminalResult = CliTerminalEventsResult<CliOutputAudience> | CliTerminalListResult<CliOutputAudience> | CliTerminalReadResult | CliTerminalShowResult<CliOutputAudience> | {
+    readonly command: "terminal.close";
+    readonly result: LiveTerminalCloseResult;
+} | {
+    readonly command: "terminal.controller.acquire";
+    readonly result: LiveTerminalControllerAcquireResult;
+} | {
+    readonly command: "terminal.controller.release";
+    readonly result: LiveTerminalControllerReleaseResult;
+} | {
+    readonly command: "terminal.controller.request";
+    readonly result: LiveTerminalControllerRequestResult;
+} | {
+    readonly command: "terminal.controller.request.show";
+    readonly result: LiveTerminalControllerRequestShowResult;
+} | {
+    readonly command: "terminal.create";
+    readonly result: InteractiveTerminalCreateResult | {
+        readonly accepted: false;
+        readonly delivery: UnavailableTerminalCreateResult["delivery"];
+        readonly receipt: UnavailableTerminalCreateResult["receipt"];
+        readonly state: UnavailableTerminal["state"];
+        readonly terminalId: string;
+        readonly unavailability: UnavailableTerminal["unavailability"];
+        readonly workspaceId: string;
+        readonly workspaceRevision: string;
+    };
+} | {
+    readonly command: "terminal.input.write";
+    readonly result: LiveTerminalWriteResult;
+} | {
+    readonly command: "terminal.resize";
+    readonly result: LiveTerminalResizeResult;
+} | {
+    readonly command: "terminal.signal";
+    readonly result: LiveTerminalSignalResult;
+};
+export declare const formatTerminalList: (result: CliTerminalListResult<CliOutputAudience>) => string;
+export declare const formatTerminalShow: (result: CliTerminalShowResult<CliOutputAudience>) => string;
+export declare const formatTerminalEvents: (result: CliTerminalEventsResult<CliOutputAudience>) => string;
+export declare const formatTerminalRead: (result: CliTerminalReadResult) => string;
+export declare const formatTerminalResult: (result: CliTerminalResult) => string;
+export declare const writeTerminalResult: <TValue>(result: CliNodeResult<TValue>, context: {
+    readonly io: CliIo;
+    readonly json: boolean;
+}, map: (value: TValue) => CliTerminalResult) => number;
+export {};
+//# sourceMappingURL=human.d.ts.map

package/dist/terminal/output/human.js

@@ -0,0 +1,55 @@
+import { cell, formatRows, writeNodeResult, } from "../../command-line/index.js";
+const isHumanLiveTerminal = (terminal) => terminal.state !== "unavailable" && "capability" in terminal;
+const formatTerminalProjection = (terminal) => {
+    if (terminal.state === "unavailable") {
+        return `${cell(terminal.id)}\t${cell(terminal.state)}\t${cell(terminal.unavailability.code)}\t${cell(terminal.workspaceId)}`;
+    }
+    if (!isHumanLiveTerminal(terminal)) {
+        throw new Error("Human live terminal TSV requires capability.tier.");
+    }
+    return `${cell(terminal.id)}\t${cell(terminal.state)}\t${cell(terminal.capability.tier)}\t${cell(terminal.workspaceId)}`;
+};
+export const formatTerminalList = (result) => formatRows(result.items, formatTerminalProjection, "No terminals.");
+export const formatTerminalShow = (result) => `${formatTerminalProjection(result.terminal)}\n`;
+const isHumanLegacyEvent = (event) => "unavailability" in event && "globalCursor" in event;
+const formatTerminalEvent = (event) => {
+    if ("unavailability" in event) {
+        if (!isHumanLegacyEvent(event)) {
+            throw new Error("Human legacy terminal event TSV requires globalCursor.");
+        }
+        return `${cell(event.cursor)}\t${cell(event.type)}\t${cell(event.globalCursor)}`;
+    }
+    return `${cell(event.cursor)}\t${cell(event.type)}`;
+};
+export const formatTerminalEvents = (result) => formatRows(result.items, formatTerminalEvent);
+export const formatTerminalRead = (result) => formatRows(result.items, (chunk) => `${cell(chunk.cursor)}\t${chunk.bytesBase64}`);
+export const formatTerminalResult = (result) => {
+    switch (result.command) {
+        case "terminal.create":
+            return "accepted" in result.result && !result.result.accepted
+                ? `${result.result.terminalId}\t${result.result.state}\t${result.result.unavailability.code}\n`
+                : `${JSON.stringify(result.result)}\n`;
+        case "terminal.close":
+        case "terminal.controller.acquire":
+        case "terminal.controller.release":
+        case "terminal.controller.request":
+        case "terminal.controller.request.show":
+        case "terminal.input.write":
+        case "terminal.resize":
+        case "terminal.signal":
+            return `${JSON.stringify(result.result)}\n`;
+        case "terminal.events":
+            return formatTerminalEvents(result);
+        case "terminal.list":
+            return formatTerminalList(result);
+        case "terminal.read":
+            return formatTerminalRead(result);
+        case "terminal.show":
+            return formatTerminalShow(result);
+    }
+};
+export const writeTerminalResult = (result, context, map) => writeNodeResult(result, context, {
+    toResult: map,
+    toText: formatTerminalResult,
+});
+//# sourceMappingURL=human.js.map

package/dist/terminal/output/index.d.ts

@@ -0,0 +1,3 @@
+export { type CliLiveTerminal, type CliOutputAudience, type CliTerminalEvent, type CliTerminalEventsResult, type CliTerminalListItem, type CliTerminalListResult, type CliTerminalReadResult, type CliTerminalShowResult, type CliTerminalShowTerminal, projectTerminalEventsResult, projectTerminalListResult, projectTerminalReadResult, projectTerminalShowResult, terminalOutputAudience, } from "./compact-list.js";
+export { type CliTerminalResult, formatTerminalEvents, formatTerminalList, formatTerminalRead, formatTerminalResult, formatTerminalShow, writeTerminalResult, } from "./human.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/terminal/output/index.js

@@ -0,0 +1,3 @@
+export { projectTerminalEventsResult, projectTerminalListResult, projectTerminalReadResult, projectTerminalShowResult, terminalOutputAudience, } from "./compact-list.js";
+export { formatTerminalEvents, formatTerminalList, formatTerminalRead, formatTerminalResult, formatTerminalShow, writeTerminalResult, } from "./human.js";
+//# sourceMappingURL=index.js.map

package/dist/terminal/tree/index.d.ts

@@ -0,0 +1,2 @@
+export { TERMINAL_TREE } from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/terminal/tree/index.js

@@ -0,0 +1,2 @@
+export { TERMINAL_TREE } from "./tree.js";
+//# sourceMappingURL=index.js.map

package/dist/terminal/tree/tree.d.ts

@@ -0,0 +1,3 @@
+import type { TreeFragment } from "../../command-tree/index.js";
+export declare const TERMINAL_TREE: TreeFragment;
+//# sourceMappingURL=tree.d.ts.map

package/dist/terminal/tree/tree.js

@@ -0,0 +1,104 @@
+const terminal = () => import("../index.js");
+export const TERMINAL_TREE = {
+    groups: [
+        ["terminal", "Terminals in a Workspace."],
+        ["terminal events", "A terminal's events."],
+        ["terminal controller", "Control of a terminal."],
+        ["terminal controller request", "Requests to control a terminal."],
+        ["terminal input", "Terminal input."],
+    ],
+    leaves: [
+        [
+            "terminal create --workspace <workspace-id> [--interactive --columns <2..500> --rows <2..300>] [--command-id <id>]",
+            1,
+            "terminal.create",
+            "Create a terminal in a Workspace.",
+            { run: [terminal, "runTerminalCreate"] },
+        ],
+        [
+            "terminal list --workspace <workspace-id> [--limit <1..100>] [--after <cursor>]",
+            1,
+            "terminal.list",
+            "List a Workspace's terminals.",
+            { run: [terminal, "runTerminalList"] },
+        ],
+        [
+            "terminal show <terminal-id>",
+            1,
+            "terminal.show",
+            "Show one terminal.",
+            { run: [terminal, "runTerminalShow"] },
+        ],
+        [
+            "terminal read <terminal-id> [--limit <1..8>] [--after <chunk-cursor>]",
+            1,
+            "terminal.read",
+            "Read a terminal's output.",
+            { run: [terminal, "runTerminalRead"] },
+        ],
+        [
+            "terminal events list --terminal <terminal-id> [--limit <1..32>] [--after <terminal-cursor>]",
+            1,
+            "terminal.events.list",
+            "List a terminal's events.",
+            { run: [terminal, "runTerminalEventsList"] },
+        ],
+        [
+            "terminal controller request create --terminal <terminal-id> --terminal-generation <1..65535> --lease-ms <1000..30000> [--command-id <id>]",
+            1,
+            "terminal.controller.request",
+            "Request control of a terminal.",
+            { run: [terminal, "runControllerRequestCreate"] },
+        ],
+        [
+            "terminal controller request show <controller-request-id> --terminal <terminal-id> --terminal-generation <1..65535>",
+            1,
+            "terminal.controller.request.show",
+            "Show a terminal control request.",
+            { run: [terminal, "runControllerRequestShow"] },
+        ],
+        [
+            "terminal controller acquire <terminal-id> --request <controller-request-id> --terminal-generation <1..65535> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "terminal.controller.acquire",
+            "Acquire control of a terminal.",
+            { run: [terminal, "runControllerAcquire"] },
+        ],
+        [
+            "terminal controller release <terminal-id> --controller-id <id> --controller-epoch <epoch> --controller-revision <revision> --controller-expires-at <timestamp> --terminal-generation <1..65535> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "terminal.controller.release",
+            "Release control of a terminal.",
+            { run: [terminal, "runControllerRelease"] },
+        ],
+        [
+            "terminal input write <terminal-id> --input-stdin --input-id <id> --input-sequence <1..2147483647> --controller-id <id> --controller-epoch <epoch> --controller-revision <revision> --controller-expires-at <timestamp> --terminal-generation <1..65535> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "terminal.input.write",
+            "Write input to a terminal you control.",
+            { run: [terminal, "runTerminalInputWrite"] },
+        ],
+        [
+            "terminal resize <terminal-id> --columns <2..500> --rows <2..300> --controller-id <id> --controller-epoch <epoch> --controller-revision <revision> --controller-expires-at <timestamp> --terminal-generation <1..65535> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "terminal.session.resize",
+            "Resize a terminal you control.",
+            { run: [terminal, "runTerminalResize"] },
+        ],
+        [
+            "terminal signal <terminal-id> --signal <hangup|interrupt|terminate> --controller-id <id> --controller-epoch <epoch> --controller-revision <revision> --controller-expires-at <timestamp> --terminal-generation <1..65535> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "terminal.session.signal",
+            "Signal a terminal you control.",
+            { run: [terminal, "runTerminalSignal"] },
+        ],
+        [
+            "terminal close <terminal-id> --controller-id <id> --controller-epoch <epoch> --controller-revision <revision> --controller-expires-at <timestamp> --terminal-generation <1..65535> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "terminal.session.close",
+            "Close a terminal you control.",
+            { run: [terminal, "runTerminalClose"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

package/guidance/maia-cli/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: maia-cli
+description: >
+  Operate the public Maia CLI and first-party Pi agent. Discover
+  callable commands from classified help, inspect local control-plane state,
+  recover receipts, and run maia agent without inventing runtime adapters.
+---
+
+# Maia CLI
+
+## Goal
+
+Use the installed `maia` binary as the public client. Treat `maia help --json`
+and `maia help <family> --json` as the command allowlist.
+
+## Main rules
+
+1. Use only families and usage rows present in classified help.
+2. Treat `source_implemented_candidate` as release-disabled unless the caller
+   explicitly accepts that status.
+3. Prefer `--json` for node-facing commands. Read errors from stderr.
+4. Put prompts and large or sensitive bodies on bounded stdin where the command
+   supports it.
+5. Reuse a mutation's command ID and reconcile its receipt after an unknown
+   outcome.
+6. Use exact project, workspace, session, turn, run, task, worker, and revision
+   identifiers. Never infer authority from cwd.
+
+## Implemented foundation
+
+- `maia --json status`
+- `maia --json project register <path>`
+- `maia --json project list`
+- `maia --json project show <project-id>`
+- `maia --json workspace list --project <project-id>`
+- `maia --json workspace show <workspace-id>`
+- `maia --json workspace repository attach <path> --workspace <workspace-id> --expected-revision <revision>`
+- `maia --json receipt list`
+- `maia --json receipt show <command-id>`
+- `maia --json session create --workspace <workspace-id>`
+- `maia --json session list --project <project-id>`
+- `maia --json session show <session-id>`
+- `maia --json session events list --session <session-id>`
+- `maia agent`
+- `maia agent --print --no-session -- <prompt>`
+- `maia agent --json-events --no-session -- <prompt>`
+
+`maia agent` is the first-party official-Pi harness. It is not a selector for
+Codex, Claude, installed Pi, or `pi-rpc`. Ambient `~/.pi` resources are not
+loaded.
+
+## Do not
+
+- Do not call absent integration or runtime-discovery families.
+- Do not write provider-native configuration roots.
+- Do not treat a Pi extension as Maia operation authority.
+- Do not treat a worktree or Pi process as a sandbox.
+- Do not invent a hidden coordinator, current Session, or unbounded target.

package/guidance/maia-orchestration/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: maia-orchestration
+description: >
+  Coordinate source-candidate, release-disabled local-v1 Maia Runs through the
+  public CLI: create, list, show, task list and show, inbox check and ack,
+  questions, and dispatch show or settle-terminal. Use when an external agent
+  is the explicit Run coordinator. Do not treat these commands as
+  release-enabled, worker assignment, or Orca equivalence.
+---
+
+# Maia orchestration
+
+Every command in this Skill is a **source-implemented candidate,
+release-disabled**. Confirm the usage exists on `maia help run --json` and is
+tagged `source_implemented_candidate` before running it. Do not start a
+worker, waiter, harness, or model turn.
+
+## Identity
+
+Supply explicit ids. Do not infer a Run from the terminal, cwd, Git, or
+environment. Do not use `--scope current`, `--from`, or `--preamble`.
+
+After `run create`, keep `run.id`, `run.revision`, `dispatch.id`,
+`dispatch.revision`, both mailbox ids and revisions, and `receipt.commandId`
+from the compact CLI projection. Recover a Task objective with
+`run task show`. Recover Dispatch identity with `run dispatch show`.
+
+## Candidate commands
+
+Label every invocation as release-disabled when you describe it.
+
+- `maia --json run create --workspace <workspace-id> --terminal <terminal-id> --graph-stdin`
+- `maia --json run list --workspace <workspace-id>`
+- `maia --json run show <run-id>`
+- `maia --json run task list --run <run-id>`
+- `maia --json run task show <task-id> --run <run-id>`
+- `maia --json run inbox check --run <run-id> --owner <run|dispatch> --owner-id <id> --coordinator-epoch 1`
+- `maia --json run inbox ack <delivery-id> --run <run-id> --owner <run|dispatch> --owner-id <id> --expected-mailbox-revision <revision> --coordinator-epoch 1`
+- `maia --json run question open --run <run-id> --dispatch <dispatch-id> --subject <text> --body-stdin --expected-run-revision <revision> --expected-dispatch-revision <revision> --coordinator-epoch 1`
+- `maia --json run question reply <question-id> --run <run-id> --dispatch <dispatch-id> --answer-stdin --expected-run-revision <revision> --expected-dispatch-revision <revision> --expected-question-revision <revision> --coordinator-epoch 1`
+- `maia --json run question cancel <question-id> --run <run-id> --dispatch <dispatch-id> --expected-run-revision <revision> --expected-dispatch-revision <revision> --expected-question-revision <revision> --coordinator-epoch 1`
+- `maia --json run dispatch show --run <run-id>`
+- `maia --json run dispatch settle-terminal <dispatch-id> --run <run-id> --expected-run-revision <revision> --expected-dispatch-revision <revision> --coordinator-epoch 1`
+
+Put the Task graph, Question body, and reply answer on stdin.
+
+## Do not run
+
+Do not wait, watch, or poll an inbox. Do not assign a worker. Do not settle a
+caller-selected outcome. `settle-terminal` only records the Terminal's exact
+unavailable failure. Do not teach Skill install/sync or extra runtime probes.
+
+A compact CLI projection is not a protocol change. The SDK remains lossless.
+No Orca command is equivalent.

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@maiaos/cli",
+  "version": "0.1.0-canary.2",
+  "description": "The maia CLI and MCP server: start, drive, observe and stop swarms of Claude Code and Codex agents from a terminal, a script or another agent.",
+  "keywords": [
+    "maia",
+    "maiaos",
+    "cli",
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "ai-agents",
+    "coding-agents",
+    "multi-agent",
+    "agent-orchestration",
+    "claude-code",
+    "codex",
+    "typescript"
+  ],
+  "homepage": "https://github.com/maiaos/maiaos/tree/main/apps/cli#readme",
+  "bugs": "https://github.com/maiaos/maiaos/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maiaos/maiaos.git",
+    "directory": "apps/cli"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "maia": "./dist/bin/maia.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/bin/*.meta.json",
+    "!dist/**/*.d.ts.map",
+    "!dist/**/*.js.map",
+    "!dist/**/*.mjs.map",
+    "!dist/bin/maia.d.ts",
+    "!dist/bin/maia.d.ts.map",
+    "guidance",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "24.22.1"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "@vllnt/typescript": "2.0.0-canary.a1749e0",
+    "eslint": "9.39.5",
+    "typescript": "npm:@typescript/typescript6@6.0.2"
+  },
+  "dependencies": {
+    "@effect/platform-node-shared": "4.0.0",
+    "@maiaos/agent": "0.1.0-canary.2",
+    "@maiaos/sdk": "0.1.0-canary.2",
+    "effect": "4.0.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{force:true,recursive:true})\" && tsc --project tsconfig.build.json && node scripts/build-executable.mjs",
+    "lint": "eslint src scripts --max-warnings 0",
+    "test": "node -e \"require('node:fs').rmSync('.test-dist',{force:true,recursive:true})\" && tsc --project tsconfig.test.json && node --import ../../scripts/lib/test-environment.mjs --test --test-concurrency=2 --enable-source-maps \".test-dist/**/*.test.js\"",
+    "typecheck": "tsc --project tsconfig.json --noEmit && tsc --project scripts/tsconfig.json --noEmit"
+  }
+}