@spinabot/brigade 1.3.2 → 1.5.0

package/dist/agents/extensions/activation-planner.js

@@ -0,0 +1,221 @@
+/**
+ * Manifest-driven lazy activation planner (plugin SDK Step 5).
+ *
+ * Today the loader imports + runs `register()` EAGERLY for every eligible user
+ * module. With many installed modules that's O(modules) cold-boot cost paid even
+ * for modules whose capability is irrelevant to the active config (a Slack
+ * channel module on an install with no Slack channel configured still gets
+ * imported + registered). The `BrigadeModuleManifest.activation` block
+ * (`onChannels` / `onProviders` / `onCommands` / `onCapabilities`) declares WHEN
+ * a module is relevant; this planner consumes it so the loader can SKIP importing
+ * a module whose triggers don't fire — O(manifest) boot instead of O(modules).
+ *
+ * ── Trigger semantics ──────────────────────────────────────────────────────
+ * The planner takes a module's `activation` triggers + an `ActivationSnapshot`
+ * (a cheap, config-derived view of what's active right now) and returns
+ * `{ activate, reason? }`.
+ *
+ *   - NO manifest, or a manifest with NO `activation` block, or an `activation`
+ *     block with NO non-empty trigger array ⇒ ALWAYS activate (back-compat:
+ *     nothing that worked before regresses; a module that doesn't opt into lazy
+ *     activation keeps loading eagerly).
+ *
+ *   - When `activation` declares one or more NON-EMPTY trigger arrays, the
+ *     module activates iff AT LEAST ONE declared trigger matches the snapshot
+ *     (OR across trigger kinds AND across entries within a kind — any single
+ *     hit is enough). The intent of a trigger is "load me when X is present",
+ *     so the union (not intersection) is the correct semantics: a module that
+ *     declares both `onChannels: ["slack"]` and `onProviders: ["openai"]` wants
+ *     to load if EITHER Slack is configured OR OpenAI is the active provider.
+ *
+ *   - A trigger array that is present but EMPTY (`onChannels: []`) is treated as
+ *     "no constraint from this kind" — it neither forces activation nor blocks
+ *     it; only non-empty arrays carry a constraint. If ALL declared arrays are
+ *     empty the module falls back to the back-compat ALWAYS-activate rule.
+ *
+ *   Match rules per trigger kind (all case-insensitive, trimmed):
+ *     - `onChannels`    matches a channel id that is CONFIGURED + ENABLED
+ *                       (`cfg.channels.<id>` present and not `enabled === false`).
+ *     - `onProviders`   matches the active model provider
+ *                       (`cfg.agents.defaults.provider`) OR any provider id that
+ *                       appears in a configured channel/model — the snapshot
+ *                       collects the set; the planner only checks membership.
+ *     - `onCommands`    matches an AVAILABLE command name. The snapshot's
+ *                       `commands` set is the union of (a) the built-in channel
+ *                       commands every configured channel exposes (`/help`,
+ *                       `/status`, `/agent`, …) and (b) any extra command names
+ *                       the loader supplies (e.g. command names the bundled
+ *                       modules declare in their manifest). A module gated only
+ *                       on `onCommands:[...]` activates when one of its named
+ *                       commands is available — otherwise it stays dormant.
+ *     - `onCapabilities` matches an `extensions.slots.<slot>` value the operator
+ *                       pinned (memory / contextEngine / compaction /
+ *                       agentHarness) — a module that PROVIDES the pinned backend
+ *                       activates; others stay dormant.
+ *
+ * The planner is a PURE function: no I/O, no config reads of its own. The loader
+ * builds the snapshot once (via `buildActivationSnapshot`) and consults the
+ * planner per module BEFORE importing it.
+ */
+/**
+ * The built-in channel command names Brigade wires for EVERY configured channel
+ * (`buildBundledCommands` in the inbound pipeline produces these). They are a
+ * stable, channel-neutral constant, so the snapshot can fold them into the
+ * `commands` set whenever at least one channel is configured WITHOUT importing
+ * the pipeline (which would pull a heavy module into this pure planner). A bundled
+ * channel like `/help` is therefore matchable by an `onCommands:["help"]` trigger
+ * on any install that has a channel. Module-contributed commands are passed in
+ * separately via `buildActivationSnapshot(config, availableCommands)`.
+ */
+export const BUILTIN_CHANNEL_COMMAND_NAMES = [
+    "help",
+    "start",
+    "pending",
+    "approve",
+    "deny",
+    "status",
+    "allowlist",
+    "agent",
+    "agents",
+    "whoami",
+    "org",
+];
+/** Lowercase + trim a list into a set, dropping empties. */
+function toSet(values) {
+    const out = new Set();
+    for (const v of values ?? []) {
+        const norm = typeof v === "string" ? v.trim().toLowerCase() : "";
+        if (norm)
+            out.add(norm);
+    }
+    return out;
+}
+/** Does any entry of `wanted` appear in `have`? (case-insensitive; inputs pre-normalized.) */
+function anyMatch(wanted, have) {
+    for (const w of wanted) {
+        const norm = typeof w === "string" ? w.trim().toLowerCase() : "";
+        if (norm && have.has(norm))
+            return true;
+    }
+    return false;
+}
+/**
+ * Build the activation snapshot from the active config. Pure read — never
+ * mutates config, never touches disk. The loader calls this once before the
+ * per-module loop.
+ *
+ * `availableCommands` (optional) lets the caller fold in EXTRA command names
+ * that aren't derivable from config alone — e.g. the command names the bundled
+ * modules declare in their manifest. They are merged with the built-in channel
+ * command set (the latter added only when at least one channel is configured),
+ * so an `onCommands` trigger can fire off either source.
+ */
+export function buildActivationSnapshot(config, availableCommands) {
+    const channels = new Set();
+    const providers = new Set();
+    const commands = new Set();
+    const capabilities = new Set();
+    // ── channels: cfg.channels.<id> present and not explicitly disabled.
+    const channelsCfg = config
+        .channels;
+    if (channelsCfg && typeof channelsCfg === "object") {
+        for (const [id, slot] of Object.entries(channelsCfg)) {
+            const norm = id.trim().toLowerCase();
+            if (!norm)
+                continue;
+            // A slot that exists counts as "configured"; only an explicit
+            // `enabled: false` opts out. (Mirrors the channel manager, which
+            // treats an absent `enabled` as on once the slot has credentials.)
+            if (slot && typeof slot === "object" && slot.enabled === false)
+                continue;
+            channels.add(norm);
+            // A channel may name an owning provider; fold it into the provider set
+            // so an `onProviders` trigger can fire off a channel's transport too.
+            if (slot && typeof slot === "object" && typeof slot.provider === "string") {
+                const p = slot.provider.trim().toLowerCase();
+                if (p)
+                    providers.add(p);
+            }
+        }
+    }
+    // ── providers: the active model provider stamped at onboard time.
+    const activeProvider = config.agents?.defaults?.provider;
+    if (typeof activeProvider === "string") {
+        const p = activeProvider.trim().toLowerCase();
+        if (p)
+            providers.add(p);
+    }
+    // ── capabilities: pinned slot backends (memory/contextEngine/compaction/agentHarness).
+    const slots = config.extensions?.slots;
+    if (slots && typeof slots === "object") {
+        for (const value of Object.values(slots)) {
+            if (typeof value !== "string")
+                continue;
+            const norm = value.trim().toLowerCase();
+            if (norm)
+                capabilities.add(norm);
+        }
+    }
+    // ── commands: the built-in channel commands are wired for EVERY configured
+    // channel, so they become "available" the moment any channel is configured.
+    // (No channel ⇒ no channel command surface ⇒ leave them out.)
+    if (channels.size > 0) {
+        for (const name of BUILTIN_CHANNEL_COMMAND_NAMES)
+            commands.add(name);
+    }
+    // Plus any extra command names the caller supplies (e.g. command names the
+    // bundled modules declare). Normalized + deduped like every other set.
+    for (const name of availableCommands ?? []) {
+        const norm = typeof name === "string" ? name.trim().toLowerCase() : "";
+        if (norm)
+            commands.add(norm);
+    }
+    return { channels, providers, commands, capabilities };
+}
+/**
+ * Decide whether a module should activate, given its manifest (or `undefined`)
+ * and the active-config snapshot. PURE — see file header for the full trigger
+ * semantics. The headline rules:
+ *   - no manifest / no activation / no non-empty triggers ⇒ activate (back-compat)
+ *   - otherwise activate iff at least one declared trigger matches the snapshot.
+ */
+export function planActivation(manifest, snapshot) {
+    const activation = manifest?.activation;
+    if (!activation) {
+        // No manifest or no activation block — always-on (eager, as before).
+        return { activate: true };
+    }
+    const onChannels = toSet(activation.onChannels);
+    const onProviders = toSet(activation.onProviders);
+    const onCommands = toSet(activation.onCommands);
+    const onCapabilities = toSet(activation.onCapabilities);
+    const declaredKinds = [];
+    if (onChannels.size > 0)
+        declaredKinds.push({ kind: "onChannels", wanted: onChannels, have: snapshot.channels });
+    if (onProviders.size > 0)
+        declaredKinds.push({ kind: "onProviders", wanted: onProviders, have: snapshot.providers });
+    if (onCommands.size > 0)
+        declaredKinds.push({ kind: "onCommands", wanted: onCommands, have: snapshot.commands });
+    if (onCapabilities.size > 0)
+        declaredKinds.push({ kind: "onCapabilities", wanted: onCapabilities, have: snapshot.capabilities });
+    // No non-empty trigger arrays — the activation block carries no constraint,
+    // so the module stays always-on (back-compat).
+    if (declaredKinds.length === 0) {
+        return { activate: true };
+    }
+    // Activate iff ANY declared trigger matches the snapshot.
+    for (const { wanted, have } of declaredKinds) {
+        if (anyMatch([...wanted], have)) {
+            return { activate: true };
+        }
+    }
+    // Nothing matched — describe what would have been needed.
+    const detail = declaredKinds
+        .map(({ kind, wanted }) => `${kind}=[${[...wanted].join(",")}]`)
+        .join(" ");
+    return {
+        activate: false,
+        reason: `no activation trigger matched active config (${detail})`,
+    };
+}
+//# sourceMappingURL=activation-planner.js.map

package/dist/agents/extensions/activation-planner.js.map

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

package/dist/agents/extensions/diagnose.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Extension diagnosis — the shared, registry-free analysis behind
+ * `brigade extensions list` and `brigade extensions doctor`.
+ *
+ * It answers two questions for the operator authoring a plugin:
+ *   1. WHAT modules exist — the bundled set that ships with Brigade plus every
+ *      module dropped into `~/.brigade/extensions/`.
+ *   2. For each user module, WOULD IT LOAD — did it pass the safety gate, did it
+ *      import cleanly, and did it export a usable module? When the answer is no,
+ *      the exact reason (so the author can fix it).
+ *
+ * This deliberately does NOT run a module's `register()` or touch a registry —
+ * it inspects candidates the same way discovery would, so it's safe to call from
+ * a short-lived CLI command. The richer config-gating decisions (allowlist /
+ * disabled / requiresEnv / configSchema) live in the loader's structured logs;
+ * this surface covers the discovery half ("did Brigade even find + import it").
+ */
+import type { BrigadeExtensionRegistry, PluginRecord } from "./registry.js";
+import type { BrigadeModule } from "./types.js";
+/** Where a module came from. */
+export type ExtensionOrigin = "bundled" | "user";
+/** Headline status shown in the `list` table. */
+export type ExtensionStatus = "loaded" | "skipped";
+/**
+ * One diagnosed extension entry — a bundled module OR a user candidate. The same
+ * shape feeds both the `list` table and the deeper `doctor` view.
+ */
+export interface DiagnosedExtension {
+    /** The module's declared id, or — for a user candidate that never produced a
+     *  module — a readable label derived from its file. */
+    id: string;
+    origin: ExtensionOrigin;
+    /** Absolute source path the module was found at. */
+    source: string;
+    status: ExtensionStatus;
+    /** One short, non-jargony line explaining a `skipped` status. */
+    reason?: string;
+    /** Per-candidate detail (user modules only) for the `doctor` view. */
+    checks?: {
+        /** Passed the file-safety gate. */
+        safe: boolean;
+        /** Imported without error. */
+        imported: boolean;
+        /** Exported a usable module. */
+        exportedModule: boolean;
+    };
+    /**
+     * Live REGISTER-phase status (FIX 4), present ONLY when a live registry was
+     * passed to `diagnoseExtensions`. Discovery alone never runs `register()`, so
+     * without a live registry this is undefined and the discovery-only path is
+     * byte-identical to before. When present it reflects the durable
+     * `PluginRecord`: did the module activate, fail, or just get discovered, and
+     * which capability ids it registered.
+     */
+    live?: {
+        status: PluginRecord["status"];
+        failurePhase?: string;
+        /** Flat list of `kind:id` strings for the capabilities the module registered. */
+        capabilities: string[];
+    };
+}
+/** Result of a full diagnosis pass over the bundled + user extension sets. */
+export interface ExtensionDiagnosis {
+    /** The extensions directory that was scanned. */
+    extensionsDir: string;
+    /** Every diagnosed entry, bundled first then user, each set id-sorted. */
+    extensions: DiagnosedExtension[];
+}
+/**
+ * Diagnose every bundled module + every user candidate under `extensionsDir`.
+ *
+ * Bundled modules are always reported as `loaded` (they ship in-tree and import
+ * at build time). User candidates are taken through the same gate discovery uses
+ * — safety check, then import, then valid-module check — and reported with the
+ * first failing step as the skip reason.
+ *
+ * `liveRegistry` (optional, FIX 4) — when a caller has a LIVE registry (one that
+ * actually ran `register()`), pass it to overlay each entry's `live` field with
+ * the durable `PluginRecord` (register-phase status + attributed capabilities).
+ * Omit it (the CLI's default) and the result is byte-identical to the pure
+ * discovery pass — no `register()` is ever run here.
+ */
+export declare function diagnoseExtensions(bundled: ReadonlyArray<BrigadeModule>, extensionsDir: string, liveRegistry?: BrigadeExtensionRegistry): Promise<ExtensionDiagnosis>;
+//# sourceMappingURL=diagnose.d.ts.map

package/dist/agents/extensions/diagnose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnose.d.ts","sourceRoot":"","sources":["../../../src/agents/extensions/diagnose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,OAAO,KAAK,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjD,iDAAiD;AACjD,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC;2DACuD;IACvD,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,eAAe,CAAC;IACxB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,MAAM,CAAC,EAAE;QACR,mCAAmC;QACnC,IAAI,EAAE,OAAO,CAAC;QACd,8BAA8B;QAC9B,QAAQ,EAAE,OAAO,CAAC;QAClB,gCAAgC;QAChC,cAAc,EAAE,OAAO,CAAC;KACxB,CAAC;IACF;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE;QACN,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,iFAAiF;QACjF,YAAY,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;CACF;AAED,8EAA8E;AAC9E,MAAM,WAAW,kBAAkB;IAClC,iDAAiD;IACjD,aAAa,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,UAAU,EAAE,kBAAkB,EAAE,CAAC;CACjC;AAaD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,EACrC,aAAa,EAAE,MAAM,EACrB,YAAY,CAAC,EAAE,wBAAwB,GACrC,OAAO,CAAC,kBAAkB,CAAC,CAqE7B"}

package/dist/agents/extensions/diagnose.js

@@ -0,0 +1,123 @@
+/**
+ * Extension diagnosis — the shared, registry-free analysis behind
+ * `brigade extensions list` and `brigade extensions doctor`.
+ *
+ * It answers two questions for the operator authoring a plugin:
+ *   1. WHAT modules exist — the bundled set that ships with Brigade plus every
+ *      module dropped into `~/.brigade/extensions/`.
+ *   2. For each user module, WOULD IT LOAD — did it pass the safety gate, did it
+ *      import cleanly, and did it export a usable module? When the answer is no,
+ *      the exact reason (so the author can fix it).
+ *
+ * This deliberately does NOT run a module's `register()` or touch a registry —
+ * it inspects candidates the same way discovery would, so it's safe to call from
+ * a short-lived CLI command. The richer config-gating decisions (allowlist /
+ * disabled / requiresEnv / configSchema) live in the loader's structured logs;
+ * this surface covers the discovery half ("did Brigade even find + import it").
+ */
+import { checkPosixSafety, importCandidateForDiagnosis, listExtensionSources, } from "./discovery.js";
+/** Derive a friendly label for a user candidate that never yielded a module id. */
+function labelFromSource(source) {
+    // `<dir>/index.ts` → the folder name; otherwise the file's base name.
+    const parts = source.replace(/\\/g, "/").split("/");
+    const base = parts[parts.length - 1] ?? source;
+    if (/^index\.(js|mjs|ts|mts)$/i.test(base) && parts.length >= 2) {
+        return parts[parts.length - 2] ?? base;
+    }
+    return base.replace(/\.(js|mjs|ts|mts)$/i, "");
+}
+/**
+ * Diagnose every bundled module + every user candidate under `extensionsDir`.
+ *
+ * Bundled modules are always reported as `loaded` (they ship in-tree and import
+ * at build time). User candidates are taken through the same gate discovery uses
+ * — safety check, then import, then valid-module check — and reported with the
+ * first failing step as the skip reason.
+ *
+ * `liveRegistry` (optional, FIX 4) — when a caller has a LIVE registry (one that
+ * actually ran `register()`), pass it to overlay each entry's `live` field with
+ * the durable `PluginRecord` (register-phase status + attributed capabilities).
+ * Omit it (the CLI's default) and the result is byte-identical to the pure
+ * discovery pass — no `register()` is ever run here.
+ */
+export async function diagnoseExtensions(bundled, extensionsDir, liveRegistry) {
+    const out = [];
+    const overlayLive = (entry) => {
+        if (!liveRegistry)
+            return entry;
+        const rec = liveRegistry.pluginRecord(entry.id);
+        if (!rec)
+            return entry;
+        return { ...entry, live: pluginRecordToLive(rec) };
+    };
+    // Bundled set — sorted by id for a stable table.
+    for (const m of [...bundled].sort((a, b) => a.id.localeCompare(b.id))) {
+        out.push(overlayLive({ id: m.id, origin: "bundled", source: "(built in)", status: "loaded" }));
+    }
+    // User candidates — diagnosed one by one.
+    const userEntries = [];
+    for (const candidate of listExtensionSources(extensionsDir)) {
+        const { source } = candidate;
+        // Re-run the safety check rather than trust `candidate.safetyReason`
+        // alone, so the verdict and the rest of the diagnosis share one source.
+        const safetyReason = candidate.safetyReason ?? checkPosixSafety(source, extensionsDir);
+        if (safetyReason) {
+            userEntries.push({
+                id: labelFromSource(source),
+                origin: "user",
+                source,
+                status: "skipped",
+                reason: "blocked by a safety check on the file",
+                checks: { safe: false, imported: false, exportedModule: false },
+            });
+            continue;
+        }
+        const result = await importCandidateForDiagnosis(source);
+        if (!result.imported) {
+            userEntries.push({
+                id: labelFromSource(source),
+                origin: "user",
+                source,
+                status: "skipped",
+                reason: "the file could not be loaded — check it for errors",
+                checks: { safe: true, imported: false, exportedModule: false },
+            });
+            continue;
+        }
+        if (!result.hasValidModule) {
+            userEntries.push({
+                id: labelFromSource(source),
+                origin: "user",
+                source,
+                status: "skipped",
+                reason: "the file does not export a Brigade module (use `export default defineModule({...})`)",
+                checks: { safe: true, imported: true, exportedModule: false },
+            });
+            continue;
+        }
+        userEntries.push({
+            id: result.moduleId ?? labelFromSource(source),
+            origin: "user",
+            source,
+            status: "loaded",
+            checks: { safe: true, imported: true, exportedModule: true },
+        });
+    }
+    userEntries.sort((a, b) => a.id.localeCompare(b.id));
+    out.push(...userEntries.map(overlayLive));
+    return { extensionsDir, extensions: out };
+}
+/** Flatten a `PluginRecord` into the diagnosis `live` view (`kind:id` capability strings). */
+function pluginRecordToLive(rec) {
+    const capabilities = [];
+    for (const [kind, ids] of Object.entries(rec.capabilities)) {
+        for (const id of ids)
+            capabilities.push(`${kind}:${id}`);
+    }
+    return {
+        status: rec.status,
+        ...(rec.failurePhase !== undefined ? { failurePhase: rec.failurePhase } : {}),
+        capabilities,
+    };
+}
+//# sourceMappingURL=diagnose.js.map

package/dist/agents/extensions/diagnose.js.map

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

package/dist/agents/extensions/discovery.d.ts

@@ -2,13 +2,20 @@
  * User-module discovery.
  *
  * Out-of-tree modules dropped into `~/.brigade/extensions/` are discovered and
- * dynamic-imported here, alongside the bundled ones. A candidate is either a
- * top-level `*.js`/`*.mjs` file or a folder containing `index.js`/`index.mjs`.
- * Each must `export default` a `BrigadeModule` (or an array of them); anything
- * else is skipped with a warning — a bad user module never aborts boot.
+ * imported here, alongside the bundled ones. A candidate is either a top-level
+ * `*.js`/`*.mjs`/`*.ts`/`*.mts` file or a folder containing
+ * `index.{js,mjs,ts,mts}`. Each must `export default` a `BrigadeModule` (or an
+ * array of them); anything else is skipped with a warning — a bad user module
+ * never aborts boot. `.d.ts` declaration files are NOT candidates.
  *
- * Authors import the stable `@brigade/extension-sdk` surface (defineModule + the
- * capability contracts), so a user module never reaches into Brigade internals.
+ * TypeScript-authored modules load directly: imports go through a Jiti instance
+ * that transpiles `.ts`/`.mts` on import, so authors don't need a build step.
+ *
+ * Authors import the stable `brigade/extension-sdk` / `brigade/channel-sdk`
+ * surface (defineModule + the capability contracts), so a user module never
+ * reaches into Brigade internals. Those specifiers are alias-resolved to
+ * Brigade's own built SDK entry points by the Jiti instance (see `sdk-alias.ts`),
+ * so the author does NOT install Brigade into the extensions folder.
  *
  * POSIX safety gates (non-Windows only): world-writable files are rejected
  * (mode & 0o002), suspicious ownership (uid != current uid AND != root) is
@@ -56,6 +63,50 @@ export interface DiscoveredModule {
  * `platformOverride` is a test seam — callers normally omit it.
  */
 export declare function checkPosixSafety(candidate: string, extensionsDir: string, platformOverride?: NodeJS.Platform): string | null;
+/**
+ * Read the sidecar manifest for a candidate entry, WITHOUT importing the module.
+ * `source` is the resolved entry path (a file, or a dir's `index.*`). Returns the
+ * parsed `BrigadeModuleManifest` when a readable, well-formed sidecar exists;
+ * `undefined` otherwise (no sidecar, unreadable, malformed, or wrong shape).
+ */
+export declare function readSidecarManifest(source: string): BrigadeModuleManifest | undefined;
+/**
+ * A discovery candidate paired with its sidecar manifest (read WITHOUT importing
+ * the module body). The loader's activation planner consults `manifest` to decide
+ * whether to import + register the module at all — a non-triggered module is never
+ * imported. `manifest` is `undefined` when the candidate ships no sidecar; the
+ * loader then falls back to importing the module to read its `manifest` field.
+ */
+export interface DiscoveryCandidate {
+    /** Absolute entry path the module would be imported from. */
+    source: string;
+    /** POSIX safety verdict — `null` = passed; non-null = rejection reason. */
+    safetyReason: string | null;
+    /** Sidecar manifest, when a readable `brigade.extension.json` exists next to the entry. */
+    manifest?: BrigadeModuleManifest;
+}
+/**
+ * List discovery candidates under `extensionsDir` with each one's POSIX safety
+ * verdict + its sidecar manifest (read WITHOUT importing the module body). This
+ * is the lazy-activation entry point: the loader plans activation from the
+ * sidecar manifest and only imports the candidates that survive the plan. Never
+ * imports anything; never throws (an unreadable sidecar is treated as absent).
+ */
+export declare function listDiscoveryCandidates(extensionsDir: string): DiscoveryCandidate[];
+/**
+ * Import a single candidate the same way `discoverUserModules` does — through the
+ * shared SDK-alias + TypeScript Jiti instance, time-boxed — and return the
+ * discovered module(s) plus the resolved manifest. Used by the loader's lazy
+ * path AFTER the activation planner decides (from a sidecar) that the module
+ * should load, OR when the candidate shipped no sidecar so the body must be read
+ * to recover its `manifest` field. The POSIX safety gate is the caller's
+ * responsibility (mirrors `importCandidateForDiagnosis`). Returns `[]` on
+ * import failure (logged), so a bad module never aborts the load.
+ *
+ * `sidecarManifest` (when provided) takes precedence over a body-carried manifest
+ * — the operator's declarative sidecar is authoritative.
+ */
+export declare function importDiscoveredModules(source: string, sidecarManifest?: BrigadeModuleManifest): Promise<DiscoveredModule[]>;
 /**
  * Public lister — returns the candidate sources under `extensionsDir` with
  * each one's safety verdict, WITHOUT importing them. Useful for diagnostic
@@ -73,8 +124,35 @@ export declare function listExtensionSources(extensionsDir: string): ReadonlyArr
 /** Does the extensions dir exist? Plain `fs.existsSync` lift so callers don't
  *  need to re-derive the path. */
 export declare function extensionsRootExists(extensionsDir: string): boolean;
-/** Drop the discovery cache so the next `discoverUserModules` re-scans (reload). */
+/** Drop the discovery cache so the next `discoverUserModules` re-scans (reload).
+ *  Also drops the shared Jiti instance so a reloaded module is re-transpiled
+ *  fresh rather than served from Jiti's own module cache. */
 export declare function clearDiscoveryCache(): void;
+/**
+ * Per-candidate import outcome used by the diagnostic surfaces
+ * (`brigade extensions list` / `doctor`). Reports — WITHOUT mutating any
+ * registry — whether a single candidate file imports cleanly and exports a
+ * usable module.
+ */
+export interface CandidateImportResult {
+    /** The candidate imported without throwing (or timing out). */
+    imported: boolean;
+    /** A usable BrigadeModule was found on the default/module export. */
+    hasValidModule: boolean;
+    /** The discovered module's declared id, when one was found. */
+    moduleId?: string;
+    /** Failure detail when `imported` is false (timeout / transpile / throw). */
+    error?: string;
+}
+/**
+ * Import a single candidate the same way `discoverUserModules` does — through
+ * the shared SDK-alias + TypeScript Jiti instance, time-boxed — and report what
+ * came back, without recording anything into a registry. This is the engine
+ * behind `brigade extensions doctor`'s "did my plugin import + export a module?"
+ * diagnosis. Callers run `checkPosixSafety` FIRST; this only runs for a
+ * candidate that passed the safety gate.
+ */
+export declare function importCandidateForDiagnosis(source: string): Promise<CandidateImportResult>;
 /**
  * Discover + import user modules from `extensionsDir`. Returns the loaded
  * modules (shape-validated). Errors per candidate are logged and skipped.

package/dist/agents/extensions/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/agents/extensions/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAmBvE,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CACjC;AA8BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC,QAAQ,GAChC,MAAM,GAAG,IAAI,CAqCf;AAoCD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,aAAa,EAAE,MAAM,GACnB,aAAa,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAmB5F;AAED;kCACkC;AAClC,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED,oFAAoF;AACpF,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAmD5F"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/agents/extensions/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAOH,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAkCvE,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAkDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC,QAAQ,GAChC,MAAM,GAAG,IAAI,CAqCf;AA4CD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAoCrF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAQnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAC5C,MAAM,EAAE,MAAM,EACd,eAAe,CAAC,EAAE,qBAAqB,GACrC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6B7B;AAQD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,aAAa,EAAE,MAAM,GACnB,aAAa,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAmB5F;AAED;kCACkC;AAClC,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;6DAE6D;AAC7D,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACrC,+DAA+D;IAC/D,QAAQ,EAAE,OAAO,CAAC;IAClB,qEAAqE;IACrE,cAAc,EAAE,OAAO,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAiBhG;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAmD5F"}