context-probe 0.1.0

package/dist/src/core/contracts/governance-review.d.ts

@@ -0,0 +1,31 @@
+export type ReviewItemKind = "proxy" | "missing_input" | "low_confidence" | "collision" | "history_hotspot" | "unknown";
+export interface ReviewItem {
+    reviewItemId: string;
+    reason: string;
+    kind?: ReviewItemKind;
+    summary: string;
+    confidence: number;
+    evidenceRefs: string[];
+    targetEntityId?: string;
+    suggestedPatch?: Record<string, unknown>;
+}
+export interface ReviewResolution {
+    reviewItemId: string;
+    status: string;
+    decision?: {
+        patch?: Record<string, unknown>;
+    };
+    note?: string;
+    reviewedAt?: string;
+}
+export interface ResolvedReviewItem extends ReviewItem {
+    resolution?: ReviewResolution | null;
+}
+export interface ReviewResolutionLog {
+    reviewItems: ResolvedReviewItem[];
+    overrides: Array<{
+        targetEntityId: string;
+        patch: Record<string, unknown>;
+        reason: string;
+    }>;
+}

package/dist/src/core/contracts/governance-review.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/contracts/governance-runtime.d.ts

@@ -0,0 +1,12 @@
+import type { ProgressUpdate } from "./common.js";
+export interface DomainPack {
+    id: string;
+    version: string;
+    commands: string[];
+    metrics: string[];
+    reviewRules: string[];
+}
+export interface CommandContext {
+    cwd: string;
+    reportProgress?: (update: ProgressUpdate) => void;
+}

package/dist/src/core/contracts/governance-runtime.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/contracts/governance-scoring.d.ts

@@ -0,0 +1,41 @@
+export interface DomainDesignPilotAnalysis {
+    category: string;
+    applied: boolean;
+    localitySource: "els" | "persistence_candidate";
+    baselineElsValue: number;
+    persistenceCandidateValue: number;
+    effectiveElsValue: number;
+    overallGate: {
+        reasons: string[];
+        replacementVerdict: "go" | "no_go";
+        rolloutDisposition: "replace" | "shadow_only";
+    };
+    categoryGate: {
+        reasons: string[];
+        replacementVerdict: "go" | "no_go";
+        rolloutDisposition: "replace" | "shadow_only";
+    };
+}
+export interface MarkdownReportResult {
+    format: "md";
+    report: string;
+}
+export interface MetricGateDecision {
+    status: "ok" | "warning" | "error";
+    failures: string[];
+    warnings: string[];
+}
+export interface MeasurementGateResult {
+    domainId: "domain_design" | "architecture_design";
+    gate: MetricGateDecision;
+    metrics: MetricScore[];
+    pilot?: DomainDesignPilotAnalysis;
+}
+export interface MetricScore {
+    metricId: string;
+    value: number;
+    components: Record<string, number>;
+    confidence: number;
+    evidenceRefs: string[];
+    unknowns: string[];
+}

package/dist/src/core/contracts/governance-scoring.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/contracts/governance.d.ts

@@ -0,0 +1,5 @@
+export * from "./governance-extraction.js";
+export * from "./governance-policy.js";
+export * from "./governance-review.js";
+export * from "./governance-runtime.js";
+export * from "./governance-scoring.js";

package/dist/src/core/contracts/governance.js

@@ -0,0 +1,5 @@
+export * from "./governance-extraction.js";
+export * from "./governance-policy.js";
+export * from "./governance-review.js";
+export * from "./governance-runtime.js";
+export * from "./governance-scoring.js";

package/dist/src/core/contracts.d.ts

@@ -0,0 +1,6 @@
+export * from "./contracts/analysis.js";
+export * from "./contracts/architecture.js";
+export * from "./contracts/common.js";
+export * from "./contracts/domain-design.js";
+export * from "./contracts/domain-model.js";
+export * from "./contracts/governance.js";

package/dist/src/core/contracts.js

@@ -0,0 +1,6 @@
+export * from "./contracts/analysis.js";
+export * from "./contracts/architecture.js";
+export * from "./contracts/common.js";
+export * from "./contracts/domain-design.js";
+export * from "./contracts/domain-model.js";
+export * from "./contracts/governance.js";

package/dist/src/core/document-extractor-glossary.d.ts

@@ -0,0 +1,3 @@
+import type { Fragment, GlossaryTerm } from "./contracts.js";
+export declare function normalizeGlossaryFromHeuristic(fragments: Fragment[]): GlossaryTerm[];
+export declare function normalizeGlossaryFromCli(rawItems: Record<string, unknown>[], fragments: Fragment[]): GlossaryTerm[];

package/dist/src/core/document-extractor-glossary.js

@@ -0,0 +1,90 @@
+import { createEvidenceFromFragment, createTermId, findFragmentsByIds, isStructuredNoiseFragment, normalizeInlineTerm, } from "./document-extractor-shared.js";
+function collectTerms(fragments) {
+    const terms = new Map();
+    const pushTerm = (term, fragment, aliases = []) => {
+        if (term.length < 3) {
+            return;
+        }
+        const current = terms.get(term) ?? {
+            canonicalTerm: term,
+            aliases: [],
+            count: 0,
+            evidence: [],
+            fragmentIds: [],
+        };
+        current.count += 1;
+        current.fragmentIds.push(fragment.fragmentId);
+        current.aliases = Array.from(new Set([...current.aliases, ...aliases.filter((alias) => alias !== term)]));
+        current.evidence.push(createEvidenceFromFragment(fragment, `Term candidate: ${term}`, 0.7));
+        terms.set(term, current);
+    };
+    for (const fragment of fragments) {
+        if (isStructuredNoiseFragment(fragment)) {
+            continue;
+        }
+        for (const match of fragment.text.matchAll(/`([^`]+)`\s*\(([^)]*)\)/g)) {
+            const canonical = match[1] ? normalizeInlineTerm(match[1]) : undefined;
+            const aliasSection = match[2] ?? "";
+            const aliases = Array.from(aliasSection.matchAll(/`([^`]+)`/g))
+                .map((aliasMatch) => (aliasMatch[1] ? normalizeInlineTerm(aliasMatch[1]) : undefined))
+                .filter((alias) => Boolean(alias));
+            if (canonical) {
+                pushTerm(canonical, fragment, aliases);
+            }
+        }
+        for (const match of fragment.text.matchAll(/`([^`]+)`/g)) {
+            const normalized = match[1] ? normalizeInlineTerm(match[1]) : undefined;
+            if (normalized) {
+                pushTerm(normalized, fragment);
+            }
+        }
+        for (const match of fragment.text.matchAll(/\b[A-Z][A-Za-z0-9_]{2,}\b/g)) {
+            const normalized = normalizeInlineTerm(match[0]);
+            if (normalized) {
+                pushTerm(normalized, fragment);
+            }
+        }
+    }
+    return terms;
+}
+export function normalizeGlossaryFromHeuristic(fragments) {
+    return Array.from(collectTerms(fragments).values())
+        .sort((left, right) => right.count - left.count)
+        .map((candidate) => ({
+        termId: createTermId(`${candidate.canonicalTerm}:${candidate.fragmentIds.join(",")}`),
+        canonicalTerm: candidate.canonicalTerm,
+        aliases: candidate.aliases,
+        count: candidate.count,
+        collision: false,
+        confidence: 0.7,
+        evidence: candidate.evidence,
+        unknowns: [],
+        fragmentIds: candidate.fragmentIds,
+    }));
+}
+export function normalizeGlossaryFromCli(rawItems, fragments) {
+    return rawItems
+        .filter((item) => typeof item.canonicalTerm === "string")
+        .map((item) => {
+        const canonicalTerm = item.canonicalTerm;
+        const fragmentIds = Array.isArray(item.fragmentIds)
+            ? item.fragmentIds.filter((value) => typeof value === "string")
+            : [];
+        const supportingFragments = findFragmentsByIds(fragments, fragmentIds);
+        return {
+            termId: createTermId(`${canonicalTerm}:${fragmentIds.join(",")}`),
+            canonicalTerm,
+            aliases: Array.isArray(item.aliases)
+                ? item.aliases.filter((value) => typeof value === "string")
+                : [],
+            count: fragmentIds.length || 1,
+            collision: Boolean(item.collision),
+            confidence: typeof item.confidence === "number" ? item.confidence : 0.7,
+            evidence: supportingFragments.map((fragment) => createEvidenceFromFragment(fragment, `Term candidate: ${canonicalTerm}`, typeof item.confidence === "number" ? item.confidence : 0.7)),
+            unknowns: Array.isArray(item.unknowns)
+                ? item.unknowns.filter((value) => typeof value === "string")
+                : [],
+            fragmentIds,
+        };
+    });
+}

package/dist/src/core/document-extractor-identity.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractionMetadata, Fragment } from "./contracts.js";
+import type { ExtractionOptions } from "./document-extractor-types.js";
+export declare function buildMetadata(options: ExtractionOptions): ExtractionMetadata;
+export declare function createTermId(seed: string): string;
+export declare function createRuleId(seed: string): string;
+export declare function createInvariantId(seed: string): string;
+export declare function createEvidenceFromFragment(fragment: Fragment, statement: string, confidence: number): {
+    evidenceId: string;
+    type: string;
+    statement: string;
+    confidence: number;
+    source: {
+        artifactId: string;
+        fragmentId: string;
+        path: string;
+    };
+};
+export declare function findFragmentsByIds(fragments: Fragment[], fragmentIds: string[]): Fragment[];

package/dist/src/core/document-extractor-identity.js

@@ -0,0 +1,37 @@
+import { createEvidenceId } from "./response.js";
+export function buildMetadata(options) {
+    return {
+        extractor: options.extractor ?? "heuristic",
+        ...(options.provider ? { provider: options.provider } : {}),
+        promptProfile: options.promptProfile ?? "default",
+        fallback: options.fallback ?? "heuristic",
+    };
+}
+export function createTermId(seed) {
+    return `TERM-${createEvidenceId(seed).replace("EV-", "")}`;
+}
+export function createRuleId(seed) {
+    return `RULE-${createEvidenceId(seed).replace("EV-", "")}`;
+}
+export function createInvariantId(seed) {
+    return `INV-${createEvidenceId(seed).replace("EV-", "")}`;
+}
+export function createEvidenceFromFragment(fragment, statement, confidence) {
+    return {
+        evidenceId: createEvidenceId(`${fragment.fragmentId}:${statement}`),
+        type: "document_fragment",
+        statement,
+        confidence,
+        source: {
+            artifactId: fragment.artifactId,
+            fragmentId: fragment.fragmentId,
+            path: fragment.path,
+        },
+    };
+}
+export function findFragmentsByIds(fragments, fragmentIds) {
+    const fragmentMap = new Map(fragments.map((fragment) => [fragment.fragmentId, fragment]));
+    return fragmentIds
+        .map((fragmentId) => fragmentMap.get(fragmentId))
+        .filter((fragment) => Boolean(fragment));
+}

package/dist/src/core/document-extractor-shared.d.ts

@@ -0,0 +1,3 @@
+export { buildMetadata, createEvidenceFromFragment, createInvariantId, createRuleId, createTermId, findFragmentsByIds, } from "./document-extractor-identity.js";
+export { buildInvariantReviewState, hasAnySignal, hasPredicateShape, INVARIANT_PREDICATE_PATTERNS, INVARIANT_SIGNALS, isListItemLine, isQuestionLikeStatement, isStructuredNoiseFragment, normalizeInlineTerm, normalizeStatement, RULE_INVARIANT_AMBIGUITY, RULE_PREDICATE_PATTERNS, RULE_SIGNALS, splitIntoSentences, stripListMarker, } from "./document-extractor-text.js";
+export type { ExtractionOptions, HeuristicStatementCandidate, HeuristicTermCandidate, StatementSegment, } from "./document-extractor-types.js";

package/dist/src/core/document-extractor-shared.js

@@ -0,0 +1,2 @@
+export { buildMetadata, createEvidenceFromFragment, createInvariantId, createRuleId, createTermId, findFragmentsByIds, } from "./document-extractor-identity.js";
+export { buildInvariantReviewState, hasAnySignal, hasPredicateShape, INVARIANT_PREDICATE_PATTERNS, INVARIANT_SIGNALS, isListItemLine, isQuestionLikeStatement, isStructuredNoiseFragment, normalizeInlineTerm, normalizeStatement, RULE_INVARIANT_AMBIGUITY, RULE_PREDICATE_PATTERNS, RULE_SIGNALS, splitIntoSentences, stripListMarker, } from "./document-extractor-text.js";

package/dist/src/core/document-extractor-statements-classification-cli.d.ts

@@ -0,0 +1,3 @@
+import type { Fragment, InvariantCandidate, RuleCandidate } from "./contracts.js";
+export declare function normalizeRulesFromCli(rawItems: Record<string, unknown>[], fragments: Fragment[]): RuleCandidate[];
+export declare function normalizeInvariantsFromCli(rawItems: Record<string, unknown>[], fragments: Fragment[]): InvariantCandidate[];

package/dist/src/core/document-extractor-statements-classification-cli.js

@@ -0,0 +1,50 @@
+import { createEvidenceFromFragment, createInvariantId, createRuleId, findFragmentsByIds, } from "./document-extractor-shared.js";
+function collectRawStatementItems(rawItems, fragments, defaultConfidence, defaultType) {
+    return rawItems
+        .filter((item) => typeof item.statement === "string")
+        .map((item) => {
+        const statement = item.statement;
+        const fragmentIds = Array.isArray(item.fragmentIds)
+            ? item.fragmentIds.filter((value) => typeof value === "string")
+            : [];
+        const supportingFragments = findFragmentsByIds(fragments, fragmentIds);
+        const confidence = typeof item.confidence === "number" ? item.confidence : defaultConfidence;
+        return {
+            statement,
+            fragmentIds,
+            confidence,
+            type: typeof item.type === "string" ? item.type : defaultType,
+            evidence: supportingFragments.map((fragment) => createEvidenceFromFragment(fragment, statement, confidence)),
+            unknowns: Array.isArray(item.unknowns)
+                ? item.unknowns.filter((value) => typeof value === "string")
+                : [],
+            relatedTerms: Array.isArray(item.relatedTerms)
+                ? item.relatedTerms.filter((value) => typeof value === "string")
+                : [],
+        };
+    });
+}
+export function normalizeRulesFromCli(rawItems, fragments) {
+    return collectRawStatementItems(rawItems, fragments, 0.7, "business_rule").map((item) => ({
+        ruleId: createRuleId(`${item.statement}:${item.fragmentIds.join(",")}`),
+        type: item.type,
+        statement: item.statement,
+        confidence: item.confidence,
+        evidence: item.evidence,
+        unknowns: item.unknowns,
+        fragmentIds: item.fragmentIds,
+        relatedTerms: item.relatedTerms,
+    }));
+}
+export function normalizeInvariantsFromCli(rawItems, fragments) {
+    return collectRawStatementItems(rawItems, fragments, 0.68, "strong_invariant").map((item) => ({
+        invariantId: createInvariantId(`${item.statement}:${item.fragmentIds.join(",")}`),
+        type: item.type,
+        statement: item.statement,
+        confidence: item.confidence,
+        evidence: item.evidence,
+        unknowns: item.unknowns,
+        fragmentIds: item.fragmentIds,
+        relatedTerms: item.relatedTerms,
+    }));
+}

package/dist/src/core/document-extractor-statements-classification-core.d.ts

@@ -0,0 +1,17 @@
+import type { Fragment } from "./contracts.js";
+export interface ClassifiedStatementItem {
+    statement: string;
+    fragment: Fragment;
+    confidence: number;
+    unknowns: string[];
+    sourceKind: "sentence" | "bullet";
+}
+export interface ClassifiedStatement {
+    kind: "rule" | "invariant";
+    item: ClassifiedStatementItem;
+}
+export interface ClassifiedStatementCollections {
+    rules: ClassifiedStatementItem[];
+    invariants: ClassifiedStatementItem[];
+}
+export declare function collectHeuristicStatementClassifications(fragments: Fragment[]): ClassifiedStatementCollections;

package/dist/src/core/document-extractor-statements-classification-core.js

@@ -0,0 +1,91 @@
+import { buildInvariantReviewState, hasAnySignal, hasPredicateShape, INVARIANT_PREDICATE_PATTERNS, INVARIANT_SIGNALS, isQuestionLikeStatement, isStructuredNoiseFragment, normalizeStatement, RULE_INVARIANT_AMBIGUITY, RULE_PREDICATE_PATTERNS, RULE_SIGNALS, } from "./document-extractor-shared.js";
+import { buildStatementSegments } from "./document-extractor-statements-segments.js";
+function classifyStatement(statement, fragment, sourceKind) {
+    const normalized = normalizeStatement(statement);
+    if (!normalized || isQuestionLikeStatement(normalized)) {
+        return undefined;
+    }
+    const hasRuleSignal = hasAnySignal(normalized, RULE_SIGNALS);
+    const hasInvariantSignal = hasAnySignal(normalized, INVARIANT_SIGNALS);
+    const hasRulePredicate = hasPredicateShape(normalized, RULE_PREDICATE_PATTERNS);
+    const hasInvariantPredicate = hasPredicateShape(normalized, INVARIANT_PREDICATE_PATTERNS);
+    if ((!hasRuleSignal || !hasRulePredicate) && (!hasInvariantSignal || !hasInvariantPredicate)) {
+        return undefined;
+    }
+    const bulletPenalty = sourceKind === "bullet" ? 0.06 : 0;
+    if (hasInvariantSignal && hasInvariantPredicate && (!hasRuleSignal || !hasRulePredicate)) {
+        const invariantReviewState = buildInvariantReviewState(normalized, sourceKind);
+        return {
+            kind: "invariant",
+            item: {
+                statement: normalized,
+                fragment,
+                confidence: invariantReviewState.confidence,
+                unknowns: invariantReviewState.unknowns,
+                sourceKind,
+            },
+        };
+    }
+    if (hasRuleSignal && hasRulePredicate && hasInvariantSignal && !hasInvariantPredicate) {
+        return {
+            kind: "rule",
+            item: {
+                statement: normalized,
+                fragment,
+                confidence: 0.62 - bulletPenalty,
+                unknowns: [RULE_INVARIANT_AMBIGUITY],
+                sourceKind,
+            },
+        };
+    }
+    if (hasRuleSignal && hasRulePredicate && (!hasInvariantSignal || !hasInvariantPredicate)) {
+        return {
+            kind: "rule",
+            item: {
+                statement: normalized,
+                fragment,
+                confidence: 0.78 - bulletPenalty,
+                unknowns: [],
+                sourceKind,
+            },
+        };
+    }
+    return {
+        kind: hasInvariantPredicate ? "invariant" : "rule",
+        item: {
+            statement: normalized,
+            fragment,
+            confidence: 0.62 - bulletPenalty,
+            unknowns: [RULE_INVARIANT_AMBIGUITY],
+            sourceKind,
+        },
+    };
+}
+export function collectHeuristicStatementClassifications(fragments) {
+    const rules = [];
+    const invariants = [];
+    const seen = new Set();
+    for (const fragment of fragments) {
+        if (fragment.kind !== "paragraph" || isStructuredNoiseFragment(fragment)) {
+            continue;
+        }
+        for (const segment of buildStatementSegments(fragment)) {
+            const classified = classifyStatement(segment.text, fragment, segment.sourceKind);
+            if (!classified) {
+                continue;
+            }
+            const dedupeKey = `${classified.kind}:${fragment.fragmentId}:${classified.item.statement}`;
+            if (seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
+            if (classified.kind === "rule") {
+                rules.push(classified.item);
+            }
+            else {
+                invariants.push(classified.item);
+            }
+        }
+    }
+    return { rules, invariants };
+}

package/dist/src/core/document-extractor-statements-classification-heuristic.d.ts

@@ -0,0 +1,3 @@
+import type { Fragment, InvariantCandidate, RuleCandidate } from "./contracts.js";
+export declare function normalizeRulesFromHeuristic(fragments: Fragment[]): RuleCandidate[];
+export declare function normalizeInvariantsFromHeuristic(fragments: Fragment[]): InvariantCandidate[];

package/dist/src/core/document-extractor-statements-classification-heuristic.js

@@ -0,0 +1,32 @@
+import { createEvidenceFromFragment, createInvariantId, createRuleId } from "./document-extractor-shared.js";
+import { collectHeuristicStatementClassifications, } from "./document-extractor-statements-classification-core.js";
+function toRuleCandidate(item) {
+    return {
+        ruleId: createRuleId(`${item.fragment.fragmentId}:${item.statement}`),
+        type: "business_rule",
+        statement: item.statement,
+        confidence: item.confidence,
+        evidence: [createEvidenceFromFragment(item.fragment, item.statement, item.confidence)],
+        unknowns: item.unknowns,
+        fragmentIds: [item.fragment.fragmentId],
+        relatedTerms: [],
+    };
+}
+function toInvariantCandidate(item) {
+    return {
+        invariantId: createInvariantId(`${item.fragment.fragmentId}:${item.statement}`),
+        type: "strong_invariant",
+        statement: item.statement,
+        confidence: item.confidence,
+        evidence: [createEvidenceFromFragment(item.fragment, item.statement, item.confidence)],
+        unknowns: item.unknowns,
+        fragmentIds: [item.fragment.fragmentId],
+        relatedTerms: [],
+    };
+}
+export function normalizeRulesFromHeuristic(fragments) {
+    return collectHeuristicStatementClassifications(fragments).rules.map(toRuleCandidate);
+}
+export function normalizeInvariantsFromHeuristic(fragments) {
+    return collectHeuristicStatementClassifications(fragments).invariants.map(toInvariantCandidate);
+}

package/dist/src/core/document-extractor-statements-classification.d.ts

@@ -0,0 +1,2 @@
+export { normalizeInvariantsFromCli, normalizeRulesFromCli, } from "./document-extractor-statements-classification-cli.js";
+export { normalizeInvariantsFromHeuristic, normalizeRulesFromHeuristic, } from "./document-extractor-statements-classification-heuristic.js";

package/dist/src/core/document-extractor-statements-classification.js

@@ -0,0 +1,2 @@
+export { normalizeInvariantsFromCli, normalizeRulesFromCli, } from "./document-extractor-statements-classification-cli.js";
+export { normalizeInvariantsFromHeuristic, normalizeRulesFromHeuristic, } from "./document-extractor-statements-classification-heuristic.js";

package/dist/src/core/document-extractor-statements-segments.d.ts

@@ -0,0 +1,3 @@
+import type { Fragment } from "./contracts.js";
+import type { StatementSegment } from "./document-extractor-types.js";
+export declare function buildStatementSegments(fragment: Fragment): StatementSegment[];

package/dist/src/core/document-extractor-statements-segments.js

@@ -0,0 +1,38 @@
+import { isListItemLine, normalizeStatement, splitIntoSentences, stripListMarker, } from "./document-extractor-shared.js";
+export function buildStatementSegments(fragment) {
+    const segments = [];
+    const proseBuffer = [];
+    const flushProse = () => {
+        if (proseBuffer.length === 0) {
+            return;
+        }
+        splitIntoSentences(proseBuffer.join(" ")).forEach((sentence) => {
+            segments.push({
+                text: sentence,
+                sourceKind: "sentence",
+            });
+        });
+        proseBuffer.length = 0;
+    };
+    for (const rawLine of fragment.text.split("\n")) {
+        const line = rawLine.trim();
+        if (!line) {
+            flushProse();
+            continue;
+        }
+        if (isListItemLine(line)) {
+            flushProse();
+            const bullet = normalizeStatement(stripListMarker(line));
+            if (bullet) {
+                segments.push({
+                    text: bullet,
+                    sourceKind: "bullet",
+                });
+            }
+            continue;
+        }
+        proseBuffer.push(line);
+    }
+    flushProse();
+    return segments;
+}

package/dist/src/core/document-extractor-statements.d.ts

@@ -0,0 +1 @@
+export { normalizeInvariantsFromCli, normalizeInvariantsFromHeuristic, normalizeRulesFromCli, normalizeRulesFromHeuristic, } from "./document-extractor-statements-classification.js";

package/dist/src/core/document-extractor-statements.js

@@ -0,0 +1 @@
+export { normalizeInvariantsFromCli, normalizeInvariantsFromHeuristic, normalizeRulesFromCli, normalizeRulesFromHeuristic, } from "./document-extractor-statements-classification.js";

package/dist/src/core/document-extractor-text-normalization.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeStatement(statement: string): string;
+export declare function isListItemLine(line: string): boolean;
+export declare function stripListMarker(line: string): string;
+export declare function splitIntoSentences(text: string): string[];
+export declare function isQuestionLikeStatement(text: string): boolean;

package/dist/src/core/document-extractor-text-normalization.js

@@ -0,0 +1,29 @@
+export function normalizeStatement(statement) {
+    return statement.replace(/\s+/g, " ").trim();
+}
+export function isListItemLine(line) {
+    return /^[-*+]\s+/.test(line) || /^\d+\.\s+/.test(line);
+}
+export function stripListMarker(line) {
+    return line
+        .replace(/^[-*+]\s+/, "")
+        .replace(/^\d+\.\s+/, "")
+        .trim();
+}
+export function splitIntoSentences(text) {
+    const normalized = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join(" ");
+    if (!normalized) {
+        return [];
+    }
+    return normalized
+        .split(/(?<=[。！？])\s*|(?<=[!?])\s+|(?<=\.)\s+/u)
+        .map((sentence) => normalizeStatement(sentence))
+        .filter(Boolean);
+}
+export function isQuestionLikeStatement(text) {
+    return /[か？?][。.]?$/u.test(text);
+}

package/dist/src/core/document-extractor-text-review.d.ts

@@ -0,0 +1,3 @@
+import type { HeuristicStatementCandidate } from "./document-extractor-types.js";
+export declare const INVARIANT_ACCEPTANCE_AMBIGUITY = "The boundary between an invariant and an acceptance condition is ambiguous.";
+export declare function buildInvariantReviewState(statement: string, sourceKind: "sentence" | "bullet"): Pick<HeuristicStatementCandidate, "confidence" | "unknowns">;

package/dist/src/core/document-extractor-text-review.js

@@ -0,0 +1,15 @@
+import { INVARIANT_REVIEW_SIGNALS } from "./document-extractor-text-signals.js";
+export const INVARIANT_ACCEPTANCE_AMBIGUITY = "The boundary between an invariant and an acceptance condition is ambiguous.";
+export function buildInvariantReviewState(statement, sourceKind) {
+    const bulletPenalty = sourceKind === "bullet" ? 0.06 : 0;
+    if (INVARIANT_REVIEW_SIGNALS.some((pattern) => pattern.test(statement))) {
+        return {
+            confidence: 0.68 - bulletPenalty,
+            unknowns: [INVARIANT_ACCEPTANCE_AMBIGUITY],
+        };
+    }
+    return {
+        confidence: 0.82 - bulletPenalty,
+        unknowns: [],
+    };
+}

package/dist/src/core/document-extractor-text-signals.d.ts

@@ -0,0 +1,11 @@
+import type { Fragment } from "./contracts.js";
+export declare const RULE_SIGNALS: RegExp[];
+export declare const INVARIANT_SIGNALS: RegExp[];
+export declare const RULE_PREDICATE_PATTERNS: RegExp[];
+export declare const INVARIANT_PREDICATE_PATTERNS: RegExp[];
+export declare const RULE_INVARIANT_AMBIGUITY = "The boundary between a rule and an invariant is ambiguous.";
+export declare const INVARIANT_REVIEW_SIGNALS: RegExp[];
+export declare function isStructuredNoiseFragment(fragment: Fragment): boolean;
+export declare function hasAnySignal(text: string, patterns: RegExp[]): boolean;
+export declare function hasPredicateShape(text: string, patterns: RegExp[]): boolean;
+export declare function normalizeInlineTerm(term: string): string | undefined;