@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/council/triage.js

@@ -0,0 +1,228 @@
+/**
+ * Council triage — a cheap single-LLM gate in FRONT of the expensive
+ * multi-model fan-out (OpenHuman-inspired drop/ack/react/escalate: only
+ * "escalate" convenes the full council).
+ *
+ * The Code Buddy Council fans a task out to N models + a judge + a synthesis
+ * pass — real money and latency. A trivial, factual, unambiguous question
+ * does not deserve that. When `CODEBUDDY_COUNCIL_TRIAGE` is on, one cheap
+ * (latency-routed, local/free-preferable) model classifies the request:
+ *
+ *   - SINGLE  → the same cheap model answers, and we return early with a
+ *               well-formed `CouncilRunResult` marked `triaged: true`. The
+ *               fan-out is NEVER launched.
+ *   - COUNCIL → we return null and the engine runs the full deliberation.
+ *
+ * FAIL-SAFE TOWARD QUALITY: any error, timeout, empty answer, or non-parsable
+ * verdict returns null ⇒ the full council runs. Triage can only ever SAVE
+ * money, never silently downgrade a hard question to one model. The parser
+ * accepts SINGLE only on an explicit, well-formed verdict; everything else
+ * (including the classifier's "when in doubt") resolves to COUNCIL.
+ *
+ * Opt-in, default OFF ⇒ this module is never even entered and the council
+ * behaves exactly as before.
+ *
+ * @module council/triage
+ */
+import { withTimeout } from './with-timeout.js';
+import { sanitizeModelOutput } from '../utils/output-sanitizer.js';
+import { inferTaskType } from '../fleet/model-capability-heuristics.js';
+import { computeTextConsensus } from '../fleet/result-aggregator.js';
+import { computeCouncilDecisionSignals } from './signals.js';
+import { computeDeliberationHealth } from './deliberation-health.js';
+/** Only an explicit, opt-in truthy value enables triage. */
+export function isCouncilTriageEnabled(env = process.env) {
+    const v = (env.CODEBUDDY_COUNCIL_TRIAGE ?? '').trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+function isTriageLocalOnly(env) {
+    const v = (env.CODEBUDDY_COUNCIL_TRIAGE_LOCAL_ONLY ?? '').trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+function triageTimeoutMs(deps, env) {
+    if (typeof deps.timeoutMs === 'number' && deps.timeoutMs > 0)
+        return deps.timeoutMs;
+    const raw = Number(env.CODEBUDDY_COUNCIL_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 45000;
+}
+const TRIAGE_SYSTEM = 'You are the fast triage stage of Code Buddy Council. Decide whether a request needs the ' +
+    'full multi-model council (several LLMs + a judge — expensive) or can be answered just as ' +
+    'well by ONE competent model (cheap).\n' +
+    'Answer COUNCIL when the request is hard, ambiguous, high-stakes, a design/architecture ' +
+    'trade-off, a security or correctness judgement, or genuinely benefits from several ' +
+    'independent perspectives.\n' +
+    'Answer SINGLE only when the request is factual, trivial, unambiguous, and a single good ' +
+    'model would answer it as well as many would.\n' +
+    'When in doubt, answer COUNCIL.\n' +
+    'Reply in EXACTLY this format and nothing else:\n' +
+    'DECISION: SINGLE or COUNCIL\n' +
+    'REASON: <one short sentence>';
+/**
+ * Parse the falsifiable triage contract. SINGLE is accepted ONLY on an
+ * explicit, well-formed verdict (`DECISION: SINGLE`, or a bare `SINGLE`);
+ * any noise, ambiguity, or a COUNCIL verdict resolves to COUNCIL. This is the
+ * quality fail-safe at the parsing layer: a garbled reply can never downgrade
+ * the run to one model.
+ */
+export function parseTriageDecision(text) {
+    const clean = (text ?? '').trim();
+    const reason = clean.match(/reason\s*:\s*(.+)/i)?.[1]?.trim().slice(0, 200);
+    const withReason = (decision) => reason ? { decision, reason } : { decision };
+    const decisionLine = clean.match(/decision\s*:\s*(single|council)/i);
+    if (decisionLine) {
+        return withReason(decisionLine[1].toLowerCase() === 'single' ? 'single' : 'council');
+    }
+    // No DECISION line — accept SINGLE only when the whole reply is exactly that.
+    if (/^single\.?$/i.test(clean))
+        return withReason('single');
+    // Unparsable / ambiguous ⇒ COUNCIL (fail-safe toward quality).
+    return withReason('council');
+}
+async function defaultSelectTriageModel(task, opts) {
+    const { selectFastestModel } = await import('../fleet/model-selector.js');
+    const sel = await selectFastestModel(task, {
+        ...(opts.localOnly ? { localOnly: true } : {}),
+        ...(opts.preferModel ? { preferModel: opts.preferModel } : {}),
+        ...(opts.env ? { env: opts.env } : {}),
+    });
+    if (!sel)
+        return null;
+    return {
+        provider: sel.provider,
+        model: sel.model,
+        ...(sel.apiKey ? { apiKey: sel.apiKey } : {}),
+        ...(sel.baseURL ? { baseURL: sel.baseURL } : {}),
+        isLocal: sel.isLocal,
+        reason: sel.reason,
+    };
+}
+/**
+ * Run the triage stage. Returns a triaged `CouncilRunResult` when the request
+ * is classified SINGLE (fan-out skipped), or `null` in every other case
+ * (COUNCIL verdict, explicit multi-model intent, or ANY failure) so the engine
+ * proceeds to the full deliberation. Never throws.
+ */
+export async function runCouncilTriage(task, opts, deps, onProgress = () => { }) {
+    const env = deps.env ?? process.env;
+    // Honour explicit deliberation intent: a pinned model set or a fleet run
+    // means the user WANTS the full council — never triage it away.
+    if (opts.models || opts.fleet)
+        return null;
+    try {
+        const select = deps.selectTriageModel ?? defaultSelectTriageModel;
+        const preferModel = (env.CODEBUDDY_COUNCIL_TRIAGE_MODEL ?? '').trim();
+        const selection = await select(task, {
+            ...(isTriageLocalOnly(env) ? { localOnly: true } : {}),
+            ...(preferModel ? { preferModel } : {}),
+            env,
+        });
+        if (!selection)
+            return null; // no cheap model available → full council
+        const candidate = {
+            provider: selection.provider,
+            model: selection.model,
+            ...(selection.apiKey ? { apiKey: selection.apiKey } : {}),
+            ...(selection.baseURL ? { baseURL: selection.baseURL } : {}),
+            costInputUsdPerMtok: 0,
+        };
+        let client;
+        try {
+            client = deps.clientFactory(candidate);
+        }
+        catch {
+            return null; // cannot build the triage client → full council
+        }
+        const timeoutMs = triageTimeoutMs(deps, env);
+        // 1. classify (one cheap call).
+        const classifyResp = await withTimeout(client.chat([
+            { role: 'system', content: TRIAGE_SYSTEM },
+            { role: 'user', content: task },
+        ]), timeoutMs, 'triage');
+        const decision = parseTriageDecision(sanitizeModelOutput(classifyResp.content));
+        if (decision.decision !== 'single') {
+            onProgress({ type: 'triage', decision: 'council', ...(decision.reason ? { reason: decision.reason } : {}) });
+            return null; // COUNCIL / unparsable → full council
+        }
+        // 2. answer with the single model.
+        const t0 = Date.now();
+        const answerResp = await withTimeout(client.chat([{ role: 'user', content: task }]), timeoutMs, selection.model);
+        const content = sanitizeModelOutput(answerResp.content).trim();
+        if (!content)
+            return null; // empty single answer → full council (fail-safe)
+        onProgress({
+            type: 'triage',
+            decision: 'single',
+            model: selection.model,
+            ...(decision.reason ? { reason: decision.reason } : {}),
+        });
+        const taskType = (opts.taskType || inferTaskType(task)).toLowerCase();
+        const answer = {
+            source: { kind: 'local', provider: selection.provider, model: selection.model },
+            displayName: selection.model,
+            content,
+            latencyMs: Date.now() - t0,
+            tokensUsed: answerResp.totalTokens,
+            // The triage model is the cheapest available; treat its marginal cost as
+            // ~0 for the ledger (a precise $/Mtok is not carried by the selector).
+            costUsd: 0,
+        };
+        const plan = {
+            mode: 'direct',
+            reason: 'triage: question jugée simple — réponse mono-modèle (fan-out évité)',
+            roles: [],
+        };
+        const consensus = computeTextConsensus([
+            { peerId: selection.provider, model: selection.model, text: content },
+        ]);
+        const verdict = {
+            kind: 'judged',
+            winnerIdx: 0,
+            scores: [1],
+            roleScores: [1],
+            rationale: decision.reason
+                ? `triage mono-modèle : ${decision.reason}`
+                : 'triage mono-modèle (question jugée simple)',
+            verified: '',
+            judgeModel: null,
+            neutral: false,
+        };
+        const signals = computeCouncilDecisionSignals([1], 0, consensus.score, { collective: false });
+        // DHI is honest about there being NO deliberation (no judge) — but a
+        // triaged run is not a degraded council, so we do NOT persist it to the
+        // health ledger (that would flood it with zeros). The field exists for
+        // shape completeness; the host's healthSink is deliberately not called.
+        const health = computeDeliberationHealth({
+            at: (deps.now?.() ?? new Date()).toISOString(),
+            taskType,
+            planMode: 'direct',
+            seats: 1,
+            answers: [{ content, winner: true }],
+            judgeAlive: false,
+            scores: [1],
+            consensusScore: consensus.score,
+            synthesis: null,
+        });
+        return {
+            taskType,
+            plan,
+            answers: [answer],
+            failures: [],
+            verdict,
+            consensus,
+            signals,
+            synthesis: null,
+            finalText: content,
+            learned: false,
+            learnSkipReason: 'triage mono-modèle (pas de délibération)',
+            health,
+            triaged: true,
+            singleModel: selection.model,
+            ...(decision.reason ? { triageReason: decision.reason } : {}),
+        };
+    }
+    catch {
+        // FAIL-SAFE: any error → full council. Never let triage break a run.
+        return null;
+    }
+}
+//# sourceMappingURL=triage.js.map

package/dist/council/types.d.ts

@@ -0,0 +1,292 @@
+/**
+ * Council types — the data contracts of the 8-step deliberation pipeline.
+ *
+ * The pipeline itself lives in `council-engine.ts` (host-agnostic: takes
+ * injected dependencies, returns a `CouncilRunResult`); the CLI presenter in
+ * `src/commands/council.ts` only renders these types. Keeping the contracts
+ * here lets any host (server, Cowork, voice loop, sagas) consume a council
+ * run as data without importing CLI code.
+ *
+ * @module council/types
+ */
+import type { ModelStrength } from '../fleet/types.js';
+import type { ConsensusSummary } from '../fleet/result-aggregator.js';
+import type { ModelScoreboard } from '../fleet/model-scoreboard.js';
+import type { DeliberationHealth } from './deliberation-health.js';
+import type { TaskType } from './task-types.js';
+export type { KnownTaskType, TaskType } from './task-types.js';
+/** One usable LLM as exposed by the active-LLM registry. */
+export interface CouncilCandidate {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    costInputUsdPerMtok: number;
+}
+export interface RankedCandidate {
+    c: CouncilCandidate;
+    strengths: ModelStrength[];
+    score: number;
+    /** Raw historical win rate (0-1), display only — selection uses selectionBias. */
+    hist: number;
+}
+export interface CouncilOptions {
+    /** How many models to consult (default 3). */
+    count?: number;
+    /** Comma list of provider/model substrings to restrict candidates. */
+    models?: string;
+    /** Provider/model substring to use as the judge (default: a neutral strong model). */
+    judge?: string;
+    /** Override the inferred task type. */
+    taskType?: TaskType;
+    /** commander sets this false on --no-consensus. */
+    consensus?: boolean;
+    /** Just print the learned scoreboard and exit. */
+    scoreboard?: boolean;
+    /** Also consult connected fleet peers (other machines' Code Buddy) via peer.chat. */
+    fleet?: boolean;
+    /** Use adaptive conductor roles instead of asking every model the exact same prompt. Default true. */
+    conductor?: boolean;
+    /** Use a final synthesis pass for collective conductor runs. Default true. */
+    synthesis?: boolean;
+    /** Inject peer connections (tests/scripts); else read getFleetRegistry().list(). */
+    fleetPeers?: CouncilPeer[];
+    /** Per-peer timeout for the fleet round-trip (default = council timeout). */
+    peerTimeoutMs?: number;
+}
+export interface CouncilRole {
+    id: string;
+    label: string;
+    mission: string;
+    focus: string[];
+}
+export interface CouncilConductorPlan {
+    mode: 'direct' | 'collective';
+    reason: string;
+    roles: CouncilRole[];
+}
+/** Normalised chat result the council needs from any LLM client. */
+export interface CouncilChatResult {
+    content: string;
+    promptTokens: number;
+    totalTokens: number;
+}
+/**
+ * Minimal chat surface consumed by the engine. `CodeBuddyClient` is adapted
+ * to this in the presenter; tests inject plain objects.
+ */
+export interface CouncilChatClient {
+    chat(messages: Array<{
+        role: 'system' | 'user';
+        content: string;
+    }>, options?: {
+        signal?: AbortSignal;
+    }): Promise<CouncilChatResult>;
+}
+export type CouncilAnswerSource = {
+    kind: 'local';
+    provider: string;
+    model: string;
+} | {
+    kind: 'peer';
+    peerId: string;
+    model: string;
+};
+export interface CouncilAnswer {
+    source: CouncilAnswerSource;
+    /** Model id locally, `peerId:model` for fleet peers — the judged display name. */
+    displayName: string;
+    role?: CouncilRole;
+    content: string;
+    latencyMs: number;
+    tokensUsed: number;
+    costUsd: number;
+}
+export interface JudgeVerdict {
+    /** 'abstained' = no reliable verdict (non-JSON, timeout, no judge) — never a fabricated winner. */
+    kind: 'judged' | 'abstained';
+    winnerIdx: number | null;
+    /** Task-fit scores (0-1) — the winner is chosen on these. */
+    scores: number[];
+    /**
+     * Role-fit scores (0-1) — did each answer hold its announced role (a critic
+     * exposing precise breaking conditions holds its role even without a full
+     * answer)? Feeds the scoreboard's role learning so specialised roles are no
+     * longer punished for doing their job. Falls back to `scores` when the
+     * judge only returned single scores.
+     */
+    roleScores: number[];
+    rationale: string;
+    /** What the judge re-verified itself (counts, computations) — '' when nothing. */
+    verified: string;
+    judgeModel: string | null;
+    /** False when the judge is itself a panel member — display-only, never trains the scoreboard. */
+    neutral: boolean;
+    /** True when the judge CALL failed (timeout/transport) — the judge model itself is penalised. */
+    judgeCallFailed?: boolean;
+}
+export interface CouncilDecisionSignals {
+    confidence: 'high' | 'medium' | 'low';
+    winnerScore: number;
+    runnerUpScore: number;
+    margin: number;
+    consensusScore: number;
+    reasons: string[];
+}
+export interface CouncilSynthesisCandidate {
+    modelName: string;
+    roleLabel?: string;
+    score: number;
+    winner: boolean;
+    content: string;
+}
+export interface CouncilSynthesisPrompt {
+    system: string;
+    user: string;
+}
+export interface CouncilPeer {
+    id: string;
+    listener: {
+        request: (method: string, params?: Record<string, unknown>, options?: {
+            timeoutMs?: number;
+        }) => Promise<unknown>;
+    };
+}
+export interface PeerAnswer {
+    modelId: string;
+    modelName: string;
+    content: string;
+    latency: number;
+    tokensUsed: number;
+    cost: number;
+    role?: CouncilRole;
+}
+export interface GatherPeerAnswersOptions {
+    promptForPeer?: (peer: CouncilPeer, index: number) => string;
+    roleForPeer?: (peer: CouncilPeer, index: number) => CouncilRole | undefined;
+}
+export type CouncilProgressEvent = {
+    type: 'panel';
+    taskType: TaskType;
+    entries: Array<{
+        model: string;
+        histWinRate: number;
+    }>;
+    peerCount: number;
+    /** Model granted the ε-exploration seat this run, if any. */
+    explored?: string;
+    /** Usable models after apiKey + --models filtering (before pickDiverse). */
+    poolSize?: number;
+    /** Requested seat count (`--count`, default 3). */
+    requestedCount?: number;
+    /** Raw `--models` filter, when set. */
+    modelsFilter?: string;
+    /** False when `--models` matched nothing and the full pool was kept. */
+    modelsMatched?: boolean;
+} | {
+    type: 'conductor';
+    roles: string[];
+} | {
+    type: 'fleet_no_peers';
+} | {
+    type: 'fleet_consulting';
+    peerCount: number;
+} | {
+    type: 'answer_failed';
+    source: string;
+    error: string;
+}
+/**
+ * Cheap triage verdict (opt-in `CODEBUDDY_COUNCIL_TRIAGE`). `single` = the
+ * question was classified simple enough for one model and the expensive
+ * fan-out was skipped; `council` = the full deliberation runs as usual.
+ */
+ | {
+    type: 'triage';
+    decision: 'single' | 'council';
+    model?: string;
+    reason?: string;
+};
+/**
+ * A cheap triage-stage model pick — the minimal shape the engine needs to
+ * build a client and short-circuit to a single answer. Structurally a subset
+ * of `fleet/model-selector.ts`'s `ModelSelection` so the default selector
+ * (`selectFastestModel`) adapts trivially.
+ */
+export interface TriageModelSelection {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    isLocal: boolean;
+    reason: string;
+}
+export interface CouncilEngineDeps {
+    /** Thunk (not a value) so hosts keep the lazy registry import until a run actually starts. */
+    loadRegistry: () => Promise<CouncilCandidate[]>;
+    scoreboard: ModelScoreboard;
+    clientFactory: (c: CouncilCandidate) => CouncilChatClient;
+    /** Fleet peers to consult when opts.fleet is set (empty array = none connected). */
+    peers: CouncilPeer[];
+    /** Injectable randomness (judge shuffle + exploration seat) for deterministic tests. */
+    rng?: () => number;
+    /** Per-model wall-clock cap; default CODEBUDDY_COUNCIL_TIMEOUT_MS or 45s. */
+    timeoutMs?: number;
+    peerTimeoutMs?: number;
+    /** ε for the exploration seat; default CODEBUDDY_COUNCIL_EXPLORE or 0.1. */
+    exploreEpsilon?: number;
+    /** Injectable clock for deterministic outcome timestamps. */
+    now?: () => Date;
+    /**
+     * Where to persist the per-run deliberation-health record (DHI). The engine
+     * only computes and hands it over — file IO is host policy (the CLI
+     * presenter appends to ~/.codebuddy/council-deliberation-health.jsonl).
+     */
+    healthSink?: (health: DeliberationHealth) => void;
+    /**
+     * Cheap triage-stage model selector, used only when `CODEBUDDY_COUNCIL_TRIAGE`
+     * is on. Defaults to a wrapper over `fleet/model-selector.ts selectFastestModel`
+     * (latency-routed, local/free-preferable). Injected in tests to stay offline.
+     */
+    selectTriageModel?: (task: string, opts: {
+        localOnly?: boolean;
+        preferModel?: string;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<TriageModelSelection | null>;
+    /** Env source for triage flags (tests inject a plain object). Defaults to process.env. */
+    env?: NodeJS.ProcessEnv;
+}
+export interface CouncilRunResult {
+    taskType: TaskType;
+    plan: CouncilConductorPlan;
+    answers: CouncilAnswer[];
+    failures: Array<{
+        source: string;
+        error: string;
+    }>;
+    verdict: JudgeVerdict;
+    consensus: ConsensusSummary;
+    signals: CouncilDecisionSignals;
+    synthesis: string | null;
+    /** synthesis ?? judged winner ?? labelled concatenation of all answers. */
+    finalText: string;
+    /** True when this run's outcomes were recorded to the scoreboard. */
+    learned: boolean;
+    learnSkipReason?: string;
+    /** Per-run deliberation-health metrics (DHI) — see council/deliberation-health.ts. */
+    health: DeliberationHealth;
+    /**
+     * True when the cheap triage stage short-circuited the run to a single model
+     * (no multi-model fan-out). Only ever set when `CODEBUDDY_COUNCIL_TRIAGE` is
+     * on; absent/undefined for every normal deliberation (OFF = unchanged shape).
+     */
+    triaged?: boolean;
+    /** The single model that answered when `triaged` — provenance for consumers. */
+    singleModel?: string;
+    /** The triage classifier's short reason for choosing SINGLE. */
+    triageReason?: string;
+}
+export declare class CouncilError extends Error {
+    readonly code: 'no-candidates' | 'all-failed';
+    constructor(code: 'no-candidates' | 'all-failed', message: string);
+}

package/dist/council/types.js

@@ -0,0 +1,20 @@
+/**
+ * Council types — the data contracts of the 8-step deliberation pipeline.
+ *
+ * The pipeline itself lives in `council-engine.ts` (host-agnostic: takes
+ * injected dependencies, returns a `CouncilRunResult`); the CLI presenter in
+ * `src/commands/council.ts` only renders these types. Keeping the contracts
+ * here lets any host (server, Cowork, voice loop, sagas) consume a council
+ * run as data without importing CLI code.
+ *
+ * @module council/types
+ */
+export class CouncilError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'CouncilError';
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/council/with-timeout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared timeout race for council LLM calls.
+ *
+ * The optional controller lets callers that pass its signal to a transport
+ * abort real network/model work on timeout. Legacy callers still get the
+ * timer race without changing behaviour.
+ *
+ * @module council/with-timeout
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, label: string, controller?: AbortController): Promise<T>;

package/dist/council/with-timeout.js

@@ -0,0 +1,29 @@
+/**
+ * Shared timeout race for council LLM calls.
+ *
+ * The optional controller lets callers that pass its signal to a transport
+ * abort real network/model work on timeout. Legacy callers still get the
+ * timer race without changing behaviour.
+ *
+ * @module council/with-timeout
+ */
+export async function withTimeout(promise, ms, label, controller) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller?.abort(`${label} timeout`);
+                    reject(new Error(`${label} timeout >${Math.round(ms / 1000)}s`));
+                }, ms);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=with-timeout.js.map

package/dist/curator/curator.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Curator — nightly-style maintenance REPORT over the agent's learnable layer
+ * (jarvis-OS Curator, clean-room concepts). Règle non négociable : il PROPOSE,
+ * il n'APPLIQUE RIEN. Chaque proposition pointe vers la commande humaine
+ * existante ; `applyCuratorPatch()` refuse par principe (le refus est du code
+ * vivant, pas une doc).
+ *
+ * Cinq sections, chacune fail-open (une source cassée dégrade le rapport sans
+ * le casser — pattern Command Center) :
+ *  1. Mémoire persistante — candidats à l'oubli Ebbinghaus (dry-run pur via
+ *     decideForgets ; l'archivage réel reste le job du dreaming opt-in).
+ *  2. Skills authored — dormantes (mtime ancien, non épinglées) à réviser.
+ *  3. CKG — proportion d'entités supersédées comme proxy d'instabilité.
+ *  4. Leçons — candidates `pending` qui stagnent.
+ *  5. Modèles — activité/coûts/échecs du ledger council (7 derniers jours).
+ *
+ * Chemins protégés : seules les skills `authored-*` sont proposables ; la
+ * mémoire passe par decideForgets qui exclut déjà preferences/decisions/pinned
+ * (re-filtré ici, défense en profondeur).
+ */
+import type { Memory, MemoryScope } from '../memory/persistent-memory.js';
+export type CuratorPatchKind = 'ARCHIVE_MEMORY' | 'REVIEW_SKILL' | 'REVIEW_CONTRADICTIONS' | 'REVIEW_LESSON';
+export interface CuratorPatch {
+    kind: CuratorPatchKind;
+    target: string;
+    reason: string;
+    /** Signal seulement (réversible + à faible risque) — le Curator n'applique JAMAIS. */
+    autoAppliable: boolean;
+    /** La commande/le chemin humain existant pour agir. */
+    howToApply: string;
+}
+export interface CuratorSection {
+    name: string;
+    ok: boolean;
+    summary: string;
+    details?: string[];
+}
+export interface CuratorReport {
+    generatedAt: string;
+    cwd: string;
+    sections: CuratorSection[];
+    patches: CuratorPatch[];
+    notes: string[];
+}
+/** Seam d'injection pour les tests — chaque source est optionnelle. */
+export interface CuratorDeps {
+    now?: Date;
+    /** Énumération mémoire par scope (défaut : getMemoryManager initialisé). */
+    listMemories?: (scope: MemoryScope) => Promise<Memory[]>;
+    /** Répertoire des skills du projet (défaut : <cwd>/.codebuddy/skills). */
+    skillsDir?: string;
+    /** Stats CKG (défaut : getCollectiveKnowledgeGraph().getStats()). */
+    ckgStats?: () => Promise<{
+        entities: number;
+        superseded: number;
+        relations: number;
+    }>;
+    /** Leçons candidates pending (défaut : getLessonCandidateQueue(cwd)). */
+    listPendingLessons?: () => Promise<Array<{
+        id: string;
+        createdAt: string;
+        category?: string;
+    }>>;
+    /** Ledger de performance modèles (défaut : ~/.codebuddy/fleet-model-performance.jsonl). */
+    modelLedgerPath?: string;
+}
+export declare function runCuratorScan(cwd?: string, deps?: CuratorDeps): Promise<CuratorReport>;
+/**
+ * Le refus matérialisé en code vivant (pattern jarvis-OS « apply ⇒ 403 ») :
+ * tout chemin futur qui tenterait d'auto-appliquer un patch du Curator doit
+ * passer par ici — et ici, c'est non.
+ */
+export declare function applyCuratorPatch(patch: CuratorPatch): never;
+export declare function renderCuratorMarkdown(report: CuratorReport): string;
+/** Persiste le rapport : JSON horodaté + latest.md (miroir humain écrasé). */
+export declare function saveCuratorReport(report: CuratorReport, cwd?: string): Promise<{
+    jsonPath: string;
+    mdPath: string;
+}>;