@proposit/proposit-core 1.2.0 → 1.3.1

package/dist/extensions/argument-ingestion/stages/schemas.d.ts

@@ -0,0 +1,161 @@
+import Type, { type Static } from "typebox";
+export declare const SpanSchema: Type.TObject<{
+    start: Type.TNumber;
+    end: Type.TNumber;
+}>;
+export type TSpan = Static<typeof SpanSchema>;
+export declare const SegmentationOutputSchema: Type.TObject<{
+    segments: Type.TArray<Type.TObject<{
+        segmentId: Type.TString;
+        text: Type.TString;
+        span: Type.TObject<{
+            start: Type.TNumber;
+            end: Type.TNumber;
+        }>;
+    }>>;
+}>;
+export type TSegmentationOutput = Static<typeof SegmentationOutputSchema>;
+export type TSegment = TSegmentationOutput["segments"][number];
+export declare const ClaimMentionExtractionOutputSchema: Type.TObject<{
+    mentions: Type.TArray<Type.TObject<{
+        mentionId: Type.TString;
+        segmentId: Type.TString;
+        text: Type.TString;
+        span: Type.TObject<{
+            start: Type.TNumber;
+            end: Type.TNumber;
+        }>;
+    }>>;
+}>;
+export type TClaimMentionExtractionOutput = Static<typeof ClaimMentionExtractionOutputSchema>;
+export type TClaimMention = TClaimMentionExtractionOutput["mentions"][number];
+export declare const CitationSourceDetectionOutputSchema: Type.TObject<{
+    sources: Type.TArray<Type.TObject<{
+        sourceId: Type.TString;
+        segmentIds: Type.TArray<Type.TString>;
+        sourceString: Type.TString;
+        url: Type.TUnion<[Type.TString, Type.TNull]>;
+        spans: Type.TArray<Type.TObject<{
+            start: Type.TNumber;
+            end: Type.TNumber;
+        }>>;
+    }>>;
+}>;
+export type TCitationSourceDetectionOutput = Static<typeof CitationSourceDetectionOutputSchema>;
+export type TCitationSource = TCitationSourceDetectionOutput["sources"][number];
+export declare const AxiomIndicatorDetectionOutputSchema: Type.TObject<{
+    axioms: Type.TArray<Type.TObject<{
+        axiomId: Type.TString;
+        segmentIds: Type.TArray<Type.TString>;
+        indicator: Type.TString;
+        spans: Type.TArray<Type.TObject<{
+            start: Type.TNumber;
+            end: Type.TNumber;
+        }>>;
+    }>>;
+}>;
+export type TAxiomIndicatorDetectionOutput = Static<typeof AxiomIndicatorDetectionOutputSchema>;
+export type TAxiomIndicator = TAxiomIndicatorDetectionOutput["axioms"][number];
+export declare const BaseCanonicalClaimSchema: Type.TObject<{
+    miniId: Type.TString;
+    mentionIds: Type.TArray<Type.TString>;
+    suggestedSymbol: Type.TString;
+    type: Type.TUnion<[Type.TLiteral<"normal">, Type.TLiteral<"citation">, Type.TLiteral<"axiomatic">]>;
+}>;
+export type TBaseCanonicalClaim = Static<typeof BaseCanonicalClaimSchema>;
+export declare const MentionToClaimEntrySchema: Type.TObject<{
+    mentionId: Type.TString;
+    claimMiniId: Type.TString;
+}>;
+export type TMentionToClaimEntry = Static<typeof MentionToClaimEntrySchema>;
+export declare const ClaimCanonicalizationOutputSchema: Type.TObject<{
+    canonicalClaims: Type.TArray<Type.TObject<{
+        miniId: Type.TString;
+        mentionIds: Type.TArray<Type.TString>;
+        suggestedSymbol: Type.TString;
+        type: Type.TUnion<[Type.TLiteral<"normal">, Type.TLiteral<"citation">, Type.TLiteral<"axiomatic">]>;
+    }>>;
+    mentionToClaim: Type.TArray<Type.TObject<{
+        mentionId: Type.TString;
+        claimMiniId: Type.TString;
+    }>>;
+}>;
+export type TClaimCanonicalizationOutput = Static<typeof ClaimCanonicalizationOutputSchema>;
+/** Per-claim record including the extension-injected fields. */
+export type TCanonicalClaim = TBaseCanonicalClaim & Record<string, unknown>;
+export declare const ClaimTypeClassificationEntrySchema: Type.TObject<{
+    miniId: Type.TString;
+    type: Type.TUnion<[Type.TLiteral<"normal">, Type.TLiteral<"citation">, Type.TLiteral<"axiomatic">]>;
+    sourceString: Type.TUnion<[Type.TString, Type.TNull]>;
+}>;
+export type TClaimTypeClassificationEntry = Static<typeof ClaimTypeClassificationEntrySchema>;
+export declare const ClaimTypeClassificationOutputSchema: Type.TObject<{
+    classifications: Type.TArray<Type.TObject<{
+        miniId: Type.TString;
+        type: Type.TUnion<[Type.TLiteral<"normal">, Type.TLiteral<"citation">, Type.TLiteral<"axiomatic">]>;
+        sourceString: Type.TUnion<[Type.TString, Type.TNull]>;
+    }>>;
+}>;
+export type TClaimTypeClassificationOutput = Static<typeof ClaimTypeClassificationOutputSchema>;
+export declare const VariableAssignmentOutputSchema: Type.TArray<Type.TObject<{
+    miniId: Type.TString;
+    symbol: Type.TString;
+    claimMiniId: Type.TString;
+}>>;
+export type TVariableAssignmentOutput = Static<typeof VariableAssignmentOutputSchema>;
+export type TAssignedVariable = TVariableAssignmentOutput[number];
+export declare const RelationKindSchema: Type.TUnion<[Type.TLiteral<"support">, Type.TLiteral<"joint-support">, Type.TLiteral<"derivation-support">]>;
+export type TRelationKind = Static<typeof RelationKindSchema>;
+export declare const RelationExtractionOutputSchema: Type.TObject<{
+    relations: Type.TArray<Type.TObject<{
+        relationId: Type.TString;
+        type: Type.TUnion<[Type.TLiteral<"support">, Type.TLiteral<"joint-support">, Type.TLiteral<"derivation-support">]>;
+        sources: Type.TArray<Type.TString>;
+        target: Type.TString;
+        evidence: Type.TObject<{
+            segmentIds: Type.TArray<Type.TString>;
+            quote: Type.TString;
+        }>;
+    }>>;
+}>;
+export type TRelationExtractionOutput = Static<typeof RelationExtractionOutputSchema>;
+export type TRelation = TRelationExtractionOutput["relations"][number];
+export declare const ConclusionSelectionOutputSchema: Type.TObject<{
+    conclusionMiniId: Type.TUnion<[Type.TString, Type.TNull]>;
+    rationale: Type.TString;
+}>;
+export type TConclusionSelectionOutput = Static<typeof ConclusionSelectionOutputSchema>;
+export declare const FormulaPremiseRoleHintSchema: Type.TUnion<[Type.TLiteral<"support">, Type.TLiteral<"joint-support">, Type.TLiteral<"derivation">, Type.TLiteral<"conclusion">]>;
+export type TFormulaPremiseRoleHint = Static<typeof FormulaPremiseRoleHintSchema>;
+export declare const FormulaCompilationOutputSchema: Type.TObject<{
+    premises: Type.TArray<Type.TObject<{
+        premiseMiniId: Type.TString;
+        formula: Type.TString;
+        roleHint: Type.TUnion<[Type.TLiteral<"support">, Type.TLiteral<"joint-support">, Type.TLiteral<"derivation">, Type.TLiteral<"conclusion">]>;
+        sourceRelationId: Type.TUnion<[Type.TString, Type.TNull]>;
+    }>>;
+    conclusionPremiseMiniId: Type.TUnion<[Type.TString, Type.TNull]>;
+}>;
+export type TFormulaCompilationOutput = Static<typeof FormulaCompilationOutputSchema>;
+export type TCompiledPremise = TFormulaCompilationOutput["premises"][number];
+export declare const ValidationStageOutputSchema: Type.TArray<Type.TObject<{
+    code: Type.TString;
+    message: Type.TString;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+}>>;
+export type TValidationStageOutput = Static<typeof ValidationStageOutputSchema>;
+export declare const STAGE_IDS: {
+    readonly segmentation: "segmentation";
+    readonly claimMentionExtraction: "claim-mention-extraction";
+    readonly citationSourceDetection: "citation-source-detection";
+    readonly axiomIndicatorDetection: "axiom-indicator-detection";
+    readonly claimCanonicalization: "claim-canonicalization";
+    readonly claimTypeClassification: "claim-type-classification";
+    readonly claimReferenceValidation: "claim-reference-validation";
+    readonly variableAssignment: "variable-assignment";
+    readonly relationExtraction: "relation-extraction";
+    readonly conclusionSelection: "conclusion-selection";
+    readonly formulaCompilation: "formula-compilation";
+    readonly formulaValidation: "formula-validation";
+};
+//# sourceMappingURL=schemas.d.ts.map

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

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

package/dist/extensions/argument-ingestion/stages/schemas.js

@@ -0,0 +1,218 @@
+// Shared TypeBox schemas for the v2-multi-stage ingestion stages.
+//
+// Each stage's output schema lives here (rather than next to the stage
+// module) so the schemas can be referenced from `finalize-response-v2.ts`,
+// the v2 unit tests, and any future consumer that wants to validate a
+// recorded stage output without importing the stage's `run` function.
+import Type, {} from "typebox";
+// **Span shape (`{ start, end }`).** Spans use a named-key object
+// rather than a positional tuple. The original tuple shape
+// (`Type.Tuple([Type.Number(), Type.Number()])`) caused the OpenAI
+// structured-output converter to throw `UnsupportedSchemaError:
+// "Tuple"` at request-build time — `segmentation` then surfaced a
+// `LLM_NON_RETRYABLE_ERROR` on first attempt, every downstream stage
+// cascade-skipped on the required dep, and the recording mode
+// completed in ~9ms with `output: null` and zero LLM calls. The
+// named-key form is also more LLM-friendly (each value carries its
+// semantic role rather than relying on positional convention) and
+// stays within the converter's supported subset (Object, Array,
+// String, Number, Integer, Boolean, Literal, Union, Optional, Record,
+// Null). See `test/extensions/argument-ingestion/stages/schema-converter-regression.test.ts`
+// for the regression coverage that pins every v2 LLM stage's
+// `outputSchema` through `typeboxToOpenAiSchema`.
+export const SpanSchema = Type.Object({
+    start: Type.Number({
+        description: "Inclusive character offset where the span begins (relative to the parent text).",
+    }),
+    end: Type.Number({
+        description: "Exclusive character offset where the span ends (relative to the parent text).",
+    }),
+});
+// -- Stage 1: segmentation --
+// **Why every LLM-stage output is wrapped in a single-key object.**
+// The OpenAI Responses-API strict-mode structured output requires the
+// root schema to be `{ "type": "object" }`. Bare top-level arrays are
+// rejected with a 400 `invalid_json_schema` ("schema must be a JSON
+// Schema of 'type: object', got 'type: array'"). To keep every LLM
+// stage's outputSchema acceptable to the converter + the API, we wrap
+// the natural array shape in a single-key envelope (`segments`,
+// `mentions`, `sources`, `axioms`, `relations`). Downstream readers
+// access the array via `output.segments` (etc.); the envelope is
+// shallow and does not change the per-item shape. The same regression
+// test that pins `typeboxToOpenAiSchema` survival now also asserts
+// every LLM-stage's converted root is `type: object`.
+export const SegmentationOutputSchema = Type.Object({
+    segments: Type.Array(Type.Object({
+        segmentId: Type.String(),
+        text: Type.String(),
+        span: SpanSchema,
+    })),
+});
+// -- Stage 2: claim-mention-extraction --
+export const ClaimMentionExtractionOutputSchema = Type.Object({
+    mentions: Type.Array(Type.Object({
+        mentionId: Type.String(),
+        segmentId: Type.String(),
+        text: Type.String(),
+        span: SpanSchema,
+    })),
+});
+// -- Stage 3: citation-source-detection --
+export const CitationSourceDetectionOutputSchema = Type.Object({
+    sources: Type.Array(Type.Object({
+        sourceId: Type.String(),
+        segmentIds: Type.Array(Type.String()),
+        sourceString: Type.String(),
+        url: Type.Union([Type.String(), Type.Null()]),
+        spans: Type.Array(SpanSchema),
+    })),
+});
+// -- Stage 4: axiom-indicator-detection --
+export const AxiomIndicatorDetectionOutputSchema = Type.Object({
+    axioms: Type.Array(Type.Object({
+        axiomId: Type.String(),
+        segmentIds: Type.Array(Type.String()),
+        indicator: Type.String(),
+        spans: Type.Array(SpanSchema),
+    })),
+});
+// -- Stage 5: claim-canonicalization --
+// The per-claim record in `canonicalClaims` carries:
+//   - `miniId` — c1, c2, ... allocated by the canonicalizer
+//   - `mentionIds` — list of mention ids that resolved to this claim
+//   - `suggestedSymbol` — snake_case-ish symbol proposal (validated
+//     downstream by `variable-assignment`)
+//   - the extension fields from `extension.claimSchema` (e.g. for
+//     `basics`: a discriminated union over `type`)
+//
+// We can't bake the extension shape into a static TypeBox object —
+// the canonicalizer's schema is built per-extension by
+// `buildCanonicalClaimsSchema(extension)` below. The exported
+// `ClaimCanonicalizationOutputSchema` is the *base* shape (without the
+// extension fields) and is used by tests that don't need the per-
+// extension constraints.
+export const BaseCanonicalClaimSchema = Type.Object({
+    miniId: Type.String(),
+    mentionIds: Type.Array(Type.String()),
+    suggestedSymbol: Type.String(),
+    // Per spec §7.2 row 5, the canonicalizer also drafts the
+    // per-claim type. We capture it as `type` and let
+    // `claim-type-classification` refine/confirm. Extension fields
+    // (title/body/url/axiom) come from the merged extension schema.
+    type: Type.Union([
+        Type.Literal("normal"),
+        Type.Literal("citation"),
+        Type.Literal("axiomatic"),
+    ]),
+});
+// **Why `mentionToClaim` is an array, not a map.** OpenAI Responses-API
+// strict-mode JSON Schema does not support `additionalProperties` or
+// `patternProperties` — fixed-shape objects only. `Type.Record(K, V)`
+// generates JSON Schema like `{ type: "object", additionalProperties:
+// <V> }`, which strict mode rejects with 400 `invalid_json_schema`
+// ("'required' is required to be supplied and to be an array
+// including every key in properties. Extra required key
+// 'mentionToClaim' supplied."). Surfacing the map as an explicit
+// `[{ mentionId, claimMiniId }, ...]` list bypasses the constraint
+// entirely. Downstream readers convert to a `Map<string, string>`
+// when they need O(1) lookups.
+export const MentionToClaimEntrySchema = Type.Object({
+    mentionId: Type.String(),
+    claimMiniId: Type.String(),
+});
+export const ClaimCanonicalizationOutputSchema = Type.Object({
+    canonicalClaims: Type.Array(BaseCanonicalClaimSchema),
+    mentionToClaim: Type.Array(MentionToClaimEntrySchema),
+});
+// -- Stage 6: claim-type-classification --
+// Same OpenAI strict-mode constraint as above. The natural shape
+// `Record<miniId, { type, sourceString }>` becomes an explicit list
+// of `{ miniId, type, sourceString }` entries, wrapped in a
+// single-key `classifications` envelope (the lambda-fold 3 root-
+// must-be-object invariant). Downstream readers build a Map on
+// receipt when they need keyed lookups.
+export const ClaimTypeClassificationEntrySchema = Type.Object({
+    miniId: Type.String(),
+    type: Type.Union([
+        Type.Literal("normal"),
+        Type.Literal("citation"),
+        Type.Literal("axiomatic"),
+    ]),
+    sourceString: Type.Union([Type.String(), Type.Null()]),
+});
+export const ClaimTypeClassificationOutputSchema = Type.Object({
+    classifications: Type.Array(ClaimTypeClassificationEntrySchema),
+});
+// -- Stage 8: variable-assignment --
+export const VariableAssignmentOutputSchema = Type.Array(Type.Object({
+    miniId: Type.String(),
+    symbol: Type.String(),
+    claimMiniId: Type.String(),
+}));
+// -- Stage 9: relation-extraction --
+export const RelationKindSchema = Type.Union([
+    Type.Literal("support"),
+    Type.Literal("joint-support"),
+    Type.Literal("derivation-support"),
+]);
+export const RelationExtractionOutputSchema = Type.Object({
+    relations: Type.Array(Type.Object({
+        relationId: Type.String(),
+        type: RelationKindSchema,
+        sources: Type.Array(Type.String()),
+        target: Type.String(),
+        evidence: Type.Object({
+            segmentIds: Type.Array(Type.String()),
+            quote: Type.String(),
+        }),
+    })),
+});
+// -- Stage 10: conclusion-selection --
+export const ConclusionSelectionOutputSchema = Type.Object({
+    conclusionMiniId: Type.Union([Type.String(), Type.Null()]),
+    rationale: Type.String(),
+});
+// -- Stage 11: formula-compilation --
+export const FormulaPremiseRoleHintSchema = Type.Union([
+    Type.Literal("support"),
+    Type.Literal("joint-support"),
+    Type.Literal("derivation"),
+    Type.Literal("conclusion"),
+]);
+export const FormulaCompilationOutputSchema = Type.Object({
+    premises: Type.Array(Type.Object({
+        premiseMiniId: Type.String(),
+        formula: Type.String(),
+        roleHint: FormulaPremiseRoleHintSchema,
+        // Optional pointer back to the relation that produced this
+        // premise (null for the conclusion premise, which is
+        // synthesized rather than extracted).
+        sourceRelationId: Type.Union([Type.String(), Type.Null()]),
+    })),
+    conclusionPremiseMiniId: Type.Union([Type.String(), Type.Null()]),
+});
+// -- Stage 7 + 12 are validation stages whose `run` return value is
+// the same shape: an array of structured processing-failure-context
+// records. They emit failures via `ctx.addFailure` as the load-bearing
+// channel; the array return is mirroring + downstream-readable.
+export const ValidationStageOutputSchema = Type.Array(Type.Object({
+    code: Type.String(),
+    message: Type.String(),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+}));
+// -- Per-stage ids --
+export const STAGE_IDS = {
+    segmentation: "segmentation",
+    claimMentionExtraction: "claim-mention-extraction",
+    citationSourceDetection: "citation-source-detection",
+    axiomIndicatorDetection: "axiom-indicator-detection",
+    claimCanonicalization: "claim-canonicalization",
+    claimTypeClassification: "claim-type-classification",
+    claimReferenceValidation: "claim-reference-validation",
+    variableAssignment: "variable-assignment",
+    relationExtraction: "relation-extraction",
+    conclusionSelection: "conclusion-selection",
+    formulaCompilation: "formula-compilation",
+    formulaValidation: "formula-validation",
+};
+//# sourceMappingURL=schemas.js.map

package/dist/extensions/argument-ingestion/stages/schemas.js.map

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

package/dist/extensions/argument-ingestion/stages/segmentation.d.ts

@@ -0,0 +1,26 @@
+import { type TSegmentationOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TLlmStageOptionsOverride } from "../shared/types.js";
+export declare const SEGMENTATION_MODEL = "gpt-5.4-mini";
+export declare const SEGMENTATION_MAX_OUTPUT_TOKENS = 8192;
+export declare const SEGMENTATION_SYSTEM_PROMPT = "You are the first stage of an argument-ingestion pipeline. Your job is to split the supplied input text into a list of segments.\n\nReturn an object with a single key `segments` whose value is the array of segments.\n\nA segment is a sentence-or-thereabouts span of text \u2014 a self-contained clause that a human could read on its own. Sentence-final punctuation usually marks segment boundaries; bullet items in a list count as separate segments; multi-clause sentences split into one segment per major clause when the clauses each carry their own assertion.\n\nAssign each segment a short stable id like \"s1\", \"s2\", ... in left-to-right order, copy the segment's text verbatim (no rewriting), and record the character \"span\" as an object with \"start\" (inclusive) and \"end\" (exclusive) character offsets into the input. Whitespace between segments is owned by neither segment.\n\nCover the input completely: every non-whitespace character must fall inside some segment's span. Do not invent text. Do not classify segments \u2014 that is a later stage's job.";
+/**
+ * Internal default knobs for the segmentation stage. Exported so the
+ * pipeline factory can compose `resolveLlmStageOptions` over them.
+ */
+export declare const SEGMENTATION_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+/**
+ * Build the segmentation stage with optional caller overrides. The
+ * pipeline factory threads `TLlmStageOptionsOverride` through this
+ * factory; standalone consumers can call it with no args to get the
+ * default-options stage.
+ */
+export declare function createSegmentationStage(options?: TLlmStageOptionsOverride): TStage<TSegmentationOutput>;
+/**
+ * Backward-compatible default-options stage. Existing consumers
+ * (tests, the v2 factory's pre-1.3.1 path) keep importing this and
+ * see the new internal defaults — same as if they had called
+ * `createSegmentationStage()` with no args.
+ */
+export declare const segmentationStage: TStage<TSegmentationOutput>;
+//# sourceMappingURL=segmentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segmentation.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/segmentation.ts"],"names":[],"mappings":"AAYA,OAAO,EAGH,KAAK,mBAAmB,EAC3B,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAER,wBAAwB,EAC3B,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,kBAAkB,iBAAiB,CAAA;AAqBhD,eAAO,MAAM,8BAA8B,OAAO,CAAA;AAElD,eAAO,MAAM,0BAA0B,mjCAQsI,CAAA;AAY7K;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,wBAEzC,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACnC,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,mBAAmB,CAAC,CAW7B;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,mBAAmB,CAC7B,CAAA"}

package/dist/extensions/argument-ingestion/stages/segmentation.js

@@ -0,0 +1,81 @@
+// `segmentation` — first stage of the v2 multi-stage ingestion
+// pipeline. Splits the raw input text into segments (sentences or
+// sentence-like chunks) and emits a stable `segmentId` per segment
+// plus the text + character span.
+//
+// Why this lives in its own stage: downstream stages key their
+// extractions to `segmentId`s rather than to character offsets, so
+// extraction outputs survive small text edits if the segment ids are
+// stable. Splitting is also a cheap-tier task; running it as its own
+// stage prevents the larger downstream stages from burning tokens on
+// the same job.
+import { STAGE_IDS, SegmentationOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const SEGMENTATION_MODEL = "gpt-5.4-mini";
+// **Output cap (v1.3.1 fix for the segmentation-truncation
+// regression).** Segmentation emits an array of `{ segmentId, text,
+// span }` records — each segment's `text` is copied verbatim from
+// the input (per the prompt). For a 15 KB input the model
+// legitimately wants 30–50 segments at ~80–150 tokens of JSON each,
+// so the output budget needs to comfortably exceed 5 k tokens.
+// Without an explicit cap the Responses API's default
+// `max_output_tokens` for `gpt-5.4-mini` kicks in mid-string and
+// the model returns `status: "incomplete"` + partial JSON; v1.3.0
+// reproduced this against Singer's "Solution to World Poverty"
+// (15.5 KB / ~4 k input tokens). 8192 tokens is roughly 2× the
+// expected upper bound on realistic input sizes and stays well below
+// any per-model context-window limit — comfortable headroom without
+// burning tokens on an over-spec'd cap.
+//
+// Callers that ingest larger inputs can raise the cap further via
+// `createIngestionV2Pipeline(extension, { llm: { overrides: {
+// segmentation: { maxOutputTokens: N } } } })` — see
+// `shared/types.ts`.
+export const SEGMENTATION_MAX_OUTPUT_TOKENS = 8192;
+export const SEGMENTATION_SYSTEM_PROMPT = `You are the first stage of an argument-ingestion pipeline. Your job is to split the supplied input text into a list of segments.
+
+Return an object with a single key \`segments\` whose value is the array of segments.
+
+A segment is a sentence-or-thereabouts span of text — a self-contained clause that a human could read on its own. Sentence-final punctuation usually marks segment boundaries; bullet items in a list count as separate segments; multi-clause sentences split into one segment per major clause when the clauses each carry their own assertion.
+
+Assign each segment a short stable id like "s1", "s2", ... in left-to-right order, copy the segment's text verbatim (no rewriting), and record the character "span" as an object with "start" (inclusive) and "end" (exclusive) character offsets into the input. Whitespace between segments is owned by neither segment.
+
+Cover the input completely: every non-whitespace character must fall inside some segment's span. Do not invent text. Do not classify segments — that is a later stage's job.`;
+function buildSegmentationPrompt(ctx) {
+    const input = ctx.input;
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.segmentation} -->\n${SEGMENTATION_SYSTEM_PROMPT}`;
+    const user = `Input text:\n\n${input.text}`;
+    return { system: markedSystem, user };
+}
+/**
+ * Internal default knobs for the segmentation stage. Exported so the
+ * pipeline factory can compose `resolveLlmStageOptions` over them.
+ */
+export const SEGMENTATION_STAGE_DEFAULTS = {
+    maxOutputTokens: SEGMENTATION_MAX_OUTPUT_TOKENS,
+};
+/**
+ * Build the segmentation stage with optional caller overrides. The
+ * pipeline factory threads `TLlmStageOptionsOverride` through this
+ * factory; standalone consumers can call it with no args to get the
+ * default-options stage.
+ */
+export function createSegmentationStage(options) {
+    return llmStage({
+        id: STAGE_IDS.segmentation,
+        dependsOn: [],
+        outputSchema: SegmentationOutputSchema,
+        model: SEGMENTATION_MODEL,
+        maxOutputTokens: options?.maxOutputTokens ?? SEGMENTATION_MAX_OUTPUT_TOKENS,
+        reasoningEffort: options?.reasoningEffort,
+        buildPrompt: buildSegmentationPrompt,
+    });
+}
+/**
+ * Backward-compatible default-options stage. Existing consumers
+ * (tests, the v2 factory's pre-1.3.1 path) keep importing this and
+ * see the new internal defaults — same as if they had called
+ * `createSegmentationStage()` with no args.
+ */
+export const segmentationStage = createSegmentationStage();
+//# sourceMappingURL=segmentation.js.map

package/dist/extensions/argument-ingestion/stages/segmentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentation.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/segmentation.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,kEAAkE;AAClE,mEAAmE;AACnE,kCAAkC;AAClC,EAAE;AACF,+DAA+D;AAC/D,mEAAmE;AACnE,qEAAqE;AACrE,qEAAqE;AACrE,qEAAqE;AACrE,gBAAgB;AAEhB,OAAO,EACH,SAAS,EACT,wBAAwB,GAE3B,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAA;AAOlE,MAAM,CAAC,MAAM,kBAAkB,GAAG,cAAc,CAAA;AAEhD,2DAA2D;AAC3D,oEAAoE;AACpE,kEAAkE;AAClE,0DAA0D;AAC1D,oEAAoE;AACpE,+DAA+D;AAC/D,sDAAsD;AACtD,iEAAiE;AACjE,kEAAkE;AAClE,+DAA+D;AAC/D,+DAA+D;AAC/D,qEAAqE;AACrE,oEAAoE;AACpE,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,8DAA8D;AAC9D,qDAAqD;AACrD,qBAAqB;AACrB,MAAM,CAAC,MAAM,8BAA8B,GAAG,IAAI,CAAA;AAElD,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;6KAQmI,CAAA;AAE7K,SAAS,uBAAuB,CAAC,GAAkB;IAI/C,MAAM,KAAK,GAAG,GAAG,CAAC,KAAwB,CAAA;IAC1C,MAAM,YAAY,GAAG,kBAAkB,SAAS,CAAC,YAAY,SAAS,0BAA0B,EAAE,CAAA;IAClG,MAAM,IAAI,GAAG,kBAAkB,KAAK,CAAC,IAAI,EAAE,CAAA;IAC3C,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAA;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAA6B;IACjE,eAAe,EAAE,8BAA8B;CAClD,CAAA;AAED;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CACnC,OAAkC;IAElC,OAAO,QAAQ,CAAsB;QACjC,EAAE,EAAE,SAAS,CAAC,YAAY;QAC1B,SAAS,EAAE,EAAE;QACb,YAAY,EAAE,wBAAwB;QACtC,KAAK,EAAE,kBAAkB;QACzB,eAAe,EACX,OAAO,EAAE,eAAe,IAAI,8BAA8B;QAC9D,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,WAAW,EAAE,uBAAuB;KACvC,CAAC,CAAA;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAC1B,uBAAuB,EAAE,CAAA"}

package/dist/extensions/argument-ingestion/stages/variable-assignment.d.ts

@@ -0,0 +1,15 @@
+import { type TClaimCanonicalizationOutput, type TVariableAssignmentOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+export declare function isValidVariableSymbol(symbol: string): boolean;
+export type TAssignVariablesInput = {
+    canonicalClaims: TClaimCanonicalizationOutput["canonicalClaims"];
+    generateId: () => string;
+};
+/**
+ * Pure helper exposed for direct unit testing. The `variable-assignment`
+ * stage is a thin wrapper that reads `ctx.get(claim-canonicalization)`
+ * and calls this function with `ctx.generateId`.
+ */
+export declare function assignVariables(input: TAssignVariablesInput): TVariableAssignmentOutput;
+export declare const variableAssignmentStage: TStage<TVariableAssignmentOutput>;
+//# sourceMappingURL=variable-assignment.d.ts.map

package/dist/extensions/argument-ingestion/stages/variable-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable-assignment.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/variable-assignment.ts"],"names":[],"mappings":"AAwBA,OAAO,EAIH,KAAK,4BAA4B,EACjC,KAAK,yBAAyB,EACjC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAI7D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAI7D;AAED,MAAM,MAAM,qBAAqB,GAAG;IAChC,eAAe,EAAE,4BAA4B,CAAC,iBAAiB,CAAC,CAAA;IAChE,UAAU,EAAE,MAAM,MAAM,CAAA;CAC3B,CAAA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC3B,KAAK,EAAE,qBAAqB,GAC7B,yBAAyB,CA0B3B;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,yBAAyB,CAoBhE,CAAA"}

package/dist/extensions/argument-ingestion/stages/variable-assignment.js

@@ -0,0 +1,84 @@
+// `variable-assignment` — deterministic stage that mints one
+// `TParsedVariable`-shaped record per canonical claim.
+//
+// Behavior (spec §7.2 row 8):
+//   1. Read `claim-canonicalization.canonicalClaims` (in canonicalization
+//      order).
+//   2. For each claim, attempt to use its `suggestedSymbol` as the
+//      variable symbol. The symbol is valid iff it matches the regex
+//      `/^[a-zA-Z_][a-zA-Z0-9_]{0,31}$/` AND is unique among already-
+//      assigned variable symbols.
+//   3. If the suggested symbol is invalid or already used, fall back to
+//      `p1`, `p2`, `p3`, ... where the integer is the smallest one not
+//      already used by any valid suggested symbol or earlier fallback.
+//   4. Mint a fresh variable `miniId` (separate from the claim's
+//      `miniId`) via `ctx.generateId` for each output record. Tests use
+//      a deterministic stub generator that produces `v1`, `v2`, ...
+//
+// The framework default `ctx.generateId` is `crypto.randomUUID()`; the
+// recording-replay tests inject a deterministic counter so the
+// recorded fixtures stay stable.
+//
+// Errors / failures: this stage never throws and emits no
+// `ProcessingFailure`s. Empty input simply yields an empty array.
+import { STAGE_IDS, VariableAssignmentOutputSchema, } from "./schemas.js";
+import { deterministicStage } from "../../../lib/pipelines/stage-helpers.js";
+const SYMBOL_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]{0,31}$/;
+export function isValidVariableSymbol(symbol) {
+    if (symbol.length === 0)
+        return false;
+    if (symbol.length > 32)
+        return false;
+    return SYMBOL_REGEX.test(symbol);
+}
+/**
+ * Pure helper exposed for direct unit testing. The `variable-assignment`
+ * stage is a thin wrapper that reads `ctx.get(claim-canonicalization)`
+ * and calls this function with `ctx.generateId`.
+ */
+export function assignVariables(input) {
+    const out = [];
+    const usedSymbols = new Set();
+    let fallbackCounter = 1;
+    for (const claim of input.canonicalClaims) {
+        let symbol;
+        const suggested = claim.suggestedSymbol;
+        if (isValidVariableSymbol(suggested) && !usedSymbols.has(suggested)) {
+            symbol = suggested;
+        }
+        else {
+            // Walk fallback counter to the next unused `p<n>`.
+            while (usedSymbols.has(`p${fallbackCounter}`)) {
+                fallbackCounter += 1;
+            }
+            symbol = `p${fallbackCounter}`;
+            fallbackCounter += 1;
+        }
+        usedSymbols.add(symbol);
+        out.push({
+            miniId: input.generateId(),
+            symbol,
+            claimMiniId: claim.miniId,
+        });
+    }
+    return out;
+}
+export const variableAssignmentStage = deterministicStage({
+    id: STAGE_IDS.variableAssignment,
+    dependsOn: [STAGE_IDS.claimCanonicalization],
+    outputSchema: VariableAssignmentOutputSchema,
+    fn: (ctx) => {
+        const canon = ctx.get(STAGE_IDS.claimCanonicalization);
+        if (!canon) {
+            // Required dep — executor wouldn't have scheduled us
+            // without it. Defensive: empty array if it somehow
+            // arrived.
+            return [];
+        }
+        return assignVariables({
+            canonicalClaims: canon.canonicalClaims,
+            generateId: ctx.generateId,
+        });
+    },
+});
+//# sourceMappingURL=variable-assignment.js.map

package/dist/extensions/argument-ingestion/stages/variable-assignment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable-assignment.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/variable-assignment.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,uDAAuD;AACvD,EAAE;AACF,8BAA8B;AAC9B,0EAA0E;AAC1E,eAAe;AACf,mEAAmE;AACnE,qEAAqE;AACrE,sEAAsE;AACtE,kCAAkC;AAClC,wEAAwE;AACxE,uEAAuE;AACvE,uEAAuE;AACvE,iEAAiE;AACjE,wEAAwE;AACxE,oEAAoE;AACpE,EAAE;AACF,uEAAuE;AACvE,+DAA+D;AAC/D,iCAAiC;AACjC,EAAE;AACF,0DAA0D;AAC1D,kEAAkE;AAElE,OAAO,EACH,SAAS,EACT,8BAA8B,GAIjC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AAG5E,MAAM,YAAY,GAAG,+BAA+B,CAAA;AAEpD,MAAM,UAAU,qBAAqB,CAAC,MAAc;IAChD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IACrC,IAAI,MAAM,CAAC,MAAM,GAAG,EAAE;QAAE,OAAO,KAAK,CAAA;IACpC,OAAO,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;AACpC,CAAC;AAOD;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC3B,KAA4B;IAE5B,MAAM,GAAG,GAAwB,EAAE,CAAA;IACnC,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAA;IACrC,IAAI,eAAe,GAAG,CAAC,CAAA;IAEvB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,eAAe,EAAE,CAAC;QACxC,IAAI,MAAc,CAAA;QAClB,MAAM,SAAS,GAAG,KAAK,CAAC,eAAe,CAAA;QACvC,IAAI,qBAAqB,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAClE,MAAM,GAAG,SAAS,CAAA;QACtB,CAAC;aAAM,CAAC;YACJ,mDAAmD;YACnD,OAAO,WAAW,CAAC,GAAG,CAAC,IAAI,eAAe,EAAE,CAAC,EAAE,CAAC;gBAC5C,eAAe,IAAI,CAAC,CAAA;YACxB,CAAC;YACD,MAAM,GAAG,IAAI,eAAe,EAAE,CAAA;YAC9B,eAAe,IAAI,CAAC,CAAA;QACxB,CAAC;QACD,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACvB,GAAG,CAAC,IAAI,CAAC;YACL,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE;YAC1B,MAAM;YACN,WAAW,EAAE,KAAK,CAAC,MAAM;SAC5B,CAAC,CAAA;IACN,CAAC;IACD,OAAO,GAAG,CAAA;AACd,CAAC;AAED,MAAM,CAAC,MAAM,uBAAuB,GAChC,kBAAkB,CAA4B;IAC1C,EAAE,EAAE,SAAS,CAAC,kBAAkB;IAChC,SAAS,EAAE,CAAC,SAAS,CAAC,qBAAqB,CAAC;IAC5C,YAAY,EAAE,8BAA8B;IAC5C,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE;QACR,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CACjB,SAAS,CAAC,qBAAqB,CAClC,CAAA;QACD,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,qDAAqD;YACrD,mDAAmD;YACnD,WAAW;YACX,OAAO,EAAE,CAAA;QACb,CAAC;QACD,OAAO,eAAe,CAAC;YACnB,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,UAAU,EAAE,GAAG,CAAC,UAAU;SAC7B,CAAC,CAAA;IACN,CAAC;CACJ,CAAC,CAAA"}