@markstanden/opencode-test-container 0.0.0-stage → 0.1.1

package/dist/evaluators/docs/analysis/screening/inventory.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Configured preservation inventories and local assertion scanning.
+ *
+ * A missing keyword never proves a lost fact and a matching keyword never
+ * proves truth: this module reports recognised mentions, local negation and
+ * conflicts between assertions, with exact spans, and leaves every semantic
+ * verdict to the judge. Inventories are data (the manifest scenario's
+ * configuration); no fact name is hard-coded here.
+ *
+ * Summary and Facts are scanned as separate surfaces, and each assertion is
+ * evaluated independently so a rejecting clause in one sentence cannot
+ * condemn an affirmative claim in another. Failed-approach bullets are
+ * context, not affirmative claims.
+ */
+import type { PreservationInventorySpec } from "../model.ts";
+/** One independently evaluated assertion with its document offsets. */
+export interface Assertion {
+    /** The assertion text. */
+    text: string;
+    /** The full bullet or Summary line the assertion came from. */
+    context: string;
+    /** Offset of the assertion start within the document. */
+    start: number;
+    /** Offset just past the assertion end within the document. */
+    end: number;
+}
+/** The claim surface of one document. */
+export interface ClaimSurface {
+    /** The Summary value, or an empty string. */
+    summary: string;
+    /** Assertions of the Summary line with document offsets. */
+    summaryAssertions: Assertion[];
+    /** Fact bullets with their document offsets. */
+    facts: Array<{
+        text: string;
+        offset: number;
+    }>;
+    /** Failed-approach bullets, kept as review context only. */
+    failedApproaches: Array<{
+        text: string;
+        offset: number;
+    }>;
+}
+/** One span of document text. */
+export interface Span {
+    /** The matched text. */
+    text: string;
+    /** Offset of the match start within the document. */
+    start: number;
+    /** Offset just past the match end within the document. */
+    end: number;
+}
+/** One inventory trigger, with its context and exact spans. */
+export interface InventoryTrigger {
+    /** What kind of trigger this is. */
+    kind: "negated-fact" | "obsolete-current" | "conflict";
+    /** The inventory fact id. */
+    factId: string;
+    /** The full bullet or Summary text the assertion came from. */
+    context: string;
+    /** The evaluated assertion text. */
+    assertion: string;
+    /** The assertion's span within the document. */
+    span: {
+        start: number;
+        end: number;
+    };
+    /** The fact mention's span. */
+    mention: Span;
+    /** The negation cue's span, when one applied. */
+    negation?: Span | undefined;
+    /** The opposing assertion in a conflict. */
+    other?: {
+        assertion: string;
+        span: {
+            start: number;
+            end: number;
+        };
+    } | undefined;
+}
+/** The result of scanning one document against an inventory. */
+export interface InventoryScan {
+    /** Local negation, obsolete-current and conflict triggers, span-sorted. */
+    triggers: InventoryTrigger[];
+    /** Still-valid facts with no recognised mention. */
+    missing: string[];
+    /** Facts with at least one affirmative (or, for obsolete claims, any) mention. */
+    recognised: string[];
+}
+/**
+ * Split text into assertions, keeping each assertion's document offsets.
+ * @param text The text to split.
+ * @param baseOffset The offset of `text` within the document.
+ * @param context The full bullet or Summary line the text belongs to.
+ * @returns The nonblank assertions in order.
+ */
+export declare function assertionsOf(text: string, baseOffset: number, context?: string): Assertion[];
+/**
+ * Read a document's Summary, Facts and Failed-approach surfaces with offsets.
+ * @param document The document body.
+ * @returns The claim surface.
+ */
+export declare function claimSurfaceOf(document: string): ClaimSurface;
+/**
+ * Scan one document against a configured inventory.
+ * @param document The document body.
+ * @param inventory The scenario's configured inventory.
+ * @returns Triggers with spans, plus recognised and missing facts.
+ */
+export declare function scanInventory(document: string, inventory: PreservationInventorySpec): InventoryScan;
+/** The deterministic cross-check result for one replacement document. */
+export interface PreservationScreenResult {
+    /** Rejected on an explicit contradiction; unknown when a fact is absent. */
+    status: "accepted" | "rejected" | "unknown";
+    /** Still-valid facts with no recognised mention. */
+    missing: string[];
+    /** Whether a current obsolete claim survived. */
+    obsolete: boolean;
+    /** Fact ids with a local contradiction or conflict. */
+    contradicted: string[];
+    /** The triggers behind a rejection, with full context and spans. */
+    triggers: InventoryTrigger[];
+    /** Always true: a keyword screen never decides the semantic guardrail. */
+    requiresSemanticReview: true;
+}
+/**
+ * Screen a replacement document against an inventory as a pre-check.
+ *
+ * This is a cross-check only. `accepted` still requires the evidence-based
+ * semantic review; `unknown` means a keyword was absent, never that a fact
+ * was lost.
+ * @param document The resulting document body.
+ * @param inventory The scenario's configured inventory.
+ * @returns The screen result with every rejection's triggers.
+ */
+export declare function preservationScreen(document: string, inventory: PreservationInventorySpec): PreservationScreenResult;

package/dist/evaluators/docs/analysis/screening/inventory.js

@@ -0,0 +1,307 @@
+/** A section heading line (text starts with a non-blank character). */
+const HEADING = /^#{2,3}[ \t]+([^ \t].*)$/;
+/** A bullet line (text starts with a non-blank character). */
+const BULLET = /^[ \t]*[-*][ \t]+([^ \t].*)$/;
+/** A Summary line. */
+const SUMMARY = /^Summary:(.*)$/i;
+/** Sentence/clause separators used to evaluate assertions independently. */
+const SEPARATOR = /;\s*|\.\s+(?=[A-Z`])/g;
+/**
+ * Split text into assertions, keeping each assertion's document offsets.
+ * @param text The text to split.
+ * @param baseOffset The offset of `text` within the document.
+ * @param context The full bullet or Summary line the text belongs to.
+ * @returns The nonblank assertions in order.
+ */
+export function assertionsOf(text, baseOffset, context = text) {
+    const assertions = [];
+    let cursor = 0;
+    SEPARATOR.lastIndex = 0;
+    for (let match = SEPARATOR.exec(text); match !== null; match = SEPARATOR.exec(text)) {
+        pushAssertion(assertions, text, baseOffset, cursor, match.index, context);
+        cursor = match.index + match[0].length;
+    }
+    pushAssertion(assertions, text, baseOffset, cursor, text.length, context);
+    return assertions;
+}
+/**
+ * Append one trimmed, nonblank assertion slice.
+ * @param assertions The accumulator.
+ * @param text The whole text.
+ * @param baseOffset The text's document offset.
+ * @param from Slice start.
+ * @param to Slice end.
+ * @param context The full bullet or Summary line.
+ */
+function pushAssertion(assertions, text, baseOffset, from, to, context) {
+    const raw = text.slice(from, to);
+    const trimmed = raw.trim();
+    if (trimmed === "")
+        return;
+    const leading = raw.length - raw.trimStart().length;
+    assertions.push({
+        text: trimmed,
+        context,
+        start: baseOffset + from + leading,
+        end: baseOffset + from + leading + trimmed.length,
+    });
+}
+/**
+ * Read a document's Summary, Facts and Failed-approach surfaces with offsets.
+ * @param document The document body.
+ * @returns The claim surface.
+ */
+export function claimSurfaceOf(document) {
+    const surface = {
+        summary: "",
+        summaryAssertions: [],
+        facts: [],
+        failedApproaches: [],
+    };
+    let section = "none";
+    let offset = 0;
+    for (const line of document.split("\n")) {
+        section = lineSection(surface, line, offset, section);
+        offset += line.length + 1;
+    }
+    return surface;
+}
+/**
+ * Apply one document line to the claim surface.
+ * @param surface The claim surface accumulator.
+ * @param line The raw line.
+ * @param offset The line's document offset.
+ * @param section The section state before this line.
+ * @returns The section state after this line.
+ */
+function lineSection(surface, line, offset, section) {
+    const trimmed = line.trim();
+    const heading = HEADING.exec(trimmed);
+    if (heading !== null)
+        return sectionOf((heading[1] ?? "").trim());
+    const summary = SUMMARY.exec(trimmed);
+    if (summary !== null) {
+        recordSummary(surface, line, offset, (summary[1] ?? "").trim());
+        return section;
+    }
+    const bullet = BULLET.exec(line);
+    if (bullet !== null && section !== "none") {
+        recordBullet(surface, bullet[1] ?? "", line, offset, section);
+    }
+    return section;
+}
+/**
+ * Record a Summary line's value and assertions.
+ * @param surface The claim surface.
+ * @param line The raw line.
+ * @param offset The line's document offset.
+ * @param value The trimmed Summary value.
+ */
+function recordSummary(surface, line, offset, value) {
+    surface.summary = value;
+    surface.summaryAssertions =
+        value === ""
+            ? []
+            : assertionsOf(value, offset + line.indexOf(value), line.trim());
+}
+/**
+ * Record one bullet line in its section.
+ * @param surface The claim surface.
+ * @param text The bullet text.
+ * @param line The raw line.
+ * @param offset The line's document offset.
+ * @param section The current section.
+ */
+function recordBullet(surface, text, line, offset, section) {
+    const entry = { text, offset: offset + line.indexOf(text) };
+    if (section === "facts")
+        surface.facts.push(entry);
+    else
+        surface.failedApproaches.push(entry);
+}
+/**
+ * Classify a section heading for claim-surface purposes.
+ * @param name The heading text.
+ * @returns The section kind.
+ */
+function sectionOf(name) {
+    if (/^facts$/i.test(name))
+        return "facts";
+    if (/^failed\s+(approaches|attempts)$/i.test(name))
+        return "failed";
+    return "none";
+}
+/**
+ * Find the first match of a regex source in an assertion, as a span.
+ * @param source The regex source.
+ * @param assertion The assertion.
+ * @param baseOffset The assertion's document offset.
+ * @returns The span, or undefined.
+ */
+function spanIn(source, assertion, baseOffset) {
+    const match = new RegExp(source, "i").exec(assertion.text);
+    if (match === null)
+        return undefined;
+    return {
+        text: match[0],
+        start: baseOffset + match.index,
+        end: baseOffset + match.index + match[0].length,
+    };
+}
+/**
+ * Collect every mention of one fact across the Summary and Facts assertions.
+ * @param fact The configured fact.
+ * @param assertions The assertions to scan, with document offsets.
+ * @param negationCues The inventory's negation cue sources.
+ * @returns The mentions in document order.
+ */
+function mentionsOf(fact, assertions, negationCues) {
+    const patterns = fact.obsoleteCurrentPatterns ?? fact.mentionPatterns ?? [];
+    const mentions = [];
+    for (const assertion of assertions) {
+        for (const pattern of patterns) {
+            const span = spanIn(pattern, assertion, assertion.start);
+            if (span === undefined)
+                continue;
+            const negation = negationCues
+                .map((cue) => spanIn(cue, assertion, assertion.start))
+                .find((cue) => cue !== undefined);
+            mentions.push({ assertion, span, negation });
+            break;
+        }
+    }
+    return mentions;
+}
+/**
+ * Build the triggers one fact's mentions imply.
+ * @param fact The configured fact.
+ * @param mentions The fact's mentions.
+ * @returns Triggers for local negation, obsolete-current claims and conflicts.
+ */
+function factTriggers(fact, mentions) {
+    const obsolete = fact.obsoleteCurrentPatterns !== undefined;
+    const triggers = [];
+    const affirmative = mentions.filter((mention) => mention.negation === undefined);
+    for (const mention of mentions) {
+        const base = {
+            factId: fact.id,
+            context: mention.assertion.context,
+            assertion: mention.assertion.text,
+            span: {
+                start: mention.assertion.start,
+                end: mention.assertion.end,
+            },
+            mention: mention.span,
+        };
+        if (obsolete) {
+            if (mention.negation === undefined) {
+                triggers.push({
+                    ...base,
+                    kind: "obsolete-current",
+                });
+            }
+            continue;
+        }
+        if (mention.negation === undefined)
+            continue;
+        triggers.push({
+            ...base,
+            kind: "negated-fact",
+            negation: mention.negation,
+        });
+        const opposing = affirmative[0];
+        if (opposing !== undefined && opposing !== mention) {
+            triggers.push({
+                ...base,
+                kind: "conflict",
+                negation: mention.negation,
+                other: {
+                    assertion: opposing.assertion.text,
+                    span: {
+                        start: opposing.assertion.start,
+                        end: opposing.assertion.end,
+                    },
+                },
+            });
+        }
+    }
+    return triggers;
+}
+/**
+ * Scan one document against a configured inventory.
+ * @param document The document body.
+ * @param inventory The scenario's configured inventory.
+ * @returns Triggers with spans, plus recognised and missing facts.
+ */
+export function scanInventory(document, inventory) {
+    const surface = claimSurfaceOf(document);
+    const assertions = [
+        ...surface.summaryAssertions,
+        ...surface.facts.flatMap((fact) => assertionsOf(fact.text, fact.offset, fact.text)),
+    ];
+    const triggers = [];
+    const missing = [];
+    const recognised = [];
+    for (const fact of inventory.facts) {
+        const mentions = mentionsOf(fact, assertions, inventory.negationCues);
+        triggers.push(...factTriggers(fact, mentions));
+        const obsolete = fact.obsoleteCurrentPatterns !== undefined;
+        seenFact(fact, mentions, obsolete, missing, recognised);
+    }
+    triggers.sort((left, right) => left.span.start - right.span.start);
+    return { triggers, missing, recognised };
+}
+/**
+ * Record whether a fact is recognised or missing.
+ * @param fact The configured fact.
+ * @param mentions The fact's mentions.
+ * @param obsolete Whether the fact is an obsolete-claim fact.
+ * @param missing The missing accumulator.
+ * @param recognised The recognised accumulator.
+ */
+function seenFact(fact, mentions, obsolete, missing, recognised) {
+    if (obsolete) {
+        if (mentions.length > 0)
+            recognised.push(fact.id);
+        return;
+    }
+    const affirmative = mentions.some((mention) => mention.negation === undefined);
+    if (affirmative)
+        recognised.push(fact.id);
+    else
+        missing.push(fact.id);
+}
+/**
+ * Screen a replacement document against an inventory as a pre-check.
+ *
+ * This is a cross-check only. `accepted` still requires the evidence-based
+ * semantic review; `unknown` means a keyword was absent, never that a fact
+ * was lost.
+ * @param document The resulting document body.
+ * @param inventory The scenario's configured inventory.
+ * @returns The screen result with every rejection's triggers.
+ */
+export function preservationScreen(document, inventory) {
+    const scan = scanInventory(document, inventory);
+    const obsolete = scan.triggers.some((trigger) => trigger.kind === "obsolete-current");
+    const contradicted = [
+        ...new Set(scan.triggers
+            .filter((trigger) => trigger.kind !== "obsolete-current")
+            .map((trigger) => trigger.factId)),
+    ];
+    const status = obsolete
+        ? "rejected"
+        : contradicted.length > 0
+            ? "rejected"
+            : scan.missing.length > 0
+                ? "unknown"
+                : "accepted";
+    return {
+        status,
+        missing: scan.missing,
+        obsolete,
+        contradicted,
+        triggers: scan.triggers,
+        requiresSemanticReview: true,
+    };
+}

package/dist/evaluators/docs/analysis/screening/noteVersion.d.ts

@@ -0,0 +1,15 @@
+/** The two classifications the historical NOTE-02 review used. */
+export type NoteVersionVerdict = "useful-update" | "misleading";
+/**
+ * Split Summary/Facts assertions so one rejection cannot mask another.
+ * @param document The document body.
+ * @returns The assertion texts from the claim surface.
+ */
+export declare function claimAssertions(document: string): string[];
+/**
+ * Classify a NOTE-02 documentation update.
+ * @param document The replacement document body.
+ * @returns `misleading` when the superseded 22 floor is still presented as
+ *   current, otherwise `useful-update`.
+ */
+export declare function noteVersionVerdict(document: string): NoteVersionVerdict;

package/dist/evaluators/docs/analysis/screening/noteVersion.js

@@ -0,0 +1,46 @@
+/**
+ * The NOTE-02 partial-fix rule, scoped to the historical correction.
+ *
+ * A documentation update that presents the superseded Node 22 floor as the
+ * supported/current contract in its Summary or Facts is misleading; a
+ * completed Node 24 migration is a useful update. Assertions are evaluated
+ * separately so a rejecting clause in one sentence cannot suppress an
+ * affirmative claim in another, and Failed approaches stay context.
+ *
+ * This helper is deliberately not a general semantic classifier.
+ */
+import { claimSurfaceOf } from "./inventory.js";
+/** Whether one assertion rejects the Node 22 floor. */
+const rejects22 = (text) => /Node\s*22[^\n.]{0,50}\b(?:no longer|not|never|unsupported|deprecated|superseded|must not)\b/i.test(text) ||
+    /\b(?:no longer|not|never)\b[^\n.]{0,30}\b(?:support|use|require)\b[^\n.]{0,20}Node\s*22/i.test(text);
+/** Whether one assertion presents the Node 22 floor as current. */
+const asserts22 = (text) => /Node\s*22/i.test(text) ||
+    /22\s*or newer/i.test(text) ||
+    /\bfloor\b[^\n]{0,12}\b22\b/i.test(text) ||
+    /\bminimum\b[^\n]{0,24}\b22\b/i.test(text) ||
+    /required\s+is\s+22/i.test(text);
+/**
+ * Split Summary/Facts assertions so one rejection cannot mask another.
+ * @param document The document body.
+ * @returns The assertion texts from the claim surface.
+ */
+export function claimAssertions(document) {
+    const surface = claimSurfaceOf(document);
+    return [
+        ...surface.summaryAssertions.map((assertion) => assertion.text),
+        ...surface.facts.flatMap((fact) => fact.text
+            .split(/\n+|(?<=[.!?;])\s+/)
+            .map((part) => part.trim())
+            .filter(Boolean)),
+    ];
+}
+/**
+ * Classify a NOTE-02 documentation update.
+ * @param document The replacement document body.
+ * @returns `misleading` when the superseded 22 floor is still presented as
+ *   current, otherwise `useful-update`.
+ */
+export function noteVersionVerdict(document) {
+    const claims = claimAssertions(document).some((assertion) => asserts22(assertion) && !rejects22(assertion));
+    return claims ? "misleading" : "useful-update";
+}

package/dist/evaluators/docs/analysis/screening/reconcile.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reconciliation between static-screen findings and the recorded judge layer.
+ *
+ * A screen finding is not a verdict: this module reports whether the judge's
+ * reason or evidence text references the finding, and keeps the two layers
+ * distinct. Exact-text reference is deliberately conservative — a paraphrase
+ * counts as not referenced, and a short excerpt cannot establish anything.
+ */
+import type { EvidenceRole, Finding, TrialIdentity } from "./rules.ts";
+/** The judge text a reconciliation reads. */
+export interface JudgementText {
+    /** The judgement's stated reason. */
+    reason: string;
+    /** The judgement's evidence quotes. */
+    evidence: string[];
+}
+/** One finding's reconciliation status against the judge layer. */
+export interface ReconcileRow {
+    /** The finding's rule id. */
+    ruleId: string;
+    /** The finding's inventory fact id, when present. */
+    factId: string | undefined;
+    /** The trial the finding came from. */
+    trial: TrialIdentity;
+    /** The evidence role the finding cites. */
+    role: EvidenceRole;
+    /** The finding's root-relative source reference. */
+    source: string;
+    /** Whether the judge text references the finding's excerpt. */
+    status: "referenced" | "not-referenced" | "unresolved";
+}
+/**
+ * Reconcile screen findings with one judgement layer.
+ * @param findings The screen findings.
+ * @param judgement The selected judgement's reason and evidence, when judged.
+ * @returns One row per finding: referenced, not-referenced or unresolved.
+ */
+export declare function reconcileFindings(findings: readonly Finding[], judgement: JudgementText | undefined): ReconcileRow[];

package/dist/evaluators/docs/analysis/screening/reconcile.js

@@ -0,0 +1,40 @@
+/**
+ * Normalise text for conservative excerpt comparison.
+ * @param text The text to normalise.
+ * @returns Lowercase words with markdown punctuation collapsed.
+ */
+function normalise(text) {
+    return text
+        .toLowerCase()
+        .replace(/[`*_#|]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Reconcile screen findings with one judgement layer.
+ * @param findings The screen findings.
+ * @param judgement The selected judgement's reason and evidence, when judged.
+ * @returns One row per finding: referenced, not-referenced or unresolved.
+ */
+export function reconcileFindings(findings, judgement) {
+    const rows = findings.map((finding) => ({
+        ruleId: finding.ruleId,
+        factId: finding.factId,
+        trial: finding.trial,
+        role: finding.role,
+        source: finding.source.reference,
+        status: "unresolved",
+    }));
+    if (judgement === undefined)
+        return rows;
+    const text = normalise([judgement.reason, ...judgement.evidence].join(" "));
+    return findings.map((finding, index) => {
+        const excerpt = normalise(finding.excerpt);
+        const status = excerpt.length < 8
+            ? "unresolved"
+            : text.includes(excerpt)
+                ? "referenced"
+                : "not-referenced";
+        return { ...rows[index], status };
+    });
+}