monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/config-adapter.js

@@ -0,0 +1,186 @@
+/**
+ * Configuration Adapter
+ * Converts between SystemConfig and MonomindConfig types
+ */
+/**
+ * Convert SystemConfig to MonomindConfig (CLI-specific format)
+ */
+export function systemConfigToMonomindConfig(systemConfig) {
+    return {
+        version: '3.0.0',
+        projectRoot: systemConfig.orchestrator?.session?.dataDir || process.cwd(),
+        // Agent configuration
+        agents: {
+            defaultType: 'coder',
+            autoSpawn: false, // Not in SystemConfig
+            maxConcurrent: systemConfig.orchestrator?.lifecycle?.maxConcurrentAgents ?? 15,
+            timeout: systemConfig.orchestrator?.lifecycle?.spawnTimeout ?? 300000,
+            providers: [],
+        },
+        // Swarm configuration
+        swarm: {
+            topology: normalizeTopology(systemConfig.swarm?.topology),
+            maxAgents: systemConfig.swarm?.maxAgents ?? 15,
+            autoScale: systemConfig.swarm?.autoScale?.enabled ?? false,
+            coordinationStrategy: systemConfig.swarm?.coordination?.consensusRequired ? 'consensus' : 'leader',
+            healthCheckInterval: systemConfig.swarm?.coordination?.timeoutMs ?? 10000,
+        },
+        // Memory configuration
+        memory: {
+            backend: normalizeMemoryBackend(systemConfig.memory?.type),
+            persistPath: systemConfig.memory?.path || './data/memory',
+            cacheSize: systemConfig.memory?.maxSize ?? 1000000,
+            enableHNSW: systemConfig.memory?.agentdb?.indexType === 'hnsw',
+            vectorDimension: systemConfig.memory?.agentdb?.dimensions ?? 384, // Match all-MiniLM-L6-v2 output (#1395 Bug 5)
+        },
+        // MCP configuration
+        mcp: {
+            serverHost: systemConfig.mcp?.transport?.host || 'localhost',
+            serverPort: systemConfig.mcp?.transport?.port ?? 3000,
+            autoStart: false, // Not in SystemConfig
+            transportType: systemConfig.mcp?.transport?.type || 'stdio',
+            tools: [], // Not in SystemConfig
+        },
+        // CLI preferences
+        cli: {
+            colorOutput: true,
+            interactive: true,
+            verbosity: 'normal',
+            outputFormat: 'text',
+            progressStyle: 'spinner',
+        },
+        // Hooks configuration
+        hooks: {
+            enabled: false,
+            autoExecute: false,
+            hooks: [],
+        },
+    };
+}
+/**
+ * Convert MonomindConfig to SystemConfig
+ */
+export function configToSystemConfig(config) {
+    return {
+        orchestrator: {
+            lifecycle: {
+                maxConcurrentAgents: config.agents.maxConcurrent,
+                spawnTimeout: config.agents.timeout,
+                terminateTimeout: 10000,
+                maxSpawnRetries: 3,
+            },
+            session: {
+                dataDir: config.projectRoot,
+                persistSessions: true,
+                sessionRetentionMs: 3600000,
+            },
+            health: {
+                checkInterval: config.swarm.healthCheckInterval,
+                historyLimit: 100,
+                degradedThreshold: 1,
+                unhealthyThreshold: 2,
+            },
+        },
+        swarm: {
+            topology: denormalizeTopology(config.swarm.topology),
+            maxAgents: config.swarm.maxAgents,
+            autoScale: {
+                enabled: config.swarm.autoScale,
+                minAgents: 1,
+                maxAgents: config.swarm.maxAgents,
+                scaleUpThreshold: 0.8,
+                scaleDownThreshold: 0.3,
+            },
+            coordination: {
+                consensusRequired: config.swarm.coordinationStrategy === 'consensus',
+                timeoutMs: config.swarm.healthCheckInterval,
+                retryPolicy: {
+                    maxRetries: 3,
+                    backoffMs: 500,
+                },
+            },
+            communication: {
+                protocol: 'events',
+                batchSize: 10,
+                flushIntervalMs: 100,
+            },
+        },
+        memory: {
+            type: denormalizeMemoryBackend(config.memory.backend),
+            path: config.memory.persistPath,
+            maxSize: config.memory.cacheSize,
+            agentdb: {
+                dimensions: config.memory.vectorDimension,
+                indexType: config.memory.enableHNSW ? 'hnsw' : 'flat',
+                efConstruction: 200,
+                m: 16,
+                quantization: 'none',
+            },
+        },
+        mcp: {
+            name: 'monomind',
+            version: '3.0.0',
+            transport: {
+                type: config.mcp.transportType,
+                host: config.mcp.serverHost,
+                port: config.mcp.serverPort,
+            },
+            capabilities: {
+                tools: true,
+                resources: true,
+                prompts: true,
+                logging: true,
+            },
+        },
+    };
+}
+/**
+ * Normalize topology from SystemConfig to MonomindConfig
+ */
+function normalizeTopology(topology) {
+    switch (topology) {
+        case 'hierarchical':
+        case 'mesh':
+        case 'ring':
+        case 'star':
+        case 'hybrid':
+        case 'hierarchical-mesh':
+            return topology;
+        case 'adaptive':
+            return 'hybrid';
+        default:
+            return 'hierarchical';
+    }
+}
+/**
+ * Denormalize topology from MonomindConfig to SystemConfig
+ */
+function denormalizeTopology(topology) {
+    if (topology === 'hybrid') {
+        return 'hierarchical-mesh';
+    }
+    return topology;
+}
+/**
+ * Normalize memory backend from SystemConfig to MonomindConfig
+ */
+function normalizeMemoryBackend(backend) {
+    switch (backend) {
+        case 'memory':
+        case 'sqlite':
+        case 'agentdb':
+        case 'hybrid':
+            return backend;
+        case 'redis':
+            return 'memory'; // Redis maps to memory for CLI purposes
+        default:
+            return 'hybrid';
+    }
+}
+/**
+ * Denormalize memory backend from MonomindConfig to SystemConfig
+ */
+function denormalizeMemoryBackend(backend) {
+    return backend;
+}
+//# sourceMappingURL=config-adapter.js.map

package/packages/@monomind/cli/dist/src/consensus/audit-writer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * AuditWriter (Task 36)
+ *
+ * Append-only JSONL storage for consensus audit records and individual votes.
+ */
+import type { ConsensusAuditRecord, ConsensusProtocol } from '../../../../@monoes/shared/src/types/consensus-audit.js';
+/** Input for recording a consensus decision */
+export interface RecordInput {
+    decisionId: string;
+    swarmId: string;
+    protocol: ConsensusProtocol;
+    topic: string;
+    decision: unknown;
+    votes: Array<{
+        agentId: string;
+        agentSlug: string;
+        vote: unknown;
+        votedAt: string;
+    }>;
+    quorumRequired: number;
+    quorumThreshold: number;
+    round: number;
+    startedAt: string;
+    completedAt: string;
+    sessionSecret: string;
+}
+export declare class AuditWriter {
+    private readonly auditPath;
+    private readonly votesPath;
+    constructor(dataDir: string);
+    /**
+     * Record a consensus decision: sign all votes, compute quorum proof,
+     * and persist both the audit record and individual votes to JSONL.
+     */
+    record(input: RecordInput): ConsensusAuditRecord;
+    /**
+     * List consensus decisions, optionally filtered by swarmId.
+     */
+    listDecisions(swarmId?: string, limit?: number): ConsensusAuditRecord[];
+    /**
+     * Re-verify all vote signatures in a decision.
+     */
+    verifyDecision(decisionId: string, sessionSecret: string): {
+        valid: boolean;
+        invalidVotes: string[];
+    };
+    private appendLine;
+    private readLines;
+}
+//# sourceMappingURL=audit-writer.d.ts.map

package/packages/@monomind/cli/dist/src/consensus/audit-writer.js

@@ -0,0 +1,142 @@
+/**
+ * AuditWriter (Task 36)
+ *
+ * Append-only JSONL storage for consensus audit records and individual votes.
+ */
+import { appendFileSync, readFileSync, existsSync, mkdirSync, statSync } from 'fs';
+import { createHmac, timingSafeEqual } from 'crypto';
+import { dirname, join, resolve, relative } from 'path';
+import { parseJsonl } from '../utils/parse-jsonl.js';
+import { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export class AuditWriter {
+    auditPath;
+    votesPath;
+    constructor(dataDir) {
+        const resolved = resolve(dataDir);
+        const cwd = process.cwd();
+        const rel = relative(cwd, resolved);
+        if (rel.startsWith('..') || resolve(rel) === resolve('/')) {
+            throw new Error(`AuditWriter: dataDir must be within the working directory: ${dataDir}`);
+        }
+        if (!existsSync(resolved)) {
+            mkdirSync(resolved, { recursive: true });
+        }
+        this.auditPath = join(resolved, 'consensus-audit.jsonl');
+        this.votesPath = join(resolved, 'consensus-votes.jsonl');
+    }
+    /**
+     * Record a consensus decision: sign all votes, compute quorum proof,
+     * and persist both the audit record and individual votes to JSONL.
+     */
+    record(input) {
+        const key = deriveSigningKey(input.swarmId, input.sessionSecret);
+        // Sign each vote
+        const signedVotes = input.votes.map((v) => ({
+            agentId: v.agentId,
+            agentSlug: v.agentSlug,
+            vote: v.vote,
+            signature: signVote(v.agentId, v.vote, input.decisionId, key),
+            votedAt: v.votedAt,
+        }));
+        // Compute quorum proof
+        const achieved = signedVotes.length;
+        const quorumProof = {
+            required: input.quorumRequired,
+            achieved,
+            threshold: input.quorumThreshold,
+            satisfied: achieved >= input.quorumRequired,
+        };
+        // Compute duration (guard against invalid date strings)
+        const startMs = new Date(input.startedAt).getTime();
+        const endMs = new Date(input.completedAt).getTime();
+        const durationMs = isNaN(startMs) || isNaN(endMs) ? null : endMs - startMs;
+        const recordWithoutSig = {
+            decisionId: input.decisionId,
+            swarmId: input.swarmId,
+            protocol: input.protocol,
+            topic: input.topic,
+            decision: input.decision,
+            votes: signedVotes,
+            quorumProof,
+            quorumAchieved: quorumProof.satisfied,
+            round: input.round,
+            startedAt: input.startedAt,
+            completedAt: input.completedAt,
+            durationMs,
+        };
+        // Sign the full outer record so decision, quorumProof, and metadata are tamper-evident.
+        // Previously only individual votes were signed; this extends coverage to all fields.
+        const recordSignature = createHmac('sha256', key)
+            .update(JSON.stringify(recordWithoutSig))
+            .digest('hex');
+        const record = { ...recordWithoutSig, recordSignature };
+        // Persist audit record
+        this.appendLine(this.auditPath, record);
+        // Persist individual votes
+        for (const vote of signedVotes) {
+            this.appendLine(this.votesPath, { decisionId: input.decisionId, ...vote });
+        }
+        return record;
+    }
+    /**
+     * List consensus decisions, optionally filtered by swarmId.
+     */
+    listDecisions(swarmId, limit) {
+        const records = this.readLines(this.auditPath);
+        const filtered = swarmId ? records.filter((r) => r.swarmId === swarmId) : records;
+        return limit !== undefined ? filtered.slice(0, limit) : filtered;
+    }
+    /**
+     * Re-verify all vote signatures in a decision.
+     */
+    verifyDecision(decisionId, sessionSecret) {
+        const records = this.readLines(this.auditPath);
+        const record = records.find((r) => r.decisionId === decisionId);
+        if (!record) {
+            return { valid: false, invalidVotes: [] };
+        }
+        const key = deriveSigningKey(record.swarmId, sessionSecret);
+        const invalidVotes = [];
+        for (const vote of record.votes) {
+            const ok = verifyVote(vote.agentId, vote.vote, decisionId, vote.signature, key);
+            if (!ok) {
+                invalidVotes.push(vote.agentId);
+            }
+        }
+        // Verify the outer record signature for tamper-evidence
+        const { recordSignature, ...recordWithoutSig } = record;
+        const expectedSig = createHmac('sha256', key)
+            .update(JSON.stringify(recordWithoutSig))
+            .digest('hex');
+        const expBuf = Buffer.from(expectedSig, 'hex');
+        const gotBuf = Buffer.from(typeof recordSignature === 'string' ? recordSignature : '', 'hex');
+        const recordTampered = gotBuf.length !== expBuf.length || !timingSafeEqual(gotBuf, expBuf);
+        return { valid: invalidVotes.length === 0 && !recordTampered, invalidVotes };
+    }
+    // ── helpers ──
+    appendLine(filePath, data) {
+        // Audit writes must be reliable — propagate errors so callers know the audit trail
+        // is incomplete (silent failure defeats tamper-evidence)
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        appendFileSync(filePath, JSON.stringify(data) + '\n', 'utf-8');
+    }
+    readLines(filePath) {
+        if (!existsSync(filePath))
+            return [];
+        try {
+            const MAX_BYTES = 50 * 1024 * 1024;
+            if (statSync(filePath).size > MAX_BYTES) {
+                throw new Error(`Audit log ${filePath} exceeds 50MB — run rotation/cleanup`);
+            }
+            const content = readFileSync(filePath, 'utf-8');
+            return parseJsonl(content);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=audit-writer.js.map

package/packages/@monomind/cli/dist/src/consensus/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Consensus module barrel export (Task 36)
+ */
+export { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export { AuditWriter } from './audit-writer.js';
+export type { RecordInput } from './audit-writer.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/consensus/index.js

@@ -0,0 +1,6 @@
+/**
+ * Consensus module barrel export (Task 36)
+ */
+export { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export { AuditWriter } from './audit-writer.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/consensus/vote-signer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * VoteSigner (Task 36)
+ *
+ * HMAC-SHA256 signing and verification for consensus votes.
+ */
+/**
+ * Derive a signing key from a swarmId and session secret using HMAC-SHA256.
+ */
+export declare function deriveSigningKey(swarmId: string, sessionSecret: string): Buffer;
+export declare function signVote(agentId: string, vote: unknown, decisionId: string, key: Buffer): string;
+/**
+ * CP-WBFT: Compute confidence-weighted vote tally.
+ *
+ * Each agent's vote is scaled by its confidence score (derived from a probe query)
+ * before tallying. Agents that fail the probe receive weight 0.
+ * Tolerates up to 85.7% Byzantine fault rate across topologies.
+ *
+ * Source: https://arxiv.org/abs/2511.10400 (CP-WBFT — AAAI 2026)
+ */
+export declare function weightedTally(votes: Array<{
+    agentId: string;
+    vote: boolean;
+    confidence: number;
+}>): {
+    approved: number;
+    rejected: number;
+    weightedApproval: number;
+    weightedRejection: number;
+    quorum: boolean;
+};
+/**
+ * Verify a vote signature using constant-time comparison.
+ * Returns true when the signature is valid.
+ */
+export declare function verifyVote(agentId: string, vote: unknown, decisionId: string, signature: string, key: Buffer): boolean;
+//# sourceMappingURL=vote-signer.d.ts.map

package/packages/@monomind/cli/dist/src/consensus/vote-signer.js

@@ -0,0 +1,71 @@
+/**
+ * VoteSigner (Task 36)
+ *
+ * HMAC-SHA256 signing and verification for consensus votes.
+ */
+import { createHmac, timingSafeEqual } from 'crypto';
+/**
+ * Derive a signing key from a swarmId and session secret using HMAC-SHA256.
+ */
+export function deriveSigningKey(swarmId, sessionSecret) {
+    return createHmac('sha256', sessionSecret).update(swarmId).digest();
+}
+/**
+ * Sign a vote, producing a hex-encoded HMAC-SHA256 signature.
+ */
+function canonicalize(val) {
+    if (val === null || typeof val !== 'object')
+        return JSON.stringify(val);
+    if (Array.isArray(val))
+        return '[' + val.map(canonicalize).join(',') + ']';
+    const sorted = Object.keys(val).sort().map(k => JSON.stringify(k) + ':' + canonicalize(val[k]));
+    return '{' + sorted.join(',') + '}';
+}
+export function signVote(agentId, vote, decisionId, key) {
+    const payload = JSON.stringify({ agentId, vote: canonicalize(vote), decisionId });
+    return createHmac('sha256', key).update(payload).digest('hex');
+}
+/**
+ * CP-WBFT: Compute confidence-weighted vote tally.
+ *
+ * Each agent's vote is scaled by its confidence score (derived from a probe query)
+ * before tallying. Agents that fail the probe receive weight 0.
+ * Tolerates up to 85.7% Byzantine fault rate across topologies.
+ *
+ * Source: https://arxiv.org/abs/2511.10400 (CP-WBFT — AAAI 2026)
+ */
+export function weightedTally(votes) {
+    let weightedApproval = 0;
+    let weightedRejection = 0;
+    let totalWeight = 0;
+    for (const { vote, confidence } of votes) {
+        const w = Math.max(0, Math.min(1, confidence)); // clamp to [0,1]
+        totalWeight += w;
+        if (vote) {
+            weightedApproval += w;
+        }
+        else {
+            weightedRejection += w;
+        }
+    }
+    return {
+        approved: votes.filter(v => v.vote).length,
+        rejected: votes.filter(v => !v.vote).length,
+        weightedApproval,
+        weightedRejection,
+        quorum: totalWeight > 0 && weightedApproval / totalWeight > 0.5,
+    };
+}
+/**
+ * Verify a vote signature using constant-time comparison.
+ * Returns true when the signature is valid.
+ */
+export function verifyVote(agentId, vote, decisionId, signature, key) {
+    const expected = signVote(agentId, vote, decisionId, key);
+    const sigBuf = Buffer.from(signature, 'hex');
+    const expBuf = Buffer.from(expected, 'hex');
+    if (sigBuf.length !== expBuf.length)
+        return false;
+    return timingSafeEqual(sigBuf, expBuf);
+}
+//# sourceMappingURL=vote-signer.js.map

package/packages/@monomind/cli/dist/src/context/context-provider.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Context Provider — interfaces and base class for dynamic prompt assembly.
+ *
+ * Each provider contributes a named section of context to the assembled prompt.
+ * Providers are prioritised (0-100) and budget-aware via token estimation.
+ */
+export interface RunContext {
+    agentSlug: string;
+    taskDescription: string;
+    sessionId: string;
+    swarmId?: string;
+    workingDir?: string;
+    metadata: Record<string, unknown>;
+}
+export interface ContextSection {
+    name: string;
+    content: string;
+    tokenCount: number;
+    priority: number;
+    required: boolean;
+}
+export interface ContextProvider {
+    readonly name: string;
+    readonly priority: number;
+    readonly maxTokens: number;
+    readonly required: boolean;
+    provide(ctx: RunContext): Promise<string>;
+}
+/**
+ * Convenience base class that implements the ContextProvider contract and
+ * supplies a rough token-truncation helper (approx 4 chars per token).
+ */
+export declare abstract class BaseContextProvider implements ContextProvider {
+    abstract readonly name: string;
+    abstract readonly priority: number;
+    readonly maxTokens: number;
+    readonly required: boolean;
+    /**
+     * Truncate `text` so that it fits within `maxTokens` (4 chars/token).
+     */
+    protected truncateToTokens(text: string, maxTokens: number): string;
+    abstract provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=context-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/context-provider.js

@@ -0,0 +1,25 @@
+/**
+ * Context Provider — interfaces and base class for dynamic prompt assembly.
+ *
+ * Each provider contributes a named section of context to the assembled prompt.
+ * Providers are prioritised (0-100) and budget-aware via token estimation.
+ */
+/**
+ * Convenience base class that implements the ContextProvider contract and
+ * supplies a rough token-truncation helper (approx 4 chars per token).
+ */
+export class BaseContextProvider {
+    maxTokens = 500;
+    required = false;
+    /**
+     * Truncate `text` so that it fits within `maxTokens` (4 chars/token).
+     */
+    truncateToTokens(text, maxTokens) {
+        const maxChars = maxTokens * 4;
+        if (text.length <= maxChars) {
+            return text;
+        }
+        return text.slice(0, maxChars);
+    }
+}
+//# sourceMappingURL=context-provider.js.map

package/packages/@monomind/cli/dist/src/context/git-state-provider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GitStateProvider — injects current git branch, recent log, and changed files
+ * into the assembled prompt.  Falls back gracefully when not inside a git repo.
+ */
+import { BaseContextProvider, type RunContext } from './context-provider.js';
+export declare class GitStateProvider extends BaseContextProvider {
+    readonly name: "git-state";
+    readonly priority = 60;
+    readonly maxTokens = 300;
+    provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=git-state-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/git-state-provider.js

@@ -0,0 +1,34 @@
+/**
+ * GitStateProvider — injects current git branch, recent log, and changed files
+ * into the assembled prompt.  Falls back gracefully when not inside a git repo.
+ */
+import { execSync } from 'child_process';
+import { BaseContextProvider } from './context-provider.js';
+export class GitStateProvider extends BaseContextProvider {
+    name = 'git-state';
+    priority = 60;
+    maxTokens = 300;
+    async provide(ctx) {
+        try {
+            const cwd = ctx.workingDir ?? process.cwd();
+            const opts = { cwd, encoding: 'utf-8', timeout: 5000 };
+            const branch = execSync('git branch --show-current', opts).trim();
+            const log = execSync('git log --oneline -5', opts).trim();
+            const changed = execSync('git diff --name-only HEAD', opts).trim();
+            const parts = [
+                `**Branch:** ${branch}`,
+                '',
+                '**Recent commits:**',
+                log,
+            ];
+            if (changed) {
+                parts.push('', '**Changed files:**', changed);
+            }
+            return this.truncateToTokens(parts.join('\n'), this.maxTokens);
+        }
+        catch {
+            return 'Git state unavailable (not a git repository or git not installed).';
+        }
+    }
+}
+//# sourceMappingURL=git-state-provider.js.map

package/packages/@monomind/cli/dist/src/context/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Context module — dynamic system prompt assembly.
+ *
+ * Re-exports all context providers and the prompt assembler.
+ */
+export { type RunContext, type ContextSection, type ContextProvider, BaseContextProvider, } from './context-provider.js';
+export { GitStateProvider } from './git-state-provider.js';
+export { TaskHistoryProvider, type SearchFn, type SearchResult, } from './task-history-provider.js';
+export { ProjectConventionsProvider, type ConventionsLoader, } from './project-conventions-provider.js';
+export { UserPreferencesProvider, type PreferencesGetter, } from './user-preferences-provider.js';
+export { PromptAssembler, type AssemblyConfig, type AssembledPrompt, } from './prompt-assembler.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/context/index.js

@@ -0,0 +1,12 @@
+/**
+ * Context module — dynamic system prompt assembly.
+ *
+ * Re-exports all context providers and the prompt assembler.
+ */
+export { BaseContextProvider, } from './context-provider.js';
+export { GitStateProvider } from './git-state-provider.js';
+export { TaskHistoryProvider, } from './task-history-provider.js';
+export { ProjectConventionsProvider, } from './project-conventions-provider.js';
+export { UserPreferencesProvider, } from './user-preferences-provider.js';
+export { PromptAssembler, } from './prompt-assembler.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/context/project-conventions-provider.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ProjectConventionsProvider — loads project-level conventions (e.g. from
+ * CLAUDE.md or a config file) and injects them as a required context section.
+ */
+import { BaseContextProvider, type RunContext } from './context-provider.js';
+export type ConventionsLoader = () => string;
+export declare class ProjectConventionsProvider extends BaseContextProvider {
+    private readonly loader;
+    readonly name: "project-conventions";
+    readonly priority = 100;
+    readonly required = true;
+    constructor(loader: ConventionsLoader);
+    provide(_ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=project-conventions-provider.d.ts.map