@proposit/proposit-core 1.2.0 → 1.3.0

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

@@ -0,0 +1,38 @@
+// `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 };
+}
+export const claimMentionExtractionStage = llmStage({
+    id: STAGE_IDS.claimMentionExtraction,
+    dependsOn: [STAGE_IDS.segmentation],
+    outputSchema: ClaimMentionExtractionOutputSchema,
+    model: CLAIM_MENTION_EXTRACTION_MODEL,
+    buildPrompt,
+});
+//# 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;AAGlE,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,MAAM,CAAC,MAAM,2BAA2B,GACpC,QAAQ,CAAgC;IACpC,EAAE,EAAE,SAAS,CAAC,sBAAsB;IACpC,SAAS,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC;IACnC,YAAY,EAAE,kCAAkC;IAChD,KAAK,EAAE,8BAA8B;IACrC,WAAW;CACd,CAAC,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,6 @@
+import { type TClaimTypeClassificationOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/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.";
+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;AAE5E,eAAO,MAAM,+BAA+B,YAAY,CAAA;AAExD,eAAO,MAAM,uCAAuC,82CAesF,CAAA;AAqD1I,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,8BAA8B,CAW1E,CAAA"}

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

@@ -0,0 +1,67 @@
+// `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 };
+}
+export const claimTypeClassificationStage = llmStage({
+    id: STAGE_IDS.claimTypeClassification,
+    dependsOn: [
+        STAGE_IDS.claimCanonicalization,
+        optional(STAGE_IDS.citationSourceDetection),
+        optional(STAGE_IDS.axiomIndicatorDetection),
+    ],
+    outputSchema: ClaimTypeClassificationOutputSchema,
+    model: CLAIM_TYPE_CLASSIFICATION_MODEL,
+    buildPrompt,
+});
+//# 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,20 @@
+import { type TConclusionSelectionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/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.";
+/**
+ * `conclusionSelectionStage` wraps the inner `llmStage` so that when
+ * the LLM returns `conclusionMiniId: null`, the stage 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 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;AAE5E,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;AA2CtN;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,0BAA0B,CAmBvE,CAAA"}

package/dist/extensions/argument-ingestion/stages/conclusion-selection.js

@@ -0,0 +1,94 @@
+// `conclusion-selection` — picks the single claim that is the
+// argument's conclusion (the proposition the argument is FOR). Returns
+// null when no single conclusion can be selected (multiple distinct
+// conclusions, no clear conclusion at all). The null path drives
+// `formula-compilation.conclusionPremiseMiniId === null` which in
+// turn drives finalize's "argument: null + failureText: 'No single
+// conclusion could be selected.'" per spec §7.5.
+//
+// Per spec §6.4 this is a strong-reasoning stage: gpt-5.5 with
+// reasoning_effort=medium.
+import { STAGE_IDS, ConclusionSelectionOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const CONCLUSION_SELECTION_MODEL = "gpt-5.5";
+export const CONCLUSION_SELECTION_REASONING = "medium";
+export const CONCLUSION_SELECTION_NO_CONCLUSION_FAILURE_CODE = "NO_SINGLE_CONCLUSION";
+export const CONCLUSION_SELECTION_SYSTEM_PROMPT = `You select the single conclusion claim of an argument from the canonical claim set and the relation graph.
+
+You receive:
+- the per-claim type map (normal / citation / axiomatic)
+- the support relation graph from \`relation-extraction\`
+
+Emit:
+- \`conclusionMiniId\` — the canonical claim miniId of the conclusion, OR \`null\` when no single claim is clearly the conclusion
+- \`rationale\` — a one-sentence explanation of your pick (or your inability to pick one)
+
+## Selection rules
+
+1. 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.
+2. 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.
+3. Citation-typed and axiomatic-typed claims are never conclusions — they are always sources of support.
+4. If no claim is supported by any relation (a single-statement input), return null; there is no argument to select a conclusion from.
+
+The 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" — downstream stages handle the null cleanly.`;
+function buildPrompt(ctx) {
+    const typeEnvelope = ctx.get(STAGE_IDS.claimTypeClassification);
+    const classifications = typeEnvelope?.classifications ?? [];
+    const relationEnvelope = ctx.get(STAGE_IDS.relationExtraction);
+    const relations = relationEnvelope?.relations ?? [];
+    const typeLines = classifications
+        .map((entry) => `  [${entry.miniId}] type=${entry.type}`)
+        .join("\n");
+    const relationLines = relations.length > 0
+        ? relations
+            .map((r) => `  [${r.relationId}] ${r.type}: sources=[${r.sources.join(",")}] target=${r.target}`)
+            .join("\n")
+        : "  (no relations)";
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.conclusionSelection} -->\n${CONCLUSION_SELECTION_SYSTEM_PROMPT}`;
+    const user = `Per-claim types:\n${typeLines}\n\nRelations:\n${relationLines}\n\nSelect the conclusion (or return null).`;
+    return { system: markedSystem, user };
+}
+// Inner llmStage that actually performs the LLM call.
+const innerStage = llmStage({
+    id: STAGE_IDS.conclusionSelection,
+    dependsOn: [
+        STAGE_IDS.claimTypeClassification,
+        STAGE_IDS.relationExtraction,
+    ],
+    outputSchema: ConclusionSelectionOutputSchema,
+    model: CONCLUSION_SELECTION_MODEL,
+    reasoningEffort: CONCLUSION_SELECTION_REASONING,
+    buildPrompt,
+});
+/**
+ * `conclusionSelectionStage` wraps the inner `llmStage` so that when
+ * the LLM returns `conclusionMiniId: null`, the stage 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 const conclusionSelectionStage = {
+    id: innerStage.id,
+    dependsOn: innerStage.dependsOn,
+    outputSchema: innerStage.outputSchema,
+    run: async (ctx) => {
+        const output = await innerStage.run(ctx);
+        if (output.conclusionMiniId === null) {
+            ctx.addFailure({
+                code: CONCLUSION_SELECTION_NO_CONCLUSION_FAILURE_CODE,
+                message: output.rationale.length > 0
+                    ? output.rationale
+                    : "No single conclusion could be selected.",
+                severity: "warning",
+                context: { rationale: output.rationale },
+            });
+        }
+        return output;
+    },
+};
+//# sourceMappingURL=conclusion-selection.js.map

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

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

package/dist/extensions/argument-ingestion/stages/formula-compilation.d.ts

@@ -0,0 +1,27 @@
+import { type TConclusionSelectionOutput, type TFormulaCompilationOutput, type TRelationExtractionOutput, type TVariableAssignmentOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+export declare const FORMULA_COMPILATION_FAILURE_CODES: {
+    readonly unresolvedSource: "FORMULA_COMPILATION_SOURCE_UNRESOLVED";
+    readonly unresolvedTarget: "FORMULA_COMPILATION_TARGET_UNRESOLVED";
+    readonly unresolvedConclusion: "FORMULA_COMPILATION_CONCLUSION_UNRESOLVED";
+    readonly emptySources: "FORMULA_COMPILATION_SOURCES_EMPTY";
+};
+export type TCompileFormulasInput = {
+    /** Bare relations array (unwrapped from the stage's envelope). */
+    relations: TRelationExtractionOutput["relations"];
+    conclusion: TConclusionSelectionOutput | undefined;
+    variables: TVariableAssignmentOutput;
+    generateId: () => string;
+    addFailure?: (failure: {
+        code: string;
+        message: string;
+        severity: "warning" | "error";
+        context?: Record<string, unknown>;
+    }) => void;
+};
+/**
+ * Pure helper exposed for direct testing.
+ */
+export declare function compileFormulas(input: TCompileFormulasInput): TFormulaCompilationOutput;
+export declare const formulaCompilationStage: TStage<TFormulaCompilationOutput>;
+//# sourceMappingURL=formula-compilation.d.ts.map

package/dist/extensions/argument-ingestion/stages/formula-compilation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula-compilation.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/formula-compilation.ts"],"names":[],"mappings":"AAwBA,OAAO,EAGH,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAE9B,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EACjC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAE5E,eAAO,MAAM,iCAAiC;;;;;CAKpC,CAAA;AAEV,MAAM,MAAM,qBAAqB,GAAG;IAChC,kEAAkE;IAClE,SAAS,EAAE,yBAAyB,CAAC,WAAW,CAAC,CAAA;IACjD,UAAU,EAAE,0BAA0B,GAAG,SAAS,CAAA;IAClD,SAAS,EAAE,yBAAyB,CAAA;IACpC,UAAU,EAAE,MAAM,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE;QACnB,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAA;QAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACpC,KAAK,IAAI,CAAA;CACb,CAAA;AAyBD;;GAEG;AACH,wBAAgB,eAAe,CAC3B,KAAK,EAAE,qBAAqB,GAC7B,yBAAyB,CAqG3B;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,yBAAyB,CA8BhE,CAAA"}

package/dist/extensions/argument-ingestion/stages/formula-compilation.js

@@ -0,0 +1,175 @@
+// `formula-compilation` — deterministic stage that compiles each
+// `relation-extraction` output into a `parseFormula`-consumable
+// formula string, and mints one dedicated "conclusion premise" whose
+// formula is just the conclusion claim's variable symbol.
+//
+// Compilation rules (spec §7.3):
+//   support           s         → t   ⇒  s_symbol IMPLIES t_symbol
+//   joint-support     s1..sn    → t   ⇒  (s1 AND s2 AND ...) IMPLIES t_symbol
+//   derivation-support s        → t   ⇒  s_symbol IMPLIES t_symbol
+//
+// The conclusion-premise mapping rule:
+//   - When `conclusion-selection.conclusionMiniId` is non-null:
+//     exactly one premise is minted with `roleHint: "conclusion"` and
+//     `formula: <conclusion claim's variable symbol>`.
+//   - When `conclusion-selection.conclusionMiniId` is null OR the
+//     conclusion claim has no resolvable variable symbol:
+//     `conclusionPremiseMiniId` is null and the conclusion premise is
+//     not emitted. The relation premises are still emitted.
+//
+// We emit a `ProcessingFailure` (severity `error`) when a relation's
+// `sources` or `target` cannot be resolved to a variable symbol. The
+// failing relation's premise is dropped from the output (we can't
+// compile it without symbols).
+import { STAGE_IDS, FormulaCompilationOutputSchema, } from "./schemas.js";
+import { deterministicStage } from "../../../lib/pipelines/stage-helpers.js";
+export const FORMULA_COMPILATION_FAILURE_CODES = {
+    unresolvedSource: "FORMULA_COMPILATION_SOURCE_UNRESOLVED",
+    unresolvedTarget: "FORMULA_COMPILATION_TARGET_UNRESOLVED",
+    unresolvedConclusion: "FORMULA_COMPILATION_CONCLUSION_UNRESOLVED",
+    emptySources: "FORMULA_COMPILATION_SOURCES_EMPTY",
+};
+function buildClaimToSymbol(variables) {
+    const m = new Map();
+    for (const v of variables) {
+        m.set(v.claimMiniId, v.symbol);
+    }
+    return m;
+}
+function relationToRoleHint(type) {
+    switch (type) {
+        case "support":
+            return "support";
+        case "joint-support":
+            return "joint-support";
+        case "derivation-support":
+            return "derivation";
+    }
+}
+/**
+ * Pure helper exposed for direct testing.
+ */
+export function compileFormulas(input) {
+    const claimToSymbol = buildClaimToSymbol(input.variables);
+    const noopEmit = () => {
+        // intentionally empty — tests can supply addFailure to capture emits
+    };
+    const emit = input.addFailure ?? noopEmit;
+    const premises = [];
+    // Compile each relation into a premise.
+    for (const relation of input.relations) {
+        if (relation.sources.length === 0) {
+            emit({
+                code: FORMULA_COMPILATION_FAILURE_CODES.emptySources,
+                message: `Relation "${relation.relationId}" has no sources; cannot compile.`,
+                severity: "warning",
+                context: { relationId: relation.relationId },
+            });
+            continue;
+        }
+        const targetSymbol = claimToSymbol.get(relation.target);
+        if (!targetSymbol) {
+            emit({
+                code: FORMULA_COMPILATION_FAILURE_CODES.unresolvedTarget,
+                message: `Relation "${relation.relationId}" target claim "${relation.target}" has no variable assignment; dropping.`,
+                severity: "error",
+                context: {
+                    relationId: relation.relationId,
+                    targetClaimMiniId: relation.target,
+                },
+            });
+            continue;
+        }
+        const sourceSymbols = [];
+        let sourcesOk = true;
+        for (const src of relation.sources) {
+            const sym = claimToSymbol.get(src);
+            if (!sym) {
+                emit({
+                    code: FORMULA_COMPILATION_FAILURE_CODES.unresolvedSource,
+                    message: `Relation "${relation.relationId}" source claim "${src}" has no variable assignment; dropping.`,
+                    severity: "error",
+                    context: {
+                        relationId: relation.relationId,
+                        sourceClaimMiniId: src,
+                    },
+                });
+                sourcesOk = false;
+                break;
+            }
+            sourceSymbols.push(sym);
+        }
+        if (!sourcesOk)
+            continue;
+        let formula;
+        if (relation.type === "joint-support" && sourceSymbols.length > 1) {
+            formula = `(${sourceSymbols.join(" and ")}) implies ${targetSymbol}`;
+        }
+        else if (sourceSymbols.length === 1) {
+            formula = `${sourceSymbols[0]} implies ${targetSymbol}`;
+        }
+        else {
+            // joint-support with exactly one source — degenerate; still
+            // compile as a plain support implication (the parens would
+            // be redundant). joint-support with zero sources is caught
+            // by the emptySources guard above.
+            formula = `${sourceSymbols.join(" and ")} implies ${targetSymbol}`;
+        }
+        premises.push({
+            premiseMiniId: input.generateId(),
+            formula,
+            roleHint: relationToRoleHint(relation.type),
+            sourceRelationId: relation.relationId,
+        });
+    }
+    // Mint the conclusion premise iff conclusion-selection chose a
+    // claim AND the claim resolves to a known variable symbol.
+    let conclusionPremiseMiniId = null;
+    const conclusionClaimMiniId = input.conclusion?.conclusionMiniId ?? null;
+    if (conclusionClaimMiniId !== null) {
+        const conclusionSymbol = claimToSymbol.get(conclusionClaimMiniId);
+        if (!conclusionSymbol) {
+            emit({
+                code: FORMULA_COMPILATION_FAILURE_CODES.unresolvedConclusion,
+                message: `Conclusion claim "${conclusionClaimMiniId}" has no variable assignment; cannot mint conclusion premise.`,
+                severity: "error",
+                context: { conclusionClaimMiniId },
+            });
+        }
+        else {
+            const id = input.generateId();
+            premises.push({
+                premiseMiniId: id,
+                formula: conclusionSymbol,
+                roleHint: "conclusion",
+                sourceRelationId: null,
+            });
+            conclusionPremiseMiniId = id;
+        }
+    }
+    return { premises, conclusionPremiseMiniId };
+}
+export const formulaCompilationStage = deterministicStage({
+    id: STAGE_IDS.formulaCompilation,
+    dependsOn: [
+        STAGE_IDS.relationExtraction,
+        STAGE_IDS.conclusionSelection,
+        STAGE_IDS.variableAssignment,
+        STAGE_IDS.claimTypeClassification,
+    ],
+    outputSchema: FormulaCompilationOutputSchema,
+    fn: (ctx) => {
+        const relationEnvelope = ctx.get(STAGE_IDS.relationExtraction);
+        const relations = relationEnvelope?.relations ?? [];
+        const conclusion = ctx.get(STAGE_IDS.conclusionSelection);
+        const variables = ctx.get(STAGE_IDS.variableAssignment) ?? [];
+        return compileFormulas({
+            relations,
+            conclusion,
+            variables,
+            generateId: ctx.generateId,
+            addFailure: ctx.addFailure,
+        });
+    },
+});
+//# sourceMappingURL=formula-compilation.js.map