@ap3x/cli 0.1.0

package/dist/modes/rpc.d.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import type { AgentSessionRuntime } from "../sdk";
+/**
+ * JSONL RPC mode (§10 #50). One JSON object per line in each direction. Every
+ * inbound command is validated with a zod schema BEFORE it touches the runtime;
+ * a malformed command yields a structured `error` response and never throws —
+ * this is the hardening contract. The wire shape is intentionally stable so
+ * embedders can rely on it.
+ *
+ * Inbound:  { id, command, ...payload }
+ * Outbound: { id, ok: true,  result }  |  { id, ok: false, error: { code, message } }
+ */
+/** A structured error attached to a failed response. */
+export interface RpcError {
+    code: "invalid_request" | "unknown_command" | "runtime_error";
+    message: string;
+    /** zod issue details when the failure was a validation error. */
+    details?: unknown;
+}
+/** The outbound response envelope. */
+export type RpcResponse = {
+    id: string | null;
+    ok: true;
+    result: unknown;
+} | {
+    id: string | null;
+    ok: false;
+    error: RpcError;
+};
+/** Mutable per-connection session state the loop threads through commands. */
+export interface RpcSessionState {
+    runtime: AgentSessionRuntime;
+    /** Count of prompts handled this connection (diagnostics). */
+    prompts: number;
+}
+/** The discriminated union of every recognized inbound command. */
+export declare const RpcCommandSchema: z.ZodDiscriminatedUnion<"command", [z.ZodObject<{
+    command: z.ZodLiteral<"prompt">;
+    prompt: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: "prompt";
+    prompt: string;
+    id?: string | undefined;
+}, {
+    command: "prompt";
+    prompt: string;
+    id?: string | undefined;
+}>, z.ZodObject<{
+    command: z.ZodLiteral<"model">;
+    id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: "model";
+    id?: string | undefined;
+}, {
+    command: "model";
+    id?: string | undefined;
+}>, z.ZodObject<{
+    command: z.ZodLiteral<"session">;
+    id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: "session";
+    id?: string | undefined;
+}, {
+    command: "session";
+    id?: string | undefined;
+}>, z.ZodObject<{
+    command: z.ZodLiteral<"ping">;
+    id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: "ping";
+    id?: string | undefined;
+}, {
+    command: "ping";
+    id?: string | undefined;
+}>, z.ZodObject<{
+    command: z.ZodLiteral<"shutdown">;
+    id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: "shutdown";
+    id?: string | undefined;
+}, {
+    command: "shutdown";
+    id?: string | undefined;
+}>]>;
+/** A validated inbound command. */
+export type RpcCommand = z.infer<typeof RpcCommandSchema>;
+/** Distributive `Omit` so a union member keeps its own shape after dropping a key. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/** An inbound command without its (client-assigned) request id. */
+export type RpcCommandInput = DistributiveOmit<RpcCommand, "id">;
+/** The set of recognized command names (for diagnostics / docs). */
+export declare const RPC_COMMANDS: readonly ["prompt", "model", "session", "ping", "shutdown"];
+/** A line-oriented input stream: yields one inbound line at a time. */
+export interface RpcInput {
+    lines(): AsyncIterable<string>;
+}
+/** A line-oriented output sink. */
+export interface RpcOutput {
+    write(line: string): void;
+}
+/** Frame a response object as a single JSONL line (trailing newline included). */
+export declare function frameResponse(response: RpcResponse): string;
+/** Adapt a Node Readable into an {@link RpcInput} splitting on newlines. */
+export declare function nodeRpcInput(readable: NodeJS.ReadableStream): RpcInput;
+/** Adapt a Node Writable into an {@link RpcOutput}. */
+export declare function nodeRpcOutput(writable: NodeJS.WritableStream): RpcOutput;
+/**
+ * Parse + validate one inbound line. Returns either a validated command or a
+ * structured error response — it NEVER throws on bad input. Blank lines are
+ * skipped (returns `undefined`).
+ */
+export declare function parseRpcLine(line: string): RpcCommand | RpcResponse | undefined;
+/** Options for {@link runRpcMode}. */
+export interface RpcModeOptions {
+    runtime: AgentSessionRuntime;
+    input: RpcInput;
+    output: RpcOutput;
+    signal?: AbortSignal;
+}
+/**
+ * Run the JSONL RPC loop until input ends or a `shutdown` command arrives.
+ * Returns a process exit code (0). Every line produces exactly one response
+ * line; bad input produces a structured error response without throwing.
+ */
+export declare function runRpcMode(options: RpcModeOptions): Promise<number>;
+/**
+ * The embedder/test-facing counterpart to {@link runRpcMode}: it frames and
+ * sends commands and parses responses over the same JSONL wire. It is transport
+ * agnostic — you supply how a framed line is sent and how the next response line
+ * is read.
+ */
+export declare class RpcClient {
+    private readonly transport;
+    private counter;
+    constructor(transport: {
+        send(line: string): void | Promise<void>;
+        receive(): Promise<string>;
+    });
+    private nextId;
+    /** Send a command and await its response. */
+    send(command: RpcCommandInput): Promise<RpcResponse>;
+    /** Convenience: send a `prompt` command. */
+    prompt(prompt: string): Promise<RpcResponse>;
+    /** Convenience: send a `ping` command. */
+    ping(): Promise<RpcResponse>;
+}
+export {};
+//# sourceMappingURL=rpc.d.ts.map

package/dist/modes/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/modes/rpc.ts"],"names":[],"mappings":"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"}

package/dist/sdk.d.ts

@@ -0,0 +1,95 @@
+import type { AgentBackend, AgentRunResult, Session, SessionCreateOptions, SessionForkOptions, SessionRepo } from "@ap3x/agent-core";
+import { type AgentSession, type AgentSessionOptions, type AgentSessionServices, createAgentSession } from "./agent-session";
+/**
+ * The AP3X CLI SDK surface. It re-exports the {@link AgentSession} composition
+ * and adds {@link AgentSessionRuntime}, a lifecycle wrapper that owns a session
+ * plus its backend and can swap the active session over a {@link SessionRepo}
+ * (new / switch / fork / import). The services split
+ * (createAgentSessionServices -> createAgentSessionFromServices) is the
+ * injection seam for tests + F2.
+ */
+export { AgentSession, type AgentSessionEvent, type AgentSessionListener, type AgentSessionOptions, type AgentSessionServices, createAgentSession, createAgentSessionFromServices, createAgentSessionServices, } from "./agent-session";
+/** Injectable dependencies for {@link AgentSessionRuntime}'s session lifecycle. */
+export interface AgentSessionRuntimeConfig {
+    /** The store new/switch/fork/import operate over. Defaults to a `JsonlSessionRepo`. */
+    repo?: SessionRepo;
+    /**
+     * Re-derive the services bound to a swapped session. The options factory
+     * supplies one that rebuilds a fresh backend (unless a backend was injected)
+     * seeded from the ATTACHED persisted session only — a fresh session yields an
+     * empty transcript, a resumed/forked session yields its history — never from
+     * the previous session's in-memory transcript. Used by every lifecycle swap.
+     */
+    rebuild?: (session: Session | undefined) => AgentSessionServices;
+}
+/**
+ * A lifecycle-managed runtime around an {@link AgentSession}. Holds the resolved
+ * services (so the backend can be inspected and disposed) plus a
+ * {@link SessionRepo}, and exposes repo-backed session operations. Swapping the
+ * active session re-derives the services (fresh backend in production) and
+ * rebuilds the bound {@link AgentSession}, disposing the previous one so nothing
+ * stale keeps observing the old backend. F2 instantiates one per run mode.
+ */
+export declare class AgentSessionRuntime {
+    private activeSession;
+    private services;
+    private readonly repo;
+    private readonly rebuild;
+    constructor(services: AgentSessionServices, config?: AgentSessionRuntimeConfig);
+    /** The active {@link AgentSession}. Replaced (by identity) on every swap. */
+    get session(): AgentSession;
+    /** The persistent session tree currently bound, if any. */
+    get currentSession(): Session | undefined;
+    /** The underlying backend (for capability checks / advanced wiring). */
+    get backend(): AgentBackend;
+    /** Convenience pass-through to the active session's prompt queue. */
+    prompt(prompt: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<AgentRunResult>;
+    /** Mint a fresh persisted session and make it the active session. */
+    newSession(options?: SessionCreateOptions): Session;
+    /**
+     * Open an existing session by id and make it active. Surfaces the repo's
+     * `not_found` {@link SessionError} when the id is absent.
+     */
+    switchSession(id: string): Session;
+    /**
+     * Fork the active session into a new independent id that shares history up to
+     * the fork point, then switch to it. `entryId` selects the fork point (omit to
+     * copy the whole session); `options` carries the repo's fork controls
+     * (`position`, `id`, `cwd`, `parentSessionId`).
+     */
+    fork(entryId?: string, options?: Omit<SessionForkOptions, "entryId">): Session;
+    /**
+     * Import an external session `.jsonl` file into a NEW repo session containing
+     * its entries, then switch to it. Matches pi's input shape (a filesystem path,
+     * plus an optional cwd override). The imported entries are appended to a
+     * freshly-minted session and the file is re-opened so the leaf is
+     * reconstructed exactly as a normal open would (mirrors the repo's fork copy).
+     */
+    importFromJsonl(inputPath: string, options?: {
+        cwdOverride?: string;
+    }): Session;
+    /**
+     * Rebuild the active services from the CURRENT session so the live backend
+     * re-seeds from its persisted history — e.g. after `/compact` appends a
+     * compaction boundary, the fresh backend starts from the compacted context.
+     * Surfaces `not_found` {@link SessionError} when no session is attached.
+     */
+    reseed(): Session;
+    /** Release all resources held by the active session. */
+    dispose(): void;
+    private requireCurrentSession;
+    /**
+     * Re-point the runtime at `next`: rebuild the session-bound services and
+     * dispose the previous {@link AgentSession} so it stops observing the old
+     * backend. Subsequent prompt()s run (and persist) against `next`.
+     */
+    private swap;
+}
+/** Build an {@link AgentSessionRuntime} from high-level options. */
+export declare function createAgentSessionRuntime(options?: AgentSessionOptions): AgentSessionRuntime;
+/** Build an {@link AgentSessionRuntime} from pre-resolved services. */
+export declare function createAgentSessionRuntimeFromServices(services: AgentSessionServices, config?: AgentSessionRuntimeConfig): AgentSessionRuntime;
+export { createAgentSession as createSession };
+//# sourceMappingURL=sdk.d.ts.map

package/dist/sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../src/sdk.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,OAAO,EACP,oBAAoB,EACpB,kBAAkB,EAClB,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAO1B,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,kBAAkB,EAGnB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;GAOG;AAEH,OAAO,EACL,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,kBAAkB,EAClB,8BAA8B,EAC9B,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC;AAEzB,mFAAmF;AACnF,MAAM,WAAW,yBAAyB;IACxC,uFAAuF;IACvF,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,KAAK,oBAAoB,CAAC;CAClE;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyD;gBAErE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,GAAE,yBAA8B;IAkBlF,6EAA6E;IAC7E,IAAI,OAAO,IAAI,YAAY,CAE1B;IAED,2DAA2D;IAC3D,IAAI,cAAc,IAAI,OAAO,GAAG,SAAS,CAExC;IAED,wEAAwE;IACxE,IAAI,OAAO,IAAI,YAAY,CAE1B;IAED,qEAAqE;IACrE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAIhF,qEAAqE;IACrE,UAAU,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO;IAInD;;;OAGG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIlC;;;;;OAKG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC,GAAG,OAAO;IAK9E;;;;;;OAMG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IAkB/E;;;;;OAKG;IACH,MAAM,IAAI,OAAO;IAIjB,wDAAwD;IACxD,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,qBAAqB;IAW7B;;;;OAIG;IACH,OAAO,CAAC,IAAI;CAOb;AAED,oEAAoE;AACpE,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,mBAAwB,GAAG,mBAAmB,CAUhG;AAED,uEAAuE;AACvE,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,oBAAoB,EAC9B,MAAM,GAAE,yBAA8B,GACrC,mBAAmB,CAErB;AAGD,OAAO,EAAE,kBAAkB,IAAI,aAAa,EAAE,CAAC"}

package/dist/settings.d.ts

@@ -0,0 +1,109 @@
+/** A named remote A2A peer reachable via the `call_agent` tool. */
+export interface RemoteAgentConfig {
+    /** Base URL of the remote agent's A2A server (http(s)://host:port/). */
+    url: string;
+    /** Bearer token sent on every request to this peer. */
+    bearerToken?: string;
+}
+/**
+ * The full AP3X CLI configuration surface. Every field is optional in the
+ * persisted/partial forms; {@link DEFAULT_SETTINGS} supplies a value for each so
+ * the resolved {@link Settings} is total.
+ */
+export interface Settings {
+    /** Default model id (e.g. "claude-sonnet-4-5"). */
+    model: string;
+    /** Default provider slug (e.g. "anthropic"). */
+    provider: string;
+    /** Reasoning / thinking intensity. */
+    thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    /** Hard cap on assistant turns per run. */
+    maxLoops: number;
+    /** Tool execution strategy. */
+    toolExecution: "sequential" | "parallel";
+    /**
+     * Tool allowlist. An **empty** list means "no restriction" — every built-in
+     * tool is available. A non-empty list is an explicit allowlist the user opted
+     * into (via `-t`, `AP3X_ACTIVE_TOOLS`, or settings.json) and confines the
+     * model to exactly those tools.
+     */
+    activeTools: string[];
+    /** Compact the conversation automatically when the budget is exceeded. */
+    autoCompact: boolean;
+    /** Default working directory ("" means "process cwd at launch"). */
+    cwd: string;
+    /** Custom shell path for bash; "" means auto-detect. */
+    shellPath: string;
+    /** Enforce the cross-platform destructive-command blocklist. */
+    enforceBlocklist: boolean;
+    /** Named remote A2A peers the `call_agent` tool may contact (name -> config). */
+    remoteAgents: Record<string, RemoteAgentConfig>;
+    /** Agent Card name published by `ap3x serve` ("" = the AP3X display name). */
+    a2aName: string;
+    /** Agent Card description published by `ap3x serve` ("" = a model-derived default). */
+    a2aDescription: string;
+    /** Bearer token `ap3x serve` requires from callers ("" = no auth). */
+    a2aBearerToken: string;
+}
+/** A partial settings object as persisted on disk or supplied by env/flags. */
+export type PartialSettings = Partial<Settings>;
+/** The baseline configuration used when nothing else is provided. */
+export declare const DEFAULT_SETTINGS: Settings;
+/**
+ * Validate and narrow an unknown value into a {@link PartialSettings}. Unknown
+ * keys and ill-typed values are dropped rather than throwing — a corrupt
+ * settings file degrades to defaults instead of crashing the CLI. This is the
+ * total-function equivalent of a schema parse for the persisted layer.
+ */
+export declare function parsePartialSettings(value: unknown): PartialSettings;
+/**
+ * Parse a partial settings object from the AP3X environment. Recognized vars
+ * (all `AP3X_*`): MODEL, PROVIDER, THINKING, MAX_LOOPS, TOOL_EXECUTION,
+ * ACTIVE_TOOLS (comma-separated), AUTO_COMPACT, CWD, SHELL_PATH,
+ * ENFORCE_BLOCKLIST, A2A_BEARER_TOKEN. (`remoteAgents` is a structured map —
+ * file/flag layers only.)
+ */
+export declare function settingsFromEnv(env?: NodeJS.ProcessEnv): PartialSettings;
+/**
+ * Merge partial settings with the canonical precedence: **flag > env > file >
+ * default**. Later arguments to this helper are lower priority; the layers are
+ * applied default-first so higher-priority defined keys win.
+ */
+export declare function mergeSettings(layers: {
+    flag?: PartialSettings;
+    env?: PartialSettings;
+    file?: PartialSettings;
+    defaults?: Settings;
+}): Settings;
+/**
+ * Loads, merges, and persists AP3X settings under `~/.ap3x/` (or an override).
+ * The resolved configuration always reflects precedence flag > env > file >
+ * default; only the file layer is persisted.
+ */
+export declare class SettingsManager {
+    private readonly path;
+    private readonly env;
+    private fileSettings;
+    constructor(options?: {
+        configDir?: string;
+        path?: string;
+        env?: NodeJS.ProcessEnv;
+    });
+    /** The absolute path of the backing settings file. */
+    get filePath(): string;
+    /** Load the persisted (file) layer from disk. Missing/invalid files yield {}. */
+    load(): Promise<PartialSettings>;
+    /** The currently-known file layer (call {@link load} first to populate it). */
+    get persisted(): PartialSettings;
+    /** Resolve effective settings, layering flags + env over the loaded file layer. */
+    resolve(flagSettings?: PartialSettings): Settings;
+    /**
+     * Persist a partial settings patch to the file layer, merging with existing.
+     *
+     * The write is atomic: the JSON is written to a sibling `.tmp` file and then
+     * renamed over the target, so a crash mid-write can never leave a truncated
+     * or corrupt `settings.json` — readers see either the old file or the new one.
+     */
+    save(patch: PartialSettings): Promise<PartialSettings>;
+}
+//# sourceMappingURL=settings.d.ts.map

package/dist/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAIA,mEAAmE;AACnE,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,GAAG,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,QAAQ,EAAE,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IAClE,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,aAAa,EAAE,YAAY,GAAG,UAAU,CAAC;IACzC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,0EAA0E;IAC1E,WAAW,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iFAAiF;IACjF,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAChD,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,cAAc,EAAE,MAAM,CAAC;IACvB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,+EAA+E;AAC/E,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEhD,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,EAAE,QAe9B,CAAC;AAUF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAgDpE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,eAAe,CA6CrF;AAaD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,GAAG,QAAQ,CAOX;AAED;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAoB;IACxC,OAAO,CAAC,YAAY,CAAuB;gBAE/B,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;KAAE;IAMpF,sDAAsD;IACtD,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,iFAAiF;IAC3E,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC;IAUtC,+EAA+E;IAC/E,IAAI,SAAS,IAAI,eAAe,CAE/B;IAED,mFAAmF;IACnF,OAAO,CAAC,YAAY,GAAE,eAAoB,GAAG,QAAQ;IASrD;;;;;;OAMG;IACG,IAAI,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;CAc7D"}

package/dist/skills.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CLI skills discovery + system-prompt composition.
+ *
+ * The coding agent advertises skills via progressive disclosure: a compact
+ * `<available_skills>` catalog (name / description / location) goes into the
+ * system prompt, and the model loads a skill's full body with the read tool on
+ * demand. Skills live as top-level `*.md` files under `<configDir>/skills`
+ * (see `resolveSkillsDir`); parsing/catalog formatting come from agent-core.
+ *
+ * ponytail: top-level *.md listing only — the full discovery machinery
+ * (recursive traversal, ignore files, collision diagnostics) is a later slice.
+ */
+import { type Skill } from "@ap3x/agent-core";
+/**
+ * Load every top-level `*.md` skill file in `dir` (sorted by file name for a
+ * deterministic catalog). A missing or unreadable directory yields `[]` — a
+ * host without a skills dir simply has no skills.
+ */
+export declare function loadSkillsFromDir(dir: string): Promise<Skill[]>;
+/**
+ * Compose the final system prompt: the base coding prompt plus the skills
+ * catalog in the S1 `skills` slot. When the catalog is empty (no skills, or
+ * every skill hidden via `disableModelInvocation`) the base prompt is returned
+ * UNCHANGED — byte-identical to running without the skills subsystem.
+ */
+export declare function composeSystemPromptWithSkills(basePrompt: string, skills: readonly Skill[]): string;
+//# sourceMappingURL=skills.d.ts.map

package/dist/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../src/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAEL,KAAK,KAAK,EAIX,MAAM,kBAAkB,CAAC;AAE1B;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAYrE;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,MAAM,CAOR"}

package/dist/slash-commands.d.ts

@@ -0,0 +1,79 @@
+import { AuthStorage } from "@ap3x/ai";
+import type { AnthropicLoginResult, LoginAnthropicOptions } from "./auth/anthropic-login";
+import type { LoginResult, LoginWithChatGPTOptions } from "./auth/codex-login";
+import type { CopilotLoginResult, LoginGitHubCopilotOptions } from "./auth/copilot-login";
+import type { AgentSessionRuntime } from "./sdk";
+import type { Settings, SettingsManager } from "./settings";
+/**
+ * Slash commands are TABLE-DRIVEN (§10 #52): a flat array of
+ * `{ name, description, handler }` records, looked up by name — never an
+ * if-ladder. There are deliberately NO easter-egg commands; any joke/vanity
+ * The set is a curated allowlist — see {@link SLASH_COMMANDS}. Handlers operate
+ * on an injected {@link SlashContext} so they test against a mock runtime + IO
+ * with no real terminal or network.
+ */
+/** The IO + state surface a slash handler may touch. All side-effects go here. */
+export interface SlashContext {
+    /** The live agent runtime (session, backend, model). */
+    runtime: AgentSessionRuntime;
+    /** Settings manager for `/settings`, `/model`, `/reload`. */
+    settings: SettingsManager;
+    /** The resolved settings snapshot at dispatch time. */
+    resolved: Settings;
+    /** Write a line of output (renderer-injected; no direct stdout). */
+    print: (text: string) => void;
+    /** Auth storage seam for `/login` `/logout` (inject in-memory for tests). */
+    auth?: AuthStorage;
+    /**
+     * The ChatGPT OAuth login function, injectable so `/login` is testable without
+     * real browser / network / server IO. Defaults to {@link loginWithChatGPT}.
+     */
+    loginCodex?: (options?: LoginWithChatGPTOptions) => Promise<LoginResult>;
+    /**
+     * The Anthropic (Claude Pro/Max) OAuth login function, injectable so `/login`
+     * on the anthropic provider is testable without real IO. Defaults to
+     * {@link loginAnthropic}.
+     */
+    loginAnthropic?: (options?: LoginAnthropicOptions) => Promise<AnthropicLoginResult>;
+    /**
+     * The GitHub Copilot device-code login function, injectable so `/login` on
+     * the github-copilot provider is testable without real IO. Defaults to
+     * {@link loginGitHubCopilot}.
+     */
+    loginCopilot?: (options?: LoginGitHubCopilotOptions) => Promise<CopilotLoginResult>;
+    /** A signal the mode loop reads to know it should exit (`/quit`). */
+    requestExit?: () => void;
+    /** Free-form argument string following the command name. */
+    args: string;
+}
+/** The result of dispatching a slash command. */
+export interface SlashResult {
+    /** True when a command matched and ran (false ⇒ unknown command). */
+    handled: boolean;
+    /** True when the loop should terminate after this command (`/quit`). */
+    exit?: boolean;
+    /** A short status line a caller may surface; also printed via ctx.print. */
+    message?: string;
+}
+/** One row of the slash-command table. */
+export interface SlashCommand {
+    name: string;
+    description: string;
+    handler: (ctx: SlashContext) => Promise<SlashResult> | SlashResult;
+}
+/**
+ * The canonical built-in slash-command table. Adding a command is a single new
+ * record; dispatch ({@link dispatchSlashCommand}) is a table lookup.
+ */
+export declare const BUILTIN_SLASH_COMMANDS: readonly SlashCommand[];
+/** Look up a command by bare name (no leading slash). */
+export declare function findSlashCommand(name: string): SlashCommand | undefined;
+/** True when a line is a slash command (starts with a single `/`). */
+export declare function isSlashCommand(line: string): boolean;
+/**
+ * Parse and dispatch a slash-command line (e.g. `"/model claude-sonnet-4-5"`).
+ * Unknown commands return `{ handled: false }` and print a clean error — they
+ * never throw. The leading slash is required.
+ */
+export declare function dispatchSlashCommand(line: string, ctx: Omit<SlashContext, "args">): Promise<SlashResult>;
+//# sourceMappingURL=slash-commands.d.ts.map

package/dist/slash-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-commands.d.ts","sourceRoot":"","sources":["../src/slash-commands.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAa,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAE1F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;GAOG;AAEH,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,EAAE,eAAe,CAAC;IAC1B,uDAAuD;IACvD,QAAQ,EAAE,QAAQ,CAAC;IACnB,oEAAoE;IACpE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,6EAA6E;IAC7E,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,uBAAuB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACzE;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,qBAAqB,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpF;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,yBAAyB,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACpF,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;CACd;AAED,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,0CAA0C;AAC1C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC;CACpE;AAMD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,YAAY,EA6WhD,CAAC;AAOX,yDAAyD;AACzD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEvE;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,CAatB"}

package/dist/system-prompt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The runtime environment context fed to the coding agent's system prompt. This
+ * is what makes the agent OS-aware — without it the model defaults to POSIX
+ * commands (e.g. `google-chrome`, `open`, `xdg-open`) and runs them blindly on
+ * whatever platform it is actually on.
+ */
+export interface EnvContext {
+    platform: NodeJS.Platform;
+    shell: string;
+    shellKind: "bash" | "cmd" | "sh";
+    cwd: string;
+    date: string;
+}
+/**
+ * Build the coding-agent system prompt, embedding the live runtime environment
+ * so the model issues platform-correct commands and reports outcomes honestly.
+ */
+export declare function buildCodingAgentSystemPrompt(env: EnvContext): string;
+/** Resolve the live {@link EnvContext} for the current process. */
+export declare function resolveEnvContext(shellPath?: string): Promise<EnvContext>;
+//# sourceMappingURL=system-prompt.d.ts.map

package/dist/system-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../src/system-prompt.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAuCD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAoBpE;AAED,mEAAmE;AACnE,wBAAsB,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAS/E"}

package/dist/tools/a2a.d.ts

@@ -0,0 +1,11 @@
+import { type AnyAgentTool } from "@ap3x/agent-core";
+import type { ToolContext } from "./context";
+/**
+ * `call_agent` — send a task to a remote A2A agent and return its final text.
+ * The remote is a whole primary agent (possibly an orchestrator), reached via
+ * transport negotiation (JSON-RPC preferred, then REST, then gRPC).
+ */
+export declare function createCallAgentTool(ctx: ToolContext): AnyAgentTool;
+/** The A2A tool set (currently just `call_agent`). */
+export declare function createA2aTools(ctx: ToolContext): AnyAgentTool[];
+//# sourceMappingURL=a2a.d.ts.map

package/dist/tools/a2a.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a.d.ts","sourceRoot":"","sources":["../../src/tools/a2a.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,YAAY,EAAc,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAwB7C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CA4ClE;AAED,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,EAAE,CAE/D"}

package/dist/tools/bash.d.ts

@@ -0,0 +1,4 @@
+import { type AnyAgentTool } from "@ap3x/agent-core";
+import type { ToolContext } from "./context";
+export declare function createBashTool(ctx: ToolContext): AnyAgentTool;
+//# sourceMappingURL=bash.d.ts.map

package/dist/tools/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../src/tools/bash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAuC,MAAM,kBAAkB,CAAC;AAE1F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAuB7C,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CA+C7D"}

package/dist/tools/context.d.ts

@@ -0,0 +1,42 @@
+import { type ExecutionEnv } from "@ap3x/agent-core";
+import type { Model } from "@ap3x/ai";
+import type { RemoteAgentConfig } from "../settings";
+/**
+ * The swarm backend a session exposes to the orchestration tools: the resolved
+ * session model plus the resolved provider auth. Every orchestrated sub-agent is
+ * built on THIS model + auth, so a spun-up swarm runs on the same credentials
+ * (e.g. an OAuth subscription token) the CLI itself is using.
+ */
+export interface SwarmBackend {
+    /** The session's resolved model — every sub-agent is backed by it. */
+    model: Model<string>;
+    /** Resolved provider API key / bearer (forwarded to each sub-agent). */
+    apiKey?: string;
+    /** Resolved provider headers (e.g. an account-id header). */
+    headers?: Record<string, string>;
+}
+/**
+ * Ambient services a built-in tool needs to run: a filesystem + shell
+ * {@link ExecutionEnv}, plus an optional {@link SwarmBackend} for the
+ * orchestration tools. Factored out so tests can inject an in-memory or
+ * blocklist-disabled environment (and a faux-model swarm backend) without
+ * touching the real disk/shell or making network calls.
+ */
+export interface ToolContext {
+    env: ExecutionEnv;
+    /** Present when the session can orchestrate swarms (has a model + auth). */
+    swarm?: SwarmBackend;
+    /** Named remote A2A peers the `call_agent` tool may contact (settings allowlist). */
+    remoteAgents?: Record<string, RemoteAgentConfig>;
+}
+/** Build a default {@link ToolContext} backed by the real Node environment. */
+export declare function createToolContext(options?: {
+    cwd?: string;
+    shellPath?: string;
+    enforceBlocklist?: boolean;
+    /** Opt-in: confine `write`/`edit`/append to the workspace root (default off). */
+    restrictWritesToWorkspace?: boolean;
+    swarm?: SwarmBackend;
+    remoteAgents?: Record<string, RemoteAgentConfig>;
+}): ToolContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/tools/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/tools/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,YAAY,CAAC;IAClB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,qFAAqF;IACrF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CAClD;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iFAAiF;IACjF,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CAClD,GAAG,WAAW,CAWd"}

package/dist/tools/edit.d.ts

@@ -0,0 +1,16 @@
+import { type AnyAgentTool } from "@ap3x/agent-core";
+import type { ToolContext } from "./context";
+/**
+ * `edit` — exact string replacement within a file. `oldText` must occur exactly
+ * once unless `replaceAll` is set. Pass `edits` to apply several replacements
+ * atomically (in order, against one read, one write — all succeed or none are
+ * written). This is a mutating tool: serialize it with
+ * {@link withFileMutationQueue}.
+ *
+ * Matching is line-ending agnostic: a leading BOM and CRLF/CR line endings are
+ * normalized to LF for matching and restored on write, so an LF `oldText`
+ * matches a Windows CRLF (or BOM-prefixed) file. Replacements are spliced
+ * literally — `$&`, `$1`, `$$` etc. in `newText` are inserted verbatim.
+ */
+export declare function createEditTool(ctx: ToolContext): AnyAgentTool;
+//# sourceMappingURL=edit.d.ts.map

package/dist/tools/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../src/tools/edit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAc,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAoC7C;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CA4G7D"}

package/dist/tools/find.d.ts

@@ -0,0 +1,9 @@
+import { type AnyAgentTool } from "@ap3x/agent-core";
+import type { ToolContext } from "./context";
+/**
+ * `find` — locate files by glob pattern beneath a root directory. Traversal
+ * skips VCS/build dirs and is bounded. Matching uses a small in-house glob
+ * matcher (no external deps).
+ */
+export declare function createFindTool(ctx: ToolContext): AnyAgentTool;
+//# sourceMappingURL=find.d.ts.map

package/dist/tools/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../src/tools/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAc,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CA2C7D"}

package/dist/tools/grep.d.ts

@@ -0,0 +1,9 @@
+import { type AnyAgentTool } from "@ap3x/agent-core";
+import type { ToolContext } from "./context";
+/**
+ * `grep` — search file contents for a regular expression beneath a directory.
+ * Implemented in-process (no shelling out) so it is deterministic and testable.
+ * Returns `path:lineNumber:matchedLine` rows.
+ */
+export declare function createGrepTool(ctx: ToolContext): AnyAgentTool;
+//# sourceMappingURL=grep.d.ts.map

package/dist/tools/grep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../src/tools/grep.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAc,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CAwE7D"}