opencode-swarm 7.0.0-beta.1 → 7.0.1

package/dist/config/spec-schema.d.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+export declare const ObligationSchema: z.ZodEnum<{
+    MUST: "MUST";
+    SHALL: "SHALL";
+    SHOULD: "SHOULD";
+    MAY: "MAY";
+}>;
+export type Obligation = z.infer<typeof ObligationSchema>;
+export declare const SpecRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    obligation: z.ZodEnum<{
+        MUST: "MUST";
+        SHALL: "SHALL";
+        SHOULD: "SHOULD";
+        MAY: "MAY";
+    }>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type SpecRequirement = z.infer<typeof SpecRequirementSchema>;
+export declare const SpecScenarioSchema: z.ZodObject<{
+    name: z.ZodString;
+    given: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    when: z.ZodArray<z.ZodString>;
+    thenClauses: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SpecScenario = z.infer<typeof SpecScenarioSchema>;
+export declare const SpecSectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    requirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SpecSection = z.infer<typeof SpecSectionSchema>;
+export declare const SwarmSpecSchema: z.ZodObject<{
+    title: z.ZodString;
+    purpose: z.ZodString;
+    sections: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        requirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            obligation: z.ZodEnum<{
+                MUST: "MUST";
+                SHALL: "SHALL";
+                SHOULD: "SHOULD";
+                MAY: "MAY";
+            }>;
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SwarmSpec = z.infer<typeof SwarmSpecSchema>;
+export declare const SpecDeltaSchema: z.ZodObject<{
+    added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    modified: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SpecDelta = z.infer<typeof SpecDeltaSchema>;
+export declare const DeltaSpecSchema: z.ZodType<SwarmSpec | SpecDelta>;
+export type DeltaSpec = z.infer<typeof DeltaSpecSchema>;
+interface ValidationIssue {
+    line: number;
+    message: string;
+}
+interface SpecContentValidationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+}
+/**
+ * Validate raw markdown spec content using regex patterns.
+ * Checks for:
+ * - FR-### requirement IDs
+ * - Obligation keywords (MUST, SHALL, SHOULD, MAY)
+ * - Section headers (## Section Name)
+ *
+ * @param content - Raw markdown string to validate
+ * @returns Validation result with issues array
+ */
+export declare function validateSpecContent(content: string): SpecContentValidationResult;
+export {};

package/dist/context/role-filter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Role-Scoped Context Injection Filter
+ * Filters context entries based on [FOR: ...] tags for role-based context delivery.
+ */
+/**
+ * Context entry with role metadata
+ */
+export interface ContextEntry {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    name?: string;
+}
+/**
+ * Filter context entries based on target role and [FOR: ...] tags.
+ *
+ * Filtering rules:
+ * - Entries with [FOR: ALL] are included for all agents
+ * - Entries with [FOR: specific_agents] are included only for named agents
+ * - Entries without [FOR: ...] tag are included for all agents (backward compatibility)
+ * - System prompts, delegation envelopes, plan content, and knowledge entries are never filtered
+ *
+ * @param entries - Array of context entries to filter
+ * @param targetRole - The target agent role to filter for
+ * @param directory - Optional project directory for metrics logging (defaults to cwd)
+ * @returns Filtered array of context entries
+ */
+export declare function filterByRole(entries: ContextEntry[], targetRole: string, directory?: string): ContextEntry[];

package/dist/context/zone-classifier.d.ts

@@ -0,0 +1,17 @@
+export type FileZone = 'production' | 'test' | 'config' | 'generated' | 'docs' | 'build';
+export interface ZoneClassification {
+    filePath: string;
+    zone: FileZone;
+    confidence: 'high' | 'medium';
+    reason: string;
+}
+export interface ZonePolicy {
+    qaDepth: 'full' | 'standard' | 'light' | 'skip';
+    lintRequired: boolean;
+    testRequired: boolean;
+    reviewRequired: boolean;
+    securityReviewRequired: boolean;
+}
+export declare function classifyFile(filePath: string): ZoneClassification;
+export declare function classifyFiles(filePaths: string[]): ZoneClassification[];
+export declare function getZonePolicy(zone: FileZone): ZonePolicy;

package/dist/council/__tests__/council-evidence-writer.adversarial.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adversarial security tests for safeAssignOwnProps.
+ * Tests prototype pollution attacks, constructor pollution, array smuggling,
+ * and boundary violations.
+ */
+export {};

package/dist/council/council-advisory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Work Complete Council — advisory routing helper.
+ *
+ * Purpose:
+ *   Routes a CouncilSynthesis (unifiedFeedbackMd + verdict metadata) into the
+ *   architect's non-blocking advisory queue (`session.pendingAdvisoryMessages`).
+ *   The guardrails `messagesTransform` hook drains that queue into an
+ *   [ADVISORIES] block prepended to the architect's first SYSTEM message on
+ *   the next turn.
+ *
+ * Runtime call site:
+ *   `src/tools/convene-council.ts` invokes this helper after writing evidence,
+ *   guarded by `ctx?.sessionID` and `getAgentSession`. Missing session, missing
+ *   sessionID, or any thrown error silently skip — the advisory is never
+ *   critical-path. The helper is also re-exported for direct use by any future
+ *   caller that wants to push synthesis output into an advisory queue.
+ *
+ * Scope and known limitation:
+ *   The advisory queue is READ by the architect session on its next turn (self
+ *   echo). It is NOT a programmatic architect→coder delivery channel — the
+ *   architect still has to render `unifiedFeedbackMd` into the coder's
+ *   delegation payload manually, per the prompt's four-phase workflow. A
+ *   dedicated architect→coder advisory primitive is future work.
+ *
+ * Dedup semantics:
+ *   Dedup key is `council:${taskId}:${roundNumber}`. If the queue already
+ *   contains a string whose content includes that key, the push is a no-op.
+ *   Different rounds or tasks push distinct entries.
+ *
+ * Blocking signal (metadata only):
+ *   - REJECT  → header declares `blocking=true`. Council vetoed the candidate.
+ *   - CONCERNS→ `blocking=false`. Architect should weigh fixes but is not vetoed.
+ *   - APPROVE → `blocking=false`. Helper skips push entirely when there are no
+ *               advisoryFindings (nothing useful to surface).
+ */
+import type { AgentSessionState } from '../state';
+import type { CouncilSynthesis } from './types';
+/**
+ * Push a CouncilSynthesis into the given session's advisory queue so the
+ * architect will see it as an [ADVISORIES] block on the next messagesTransform.
+ *
+ * Idempotent per (taskId, roundNumber): repeated calls with the same key
+ * leave the queue unchanged. Safe to call on APPROVE — it is a no-op when
+ * there are no advisoryFindings.
+ */
+export declare function pushCouncilAdvisory(session: Pick<AgentSessionState, 'pendingAdvisoryMessages'>, synthesis: CouncilSynthesis): void;

package/dist/council/council-evidence-writer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Work Complete Council — evidence writer.
+ *
+ * Stamps the council synthesis result into `.swarm/evidence/{taskId}.json`
+ * under `gates.council`, matching the shape other gate writers use and the
+ * shape that `check_gate_status` and `update_task_status` consume (they read
+ * `evidence.gates[gateName]`). Council-specific fields (verdict, vetoedBy,
+ * roundNumber, allCriteriaMet) are stored alongside the standard GateInfo
+ * fields (sessionId, timestamp, agent); existing consumers only check
+ * `gates.council != null`, so the extras are compatible.
+ *
+ * Existing fields in the evidence file — top-level keys AND other `gates[*]`
+ * entries — are preserved across the write. The raw taskId is used as the
+ * filename; defense-in-depth regex validation rejects malformed IDs before
+ * any filesystem op.
+ */
+import type { CouncilSynthesis } from './types';
+export declare function writeCouncilEvidence(workingDir: string, synthesis: CouncilSynthesis): void;

package/dist/council/council-service.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Work Complete Council — pure synthesis service.
+ *
+ * Given the verdicts of council members (critic, reviewer, sme, test_engineer),
+ * compute the overall verdict, classify findings, detect conflicts, and build a
+ * single unified feedback document for the coder.
+ *
+ * No I/O — fully unit-testable with mock inputs. All file reads/writes happen in
+ * sibling modules (criteria-store, council-evidence-writer).
+ */
+import type { CouncilConfig, CouncilCriteria, CouncilMemberVerdict, CouncilSynthesis, PhaseCouncilSynthesis } from './types';
+export declare function synthesizeCouncilVerdicts(taskId: string, swarmId: string, verdicts: CouncilMemberVerdict[], criteria: CouncilCriteria | null, roundNumber: number, config?: Partial<CouncilConfig>): CouncilSynthesis;
+/**
+ * Synthesize phase-level council verdicts into a PhaseCouncilSynthesis.
+ * Reuses the same veto detection, conflict detection, and finding
+ * classification logic as per-task council, but scoped to a phase number.
+ *
+ * Evidence is written to .swarm/evidence/{phase}/phase-council.json relative
+ * to workingDir (or cwd).
+ */
+export declare function synthesizePhaseCouncilAdvisory(phaseNumber: number, phaseSummary: string, verdicts: CouncilMemberVerdict[], roundNumber: number, config?: Partial<CouncilConfig>, workingDir?: string): PhaseCouncilSynthesis;

package/dist/council/criteria-store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Work Complete Council — pre-declaration criteria writer/reader.
+ *
+ * Stores acceptance criteria under .swarm/council/{safeId}.json so they can be
+ * read back during council evaluation.
+ */
+import type { CouncilCriteria, CouncilCriteriaItem } from './types';
+export declare function writeCriteria(workingDir: string, taskId: string, criteria: CouncilCriteriaItem[]): void;
+export declare function readCriteria(workingDir: string, taskId: string): CouncilCriteria | null;

package/dist/council/disagreement-detector.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Disagreement detection for the General Council Mode.
+ *
+ * Pure function module — no I/O, no HTTP, deterministic. Takes Round 1 member
+ * responses, returns the set of factual disagreements that should be routed
+ * back to disputing members for Round 2 reconciliation.
+ *
+ * Two-pass detection:
+ *   Pass 1 — Explicit linguistic markers ("I disagree with", "unlike", etc.)
+ *   Pass 2 — Claim divergence heuristic (mutually exclusive recommendations)
+ *
+ * NSED design note (arXiv:2601.16863): only the disagreement delta is fed
+ * forward to Round 2, not full Round 1 context — mirrors the "semantic forget
+ * gate" selective-retention insight and keeps prompt sizes bounded.
+ */
+import type { GeneralCouncilDisagreement, GeneralCouncilMemberResponse } from './general-council-types.js';
+/**
+ * Detect disagreements across Round 1 member responses.
+ *
+ * Returns at most MAX_DISAGREEMENTS items, deduplicated by topic. Pure function:
+ * given the same input, produces the same output. Empty inputs and missing
+ * fields are handled without throwing.
+ */
+export declare function detectDisagreements(responses: GeneralCouncilMemberResponse[]): GeneralCouncilDisagreement[];

package/dist/council/general-council-advisory.d.ts

@@ -0,0 +1,29 @@
+/**
+ * General Council Mode — advisory routing helper.
+ *
+ * Sibling to ./council-advisory.ts (which is hard-typed to CouncilSynthesis
+ * for the verdict-based Work Complete Council). This helper accepts a
+ * GeneralCouncilResult and renders an advisory body the architect will see
+ * on its next turn via the standard pendingAdvisoryMessages → ADVISORIES
+ * messagesTransform flow.
+ *
+ * Design choices:
+ *   - No dedup. The general council is user-triggered (`/swarm council ...`);
+ *     a user asking the same question twice expects two advisories. The
+ *     QA-council dedup-by-taskId-and-round semantic doesn't apply here —
+ *     general council has no taskId.
+ *   - No "blocking" header. The general council is advisory by definition.
+ *     Use a clear visual marker so the architect distinguishes it from the
+ *     QA council's blocking advisories.
+ */
+import type { AgentSessionState } from '../state';
+import type { GeneralCouncilResult } from './general-council-types.js';
+/**
+ * Push a GeneralCouncilResult into the architect's advisory queue. The body
+ * is the synthesis markdown plus the moderator output when present.
+ *
+ * Safe to call: missing session or empty advisory body silently skips.
+ * Always idempotent at the architect-prompt level (no duplicate-suppression
+ * here — see header comment for rationale).
+ */
+export declare function pushGeneralCouncilAdvisory(session: Pick<AgentSessionState, 'pendingAdvisoryMessages'>, result: GeneralCouncilResult): void;

package/dist/council/general-council-service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * General Council Mode — pure synthesis service.
+ *
+ * No I/O, no HTTP. Takes completed member responses for all rounds and
+ * produces the final `GeneralCouncilResult`. Mirrors the design of
+ * `./council-service.ts` (synthesizeCouncilVerdicts).
+ *
+ * Quadratic Voting (NSED arXiv:2601.16863): consensus claims are weighted by
+ * member confidence rather than counted by headcount. A claim is a consensus
+ * point only when its weighted agreement exceeds 0.6 across members.
+ *
+ * MAINTAIN/CONCEDE/NUANCE protocol (ConfMAD): a Round 2 response with the
+ * CONCEDE keyword on a topic resolves the corresponding Round 1 disagreement;
+ * MAINTAIN leaves it persisting; NUANCE marks it persisting-with-boundary.
+ */
+import type { GeneralCouncilDeliberationResponse, GeneralCouncilMemberResponse, GeneralCouncilResult } from './general-council-types.js';
+/**
+ * Pure synthesis. Given completed member responses, produces the final
+ * `GeneralCouncilResult` (without `moderatorOutput` — moderator is invoked
+ * by the architect after this returns and populated separately).
+ */
+export declare function synthesizeGeneralCouncil(question: string, mode: 'general' | 'spec_review', round1Responses: GeneralCouncilMemberResponse[], round2Responses: GeneralCouncilDeliberationResponse[]): GeneralCouncilResult;

package/dist/council/general-council-types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * General Council Mode — data contracts.
+ *
+ * Distinct from the Work Complete Council (`./types.ts`). The general council
+ * is an advisory deliberation system: user-selected models each independently
+ * web-search and answer a question, then optionally engage in a single
+ * disagreement-targeted reconciliation round. A moderator agent synthesizes
+ * the final user-facing answer.
+ *
+ * No business logic, no I/O. Only types, interfaces, and defaults.
+ */
+export type GeneralCouncilMemberRole = 'generalist' | 'skeptic' | 'domain_expert' | 'devil_advocate' | 'synthesizer';
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    query: string;
+}
+export interface GeneralCouncilMemberConfig {
+    memberId: string;
+    model: string;
+    role: GeneralCouncilMemberRole;
+    persona?: string;
+}
+export interface GeneralCouncilMemberResponse {
+    memberId: string;
+    model: string;
+    role: GeneralCouncilMemberRole;
+    response: string;
+    sources: WebSearchResult[];
+    searchQueries: string[];
+    /** Self-reported confidence (0.0–1.0) — feeds Quadratic Voting weighted consensus */
+    confidence: number;
+    areasOfUncertainty: string[];
+    durationMs: number;
+}
+export interface GeneralCouncilDisagreementPosition {
+    memberId: string;
+    claim: string;
+    evidence: string;
+}
+export interface GeneralCouncilDisagreement {
+    topic: string;
+    positions: GeneralCouncilDisagreementPosition[];
+}
+export interface GeneralCouncilDeliberationResponse extends GeneralCouncilMemberResponse {
+    /** Topics the member addressed in Round 2 (subset of Round 1 disagreements). */
+    disagreementTopics: string[];
+}
+export interface GeneralCouncilResult {
+    question: string;
+    mode: 'general' | 'spec_review';
+    round1Responses: GeneralCouncilMemberResponse[];
+    disagreements: GeneralCouncilDisagreement[];
+    round2Responses: GeneralCouncilDeliberationResponse[];
+    /** Structural synthesis markdown (sections: consensus / disagreements / sources). */
+    synthesis: string;
+    consensusPoints: string[];
+    persistingDisagreements: string[];
+    allSources: WebSearchResult[];
+    /**
+     * Final moderator output (when council.general.moderator: true and a moderator
+     * model is configured). Populated by `convene-general-council.ts` after the
+     * architect delegates the moderator prompt to `council_moderator`. Undefined
+     * when no moderator pass is configured.
+     */
+    moderatorOutput?: string;
+    timestamp: string;
+}
+/**
+ * Config shape — matched in schema.ts via GeneralCouncilConfigSchema.
+ *
+ * `enabled` defaults to false (feature gate). The moderator pass requires
+ * a configured `moderatorModel`; when set, the architect delegates the
+ * moderator prompt produced by `convene_general_council` to the dedicated
+ * `council_moderator` agent (no `web_search` access — synthesis only).
+ */
+export interface GeneralCouncilConfig {
+    enabled: boolean;
+    searchProvider: 'tavily' | 'brave';
+    /**
+     * Optional API key. When omitted, falls back to `TAVILY_API_KEY` or
+     * `BRAVE_SEARCH_API_KEY` env vars depending on `searchProvider`.
+     */
+    searchApiKey?: string;
+    members: GeneralCouncilMemberConfig[];
+    /** Named groups of members for `/swarm council --preset <name>`. */
+    presets: Record<string, GeneralCouncilMemberConfig[]>;
+    /** When true, after Round 1 the architect routes disagreements back to disputing members. */
+    deliberate: boolean;
+    /** When true, the architect delegates a moderator pass to `council_moderator` after synthesis. */
+    moderator: boolean;
+    /** Required when `moderator: true` — model identifier for the council_moderator delegation. */
+    moderatorModel?: string;
+    /** Hard cap on results returned per member per search call (1–20). Defaults to 5. */
+    maxSourcesPerMember: number;
+}
+export declare const GENERAL_COUNCIL_DEFAULTS: GeneralCouncilConfig;

package/dist/council/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Work Complete Council — data contracts.
+ *
+ * Flat, stable schema — no nested generics. Designed for reliable LLM output.
+ * No business logic, no I/O. Only types, interfaces, and defaults.
+ */
+export type CouncilVerdict = 'APPROVE' | 'CONCERNS' | 'REJECT';
+export type CouncilFindingSeverity = 'HIGH' | 'MEDIUM' | 'LOW';
+export type CouncilFindingCategory = 'logic' | 'edge_case' | 'error_handling' | 'spec_compliance' | 'security' | 'maintainability' | 'naming' | 'domain' | 'test_gap' | 'test_quality' | 'mutation_gap' | 'adversarial_gap' | 'slop_pattern' | 'hallucinated_api' | 'lazy_abstraction' | 'cargo_cult' | 'spec_drift' | 'other';
+export type CouncilAgent = 'critic' | 'reviewer' | 'sme' | 'test_engineer' | 'explorer';
+export interface CouncilFinding {
+    severity: CouncilFindingSeverity;
+    category: CouncilFindingCategory;
+    /** e.g. "src/tools/convene-council.ts:42" */
+    location: string;
+    /** Human-readable explanation */
+    detail: string;
+    /** Concrete quote or line reference */
+    evidence: string;
+}
+export interface CouncilMemberVerdict {
+    agent: CouncilAgent;
+    verdict: CouncilVerdict;
+    /** Confidence 0.0–1.0 */
+    confidence: number;
+    findings: CouncilFinding[];
+    /** Criteria IDs from pre-declaration (e.g. ["C1","C3"]) */
+    criteriaAssessed: string[];
+    /** Criteria IDs that failed */
+    criteriaUnmet: string[];
+    durationMs: number;
+}
+export interface CouncilSynthesis {
+    taskId: string;
+    swarmId: string;
+    /** ISO 8601 */
+    timestamp: string;
+    overallVerdict: CouncilVerdict;
+    vetoedBy: CouncilAgent[] | null;
+    memberVerdicts: CouncilMemberVerdict[];
+    unresolvedConflicts: string[];
+    /** Severity HIGH + MEDIUM from veto members */
+    requiredFixes: CouncilFinding[];
+    /** Severity LOW or from non-veto members */
+    advisoryFindings: CouncilFinding[];
+    /** Single markdown document sent to coder */
+    unifiedFeedbackMd: string;
+    /** 1-indexed */
+    roundNumber: number;
+    allCriteriaMet: boolean;
+    /** Distinct council members that produced verdicts (deduplicated count). */
+    quorumSize: number;
+    /** true when called with an empty verdicts array — the APPROVE is vacuous */
+    emptyVerdictsWarning?: boolean;
+}
+/**
+ * Phase-level council synthesis result.
+ * Distinct from CouncilSynthesis — scoped to a phase number
+ * rather than a task ID, and targets .swarm/evidence/{phase}/phase-council.json
+ * for evidence-file attestation.
+ */
+export interface PhaseCouncilSynthesis {
+    phaseNumber: number;
+    /** Always 'phase' — distinguishes from task-level council */
+    scope: 'phase';
+    /** ISO 8601 */
+    timestamp: string;
+    overallVerdict: CouncilVerdict;
+    vetoedBy: CouncilAgent[] | null;
+    memberVerdicts: CouncilMemberVerdict[];
+    unresolvedConflicts: string[];
+    /** Severity HIGH + MEDIUM from veto members */
+    requiredFixes: CouncilFinding[];
+    /** Severity LOW or from non-veto members */
+    advisoryFindings: CouncilFinding[];
+    /** Phase-level advisory notes for the architect */
+    advisoryNotes: string[];
+    /** Single markdown document for phase review */
+    unifiedFeedbackMd: string;
+    /** 1-indexed */
+    roundNumber: number;
+    allCriteriaMet: boolean;
+    /** Distinct council members that produced verdicts */
+    quorumSize: number;
+    /** Path where evidence was written, e.g. .swarm/evidence/1/phase-council.json */
+    evidencePath: string;
+    /** Summary of the phase being reviewed */
+    phaseSummary?: string;
+}
+export interface CouncilCriteriaItem {
+    id: string;
+    description: string;
+    mandatory: boolean;
+}
+export interface CouncilCriteria {
+    taskId: string;
+    criteria: CouncilCriteriaItem[];
+    /** ISO 8601 */
+    declaredAt: string;
+}
+/** Config shape — matched in schema.ts via CouncilConfigSchema. */
+export interface CouncilConfig {
+    enabled: boolean;
+    /** Default 3 */
+    maxRounds: number;
+    /** Default 30_000 */
+    parallelTimeoutMs: number;
+    /** Default true — any REJECT blocks */
+    vetoPriority: boolean;
+    /** Default false — when true, submit_council_verdicts rejects unless all 5 member verdicts are provided */
+    requireAllMembers: boolean;
+    /** Default 3 — minimum distinct council members required for quorum. requireAllMembers: true overrides this to 5. */
+    minimumMembers: number;
+    /**
+     * Optional webhook URL or handler name for auto-escalation when maxRounds is
+     * reached without APPROVE. Reserved for forward compatibility — NOT yet
+     * implemented. Currently, maxRounds exhaustion surfaces a user-facing message
+     * via `buildUnifiedFeedbackMd` in council-service.ts (see the "Escalate to
+     * user" block), and the architect must relay it to the user. Future wiring
+     * options: critic_oversight agent, HTTP webhook, or configurable handler.
+     */
+    escalateOnMaxRounds?: string;
+    /** Default true — CONCERNS verdict at phase-level council does NOT block completion (advisory). Set false to make CONCERNS block like REJECT. */
+    phaseConcernsAllowComplete: boolean;
+}
+export declare const COUNCIL_DEFAULTS: CouncilConfig;

package/dist/council/web-search-provider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Web search provider abstraction for the General Council Mode.
+ *
+ * Two concrete providers (Tavily, Brave) plus a factory that selects one
+ * based on `GeneralCouncilConfig.searchProvider`. Pure HTTP layer — no tool
+ * wiring or prompt rendering. Uses the native `fetch` API (Bun-compatible);
+ * no external HTTP libraries.
+ *
+ * Errors are surfaced as typed exceptions:
+ *   - WebSearchConfigError — missing API key (factory)
+ *   - WebSearchError       — HTTP failure (4xx/5xx, network, timeout)
+ * Malformed but successful responses produce an empty result array, never throw.
+ */
+import type { GeneralCouncilConfig, WebSearchResult } from './general-council-types.js';
+export declare class WebSearchError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class WebSearchConfigError extends Error {
+    constructor(message: string);
+}
+export interface WebSearchProvider {
+    search(query: string, maxResults: number): Promise<WebSearchResult[]>;
+}
+export declare class TavilyProvider implements WebSearchProvider {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    search(query: string, maxResults: number): Promise<WebSearchResult[]>;
+}
+export declare class BraveProvider implements WebSearchProvider {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    search(query: string, maxResults: number): Promise<WebSearchResult[]>;
+}
+export declare function createWebSearchProvider(config: GeneralCouncilConfig): WebSearchProvider;

package/dist/db/global-db.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Global SQLite database singleton for opencode-swarm.
+ *
+ * Owns `global-rules.db` in the platform config directory. Stores cross-project
+ * rules and agent prompt sections. Per-project QA gate profiles live in the
+ * project DB (see `./project-db.ts`), not here.
+ */
+import type { Database } from 'bun:sqlite';
+/**
+ * Run all pending migrations on the provided database.
+ * Idempotent: existing migrations are not re-applied.
+ */
+export declare function runGlobalMigrations(db: Database): void;
+/**
+ * Return the process-wide singleton global database, creating it on first call.
+ * Directory is created if it does not exist. WAL mode is enabled immediately.
+ */
+export declare function getGlobalDb(): Database;
+/**
+ * Close and clear the global database singleton. Test-only.
+ */
+export declare function closeGlobalDb(): void;

package/dist/db/global-db.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for src/db/global-db.ts.
+ *
+ * Uses XDG_CONFIG_HOME override so getPlatformConfigDir() resolves into
+ * a temp directory (Linux only — this test suite is gated accordingly).
+ */
+export {};

package/dist/db/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Barrel re-exports for the opencode-swarm SQLite database layer.
+ *
+ * - `global-db`: process-wide singleton for cross-project rules and
+ *   agent prompt sections (`global-rules.db` in the platform config dir).
+ * - `project-db`: per-project database cache (`.swarm/swarm.db`), keyed by
+ *   normalized directory path.
+ * - `qa-gate-profile`: service layer for per-plan QA gate profiles stored
+ *   in the project DB.
+ */
+export { closeGlobalDb, getGlobalDb, runGlobalMigrations, } from './global-db.js';
+export { closeAllProjectDbs, closeProjectDb, getProjectDb, projectDbExists, projectDbPath, runProjectMigrations, } from './project-db.js';
+export { computeProfileHash, DEFAULT_QA_GATES, getEffectiveGates, getOrCreateProfile, getProfile, lockProfile, type QaGateProfile, type QaGates, setGates, } from './qa-gate-profile.js';