@spinabot/brigade 0.1.2 → 1.0.1

package/dist/agents/session-wiring.js

@@ -0,0 +1,278 @@
+/**
+ * Brigade session-wiring — the single source of truth for the tool surface
+ * + the `beforeToolCall` guard chain that EVERY Brigade agent session gets.
+ *
+ * History: Brigade briefly had two divergent session builders — a long-lived
+ * `buildAgent` (TUI + gateway) and the per-turn `runSingleTurn` (`brigade
+ * agent`). They drifted: the interactive path was missing the memory tools
+ * (Primitive #4), the exec-gate + loop-detector (Primitive #3), and the full
+ * tool list — so the surfaces the operator actually used ran a gutted agent
+ * loop with UNGATED bash and no memory.
+ *
+ * That divergence is gone. There is now exactly ONE construction path —
+ * `agents/agent-loop.ts:runSingleTurn` → a single `createAgentSession` — and
+ * every surface funnels through it: `brigade agent` calls it directly, and
+ * the gateway (which `brigade chat` / `brigade connect` are thin WebSocket
+ * clients of) runs it once per turn. These helpers are factored out of
+ * that one path so the tool set + guards stay legible and unit-testable;
+ * per-provider behaviour lives in the stream-fn wrappers (see
+ * `stream-wrappers.ts`), never per-model loop branching. The shape is
+ * deliberately "one loop + provider adapters".
+ */
+import { DEFAULT_SUBAGENT_TIMEOUT_SECONDS } from "./subagent-policy.js";
+import { makeCmdIsmGuard } from "./cmd-ism-guard.js";
+import { makeConfigWriteGuard } from "./config-write-guard.js";
+import { makeExecGate } from "./exec-gate.js";
+import { makePathWriteGuard } from "./path-write-guard.js";
+import { makeUnknownToolGuard } from "./tool-guard.js";
+import { makeToolLoopDetector } from "./tool-loop-detector.js";
+import { wrapOwnerOnlyToolExecution, wrapToolExecutionTimeout } from "./tools/common.js";
+import { createBrigadeTools } from "./tools/registry.js";
+/**
+ * Pi built-in tools Brigade enables by name (vs Pi's default 4).
+ *
+ * `find` is deliberately ABSENT: Pi's builtin shells out to `fd`, whose
+ * `--glob --full-path` mode (used for any pattern containing `/`) matches
+ * nothing on Windows — every `**`-style search silently returned "No files
+ * found" on real trees. Brigade registers its own walker-based `find` (same
+ * name, same schema) via the tool registry instead — see
+ * `tools/find-tool.ts` for the full forensic note.
+ */
+const BUILTIN_TOOL_NAMES = ["read", "write", "edit", "bash", "grep", "ls"];
+/**
+ * Assemble Brigade's full tool surface for a session. Pure + cheap — safe
+ * to call once per session build. `createBrigadeTools` constructs the
+ * memory tools rooted at `workspaceDir`.
+ *
+ * `senderIsOwner` defaults to `true` so all existing CLI / TUI / gateway
+ * callers (which today ARE the workspace owner) keep their behaviour
+ * unchanged — the moment a channel adapter routes a non-owner DM through
+ * the per-turn path it MUST pass `senderIsOwner: false` explicitly so any
+ * `ownerOnly: true` tool refuses the call with `BrigadeToolAuthorizationError`
+ * before its body runs. The wrapper is a no-op for non-ownerOnly tools so
+ * applying it to the full custom-tool list is cheap.
+ */
+export function assembleBrigadeToolset(opts) {
+    const senderIsOwner = opts.senderIsOwner ?? true;
+    const rawCustomTools = createBrigadeTools({
+        workspaceDir: opts.workspaceDir,
+        agentId: opts.agentId,
+        cwd: opts.cwd,
+        // Pass senderIsOwner so tools like send_media that need a
+        // narrower-than-blanket gate (allow same-chat replies for
+        // non-owners, refuse cross-conversation sends) can self-check.
+        senderIsOwner,
+        ...(opts.memoryCapability ? { memoryCapability: opts.memoryCapability } : {}),
+        ...(opts.subagentContext ? { subagentContext: opts.subagentContext } : {}),
+        ...(opts.channelContext ? { channelContext: opts.channelContext } : {}),
+        ...(opts.sessionContext ? { sessionContext: opts.sessionContext } : {}),
+        ...(opts.sandboxedSessionTools !== undefined
+            ? { sandboxedSessionTools: opts.sandboxedSessionTools }
+            : {}),
+        ...(opts.sessionToolAccess !== undefined
+            ? { sessionToolAccess: opts.sessionToolAccess }
+            : {}),
+    });
+    // Wrap every tool — `wrapOwnerOnlyToolExecution` is a no-op for the owner
+    // AND for non-ownerOnly tools, so the cost is one identity-check per tool.
+    // Then ALSO wrap with `wrapToolExecutionTimeout` so a tool whose promise
+    // never resolves (e.g. a runaway file lock, a hung dependency) can't
+    // wedge the agent loop forever — the model gets a `BrigadeToolTimeoutError`
+    // after ~60s and can tell the operator instead of spinning indefinitely.
+    //
+    // EXCEPTION — the spawn tools AWAIT their children by contract
+    // (Primitive #6: result-as-tool-result), and each child may legitimately
+    // run up to its own `timeoutSeconds` (default 300s). The blanket 60s
+    // watchdog was killing every longer fan-out with a misleading "assume
+    // the call hung" while the children kept running and later announced via
+    // the completion bridge (observed in production 2026-06-11). Their budget
+    // is sized per call: the call's own per-child timeout + dispatch/settle
+    // slack — children run concurrently, so the max child budget bounds the
+    // whole call.
+    const wrappedCustomTools = rawCustomTools.map((t) => {
+        const ownerWrapped = wrapOwnerOnlyToolExecution(t, senderIsOwner);
+        if (t.name === "spawn_agent" || t.name === "spawn_agents") {
+            return wrapToolExecutionTimeout(ownerWrapped, undefined, resolveSpawnToolTimeoutMs);
+        }
+        // Image generation runs 1-2 minutes per call (the tool bounds its own
+        // HTTP requests at 150s) — the 60s blanket budget would kill every
+        // legitimate generation.
+        if (t.name === "generate_image") {
+            return wrapToolExecutionTimeout(ownerWrapped, 200_000);
+        }
+        // sessions_send WAITS for the peer's run up to its own
+        // `timeoutSeconds` (default 90s) + a 10s final-text flush poll — the
+        // blanket 60s watchdog killed every legitimate wait mid-flight
+        // (tool_end ✗ while the peer was still working; observed in
+        // production 2026-06-12, same class as the spawn-tool kill). Budget
+        // per call: the call's own wait window + flush + slack.
+        if (t.name === "sessions_send") {
+            return wrapToolExecutionTimeout(ownerWrapped, undefined, resolveSessionsSendTimeoutMs);
+        }
+        // oauth_authorize `await` blocks until the operator clicks the link —
+        // up to its own `waitSeconds` (default 240). The blanket 60s watchdog
+        // would kill that legitimate wait; size the budget from the call's
+        // waitSeconds + slack (same pattern as spawn / sessions_send).
+        if (t.name === "oauth_authorize") {
+            return wrapToolExecutionTimeout(ownerWrapped, undefined, resolveOAuthAuthorizeTimeoutMs);
+        }
+        return wrapToolExecutionTimeout(ownerWrapped);
+    });
+    // Per-job toolsAllow filter (cron). When omitted, every tool flows
+    // through. When supplied, only the named tools survive — both for the
+    // custom-tool array AND for the builtinToolNames allowlist below.
+    const allow = opts.toolsAllow;
+    const customTools = allow === undefined
+        ? wrappedCustomTools
+        : wrappedCustomTools.filter((t) => allow.includes(t.name));
+    const builtinNames = allow === undefined
+        ? [...BUILTIN_TOOL_NAMES]
+        : BUILTIN_TOOL_NAMES.filter((n) => allow.includes(n));
+    const brigadeToolNames = customTools.map((t) => t.name);
+    return {
+        builtinToolNames: builtinNames,
+        brigadeToolNames,
+        enabledToolNames: [...builtinNames, ...brigadeToolNames],
+        customTools,
+        capabilities: {
+            memory: brigadeToolNames.includes("recall_memory"),
+            subAgents: brigadeToolNames.includes("spawn_agent"),
+        },
+    };
+}
+/**
+ * Per-call watchdog budget for the spawn tools. The call's own
+ * `timeoutSeconds` (per child, children run concurrently) bounds the
+ * legitimate runtime; 30s of slack covers dispatch + settle + announce.
+ * Exported for tests.
+ */
+export function resolveSpawnToolTimeoutMs(toolArgs) {
+    const bag = toolArgs;
+    const readPositive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined;
+    // spawn_agent carries a TOP-LEVEL timeoutSeconds; spawn_agents carries it
+    // PER-TASK (tasks[].timeoutSeconds). Children run concurrently, so the
+    // call's legitimate runtime is bounded by the SLOWEST child — take the max
+    // across whichever shape is present. Audit P1 (F4, 2026-06-11): reading
+    // only the top-level field left every spawn_agents call on the 300s
+    // default, so a per-task timeout above 300s was still watchdog-killed at
+    // 330s while the child ran on — the exact bug this budget existed to fix.
+    let perChildSeconds = readPositive(bag?.timeoutSeconds);
+    if (Array.isArray(bag?.tasks)) {
+        for (const task of bag.tasks) {
+            const t = readPositive(task?.timeoutSeconds);
+            if (t !== undefined && (perChildSeconds === undefined || t > perChildSeconds)) {
+                perChildSeconds = t;
+            }
+        }
+    }
+    return (perChildSeconds ?? DEFAULT_SUBAGENT_TIMEOUT_SECONDS) * 1000 + 30_000;
+}
+/**
+ * Per-call watchdog budget for `sessions_send`. The tool's legitimate
+ * runtime = its own wait window (`timeoutSeconds`, default 90s — the
+ * settle race in send.ts) + the 10s final-text flush poll + slack for
+ * dispatch/history reads. Without this, the blanket 60s watchdog killed
+ * every wait longer than a minute while the peer kept working.
+ * Exported for tests.
+ */
+export function resolveSessionsSendTimeoutMs(toolArgs) {
+    const bag = toolArgs;
+    const waitSeconds = typeof bag?.timeoutSeconds === "number" &&
+        Number.isFinite(bag.timeoutSeconds) &&
+        bag.timeoutSeconds > 0
+        ? bag.timeoutSeconds
+        : 90;
+    return waitSeconds * 1000 + 10_000 + 30_000;
+}
+/**
+ * Per-call watchdog budget for `oauth_authorize`. The `await` action blocks
+ * until the operator clicks the authorization link — up to its own
+ * `waitSeconds` (default 240). `start` / `cancel` are fast but harmlessly
+ * inherit the same generous budget. Exported for tests.
+ */
+export function resolveOAuthAuthorizeTimeoutMs(toolArgs) {
+    const bag = toolArgs;
+    const waitSeconds = typeof bag?.waitSeconds === "number" && Number.isFinite(bag.waitSeconds) && bag.waitSeconds > 0
+        ? bag.waitSeconds
+        : 240;
+    return waitSeconds * 1000 + 20_000;
+}
+/**
+ * Compose Brigade's canonical `beforeToolCall` chain. Order, fixed:
+ *
+ *   decodeArgs → unknown-tool guard → path-write guard → cmd-ism guard → loop detector → exec-gate → userHook
+ *
+ * - **decodeArgs** (optional): provider arg cleanup before anything reads them.
+ * - **unknown-tool guard**: refuse hallucinated names + malformed args.
+ * - **path-write guard**: refuse `write`/`edit` to protected roots
+ *   (install dir's `skills/`, `~/.brigade/brigade.json`,
+ *   `~/.brigade/agents/<id>/agent/` internals) and redirect the model to
+ *   the right tool (`manage_skill` / `manage_agent`). Strict gate ahead
+ *   of the loop detector + exec-gate — those are downstream of "is the
+ *   destination even legal".
+ * - **cmd-ism guard**: refuse bash commands that redirect into a reserved
+ *   DOS device name (`2>nul` etc.) — in the POSIX shell those create a
+ *   real `nul` file that Windows then cannot delete.
+ * - **loop detector**: block a model stuck repeating the same call.
+ * - **exec-gate**: bash/exec/shell/sh approval + workdir/env refusal.
+ * - **userHook** (optional): operator policy, only if nothing blocked.
+ *
+ * A thrown guard/hook is converted to a block (fail-closed) so a bug never
+ * lets a destructive call through.
+ */
+export function composeBrigadeBeforeToolCall(opts) {
+    const nameGuard = makeUnknownToolGuard(opts.enabledToolNames);
+    // Thread the SESSION cwd so the guard resolves relative / `~` paths the
+    // SAME way Pi's write/edit/bash tools do (audit P0 F-guards, 2026-06-11).
+    // Without this the guard resolved against the gateway process.cwd() and a
+    // model could reach the real config via `edit({path:"~/.brigade/brigade.json"})`
+    // or a workspace-relative `../brigade.json`.
+    const pathGuard = makePathWriteGuard({ cwd: opts.displayCwd });
+    const cmdIsmGuard = makeCmdIsmGuard();
+    const configWriteGuard = makeConfigWriteGuard();
+    const loopDetector = makeToolLoopDetector({ ctxRef: opts.gateCtxRef });
+    const execGate = makeExecGate({ ctxRef: opts.gateCtxRef, displayCwd: opts.displayCwd });
+    return async (ctx, signal) => {
+        if (opts.decodeArgs) {
+            try {
+                opts.decodeArgs(ctx);
+            }
+            catch {
+                // A decode failure shouldn't block the call — the guards below
+                // still validate; a malformed arg surfaces there.
+            }
+        }
+        const named = await nameGuard(ctx, signal);
+        if (named?.block)
+            return named;
+        const pathBlock = await pathGuard(ctx, signal);
+        if (pathBlock?.block)
+            return pathBlock;
+        const cmdIsm = await cmdIsmGuard(ctx, signal);
+        if (cmdIsm?.block)
+            return cmdIsm;
+        // Config-write boundary BEFORE the exec-gate, so the operator is never
+        // asked to approve a shell mutation of Brigade's own state files.
+        const cfgWrite = await configWriteGuard(ctx, signal);
+        if (cfgWrite?.block)
+            return cfgWrite;
+        const loop = await loopDetector(ctx, signal);
+        if (loop?.block)
+            return loop;
+        const gate = await execGate(ctx, signal);
+        if (gate?.block)
+            return gate;
+        if (!opts.userBeforeHook)
+            return undefined;
+        try {
+            return await opts.userBeforeHook(ctx, signal);
+        }
+        catch (err) {
+            return {
+                block: true,
+                reason: `policy hook error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    };
+}
+//# sourceMappingURL=session-wiring.js.map

package/dist/agents/session-wiring.js.map

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

package/dist/agents/session-write-lock.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Re-export shim for the OS-level cross-process session-file lock.
+ *
+ * Brigade ships ONE implementation at `../sessions/session-write-lock.ts`
+ * (PID-tagged lockfile + stale-stealing). The lock guards both:
+ *   - JSONL session transcript appends (sessions/...)
+ *   - The shared `brigade-store.json` file mutations (this directory's
+ *     `./session-store.ts` + `./session-store-lock.ts`).
+ *
+ * The actual primitive lives one directory over; this re-export keeps the
+ * `agents/` neighbourhood's import paths stable so callers don't reach
+ * across the subsystem boundary unnecessarily.
+ */
+export { acquireSessionWriteLock, type AcquireSessionWriteLockArgs, type SessionWriteLock, } from "../sessions/session-write-lock.js";
+//# sourceMappingURL=session-write-lock.d.ts.map

package/dist/agents/session-write-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-write-lock.d.ts","sourceRoot":"","sources":["../../src/agents/session-write-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACN,uBAAuB,EACvB,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,GACrB,MAAM,mCAAmC,CAAC"}

package/dist/agents/session-write-lock.js

@@ -0,0 +1,15 @@
+/**
+ * Re-export shim for the OS-level cross-process session-file lock.
+ *
+ * Brigade ships ONE implementation at `../sessions/session-write-lock.ts`
+ * (PID-tagged lockfile + stale-stealing). The lock guards both:
+ *   - JSONL session transcript appends (sessions/...)
+ *   - The shared `brigade-store.json` file mutations (this directory's
+ *     `./session-store.ts` + `./session-store-lock.ts`).
+ *
+ * The actual primitive lives one directory over; this re-export keeps the
+ * `agents/` neighbourhood's import paths stable so callers don't reach
+ * across the subsystem boundary unnecessarily.
+ */
+export { acquireSessionWriteLock, } from "../sessions/session-write-lock.js";
+//# sourceMappingURL=session-write-lock.js.map

package/dist/agents/session-write-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-write-lock.js","sourceRoot":"","sources":["../../src/agents/session-write-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACN,uBAAuB,GAGvB,MAAM,mCAAmC,CAAC"}

package/dist/agents/skills/agent-filter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Per-agent skill allowlist resolver.
+ *
+ * Brigade lets the operator pin which skills a specific agent can see, via
+ * `cfg.agents.<id>.skills` (per-agent) and `cfg.agents.defaults.skills`
+ * (fallback for any agent without its own override). The semantics mirror
+ * the reference codebase Brigade is downstream of:
+ *
+ *   - present + non-empty array  → restrict to listed skill names
+ *   - present + empty array `[]` → agent gets NO skills (explicit deny-all)
+ *   - absent                     → inherit from `agents.defaults.skills`
+ *   - both absent                → no restriction; every discovered/enabled
+ *                                  skill is allowed through
+ *
+ * The resolver returns `undefined` to mean "no restriction" — kept separate
+ * from `[]` so a missing field doesn't silently become a deny-all on
+ * round-trip through optional-chains.
+ */
+import type { BrigadeConfig } from "../../config/io.js";
+/**
+ * Resolve the effective skill allowlist for the given agent id.
+ *
+ * Returns:
+ *   - `string[]`  — allowlist of names; `[]` means deny all
+ *   - `undefined` — no restriction (caller should expose every eligible skill)
+ *
+ * Lookup order:
+ *   1. Per-agent override at `cfg.agents.<id>.skills`
+ *   2. Shared default at `cfg.agents.defaults.skills`
+ *   3. Undefined (no restriction)
+ *
+ * `Object.hasOwn` on the per-agent entry is critical: a falsy/empty array
+ * still "wins" over defaults when the operator wrote it explicitly. Reading
+ * via plain access + truthiness would collapse `[]` into "fall through to
+ * defaults", which is exactly the opposite of the operator's intent.
+ */
+export declare function resolveEffectiveAgentSkillFilter(cfg: BrigadeConfig | undefined, agentId: string | undefined): string[] | undefined;
+/**
+ * True when the given skill name should be exposed under the supplied
+ * allowlist. Undefined allowlist = unrestricted (always true).
+ */
+export declare function isSkillAllowedForAgent(skillName: string, allowlist: string[] | undefined): boolean;
+//# sourceMappingURL=agent-filter.d.ts.map

package/dist/agents/skills/agent-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-filter.d.ts","sourceRoot":"","sources":["../../../src/agents/skills/agent-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAmBxD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gCAAgC,CAC/C,GAAG,EAAE,aAAa,GAAG,SAAS,EAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,EAAE,GAAG,SAAS,CAyBtB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EAAE,GAAG,SAAS,GAC7B,OAAO,CAGT"}

package/dist/agents/skills/agent-filter.js

@@ -0,0 +1,89 @@
+/**
+ * Per-agent skill allowlist resolver.
+ *
+ * Brigade lets the operator pin which skills a specific agent can see, via
+ * `cfg.agents.<id>.skills` (per-agent) and `cfg.agents.defaults.skills`
+ * (fallback for any agent without its own override). The semantics mirror
+ * the reference codebase Brigade is downstream of:
+ *
+ *   - present + non-empty array  → restrict to listed skill names
+ *   - present + empty array `[]` → agent gets NO skills (explicit deny-all)
+ *   - absent                     → inherit from `agents.defaults.skills`
+ *   - both absent                → no restriction; every discovered/enabled
+ *                                  skill is allowed through
+ *
+ * The resolver returns `undefined` to mean "no restriction" — kept separate
+ * from `[]` so a missing field doesn't silently become a deny-all on
+ * round-trip through optional-chains.
+ */
+/**
+ * Normalise an unknown value into a clean string[] of skill names. Drops
+ * non-strings, trims whitespace, and removes empties so a hand-edited
+ * `["gh", " ", "", null]` doesn't accidentally widen the allowlist.
+ */
+function normaliseSkillNames(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry !== "string")
+            continue;
+        const trimmed = entry.trim();
+        if (trimmed.length === 0)
+            continue;
+        out.push(trimmed);
+    }
+    return out;
+}
+/**
+ * Resolve the effective skill allowlist for the given agent id.
+ *
+ * Returns:
+ *   - `string[]`  — allowlist of names; `[]` means deny all
+ *   - `undefined` — no restriction (caller should expose every eligible skill)
+ *
+ * Lookup order:
+ *   1. Per-agent override at `cfg.agents.<id>.skills`
+ *   2. Shared default at `cfg.agents.defaults.skills`
+ *   3. Undefined (no restriction)
+ *
+ * `Object.hasOwn` on the per-agent entry is critical: a falsy/empty array
+ * still "wins" over defaults when the operator wrote it explicitly. Reading
+ * via plain access + truthiness would collapse `[]` into "fall through to
+ * defaults", which is exactly the opposite of the operator's intent.
+ */
+export function resolveEffectiveAgentSkillFilter(cfg, agentId) {
+    if (!cfg)
+        return undefined;
+    const agents = cfg.agents;
+    if (!agents)
+        return undefined;
+    const id = (agentId ?? "").trim();
+    if (id) {
+        const entry = agents[id];
+        if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+            const obj = entry;
+            if (Object.hasOwn(obj, "skills")) {
+                return normaliseSkillNames(obj.skills);
+            }
+        }
+    }
+    const defaults = agents.defaults;
+    if (defaults && typeof defaults === "object" && !Array.isArray(defaults)) {
+        const obj = defaults;
+        if (Object.hasOwn(obj, "skills")) {
+            return normaliseSkillNames(obj.skills);
+        }
+    }
+    return undefined;
+}
+/**
+ * True when the given skill name should be exposed under the supplied
+ * allowlist. Undefined allowlist = unrestricted (always true).
+ */
+export function isSkillAllowedForAgent(skillName, allowlist) {
+    if (allowlist === undefined)
+        return true;
+    return allowlist.includes(skillName);
+}
+//# sourceMappingURL=agent-filter.js.map

package/dist/agents/skills/agent-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-filter.js","sourceRoot":"","sources":["../../../src/agents/skills/agent-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,KAAc;IAC1C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;QAC3B,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,SAAS;QACxC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACnC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,gCAAgC,CAC/C,GAA8B,EAC9B,OAA2B;IAE3B,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAC3B,MAAM,MAAM,GAAG,GAAG,CAAC,MAA6C,CAAC;IACjE,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAE9B,MAAM,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAClC,IAAI,EAAE,EAAE,CAAC;QACR,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACjE,MAAM,GAAG,GAAG,KAAgC,CAAC;YAC7C,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC;gBAClC,OAAO,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACxC,CAAC;QACF,CAAC;IACF,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;IACjC,IAAI,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1E,MAAM,GAAG,GAAG,QAAmC,CAAC;QAChD,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC;YAClC,OAAO,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC;IACF,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACrC,SAAiB,EACjB,SAA+B;IAE/B,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACzC,OAAO,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AACtC,CAAC"}

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

@@ -0,0 +1,97 @@
+/**
+ * Skill discovery — the Brigade-native facade over Pi's skill loader.
+ *
+ * Pi (`loadSkillsFromDir`) does the heavy lifting we want to reuse: SKILL.md
+ * discovery (folder-per-skill), frontmatter parse + validation (name matches
+ * dir, lowercase, description present), and the standard agentskills.io
+ * `<available_skills>` XML render (`formatSkillsForPrompt`). Brigade layers on
+ * what Pi structurally lacks: two-root merge (bundled + user workspace),
+ * config enable/disable, and OS/binary/env ELIGIBILITY filtering — see
+ * `eligibility.ts`.
+ *
+ * WHY render here instead of letting Pi inject: Brigade pins the whole system
+ * prompt via `applyPersonaOverrideToSession`, which replaces Pi's prompt-build
+ * hook — so Pi's own skills injection never survives. The agent-loop passes
+ * the rendered block into the assembler, so the assembled persona prompt owns
+ * the `<available_skills>` section directly. The session's Pi resource loader
+ * runs with `noSkills` so nothing is discovered twice.
+ *
+ * Discovery is a synchronous filesystem scan (Pi's loader is sync). At
+ * single-user scale with a handful of skills it's sub-millisecond, so it runs
+ * per turn with no cache — a dropped-in skill is live on the very next turn
+ * (the "drop-a-folder-it-works" contract) with no watcher to wire.
+ */
+import { type EligibilityEnv, type SkillEligibility } from "./eligibility.js";
+/** `~/.brigade/skills/` — managed-dir installs (`skills.install` RPC). */
+export declare const SOURCE_MANAGED = "managed";
+/** `~/.agents/skills/` — operator's personal skills shared across projects. */
+export declare const SOURCE_PERSONAL = "agents-skills-personal";
+/** `<workspace>/.agents/skills/` — project-scoped skills. */
+export declare const SOURCE_PROJECT = "agents-skills-project";
+/** A discovered, eligible skill — lean metadata for status/diagnostics. */
+export interface DiscoveredSkill {
+    name: string;
+    description: string;
+    /** Absolute path to the skill's SKILL.md (or .md) — what the model reads. */
+    filePath: string;
+    /** Which root it came from ("bundled" | "workspace"). */
+    source: string;
+    eligibility: SkillEligibility;
+}
+export interface SkillDiscoveryResult {
+    /** Eligible + enabled skills, sorted by name. */
+    skills: DiscoveredSkill[];
+    /** The rendered `<available_skills>` block, or undefined when none are eligible. */
+    promptBlock: string | undefined;
+    /** Total skills found on disk BEFORE eligibility/enabled filtering. */
+    totalDiscovered: number;
+    /** Loader validation diagnostics (bad frontmatter, name mismatch, …). */
+    diagnostics: unknown[];
+}
+export interface DiscoverSkillsArgs {
+    /** `<workspace>/skills` — user-authored skills (highest precedence). */
+    workspaceSkillsDir: string;
+    /** `<packageRoot>/skills` — shipped starter skills. Omit/missing to skip. */
+    bundledSkillsDir?: string;
+    /** `~/.brigade/skills/` — `skills.install` RPC drop-zone. Above bundled. */
+    managedSkillsDir?: string;
+    /** `~/.agents/skills/` — operator's cross-project personal skills. */
+    personalSkillsDir?: string;
+    /** `<workspace>/.agents/skills/` — project-scoped skills. */
+    projectSkillsDir?: string;
+    /** Extra search roots from config (`skills.paths`). Above bundled, below managed. */
+    extraPaths?: string[];
+    /**
+     * Org-hierarchy-visible roots — OTHER agents' workspace skill dirs the
+     * current agent may see via `skills.orgAccess`. Each becomes a root tagged
+     * `org:<agentId>`, inserted just ABOVE bundled and BELOW every other root
+     * (config paths, managed, personal, project, workspace) so an org-visible
+     * skill can never shadow a skill the operator placed locally, and the
+     * agent's own workspace always wins a name collision. Still subject to the
+     * per-agent allowlist + eligibility (they're shared surface, unlike the
+     * agent's OWN workspace skills which are allowlist-exempt).
+     */
+    orgSkillRoots?: Array<{
+        dir: string;
+        agentId: string;
+    }>;
+    /** Names disabled via config (`skills.entries[name].enabled === false`). */
+    disabledNames?: Set<string>;
+    /**
+     * Per-agent skill allowlist (`cfg.agents.<id>.skills`, falling back to
+     * `cfg.agents.defaults.skills`). `undefined` means "no restriction"; `[]`
+     * means "deny all". When a name isn't in the allowlist, the skill is
+     * dropped from the rendered prompt block but still counted in
+     * `totalDiscovered` so diagnostics can show the operator what was hidden.
+     */
+    skillAllowlist?: string[];
+    /** Injected platform/env for eligibility (tests). Defaults to the live host. */
+    eligibilityCtx?: EligibilityEnv;
+}
+/**
+ * Discover skills across the bundled + workspace roots, merge by name
+ * (workspace wins), drop config-disabled and ineligible ones, and render the
+ * survivors into the `<available_skills>` prompt block.
+ */
+export declare function discoverSkills(args: DiscoverSkillsArgs): SkillDiscoveryResult;
+//# sourceMappingURL=discovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/agents/skills/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAOH,OAAO,EACN,KAAK,cAAc,EAGnB,KAAK,gBAAgB,EACrB,MAAM,kBAAkB,CAAC;AAO1B,0EAA0E;AAC1E,eAAO,MAAM,cAAc,YAAY,CAAC;AACxC,+EAA+E;AAC/E,eAAO,MAAM,eAAe,2BAA2B,CAAC;AACxD,6DAA6D;AAC7D,eAAO,MAAM,cAAc,0BAA0B,CAAC;AAGtD,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,gBAAgB,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACpC,iDAAiD;IACjD,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,oFAAoF;IACpF,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,uEAAuE;IACvE,eAAe,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,WAAW,EAAE,OAAO,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IAClC,wEAAwE;IACxE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,4EAA4E;IAC5E,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,gFAAgF;IAChF,cAAc,CAAC,EAAE,cAAc,CAAC;CAChC;AAkBD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,oBAAoB,CA0E7E"}