qlogicagent 0.2.1 → 0.4.0

package/dist/orchestration/reactive-compact.js

@@ -1,78 +0,0 @@
-/**
- * Reactive Compact — Emergency context compression when API returns prompt-too-long.
- *
- * Aligned with Claude Code's reactive compact chain:
- * 1. API 413 → withhold error → attempt reactive compact → retry
- * 2. Only one reactive compact attempt per turn (prevent infinite loops)
- * 3. Falls back to abort if compact fails
- *
- * Also handles post-compact restoration:
- * - Todo list re-injection
- * - Skill context re-injection
- * - Tool delta re-injection (new/removed tools since last compact)
- */
-export const DEFAULT_REACTIVE_COMPACT_CONFIG = {
-    maxConsecutiveFailures: 3,
-    minMessagesAfterCompact: 4,
-    targetUsagePercent: 50,
-};
-/**
- * Build the restoration message to inject after a compact operation.
- * This ensures critical state survives context compression.
- */
-export function buildPostCompactRestorationMessage(payload) {
-    const sections = [];
-    if (payload.todoList && payload.todoList.length > 0) {
-        const todoLines = payload.todoList.map((t) => `  ${t.status === "completed" ? "[x]" : t.status === "in-progress" ? "[~]" : "[ ]"} #${t.id}: ${t.title}`);
-        sections.push(`## Active Todo List\n${todoLines.join("\n")}`);
-    }
-    if (payload.activeSkillContext) {
-        sections.push(`## Active Skill: ${payload.activeSkillContext.name}\nStep ${payload.activeSkillContext.step}:\n${payload.activeSkillContext.instructions}`);
-    }
-    if (payload.toolDelta && (payload.toolDelta.added.length > 0 || payload.toolDelta.removed.length > 0)) {
-        const lines = [];
-        if (payload.toolDelta.added.length > 0) {
-            lines.push(`New tools available: ${payload.toolDelta.added.join(", ")}`);
-        }
-        if (payload.toolDelta.removed.length > 0) {
-            lines.push(`Tools no longer available: ${payload.toolDelta.removed.join(", ")}`);
-        }
-        sections.push(`## Tool Changes\n${lines.join("\n")}`);
-    }
-    if (payload.customBlocks) {
-        for (const block of payload.customBlocks) {
-            sections.push(`## ${block.label}\n${block.content}`);
-        }
-    }
-    if (sections.length === 0)
-        return null;
-    return `[Context was compressed. The following state has been restored:]\n\n${sections.join("\n\n")}`;
-}
-export function createReactiveCompactState() {
-    return {
-        consecutiveFailures: 0,
-        attemptedThisTurn: false,
-        lastCompactAt: null,
-        toolsAtLastCompact: [],
-    };
-}
-/**
- * Determine if reactive compact should be attempted.
- */
-export function shouldAttemptReactiveCompact(state, config = DEFAULT_REACTIVE_COMPACT_CONFIG) {
-    if (state.attemptedThisTurn)
-        return false;
-    if (state.consecutiveFailures >= config.maxConsecutiveFailures)
-        return false;
-    return true;
-}
-/**
- * Calculate the tool delta since last compact.
- */
-export function computeToolDelta(currentTools, toolsAtLastCompact) {
-    const currentSet = new Set(currentTools);
-    const lastSet = new Set(toolsAtLastCompact);
-    const added = currentTools.filter((t) => !lastSet.has(t));
-    const removed = toolsAtLastCompact.filter((t) => !currentSet.has(t));
-    return { added, removed };
-}

package/dist/orchestration/retry-loop.d.ts

@@ -1,22 +0,0 @@
-export declare function executeBoundedRetryLoop<TResult>(params: {
-    maxIterations: number;
-    onRetryLimit: (params: {
-        iterations: number;
-        maxIterations: number;
-    }) => Promise<TResult> | TResult;
-    executeIteration: (params: {
-        iteration: number;
-    }) => Promise<{
-        kind: "continue";
-    } | {
-        kind: "return";
-        result: TResult;
-    }>;
-}): Promise<TResult>;
-export declare function resolveScaledRetryIterations(params: {
-    candidateCount: number;
-    baseIterations?: number;
-    perCandidateIterations?: number;
-    minIterations?: number;
-    maxIterations?: number;
-}): number;

package/dist/orchestration/retry-loop.js

@@ -1,24 +0,0 @@
-export async function executeBoundedRetryLoop(params) {
-    let iterations = 0;
-    while (true) {
-        if (iterations >= params.maxIterations) {
-            return await params.onRetryLimit({
-                iterations,
-                maxIterations: params.maxIterations,
-            });
-        }
-        iterations += 1;
-        const outcome = await params.executeIteration({ iteration: iterations });
-        if (outcome.kind === "return") {
-            return outcome.result;
-        }
-    }
-}
-export function resolveScaledRetryIterations(params) {
-    const baseIterations = Math.max(0, Math.floor(params.baseIterations ?? 24));
-    const perCandidateIterations = Math.max(0, Math.floor(params.perCandidateIterations ?? 8));
-    const minIterations = Math.max(1, Math.floor(params.minIterations ?? 32));
-    const maxIterations = Math.max(minIterations, Math.floor(params.maxIterations ?? 160));
-    const scaled = baseIterations + Math.max(1, Math.floor(params.candidateCount)) * perCandidateIterations;
-    return Math.min(maxIterations, Math.max(minIterations, scaled));
-}

package/dist/orchestration/skill-candidate.d.ts

@@ -1,52 +0,0 @@
-import { type SkillCandidateAction, type SkillCandidateArtifactContract, type SkillCandidateEffectivenessContract, type SkillCandidateReviewContract, type SkillCandidateSourceExecutionContract } from "../contracts/skill-candidate.js";
-export type SkillImprovementPolicyContract = {
-    reviewRequired: boolean;
-    canaryRequired: boolean;
-    autoPromote: boolean;
-    minCanarySampleCount: number;
-    minSuccessRate: number;
-    maxRegressionRate: number;
-    maxCostIncreaseRate: number;
-    staleAfterHours: number;
-};
-export type SkillCandidateImprovementEvidenceBundleContract = {
-    artifact?: SkillCandidateArtifactContract | null;
-    sourceExecution?: SkillCandidateSourceExecutionContract | null;
-    sourceSessionKey?: string | null;
-    diffSummary?: string | null;
-    baselineCandidateId?: string | null;
-    rolloutNotes?: string | null;
-    validationRefs?: string[];
-    evidence?: Record<string, unknown>;
-};
-export declare function createDefaultSkillImprovementPolicy(overrides?: Partial<SkillImprovementPolicyContract>): SkillImprovementPolicyContract;
-export declare function normalizeSkillImprovementPolicy(value: unknown, fallback?: SkillImprovementPolicyContract): SkillImprovementPolicyContract;
-export declare function buildSkillCandidateEvidencePayload(params: {
-    evidence?: Record<string, unknown> | null;
-    artifact?: SkillCandidateArtifactContract | null;
-    sourceExecution?: SkillCandidateSourceExecutionContract | null;
-    sourceSessionKey?: string | null;
-}): Record<string, unknown>;
-export declare function buildSkillCandidateImprovementEvidenceBundle(params: SkillCandidateImprovementEvidenceBundleContract): Record<string, unknown>;
-export declare function buildSkillCandidateLatestReview(params: {
-    action: SkillCandidateAction;
-    actor?: string | null;
-    notes?: string | null;
-    payload?: Record<string, unknown> | null;
-    createdAt?: string;
-}): SkillCandidateReviewContract;
-export declare function buildSkillCandidateEffectivenessSummary(params: {
-    phase: "canary" | "published";
-    sampleCount?: number;
-    successCount?: number;
-    failureCount?: number;
-    regressionCount?: number;
-    avgLatencyMs?: number;
-    avgCostUsd?: number;
-    score?: number;
-    staleReason?: string | null;
-    notes?: string | null;
-    summary?: Record<string, unknown> | null;
-    lastObservedAt?: string;
-    updatedAt?: string;
-}): SkillCandidateEffectivenessContract;

package/dist/orchestration/skill-candidate.js

@@ -1,141 +0,0 @@
-import { coerceSkillCandidateJsonObject, normalizeSkillCandidateAction, normalizeSkillCandidateArtifact, normalizeSkillCandidateEffectiveness, normalizeSkillCandidateEffectivenessPhase, normalizeSkillCandidateSourceExecution, } from "../contracts/skill-candidate.js";
-const DEFAULT_SKILL_IMPROVEMENT_POLICY = {
-    reviewRequired: true,
-    canaryRequired: true,
-    autoPromote: false,
-    minCanarySampleCount: 10,
-    minSuccessRate: 0.7,
-    maxRegressionRate: 0.1,
-    maxCostIncreaseRate: 0.25,
-    staleAfterHours: 168,
-};
-function normalizeOptionalBoolean(value, fallback) {
-    if (typeof value === "boolean") {
-        return value;
-    }
-    if (typeof value === "string") {
-        const normalized = value.trim().toLowerCase();
-        if (normalized === "true") {
-            return true;
-        }
-        if (normalized === "false") {
-            return false;
-        }
-    }
-    return fallback;
-}
-function normalizeOptionalFiniteNumber(value, fallback) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed) {
-            const parsed = Number(trimmed);
-            if (Number.isFinite(parsed)) {
-                return parsed;
-            }
-        }
-    }
-    return fallback;
-}
-function normalizeOptionalStringArray(value) {
-    return Array.isArray(value)
-        ? value
-            .filter((entry) => typeof entry === "string")
-            .map((entry) => entry.trim())
-            .filter(Boolean)
-        : [];
-}
-export function createDefaultSkillImprovementPolicy(overrides = {}) {
-    return normalizeSkillImprovementPolicy(overrides, DEFAULT_SKILL_IMPROVEMENT_POLICY);
-}
-export function normalizeSkillImprovementPolicy(value, fallback = DEFAULT_SKILL_IMPROVEMENT_POLICY) {
-    const record = coerceSkillCandidateJsonObject(value);
-    return {
-        reviewRequired: normalizeOptionalBoolean(record.reviewRequired, fallback.reviewRequired),
-        canaryRequired: normalizeOptionalBoolean(record.canaryRequired, fallback.canaryRequired),
-        autoPromote: normalizeOptionalBoolean(record.autoPromote, fallback.autoPromote),
-        minCanarySampleCount: Math.max(1, Math.floor(normalizeOptionalFiniteNumber(record.minCanarySampleCount, fallback.minCanarySampleCount))),
-        minSuccessRate: Math.max(0, Math.min(1, normalizeOptionalFiniteNumber(record.minSuccessRate, fallback.minSuccessRate))),
-        maxRegressionRate: Math.max(0, Math.min(1, normalizeOptionalFiniteNumber(record.maxRegressionRate, fallback.maxRegressionRate))),
-        maxCostIncreaseRate: Math.max(0, normalizeOptionalFiniteNumber(record.maxCostIncreaseRate, fallback.maxCostIncreaseRate)),
-        staleAfterHours: Math.max(1, Math.floor(normalizeOptionalFiniteNumber(record.staleAfterHours, fallback.staleAfterHours))),
-    };
-}
-export function buildSkillCandidateEvidencePayload(params) {
-    const evidence = coerceSkillCandidateJsonObject(params.evidence);
-    const artifact = params.artifact ? normalizeSkillCandidateArtifact(params.artifact) : null;
-    const sourceExecution = params.sourceExecution
-        ? normalizeSkillCandidateSourceExecution(params.sourceExecution)
-        : null;
-    const sourceSessionKey = typeof params.sourceSessionKey === "string"
-        ? params.sourceSessionKey.trim()
-        : "";
-    return {
-        ...evidence,
-        ...(artifact ? { artifact } : {}),
-        ...(sourceExecution ? { sourceExecution } : {}),
-        ...(sourceSessionKey ? { sourceSessionKey } : {}),
-    };
-}
-export function buildSkillCandidateImprovementEvidenceBundle(params) {
-    const evidence = buildSkillCandidateEvidencePayload(params);
-    const diffSummary = typeof params.diffSummary === "string" && params.diffSummary.trim()
-        ? params.diffSummary.trim()
-        : "";
-    const baselineCandidateId = typeof params.baselineCandidateId === "string"
-        && params.baselineCandidateId.trim()
-        ? params.baselineCandidateId.trim()
-        : "";
-    const rolloutNotes = typeof params.rolloutNotes === "string" && params.rolloutNotes.trim()
-        ? params.rolloutNotes.trim()
-        : "";
-    const validationRefs = normalizeOptionalStringArray(params.validationRefs);
-    return {
-        ...evidence,
-        ...(diffSummary ? { diffSummary } : {}),
-        ...(baselineCandidateId ? { baselineCandidateId } : {}),
-        ...(rolloutNotes ? { rolloutNotes } : {}),
-        ...(validationRefs.length > 0 ? { validationRefs } : {}),
-    };
-}
-export function buildSkillCandidateLatestReview(params) {
-    return {
-        action: normalizeSkillCandidateAction(params.action) ?? params.action,
-        actor: typeof params.actor === "string" && params.actor.trim() ? params.actor.trim() : null,
-        notes: typeof params.notes === "string" && params.notes.trim() ? params.notes.trim() : null,
-        payload: coerceSkillCandidateJsonObject(params.payload),
-        createdAt: typeof params.createdAt === "string" && params.createdAt.trim()
-            ? params.createdAt.trim()
-            : new Date().toISOString(),
-    };
-}
-export function buildSkillCandidateEffectivenessSummary(params) {
-    const sampleCount = Math.max(0, Math.floor(params.sampleCount ?? 0));
-    const successCount = Math.max(0, Math.floor(params.successCount ?? 0));
-    const failureCount = Math.max(0, Math.floor(params.failureCount ?? Math.max(sampleCount - successCount, 0)));
-    const regressionCount = Math.max(0, Math.floor(params.regressionCount ?? 0));
-    const successRate = sampleCount > 0 ? successCount / sampleCount : 0;
-    const regressionRate = sampleCount > 0 ? regressionCount / sampleCount : 0;
-    const score = typeof params.score === "number" && Number.isFinite(params.score)
-        ? params.score
-        : Number((successRate - regressionRate).toFixed(4));
-    return normalizeSkillCandidateEffectiveness({
-        phase: normalizeSkillCandidateEffectivenessPhase(params.phase) ?? params.phase,
-        sampleCount,
-        successCount,
-        failureCount,
-        regressionCount,
-        successRate,
-        regressionRate,
-        avgLatencyMs: params.avgLatencyMs,
-        avgCostUsd: params.avgCostUsd,
-        score,
-        staleReason: params.staleReason,
-        notes: params.notes,
-        summary: coerceSkillCandidateJsonObject(params.summary),
-        lastObservedAt: params.lastObservedAt ?? new Date().toISOString(),
-        updatedAt: params.updatedAt ?? new Date().toISOString(),
-    });
-}

package/dist/orchestration/skill-consolidation.d.ts

@@ -1,123 +0,0 @@
-/**
- * Skill consolidation strategy — pure decision logic for
- * the Autonomous Curator's LLM-driven skill merging phase.
- *
- * This module:
- * 1. Detects prefix clusters among skill names.
- * 2. Builds the consolidation prompt for the LLM review agent.
- * 3. Parses structured LLM output into actionable merge/prune plans.
- * 4. Reconciles LLM intent against ground truth (existing skills).
- *
- * No I/O — the caller invokes the LLM and applies the results.
- */
-/** A skill summary fed to the LLM reviewer. */
-export interface ConsolidationSkillSummary {
-    name: string;
-    description: string;
-    /** Comma-separated tool names the skill uses. */
-    tools: string;
-    useCount: number;
-    lastActivityAt: string | null;
-    state: "active" | "stale";
-}
-/** A single consolidation action proposed by the LLM. */
-export interface ConsolidationAction {
-    /** Source skill to be absorbed. */
-    sourceSkill: string;
-    /** Target umbrella skill (existing or to-be-created). */
-    targetUmbrella: string;
-    /** Whether the target umbrella already exists. */
-    targetExists: boolean;
-    /** LLM's reason for the merge. */
-    reason: string;
-}
-/** A single pruning action proposed by the LLM. */
-export interface PruningAction {
-    /** Skill to be archived (not deleted). */
-    skillName: string;
-    /** Reason for pruning. */
-    reason: string;
-}
-/** Full consolidation plan produced by parsing LLM output. */
-export interface ConsolidationPlan {
-    consolidations: ConsolidationAction[];
-    prunings: PruningAction[];
-    /** Skills mentioned by LLM but not found in ground truth. */
-    hallucinations: string[];
-}
-/** Result of reconciling the LLM plan against ground truth. */
-export interface ReconciledConsolidationPlan {
-    /** Validated consolidation actions (targets exist or are marked for creation). */
-    validConsolidations: ConsolidationAction[];
-    /** Validated pruning actions (skills exist). */
-    validPrunings: PruningAction[];
-    /** Rejected actions due to ground-truth mismatch. */
-    rejected: Array<{
-        action: string;
-        reason: string;
-    }>;
-}
-/** A detected cluster of skills sharing a naming prefix. */
-export interface SkillPrefixCluster {
-    prefix: string;
-    skills: string[];
-}
-/**
- * Detect prefix clusters among skill names.
- *
- * A cluster is ≥2 skills sharing a common hyphenated prefix of ≥2 chars.
- * E.g. `["pr-review", "pr-merge", "pr-label"]` → cluster `"pr"`.
- */
-export declare function detectPrefixClusters(skillNames: readonly string[], minClusterSize?: number): SkillPrefixCluster[];
-/**
- * Build the consolidation review prompt for the LLM curator agent.
- *
- * The prompt instructs the model to:
- * 1. Identify prefix clusters and overlapping skills.
- * 2. Propose umbrella consolidations.
- * 3. Mark redundant/trivial skills for pruning (archive, not delete).
- * 4. Output a structured YAML block.
- */
-export declare function buildConsolidationPrompt(candidates: readonly ConsolidationSkillSummary[], existingUmbrellas: readonly string[], clusters: readonly SkillPrefixCluster[]): string;
-/**
- * Parse the LLM's structured YAML response into a ConsolidationPlan.
- *
- * Tolerant: handles minor formatting variations, ignores unknown fields.
- */
-export declare function parseConsolidationOutput(llmOutput: string, knownSkills: ReadonlySet<string>): ConsolidationPlan;
-/**
- * Reconcile the LLM's consolidation plan against ground truth.
- *
- * Validates that:
- * - Source skills exist and aren't already consolidated in this plan.
- * - Target umbrellas either exist or are new (will be created).
- * - Pruning targets aren't also being consolidated.
- */
-export declare function reconcileConsolidationPlan(plan: ConsolidationPlan, knownSkills: ReadonlySet<string>): ReconciledConsolidationPlan;
-/** Summary of a curator review run. */
-export interface CuratorRunReport {
-    /** ISO-8601 timestamp of the run. */
-    runAt: string;
-    /** Duration in seconds. */
-    durationSeconds: number;
-    /** Number of skills checked for lifecycle transitions. */
-    autoTransitionsChecked: number;
-    /** Number of skills marked stale. */
-    autoMarkedStale: number;
-    /** Number of skills archived. */
-    autoArchived: number;
-    /** Number of skills reactivated. */
-    autoReactivated: number;
-    /** Number of LLM-proposed consolidations accepted. */
-    consolidationsAccepted: number;
-    /** Number of LLM-proposed prunings accepted. */
-    pruningsAccepted: number;
-    /** Number of LLM-proposed actions rejected. */
-    actionsRejected: number;
-    /** Number of hallucinated skill names. */
-    hallucinations: number;
-}
-/**
- * Build a human-readable summary from a curator run report.
- */
-export declare function buildCuratorRunSummary(report: CuratorRunReport): string;

package/dist/orchestration/skill-consolidation.js

@@ -1,220 +0,0 @@
-/**
- * Skill consolidation strategy — pure decision logic for
- * the Autonomous Curator's LLM-driven skill merging phase.
- *
- * This module:
- * 1. Detects prefix clusters among skill names.
- * 2. Builds the consolidation prompt for the LLM review agent.
- * 3. Parses structured LLM output into actionable merge/prune plans.
- * 4. Reconciles LLM intent against ground truth (existing skills).
- *
- * No I/O — the caller invokes the LLM and applies the results.
- */
-/**
- * Detect prefix clusters among skill names.
- *
- * A cluster is ≥2 skills sharing a common hyphenated prefix of ≥2 chars.
- * E.g. `["pr-review", "pr-merge", "pr-label"]` → cluster `"pr"`.
- */
-export function detectPrefixClusters(skillNames, minClusterSize = 2) {
-    const prefixMap = new Map();
-    for (const name of skillNames) {
-        const dashIdx = name.indexOf("-");
-        if (dashIdx < 2)
-            continue;
-        const prefix = name.slice(0, dashIdx);
-        const existing = prefixMap.get(prefix);
-        if (existing) {
-            existing.push(name);
-        }
-        else {
-            prefixMap.set(prefix, [name]);
-        }
-    }
-    const clusters = [];
-    for (const [prefix, skills] of prefixMap) {
-        if (skills.length >= minClusterSize) {
-            clusters.push({ prefix, skills: skills.sort() });
-        }
-    }
-    return clusters.sort((a, b) => b.skills.length - a.skills.length);
-}
-// ── LLM prompt construction ────────────────────────────────────────
-/**
- * Build the consolidation review prompt for the LLM curator agent.
- *
- * The prompt instructs the model to:
- * 1. Identify prefix clusters and overlapping skills.
- * 2. Propose umbrella consolidations.
- * 3. Mark redundant/trivial skills for pruning (archive, not delete).
- * 4. Output a structured YAML block.
- */
-export function buildConsolidationPrompt(candidates, existingUmbrellas, clusters) {
-    const candidateList = candidates.map((c) => `- **${c.name}** (${c.state}, uses: ${c.useCount}, tools: ${c.tools})${c.lastActivityAt ? ` last active: ${c.lastActivityAt}` : ""}`).join("\n");
-    const umbrellaList = existingUmbrellas.length > 0
-        ? existingUmbrellas.map((u) => `- ${u}`).join("\n")
-        : "(none)";
-    const clusterList = clusters.length > 0
-        ? clusters.map((c) => `- **${c.prefix}-***: ${c.skills.join(", ")}`).join("\n")
-        : "(no clusters detected)";
-    return `You are the Autonomous Curator for a skill library.
-
-## Goal
-
-Transform narrow, session-specific skills into a well-organized library of
-class-level umbrella skills. A collection of hundreds of narrow skills is FAILURE.
-
-## Ground Rules
-
-1. **NEVER delete** — only archive (prune). Archived skills can be restored.
-2. **Do NOT touch pinned or bundled skills** — they are already filtered out.
-3. **Identify prefix clusters** and merge them into umbrella skills.
-4. **Move session-specific details** into the umbrella's references/ folder.
-5. **Preserve unique value** — only merge if the source is genuinely redundant
-   or a subset of the target.
-
-## Detected Prefix Clusters
-
-${clusterList}
-
-## Existing Umbrella Skills
-
-${umbrellaList}
-
-## Candidate Skills for Review
-
-${candidateList}
-
-## Required Output Format
-
-Respond with EXACTLY this YAML block (no extra text outside the block):
-
-\`\`\`yaml
-consolidations:
-  - source: "skill-name-a"
-    target: "umbrella-skill"
-    reason: "subset of umbrella functionality"
-  - source: "skill-name-b"
-    target: "new-umbrella-name"
-    reason: "cluster merge"
-
-prunings:
-  - skill: "skill-name-c"
-    reason: "trivial single-use, no ongoing value"
-\`\`\`
-
-If no consolidations or prunings are warranted, use empty lists.
-Respond ONLY with the YAML block.`;
-}
-// ── LLM output parsing ─────────────────────────────────────────────
-/**
- * Parse the LLM's structured YAML response into a ConsolidationPlan.
- *
- * Tolerant: handles minor formatting variations, ignores unknown fields.
- */
-export function parseConsolidationOutput(llmOutput, knownSkills) {
-    const consolidations = [];
-    const prunings = [];
-    const hallucinations = [];
-    // Extract YAML block if wrapped in ```yaml ... ```
-    const yamlMatch = llmOutput.match(/```(?:yaml)?\s*\n([\s\S]*?)```/);
-    const yaml = yamlMatch ? yamlMatch[1] : llmOutput;
-    // Parse consolidations
-    const consolidationBlock = yaml.match(/consolidations:\s*\n((?:\s+-[\s\S]*?)?)(?=prunings:|$)/);
-    if (consolidationBlock?.[1]) {
-        const entries = consolidationBlock[1].matchAll(/- source:\s*"([^"]+)"\s*\n\s*target:\s*"([^"]+)"\s*\n\s*reason:\s*"([^"]+)"/g);
-        for (const [, source, target, reason] of entries) {
-            if (!knownSkills.has(source)) {
-                hallucinations.push(source);
-                continue;
-            }
-            consolidations.push({
-                sourceSkill: source,
-                targetUmbrella: target,
-                targetExists: knownSkills.has(target),
-                reason,
-            });
-        }
-    }
-    // Parse prunings
-    const pruningBlock = yaml.match(/prunings:\s*\n([\s\S]*?)$/);
-    if (pruningBlock?.[1]) {
-        const entries = pruningBlock[1].matchAll(/- skill:\s*"([^"]+)"\s*\n\s*reason:\s*"([^"]+)"/g);
-        for (const [, skill, reason] of entries) {
-            if (!knownSkills.has(skill)) {
-                hallucinations.push(skill);
-                continue;
-            }
-            prunings.push({ skillName: skill, reason });
-        }
-    }
-    return { consolidations, prunings, hallucinations };
-}
-// ── Reconciliation ─────────────────────────────────────────────────
-/**
- * Reconcile the LLM's consolidation plan against ground truth.
- *
- * Validates that:
- * - Source skills exist and aren't already consolidated in this plan.
- * - Target umbrellas either exist or are new (will be created).
- * - Pruning targets aren't also being consolidated.
- */
-export function reconcileConsolidationPlan(plan, knownSkills) {
-    const validConsolidations = [];
-    const validPrunings = [];
-    const rejected = [];
-    const consolidatedSources = new Set();
-    for (const c of plan.consolidations) {
-        if (!knownSkills.has(c.sourceSkill)) {
-            rejected.push({
-                action: `consolidate ${c.sourceSkill} → ${c.targetUmbrella}`,
-                reason: `source skill "${c.sourceSkill}" not found`,
-            });
-            continue;
-        }
-        if (consolidatedSources.has(c.sourceSkill)) {
-            rejected.push({
-                action: `consolidate ${c.sourceSkill} → ${c.targetUmbrella}`,
-                reason: `source skill "${c.sourceSkill}" already consolidated in this plan`,
-            });
-            continue;
-        }
-        if (c.sourceSkill === c.targetUmbrella) {
-            rejected.push({
-                action: `consolidate ${c.sourceSkill} → ${c.targetUmbrella}`,
-                reason: "source and target are the same skill",
-            });
-            continue;
-        }
-        consolidatedSources.add(c.sourceSkill);
-        validConsolidations.push(c);
-    }
-    for (const p of plan.prunings) {
-        if (!knownSkills.has(p.skillName)) {
-            rejected.push({
-                action: `prune ${p.skillName}`,
-                reason: `skill "${p.skillName}" not found`,
-            });
-            continue;
-        }
-        if (consolidatedSources.has(p.skillName)) {
-            rejected.push({
-                action: `prune ${p.skillName}`,
-                reason: `skill "${p.skillName}" is being consolidated, not pruned`,
-            });
-            continue;
-        }
-        validPrunings.push(p);
-    }
-    return { validConsolidations, validPrunings, rejected };
-}
-/**
- * Build a human-readable summary from a curator run report.
- */
-export function buildCuratorRunSummary(report) {
-    const parts = [];
-    parts.push(`Curator run at ${report.runAt} (${report.durationSeconds.toFixed(1)}s)`);
-    parts.push(`Auto: ${report.autoTransitionsChecked} checked, ${report.autoMarkedStale} stale, ${report.autoArchived} archived, ${report.autoReactivated} reactivated`);
-    parts.push(`LLM: ${report.consolidationsAccepted} consolidated, ${report.pruningsAccepted} pruned, ${report.actionsRejected} rejected, ${report.hallucinations} hallucinated`);
-    return parts.join("; ");
-}