@proposit/proposit-core 1.2.0 → 1.3.1

package/dist/extensions/argument-ingestion/stages/claim-canonicalization.js

@@ -0,0 +1,157 @@
+// `claim-canonicalization` — merges the raw mentions into a single
+// canonical claim set. Each canonical claim carries:
+//   - a miniId (c1, c2, ...) allocated by the stage
+//   - the mentionIds it absorbed
+//   - a `suggestedSymbol` — the canonicalizer's snake_case-shaped
+//     proposal (validated downstream by variable-assignment)
+//   - the extension's per-claim fields (e.g. for `basics`: a
+//     discriminated union over `type` with title/body/url/axiom)
+//
+// `mentionToClaim` maps every mention id back to its assigned
+// canonical claim's miniId — useful for downstream stages (and
+// finalize) that want to trace evidence back to the text.
+//
+// Per spec §6.4 this is a strong-reasoning stage: `gpt-5.5` with
+// `reasoningEffort: 'medium'`.
+import Type, {} from "typebox";
+import { MentionToClaimEntrySchema, STAGE_IDS, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+import { optional } from "../../../lib/pipelines/types.js";
+export const CLAIM_CANONICALIZATION_MODEL = "gpt-5.5";
+export const CLAIM_CANONICALIZATION_REASONING = "medium";
+export const CLAIM_CANONICALIZATION_SYSTEM_PROMPT = `You merge raw claim mentions into a single canonical set of claims for an argument-ingestion pipeline.
+
+You are given:
+- the raw input text (for full context)
+- the segmented breakdown of the text
+- the list of every claim mention extracted from those segments
+- optionally, the detected citation sources + axiom indicators
+
+Your output has two parts:
+
+1. \`canonicalClaims\` — an array of canonical claims, one entry per distinct proposition the author makes. Two mentions that assert the same proposition (even when phrased differently across the text) merge into a single canonical claim. Each canonical claim carries:
+   - \`miniId\` — assign in canonicalization order: c1, c2, c3, ...
+   - \`mentionIds\` — list of the mention ids that resolved to this claim
+   - \`type\` — one of "normal", "citation", or "axiomatic" (see below)
+   - \`suggestedSymbol\` — a short PascalCase-or-snake_case identifier summarizing the claim (e.g. "Rain_Wets_Ground", "NASA_Temp_Rise", "Socrates_Mortal"). Use letters, digits, and underscores only; start with a letter or underscore; keep under 32 characters; aim for under 20. AVOID single letters and generic names like "Claim1".
+   - the extension fields described in your output schema (title, body, url, axiom — whichever apply to the claim's \`type\`)
+
+2. \`mentionToClaim\` — an array of \`{ "mentionId": "...", "claimMiniId": "..." }\` entries, one per input mention. Every input mentionId must appear in exactly one entry; the mapping is total. (We surface this as a list rather than a map because the response schema does not allow arbitrary string keys.)
+
+## Claim types
+
+- \`"normal"\` — a primary proposition the argument argues for or from.
+- \`"citation"\` — a claim whose content is "the cited source asserts X". Use this type when one of the citation sources covers the same span(s) as the mention. Populate \`url\` (the URL if present) and \`title\` (a short human-readable label).
+- \`"axiomatic"\` — a claim invoked as self-evident truth. Use this type when an axiom indicator (e.g. "by definition") covers or precedes the mention. Populate \`axiom\` with the gist of the self-evident proposition.
+
+When a mention is the antecedent of "according to X, P", split it into two claims: a citation-typed claim for the source itself + a normal-typed claim for the proposition. The two are connected via a relation in a later stage, not here.
+
+## Style
+
+- Claim titles + bodies are written in third-person, present-tense, active voice.
+- Titles are short (≤ 50 characters); bodies fill in the detail.
+- For citation claims, the title summarizes what the source asserts (e.g. "NASA reports temperature rise"); the URL goes in \`url\`.
+- For axiomatic claims, the \`axiom\` field captures the self-evident proposition (e.g. "A bachelor is an unmarried man by definition.").
+
+Output ONLY the schema-shaped object. No prose.`;
+function buildResponseSchema(extension) {
+    return Type.Object({
+        canonicalClaims: Type.Array(buildClaimRecordSchema(extension.claimSchema)),
+        // List-shape (not Record/map) for OpenAI strict-mode
+        // compatibility — see `MentionToClaimEntrySchema` docstring
+        // in `./schemas.ts` for the OpenAI 400 chain that motivated
+        // the shape change.
+        mentionToClaim: Type.Array(MentionToClaimEntrySchema),
+    }, { additionalProperties: false });
+}
+function buildClaimRecordSchema(claimSchema) {
+    // claimSchema is the extension's claim shape — often a
+    // discriminated union over `type`. We need to inject the
+    // canonicalizer-owned fields (miniId / mentionIds / suggestedSymbol)
+    // into each branch.
+    const canonicalFields = {
+        miniId: Type.String({
+            description: "Sequential canonicalization id (c1, c2, ...).",
+        }),
+        mentionIds: Type.Array(Type.String(), {
+            description: "Mention ids merged into this canonical claim.",
+        }),
+        suggestedSymbol: Type.String({
+            description: "Snake_case / PascalCase identifier proposal for the claim's logical variable. ≤ 32 chars; letters / digits / underscores; starts with letter or underscore.",
+        }),
+    };
+    const ext = claimSchema;
+    const anyOf = ext.anyOf;
+    if (Array.isArray(anyOf)) {
+        const branches = anyOf.map((branch) => {
+            const branchProps = branch
+                .properties;
+            if (!branchProps) {
+                throw new Error("claim-canonicalization: union extension branches must be object schemas.");
+            }
+            return Type.Object({ ...canonicalFields, ...branchProps }, { additionalProperties: false });
+        });
+        return Type.Union(branches);
+    }
+    const objProps = ext.properties;
+    if (!objProps) {
+        throw new Error("claim-canonicalization: extension claimSchema must be a Type.Object or a Type.Union of Type.Objects.");
+    }
+    return Type.Object({ ...canonicalFields, ...objProps }, { additionalProperties: false });
+}
+function buildPrompt(ctx) {
+    const input = ctx.input;
+    const mentionEnvelope = ctx.get(STAGE_IDS.claimMentionExtraction);
+    const mentions = mentionEnvelope?.mentions ?? [];
+    const citationEnvelope = ctx.get(STAGE_IDS.citationSourceDetection);
+    const citations = citationEnvelope?.sources ?? [];
+    const axiomEnvelope = ctx.get(STAGE_IDS.axiomIndicatorDetection);
+    const axioms = axiomEnvelope?.axioms ?? [];
+    const mentionLines = mentions
+        .map((m) => `  [${m.mentionId} @ ${m.segmentId}] ${JSON.stringify(m.text)}`)
+        .join("\n");
+    const citationLines = citations.length > 0
+        ? citations
+            .map((c) => `  [${c.sourceId} @ ${c.segmentIds.join(",")}] ${JSON.stringify(c.sourceString)}${c.url ? ` (url: ${c.url})` : ""}`)
+            .join("\n")
+        : "  (none)";
+    const axiomLines = axioms.length > 0
+        ? axioms
+            .map((a) => `  [${a.axiomId} @ ${a.segmentIds.join(",")}] ${JSON.stringify(a.indicator)}`)
+            .join("\n")
+        : "  (none)";
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.claimCanonicalization} -->\n${CLAIM_CANONICALIZATION_SYSTEM_PROMPT}`;
+    const user = `Input text:\n\n${input.text}\n\nClaim mentions:\n${mentionLines}\n\nDetected citation sources:\n${citationLines}\n\nDetected axiom indicators:\n${axiomLines}\n\nProduce the canonicalClaims + mentionToClaim object.`;
+    return { system: markedSystem, user };
+}
+/** Internal default knobs for the claim-canonicalization stage. */
+export const CLAIM_CANONICALIZATION_STAGE_DEFAULTS = {
+    reasoningEffort: CLAIM_CANONICALIZATION_REASONING,
+};
+/**
+ * Builds the `claim-canonicalization` stage for the supplied
+ * extension. The stage's `outputSchema` carries the extension's
+ * per-claim fields, so the LLM's structured-output schema matches the
+ * extension's claim shape (e.g. for `basics`: a discriminated union
+ * over `type`).
+ *
+ * `options` overrides the stage's internal defaults
+ * (`CLAIM_CANONICALIZATION_STAGE_DEFAULTS`). Threaded through by
+ * `createIngestionV2Pipeline` per its `TIngestionLlmOptions` surface.
+ */
+export function createClaimCanonicalizationStage(extension, options) {
+    return llmStage({
+        id: STAGE_IDS.claimCanonicalization,
+        dependsOn: [
+            STAGE_IDS.claimMentionExtraction,
+            optional(STAGE_IDS.citationSourceDetection),
+            optional(STAGE_IDS.axiomIndicatorDetection),
+        ],
+        outputSchema: buildResponseSchema(extension),
+        model: CLAIM_CANONICALIZATION_MODEL,
+        maxOutputTokens: options?.maxOutputTokens,
+        reasoningEffort: options?.reasoningEffort ?? CLAIM_CANONICALIZATION_REASONING,
+        buildPrompt,
+    });
+}
+//# sourceMappingURL=claim-canonicalization.js.map

package/dist/extensions/argument-ingestion/stages/claim-canonicalization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-canonicalization.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-canonicalization.ts"],"names":[],"mappings":"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"}

package/dist/extensions/argument-ingestion/stages/claim-mention-extraction.d.ts

@@ -0,0 +1,12 @@
+import { type TClaimMentionExtractionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const CLAIM_MENTION_EXTRACTION_MODEL = "gpt-5.4";
+export declare const CLAIM_MENTION_EXTRACTION_SYSTEM_PROMPT = "You extract textual \"claim mentions\" from segments of an argument. A mention is any contiguous span of text that asserts a proposition the author is making \u2014 a sentence-or-clause-sized chunk that a reader would read as a single assertion.\n\nReturn an object with a single key `mentions` whose value is the array of extracted mentions. For each mention emit:\n- a fresh \"mentionId\" (m1, m2, ...; unique across all segments)\n- the \"segmentId\" the mention belongs to\n- the verbatim \"text\" of the mention (copy from the input \u2014 do not rewrite)\n- the character \"span\" (an object with \"start\" inclusive, \"end\" exclusive) relative to the SEGMENT'S TEXT (not the original input)\n\nA single segment can produce multiple mentions when it asserts multiple things. Most segments produce one mention. Do NOT deduplicate \u2014 if the same proposition is reasserted in a later segment, emit it as a separate mention there too. Do NOT classify the mention. Do NOT include connectives, hedges, or discourse markers in the span when they are not part of the asserted proposition.\n\nIf a segment is purely a discourse marker (e.g., \"Therefore,\" or \"Moreover,\"), emit no mention for it. If there are no mentions at all, return `{ \"mentions\": [] }`.";
+/** Internal default knobs for the claim-mention-extraction stage. */
+export declare const CLAIM_MENTION_EXTRACTION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/** Build the claim-mention-extraction stage with optional caller overrides. */
+export declare function createClaimMentionExtractionStage(options?: TLlmStageOptionsOverride): TStage<TClaimMentionExtractionOutput>;
+/** Backward-compatible default-options stage. */
+export declare const claimMentionExtractionStage: TStage<TClaimMentionExtractionOutput>;
+//# sourceMappingURL=claim-mention-extraction.d.ts.map

package/dist/extensions/argument-ingestion/stages/claim-mention-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-mention-extraction.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-mention-extraction.ts"],"names":[],"mappings":"AAOA,OAAO,EAGH,KAAK,6BAA6B,EAErC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAElE,eAAO,MAAM,8BAA8B,YAAY,CAAA;AAEvD,eAAO,MAAM,sCAAsC,svCAUoH,CAAA;AAavK,qEAAqE;AACrE,eAAO,MAAM,uCAAuC,EAAE,wBAChD,CAAA;AAEN,+EAA+E;AAC/E,wBAAgB,iCAAiC,CAC7C,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,6BAA6B,CAAC,CAUvC;AAED,iDAAiD;AACjD,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,6BAA6B,CACvC,CAAA"}

package/dist/extensions/argument-ingestion/stages/claim-mention-extraction.js

@@ -0,0 +1,47 @@
+// `claim-mention-extraction` — extracts every textual mention of a
+// claim (a proposition the author makes) from each segment. Mentions
+// are NOT deduplicated at this stage; `claim-canonicalization` does
+// the dedupe/merge work. Producing mentions per-segment keeps this
+// stage cheap + parallelizable; the dedupe stage gets the full
+// mention list as context.
+import { STAGE_IDS, ClaimMentionExtractionOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const CLAIM_MENTION_EXTRACTION_MODEL = "gpt-5.4";
+export const CLAIM_MENTION_EXTRACTION_SYSTEM_PROMPT = `You extract textual "claim mentions" from segments of an argument. A mention is any contiguous span of text that asserts a proposition the author is making — a sentence-or-clause-sized chunk that a reader would read as a single assertion.
+
+Return an object with a single key \`mentions\` whose value is the array of extracted mentions. For each mention emit:
+- a fresh "mentionId" (m1, m2, ...; unique across all segments)
+- the "segmentId" the mention belongs to
+- the verbatim "text" of the mention (copy from the input — do not rewrite)
+- the character "span" (an object with "start" inclusive, "end" exclusive) relative to the SEGMENT'S TEXT (not the original input)
+
+A single segment can produce multiple mentions when it asserts multiple things. Most segments produce one mention. Do NOT deduplicate — if the same proposition is reasserted in a later segment, emit it as a separate mention there too. Do NOT classify the mention. Do NOT include connectives, hedges, or discourse markers in the span when they are not part of the asserted proposition.
+
+If a segment is purely a discourse marker (e.g., "Therefore," or "Moreover,"), emit no mention for it. If there are no mentions at all, return \`{ "mentions": [] }\`.`;
+function buildPrompt(ctx) {
+    const segmentation = ctx.get(STAGE_IDS.segmentation);
+    const segments = segmentation?.segments ?? [];
+    const renderedSegments = segments
+        .map((s) => `[${s.segmentId}] ${JSON.stringify(s.text)}`)
+        .join("\n");
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.claimMentionExtraction} -->\n${CLAIM_MENTION_EXTRACTION_SYSTEM_PROMPT}`;
+    const user = `Segments:\n\n${renderedSegments}\n\nExtract every claim mention.`;
+    return { system: markedSystem, user };
+}
+/** Internal default knobs for the claim-mention-extraction stage. */
+export const CLAIM_MENTION_EXTRACTION_STAGE_DEFAULTS = {};
+/** Build the claim-mention-extraction stage with optional caller overrides. */
+export function createClaimMentionExtractionStage(options) {
+    return llmStage({
+        id: STAGE_IDS.claimMentionExtraction,
+        dependsOn: [STAGE_IDS.segmentation],
+        outputSchema: ClaimMentionExtractionOutputSchema,
+        model: CLAIM_MENTION_EXTRACTION_MODEL,
+        maxOutputTokens: options?.maxOutputTokens,
+        reasoningEffort: options?.reasoningEffort,
+        buildPrompt,
+    });
+}
+/** Backward-compatible default-options stage. */
+export const claimMentionExtractionStage = createClaimMentionExtractionStage();
+//# sourceMappingURL=claim-mention-extraction.js.map

package/dist/extensions/argument-ingestion/stages/claim-mention-extraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-mention-extraction.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-mention-extraction.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,qEAAqE;AACrE,oEAAoE;AACpE,mEAAmE;AACnE,+DAA+D;AAC/D,2BAA2B;AAE3B,OAAO,EACH,SAAS,EACT,kCAAkC,GAGrC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAA;AAIlE,MAAM,CAAC,MAAM,8BAA8B,GAAG,SAAS,CAAA;AAEvD,MAAM,CAAC,MAAM,sCAAsC,GAAG;;;;;;;;;;uKAUiH,CAAA;AAEvK,SAAS,WAAW,CAAC,GAAkB;IACnC,MAAM,YAAY,GAAG,GAAG,CAAC,GAAG,CAAsB,SAAS,CAAC,YAAY,CAAC,CAAA;IACzE,MAAM,QAAQ,GAAG,YAAY,EAAE,QAAQ,IAAI,EAAE,CAAA;IAC7C,MAAM,gBAAgB,GAAG,QAAQ;SAC5B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;SACxD,IAAI,CAAC,IAAI,CAAC,CAAA;IACf,MAAM,YAAY,GAAG,kBAAkB,SAAS,CAAC,sBAAsB,SAAS,sCAAsC,EAAE,CAAA;IACxH,MAAM,IAAI,GAAG,gBAAgB,gBAAgB,kCAAkC,CAAA;IAC/E,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAA;AACzC,CAAC;AAED,qEAAqE;AACrE,MAAM,CAAC,MAAM,uCAAuC,GAChD,EAAE,CAAA;AAEN,+EAA+E;AAC/E,MAAM,UAAU,iCAAiC,CAC7C,OAAkC;IAElC,OAAO,QAAQ,CAAgC;QAC3C,EAAE,EAAE,SAAS,CAAC,sBAAsB;QACpC,SAAS,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC;QACnC,YAAY,EAAE,kCAAkC;QAChD,KAAK,EAAE,8BAA8B;QACrC,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,WAAW;KACd,CAAC,CAAA;AACN,CAAC;AAED,iDAAiD;AACjD,MAAM,CAAC,MAAM,2BAA2B,GACpC,iCAAiC,EAAE,CAAA"}

package/dist/extensions/argument-ingestion/stages/claim-reference-validation.d.ts

@@ -0,0 +1,37 @@
+import { type TClaimCanonicalizationOutput, type TValidationStageOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+export declare const CLAIM_REFERENCE_FAILURE_CODES: {
+    readonly miniIdCollision: "CLAIM_MINIID_COLLISION";
+    readonly danglingMapping: "CLAIM_MENTION_MAPPING_DANGLING";
+    readonly emptyMentionId: "CLAIM_MENTION_ID_EMPTY";
+    readonly emptyMentionList: "CLAIM_MENTION_LIST_EMPTY";
+};
+export type TClaimReferenceFailureContext = {
+    code: "CLAIM_MINIID_COLLISION";
+    claimMiniId: string;
+    occurrences: number;
+} | {
+    code: "CLAIM_MENTION_MAPPING_DANGLING";
+    mentionId: string;
+    unknownClaimMiniId: string;
+} | {
+    code: "CLAIM_MENTION_ID_EMPTY";
+    targetClaimMiniId: string;
+} | {
+    code: "CLAIM_MENTION_LIST_EMPTY";
+    claimMiniId: string;
+};
+/**
+ * Pure helper exposed for direct testing. Returns the list of
+ * failures the stage will emit; the stage wrapper also calls
+ * `ctx.addFailure` on each.
+ */
+export declare function validateClaimReferences(canon: TClaimCanonicalizationOutput): {
+    failures: {
+        code: string;
+        message: string;
+        context: Record<string, unknown>;
+    }[];
+};
+export declare const claimReferenceValidationStage: TStage<TValidationStageOutput>;
+//# sourceMappingURL=claim-reference-validation.d.ts.map

package/dist/extensions/argument-ingestion/stages/claim-reference-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-reference-validation.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-reference-validation.ts"],"names":[],"mappings":"AAiBA,OAAO,EAGH,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,EAC9B,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAE7D,eAAO,MAAM,6BAA6B;;;;;CAKhC,CAAA;AAEV,MAAM,MAAM,6BAA6B,GACnC;IACI,IAAI,EAAE,wBAAwB,CAAA;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACtB,GACD;IACI,IAAI,EAAE,gCAAgC,CAAA;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,kBAAkB,EAAE,MAAM,CAAA;CAC7B,GACD;IAAE,IAAI,EAAE,wBAAwB,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,0BAA0B,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/D;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,4BAA4B,GAAG;IAC1E,QAAQ,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACnC,EAAE,CAAA;CACN,CAmEA;AAED,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,sBAAsB,CAyBnE,CAAA"}

package/dist/extensions/argument-ingestion/stages/claim-reference-validation.js

@@ -0,0 +1,108 @@
+// `claim-reference-validation` — deterministic stage that audits the
+// `claim-canonicalization` output for internal consistency.
+//
+// Emits a `ProcessingFailure` (via `ctx.addFailure`) for each of:
+//   - **miniId collision** — two canonical claims share the same
+//     `miniId`.
+//   - **dangling mapping** — `mentionToClaim` references a `miniId`
+//     that isn't in `canonicalClaims`.
+//   - **empty mention id** — `mentionToClaim` key is empty/whitespace.
+//   - **empty mention list on a claim** — a claim's `mentionIds` is
+//     empty (a canonicalizer-internal bug; every canonical claim
+//     should map back to ≥1 mention).
+//
+// Doesn't gate downstream (failures are informational; the stage's
+// return value mirrors the emitted failures for any downstream stage
+// that wants to consult them, but most don't).
+import { STAGE_IDS, ValidationStageOutputSchema, } from "./schemas.js";
+import { deterministicStage } from "../../../lib/pipelines/stage-helpers.js";
+export const CLAIM_REFERENCE_FAILURE_CODES = {
+    miniIdCollision: "CLAIM_MINIID_COLLISION",
+    danglingMapping: "CLAIM_MENTION_MAPPING_DANGLING",
+    emptyMentionId: "CLAIM_MENTION_ID_EMPTY",
+    emptyMentionList: "CLAIM_MENTION_LIST_EMPTY",
+};
+/**
+ * Pure helper exposed for direct testing. Returns the list of
+ * failures the stage will emit; the stage wrapper also calls
+ * `ctx.addFailure` on each.
+ */
+export function validateClaimReferences(canon) {
+    const failures = [];
+    // 1. miniId collisions.
+    const miniIdCounts = new Map();
+    for (const claim of canon.canonicalClaims) {
+        miniIdCounts.set(claim.miniId, (miniIdCounts.get(claim.miniId) ?? 0) + 1);
+    }
+    for (const [miniId, count] of miniIdCounts) {
+        if (count > 1) {
+            failures.push({
+                code: CLAIM_REFERENCE_FAILURE_CODES.miniIdCollision,
+                message: `Canonical claim miniId "${miniId}" appears ${String(count)} times; miniIds must be unique within a single pipeline run.`,
+                context: { claimMiniId: miniId, occurrences: count },
+            });
+        }
+    }
+    const knownMiniIds = new Set(canon.canonicalClaims.map((c) => c.miniId));
+    // 2. mentionToClaim dangling references + empty mention ids.
+    // mentionToClaim is now a list of { mentionId, claimMiniId }
+    // entries (lambda-fold 4 — OpenAI strict-mode doesn't accept
+    // Record-shaped maps with arbitrary string keys).
+    for (const entry of canon.mentionToClaim) {
+        const { mentionId, claimMiniId } = entry;
+        if (mentionId.trim().length === 0) {
+            failures.push({
+                code: CLAIM_REFERENCE_FAILURE_CODES.emptyMentionId,
+                message: `mentionToClaim has an empty/whitespace mention id targeting claim "${claimMiniId}".`,
+                context: { targetClaimMiniId: claimMiniId },
+            });
+            continue;
+        }
+        if (!knownMiniIds.has(claimMiniId)) {
+            failures.push({
+                code: CLAIM_REFERENCE_FAILURE_CODES.danglingMapping,
+                message: `mentionToClaim entry "${mentionId}" points at claim "${claimMiniId}" which is not in canonicalClaims.`,
+                context: {
+                    mentionId,
+                    unknownClaimMiniId: claimMiniId,
+                },
+            });
+        }
+    }
+    // 3. claims with empty mentionIds.
+    for (const claim of canon.canonicalClaims) {
+        if (claim.mentionIds.length === 0) {
+            failures.push({
+                code: CLAIM_REFERENCE_FAILURE_CODES.emptyMentionList,
+                message: `Canonical claim "${claim.miniId}" has an empty mentionIds list; every canonical claim must reference at least one mention.`,
+                context: { claimMiniId: claim.miniId },
+            });
+        }
+    }
+    return { failures };
+}
+export const claimReferenceValidationStage = deterministicStage({
+    id: STAGE_IDS.claimReferenceValidation,
+    dependsOn: [STAGE_IDS.claimCanonicalization],
+    outputSchema: ValidationStageOutputSchema,
+    fn: (ctx) => {
+        const canon = ctx.get(STAGE_IDS.claimCanonicalization);
+        if (!canon)
+            return [];
+        const { failures } = validateClaimReferences(canon);
+        for (const f of failures) {
+            ctx.addFailure({
+                code: f.code,
+                message: f.message,
+                severity: "warning",
+                context: f.context,
+            });
+        }
+        return failures.map((f) => ({
+            code: f.code,
+            message: f.message,
+            context: f.context,
+        }));
+    },
+});
+//# sourceMappingURL=claim-reference-validation.js.map

package/dist/extensions/argument-ingestion/stages/claim-reference-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-reference-validation.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-reference-validation.ts"],"names":[],"mappings":"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"}

package/dist/extensions/argument-ingestion/stages/claim-type-classification.d.ts

@@ -0,0 +1,12 @@
+import { type TClaimTypeClassificationOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const CLAIM_TYPE_CLASSIFICATION_MODEL = "gpt-5.4";
+export declare const CLAIM_TYPE_CLASSIFICATION_SYSTEM_PROMPT = "You confirm or revise the type of each canonical claim in an argument-ingestion pipeline.\n\nReturn an object with a single key `classifications` whose value is an array of per-claim entries. For each canonical claim you receive (id, the canonicalizer's draft `type`, and the claim's body/title/url/axiom fields), emit one entry with:\n- `miniId` \u2014 the canonical claim's miniId (copy verbatim)\n- `type` \u2014 one of \"normal\", \"citation\", \"axiomatic\"\n- `sourceString` \u2014 populate when type is \"citation\" with the source label (or url) the claim is built on; null otherwise\n\nUse the supplied detected citation sources + axiom indicators as evidence. Override the canonicalizer's draft only when the evidence clearly contradicts it. The default is to confirm the draft. Be conservative \u2014 a wrong override here cascades into wrong support edges downstream.\n\nEvery input claim must appear in `classifications` exactly once.\n\n## Type rules\n\n- `\"normal\"` \u2014 primary reasoning content; the default.\n- `\"citation\"` \u2014 content is \"the cited source says/shows X\" AND a citation source covers the claim. The claim's title/body summarizes what the source asserts; the URL (when present) names the source.\n- `\"axiomatic\"` \u2014 content is invoked as self-evidently true AND an axiom indicator (e.g. \"by definition\") covers or precedes the claim.";
+/** Internal default knobs for the claim-type-classification stage. */
+export declare const CLAIM_TYPE_CLASSIFICATION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/** Build the claim-type-classification stage with optional caller overrides. */
+export declare function createClaimTypeClassificationStage(options?: TLlmStageOptionsOverride): TStage<TClaimTypeClassificationOutput>;
+/** Backward-compatible default-options stage. */
+export declare const claimTypeClassificationStage: TStage<TClaimTypeClassificationOutput>;
+//# sourceMappingURL=claim-type-classification.d.ts.map

package/dist/extensions/argument-ingestion/stages/claim-type-classification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-type-classification.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-type-classification.ts"],"names":[],"mappings":"AAOA,OAAO,EAMH,KAAK,8BAA8B,EACtC,MAAM,cAAc,CAAA;AAGrB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAElE,eAAO,MAAM,+BAA+B,YAAY,CAAA;AAExD,eAAO,MAAM,uCAAuC,82CAesF,CAAA;AAqD1I,sEAAsE;AACtE,eAAO,MAAM,wCAAwC,EAAE,wBACjD,CAAA;AAEN,gFAAgF;AAChF,wBAAgB,kCAAkC,CAC9C,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,8BAA8B,CAAC,CAcxC;AAED,iDAAiD;AACjD,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,8BAA8B,CACxC,CAAA"}

package/dist/extensions/argument-ingestion/stages/claim-type-classification.js

@@ -0,0 +1,76 @@
+// `claim-type-classification` — refines or confirms the canonicalizer's
+// per-claim `type` field. The canonicalizer already drafted a type
+// based on whether a citation or axiom indicator covered the claim;
+// this stage is a second pass that catches mis-classifications (e.g.
+// a claim the canonicalizer marked "normal" that actually belongs to
+// "citation" because the source's content equals the claim's content).
+import { STAGE_IDS, ClaimTypeClassificationOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+import { optional } from "../../../lib/pipelines/types.js";
+export const CLAIM_TYPE_CLASSIFICATION_MODEL = "gpt-5.4";
+export const CLAIM_TYPE_CLASSIFICATION_SYSTEM_PROMPT = `You confirm or revise the type of each canonical claim in an argument-ingestion pipeline.
+
+Return an object with a single key \`classifications\` whose value is an array of per-claim entries. For each canonical claim you receive (id, the canonicalizer's draft \`type\`, and the claim's body/title/url/axiom fields), emit one entry with:
+- \`miniId\` — the canonical claim's miniId (copy verbatim)
+- \`type\` — one of "normal", "citation", "axiomatic"
+- \`sourceString\` — populate when type is "citation" with the source label (or url) the claim is built on; null otherwise
+
+Use the supplied detected citation sources + axiom indicators as evidence. Override the canonicalizer's draft only when the evidence clearly contradicts it. The default is to confirm the draft. Be conservative — a wrong override here cascades into wrong support edges downstream.
+
+Every input claim must appear in \`classifications\` exactly once.
+
+## Type rules
+
+- \`"normal"\` — primary reasoning content; the default.
+- \`"citation"\` — content is "the cited source says/shows X" AND a citation source covers the claim. The claim's title/body summarizes what the source asserts; the URL (when present) names the source.
+- \`"axiomatic"\` — content is invoked as self-evidently true AND an axiom indicator (e.g. "by definition") covers or precedes the claim.`;
+function buildPrompt(ctx) {
+    const canon = ctx.get(STAGE_IDS.claimCanonicalization);
+    const citationEnvelope = ctx.get(STAGE_IDS.citationSourceDetection);
+    const citations = citationEnvelope?.sources ?? [];
+    const axiomEnvelope = ctx.get(STAGE_IDS.axiomIndicatorDetection);
+    const axioms = axiomEnvelope?.axioms ?? [];
+    const claimLines = (canon?.canonicalClaims ?? [])
+        .map((c) => `  [${c.miniId}] type=${c.type} suggestedSymbol=${c.suggestedSymbol} fields=${JSON.stringify({
+        ...c,
+        miniId: undefined,
+        mentionIds: undefined,
+        suggestedSymbol: undefined,
+        type: undefined,
+    })}`)
+        .join("\n");
+    const citationLines = citations.length > 0
+        ? citations
+            .map((c) => `  [${c.sourceId} @ ${c.segmentIds.join(",")}] ${JSON.stringify(c.sourceString)}${c.url ? ` (url: ${c.url})` : ""}`)
+            .join("\n")
+        : "  (none)";
+    const axiomLines = axioms.length > 0
+        ? axioms
+            .map((a) => `  [${a.axiomId} @ ${a.segmentIds.join(",")}] ${JSON.stringify(a.indicator)}`)
+            .join("\n")
+        : "  (none)";
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.claimTypeClassification} -->\n${CLAIM_TYPE_CLASSIFICATION_SYSTEM_PROMPT}`;
+    const user = `Canonical claims (with the canonicalizer's draft type):\n${claimLines}\n\nDetected citation sources:\n${citationLines}\n\nDetected axiom indicators:\n${axiomLines}\n\nEmit the per-claim type map.`;
+    return { system: markedSystem, user };
+}
+/** Internal default knobs for the claim-type-classification stage. */
+export const CLAIM_TYPE_CLASSIFICATION_STAGE_DEFAULTS = {};
+/** Build the claim-type-classification stage with optional caller overrides. */
+export function createClaimTypeClassificationStage(options) {
+    return llmStage({
+        id: STAGE_IDS.claimTypeClassification,
+        dependsOn: [
+            STAGE_IDS.claimCanonicalization,
+            optional(STAGE_IDS.citationSourceDetection),
+            optional(STAGE_IDS.axiomIndicatorDetection),
+        ],
+        outputSchema: ClaimTypeClassificationOutputSchema,
+        model: CLAIM_TYPE_CLASSIFICATION_MODEL,
+        maxOutputTokens: options?.maxOutputTokens,
+        reasoningEffort: options?.reasoningEffort,
+        buildPrompt,
+    });
+}
+/** Backward-compatible default-options stage. */
+export const claimTypeClassificationStage = createClaimTypeClassificationStage();
+//# sourceMappingURL=claim-type-classification.js.map

package/dist/extensions/argument-ingestion/stages/claim-type-classification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-type-classification.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-type-classification.ts"],"names":[],"mappings":"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"}

package/dist/extensions/argument-ingestion/stages/conclusion-selection.d.ts

@@ -0,0 +1,27 @@
+import { type TConclusionSelectionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const CONCLUSION_SELECTION_MODEL = "gpt-5.5";
+export declare const CONCLUSION_SELECTION_REASONING: "minimal" | "low" | "medium" | "high";
+export declare const CONCLUSION_SELECTION_NO_CONCLUSION_FAILURE_CODE = "NO_SINGLE_CONCLUSION";
+export declare const CONCLUSION_SELECTION_SYSTEM_PROMPT = "You select the single conclusion claim of an argument from the canonical claim set and the relation graph.\n\nYou receive:\n- the per-claim type map (normal / citation / axiomatic)\n- the support relation graph from `relation-extraction`\n\nEmit:\n- `conclusionMiniId` \u2014 the canonical claim miniId of the conclusion, OR `null` when no single claim is clearly the conclusion\n- `rationale` \u2014 a one-sentence explanation of your pick (or your inability to pick one)\n\n## Selection rules\n\n1. The conclusion is the claim that no other claim is meant to support but is itself the terminus of one or more support edges. In a clean argument it's the \"therefore X\" claim.\n2. If multiple distinct claims are each terminal AND each could plausibly be THE point of the argument (genuinely ambiguous), return null with a rationale naming the contenders.\n3. Citation-typed and axiomatic-typed claims are never conclusions \u2014 they are always sources of support.\n4. If no claim is supported by any relation (a single-statement input), return null; there is no argument to select a conclusion from.\n\nThe default disposition is \"select\"; only return null when ambiguity is genuine. Forcing a wrong choice is worse than admitting \"no single conclusion could be selected\" \u2014 downstream stages handle the null cleanly.";
+/** Internal default knobs for the conclusion-selection stage. */
+export declare const CONCLUSION_SELECTION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/**
+ * Build the conclusion-selection stage with optional caller
+ * overrides. The stage wraps an inner `llmStage` so that when the LLM
+ * returns `conclusionMiniId: null`, it also emits a
+ * `ProcessingFailure` with code `NO_SINGLE_CONCLUSION` via
+ * `ctx.addFailure` (spec §7.2 row 10). The stage still completes
+ * successfully — the null output flows through `formula-compilation`
+ * (which emits `conclusionPremiseMiniId: null`) into
+ * `finalize-response-v2` (which assembles `{ argument: null,
+ * failureText: "No single conclusion could be selected." }`). The
+ * added failure is a UI-rendering hint, not a task-outcome signal;
+ * severity is `warning` to match the informational-only role of
+ * finalize's failureText path.
+ */
+export declare function createConclusionSelectionStage(options?: TLlmStageOptionsOverride): TStage<TConclusionSelectionOutput>;
+/** Backward-compatible default-options stage. */
+export declare const conclusionSelectionStage: TStage<TConclusionSelectionOutput>;
+//# sourceMappingURL=conclusion-selection.d.ts.map

package/dist/extensions/argument-ingestion/stages/conclusion-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conclusion-selection.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/conclusion-selection.ts"],"names":[],"mappings":"AAWA,OAAO,EAIH,KAAK,0BAA0B,EAElC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAElE,eAAO,MAAM,0BAA0B,YAAY,CAAA;AACnD,eAAO,MAAM,8BAA8B,EACrC,SAAS,GACT,KAAK,GACL,QAAQ,GACR,MAAiB,CAAA;AAEvB,eAAO,MAAM,+CAA+C,yBAClC,CAAA;AAE1B,eAAO,MAAM,kCAAkC,szCAiBuK,CAAA;AA8BtN,iEAAiE;AACjE,eAAO,MAAM,mCAAmC,EAAE,wBAEjD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAC1C,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,0BAA0B,CAAC,CAkCpC;AAED,iDAAiD;AACjD,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,0BAA0B,CACpC,CAAA"}