indusagi-coding-agent 0.1.59 → 0.1.61

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

@@ -0,0 +1,317 @@
+/**
+ * Capability-deck contract — the FROZEN type surface of the tooling layer.
+ *
+ * This module is the single typed seam between the coding-agent *product* and
+ * the set of callable capabilities the agent runtime executes — file ops, the
+ * shell, search, the web, the delegate/subagent action, the checklist, the
+ * background-process proxy, SaaS connector actions, and dynamically-grafted MCP
+ * server tools. It declares *only* shapes plus a handful of tiny inert helpers
+ * (an id brand, a key minter, a fault factory, and a pure ledger reducer) — no
+ * I/O, no provisioning, no orchestration. Every later deck module (the manifest
+ * catalog, the builtin bridge, the per-concern provisioners, the bridge network,
+ * and the assembled `ToolDeck`) is written against the names declared here, so
+ * the file is intentionally small, append-mostly, and stable.
+ *
+ * Design stance:
+ *   - A {@link Capability} is exactly the framework `AgentTool` shape. The deck
+ *     does not invent a parallel descriptor type; it *manages* AgentTools so the
+ *     conductor can consume the deck's output directly as `options.tools`.
+ *   - The catalog is a single source of truth: {@link CapabilityCard} rows live
+ *     in one `CAPABILITY_CARDS` array (built by the manifest module), and every
+ *     index/lookup is derived *from* that array rather than hand-maintained in a
+ *     second parallel map.
+ *   - Profiles replace a trio of near-identical build functions: one
+ *     data-driven provisioner walks a {@link DeckProfile} ("authoring" |
+ *     "survey" | "all") to assemble the right capability set for a session.
+ *   - MCP enrollment is **event-sourced**: a {@link BridgeLedger} is the fold of
+ *     an append-only stream of {@link BridgeEntry} events (`enroll` / `retire`),
+ *     keyed by a content-hash / ULID {@link BridgeKey} rather than a path digest.
+ *     The current view is a {@link LedgerSnapshot} reduced from that stream.
+ *
+ * Framework anchors (all from the `indusagi` package — the sibling rebuilt
+ * framework this app targets):
+ *   - `AgentTool`, `AgentToolResult`     ← `indusagi/agent`
+ *   - `ToolBox`                          ← `indusagi/runtime`
+ *   - `TSchema`, `Static`                ← `@sinclair/typebox`
+ *
+ * The deck never re-declares these; it composes them.
+ */
+import type { AgentTool, AgentToolResult } from "indusagi/agent";
+import type { ToolBox } from "indusagi/runtime";
+import type { Static, TSchema } from "@sinclair/typebox";
+/** Re-exported framework vocabulary that deck consumers routinely need. */
+export type { AgentTool, AgentToolResult, ToolBox, TSchema, Static };
+/**
+ * A single callable tool the deck manages.
+ *
+ * Deliberately an alias of the framework `AgentTool` rather than a fresh shape:
+ * the conductor and the framework agent loop both expect `AgentTool` objects, so
+ * the deck's whole job is to *assemble* them, not to wrap them in a parallel
+ * descriptor. A `Capability` therefore carries the framework contract verbatim —
+ * `name`, `label`, `description`, a TypeBox `parameters` schema, and an
+ * async `execute` — while the deck owns only the catalog, profiles, and
+ * dynamic-bridge layers around it.
+ *
+ * `TParameters` is left open (`TSchema`) so heterogeneous capabilities with
+ * different parameter schemas coexist in one `Capability[]`.
+ */
+export type Capability<TParameters extends TSchema = TSchema, TDetails = unknown> = AgentTool<TParameters, TDetails>;
+/**
+ * A capability whose parameter/detail types are erased — the element type of a
+ * heterogeneous deck.
+ *
+ * A `Capability[]` array of mixed schemas widens to `AnyCapability[]`; this is
+ * the shape the conductor consumes as `options.tools` and the type the deck's
+ * {@link ToolDeck.tools} / {@link ToolDeck.box} surface in.
+ */
+export type AnyCapability = Capability<TSchema, unknown>;
+/**
+ * String-branded stable identifier for a capability.
+ *
+ * The wire-facing tool `name` the model sees (e.g. `"read"`, `"bash"`,
+ * `"composio_execute"`, a qualified `"<server>__<tool>"`); branded so an
+ * arbitrary string cannot be passed where a vetted capability id is required.
+ * Mint one with {@link capabilityId}.
+ */
+export type CapabilityId = string & {
+    readonly __capability: unique symbol;
+};
+/**
+ * Brand a raw string as a {@link CapabilityId}. The single sanctioned way to
+ * produce one, so id provenance stays uniform across the catalog and bridge.
+ *
+ * @param raw the wire-facing tool name to brand
+ */
+export declare function capabilityId(raw: string): CapabilityId;
+/**
+ * One row of the static capability catalog — the deck's single source of truth.
+ *
+ * A card is *metadata plus a builder*: it advertises the capability's identity
+ * (`id`, `title`, `summary`) for help/introspection and slash-command listings,
+ * and carries a {@link CapabilityCard.build} factory that mints the live
+ * {@link Capability} for a given {@link DeckContext}. The catalog array
+ * (`CAPABILITY_CARDS`, owned by the manifest module) is the only hand-maintained
+ * list; every index, profile membership, and lookup is derived from it.
+ */
+export interface CapabilityCard {
+    /** Stable, wire-facing identifier of the capability this card builds. */
+    readonly id: CapabilityId;
+    /** Short human-facing title for catalogs and help text. */
+    readonly title: string;
+    /** One-line description of what the capability does, in the deck's own voice. */
+    readonly summary: string;
+    /**
+     * Build the live capability for a working context.
+     *
+     * Pure with respect to the deck: it reads the injected backends from `ctx`
+     * and returns a configured {@link Capability}; it performs no enrollment and
+     * mutates no shared state.
+     *
+     * @param ctx the working context (cwd + injectable backends) to bind to
+     */
+    build(ctx: DeckContext): Capability;
+}
+/**
+ * The set of capabilities a card is eligible for, by profile.
+ *
+ * A card declares which {@link DeckProfile}s it participates in; the
+ * data-driven provisioner intersects this with the requested profile instead of
+ * branching through separate per-profile build functions. `"all"` is implied for
+ * every card and need not be listed.
+ */
+export type CardProfiles = readonly DeckProfile[];
+/**
+ * The named capability sets a session can be provisioned with — the profile
+ * table that replaces a trio of near-identical build functions.
+ *
+ *   - `authoring` — the full mutating set: read/write/edit/ls + search + shell +
+ *     web + checklist + delegate + background processes + SaaS actions. The
+ *     default for an interactive coding session.
+ *   - `survey`    — observe-only: read/ls/search/web/checklist. No filesystem
+ *     mutation and no shell. Safe when the agent must not change the workspace.
+ *   - `all`       — every registered capability, nothing withheld.
+ */
+export type DeckProfile = "authoring" | "survey" | "all";
+/**
+ * The working context handed to {@link CapabilityCard.build}.
+ *
+ * Bundles the workspace root with the injectable backends a capability binds to,
+ * so capabilities stay framework-agnostic and testable: a test passes fake
+ * `fs` / `shell` ports, production passes the Node-backed ones. Every field
+ * beyond `cwd` is optional — the manifest supplies framework defaults when a
+ * backend is not injected.
+ */
+export interface DeckContext {
+    /** Absolute working directory the session's capabilities are scoped to. */
+    readonly cwd: string;
+    /** Injectable filesystem port; framework Node backend is the default. */
+    readonly fs?: DeckFsBackend;
+    /** Injectable shell port; framework Node backend is the default. */
+    readonly shell?: DeckShellBackend;
+    /** Opaque framework handles a capability may need (model registry, stores). */
+    readonly framework?: DeckFrameworkHandles;
+}
+/**
+ * Filesystem backend port a capability may bind to.
+ *
+ * Intentionally opaque at the contract layer: the concrete port shape is owned
+ * by the framework capabilities kernel. The deck only needs to *thread* it from
+ * a host into a card's builder, so the contract treats it as a branded handle —
+ * threaded, not interpreted, here.
+ */
+export type DeckFsBackend = {
+    readonly __deckFsBackend: unique symbol;
+};
+/**
+ * Shell backend port a capability may bind to. Opaque for the same reason as
+ * {@link DeckFsBackend}: a branded handle the contract threads but never reads.
+ */
+export type DeckShellBackend = {
+    readonly __deckShellBackend: unique symbol;
+};
+/**
+ * A bag of opaque framework handles the novel capabilities wire to — the
+ * subagent/delegate manager, the checklist ledger, the background-process
+ * controller, the SaaS gateway. Each is optional and keyed by name; a card that
+ * needs one reads it from here, and the manifest fills in defaults.
+ */
+export interface DeckFrameworkHandles {
+    readonly [name: string]: unknown;
+}
+/**
+ * The stable key of an enrolled bridge capability.
+ *
+ * Minted from the capability's identity rather than from a working-directory
+ * digest, so the same external tool grafted from two sessions collapses to one
+ * key and re-enrolling is idempotent. In practice a content hash of the
+ * qualified `<server>__<tool>` name (and its schema) or a fresh ULID; branded so
+ * a raw string cannot stand in for a vetted key.
+ */
+export type BridgeKey = string & {
+    readonly __bridgeKey: unique symbol;
+};
+/** Brand a raw string as a {@link BridgeKey}. */
+export declare function bridgeKey(raw: string): BridgeKey;
+/**
+ * The operations the MCP enrollment stream records.
+ *
+ *   - `enroll` — a bridge capability became available and was grafted in (an
+ *     upsert: re-enrolling the same {@link BridgeKey} replaces its entry).
+ *   - `retire` — a bridge capability (or a whole server's set) was withdrawn (a
+ *     splice: the keyed entry is removed from the reduced view).
+ */
+export type BridgeOp = "enroll" | "retire";
+/**
+ * A single append-only event in the MCP enrollment stream.
+ *
+ * The ledger is never mutated in place; every change is one of these entries
+ * appended to an ordered log, and the live view is the fold of that log. An
+ * `enroll` entry carries the grafted {@link Capability} and the owning server;
+ * a `retire` entry need only name the {@link BridgeKey} (and server) to remove.
+ * Field names are the deck's own, not the framework's registry schema.
+ */
+export interface BridgeEntry {
+    /** The operation this event records. */
+    readonly op: BridgeOp;
+    /** Stable key of the bridge capability the event concerns. */
+    readonly key: BridgeKey;
+    /** Id of the external MCP server that owns the capability. */
+    readonly server: string;
+    /** The grafted capability — present on `enroll`, omitted on `retire`. */
+    readonly capability?: AnyCapability;
+    /** Monotonic sequence number; the append order, used to break upsert ties. */
+    readonly seq: number;
+    /** ISO-8601 timestamp the event was appended. */
+    readonly at: string;
+}
+/**
+ * The reduced, current view of the MCP enrollment ledger.
+ *
+ * A pure projection of the {@link BridgeEntry} stream: the set of bridge
+ * capabilities live *right now*, keyed by {@link BridgeKey}, alongside the
+ * highest sequence number folded and a per-server tool count for status
+ * rendering. Produced by {@link reduceLedger}; consumers read it, never mutate.
+ */
+export interface LedgerSnapshot {
+    /** Currently-enrolled bridge capabilities, keyed by their stable key. */
+    readonly live: ReadonlyMap<BridgeKey, AnyCapability>;
+    /** Number of live capabilities grafted from each server, keyed by server id. */
+    readonly byServer: ReadonlyMap<string, number>;
+    /** The highest {@link BridgeEntry.seq} folded into this snapshot. */
+    readonly highWater: number;
+}
+/**
+ * Fold an append-only {@link BridgeEntry} stream into its current
+ * {@link LedgerSnapshot}.
+ *
+ * Pure and total: `enroll` upserts the keyed capability (later `seq` wins on a
+ * repeated key), `retire` removes it, and entries are applied in `seq` order so
+ * the result is independent of array order. This is the single sanctioned
+ * reducer, so the event-sourced view stays consistent across every producer.
+ *
+ * @param entries the enrollment events to fold, in any order
+ */
+export declare function reduceLedger(entries: readonly BridgeEntry[]): LedgerSnapshot;
+/**
+ * The assembled capability deck a session runs against.
+ *
+ * The product of provisioning a {@link DeckProfile} against a
+ * {@link DeckContext}, optionally with bridge capabilities grafted on. It
+ * exposes exactly two reads: the flat capability list (for inspection, naming,
+ * and `--tools` style selection) and the consumable box the conductor wires in.
+ *
+ * `box()` returns an `AnyCapability[]` — the same `AgentTool[]` the conductor's
+ * session options accept directly — so a deck drops straight into
+ * `SessionConductorOptions.tools`. The {@link DeckBox} alias also admits the
+ * framework `ToolBox` for hosts that drive the lower-level runtime contract
+ * instead of the conductor.
+ */
+export interface ToolDeck {
+    /** The flat list of live capabilities, for inspection and selection. */
+    tools(): AnyCapability[];
+    /** The consumable surface the conductor (or runtime) wires in as its tools. */
+    box(): DeckBox;
+}
+/**
+ * What {@link ToolDeck.box} hands to a consumer.
+ *
+ * Primarily an `AnyCapability[]` (= `AgentTool[]`), which the conductor accepts
+ * verbatim as `options.tools`. Also admits the framework {@link ToolBox} so a
+ * host wiring the raw runtime contract — or grafting MCP tools through the
+ * protocol bridge, which yields a `ToolBox` — can consume the deck the same way.
+ */
+export type DeckBox = AnyCapability[] | ToolBox;
+/**
+ * The closed set of failure categories the deck can surface during
+ * provisioning or bridge enrollment.
+ *
+ *   - `unknown_capability` — a requested id is not in the catalog.
+ *   - `build_failed`       — a card's `build` threw while minting a capability.
+ *   - `bridge`             — connecting/listing/grafting an MCP server failed.
+ *   - `backend`            — a required injected backend was missing or invalid.
+ */
+export type DeckFaultKind = "unknown_capability" | "build_failed" | "bridge" | "backend";
+/**
+ * A typed, discriminated failure raised by the deck.
+ *
+ * `kind` selects the category; `message` is a human-readable summary; the
+ * optional `cause` carries the underlying error for logging without forcing
+ * consumers to parse the message. Construct one with {@link deckFault}.
+ */
+export interface DeckFault {
+    /** Failure category — the discriminant consumers switch on. */
+    readonly kind: DeckFaultKind;
+    /** Human-readable, single-line summary of what went wrong. */
+    readonly message: string;
+    /** Underlying error or structured detail, if any. */
+    readonly cause?: unknown;
+}
+/**
+ * Construct a {@link DeckFault}. The single sanctioned way to mint one, so the
+ * shape stays uniform across every producer.
+ *
+ * @param kind    the failure category
+ * @param message a human-readable, single-line summary
+ * @param cause   optional underlying error or structured detail
+ */
+export declare function deckFault(kind: DeckFaultKind, message: string, cause?: unknown): DeckFault;

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

@@ -0,0 +1,46 @@
+/**
+ * Capability-deck subsystem — public barrel.
+ *
+ * Re-exports the FROZEN tooling-layer contract: the {@link Capability} alias
+ * over the framework `AgentTool`, the branded {@link CapabilityId}, the
+ * catalog row ({@link CapabilityCard}) that is the deck's single source of
+ * truth, the {@link DeckProfile} table and {@link DeckContext} injection bag,
+ * the event-sourced MCP enrollment model ({@link BridgeEntry}, {@link BridgeOp},
+ * {@link LedgerSnapshot} + the pure {@link reduceLedger} fold), the assembled
+ * {@link ToolDeck} the conductor consumes, and the typed {@link DeckFault}.
+ *
+ * Behavior modules (the manifest catalog, the builtin bridge, the per-concern
+ * provisioners, the bridge network, and the deck assembler) are added to this
+ * barrel as they land; consumers import the deck surface from
+ * `src/capability-deck` rather than reaching into individual modules.
+ */
+export type { Capability, AnyCapability, CapabilityId, CapabilityCard, CardProfiles, DeckProfile, DeckContext, DeckFsBackend, DeckShellBackend, DeckFrameworkHandles, BridgeKey, BridgeOp, BridgeEntry, LedgerSnapshot, ToolDeck, DeckBox, DeckFaultKind, DeckFault, AgentTool, AgentToolResult, ToolBox, TSchema, Static, } from "./contract";
+export { capabilityId, bridgeKey, reduceLedger, deckFault, } from "./contract";
+/**
+ * Built-in bridge — the single seam re-exposing the framework's native tools
+ * (read/write/edit/ls/grep/find/bash/process/checklist/web) as capabilities.
+ */
+export { BUILTIN_BRIDGE, BUILTIN_IDS, BUILTIN_PROFILES, builtinDescriptors, buildBuiltin, buildBuiltinsForProfile, type BridgeBuilder, type BuiltinDescriptor, } from "./builtin-bridge";
+/**
+ * Capability catalog — the single `CAPABILITY_CARDS` source of truth plus the
+ * lookups/profile filters derived from it.
+ */
+export { CAPABILITY_CARDS, CAPABILITY_INDEX, CARD_PROFILES, capabilityIds, hasCapability, findCard, cardsForProfile, } from "./manifest";
+/**
+ * App-novel capability cards — the in-house tools the deck builds itself
+ * (checklist, background-process proxy, delegate/sub-agent, SaaS connector,
+ * working memory) plus their builders, stores, and injection-handle types.
+ */
+export { APP_NOVEL_CARDS, todoCard, buildTodoCapability, TodoLedger, type TodoItem, type TodoState, type TodoWeight, type TodoParamsType, type TodoDetails, daemonCard, buildDaemonCapability, DaemonTable, type DaemonState, type DaemonParamsType, type DaemonDetails, taskCard, buildTaskCapability, DELEGATE_HANDLE_KEY, type DelegateRunner, type DelegateRequest, type DelegateResult, type TaskParamsType, type TaskDetails, saasCard, buildSaasCapability, SAAS_GATEWAY_KEY, type SaasGatewayPort, type RemoteToolSummary, type RemoteExecution, type SaasParamsType, type SaasDetails, memoryCard, buildMemoryCapability, InMemoryStore, MEMORY_HANDLE_KEY, type MemoryStore, type MemoryParamsType, type MemoryDetails, } from "./cards/index";
+/**
+ * Bridge ledger — event-sourced enrollment of dynamically grafted MCP tools:
+ * content-hash / ULID key minting, the immutable {@link BridgeLedger} value with
+ * its pure enroll/retire/withdraw transitions and live projections, and the
+ * side-effecting mount/adapt/detach network operations.
+ */
+export { qualifyBridgeName, bridgeContentKey, bridgeUlidKey, emptyBridgeLedger, bridgeLedgerFromLog, enrollBridgeCard, retire, withdrawServer, liveCapabilities, liveCapabilitiesForServer, type BridgeLedger, type EnrollRequest, attachBridgeCapabilities, detachBridge, bridgeBoxToCapabilities, bridgeCapabilityCard, bridgeConfig, type AttachResult, } from "./bridge-ledger/index";
+/**
+ * Deck provisioning — the single data-driven {@link provisionDeck} assembler over
+ * the profile table, plus the profile-to-cards selection it walks.
+ */
+export { provisionDeck, cardsForDeckProfile, } from "./provision";

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

@@ -0,0 +1,60 @@
+/**
+ * Capability catalog — the deck's single source of truth.
+ *
+ * This module owns {@link CAPABILITY_CARDS}: the one hand-maintained-in-one-place
+ * list of {@link CapabilityCard} rows the rest of the deck reads from. Every
+ * index, lookup, and profile-membership query is *derived* from this array, so
+ * there is never a second parallel map to keep in sync.
+ *
+ * Right now the catalog is exactly the framework built-ins — read/write/edit/
+ * ls/grep/find/bash/process/the checklist pair/web search & fetch — projected
+ * out of the single {@link BUILTIN_BRIDGE} table in `builtin-bridge.ts`. As the
+ * novel provisioners land (delegate, checklist ledger, daemon proxy, recall,
+ * SaaS actions, and the MCP bridge network) their cards are appended here too,
+ * so the catalog stays the one place the deck enumerates what tools exist.
+ *
+ * A {@link CapabilityCard} is metadata plus a builder: the wire-facing id, the
+ * deck-side title/summary prose, and a `build(ctx)` that mints the live
+ * {@link Capability}. The card does not carry profile membership — that lives in
+ * the profile table the provisioner consults — so the card shape stays the small
+ * catalog row the contract froze.
+ */
+import type { CapabilityCard, CapabilityId, CardProfiles } from "./contract";
+/**
+ * The static capability catalog — the deck's single source of truth.
+ *
+ * One ordered array of catalog rows. Today every row is a framework built-in,
+ * projected from the bridge table; novel-provisioner cards are appended here as
+ * they land. Consumers never hand-build a parallel list — they read this array
+ * (or the derived {@link CAPABILITY_INDEX} / {@link CARD_PROFILES} below).
+ */
+export declare const CAPABILITY_CARDS: readonly CapabilityCard[];
+/**
+ * The catalog keyed by wire-facing {@link CapabilityId}, derived from
+ * {@link CAPABILITY_CARDS}. Resolves a `--tools name1,name2` selection or a
+ * model-named tool to its card in O(1) without a second hand-maintained map.
+ */
+export declare const CAPABILITY_INDEX: ReadonlyMap<CapabilityId, CapabilityCard>;
+/**
+ * Profile membership for every catalog row, keyed by id and derived from the
+ * bridge table. The data-driven provisioner intersects this with a requested
+ * profile to assemble a session's capability set — no per-profile build
+ * functions, just a table walk.
+ */
+export declare const CARD_PROFILES: ReadonlyMap<CapabilityId, CardProfiles>;
+/** The wire-facing ids of every catalog row, in catalog order. */
+export declare function capabilityIds(): CapabilityId[];
+/** True when a catalog row exists under this id. */
+export declare function hasCapability(id: CapabilityId): boolean;
+/** Fetch a catalog row by id, or `undefined` when the id is unknown. */
+export declare function findCard(id: CapabilityId): CapabilityCard | undefined;
+/**
+ * The catalog rows that participate in a profile, in catalog order.
+ *
+ * `all` returns every row; a named profile keeps only the rows whose membership
+ * (read from {@link CARD_PROFILES}) admits it. The single place profile
+ * filtering happens, so the provisioner stays a thin walk over this result.
+ *
+ * @param profile the requested deck profile
+ */
+export declare function cardsForProfile(profile: "authoring" | "survey" | "all"): CapabilityCard[];

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

@@ -0,0 +1,76 @@
+/**
+ * Deck provisioning — the single data-driven assembler.
+ *
+ * One function, {@link provisionDeck}, turns a {@link DeckProfile} plus a
+ * {@link DeckContext} into an assembled {@link ToolDeck}. It replaces what would
+ * otherwise be a trio of near-identical `buildAuthoringTools` / `buildSurveyTools`
+ * / `buildAllTools` functions with a single walk over a {@link PROFILE_TABLE}: the
+ * table says which catalog rows each profile draws from, the assembler builds
+ * exactly those rows against the context, and the result exposes the two reads the
+ * conductor needs — {@link ToolDeck.tools} (the flat capability list) and
+ * {@link ToolDeck.box} (the consumable `AgentTool[]` it wires in as
+ * `options.tools`).
+ *
+ * Why a table rather than three functions:
+ *   - The catalog is already the single source of truth (`CAPABILITY_CARDS` plus
+ *     the app-novel cards). A profile is just a *selection policy* over that
+ *     catalog, so it is data — a small row per profile — not control flow.
+ *   - Adding a profile, or moving a card between profiles, is a one-line table
+ *     edit with no new branch to keep in sync.
+ *
+ * Breadth runs `authoring` (narrowest, read-only) -> `survey` (all built-ins) ->
+ * `all` (built-ins + app cards), spelled out per profile below.
+ *
+ * The three profiles, in increasing breadth:
+ *   - `authoring` — the read-only built-in subset: the observe-only tools the
+ *     framework exposes (read/ls/grep/find/web search & fetch/checklist-read). No
+ *     filesystem mutation, no shell, no app-novel cards. The safe selection for a
+ *     session that must inspect a workspace without changing it.
+ *   - `survey`    — the wider built-in subset: every framework built-in,
+ *     including the mutating ones (write/edit/bash/process/checklist-write). Still
+ *     no app-novel cards — just the full native tool set.
+ *   - `all`       — everything: every framework built-in plus every app-novel
+ *     card (the checklist, the background-process proxy, the delegate/sub-agent
+ *     action, the SaaS connector, working memory).
+ *
+ * The built-in catalog tags each native tool with the profiles it belongs to
+ * (`read` etc. are observe-only; `bash`/`write` are mutating); this table maps the
+ * deck profiles onto those membership selections, so the read-only/wider split is
+ * a table lookup rather than a hand-maintained second tool list.
+ *
+ * Bridge (MCP) capabilities are *not* selected here — they are grafted at runtime
+ * through the bridge ledger and concatenated by the host onto a deck's
+ * {@link ToolDeck.tools}; provisioning only assembles the static catalog.
+ */
+import type { CapabilityCard, DeckContext, DeckProfile, ToolDeck } from "./contract";
+/**
+ * The catalog rows a profile selects, in catalog order: the built-in subset the
+ * policy names, followed by the app-novel cards when the policy grants them.
+ *
+ * Derived purely from {@link PROFILE_TABLE} + the catalog — no per-profile
+ * branching beyond the table lookup.
+ *
+ * @param profile the requested deck profile
+ */
+export declare function cardsForDeckProfile(profile: DeckProfile): CapabilityCard[];
+/**
+ * Provision a {@link ToolDeck} for a profile and working context.
+ *
+ * Looks the profile up in {@link PROFILE_TABLE}, selects its catalog rows,
+ * builds each against `ctx`, and returns a deck that hands the resulting
+ * capabilities out two ways:
+ *   - {@link ToolDeck.tools} — the flat `AnyCapability[]` for inspection,
+ *     naming, and `--tools` style selection.
+ *   - {@link ToolDeck.box}   — the same `AnyCapability[]` (= the framework
+ *     `AgentTool[]`) the conductor consumes verbatim as
+ *     `SessionConductorOptions.tools`.
+ *
+ * The capabilities are built once, at provision time, and the same list backs
+ * both reads (returned as fresh copies so a caller cannot mutate the deck's
+ * backing array). Bridge/MCP tools are concatenated onto `tools()` by the host
+ * after provisioning; they are not part of the static selection.
+ *
+ * @param profile the requested capability set (`authoring` | `survey` | `all`)
+ * @param ctx     the working context (cwd + injectable backends) to bind cards to
+ */
+export declare function provisionDeck(profile: DeckProfile, ctx: DeckContext): ToolDeck;

package/dist/types/channels/channels.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Phase 8 channels — behavioral tests.
+ *
+ * Three independent surfaces, all driven over in-memory pipes with a scripted
+ * conductor and zero real stdio:
+ *
+ *   1. the NDJSON framer round-trips a value carrying the two Unicode line
+ *      separators (the regression), and `decodeLines` reassembles a payload split
+ *      across arbitrary chunk boundaries;
+ *   2. the oneshot channel produces the expected text and NDJSON output from a
+ *      scripted conductor (two strategy objects, one runner);
+ *   3. the link server and the generated driver round-trip a request over a pipe
+ *      pair, and an unknown method yields a JSON-RPC error reply.
+ */
+export {};