agentera 3.0.0-dev.6 → 3.0.0-dev.69

package/dist/analytics/extractCorpus/extractCorpusParity.js

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ADAPTER_VERSION, COPILOT_SPARSE_REMEDIATION, FAMILIES, MAX_SQLITE_ROWS, MAX_SQLITE_SESSIONS, MAX_TOOL_ARG_TEXT, RUNTIME_STORE_GLOBS, discoverRuntimeStore, } from "./core.js";
+import { buildCorpus } from "./corpus.js";
+import { runCoverageAudit } from "./coverageAudit.js";
+import { extractOpencodeSessions } from "./sqliteSessions.js";
+export const EXTRACT_CORPUS_PARITY_SCHEMA = "agentera-extract-corpus-parity-v1";
+export function buildExtractCorpusParityManifest() {
+    return {
+        schema_version: EXTRACT_CORPUS_PARITY_SCHEMA,
+        adapter_version: ADAPTER_VERSION,
+        max_sqlite_sessions: MAX_SQLITE_SESSIONS,
+        max_sqlite_rows: MAX_SQLITE_ROWS,
+        max_tool_arg_text: MAX_TOOL_ARG_TEXT,
+        copilot_sparse_remediation: COPILOT_SPARSE_REMEDIATION,
+        runtime_store_globs: { ...RUNTIME_STORE_GLOBS },
+        families: [...FAMILIES],
+    };
+}
+function trackEarliest(current, candidate) {
+    if (!candidate)
+        return current;
+    if (current === null)
+        return candidate;
+    return candidate < current ? candidate : current;
+}
+function trackLatest(current, candidate) {
+    if (!candidate)
+        return current;
+    if (current === null)
+        return candidate;
+    return candidate > current ? candidate : current;
+}
+function boundsFromRecords(records) {
+    let earliest = null;
+    let latest = null;
+    for (const item of records) {
+        const ts = typeof item.timestamp === "string" ? item.timestamp : null;
+        earliest = trackEarliest(earliest, ts);
+        latest = trackLatest(latest, ts);
+    }
+    return { earliest, latest };
+}
+/** Production opencode parity snapshot compared with the generated independent Python oracle. */
+export function opencodeParitySnapshot(dbPath) {
+    if (!fs.existsSync(dbPath)) {
+        throw new Error(`extract-corpus parity: missing opencode db at ${dbPath}`);
+    }
+    const audit = runCoverageAudit({
+        output: dbPath,
+        tierOutput: null,
+        projectRoot: [path.dirname(dbPath)],
+        codexSessionsDir: path.join(path.dirname(dbPath), "unused-codex"),
+        claudeProjectsDir: null,
+        opencodeConversationsDir: dbPath,
+        copilotConversationsDir: null,
+        cursorProjectsDir: null,
+        cursorChatsDir: null,
+        noCodex: true,
+        importSources: [],
+        noOpencode: false,
+        noCopilot: true,
+        noCursor: true,
+        acceptCoverageGap: false,
+        coverageAuditOnly: false,
+        format: "text",
+    }, {});
+    const coverageEntry = audit.runtimes.find((entry) => entry.runtime === "opencode");
+    const coverageProbe = {
+        record_count: 0,
+        earliest: coverageEntry?.earliest_session ?? null,
+        latest: coverageEntry?.latest_session ?? null,
+    };
+    const errors = [];
+    const extracted = extractOpencodeSessions(dbPath, errors);
+    const extractionBounds = boundsFromRecords(extracted);
+    const extractionProbe = {
+        record_count: extracted.length,
+        earliest: extractionBounds.earliest,
+        latest: extractionBounds.latest,
+    };
+    const corpus = buildCorpus({
+        projectRoots: [],
+        codexSessionsDir: null,
+        claudeProjectsDir: null,
+        opencodeConversationsDir: dbPath,
+    });
+    const runtimeStatus = corpus.metadata.runtime_statuses.find((status) => status.runtime === "opencode");
+    const recordCount = runtimeStatus?.record_count ?? extracted.length;
+    const discovery = discoverRuntimeStore("opencode", dbPath);
+    const discoveryShape = {
+        status: String(discovery.status),
+        file_count: typeof discovery.file_count === "number" ? discovery.file_count : null,
+    };
+    return {
+        record_count: recordCount,
+        earliest: coverageProbe.earliest,
+        latest: coverageProbe.latest,
+        probe_shapes: {
+            coverage: coverageProbe,
+            extraction: extractionProbe,
+            discovery: discoveryShape,
+        },
+    };
+}

package/dist/analytics/extractCorpus/filesystemSources.js

@@ -4,10 +4,7 @@ import { resolvePath } from "../../core/paths.js";
 import { isPlainObject, isoFromMtime, record, splitLines, } from "./core.js";
 export function extractInstructionDocuments(projectRoots, errors) {
     const records = [];
-    const docNames = [
-        ["AGENTS.md", "agents_md"],
-        ["CLAUDE.md", "claude_md"],
-    ];
+    const docNames = [["AGENTS.md", "agents_md"]];
     for (const root of projectRoots) {
         for (const [filename, docType] of docNames) {
             const p = path.join(root, filename);
@@ -119,4 +116,3 @@ export function extractProjectConfigSignals(projectRoots, errors) {
     }
     return records;
 }
-//# sourceMappingURL=filesystemSources.js.map

package/dist/analytics/extractCorpus/index.js

@@ -5,5 +5,10 @@ export { extractOpencodeSessions, PermissionDeniedError } from "./sqliteSessions
 export { extractCopilotSessions } from "./copilotSessions.js";
 export { resolveOpencodeDbPath, resolveCopilotStorePath, resolveCursorProjectsPath, resolveCursorChatsPath, cursorWorkspaceHash, cursorProjectDirSlug, extractCursorSessions, extractCursorAgentSessions, } from "./cursorSessions.js";
 export { ExtractionNotImplementedError, dedupeRecords, buildMetadata, buildCorpus } from "./corpus.js";
+export { formatTruncationWarnings, resolveSqliteCaps, } from "./sqliteCaps.js";
+export { COVERAGE_EXIT_FLAGGED, corpusEnvelopeCoverage, formatCoverageSummaryText, resolveRuntimeStoreConfigs, runCoverageAudit, } from "./coverageAudit.js";
 export { parseExtractArgs, extractCorpusMain } from "./cli.js";
-//# sourceMappingURL=index.js.map
+export { TIER_SCHEMA_VERSION, CURRENT_POINTER_VERSION, defaultTiersDir, familyOf, deriveSignalRecords, shardFullEvidence, selectSignalsForBound, generationId, publishEvidenceTiers, readCurrentPointer, readCurrentGeneration, readSignalTier, getFullRecord, resolveEvidenceAnchor, evidenceTierCompatibility, iterTierRecords, readTierCorpusMetadata, } from "./evidenceTiers.js";
+export { tiersDirForCorpusPath, resolveTiersDir, isAnalyzable, recoveryForState, assessTiers, readBoundedMetadata, iterBoundedRecords, legacyCorpusReadable, } from "./tierReader.js";
+export { EXTRACT_CORPUS_PARITY_SCHEMA, buildExtractCorpusParityManifest, opencodeParitySnapshot, } from "./extractCorpusParity.js";
+export { readProfileSignals, resolveProfileEvidence, profileSignalsStatus, assessProfileSufficiency, } from "../profileSignals.js";

package/dist/analytics/extractCorpus/jsonlSessions.js

@@ -111,7 +111,18 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
             const cwd = event.cwd || event.workingDirectory || event.working_directory;
             if (typeof cwd === "string" && cwd)
                 projectPath = cwd;
-            const toolRecord = toolCallRecord({ event, fallbackTimestamp, projectPath, runtime: "claude-code", sourcePath: p, index, sessionId });
+            const toolRecord = toolCallRecord({
+                event,
+                fallbackTimestamp,
+                projectPath,
+                runtime: null,
+                sourceClass: "historical_import",
+                sourceProduct: "claude-code",
+                activeRuntime: false,
+                sourcePath: p,
+                index,
+                sessionId,
+            });
             if (toolRecord !== null) {
                 records.push(toolRecord);
                 continue;
@@ -124,7 +135,10 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
                     event,
                     fallbackTimestamp,
                     projectPath,
-                    runtime: "claude-code",
+                    runtime: null,
+                    sourceClass: "historical_import",
+                    sourceProduct: "claude-code",
+                    activeRuntime: false,
                     sourcePath: p,
                     index: index * 1000 + contentIndex,
                     sessionId,
@@ -159,7 +173,10 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
                 sourceKind: "conversation_turn",
                 timestamp,
                 projectPath,
-                runtime: "claude-code",
+                runtime: null,
+                sourceClass: "historical_import",
+                sourceProduct: "claude-code",
+                activeRuntime: false,
                 sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
                 sessionId,
                 data,
@@ -171,7 +188,10 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
                         sourceKind: "history_prompt",
                         timestamp,
                         projectPath,
-                        runtime: "claude-code",
+                        runtime: null,
+                        sourceClass: "historical_import",
+                        sourceProduct: "claude-code",
+                        activeRuntime: false,
                         sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
                         sessionId,
                         data: { prompt: content, signal_type: sig },
@@ -182,4 +202,3 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
     }
     return records;
 }
-//# sourceMappingURL=jsonlSessions.js.map

package/dist/analytics/extractCorpus/sqliteCaps.js

@@ -0,0 +1,43 @@
+import { MAX_SQLITE_ROWS, MAX_SQLITE_SESSIONS, } from "./core.js";
+function parsePositiveCap(value, fallback, label) {
+    if (value === undefined || value === "")
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        throw new Error(`extract-corpus: invalid ${label}: ${value}`);
+    }
+    return parsed;
+}
+export function resolveSqliteCaps(env = process.env, cliOverrides) {
+    return {
+        maxSessions: cliOverrides?.maxSessions ??
+            parsePositiveCap(env.AGENTERA_EXTRACT_MAX_SQLITE_SESSIONS, MAX_SQLITE_SESSIONS, "max sqlite sessions cap"),
+        maxRows: cliOverrides?.maxRows ??
+            parsePositiveCap(env.AGENTERA_EXTRACT_MAX_SQLITE_ROWS, MAX_SQLITE_ROWS, "max sqlite rows cap"),
+    };
+}
+export function formatTruncationWarnings(runtimeStatuses) {
+    const lines = [];
+    for (const status of runtimeStatuses) {
+        const truncatedAt = status.truncated_at;
+        if (typeof truncatedAt !== "string" || !truncatedAt)
+            continue;
+        const runtime = typeof status.runtime === "string" ? status.runtime : "unknown";
+        const cap = typeof status.truncation_cap === "string" ? status.truncation_cap : "cap";
+        const limit = status.truncation_limit ?? "?";
+        lines.push(`  ${runtime}: truncated at ${truncatedAt} (${cap} limit=${limit})`);
+    }
+    if (lines.length === 0)
+        return "";
+    return ["SQLite extraction truncated (history beyond cap omitted):", ...lines].join("\n");
+}
+export function applyTruncationToStatus(status, truncation) {
+    if (!truncation)
+        return status;
+    return {
+        ...status,
+        truncated_at: truncation.truncatedAt,
+        truncation_cap: truncation.cap,
+        truncation_limit: truncation.limit,
+    };
+}

package/dist/analytics/extractCorpus/sqliteSessions.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import { resolvePath } from "../../core/paths.js";
-import { MAX_SQLITE_ROWS, MAX_SQLITE_SESSIONS, isoFromMtime, record, signalType, textFromContent, } from "./core.js";
+import { isoFromMtime, record, signalType, textFromContent, } from "./core.js";
 import { isPlainObject, isFilePath, rglob } from "./core.js";
+import { resolveSqliteCaps, } from "./sqliteCaps.js";
 const requireCjs = createRequire(import.meta.url);
 /** Mirrors Python raising PermissionError on a locked/busy store. */
 export class PermissionDeniedError extends Error {
@@ -63,7 +64,7 @@ export function qualified(alias, column, label) {
     const escaped = column.replace(/"/g, '""');
     return `${alias}."${escaped}" AS ${label}`;
 }
-function opencodeRows(conn) {
+function resolveOpencodeSchema(conn) {
     const tables = new Set(conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => String(r.name)));
     for (const t of ["session", "message", "part"]) {
         if (!tables.has(t)) {
@@ -96,6 +97,29 @@ function opencodeRows(conn) {
     const partId = firstColumn(partCols, ["id", "part_id", "partID"]);
     const sortExpr = `COALESCE(m."${messageTime || messageId}", p."${partTime || partMessage}", s."${sessionTime || sessionId}")`;
     const recentSessionExpr = `s."${sessionUpdated || sessionTime || sessionId}"`;
+    return {
+        sessionId,
+        messageId,
+        messageSession,
+        partMessage,
+        messageData,
+        partData,
+        roleCol,
+        messageTime,
+        partTime,
+        sessionTime,
+        sessionUpdated,
+        projectCol,
+        messageText,
+        partText,
+        partType,
+        partId,
+        sortExpr,
+        recentSessionExpr,
+    };
+}
+function opencodeRows(conn, caps, schema) {
+    const { sessionId, messageId, messageSession, partMessage, messageData, partData, roleCol, messageTime, partTime, sessionTime, projectCol, messageText, partText, partType, partId, sortExpr, recentSessionExpr, } = schema;
     const query = `
         WITH recent_sessions AS (
             SELECT s."${sessionId}" AS recent_session_id
@@ -135,16 +159,81 @@ function opencodeRows(conn) {
         FROM recent
         ORDER BY sort_time, message_id, part_id
     `;
-    return conn.prepare(query).all(MAX_SQLITE_SESSIONS, MAX_SQLITE_ROWS);
+    return conn.prepare(query).all(caps.maxSessions, caps.maxRows);
+}
+export function probeOpencodeTruncation(conn, caps, fallback) {
+    const schema = resolveOpencodeSchema(conn);
+    const { sessionId, sessionTime, sessionUpdated, recentSessionExpr } = schema;
+    const sessionTimeCol = sessionTime || sessionId;
+    const sessionCount = Number(conn.prepare("SELECT COUNT(*) AS c FROM session").get()?.c ?? 0);
+    if (sessionCount > caps.maxSessions) {
+        const query = `
+      SELECT MIN(session_ts) AS truncated_at
+      FROM (
+        SELECT s."${sessionTimeCol}" AS session_ts
+        FROM session s
+        ORDER BY ${recentSessionExpr} DESC,
+                 s."${sessionId}" DESC
+        LIMIT -1 OFFSET ?
+      )
+    `;
+        const row = conn.prepare(query).get(caps.maxSessions);
+        const truncatedAt = sqliteTimestamp(row?.truncated_at, fallback);
+        return { truncatedAt, cap: "sessions", limit: caps.maxSessions };
+    }
+    const { messageId, messageSession, partMessage, roleCol, messageTime, partTime, messageData, partData, messageText, partText, partType, partId, sortExpr, } = schema;
+    const rowCountQuery = `
+    WITH recent_sessions AS (
+      SELECT s."${sessionId}" AS recent_session_id
+      FROM session s
+      ORDER BY ${recentSessionExpr} DESC,
+               s."${sessionId}" DESC
+      LIMIT ?
+    )
+    SELECT COUNT(*) AS c
+    FROM message m
+    JOIN session s ON m."${messageSession}" = s."${sessionId}"
+    JOIN recent_sessions rs ON rs.recent_session_id = s."${sessionId}"
+    LEFT JOIN part p ON p."${partMessage}" = m."${messageId}"
+  `;
+    const rowCount = Number(conn.prepare(rowCountQuery).get(caps.maxSessions)?.c ?? 0);
+    if (rowCount > caps.maxRows) {
+        const query = `
+      WITH recent_sessions AS (
+        SELECT s."${sessionId}" AS recent_session_id
+        FROM session s
+        ORDER BY ${recentSessionExpr} DESC,
+                 s."${sessionId}" DESC
+        LIMIT ?
+      ),
+      ranked AS (
+        SELECT ${sortExpr} AS sort_time
+        FROM message m
+        JOIN session s ON m."${messageSession}" = s."${sessionId}"
+        JOIN recent_sessions rs ON rs.recent_session_id = s."${sessionId}"
+        LEFT JOIN part p ON p."${partMessage}" = m."${messageId}"
+        ORDER BY sort_time DESC,
+                 m."${messageId}" DESC,
+                 p."${partId || partMessage}" DESC
+        LIMIT -1 OFFSET ?
+      )
+      SELECT MIN(sort_time) AS truncated_at FROM ranked
+    `;
+        const row = conn.prepare(query).get(caps.maxSessions, caps.maxRows);
+        const truncatedAt = sqliteTimestamp(row?.truncated_at, fallback);
+        return { truncatedAt, cap: "rows", limit: caps.maxRows };
+    }
+    return null;
 }
 function opencodeDbCandidates(storePath) {
     if (isFilePath(storePath))
         return [storePath];
     return rglob(storePath, "opencode.db");
 }
-export function extractOpencodeSessions(storePath, errors) {
+export function extractOpencodeSessions(storePath, errors, ctx) {
     if (storePath === null || !fs.existsSync(storePath))
         return [];
+    const caps = ctx?.sqliteCaps ?? resolveSqliteCaps();
     const records = [];
     for (const dbPath of opencodeDbCandidates(storePath).slice(0, 1)) {
         const fallbackTimestamp = isoFromMtime(dbPath);
@@ -152,7 +241,11 @@ export function extractOpencodeSessions(storePath, errors) {
         let conn = null;
         try {
             conn = openSqlite(dbPath);
-            rows = opencodeRows(conn);
+            const truncation = probeOpencodeTruncation(conn, caps, fallbackTimestamp);
+            if (truncation && ctx)
+                ctx.truncation = truncation;
+            const schema = resolveOpencodeSchema(conn);
+            rows = opencodeRows(conn, caps, schema);
         }
         catch (exc) {
             const msg = exc.message || "";
@@ -272,4 +365,3 @@ export function extractOpencodeSessions(storePath, errors) {
     }
     return records;
 }
-//# sourceMappingURL=sqliteSessions.js.map

package/dist/analytics/extractCorpus/tierReader.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { compatibilityStates, evidenceTierBounds, } from "../../registries/evidenceTierContract.js";
+import { defaultTiersDir, evidenceTierCompatibility, iterTierRecords, readSignalTier, readTierCorpusMetadata, } from "./evidenceTiers.js";
+/**
+ * Bounded tier reader for analytics consumers (plan Task 3).
+ *
+ * Task 2 publishes bounded full-evidence shards and a bounded signal tier with
+ * an atomic generation pointer. This module is the consumer-side surface that
+ * projects the contract's compatibility states and recovery guidance, resolves
+ * the tiers directory from a corpus path, and exposes bounded reads (full-evidence
+ * records one shard at a time; metadata/signal reads without full records). It does
+ * not duplicate the tier map, source families, bounds, or compatibility outcomes —
+ * those are projected from `evidenceTierContract` and `evidenceTiers`.
+ *
+ * Consumers preserve their JSON output shape and exit codes. A non-current tier
+ * degrades with actionable, contract-projected recovery rather than indefinitely
+ * loading an oversized monolithic corpus envelope. `incomplete` is a degrade
+ * outcome: consumers analyze available sources and surface the coverage gap, so a
+ * host missing some runtimes still gets useful analysis instead of a hard failure.
+ */
+/** A corpus path's co-located tiers directory (`<intermediate>/tiers`). */
+export function tiersDirForCorpusPath(corpusPath) {
+    return path.join(path.dirname(corpusPath), "tiers");
+}
+/** Canonical tiers directory for the stats profile. */
+export function resolveTiersDir(env = process.env, platform = process.platform) {
+    return defaultTiersDir(env, platform);
+}
+/** Whether a compatibility state still permits analysis of available sources. */
+export function isAnalyzable(state) {
+    return state === "current" || state === "incomplete";
+}
+/**
+ * Actionable recovery guidance projected from the authority contract for a
+ * compatibility state. The contract owns the recovery text; this never
+ * duplicates it. Returns `null` for states that proceed (current/incomplete).
+ */
+export function recoveryForState(state) {
+    if (state === "current" || state === "incomplete")
+        return null;
+    const states = compatibilityStates();
+    const def = states.find((s) => s.state_id === state);
+    return def?.recovery ?? null;
+}
+/**
+ * Assess the tiers directory against the contract's compatibility states. When a
+ * legacy corpus envelope is supplied, a missing tier with an existing envelope
+ * surfaces as `legacy` (refresh guidance) rather than a bare missing state.
+ */
+export function assessTiers(tiersDir, corpusPath) {
+    const compat = evidenceTierCompatibility(tiersDir, corpusPath);
+    const assessment = {
+        state: compat.state,
+        analyzable: isAnalyzable(compat.state),
+        tiersDir,
+        corpusPath,
+        recovery: recoveryForState(compat.state) ?? undefined,
+    };
+    if (compat.state === "incomplete")
+        assessment.coverageGaps = compat.detail;
+    if (compat.state === "oversized")
+        assessment.artifact = compat.artifact;
+    if (compat.state === "current")
+        assessment.generation = compat.generation;
+    return assessment;
+}
+/**
+ * Read bounded metadata for signal-tier consumers (report status, prime
+ * coverage). Reads the manifest and the bounded signal tier only — never the
+ * full-evidence shards — so metadata consumers stay bounded at real scale. The
+ * signal tier is bounded by construction; a defensively oversized signal tier is
+ * reported as null so the caller degrades with the assessment's recovery.
+ */
+export function readBoundedMetadata(tiersDir) {
+    const signal = readSignalTier(tiersDir);
+    const corpusMetadata = readTierCorpusMetadata(tiersDir);
+    const bounds = evidenceTierBounds();
+    if (signal && (signal.bytes > bounds.signalByteCap || signal.manifest.signal.bytes > bounds.signalByteCap)) {
+        return { corpusMetadata: null, signal: null, manifest: signal.manifest };
+    }
+    return { corpusMetadata, signal, manifest: signal?.manifest ?? null };
+}
+/**
+ * Iterate full-evidence records for the current generation, one bounded shard at
+ * a time. Full-record consumers (usage analytics, startup analysis) use this so
+ * they never materialize the monolithic corpus envelope. Returns `null` when no
+ * current generation exists; callers report the assessment instead.
+ */
+export function iterBoundedRecords(tiersDir) {
+    return iterTierRecords(tiersDir);
+}
+/**
+ * Legacy fallback: a small monolithic corpus envelope may still be read for
+ * backward compatibility when no tiers were published. Oversized legacy state
+ * is never loaded whole — it returns `false` so the caller emits refresh guidance.
+ */
+export function legacyCorpusReadable(corpusPath) {
+    if (!corpusPath || !fs.existsSync(corpusPath))
+        return false;
+    const bounds = evidenceTierBounds();
+    try {
+        return fs.statSync(corpusPath).size <= bounds.readerByteCap;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/analytics/extractCorpus.js

@@ -1,3 +1,2 @@
 /** Barrel: stable import path for corpus extraction (split across ./extractCorpus/). */
 export * from "./extractCorpus/index.js";
-//# sourceMappingURL=extractCorpus.js.map

package/dist/analytics/glossaryAdviceResolution.js

@@ -0,0 +1,166 @@
+import { glossaryAdviceContract, } from "../registries/glossaryAdviceContract.js";
+import { unicodeCaselessExact } from "../registries/glossaryTermIdentity.js";
+const RECOVERY = {
+    invalid_request: "Provide one non-empty bounded requested term and retry advice resolution.",
+    invalid_acquisition: "Reacquire bounded glossary inputs and retry advice resolution.",
+    invalid_host_review: "Provide one contract-declared relation to a valid acquired personal candidate and retry advice resolution.",
+};
+export class GlossaryAdviceInputError extends Error {
+    code;
+    constructor(code) {
+        super(RECOVERY[code]);
+        this.code = code;
+        this.name = "GlossaryAdviceInputError";
+    }
+}
+function hasOnlyKeys(value, expected) {
+    const keys = Object.keys(value).sort();
+    return (keys.length === expected.length &&
+        keys.every((key, index) => key === [...expected].sort()[index]));
+}
+function boundedNonEmpty(value, maxBytes) {
+    return (typeof value === "string" &&
+        value.trim().length > 0 &&
+        Buffer.byteLength(value, "utf8") <= maxBytes);
+}
+function validateEntries(source, owner, maxEntries, maxBytes) {
+    if (!Array.isArray(source.entries) || source.entries.length > maxEntries) {
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    }
+    const terms = [];
+    for (const candidate of source.entries) {
+        if (candidate === null ||
+            typeof candidate !== "object" ||
+            !hasOnlyKeys(candidate, ["term", "meaning", "owner"]) ||
+            candidate.owner !== owner ||
+            !boundedNonEmpty(candidate.term, maxBytes) ||
+            !boundedNonEmpty(candidate.meaning, maxBytes)) {
+            throw new GlossaryAdviceInputError("invalid_acquisition");
+        }
+        if (terms.some((term) => unicodeCaselessExact(term, candidate.term))) {
+            throw new GlossaryAdviceInputError("invalid_acquisition");
+        }
+        terms.push(candidate.term);
+    }
+}
+function validateSource(source, owner, maxEntries, maxBytes, availabilityStates) {
+    if (source === null ||
+        typeof source !== "object" ||
+        !hasOnlyKeys(source, ["owner", "availability", "entries", "gap_proving", "diagnostic"])) {
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    }
+    const candidate = source;
+    if (candidate.owner !== owner ||
+        !availabilityStates.includes(candidate.availability) ||
+        typeof candidate.gap_proving !== "boolean") {
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    }
+    validateEntries(candidate, owner, maxEntries, maxBytes);
+    const valid = ["absent", "valid_empty", "valid_present"].includes(candidate.availability);
+    const expectedGap = owner === "project" && ["absent", "valid_empty"].includes(candidate.availability);
+    if (valid) {
+        const expectedEntryPresence = candidate.availability === "valid_present";
+        if (candidate.diagnostic !== null ||
+            candidate.gap_proving !== expectedGap ||
+            expectedEntryPresence !== candidate.entries.length > 0) {
+            throw new GlossaryAdviceInputError("invalid_acquisition");
+        }
+        return;
+    }
+    const diagnostic = candidate.diagnostic;
+    if (candidate.entries.length !== 0 ||
+        candidate.gap_proving ||
+        diagnostic === null ||
+        typeof diagnostic !== "object" ||
+        !hasOnlyKeys(diagnostic, ["class", "recovery"]) ||
+        diagnostic.class !== candidate.availability ||
+        typeof diagnostic.recovery !== "string" ||
+        diagnostic.recovery.trim().length === 0) {
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    }
+}
+function validateAcquired(acquired, contract) {
+    if (acquired === null ||
+        typeof acquired !== "object" ||
+        !hasOnlyKeys(acquired, ["project", "personal"])) {
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    }
+    const candidate = acquired;
+    validateSource(candidate.project, "project", contract.maxEntries, contract.maxRequestedTermUtf8Bytes, contract.availabilityStates);
+    validateSource(candidate.personal, "personal", contract.maxEntries, contract.maxRequestedTermUtf8Bytes, contract.availabilityStates);
+}
+function exactEntry(entries, requestedTerm) {
+    return entries.find((candidate) => unicodeCaselessExact(candidate.term, requestedTerm));
+}
+function validatedHostReview(requestedTerm, personal, hostReview, contract) {
+    if (hostReview === undefined)
+        return undefined;
+    if (hostReview === null ||
+        typeof hostReview !== "object" ||
+        !hasOnlyKeys(hostReview, ["relation", "candidate_owner", "candidate_term"])) {
+        throw new GlossaryAdviceInputError("invalid_host_review");
+    }
+    const candidate = hostReview;
+    if (!contract.hostReviewRelations.includes(candidate.relation) ||
+        !contract.hostReviewCandidateOwners.includes(candidate.candidate_owner) ||
+        !boundedNonEmpty(candidate.candidate_term, contract.maxRequestedTermUtf8Bytes) ||
+        unicodeCaselessExact(candidate.candidate_term, requestedTerm) ||
+        !personal.entries.some((entry) => unicodeCaselessExact(entry.term, candidate.candidate_term))) {
+        throw new GlossaryAdviceInputError("invalid_host_review");
+    }
+    return candidate;
+}
+export function classifyGlossaryAdviceInputs(requestedTerm, acquired, hostReview) {
+    const projectExact = exactEntry(acquired.project.entries, requestedTerm);
+    const personalExact = exactEntry(acquired.personal.entries, requestedTerm);
+    const projectValid = ["absent", "valid_empty", "valid_present"].includes(acquired.project.availability);
+    const personalUsable = ["valid_empty", "valid_present"].includes(acquired.personal.availability);
+    return {
+        project_input: !projectValid ? "invalid" : projectExact ? "valid_exact" : "valid_gap",
+        personal_input: personalExact
+            ? "valid_exact"
+            : personalUsable
+                ? "valid_without_exact"
+                : "invalid",
+        exact_meaning: projectExact && personalExact
+            ? projectExact.meaning === personalExact.meaning
+                ? "equivalent"
+                : "divergent"
+            : "not_applicable",
+        inferred_candidate: hostReview ? "present" : "absent",
+    };
+}
+function matches(match, state) {
+    return Object.entries(state).every(([dimension, value]) => match[dimension]?.includes(value));
+}
+export function resolveGlossaryAdvice(requestedTerm, acquired, hostReview) {
+    const contract = glossaryAdviceContract();
+    if (!boundedNonEmpty(requestedTerm, contract.maxRequestedTermUtf8Bytes)) {
+        throw new GlossaryAdviceInputError("invalid_request");
+    }
+    validateAcquired(acquired, contract);
+    const review = validatedHostReview(requestedTerm, acquired.personal, hostReview, contract);
+    const state = classifyGlossaryAdviceInputs(requestedTerm, acquired, review);
+    const rows = contract.rows.filter((row) => matches(row.match, state));
+    if (rows.length !== 1)
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    const row = rows[0];
+    const selectedOwner = row.selectedOwner === "project" || row.selectedOwner === "personal" ? row.selectedOwner : null;
+    const selectedEntry = selectedOwner
+        ? exactEntry(acquired[selectedOwner].entries, requestedTerm)
+        : undefined;
+    const advisories = contract.advisories.filter((advisory) => advisory.primaryOutcome === row.name && matches(advisory.match, state));
+    if (advisories.length > 1)
+        throw new GlossaryAdviceInputError("invalid_acquisition");
+    const advisory = advisories[0];
+    return {
+        outcome: row.name,
+        applicable_meaning: selectedEntry?.meaning ?? null,
+        applicable_owner: selectedOwner,
+        review: advisory?.review ?? row.review,
+        tension: row.tension,
+        advisory: advisory
+            ? { reason: advisory.caveatReason, ownership_state: advisory.ownershipState }
+            : null,
+    };
+}