indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/capability-deck/builtin-bridge.d.ts

@@ -1,114 +0,0 @@
-/**
- * Built-in capability bridge — ONE seam to the framework's native tools.
- *
- * The framework (`indusagi/agent`, the `actions` surface) already authors its
- * file, search, shell, web, process, and checklist tools as fully-formed
- * `AgentTool` objects and ships a `create<Name>Tool(cwd, options)` factory for
- * each. This module is the single place the deck reaches across that seam: it
- * pairs every native factory with a deck {@link CapabilityCard.build} closure so
- * the whole framework tool set is re-exposed as {@link Capability} rows in one
- * file rather than in a dozen one-line re-export stubs.
- *
- * What this buys the rest of the deck:
- *   - {@link BUILTIN_BRIDGE} — a single record keyed by the wire-facing tool
- *     name, each value a {@link BridgeBuilder} that mints the live capability for
- *     a {@link DeckContext}. The manifest derives its catalog rows from this
- *     record; nothing else hand-maintains a parallel list of built-ins.
- *   - {@link buildBuiltin} — resolve-and-build one built-in by id, surfacing a
- *     typed {@link DeckFault} on an unknown id or a builder throw.
- *   - {@link BUILTIN_PROFILES} — the per-built-in profile membership the
- *     data-driven provisioner intersects with a requested {@link DeckProfile},
- *     so the survey (observe-only) set falls out of one table instead of a
- *     second hand-written tool list.
- *
- * Design notes:
- *   - The builders thread `ctx.cwd` (and, where a factory takes them, the
- *     framework option bags) into the native factory. They never reimplement the
- *     tool — the framework owns the read/edit/grep/bash/etc. behavior; the bridge
- *     only *binds* it to a working context and re-labels it for the catalog.
- *   - The process and checklist tools are stateful framework singletons exposed
- *     through their factories; the bridge keeps them framework-backed (wrapping
- *     the framework, not any third-party package) while presenting them as plain
- *     capabilities to the deck.
- *   - All model-facing tool `name` strings are the framework's own wire contract
- *     (`read`, `bash`, `grep`, …) and are kept verbatim — the model's prompt and
- *     the conductor key off them. Only the deck-side titles/summaries are the
- *     deck's own prose.
- */
-import { type AnyCapability, type Capability, type CapabilityId, type CardProfiles, type DeckContext } from "./contract";
-/**
- * A closure that mints one framework built-in {@link Capability} for a working
- * context. The deck's view of a native factory after the bridge has bound the
- * `cwd` (and any option bag) the factory needs.
- *
- * Returns `AnyCapability` because the heterogeneous built-ins carry different
- * parameter schemas; a typed `AgentTool<TSchema>` widens to this element type,
- * which is exactly what the deck and the conductor consume.
- */
-export type BridgeBuilder = (ctx: DeckContext) => AnyCapability;
-/**
- * One descriptor in the built-in catalog: the wire-facing id, the deck-side
- * title/summary prose, the profiles the tool participates in, and the
- * {@link BridgeBuilder} that binds the framework factory to a context.
- *
- * The manifest turns each of these into a {@link CapabilityCard}; consumers that
- * want the raw built-in set read {@link BUILTIN_BRIDGE} directly.
- */
-export interface BuiltinDescriptor {
-    /** Wire-facing tool name the model invokes (framework contract, verbatim). */
-    readonly id: CapabilityId;
-    /** Short human-facing title for catalogs and help text. */
-    readonly title: string;
-    /** One-line description in the deck's own voice. */
-    readonly summary: string;
-    /** Which deck profiles this built-in belongs to. */
-    readonly profiles: CardProfiles;
-    /** Bind the framework factory to a working context. */
-    readonly build: BridgeBuilder;
-}
-/**
- * The framework built-ins keyed by their wire-facing {@link CapabilityId} — the
- * single record the manifest and provisioner read from.
- *
- * Derived from {@link BUILTIN_DESCRIPTORS}, so the keyed view and the ordered
- * list never drift: there is exactly one place a built-in is declared.
- */
-export declare const BUILTIN_BRIDGE: Readonly<Record<string, BuiltinDescriptor>>;
-/**
- * The wire-facing ids of every framework built-in, in catalog order. Convenient
- * for `--tools` style selection and for the manifest's projection.
- */
-export declare const BUILTIN_IDS: readonly CapabilityId[];
-/**
- * The profile membership of every built-in, keyed by id — the slice of the
- * profile table the data-driven provisioner reads to decide which built-ins a
- * requested {@link DeckProfile} includes.
- */
-export declare const BUILTIN_PROFILES: Readonly<Record<string, CardProfiles>>;
-/**
- * The ordered list of built-in descriptors — the manifest projects its catalog
- * rows from this, preserving order.
- */
-export declare function builtinDescriptors(): readonly BuiltinDescriptor[];
-/**
- * Resolve a built-in by id and build its live capability for a context.
- *
- * Throws a typed {@link DeckFault}: `unknown_capability` when the id is not a
- * framework built-in, or `build_failed` when the framework factory throws. This
- * is the sanctioned entry point so failure shaping stays uniform across the deck.
- *
- * @param id   the wire-facing built-in name to build
- * @param ctx  the working context to bind the factory to
- */
-export declare function buildBuiltin(id: CapabilityId, ctx: DeckContext): Capability;
-/**
- * Build every framework built-in eligible for a profile, bound to a context.
- *
- * Walks the bridge table once, keeps each built-in whose profile membership
- * admits the requested profile (`all` admits everything), and binds it. A single
- * data-driven pass replaces a trio of per-profile build functions.
- *
- * @param profile the requested deck profile
- * @param ctx     the working context to bind each factory to
- */
-export declare function buildBuiltinsForProfile(profile: "authoring" | "survey" | "all", ctx: DeckContext): AnyCapability[];

package/dist/types/capability-deck/capability-deck.test.d.ts

@@ -1,18 +0,0 @@
-/**
- * Capability-deck — Phase 4 behavioral tests (no network, no real MCP server).
- *
- * Three concerns, exercised purely:
- *   1. {@link provisionDeck} — the data-driven profile assembler: `authoring`
- *      yields the read-only built-in subset, `all` additionally pulls in the
- *      app-novel cards, and `box()` hands back an `AgentTool[]` shaped exactly
- *      the way the conductor's `options.tools` expects.
- *   2. The {@link BridgeLedger} — event-sourced MCP enrollment: enroll is an
- *      idempotent upsert, retire is a splice, and every transition yields a new
- *      immutable snapshot rather than mutating the prior ledger.
- *   3. The novel cards — the checklist round-trips set/read, and the
- *      background-process card starts/polls/stops a real short-lived sleeper.
- *
- * Everything here binds to a temp/echo context; nothing reaches the network and
- * no real MCP server is mounted (the ledger is fed synthetic capabilities).
- */
-export {};

package/dist/types/capability-deck/cards/bg-process-card.d.ts

@@ -1,99 +0,0 @@
-/**
- * Background-process capability — start, poll, and stop long-lived child
- * processes that outlive a single tool call.
- *
- * App-novel and framework-agnostic: it wraps Node's `child_process.spawn`
- * directly rather than delegating to any framework process controller, so the
- * lifecycle is owned entirely by this card. A long-running command (a dev
- * server, a watcher, a build in `--watch` mode) is launched detached from the
- * tool turn; the agent later polls its captured output or signals it to stop.
- *
- * One tool folds the lifecycle into an `action` discriminant:
- *   - `start` — spawn `command` in a shell, return the assigned handle id.
- *   - `poll`  — return the buffered stdout/stderr (and live/exited status) for a
- *               handle, optionally only the lines appended since the last poll.
- *   - `stop`  — send SIGTERM (escalating to SIGKILL after a grace window) to a
- *               handle's process tree.
- *   - `list`  — enumerate every handle this capability is tracking.
- *
- * Output is captured into bounded ring buffers so a chatty process cannot grow
- * memory without limit; only the most recent lines are retained. The card
- * produces a {@link Capability} (framework `AgentTool`) the conductor consumes.
- */
-import { type ChildProcess } from "node:child_process";
-import { type Static } from "@sinclair/typebox";
-import type { Capability, CapabilityCard, DeckContext } from "../contract";
-/** Coarse lifecycle state of a tracked background process. */
-export type DaemonState = "running" | "exited" | "signalled";
-/** A bounded buffer of recent output lines for one stream. */
-interface RingBuffer {
-    lines: string[];
-    /** Index of the next unread line for incremental polling. */
-    cursor: number;
-}
-/** One tracked background process and its captured state. */
-interface DaemonHandle {
-    readonly id: string;
-    readonly command: string;
-    readonly child: ChildProcess;
-    state: DaemonState;
-    exitCode: number | null;
-    signal: NodeJS.Signals | null;
-    readonly startedAt: number;
-    readonly stdout: RingBuffer;
-    readonly stderr: RingBuffer;
-}
-/**
- * An in-process table of background children, owned by one built capability.
- *
- * Each `start` spawns a shell-wrapped child, wires its stdout/stderr into
- * bounded buffers, and records terminal state on `exit`. `stop` escalates from
- * SIGTERM to SIGKILL if the process does not exit within a grace window. The
- * table is per-capability, so one session's daemons are isolated from another's.
- */
-export declare class DaemonTable {
-    private readonly handles;
-    private nextSeq;
-    private readonly cwd;
-    constructor(cwd: string);
-    start(command: string): DaemonHandle;
-    get(id: string): DaemonHandle | undefined;
-    list(): DaemonHandle[];
-    /**
-     * Signal a handle's process to terminate. Sends SIGTERM immediately and a
-     * SIGKILL after `graceMs` if the child is still alive. Resolves once the
-     * child has exited or the kill has been sent.
-     */
-    stop(handle: DaemonHandle, graceMs?: number): Promise<void>;
-}
-declare const DaemonParams: import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"start">, import("@sinclair/typebox").TLiteral<"poll">, import("@sinclair/typebox").TLiteral<"stop">, import("@sinclair/typebox").TLiteral<"list">]>;
-    command: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    sinceLast: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-}>;
-/** Statically-inferred parameter type the capability's `execute` receives. */
-export type DaemonParamsType = Static<typeof DaemonParams>;
-/** Structured detail returned alongside the model-facing content. */
-export interface DaemonDetails {
-    readonly action: "start" | "poll" | "stop" | "list";
-    readonly ok: boolean;
-    readonly id?: string;
-    readonly state?: DaemonState;
-    readonly exitCode?: number | null;
-    readonly processes?: ReadonlyArray<{
-        readonly id: string;
-        readonly command: string;
-        readonly state: DaemonState;
-    }>;
-}
-/**
- * Build the background-process capability, binding it to a fresh per-session
- * {@link DaemonTable} scoped to the context's working directory.
- *
- * @param ctx the deck context — its `cwd` is where launched processes run.
- */
-export declare function buildDaemonCapability(ctx: DeckContext): Capability<typeof DaemonParams, DaemonDetails>;
-/** Catalog row for the background-process capability. */
-export declare const daemonCard: CapabilityCard;
-export {};

package/dist/types/capability-deck/cards/index.d.ts

@@ -1,37 +0,0 @@
-/**
- * Capability cards — the app-novel capabilities the deck builds in-house.
- *
- * Each card is a {@link CapabilityCard}: metadata plus a `build(ctx)` factory
- * that mints a live {@link Capability} (the framework `AgentTool` shape) for a
- * working context. These are written fresh against the framework contract — not
- * derived from any prior tooling layer — and stay framework-agnostic where the
- * behavior is original (todo and bg-process wrap only Node + the deck contract).
- *
- * The connector and memory cards expose a thin, clearly-typed adapter seam over
- * a framework handle injected through {@link DeckContext.framework}; when no
- * handle is wired they degrade to a typed stub so every card builds and runs in
- * any environment, including tests.
- *
- * {@link APP_NOVEL_CARDS} is the contribution this module makes to the catalog;
- * the manifest module composes it with the builtin-bridge cards (the framework's
- * file/shell/search/web tools) to form the single `CAPABILITY_CARDS` source of
- * truth from which the deck's index and profiles are derived.
- */
-import type { CapabilityCard } from "../contract";
-export { todoCard, buildTodoCapability, TodoLedger, type TodoItem, type TodoState, type TodoWeight, type TodoParamsType, type TodoDetails, } from "./todo-card";
-export { daemonCard, buildDaemonCapability, DaemonTable, type DaemonState, type DaemonParamsType, type DaemonDetails, } from "./bg-process-card";
-export { taskCard, buildTaskCapability, DELEGATE_HANDLE_KEY, type DelegateRunner, type DelegateRequest, type DelegateResult, type TaskParamsType, type TaskDetails, } from "./task-card";
-export { workflowCard, buildWorkflowCapability, WORKFLOW_HANDLE_KEY, type WorkflowParamsType, type WorkflowDetails, } from "./workflow-card";
-export { saasCard, buildSaasCapability, SAAS_GATEWAY_KEY, type SaasGatewayPort, type RemoteToolSummary, type RemoteExecution, type SaasParamsType, type SaasDetails, } from "./saas-card";
-export { memoryCard, buildMemoryCapability, InMemoryStore, MEMORY_HANDLE_KEY, type MemoryStore, type MemoryParamsType, type MemoryDetails, } from "./memory-card";
-export { enterPlanModeCard, exitPlanModeCard, buildEnterPlanModeCapability, buildExitPlanModeCapability, PLAN_HANDLE_KEY, type PlanController, type EnterPlanParamsType, type EnterPlanDetails, type ExitPlanParamsType, type ExitPlanDetails, } from "./plan-tools";
-export { planSlug, planFilePath, writePlan, readPlan, PLANS_DIRNAME } from "./plan-file";
-/**
- * The app-novel cards, in catalog order. The manifest module concatenates these
- * with the builtin-bridge cards to build the full `CAPABILITY_CARDS` array.
- *
- * The plan-mode tools live here (the broadest `all` profile only): plan mode is a
- * gate over mutating work, so the tools are only meaningful in a full-access deck —
- * never the read-only `authoring` subset.
- */
-export declare const APP_NOVEL_CARDS: readonly CapabilityCard[];

package/dist/types/capability-deck/cards/memory-card.d.ts

@@ -1,68 +0,0 @@
-/**
- * Working-memory capability — read and update a persistent scratch note the
- * agent carries across turns.
- *
- * Status: minimal in-memory implementation + clearly-typed seam for the
- * framework memory subsystem.
- *
- * This card ships a self-contained, framework-agnostic default: a single mutable
- * text buffer the agent overwrites or appends to, scoped to one built capability
- * (one session). A host that wants persistence injects a durable store under
- * {@link MEMORY_HANDLE_KEY} via {@link DeckContext.framework} — the boot layer's
- * `DiskMemoryStore` (`boot/runners/memdir.ts`) does exactly this, persisting the
- * note to a per-cwd `MEMORY.md` so it survives across sessions. The
- * {@link Capability} surface and the tool's wire contract do not change either
- * way; {@link readStore} validates the injected store's three methods and falls
- * back to {@link InMemoryStore} when none is wired.
- *
- * The single tool keys behavior on an `action` discriminant:
- *   - `read`    — return the current working-memory note.
- *   - `replace` — overwrite the note with the supplied `content`.
- *   - `append`  — add a line to the end of the note.
- */
-import { type Static } from "@sinclair/typebox";
-import type { Capability, CapabilityCard, DeckContext } from "../contract";
-/** Key under which a host may wire a framework-backed memory store in later. */
-export declare const MEMORY_HANDLE_KEY: "memoryStore";
-/**
- * The narrow port the memory capability binds to.
- *
- * The in-memory default below satisfies it; a future framework-backed store can
- * be adapted to the same three methods and injected through the context.
- */
-export interface MemoryStore {
-    read(): string;
-    replace(content: string): void;
-    append(line: string): void;
-}
-/** A trivial in-process working-memory buffer, one per built capability. */
-export declare class InMemoryStore implements MemoryStore {
-    private buffer;
-    read(): string;
-    replace(content: string): void;
-    append(line: string): void;
-}
-declare const MemoryParams: import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"read">, import("@sinclair/typebox").TLiteral<"replace">, import("@sinclair/typebox").TLiteral<"append">]>;
-    content: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/** Statically-inferred parameter type the capability's `execute` receives. */
-export type MemoryParamsType = Static<typeof MemoryParams>;
-/** Structured detail returned alongside the model-facing content. */
-export interface MemoryDetails {
-    readonly action: "read" | "replace" | "append";
-    readonly ok: boolean;
-    /** Length of the note after the call, for quick status. */
-    readonly length: number;
-}
-/**
- * Build the working-memory capability, binding it to an injected store when one
- * is wired into the context, or a fresh in-memory store otherwise.
- *
- * @param ctx the deck context; an optional store is read from
- *            `ctx.framework[MEMORY_HANDLE_KEY]`.
- */
-export declare function buildMemoryCapability(ctx: DeckContext): Capability<typeof MemoryParams, MemoryDetails>;
-/** Catalog row for the working-memory capability. */
-export declare const memoryCard: CapabilityCard;
-export {};

package/dist/types/capability-deck/cards/plan-file.d.ts

@@ -1,56 +0,0 @@
-/**
- * Plan-file persistence — write and read the approved plan a plan-mode session
- * produces, as a slug-named markdown file under a per-session plans directory.
- *
- * Plan mode is a read-only "research first, act second" stance: the agent
- * explores under {@link EnterPlanMode}, drafts a plan, and proposes leaving plan
- * mode with {@link ExitPlanMode}. When the user approves the exit, the plan text
- * the model authored is durable — saved here so it survives the session and can
- * be reviewed, diffed, or fed back later. The conductor owns the approval
- * handshake; this module owns only the bytes-on-disk concern.
- *
- * The filename is derived from a stable slug of the plan's first line (its de
- * facto title), prefixed with a short timestamp so successive plans in one
- * session never collide. Writing is best-effort from the caller's perspective —
- * a write failure surfaces as a thrown error the conductor swallows into a
- * non-fatal note rather than faulting the turn.
- */
-/** The directory plans are written under (relative to the session scope dir). */
-export declare const PLANS_DIRNAME: "plans";
-/**
- * Derive a filesystem-safe slug from a plan's text — its first non-empty line,
- * lower-cased, with every run of non-alphanumeric characters collapsed to a
- * single dash and the result trimmed and length-capped. Falls back to `"plan"`
- * when the text yields nothing usable (empty, or punctuation-only).
- *
- * @param plan the plan body whose first line seeds the slug
- */
-export declare function planSlug(plan: string): string;
-/**
- * Resolve the absolute path a plan with `slug` is written to under `sessionDir`.
- * The `plans/` sub-directory is implied; callers pass the session scope dir and
- * get back `<sessionDir>/plans/<slug>.md`.
- *
- * @param sessionDir the per-session directory plans live beneath
- * @param slug       the derived slug (see {@link planSlug})
- */
-export declare function planFilePath(sessionDir: string, slug: string): string;
-/**
- * Write the plan body to a slug-named markdown file under `sessionDir/plans`,
- * creating the directory as needed, and return the absolute path written. The
- * filename is `<short-timestamp>-<slug>.md` so repeated plans in one session do
- * not overwrite each other.
- *
- * Throws on an I/O failure (the conductor swallows it into a non-fatal note).
- *
- * @param sessionDir the per-session directory plans live beneath
- * @param plan       the plan body to persist
- */
-export declare function writePlan(sessionDir: string, plan: string): string;
-/**
- * Read a previously-written plan file back, or `undefined` when it is missing or
- * unreadable. Used by tests and by any review surface that wants the saved plan.
- *
- * @param path the absolute plan-file path (see {@link planFilePath} / {@link writePlan})
- */
-export declare function readPlan(path: string): string | undefined;

package/dist/types/capability-deck/cards/plan-tools.d.ts

@@ -1,97 +0,0 @@
-/**
- * Plan-mode capabilities — the two tools that bracket a read-only planning phase.
- *
- *   - {@link enterPlanModeTool} (`enter_plan_mode`) is a **read-only** tool: when
- *     invoked it returns a structured detail `{ enterPlanMode: true }` plus
- *     explore-only prose. It carries no side effect of its own — the **conductor**
- *     watches the tool-result seam for `enterPlanMode` and switches the session
- *     into the `plan` permission mode (research-only — every mutating tool is
- *     blocked at the permission gate), capturing the pre-plan mode so it can be
- *     restored on exit. It is marked `readOnly: true` so it is itself always
- *     permitted, even inside plan mode.
- *
- *   - {@link exitPlanModeTool} (`exit_plan_mode`) likewise does NOT flip the mode
- *     itself — a tool cannot drive the interactive approval dialog. It returns a
- *     structured detail `{ exitPlan: true, plan }` that the conductor intercepts:
- *     the conductor raises the user-approval prompt, and on approval restores the
- *     pre-plan mode + injects the approved plan as context for the next turn,
- *     persisting it to a plan file. On reject the session stays in plan mode.
- *
- * Keeping every side effect (mode flip, approval, persistence) in the conductor
- * rather than the tool keeps the tools pure, side-effect-light, and assemblable in
- * any environment, including tests — and lets the conductor own the single
- * permission-mode source of truth.
- */
-import { type Static } from "@sinclair/typebox";
-import type { Capability, CapabilityCard, DeckContext } from "../contract";
-/**
- * Reserved key under which a host MAY wire a plan-mode controller into the deck
- * context. The conductor-driven design intercepts the plan tools' result details
- * directly (no handle required), so this is exported only for forward-compat /
- * an alternate host that wants the tool to drive the flip itself.
- */
-export declare const PLAN_HANDLE_KEY: "planController";
-/**
- * The narrow port a host may wire to flip the live session into plan mode. Unused
- * by the default (conductor-intercept) wiring; kept for hosts that prefer the tool
- * to signal directly rather than via the tool-result seam.
- */
-export interface PlanController {
-    /** Switch the session into read-only plan mode for subsequent tool calls. */
-    enterPlanMode(): void;
-}
-declare const EnterPlanParams: import("@sinclair/typebox").TObject<{}>;
-/** Statically-inferred parameter type EnterPlanMode's `execute` receives. */
-export type EnterPlanParamsType = Static<typeof EnterPlanParams>;
-/** Structured detail returned by EnterPlanMode. */
-export interface EnterPlanDetails {
-    /**
-     * The marker the conductor intercepts on the tool-result seam to switch the
-     * session into plan mode (and capture the pre-plan mode for a later restore).
-     */
-    readonly enterPlanMode: true;
-    /** Whether an optional in-context controller also applied the switch directly. */
-    readonly applied: boolean;
-}
-/**
- * Build the EnterPlanMode capability. On invoke it asks the wired
- * {@link PlanController} to switch the session into plan mode, then returns
- * explore-only prose. It is `readOnly: true`, so the permission gate always
- * permits it (including inside plan mode itself).
- *
- * @param ctx the deck context; an optional controller is read from
- *            `ctx.framework[PLAN_HANDLE_KEY]`.
- */
-export declare function buildEnterPlanModeCapability(ctx: DeckContext): Capability<typeof EnterPlanParams, EnterPlanDetails>;
-declare const ExitPlanParams: import("@sinclair/typebox").TObject<{
-    plan: import("@sinclair/typebox").TString;
-}>;
-/** Statically-inferred parameter type ExitPlanMode's `execute` receives. */
-export type ExitPlanParamsType = Static<typeof ExitPlanParams>;
-/**
- * Structured detail returned by ExitPlanMode. The conductor watches the
- * tool-result seam for `exitPlan === true`, captures the {@link plan}, and runs
- * the approval handshake (the tool itself does not flip the mode or prompt).
- */
-export interface ExitPlanDetails {
-    /** The marker the conductor intercepts to start the exit-plan handshake. */
-    readonly exitPlan: true;
-    /** The plan text the model authored, surfaced to the user for approval. */
-    readonly plan: string;
-}
-/**
- * Build the ExitPlanMode capability. It performs no mode flip and no prompt of
- * its own — it returns the `{ exitPlan: true, plan }` detail the conductor
- * intercepts. The model-facing content echoes the proposed plan so a transcript
- * reader sees what was put up for approval.
- *
- * Not marked read-only: it represents the request to RESUME mutating work, so in
- * plan mode it must still be permitted explicitly (the gate special-cases the
- * plan tools alongside read-only tools — see the conductor wiring).
- */
-export declare function buildExitPlanModeCapability(_ctx: DeckContext): Capability<typeof ExitPlanParams, ExitPlanDetails>;
-/** Catalog row for the EnterPlanMode capability. */
-export declare const enterPlanModeCard: CapabilityCard;
-/** Catalog row for the ExitPlanMode capability. */
-export declare const exitPlanModeCard: CapabilityCard;
-export {};

package/dist/types/capability-deck/cards/plan-tools.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * Plan-mode cards + plan-file helpers — focused unit tests.
- *
- * The cards are pure capability builders: EnterPlanMode is read-only and returns
- * the `{ enterPlanMode: true }` marker the conductor intercepts; ExitPlanMode
- * returns the `{ exitPlan: true, plan }` detail the conductor's handshake reads.
- * The plan-file helpers slug a title and round-trip the bytes on disk.
- */
-export {};

package/dist/types/capability-deck/cards/saas-card.d.ts

@@ -1,78 +0,0 @@
-/**
- * SaaS-action capability — a thin wrapper over the framework's connector gateway
- * (Composio-style remote tool execution).
- *
- * The heavy lifting (authenticating to a vendor, resolving toolkit scopes,
- * executing a remote tool slug) lives in the framework's `connectors-saas`
- * layer. This card does NOT re-implement any of it; it adapts an injected
- * gateway handle to the deck's {@link Capability} shape so the agent can invoke
- * remote SaaS actions by slug. When no gateway is wired into the context the card
- * still builds and returns a typed stub, so the deck assembles in every
- * environment.
- *
- * The single tool keys behavior on an `action` discriminant:
- *   - `discover` — list executable remote tool slugs (optionally filtered).
- *   - `execute`  — run one remote tool slug with arguments.
- *
- * Vendor-defined identifiers (uppercase tool slugs like `GITHUB_CREATE_ISSUE`)
- * are passed through verbatim — they are part of the connector's wire contract.
- */
-import { type Static } from "@sinclair/typebox";
-import type { Capability, CapabilityCard, DeckContext } from "../contract";
-/** Key under which a host wires a live SaaS gateway into the deck context. */
-export declare const SAAS_GATEWAY_KEY: "saasGateway";
-/** One executable remote tool advertised by the connector. */
-export interface RemoteToolSummary {
-    /** Vendor-defined slug, passed through verbatim (e.g. `GITHUB_CREATE_ISSUE`). */
-    readonly slug: string;
-    /** Human-readable description from the connector, if any. */
-    readonly description?: string;
-}
-/** The outcome of executing one remote tool slug. */
-export interface RemoteExecution {
-    readonly ok: boolean;
-    /** Connector payload, surfaced to the model as serialized text. */
-    readonly data: unknown;
-}
-/**
- * The slice of a framework SaaS gateway this card adapts.
- *
- * Deliberately narrow — the deck only needs to list and execute remote tools.
- * The framework's full gateway (connection lifecycle, scope planning, status
- * reporting) is a superset; a host adapts it to this shape when wiring it in.
- */
-export interface SaasGatewayPort {
-    /** List executable remote tools, optionally filtered by toolkit or query. */
-    discover(filter?: {
-        toolkits?: string[];
-        query?: string;
-    }): Promise<RemoteToolSummary[]>;
-    /** Execute one remote tool slug with arguments. */
-    execute(slug: string, args: Record<string, unknown>): Promise<RemoteExecution>;
-}
-declare const SaasParams: import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"discover">, import("@sinclair/typebox").TLiteral<"execute">]>;
-    slug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
-    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/** Statically-inferred parameter type the capability's `execute` receives. */
-export type SaasParamsType = Static<typeof SaasParams>;
-/** Structured detail returned alongside the model-facing content. */
-export interface SaasDetails {
-    readonly action: "discover" | "execute";
-    readonly ok: boolean;
-    readonly slug?: string;
-    readonly count?: number;
-}
-/**
- * Build the SaaS-action capability, adapting an injected gateway when present.
- *
- * @param ctx the deck context; an optional gateway is read from
- *            `ctx.framework[SAAS_GATEWAY_KEY]`.
- */
-export declare function buildSaasCapability(ctx: DeckContext): Capability<typeof SaasParams, SaasDetails>;
-/** Catalog row for the SaaS-action capability. */
-export declare const saasCard: CapabilityCard;
-export {};