@proposit/proposit-core 1.2.0 → 1.3.1

package/README.md

@@ -1196,4 +1196,13 @@ A CLI smoke test exercises every command against an isolated temp directory:
 pnpm run build && bash scripts/smoke-test.sh
 ```
 
+### Git hooks
+
+`pnpm install` runs a `prepare` script that points `core.hooksPath` at the
+tracked `.githooks/` directory, so the **pre-push** hook activates
+automatically. Before each push it runs Prettier (`--check`) on the files your
+branch changed relative to its remote counterpart, falling back to the whole
+repo when that comparison can't be made. Fix any reported files with
+`pnpm prettify`, or bypass the check once with `git push --no-verify`.
+
 See [CLI_EXAMPLES.md](CLI_EXAMPLES.md) for a full walkthrough.

package/dist/extensions/argument-ingestion/index.d.ts

@@ -1,9 +1,15 @@
-export { createIngestionV1Pipeline } from "./v1-single-shot.js";
+export { createIngestionV1Pipeline, V1_PARSE_STAGE_ID, } from "./v1-single-shot.js";
 export type { TCreateIngestionV1PipelineOptions } from "./v1-single-shot.js";
+export { createIngestionV2Pipeline } from "./v2-multi-stage.js";
+export type { TCreateIngestionV2PipelineOptions } from "./v2-multi-stage.js";
+export { resolveLlmStageOptions } from "./shared/resolve-llm-stage-options.js";
 export { basicsExtension } from "./shared/basics-extension.js";
-export type { TIngestionExtension, TIngestionInput } from "./shared/types.js";
+export type { TIngestionExtension, TIngestionInput, TIngestionLlmOptions, TLlmStageOptionsOverride, } from "./shared/types.js";
 export { finalizeResponse } from "./shared/finalize-response.js";
 export type { TFinalizeResponseInput } from "./shared/finalize-response.js";
+export { finalizeResponseV2, FINALIZE_V2_FAILURE_TEXTS, } from "./shared/finalize-response-v2.js";
+export type { TFinalizeResponseV2Input } from "./shared/finalize-response-v2.js";
 export { deriveRoles } from "./shared/role-derivation.js";
 export type { TClaimRole, TDeriveRolesInput } from "./shared/role-derivation.js";
+export * from "./stages/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/extensions/argument-ingestion/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,YAAY,EAAE,iCAAiC,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,yBAAyB,EACzB,iBAAiB,GACpB,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EAAE,iCAAiC,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,YAAY,EAAE,iCAAiC,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAA;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,YAAY,EACR,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,wBAAwB,GAC3B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EACH,kBAAkB,EAClB,yBAAyB,GAC5B,MAAM,kCAAkC,CAAA;AACzC,YAAY,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAA;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAGhF,cAAc,mBAAmB,CAAA"}

package/dist/extensions/argument-ingestion/index.js

@@ -1,11 +1,17 @@
 // Barrel for the argument-ingestion extension.
 //
-// Exposes the v1 single-shot pipeline factory + the default
-// `basicsExtension`. v2 (Phase 2 / slice 2A) will add
-// `createIngestionV2Pipeline` alongside the v1 entry-point; the
-// `TIngestionExtension` descriptor is forward-compatible across both.
-export { createIngestionV1Pipeline } from "./v1-single-shot.js";
+// Exposes the v1 single-shot pipeline factory + the v2 multi-stage
+// pipeline factory + the default `basicsExtension`. The shared
+// `TIngestionExtension` descriptor is forward-compatible across both
+// pipelines.
+export { createIngestionV1Pipeline, V1_PARSE_STAGE_ID, } from "./v1-single-shot.js";
+export { createIngestionV2Pipeline } from "./v2-multi-stage.js";
+export { resolveLlmStageOptions } from "./shared/resolve-llm-stage-options.js";
 export { basicsExtension } from "./shared/basics-extension.js";
 export { finalizeResponse } from "./shared/finalize-response.js";
+export { finalizeResponseV2, FINALIZE_V2_FAILURE_TEXTS, } from "./shared/finalize-response-v2.js";
 export { deriveRoles } from "./shared/role-derivation.js";
+// Per-stage exports — surfaced for consumers (e.g. observability
+// bridges) that want to key on stage ids without re-stringifying.
+export * from "./stages/index.js";
 //# sourceMappingURL=index.js.map

package/dist/extensions/argument-ingestion/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,4DAA4D;AAC5D,sDAAsD;AACtD,gEAAgE;AAChE,sEAAsE;AAEtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAE9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,mEAAmE;AACnE,+DAA+D;AAC/D,qEAAqE;AACrE,aAAa;AAEb,OAAO,EACH,yBAAyB,EACzB,iBAAiB,GACpB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAA;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAO9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,EACH,kBAAkB,EAClB,yBAAyB,GAC5B,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,iEAAiE;AACjE,kEAAkE;AAClE,cAAc,mBAAmB,CAAA"}

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.d.ts

@@ -0,0 +1,17 @@
+import type { TParsedArgumentResponse } from "../../../lib/parsing/index.js";
+import type { TStageContext } from "../../../lib/pipelines/index.js";
+import type { TIngestionExtension } from "./types.js";
+export declare const FINALIZE_V2_FAILURE_TEXTS: {
+    readonly noClaims: "No claims could be extracted from the input.";
+    readonly noConclusion: "No single conclusion could be selected.";
+};
+export type TFinalizeResponseV2Input = {
+    ctx: TStageContext;
+    extension: TIngestionExtension;
+};
+/**
+ * Assembles the v2 pipeline's final response from the
+ * `TStageContext`'s accumulated upstream outputs.
+ */
+export declare function finalizeResponseV2(input: TFinalizeResponseV2Input): TParsedArgumentResponse;
+//# sourceMappingURL=finalize-response-v2.d.ts.map

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize-response-v2.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/finalize-response-v2.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAWpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAErD,eAAO,MAAM,yBAAyB;;;CAG5B,CAAA;AAyGV,MAAM,MAAM,wBAAwB,GAAG;IACnC,GAAG,EAAE,aAAa,CAAA;IAClB,SAAS,EAAE,mBAAmB,CAAA;CACjC,CAAA;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,wBAAwB,GAChC,uBAAuB,CA2GzB"}

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.js

@@ -0,0 +1,185 @@
+// `finalize-response-v2` — assembles the v2 multi-stage pipeline's
+// final `TParsedArgumentResponse`-shaped output from accumulated
+// per-stage outputs.
+//
+// Behavior per spec §7.2 finalize row + §7.4 (role derivation) +
+// §7.5 (failure model):
+//
+//   - When `claim-canonicalization.canonicalClaims` is empty:
+//     `{ argument: null, failureText: "No claims could be extracted
+//     from the input.", uncategorizedText: null,
+//     selectionRationale: null, processingFailures: [] }`.
+//
+//   - When `formula-compilation.conclusionPremiseMiniId` is null
+//     (conclusion-selection returned null, or the conclusion claim
+//     wasn't resolvable to a symbol): `{ argument: null,
+//     failureText: "No single conclusion could be selected.", ... }`.
+//
+//   - Otherwise: assemble the full argument from the canonical claims
+//     (with per-claim role derived from `relation-extraction` +
+//     `conclusion-selection`), the variables from `variable-assignment`,
+//     and the premises from `formula-compilation`. The `selectionRationale`
+//     field is `conclusion-selection.rationale` (or null when the
+//     stage is missing).
+//
+// **`processingFailures` slot.** Mirroring v1's convention, finalize
+// always emits an empty `processingFailures: []` array on the output.
+// The full list of per-stage failures lives on `PipelineResult.failures`
+// — consumers that want them read that field. The slot on the response
+// object is a forward-compat hook; the framework doesn't have a clean
+// way for `finalize.run` to consult the executor's accumulated failure
+// list (which would require widening `TStageContext` — out of scope
+// for slice 2A.late).
+import { STAGE_IDS, } from "../stages/schemas.js";
+export const FINALIZE_V2_FAILURE_TEXTS = {
+    noClaims: "No claims could be extracted from the input.",
+    noConclusion: "No single conclusion could be selected.",
+};
+function buildClaimToRole(args) {
+    const out = {};
+    // Claims that participate in any relation (source or target) are
+    // "premise" by default; claims that don't appear in any relation
+    // are "intermediate" (per spec §7.4). The conclusion overrides.
+    const claimsInRelations = new Set();
+    for (const rel of args.relations) {
+        for (const s of rel.sources)
+            claimsInRelations.add(s);
+        claimsInRelations.add(rel.target);
+    }
+    for (const claim of args.canonicalClaims) {
+        if (claim.miniId === args.conclusionMiniId) {
+            out[claim.miniId] = "conclusion";
+        }
+        else if (claimsInRelations.has(claim.miniId)) {
+            out[claim.miniId] = "premise";
+        }
+        else {
+            out[claim.miniId] = "intermediate";
+        }
+    }
+    return out;
+}
+function stripCanonicalizerOnlyFields(claim) {
+    // The canonicalizer's per-claim record carries `mentionIds` and
+    // `suggestedSymbol` which are not part of the public response
+    // schema. Strip them from the finalize output (the variable's
+    // `symbol` carries the assigned identifier; mentionIds are an
+    // internal trace).
+    const stripped = {};
+    for (const [key, value] of Object.entries(claim)) {
+        if (key === "mentionIds" || key === "suggestedSymbol")
+            continue;
+        stripped[key] = value;
+    }
+    return stripped;
+}
+function buildPremiseTitle(formula, roleHint) {
+    const cap = 50;
+    const truncate = (s) => s.length <= cap ? s : s.slice(0, cap - 1) + "…";
+    switch (roleHint) {
+        case "conclusion":
+            return truncate(`Conclusion: ${formula}`);
+        case "joint-support":
+            return truncate(`Joint support → ${formula}`);
+        case "derivation":
+            return truncate(`Derivation: ${formula}`);
+        case "support":
+            return truncate(`Support: ${formula}`);
+    }
+}
+function buildArgumentTitle(canonicalClaims, conclusionMiniId) {
+    const cap = 50;
+    const conclusionClaim = canonicalClaims.find((c) => c.miniId === conclusionMiniId);
+    const candidateTitle = conclusionClaim?.title ??
+        conclusionClaim?.axiom ??
+        "Argument";
+    return candidateTitle.length <= cap
+        ? candidateTitle
+        : candidateTitle.slice(0, cap - 1) + "…";
+}
+/**
+ * Assembles the v2 pipeline's final response from the
+ * `TStageContext`'s accumulated upstream outputs.
+ */
+export function finalizeResponseV2(input) {
+    void input.extension; // forward-compat (extension-specific assembly hooks)
+    const { ctx } = input;
+    const canon = ctx.get(STAGE_IDS.claimCanonicalization);
+    const variables = ctx.get(STAGE_IDS.variableAssignment) ?? [];
+    const compilation = ctx.get(STAGE_IDS.formulaCompilation);
+    const conclusion = ctx.get(STAGE_IDS.conclusionSelection);
+    const relationEnvelope = ctx.get(STAGE_IDS.relationExtraction);
+    const relations = relationEnvelope?.relations ?? [];
+    const typeEnvelope = ctx.get(STAGE_IDS.claimTypeClassification);
+    const typeByMiniId = new Map();
+    for (const entry of typeEnvelope?.classifications ?? []) {
+        typeByMiniId.set(entry.miniId, entry);
+    }
+    const processingFailures = [];
+    const baseResponse = {
+        uncategorizedText: null,
+        selectionRationale: conclusion?.rationale ?? null,
+    };
+    // Failure path 1: no canonical claims at all.
+    if (!canon || canon.canonicalClaims.length === 0) {
+        return {
+            argument: null,
+            failureText: FINALIZE_V2_FAILURE_TEXTS.noClaims,
+            ...baseResponse,
+            // `processingFailures` is a side-channel slot the v1
+            // finalize also attaches; the response schema permits
+            // additional properties.
+            processingFailures,
+        };
+    }
+    // Failure path 2: no single conclusion could be selected (or the
+    // conclusion claim has no resolvable variable, in which case
+    // formula-compilation already emitted an unresolved-conclusion
+    // failure and left conclusionPremiseMiniId null).
+    if (compilation?.conclusionPremiseMiniId === null || !compilation) {
+        return {
+            argument: null,
+            failureText: FINALIZE_V2_FAILURE_TEXTS.noConclusion,
+            ...baseResponse,
+            processingFailures,
+        };
+    }
+    // Happy path: assemble the argument.
+    const conclusionMiniId = conclusion?.conclusionMiniId ?? null;
+    const roles = buildClaimToRole({
+        canonicalClaims: canon.canonicalClaims,
+        relations,
+        conclusionMiniId,
+    });
+    const claims = canon.canonicalClaims.map((c) => {
+        const refinedType = typeByMiniId.get(c.miniId)?.type ?? c.type;
+        const stripped = stripCanonicalizerOnlyFields(c);
+        return {
+            ...stripped,
+            type: refinedType,
+            role: roles[c.miniId],
+        };
+    });
+    const finalVariables = variables.map((v) => ({
+        ...v,
+    }));
+    const finalPremises = compilation.premises.map((p) => ({
+        miniId: p.premiseMiniId,
+        formula: p.formula,
+        title: buildPremiseTitle(p.formula, p.roleHint),
+    }));
+    const argument = {
+        claims,
+        variables: finalVariables,
+        premises: finalPremises,
+        conclusionPremiseMiniId: compilation.conclusionPremiseMiniId,
+        title: buildArgumentTitle(canon.canonicalClaims, conclusionMiniId),
+    };
+    return {
+        argument: argument,
+        failureText: null,
+        ...baseResponse,
+        processingFailures,
+    };
+}
+//# sourceMappingURL=finalize-response-v2.js.map

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.js.map

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

package/dist/extensions/argument-ingestion/shared/resolve-llm-stage-options.d.ts

@@ -0,0 +1,19 @@
+import type { TIngestionLlmOptions, TLlmStageOptionsOverride } from "./types.js";
+/**
+ * Resolve the final per-stage LLM knobs.
+ *
+ * @param stageId — the stage's id (e.g. `"segmentation"`). Used to
+ *                  pick the right entry from `options.overrides`.
+ * @param internalDefault — the stage's built-in defaults; takes
+ *                  effect for any knob not set by `options.defaults`
+ *                  or `options.overrides[stageId]`.
+ * @param options — the caller's pipeline-level options surface.
+ *                  May be `undefined`, in which case the resolver
+ *                  returns `internalDefault` verbatim.
+ *
+ * The merge is shallow per-field. A missing field at higher
+ * precedence does not blank out a lower-precedence value — it
+ * simply doesn't override.
+ */
+export declare function resolveLlmStageOptions(stageId: string, internalDefault: TLlmStageOptionsOverride, options?: TIngestionLlmOptions): TLlmStageOptionsOverride;
+//# sourceMappingURL=resolve-llm-stage-options.d.ts.map

package/dist/extensions/argument-ingestion/shared/resolve-llm-stage-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-llm-stage-options.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/resolve-llm-stage-options.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAClC,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,wBAAwB,EACzC,OAAO,CAAC,EAAE,oBAAoB,GAC/B,wBAAwB,CAiB1B"}

package/dist/extensions/argument-ingestion/shared/resolve-llm-stage-options.js

@@ -0,0 +1,44 @@
+// Shared resolver for per-stage LLM-knob options.
+//
+// The ingestion pipelines (`createIngestionV1Pipeline`,
+// `createIngestionV2Pipeline`) expose a `TIngestionLlmOptions`
+// surface with pipeline-level `defaults` + per-stage `overrides`.
+// Each LLM stage in turn carries its own *internal default* — the
+// model + effort + token cap the stage author picked for typical
+// inputs. The two surfaces compose via this resolver: stage-level
+// override > pipeline-default > internal stage default.
+/**
+ * Resolve the final per-stage LLM knobs.
+ *
+ * @param stageId — the stage's id (e.g. `"segmentation"`). Used to
+ *                  pick the right entry from `options.overrides`.
+ * @param internalDefault — the stage's built-in defaults; takes
+ *                  effect for any knob not set by `options.defaults`
+ *                  or `options.overrides[stageId]`.
+ * @param options — the caller's pipeline-level options surface.
+ *                  May be `undefined`, in which case the resolver
+ *                  returns `internalDefault` verbatim.
+ *
+ * The merge is shallow per-field. A missing field at higher
+ * precedence does not blank out a lower-precedence value — it
+ * simply doesn't override.
+ */
+export function resolveLlmStageOptions(stageId, internalDefault, options) {
+    const pipelineDefault = options?.defaults ?? {};
+    const perStage = options?.overrides?.[stageId] ?? {};
+    const resolved = { ...internalDefault };
+    if (pipelineDefault.maxOutputTokens !== undefined) {
+        resolved.maxOutputTokens = pipelineDefault.maxOutputTokens;
+    }
+    if (pipelineDefault.reasoningEffort !== undefined) {
+        resolved.reasoningEffort = pipelineDefault.reasoningEffort;
+    }
+    if (perStage.maxOutputTokens !== undefined) {
+        resolved.maxOutputTokens = perStage.maxOutputTokens;
+    }
+    if (perStage.reasoningEffort !== undefined) {
+        resolved.reasoningEffort = perStage.reasoningEffort;
+    }
+    return resolved;
+}
+//# sourceMappingURL=resolve-llm-stage-options.js.map

package/dist/extensions/argument-ingestion/shared/resolve-llm-stage-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-llm-stage-options.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/resolve-llm-stage-options.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,EAAE;AACF,wDAAwD;AACxD,+DAA+D;AAC/D,kEAAkE;AAClE,kEAAkE;AAClE,iEAAiE;AACjE,kEAAkE;AAClE,wDAAwD;AAIxD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,sBAAsB,CAClC,OAAe,EACf,eAAyC,EACzC,OAA8B;IAE9B,MAAM,eAAe,GAAG,OAAO,EAAE,QAAQ,IAAI,EAAE,CAAA;IAC/C,MAAM,QAAQ,GAAG,OAAO,EAAE,SAAS,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAA;IACpD,MAAM,QAAQ,GAA6B,EAAE,GAAG,eAAe,EAAE,CAAA;IACjE,IAAI,eAAe,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;QAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,eAAe,CAAA;IAC9D,CAAC;IACD,IAAI,eAAe,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;QAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,eAAe,CAAA;IAC9D,CAAC;IACD,IAAI,QAAQ,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;QACzC,QAAQ,CAAC,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAA;IACvD,CAAC;IACD,IAAI,QAAQ,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;QACzC,QAAQ,CAAC,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAA;IACvD,CAAC;IACD,OAAO,QAAQ,CAAA;AACnB,CAAC"}

package/dist/extensions/argument-ingestion/shared/types.d.ts

@@ -1,4 +1,5 @@
 import type { TSchema } from "typebox";
+import type { TReasoningEffort } from "../../../lib/llm/types.js";
 /**
  * Bundle of TypeBox schemas a caller hands to an ingestion pipeline
  * factory. Only `responseSchema` is consumed by v1; the per-entity
@@ -31,4 +32,42 @@ export type TIngestionExtension = {
 export type TIngestionInput = {
     text: string;
 };
+/**
+ * Per-stage LLM knob overrides for an ingestion pipeline factory.
+ *
+ * Every field is optional and merges over the stage's internal
+ * default (which is in turn merged over the pipeline-level default).
+ * The merge order is: stage-override > pipeline-default > internal
+ * stage default. A missing field at every layer means the stage
+ * keeps its built-in behavior.
+ *
+ * Currently exposes the two knobs that have proven load-bearing for
+ * the v2 pipeline: `maxOutputTokens` (the output-budget cap; not
+ * setting one means the model's default applies, which is what
+ * caused the v1.3.0 segmentation truncation against the Singer
+ * fixture) and `reasoningEffort` (effort budget for reasoning
+ * models). The struct is forward-compatible — new knobs (e.g.
+ * `model` overrides) can land additively without breaking callers.
+ */
+export type TLlmStageOptionsOverride = {
+    maxOutputTokens?: number;
+    reasoningEffort?: TReasoningEffort;
+};
+/**
+ * Pipeline-level LLM-options surface threaded through every LLM
+ * stage by the ingestion-pipeline factories.
+ *
+ * `defaults` applies to all LLM stages in the pipeline that don't
+ * have a per-stage entry under `overrides`. A stage's internal
+ * default still takes effect for any knob neither `defaults` nor
+ * `overrides` sets.
+ *
+ * `overrides` is keyed by stage id (`STAGE_IDS.segmentation`,
+ * `STAGE_IDS.claimMentionExtraction`, etc.). v1 has only one LLM
+ * stage and uses the id `"parse-argument"`.
+ */
+export type TIngestionLlmOptions = {
+    defaults?: TLlmStageOptionsOverride;
+    overrides?: Record<string, TLlmStageOptionsOverride>;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/extensions/argument-ingestion/shared/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/types.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,8EAA8E;IAC9E,cAAc,EAAE,OAAO,CAAA;IACvB,uGAAuG;IACvG,WAAW,EAAE,OAAO,CAAA;IACpB,gDAAgD;IAChD,cAAc,EAAE,OAAO,CAAA;IACvB,+CAA+C;IAC/C,aAAa,EAAE,OAAO,CAAA;IACtB,yDAAyD;IACzD,cAAc,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;CACf,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/types.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,8EAA8E;IAC9E,cAAc,EAAE,OAAO,CAAA;IACvB,uGAAuG;IACvG,WAAW,EAAE,OAAO,CAAA;IACpB,gDAAgD;IAChD,cAAc,EAAE,OAAO,CAAA;IACvB,+CAA+C;IAC/C,aAAa,EAAE,OAAO,CAAA;IACtB,yDAAyD;IACzD,cAAc,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACnC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,CAAC,EAAE,gBAAgB,CAAA;CACrC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAC/B,QAAQ,CAAC,EAAE,wBAAwB,CAAA;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;CACvD,CAAA"}

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.d.ts

@@ -0,0 +1,12 @@
+import { type TAxiomIndicatorDetectionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const AXIOM_INDICATOR_DETECTION_MODEL = "gpt-5.4-mini";
+export declare const AXIOM_INDICATOR_DETECTION_SYSTEM_PROMPT = "You scan the segments of an argument for axiom indicators \u2014 explicit signals that the author is invoking a self-evident truth as bottom-level support.\n\nRecognized indicator patterns include (non-exhaustive):\n- \"by definition\"\n- \"tautologically\", \"necessarily true\"\n- \"by convention\"\n- \"is true a priori\"\n- \"as a matter of (logic | mathematics | definition)\"\n- \"trivially\"\n\nReturn an object with a single key `axioms` whose value is the array of detected indicators. For each detected indicator emit:\n- a fresh \"axiomId\" (ax1, ax2, ...)\n- the list of \"segmentIds\" the indicator occurs in (usually one; sometimes two when the indicator straddles a clause)\n- the \"indicator\" \u2014 the verbatim trigger phrase\n- the character \"spans\" \u2014 one span object (\"start\" inclusive, \"end\" exclusive) per occurrence, relative to the SEGMENT'S TEXT\n\nHedging phrases (\"clearly\", \"obviously\", \"of course\") are NOT axiom indicators on their own \u2014 they are stylistic emphasis. Return `{ \"axioms\": [] }` when no indicators are present.";
+/** Internal default knobs for the axiom-indicator-detection stage. */
+export declare const AXIOM_INDICATOR_DETECTION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/** Build the axiom-indicator-detection stage with optional caller overrides. */
+export declare function createAxiomIndicatorDetectionStage(options?: TLlmStageOptionsOverride): TStage<TAxiomIndicatorDetectionOutput>;
+/** Backward-compatible default-options stage. */
+export declare const axiomIndicatorDetectionStage: TStage<TAxiomIndicatorDetectionOutput>;
+//# sourceMappingURL=axiom-indicator-detection.d.ts.map

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axiom-indicator-detection.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/axiom-indicator-detection.ts"],"names":[],"mappings":"AAKA,OAAO,EAGH,KAAK,8BAA8B,EAEtC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAElE,eAAO,MAAM,+BAA+B,iBAAiB,CAAA;AAE7D,eAAO,MAAM,uCAAuC,4jCAgBmI,CAAA;AAavL,sEAAsE;AACtE,eAAO,MAAM,wCAAwC,EAAE,wBACjD,CAAA;AAEN,gFAAgF;AAChF,wBAAgB,kCAAkC,CAC9C,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,8BAA8B,CAAC,CAUxC;AAED,iDAAiD;AACjD,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,8BAA8B,CACxC,CAAA"}

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.js

@@ -0,0 +1,51 @@
+// `axiom-indicator-detection` — detects places where the author
+// invokes a self-evident truth (axiom) as the bottom-level support of
+// some claim. Phrases like "by definition", "by convention",
+// "as a matter of logic", "is necessarily true" mark the spots.
+import { STAGE_IDS, AxiomIndicatorDetectionOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const AXIOM_INDICATOR_DETECTION_MODEL = "gpt-5.4-mini";
+export const AXIOM_INDICATOR_DETECTION_SYSTEM_PROMPT = `You scan the segments of an argument for axiom indicators — explicit signals that the author is invoking a self-evident truth as bottom-level support.
+
+Recognized indicator patterns include (non-exhaustive):
+- "by definition"
+- "tautologically", "necessarily true"
+- "by convention"
+- "is true a priori"
+- "as a matter of (logic | mathematics | definition)"
+- "trivially"
+
+Return an object with a single key \`axioms\` whose value is the array of detected indicators. For each detected indicator emit:
+- a fresh "axiomId" (ax1, ax2, ...)
+- the list of "segmentIds" the indicator occurs in (usually one; sometimes two when the indicator straddles a clause)
+- the "indicator" — the verbatim trigger phrase
+- the character "spans" — one span object ("start" inclusive, "end" exclusive) per occurrence, relative to the SEGMENT'S TEXT
+
+Hedging phrases ("clearly", "obviously", "of course") are NOT axiom indicators on their own — they are stylistic emphasis. Return \`{ "axioms": [] }\` when no indicators are present.`;
+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.axiomIndicatorDetection} -->\n${AXIOM_INDICATOR_DETECTION_SYSTEM_PROMPT}`;
+    const user = `Segments:\n\n${renderedSegments}\n\nDetect every axiom indicator.`;
+    return { system: markedSystem, user };
+}
+/** Internal default knobs for the axiom-indicator-detection stage. */
+export const AXIOM_INDICATOR_DETECTION_STAGE_DEFAULTS = {};
+/** Build the axiom-indicator-detection stage with optional caller overrides. */
+export function createAxiomIndicatorDetectionStage(options) {
+    return llmStage({
+        id: STAGE_IDS.axiomIndicatorDetection,
+        dependsOn: [STAGE_IDS.segmentation],
+        outputSchema: AxiomIndicatorDetectionOutputSchema,
+        model: AXIOM_INDICATOR_DETECTION_MODEL,
+        maxOutputTokens: options?.maxOutputTokens,
+        reasoningEffort: options?.reasoningEffort,
+        buildPrompt,
+    });
+}
+/** Backward-compatible default-options stage. */
+export const axiomIndicatorDetectionStage = createAxiomIndicatorDetectionStage();
+//# sourceMappingURL=axiom-indicator-detection.js.map

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axiom-indicator-detection.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/axiom-indicator-detection.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,sEAAsE;AACtE,6DAA6D;AAC7D,gEAAgE;AAEhE,OAAO,EACH,SAAS,EACT,mCAAmC,GAGtC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAA;AAIlE,MAAM,CAAC,MAAM,+BAA+B,GAAG,cAAc,CAAA;AAE7D,MAAM,CAAC,MAAM,uCAAuC,GAAG;;;;;;;;;;;;;;;;uLAgBgI,CAAA;AAEvL,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,uBAAuB,SAAS,uCAAuC,EAAE,CAAA;IAC1H,MAAM,IAAI,GAAG,gBAAgB,gBAAgB,mCAAmC,CAAA;IAChF,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAA;AACzC,CAAC;AAED,sEAAsE;AACtE,MAAM,CAAC,MAAM,wCAAwC,GACjD,EAAE,CAAA;AAEN,gFAAgF;AAChF,MAAM,UAAU,kCAAkC,CAC9C,OAAkC;IAElC,OAAO,QAAQ,CAAiC;QAC5C,EAAE,EAAE,SAAS,CAAC,uBAAuB;QACrC,SAAS,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC;QACnC,YAAY,EAAE,mCAAmC;QACjD,KAAK,EAAE,+BAA+B;QACtC,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,WAAW;KACd,CAAC,CAAA;AACN,CAAC;AAED,iDAAiD;AACjD,MAAM,CAAC,MAAM,4BAA4B,GACrC,kCAAkC,EAAE,CAAA"}

package/dist/extensions/argument-ingestion/stages/citation-source-detection.d.ts

@@ -0,0 +1,12 @@
+import { type TCitationSourceDetectionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const CITATION_SOURCE_DETECTION_MODEL = "gpt-5.4-mini";
+export declare const CITATION_SOURCE_DETECTION_SYSTEM_PROMPT = "You scan the segments of an argument for explicit references to external sources of evidence.\n\nA source reference is any of:\n- a Markdown link: `[label](url)`\n- a named source: \"according to X\", \"as reported in Y\", \"the X report\"\n- a bracketed citation marker: `[1]`, `[Smith 2024]`\n- a fully-qualified URL\n\nReturn an object with a single key `sources` whose value is the array of detected source references. For each detected source emit:\n- a fresh \"sourceId\" (src1, src2, ...)\n- the list of \"segmentIds\" the source occurs in (almost always one; multi-segment when one citation spans a clause boundary)\n- a short \"sourceString\" \u2014 the human-readable label (e.g. \"NASA climate report\", \"Smith 2024\")\n- the \"url\" field \u2014 the URL when one is present, otherwise null\n- the character \"spans\" \u2014 one span object (\"start\" inclusive, \"end\" exclusive) per occurrence, relative to the SEGMENT'S TEXT\n\nDo not detect mere mentions of people, organizations, or studies that are not invoked as supporting evidence. Quote attribution alone (\"Bob said X\") is not a citation unless Bob's saying is being used to support a claim. Return `{ \"sources\": [] }` when no sources are present.";
+/** Internal default knobs for the citation-source-detection stage. */
+export declare const CITATION_SOURCE_DETECTION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/** Build the citation-source-detection stage with optional caller overrides. */
+export declare function createCitationSourceDetectionStage(options?: TLlmStageOptionsOverride): TStage<TCitationSourceDetectionOutput>;
+/** Backward-compatible default-options stage. */
+export declare const citationSourceDetectionStage: TStage<TCitationSourceDetectionOutput>;
+//# sourceMappingURL=citation-source-detection.d.ts.map

package/dist/extensions/argument-ingestion/stages/citation-source-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-source-detection.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/citation-source-detection.ts"],"names":[],"mappings":"AAMA,OAAO,EAGH,KAAK,8BAA8B,EAEtC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAElE,eAAO,MAAM,+BAA+B,iBAAiB,CAAA;AAE7D,eAAO,MAAM,uCAAuC,6sCAemO,CAAA;AAavR,sEAAsE;AACtE,eAAO,MAAM,wCAAwC,EAAE,wBACjD,CAAA;AAEN,gFAAgF;AAChF,wBAAgB,kCAAkC,CAC9C,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,8BAA8B,CAAC,CAUxC;AAED,iDAAiD;AACjD,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,8BAA8B,CACxC,CAAA"}

package/dist/extensions/argument-ingestion/stages/citation-source-detection.js

@@ -0,0 +1,51 @@
+// `citation-source-detection` — detects explicit source references in
+// the segmented input. Markdown links, "according to X", named
+// reports/papers, bracketed citation markers, etc. The downstream
+// `claim-canonicalization` stage uses this to route the right claims
+// to citation-typed records with their `url` / `title` populated.
+import { STAGE_IDS, CitationSourceDetectionOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const CITATION_SOURCE_DETECTION_MODEL = "gpt-5.4-mini";
+export const CITATION_SOURCE_DETECTION_SYSTEM_PROMPT = `You scan the segments of an argument for explicit references to external sources of evidence.
+
+A source reference is any of:
+- a Markdown link: \`[label](url)\`
+- a named source: "according to X", "as reported in Y", "the X report"
+- a bracketed citation marker: \`[1]\`, \`[Smith 2024]\`
+- a fully-qualified URL
+
+Return an object with a single key \`sources\` whose value is the array of detected source references. For each detected source emit:
+- a fresh "sourceId" (src1, src2, ...)
+- the list of "segmentIds" the source occurs in (almost always one; multi-segment when one citation spans a clause boundary)
+- a short "sourceString" — the human-readable label (e.g. "NASA climate report", "Smith 2024")
+- the "url" field — the URL when one is present, otherwise null
+- the character "spans" — one span object ("start" inclusive, "end" exclusive) per occurrence, relative to the SEGMENT'S TEXT
+
+Do not detect mere mentions of people, organizations, or studies that are not invoked as supporting evidence. Quote attribution alone ("Bob said X") is not a citation unless Bob's saying is being used to support a claim. Return \`{ "sources": [] }\` when no sources are present.`;
+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.citationSourceDetection} -->\n${CITATION_SOURCE_DETECTION_SYSTEM_PROMPT}`;
+    const user = `Segments:\n\n${renderedSegments}\n\nDetect every citation/source reference.`;
+    return { system: markedSystem, user };
+}
+/** Internal default knobs for the citation-source-detection stage. */
+export const CITATION_SOURCE_DETECTION_STAGE_DEFAULTS = {};
+/** Build the citation-source-detection stage with optional caller overrides. */
+export function createCitationSourceDetectionStage(options) {
+    return llmStage({
+        id: STAGE_IDS.citationSourceDetection,
+        dependsOn: [STAGE_IDS.segmentation],
+        outputSchema: CitationSourceDetectionOutputSchema,
+        model: CITATION_SOURCE_DETECTION_MODEL,
+        maxOutputTokens: options?.maxOutputTokens,
+        reasoningEffort: options?.reasoningEffort,
+        buildPrompt,
+    });
+}
+/** Backward-compatible default-options stage. */
+export const citationSourceDetectionStage = createCitationSourceDetectionStage();
+//# sourceMappingURL=citation-source-detection.js.map

package/dist/extensions/argument-ingestion/stages/citation-source-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-source-detection.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/citation-source-detection.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,+DAA+D;AAC/D,kEAAkE;AAClE,qEAAqE;AACrE,kEAAkE;AAElE,OAAO,EACH,SAAS,EACT,mCAAmC,GAGtC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAA;AAIlE,MAAM,CAAC,MAAM,+BAA+B,GAAG,cAAc,CAAA;AAE7D,MAAM,CAAC,MAAM,uCAAuC,GAAG;;;;;;;;;;;;;;;uRAegO,CAAA;AAEvR,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,uBAAuB,SAAS,uCAAuC,EAAE,CAAA;IAC1H,MAAM,IAAI,GAAG,gBAAgB,gBAAgB,6CAA6C,CAAA;IAC1F,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAA;AACzC,CAAC;AAED,sEAAsE;AACtE,MAAM,CAAC,MAAM,wCAAwC,GACjD,EAAE,CAAA;AAEN,gFAAgF;AAChF,MAAM,UAAU,kCAAkC,CAC9C,OAAkC;IAElC,OAAO,QAAQ,CAAiC;QAC5C,EAAE,EAAE,SAAS,CAAC,uBAAuB;QACrC,SAAS,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC;QACnC,YAAY,EAAE,mCAAmC;QACjD,KAAK,EAAE,+BAA+B;QACtC,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,WAAW;KACd,CAAC,CAAA;AACN,CAAC;AAED,iDAAiD;AACjD,MAAM,CAAC,MAAM,4BAA4B,GACrC,kCAAkC,EAAE,CAAA"}

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

@@ -0,0 +1,21 @@
+import { type TClaimCanonicalizationOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TIngestionExtension, TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const CLAIM_CANONICALIZATION_MODEL = "gpt-5.5";
+export declare const CLAIM_CANONICALIZATION_REASONING: "minimal" | "low" | "medium" | "high";
+export declare const CLAIM_CANONICALIZATION_SYSTEM_PROMPT = "You merge raw claim mentions into a single canonical set of claims for an argument-ingestion pipeline.\n\nYou are given:\n- the raw input text (for full context)\n- the segmented breakdown of the text\n- the list of every claim mention extracted from those segments\n- optionally, the detected citation sources + axiom indicators\n\nYour output has two parts:\n\n1. `canonicalClaims` \u2014 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:\n   - `miniId` \u2014 assign in canonicalization order: c1, c2, c3, ...\n   - `mentionIds` \u2014 list of the mention ids that resolved to this claim\n   - `type` \u2014 one of \"normal\", \"citation\", or \"axiomatic\" (see below)\n   - `suggestedSymbol` \u2014 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\".\n   - the extension fields described in your output schema (title, body, url, axiom \u2014 whichever apply to the claim's `type`)\n\n2. `mentionToClaim` \u2014 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.)\n\n## Claim types\n\n- `\"normal\"` \u2014 a primary proposition the argument argues for or from.\n- `\"citation\"` \u2014 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).\n- `\"axiomatic\"` \u2014 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.\n\nWhen 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.\n\n## Style\n\n- Claim titles + bodies are written in third-person, present-tense, active voice.\n- Titles are short (\u2264 50 characters); bodies fill in the detail.\n- For citation claims, the title summarizes what the source asserts (e.g. \"NASA reports temperature rise\"); the URL goes in `url`.\n- For axiomatic claims, the `axiom` field captures the self-evident proposition (e.g. \"A bachelor is an unmarried man by definition.\").\n\nOutput ONLY the schema-shaped object. No prose.";
+/** Internal default knobs for the claim-canonicalization stage. */
+export declare const CLAIM_CANONICALIZATION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/**
+ * 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 declare function createClaimCanonicalizationStage(extension: TIngestionExtension, options?: TLlmStageOptionsOverride): TStage<TClaimCanonicalizationOutput>;
+//# sourceMappingURL=claim-canonicalization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claim-canonicalization.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-canonicalization.ts"],"names":[],"mappings":"AAiBA,OAAO,EAMH,KAAK,4BAA4B,EACpC,MAAM,cAAc,CAAA;AAGrB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EACR,mBAAmB,EAEnB,wBAAwB,EAC3B,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,4BAA4B,YAAY,CAAA;AACrD,eAAO,MAAM,gCAAgC,EACvC,SAAS,GACT,KAAK,GACL,QAAQ,GACR,MAAiB,CAAA;AAEvB,eAAO,MAAM,oCAAoC,05FAkCD,CAAA;AA8GhD,mEAAmE;AACnE,eAAO,MAAM,qCAAqC,EAAE,wBAEnD,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC5C,SAAS,EAAE,mBAAmB,EAC9B,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,4BAA4B,CAAC,CAetC"}