@moxxy/sdk 0.1.0

package/dist/agent.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Agent definitions — typed templates for subagent spawning. Each
+ * `AgentDef` describes a flavor of subagent (researcher, code-reviewer,
+ * summarizer, …) so plugins can register named agent kinds and the
+ * `dispatch_agent` tool can spawn them by type instead of relying on
+ * ad-hoc prompts.
+ *
+ * Why this lives in SDK (not core): the interface is the cross-package
+ * contract. Plugins import `AgentDef` from `@moxxy/sdk`, register
+ * agents via `PluginSpec.agents`, and the core's `AgentRegistry`
+ * surfaces them at runtime.
+ */
+export interface AgentDef {
+    /** Stable name; what `dispatch_agent({ agentType })` looks up. */
+    readonly name: string;
+    /** One-line user-visible summary — surfaced in the `/agents` modal. */
+    readonly description: string;
+    /**
+     * System prompt prepended to the child's first message. Use to set
+     * persona, output format, hard constraints, etc.
+     */
+    readonly systemPrompt?: string;
+    /**
+     * Mode name for the child. Defaults to `'tool-use'`. The
+     * spawner falls back to tool-use if the named strategy isn't
+     * registered (no point failing a child over a missing block).
+     */
+    readonly mode?: string;
+    /**
+     * Restrict the child to these tools by name. Omit for full
+     * inheritance from the parent's registry.
+     */
+    readonly allowedTools?: ReadonlyArray<string>;
+    /** Default model id; overrides the parent's active model. */
+    readonly model?: string;
+    /** Per-child iteration cap. Defaults to 50. */
+    readonly maxIterations?: number;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,QAAQ;IACvB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC"}

package/dist/agent.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":""}

package/dist/cache-strategy.d.ts

@@ -0,0 +1,35 @@
+import type { EventLogReader } from './log.js';
+import type { CacheHint, ProviderMessage } from './provider.js';
+/**
+ * Context handed to a CacheStrategy when it plans breakpoints for one call.
+ */
+export interface CacheStrategyContext {
+    readonly model: string;
+    /** Active model's context window, for strategies that scale behavior to it. */
+    readonly contextWindow: number;
+    readonly log: EventLogReader;
+    /**
+     * Index (into the `messages` array passed to `plan`) of the last message
+     * belonging to the stable, cacheable prefix — everything at or before it is
+     * byte-identical across the inner iterations of the current turn, so a
+     * rolling breakpoint placed here yields cache reads on every iteration.
+     * Undefined when the mode can't compute a boundary (e.g. no elision active);
+     * strategies should then fall back to a conservative breakpoint.
+     */
+    readonly stablePrefixMessageIndex?: number;
+}
+/**
+ * A swappable prompt-caching strategy. One is active per session (registered
+ * via plugins, exactly like compactors/modes). It decides *where* cache
+ * breakpoints go and returns provider-neutral {@link CacheHint}s; the provider
+ * is responsible for *how* to express them (Anthropic → `cache_control`).
+ *
+ * `plan` MUST be deterministic given identical inputs — a non-deterministic
+ * breakpoint placement shifts the cached prefix between calls and silently
+ * defeats the cache (paying 1.25x writes for 0 reads).
+ */
+export interface CacheStrategyDef {
+    readonly name: string;
+    plan(messages: ReadonlyArray<ProviderMessage>, ctx: CacheStrategyContext): ReadonlyArray<CacheHint>;
+}
+//# sourceMappingURL=cache-strategy.d.ts.map

package/dist/cache-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-strategy.d.ts","sourceRoot":"","sources":["../src/cache-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAC;CAC5C;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,IAAI,CACF,QAAQ,EAAE,aAAa,CAAC,eAAe,CAAC,EACxC,GAAG,EAAE,oBAAoB,GACxB,aAAa,CAAC,SAAS,CAAC,CAAC;CAC7B"}

package/dist/cache-strategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cache-strategy.js.map

package/dist/cache-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-strategy.js","sourceRoot":"","sources":["../src/cache-strategy.ts"],"names":[],"mappings":""}

package/dist/channel.d.ts

@@ -0,0 +1,146 @@
+import type { PermissionResolver } from './permission.js';
+import type { ClientSession } from './client-session.js';
+/**
+ * A Channel is a bidirectional surface that drives a Session: it feeds user
+ * prompts in, renders assistant chunks + tool activity out, and implements a
+ * PermissionResolver so it can interrupt tool execution to ask the user.
+ *
+ * The TUI (Ink) and Telegram are both Channels. Future Slack / Discord / HTTP
+ * channels implement this same interface so the moxxy CLI binary (or any
+ * embedded consumer) can dispatch to them uniformly.
+ *
+ * The generic `TStartOpts` is the concrete options shape a given channel
+ * accepts.
+ */
+export interface Channel<TStartOpts = unknown> {
+    /** Stable name (lowercase, single word). Used by dispatchers to look up by string. */
+    readonly name: string;
+    /** The PermissionResolver this channel installs on the session. */
+    readonly permissionResolver: PermissionResolver;
+    /**
+     * Begin running the channel. Returns a handle whose `running` promise
+     * resolves when the channel exits gracefully.
+     */
+    start(opts: TStartOpts): Promise<ChannelHandle>;
+}
+export interface ChannelHandle {
+    /**
+     * Resolves when the channel exits cleanly (user quit, SIGINT caught,
+     * upstream disconnected). Rejects on fatal error.
+     */
+    readonly running: Promise<void>;
+    /** Request graceful shutdown. Implementations should abort any in-flight work. */
+    stop(reason?: string): Promise<void>;
+}
+/** Common base shape for channel start options. */
+export interface ChannelStartOptsBase {
+    readonly model?: string;
+    readonly systemPrompt?: string;
+}
+/**
+ * Standard dependencies that a channel factory receives. Channels pick what
+ * they need from this bag. Production CLI populates all of these; tests may
+ * pass only a subset.
+ */
+export interface ChannelFactoryDeps {
+    /** Working directory for the channel (matches the Session's cwd). */
+    readonly cwd: string;
+    /** Optional encrypted-secret store (typed loosely — plugins import the concrete VaultStore type when needed). */
+    readonly vault?: unknown;
+    /** Optional structured logger. */
+    readonly logger?: {
+        debug?(msg: string, meta?: Record<string, unknown>): void;
+        info?(msg: string, meta?: Record<string, unknown>): void;
+        warn?(msg: string, meta?: Record<string, unknown>): void;
+        error?(msg: string, meta?: Record<string, unknown>): void;
+    };
+    /** Free-form per-channel overrides forwarded from the CLI invocation. */
+    readonly options?: Record<string, unknown>;
+}
+/**
+ * A registered, named factory for a Channel. Plugins contribute these via
+ * `definePlugin({ channels: [defineChannel(...)] })`. The CLI looks up by name
+ * and dispatches: `moxxy <name>` calls `def.create(deps).start({session,...})`.
+ */
+export interface ChannelDef<TStartOpts = unknown> {
+    readonly name: string;
+    readonly description: string;
+    create(deps: ChannelFactoryDeps): Channel<TStartOpts>;
+    /**
+     * Optional runtime gate. Lets a channel declare "I can only run if these
+     * preconditions are met" (e.g., Telegram needs a token in the vault; TUI
+     * needs a TTY). The dispatcher uses this to filter the visible channel list
+     * and to give the user a helpful error before construction.
+     *
+     * Default: always available.
+     */
+    isAvailable?(deps: ChannelFactoryDeps): Promise<ChannelAvailability>;
+    /**
+     * One-shot subcommands the channel exposes. Routed as
+     * `moxxy channels <name> <subcommand>` by the CLI. Use this for
+     * channel-specific maintenance commands that don't need to run the channel
+     * (e.g., Telegram's `unpair`, `status`) — or that want to nudge a start with
+     * a flag (e.g., `pair` -> start with options.pair=true).
+     */
+    readonly subcommands?: Readonly<Record<string, ChannelSubcommand>>;
+    /**
+     * Name of a subcommand to run for a bare `moxxy <name>` invocation on a TTY -
+     * e.g. an interactive setup wizard. When absent, a bare invocation just
+     * starts the channel.
+     */
+    readonly interactiveCommand?: string;
+}
+export interface ChannelAvailability {
+    readonly ok: boolean;
+    /** Human-readable explanation when ok=false. Shown by `moxxy channels list`. */
+    readonly reason?: string;
+}
+/** Positional + flag args handed to a channel subcommand by the CLI. */
+export interface ChannelCommandArgs {
+    readonly positional: ReadonlyArray<string>;
+    readonly flags: Readonly<Record<string, string | boolean | undefined>>;
+}
+/**
+ * Context handed to a channel subcommand. The CLI builds `deps` exactly like
+ * it does for `Channel.create()` so subcommands can:
+ *  - inspect `deps.vault` for one-shot ops (unpair, status)
+ *  - mutate `deps.options` and call `startChannel()` to launch the channel
+ *    with extra start opts (e.g., pair=true)
+ */
+export interface ChannelSubcommandContext {
+    readonly deps: ChannelFactoryDeps;
+    readonly args: ChannelCommandArgs;
+    /**
+     * Boot a session and run the channel by name. Returns the process exit code
+     * (0 on clean shutdown). Subcommands that want to "start with twist" call
+     * this with overrides instead of duplicating the start-loop themselves.
+     */
+    startChannel(options?: Readonly<Record<string, unknown>>): Promise<number>;
+    /**
+     * The booted session, so a subcommand can do channel-instance work like
+     * pairing.
+     */
+    readonly session: ClientSession;
+}
+export interface ChannelSubcommand {
+    readonly description: string;
+    run(ctx: ChannelSubcommandContext): Promise<number>;
+}
+/**
+ * Read-only registry of channels available in a Session. Implementation lives
+ * in @moxxy/core.
+ */
+export interface ChannelRegistry {
+    list(): ReadonlyArray<ChannelDef>;
+    get(name: string): ChannelDef | undefined;
+    has(name: string): boolean;
+    /**
+     * Returns every channel paired with its current availability. Channels
+     * without an `isAvailable` hook are treated as `{ok: true}`.
+     */
+    listWithAvailability(deps: ChannelFactoryDeps): Promise<ReadonlyArray<{
+        readonly def: ChannelDef;
+        readonly availability: ChannelAvailability;
+    }>>;
+}
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

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

package/dist/channel.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=channel.js.map

package/dist/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":""}

package/dist/client-session.d.ts

@@ -0,0 +1,83 @@
+import type { AgentDef } from './agent.js';
+import type { CommandDef } from './command.js';
+import type { ModeDef } from './mode.js';
+import type { LLMProvider, ProviderDef } from './provider.js';
+import type { RequirementCheck, MoxxyRequirement } from './requirements.js';
+import type { SessionLike, SessionLogReader } from './session-like.js';
+import type { Skill } from './skill.js';
+import type { ToolDef } from './tool.js';
+import type { Transcriber } from './transcriber.js';
+/**
+ * `ClientSession` widens {@link SessionLike} with the read-and-act registry
+ * surface a rich interactive channel (the Ink TUI) actually touches. Both the
+ * in-process `Session` (whose concrete registries are supersets of these
+ * views) and the `RemoteSession` proxy implement it, so the TUI is written
+ * once against `ClientSession` and runs unchanged either way.
+ *
+ * The views are intentionally narrow - only what the TUI calls. Methods are
+ * declared method-style (bivariant) so a concrete `Session` registry satisfies
+ * the view even where its real signature is slightly wider. On a remote
+ * client, the facades behind these views are backed by the runner's `getInfo`
+ * snapshot for reads and by RPCs for the few mutating calls; genuinely
+ * server-only capabilities (voice transcription, MCP admin) degrade rather
+ * than pretend.
+ */
+export interface ProvidersClientView {
+    getActive(): LLMProvider;
+    getActiveName(): string | null;
+    list(): ReadonlyArray<ProviderDef>;
+    setActive(name: string, config?: Record<string, unknown>): LLMProvider;
+    replace(def: ProviderDef, instance?: LLMProvider): void;
+}
+export interface ModesClientView {
+    list(): ReadonlyArray<ModeDef>;
+    getActive(): ModeDef;
+    setActive(name: string): void;
+}
+export interface ToolsClientView {
+    list(): ReadonlyArray<ToolDef>;
+    get(name: string): ToolDef | undefined;
+}
+export interface CommandsClientView {
+    get(name: string): CommandDef | undefined;
+    listForChannel(channel: string): ReadonlyArray<CommandDef>;
+}
+export interface SkillsClientView {
+    list(): ReadonlyArray<Skill>;
+}
+export interface AgentsClientView {
+    list(): ReadonlyArray<AgentDef>;
+}
+export interface TranscribersClientView {
+    getActiveName(): string | null;
+    has(name: string): boolean;
+    getActive(): Transcriber;
+    /** Active transcriber or null. Channels guard on this for audio input. */
+    tryGetActive(): Transcriber | null;
+    setActive(name: string, config?: Record<string, unknown>): Transcriber;
+}
+export interface RequirementsClientView {
+    check(requirements: ReadonlyArray<MoxxyRequirement>): RequirementCheck;
+}
+export interface PermissionsClientView {
+    addAllow(rule: {
+        readonly name: string;
+        readonly reason?: string;
+    }): Promise<void>;
+}
+export interface ClientSession extends SessionLike {
+    /** The mirror/real log, plus `clear()` for `/new`. */
+    readonly log: SessionLogReader & {
+        clear(): void;
+    };
+    readonly providers: ProvidersClientView;
+    readonly modes: ModesClientView;
+    readonly tools: ToolsClientView;
+    readonly commands: CommandsClientView;
+    readonly skills: SkillsClientView;
+    readonly agents: AgentsClientView;
+    readonly transcribers: TranscribersClientView;
+    readonly requirements: RequirementsClientView;
+    readonly permissions: PermissionsClientView;
+}
+//# sourceMappingURL=client-session.d.ts.map

package/dist/client-session.d.ts.map

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

package/dist/client-session.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client-session.js.map

package/dist/client-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-session.js","sourceRoot":"","sources":["../src/client-session.ts"],"names":[],"mappings":""}

package/dist/command.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Commands — channel-agnostic actions the user can trigger with a
+ * `/<name>` prefix. Live on the Session's CommandRegistry so every
+ * channel (TUI slash menu, Telegram bot command, future HTTP `/cmd`
+ * endpoint) reads the same set. Plugins contribute commands via
+ * `PluginSpec.commands`.
+ *
+ * Why a registry instead of channel-local switch statements:
+ * /info works the same way whether the user types it in the TUI or
+ * sends `/info` to the Telegram bot. The handler returns a typed
+ * CommandOutput; each channel decides how to render it (TUI as a
+ * systemNotice, Telegram as a chat message, HTTP as JSON).
+ */
+import type { SessionId } from './ids.js';
+export interface CommandDef {
+    /** Name without the leading `/`. */
+    readonly name: string;
+    /** One-line description shown in `/help` and channel pickers. */
+    readonly description: string;
+    /**
+     * Usage hint for the arguments, e.g. `set <name> <value>`. Interactive
+     * channels may render it as dimmed ghost text after the command name
+     * while the user is typing (autocomplete preview). Placeholders like
+     * `<name>` are illustrative — never inserted into the buffer literally.
+     */
+    readonly argumentHint?: string;
+    /** Alternative names (without leading `/`). */
+    readonly aliases?: ReadonlyArray<string>;
+    /**
+     * When set, the command only surfaces in these channels by name
+     * (e.g. `['tui']` for an overlay-style command that wouldn't make
+     * sense in Telegram). Omit for "all channels".
+     */
+    readonly channels?: ReadonlyArray<string>;
+    /** Optional short status shown by interactive channels while the command runs. */
+    readonly pendingNotice?: string;
+    /** Handler invoked by the channel. Receives raw args after the name. */
+    readonly handler: (ctx: CommandContext) => Promise<CommandOutput> | CommandOutput;
+}
+export interface CommandContext {
+    /** Channel that invoked the command — `'tui'`, `'telegram'`, etc. */
+    readonly channel: string;
+    /** Session id the command runs against. */
+    readonly sessionId: SessionId;
+    /** Raw text after the command name (`"hello"` for `/echo hello`). */
+    readonly args: string;
+    /**
+     * The active Session. Loosely typed (`unknown`) so the SDK doesn't
+     * pull in core; handlers cast to `Session` from `@moxxy/core` when
+     * they need registries. The plugin host always passes the real
+     * Session here.
+     */
+    readonly session: unknown;
+}
+/**
+ * What a command returns. Channels pick the appropriate UI for each
+ * variant. New variants are additive — channels that don't know a
+ * variant fall back to rendering its `text` field if present.
+ */
+export type CommandOutput = 
+/** Simple text response. Every channel can render this. */
+{
+    readonly kind: 'text';
+    readonly text: string;
+}
+/**
+ * Structural action that the host channel performs in its UI
+ * (`clear`/`new`/`exit`). Carries an optional message the channel
+ * may surface alongside the action.
+ */
+ | {
+    readonly kind: 'session-action';
+    readonly action: 'new' | 'clear' | 'exit';
+    readonly notice?: string;
+}
+/** No-op (handler decided nothing needs surfacing). */
+ | {
+    readonly kind: 'noop';
+}
+/**
+ * Handler errored. Channels render this distinctly (red text, etc.).
+ * Use this instead of throwing so the command pipeline never
+ * crashes the channel.
+ */
+ | {
+    readonly kind: 'error';
+    readonly message: string;
+};
+export type CommandHandlerResult = CommandOutput;
+//# sourceMappingURL=command.d.ts.map

package/dist/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../src/command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,WAAW,UAAU;IACzB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,kFAAkF;IAClF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAAC;CACnF;AAED,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2CAA2C;IAC3C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa;AACvB,2DAA2D;AACzD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAClD;;;;GAIG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AACH,uDAAuD;GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC3B;;;;GAIG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC"}

package/dist/command.js

@@ -0,0 +1,15 @@
+/**
+ * Commands — channel-agnostic actions the user can trigger with a
+ * `/<name>` prefix. Live on the Session's CommandRegistry so every
+ * channel (TUI slash menu, Telegram bot command, future HTTP `/cmd`
+ * endpoint) reads the same set. Plugins contribute commands via
+ * `PluginSpec.commands`.
+ *
+ * Why a registry instead of channel-local switch statements:
+ * /info works the same way whether the user types it in the TUI or
+ * sends `/info` to the Telegram bot. The handler returns a typed
+ * CommandOutput; each channel decides how to render it (TUI as a
+ * systemNotice, Telegram as a chat message, HTTP as JSON).
+ */
+export {};
+//# sourceMappingURL=command.js.map

package/dist/command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.js","sourceRoot":"","sources":["../src/command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/compactor-helpers.d.ts

@@ -0,0 +1,34 @@
+import type { EventLogReader } from './log.js';
+import type { ModeContext } from './mode.js';
+/**
+ * Cheap, no-network estimate of how many tokens the current event log
+ * would consume on the next provider request. Char-based (chars/4) with
+ * compaction events honored — events covered by a CompactionEvent.replacedRange
+ * count as the (much shorter) summary rather than their original bytes — and
+ * elision honored: old tool results (seq ≤ the elision high-water mark) count
+ * as their ~stub size rather than their full payload, matching what
+ * `projectMessagesFromLog` actually sends.
+ *
+ * Used by the auto-compact helper (see `runCompactionIfNeeded`) and by
+ * the TUI's context meter. For perfect accuracy callers can use the
+ * provider's `countTokens(req)`; this is the fast path that doesn't
+ * touch the network and is safe to run on every iteration.
+ */
+export declare function estimateContextTokens(log: EventLogReader): number;
+/**
+ * Auto-compaction hook every mode calls once per iteration, right
+ * before building messages for the next provider call. Reads the
+ * active model's real `contextWindow` (not a magic max-int sentinel),
+ * estimates current token use, and — if the configured compactor's
+ * `shouldCompact` returns true — runs `compact()` and emits the
+ * resulting CompactionEvent onto the log. `projectMessagesFromLog`
+ * already honors compaction events, so the next provider call sees
+ * the summarized prefix automatically.
+ *
+ * Designed to be tolerant: no compactor, no model descriptor, no
+ * contextWindow, or a compactor throw all degrade to a no-op so a
+ * compactor bug can't kill the turn. Failures emit a non-fatal
+ * `error` event for observability.
+ */
+export declare function runCompactionIfNeeded(ctx: ModeContext): Promise<void>;
+//# sourceMappingURL=compactor-helpers.d.ts.map

package/dist/compactor-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactor-helpers.d.ts","sourceRoot":"","sources":["../src/compactor-helpers.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CA8BjE;AA2BD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgE3E"}