@proposit/proposit-core 2.0.0 → 2.2.0

package/dist/extensions/{argument-ingestion → pipelines/base}/stages/segmentation.js

@@ -10,7 +10,7 @@
 // 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";
+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,
@@ -28,7 +28,7 @@ export const SEGMENTATION_MODEL = "gpt-5.4-mini";
 // burning tokens on an over-spec'd cap.
 //
 // Callers that ingest larger inputs can raise the cap further via
-// `createIngestionV2Pipeline(extension, { llm: { overrides: {
+// `createScholarPipeline(extension, { llm: { overrides: {
 // segmentation: { maxOutputTokens: N } } } })` — see
 // `shared/types.ts`.
 export const SEGMENTATION_MAX_OUTPUT_TOKENS = 8192;

package/dist/extensions/pipelines/base/stages/segmentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentation.js","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/base/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,4CAA4C,CAAA;AAIrE,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,0DAA0D;AAC1D,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,KAAK,EAAE,kBAAkB;IACzB,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,OAAO,EAAE,KAAK,IAAI,kBAAkB;QAC3C,eAAe,EACX,OAAO,EAAE,eAAe,IAAI,8BAA8B;QAC9D,eAAe,EAAE,OAAO,EAAE,eAAe;QACzC,KAAK,EAAE,OAAO,EAAE,KAAK;QACrB,WAAW,EAAE,uBAAuB;KACvC,CAAC,CAAA;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAC1B,uBAAuB,EAAE,CAAA"}

package/dist/extensions/{argument-ingestion → pipelines/base}/stages/variable-assignment.d.ts

@@ -1,5 +1,5 @@
 import { type TClaimCanonicalizationOutput, type TVariableAssignmentOutput } from "./schemas.js";
-import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TStage } from "../../../../lib/pipelines/types.js";
 export declare function isValidVariableSymbol(symbol: string): boolean;
 export type TAssignVariablesInput = {
     canonicalClaims: TClaimCanonicalizationOutput["canonicalClaims"];

package/dist/extensions/pipelines/base/stages/variable-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable-assignment.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/base/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,oCAAoC,CAAA;AAIhE,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 → pipelines/base}/stages/variable-assignment.js

@@ -22,7 +22,7 @@
 // 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";
+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)

package/dist/extensions/pipelines/base/stages/variable-assignment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable-assignment.js","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/base/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,4CAA4C,CAAA;AAG/E,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"}

package/dist/extensions/{argument-ingestion/shared → pipelines/base}/types.d.ts

@@ -46,13 +46,14 @@ export type TIngestionInput = {
  * `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), `reasoningEffort` (effort
- * budget for reasoning models — OpenAI-specific; ignored by the Ollama
- * provider), and `model` (the provider model identifier).
+ * budget for reasoning models — OpenAI-specific; ignored by the
+ * chat-completions provider), and `model` (the provider model
+ * identifier).
  *
  * The `model` knob lets a caller retarget every LLM stage at a
  * different backend without forking the stages — e.g. pointing the
- * whole v2 pipeline at a local Ollama model
- * (`{ llm: { defaults: { model: "qwen3.6:latest" } } }`) for cost-free
+ * whole v2 pipeline at a local model
+ * (`{ llm: { defaults: { model: "local-coder" } } }`) for cost-free
  * local development. Each stage keeps its own hard-coded `gpt-5.x`
  * default when no override is supplied, so production behavior is
  * unchanged.
@@ -63,7 +64,7 @@ export type TIngestionInput = {
  * does NOT merge it — see `resolveLlmStageOptions`). Its primary
  * consumer is the server's "no-auto-retry" toggle, which drops
  * `"transient"` from `retryOn`. Note that dropping `"transient"`
- * disables the retry for ALL transient causes — network/undici
+ * disables the retry for ALL transient causes — network
  * timeouts, 5xx, AND `incomplete/max_output_tokens` truncation — not
  * timeouts alone, because every non-Abort transport error and the
  * truncation case both classify as `"transient"`.

package/dist/extensions/pipelines/base/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/extensions/pipelines/base/types.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAEnE;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACnC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,CAAC,EAAE,gBAAgB,CAAA;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;CAChC,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/pipelines/base/types.js

@@ -0,0 +1,15 @@
+// Shared types for the ingestion pipelines.
+//
+// The scholar (thorough, multi-stage) and scribe (fast, two-call)
+// pipelines both produce a `TParsedArgumentResponse`-shaped output that
+// the existing `ArgumentParser.build()` consumes. They share an
+// extension descriptor — `TIngestionExtension` — so callers can plug in
+// custom per-entity field shapes (titles, bodies, URLs, axiom labels, …)
+// without reimplementing the pipelines.
+//
+// The descriptor's per-entity slots (`claimSchema`/`variableSchema`/…)
+// are composed by the stages (e.g. canonicalization builds its
+// per-extension output schema from `claimSchema`); `responseSchema` is
+// the pipeline's advertised output schema.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/extensions/pipelines/base/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/extensions/pipelines/base/types.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,kEAAkE;AAClE,wEAAwE;AACxE,gEAAgE;AAChE,wEAAwE;AACxE,yEAAyE;AACzE,wCAAwC;AACxC,EAAE;AACF,uEAAuE;AACvE,+DAA+D;AAC/D,uEAAuE;AACvE,2CAA2C"}

package/dist/extensions/pipelines/ingestion/index.d.ts

@@ -0,0 +1,5 @@
+export { createScholarPipeline } from "./scholar/index.js";
+export type { TCreateScholarPipelineOptions } from "./scholar/index.js";
+export { createScribePipeline } from "./scribe/index.js";
+export type { TCreateScribePipelineOptions } from "./scribe/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/pipelines/ingestion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/pipelines/ingestion/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,YAAY,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAA;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AACxD,YAAY,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/extensions/pipelines/ingestion/index.js

@@ -0,0 +1,5 @@
+// Barrel for the ingestion pipeline family (scholar + scribe).
+// Subpath: @proposit/proposit-core/pipelines/ingestion
+export { createScholarPipeline } from "./scholar/index.js";
+export { createScribePipeline } from "./scribe/index.js";
+//# sourceMappingURL=index.js.map

package/dist/extensions/pipelines/ingestion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/extensions/pipelines/ingestion/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,uDAAuD;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/extensions/pipelines/ingestion/scholar/index.d.ts

@@ -0,0 +1,3 @@
+export { createScholarPipeline, INGESTION_INPUT_SCHEMA } from "./scholar.js";
+export type { TCreateScholarPipelineOptions } from "./scholar.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/pipelines/ingestion/scholar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scholar/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAC5E,YAAY,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAA"}

package/dist/extensions/pipelines/ingestion/scholar/index.js

@@ -0,0 +1,3 @@
+// Barrel for the scholar (thorough, multi-stage) ingestion pipeline.
+export { createScholarPipeline, INGESTION_INPUT_SCHEMA } from "./scholar.js";
+//# sourceMappingURL=index.js.map

package/dist/extensions/pipelines/ingestion/scholar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scholar/index.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA"}

package/dist/extensions/pipelines/ingestion/scholar/scholar.d.ts

@@ -0,0 +1,48 @@
+import Type from "typebox";
+import type { TPipeline } from "../../../../lib/pipelines/index.js";
+import type { TParsedArgumentResponse } from "../../../../lib/parsing/index.js";
+import type { TIngestionExtension, TIngestionInput, TIngestionLlmOptions } from "../../base/types.js";
+/**
+ * Input schema shared by every ingestion pipeline: a single non-empty
+ * raw argument text. Exported so sibling pipelines (e.g. the fast
+ * `scribe` pipeline) advertise the identical input contract.
+ */
+export declare const INGESTION_INPUT_SCHEMA: Type.TObject<{
+    text: Type.TString;
+}>;
+/**
+ * Options for `createScholarPipeline`.
+ *
+ * `llm.defaults` applies to every LLM stage that doesn't have a
+ * per-stage entry under `llm.overrides`; per-stage entries are keyed
+ * by stage id (`STAGE_IDS.segmentation`, etc.). The effective knobs
+ * compose stage-override > pipeline-default > internal stage default.
+ *
+ * @example
+ * ```ts
+ * createScholarPipeline(basicsExtension, {
+ *     llm: {
+ *         defaults: { maxOutputTokens: 16_384 },
+ *         overrides: {
+ *             [STAGE_IDS.segmentation]: { maxOutputTokens: 32_768 },
+ *         },
+ *     },
+ * })
+ * ```
+ */
+export type TCreateScholarPipelineOptions = {
+    llm?: TIngestionLlmOptions;
+};
+/**
+ * Build the scholar (thorough) ingestion pipeline for the supplied
+ * extension. Returns a `TPipeline` whose 12-stage DAG segments,
+ * extracts, canonicalizes, classifies, relates, and compiles the raw
+ * text, and whose `finalize` assembles the `TParsedArgumentResponse`
+ * shape `ArgumentParser.build()` consumes.
+ *
+ * The factory is pure: it constructs stage values + a pipeline
+ * descriptor and returns immediately. Stage execution happens inside
+ * `executePipeline`.
+ */
+export declare function createScholarPipeline(extension: TIngestionExtension, options?: TCreateScholarPipelineOptions): TPipeline<TIngestionInput, TParsedArgumentResponse>;
+//# sourceMappingURL=scholar.d.ts.map

package/dist/extensions/pipelines/ingestion/scholar/scholar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scholar.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scholar/scholar.ts"],"names":[],"mappings":"AAgCA,OAAO,IAAI,MAAM,SAAS,CAAA;AAyB1B,OAAO,KAAK,EAAE,SAAS,EAAU,MAAM,oCAAoC,CAAA;AAC3E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAG/E,OAAO,KAAK,EACR,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACvB,MAAM,qBAAqB,CAAA;AAK5B;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;EAEjC,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,6BAA6B,GAAG;IACxC,GAAG,CAAC,EAAE,oBAAoB,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACjC,SAAS,EAAE,mBAAmB,EAC9B,OAAO,CAAC,EAAE,6BAA6B,GACxC,SAAS,CAAC,eAAe,EAAE,uBAAuB,CAAC,CAkGrD"}

package/dist/extensions/{argument-ingestion/v2-multi-stage.js → pipelines/ingestion/scholar/scholar.js}

@@ -1,12 +1,13 @@
-// v2 multi-stage ingestion pipeline.
+// scholar — the thorough, multi-stage ingestion pipeline.
 //
-// Composes the 12 stages defined under `./stages/` into a single
+// Composes the 12 stages defined under `../../base/stages/` into a single
 // `TPipeline<TIngestionInput, TParsedArgumentResponse>` whose `finalize`
-// assembles the same response shape v1 emits. Same output shape +
-// extension parameterization as `createIngestionV1Pipeline` — consumers
-// can swap the two factories without changing downstream parsing.
+// assembles the parsed-argument response shape downstream parsing
+// consumes. The sibling `scribe` pipeline emits the same output shape
+// from a cheaper two-call front end, so consumers can swap the two
+// factories without changing downstream parsing.
 //
-// DAG (spec §7.2):
+// DAG:
 //
 //   segmentation
 //     ├── claim-mention-extraction ─→ claim-canonicalization ─┐
@@ -29,26 +30,32 @@
 // 4 deterministic stages (claim-reference-validation, variable-assignment,
 // formula-compilation, formula-validation) + 8 LLM stages.
 import Type from "typebox";
-import { STAGE_IDS, claimReferenceValidationStage, createAxiomIndicatorDetectionStage, createCitationSourceDetectionStage, createClaimCanonicalizationStage, createClaimMentionExtractionStage, createClaimTypeClassificationStage, createConclusionSelectionStage, createRelationExtractionStage, createSegmentationStage, formulaCompilationStage, formulaValidationStage, variableAssignmentStage, SEGMENTATION_STAGE_DEFAULTS, CLAIM_MENTION_EXTRACTION_STAGE_DEFAULTS, CITATION_SOURCE_DETECTION_STAGE_DEFAULTS, AXIOM_INDICATOR_DETECTION_STAGE_DEFAULTS, CLAIM_CANONICALIZATION_STAGE_DEFAULTS, CLAIM_TYPE_CLASSIFICATION_STAGE_DEFAULTS, RELATION_EXTRACTION_STAGE_DEFAULTS, CONCLUSION_SELECTION_STAGE_DEFAULTS, } from "./stages/index.js";
-import { optional } from "../../lib/pipelines/index.js";
-import { finalizeResponseV2 } from "./shared/finalize-response-v2.js";
-import { resolveLlmStageOptions } from "./shared/resolve-llm-stage-options.js";
-const PIPELINE_ID = "argument-ingestion-v2";
+import { STAGE_IDS, claimReferenceValidationStage, createAxiomIndicatorDetectionStage, createCitationSourceDetectionStage, createClaimCanonicalizationStage, createClaimMentionExtractionStage, createClaimTypeClassificationStage, createConclusionSelectionStage, createRelationExtractionStage, createSegmentationStage, formulaCompilationStage, formulaValidationStage, variableAssignmentStage, SEGMENTATION_STAGE_DEFAULTS, CLAIM_MENTION_EXTRACTION_STAGE_DEFAULTS, CITATION_SOURCE_DETECTION_STAGE_DEFAULTS, AXIOM_INDICATOR_DETECTION_STAGE_DEFAULTS, CLAIM_CANONICALIZATION_STAGE_DEFAULTS, CLAIM_TYPE_CLASSIFICATION_STAGE_DEFAULTS, RELATION_EXTRACTION_STAGE_DEFAULTS, CONCLUSION_SELECTION_STAGE_DEFAULTS, } from "../../base/stages/index.js";
+import { optional } from "../../../../lib/pipelines/index.js";
+import { finalizeResponseV2 } from "../../base/finalize-response-v2.js";
+import { resolveLlmStageOptions } from "../../base/resolve-llm-stage-options.js";
+const PIPELINE_ID = "argument-ingestion-scholar";
 const PIPELINE_VERSION = "1.0.0";
-const INGESTION_INPUT_SCHEMA = Type.Object({
+/**
+ * Input schema shared by every ingestion pipeline: a single non-empty
+ * raw argument text. Exported so sibling pipelines (e.g. the fast
+ * `scribe` pipeline) advertise the identical input contract.
+ */
+export const INGESTION_INPUT_SCHEMA = Type.Object({
     text: Type.String({ minLength: 1 }),
 });
 /**
- * Build the v2 multi-stage ingestion pipeline for the supplied
- * extension. Returns a `TPipeline` whose stages match the 12-stage
- * DAG defined in spec §7.2 and whose `finalize` assembles the same
- * `TParsedArgumentResponse` shape `ArgumentParser.build()` consumes.
+ * Build the scholar (thorough) ingestion pipeline for the supplied
+ * extension. Returns a `TPipeline` whose 12-stage DAG segments,
+ * extracts, canonicalizes, classifies, relates, and compiles the raw
+ * text, and whose `finalize` assembles the `TParsedArgumentResponse`
+ * shape `ArgumentParser.build()` consumes.
  *
  * The factory is pure: it constructs stage values + a pipeline
  * descriptor and returns immediately. Stage execution happens inside
  * `executePipeline`.
  */
-export function createIngestionV2Pipeline(extension, options) {
+export function createScholarPipeline(extension, options) {
     const llm = options?.llm;
     const segmentationStage = createSegmentationStage(resolveLlmStageOptions(STAGE_IDS.segmentation, SEGMENTATION_STAGE_DEFAULTS, llm));
     const claimMentionExtractionStage = createClaimMentionExtractionStage(resolveLlmStageOptions(STAGE_IDS.claimMentionExtraction, CLAIM_MENTION_EXTRACTION_STAGE_DEFAULTS, llm));
@@ -97,4 +104,4 @@ export function createIngestionV2Pipeline(extension, options) {
         },
     };
 }
-//# sourceMappingURL=v2-multi-stage.js.map
+//# sourceMappingURL=scholar.js.map

package/dist/extensions/pipelines/ingestion/scholar/scholar.js.map

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

package/dist/extensions/pipelines/ingestion/scribe/extract-stage.d.ts

@@ -0,0 +1,33 @@
+import type { TStage } from "../../../../lib/pipelines/types.js";
+import { type TClaimCanonicalizationOutput, type TClaimTypeClassificationOutput } from "../../base/stages/index.js";
+import type { TIngestionExtension, TLlmStageOptionsOverride } from "../../base/types.js";
+export declare const EXTRACT_MODEL = "gpt-5.4-mini";
+/** Internal default knobs for scribe's `extract` stage. */
+export declare const EXTRACT_STAGE_DEFAULTS: TLlmStageOptionsOverride;
+export declare const EXTRACT_SYSTEM_PROMPT = "You read a raw argument and emit its canonical claim set in one pass.\n\nFor each distinct proposition the author makes, emit one canonical claim. Two phrasings of the same proposition merge into a single claim.\n\nEach canonical claim carries:\n- `miniId` \u2014 assign in order: c1, c2, c3, ...\n- `mentionIds` \u2014 leave as a single synthetic id per claim (e.g. [\"c1-m\"]); scribe does not track sub-claim mentions.\n- `type` \u2014 \"normal\" (a primary proposition), \"citation\" (content is \"the cited source asserts X\"; populate `url` + `title`), or \"axiomatic\" (invoked as self-evident; populate `axiom`).\n- `suggestedSymbol` \u2014 a short PascalCase-or-snake_case identifier (letters/digits/underscores, starts with a letter or underscore, under 32 chars). Avoid single letters and generic names.\n- the extension fields your output schema requires (title, body, url, axiom \u2014 whichever apply to the claim's type).\n- `mentionToClaim` \u2014 one `{ \"mentionId\": \"...\", \"claimMiniId\": \"...\" }` entry per synthetic mention id you used.\n\nStyle:\n- Third-person, present-tense, active voice.\n- State the proposition itself \u2014 never \"The author claims that ...\". For a citation claim, the title summarizes what the source asserts.\n\nOutput ONLY the schema-shaped object. No prose.";
+/**
+ * Build scribe's `extract` LLM stage. Its `outputSchema` is the
+ * per-extension canonicalization schema, so the cheap model is asked
+ * for the same extension-shaped claim records (title/body/url/axiom)
+ * scholar's canonicalizer produces — without which finalize would
+ * assemble empty claims.
+ */
+export declare function createExtractStage(extension: TIngestionExtension, options?: TLlmStageOptionsOverride): TStage<TClaimCanonicalizationOutput>;
+/**
+ * Adapter — republish `extract`'s canonical claims under the
+ * canonicalization slot scholar's deterministic stages + finalize read.
+ * `extract` already emits the canonicalization shape, so this is a
+ * pass-through (with a defensive empty default). Built per-extension
+ * because the canonicalization slot's schema carries the extension's
+ * claim fields.
+ */
+export declare function createExtractCanonicalizationAdapterStage(extension: TIngestionExtension): TStage<TClaimCanonicalizationOutput>;
+/**
+ * Adapter — derive the classification slot from `extract`'s claim
+ * records: each canonical claim already carries its `type`, so the
+ * classification entry is `{ miniId, type, sourceString }`.
+ * `sourceString` is the claim's `url` when present (citation claims),
+ * else null — mirroring what scholar's classification stage records.
+ */
+export declare const extractClassificationAdapterStage: TStage<TClaimTypeClassificationOutput>;
+//# sourceMappingURL=extract-stage.d.ts.map

package/dist/extensions/pipelines/ingestion/scribe/extract-stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-stage.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scribe/extract-stage.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,oCAAoC,CAAA;AAC/E,OAAO,EAIH,KAAK,4BAA4B,EACjC,KAAK,8BAA8B,EACtC,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EACR,mBAAmB,EAEnB,wBAAwB,EAC3B,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,aAAa,iBAAiB,CAAA;AAE3C,2DAA2D;AAC3D,eAAO,MAAM,sBAAsB,EAAE,wBAEpC,CAAA;AAED,eAAO,MAAM,qBAAqB,wyCAgBc,CAAA;AAYhD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,mBAAmB,EAC9B,OAAO,CAAC,EAAE,wBAAwB,GACnC,MAAM,CAAC,4BAA4B,CAAC,CAWtC;AAED;;;;;;;GAOG;AACH,wBAAgB,yCAAyC,CACrD,SAAS,EAAE,mBAAmB,GAC/B,MAAM,CAAC,4BAA4B,CAAC,CAWtC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC,EAAE,MAAM,CAAC,8BAA8B,CAmB/E,CAAA"}

package/dist/extensions/pipelines/ingestion/scribe/extract-stage.js

@@ -0,0 +1,103 @@
+// scribe stage 1 — `extract`: one cheap LLM call that produces the
+// canonical claim set (the same per-extension canonicalization shape
+// scholar's `claim-canonicalization` stage emits), collapsing scholar's
+// segmentation, claim-mention, citation-source, axiom-indicator,
+// canonicalization, and type-classification stages.
+//
+// Because a stage writes exactly one output slot, `extract` is paired
+// with two deterministic adapter stages that republish its parts under
+// the canonicalization and classification slots scholar's deterministic
+// backend + `finalizeResponseV2` read.
+import { llmStage } from "../../../../lib/pipelines/stage-helpers.js";
+import { deterministicStage } from "../../../../lib/pipelines/stage-helpers.js";
+import { STAGE_IDS, buildResponseSchema, ClaimTypeClassificationOutputSchema, } from "../../base/stages/index.js";
+export const EXTRACT_MODEL = "gpt-5.4-mini";
+/** Internal default knobs for scribe's `extract` stage. */
+export const EXTRACT_STAGE_DEFAULTS = {
+    model: EXTRACT_MODEL,
+};
+export const EXTRACT_SYSTEM_PROMPT = `You read a raw argument and emit its canonical claim set in one pass.
+
+For each distinct proposition the author makes, emit one canonical claim. Two phrasings of the same proposition merge into a single claim.
+
+Each canonical claim carries:
+- \`miniId\` — assign in order: c1, c2, c3, ...
+- \`mentionIds\` — leave as a single synthetic id per claim (e.g. ["c1-m"]); scribe does not track sub-claim mentions.
+- \`type\` — "normal" (a primary proposition), "citation" (content is "the cited source asserts X"; populate \`url\` + \`title\`), or "axiomatic" (invoked as self-evident; populate \`axiom\`).
+- \`suggestedSymbol\` — a short PascalCase-or-snake_case identifier (letters/digits/underscores, starts with a letter or underscore, under 32 chars). Avoid single letters and generic names.
+- the extension fields your output schema requires (title, body, url, axiom — whichever apply to the claim's type).
+- \`mentionToClaim\` — one \`{ "mentionId": "...", "claimMiniId": "..." }\` entry per synthetic mention id you used.
+
+Style:
+- Third-person, present-tense, active voice.
+- State the proposition itself — never "The author claims that ...". For a citation claim, the title summarizes what the source asserts.
+
+Output ONLY the schema-shaped object. No prose.`;
+function buildExtractPrompt(ctx) {
+    const input = ctx.input;
+    const system = `<!-- stage-id: ${STAGE_IDS.extract} -->\n${EXTRACT_SYSTEM_PROMPT}`;
+    const user = `Input text:\n\n${input.text}\n\nProduce the canonicalClaims + mentionToClaim object.`;
+    return { system, user };
+}
+/**
+ * Build scribe's `extract` LLM stage. Its `outputSchema` is the
+ * per-extension canonicalization schema, so the cheap model is asked
+ * for the same extension-shaped claim records (title/body/url/axiom)
+ * scholar's canonicalizer produces — without which finalize would
+ * assemble empty claims.
+ */
+export function createExtractStage(extension, options) {
+    return llmStage({
+        id: STAGE_IDS.extract,
+        dependsOn: [],
+        outputSchema: buildResponseSchema(extension),
+        model: options?.model ?? EXTRACT_MODEL,
+        maxOutputTokens: options?.maxOutputTokens,
+        reasoningEffort: options?.reasoningEffort,
+        retry: options?.retry,
+        buildPrompt: buildExtractPrompt,
+    });
+}
+/**
+ * Adapter — republish `extract`'s canonical claims under the
+ * canonicalization slot scholar's deterministic stages + finalize read.
+ * `extract` already emits the canonicalization shape, so this is a
+ * pass-through (with a defensive empty default). Built per-extension
+ * because the canonicalization slot's schema carries the extension's
+ * claim fields.
+ */
+export function createExtractCanonicalizationAdapterStage(extension) {
+    return deterministicStage({
+        id: STAGE_IDS.claimCanonicalization,
+        dependsOn: [STAGE_IDS.extract],
+        outputSchema: buildResponseSchema(extension),
+        fn: (ctx) => ctx.get(STAGE_IDS.extract) ?? {
+            canonicalClaims: [],
+            mentionToClaim: [],
+        },
+    });
+}
+/**
+ * Adapter — derive the classification slot from `extract`'s claim
+ * records: each canonical claim already carries its `type`, so the
+ * classification entry is `{ miniId, type, sourceString }`.
+ * `sourceString` is the claim's `url` when present (citation claims),
+ * else null — mirroring what scholar's classification stage records.
+ */
+export const extractClassificationAdapterStage = deterministicStage({
+    id: STAGE_IDS.claimTypeClassification,
+    dependsOn: [STAGE_IDS.extract],
+    outputSchema: ClaimTypeClassificationOutputSchema,
+    fn: (ctx) => {
+        const canon = ctx.get(STAGE_IDS.extract);
+        const claims = canon?.canonicalClaims ?? [];
+        return {
+            classifications: claims.map((c) => {
+                const url = c.url;
+                const sourceString = typeof url === "string" && url.length > 0 ? url : null;
+                return { miniId: c.miniId, type: c.type, sourceString };
+            }),
+        };
+    },
+});
+//# sourceMappingURL=extract-stage.js.map

package/dist/extensions/pipelines/ingestion/scribe/extract-stage.js.map

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

package/dist/extensions/pipelines/ingestion/scribe/index.d.ts

@@ -0,0 +1,3 @@
+export { createScribePipeline } from "./scribe.js";
+export type { TCreateScribePipelineOptions } from "./scribe.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/pipelines/ingestion/scribe/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scribe/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,YAAY,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA"}

package/dist/extensions/pipelines/ingestion/scribe/index.js

@@ -0,0 +1,3 @@
+// Barrel for the scribe (fast, two-call) ingestion pipeline.
+export { createScribePipeline } from "./scribe.js";
+//# sourceMappingURL=index.js.map

package/dist/extensions/pipelines/ingestion/scribe/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scribe/index.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA"}

package/dist/extensions/pipelines/ingestion/scribe/schemas.d.ts

@@ -0,0 +1,17 @@
+import Type, { type Static } from "typebox";
+export declare const ScribeStructureOutputSchema: 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;
+        }>;
+    }>>;
+    conclusionCandidates: Type.TArray<Type.TString>;
+    rationale: Type.TString;
+}>;
+export type TScribeStructureOutput = Static<typeof ScribeStructureOutputSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/extensions/pipelines/ingestion/scribe/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scribe/schemas.ts"],"names":[],"mappings":"AAeA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAO3C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;EAOvC,CAAA;AACD,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/extensions/pipelines/ingestion/scribe/schemas.js

@@ -0,0 +1,26 @@
+// Output schemas for scribe's two cheap LLM stages.
+//
+// scribe collapses scholar's eight LLM stages into two combined calls:
+//   - `extract`  → the canonical claim set (the same per-extension
+//     canonicalization shape scholar emits), so its deterministic
+//     adapters can republish the canonicalization + classification
+//     slots scholar's backend reads.
+//   - `structure` → the relation graph + a confidence-ranked list of
+//     conclusion candidates, so its adapters can republish the
+//     relation-extraction + conclusion-selection slots.
+//
+// `extract`'s output schema is the per-extension canonicalization
+// schema itself (`buildResponseSchema(extension)`); only `structure`
+// needs a bespoke schema, defined here.
+import Type, {} from "typebox";
+import { RelationExtractionOutputSchema } from "../../base/stages/index.js";
+// `structure` emits the relation graph (same per-relation shape as
+// scholar's `relation-extraction`) plus the conclusion candidates +
+// rationale (same fields scholar's conclusion-selection LLM emits,
+// before the deterministic resolution the adapter reproduces).
+export const ScribeStructureOutputSchema = Type.Object({
+    relations: RelationExtractionOutputSchema.properties.relations,
+    conclusionCandidates: Type.Array(Type.String()),
+    rationale: Type.String(),
+}, { additionalProperties: false });
+//# sourceMappingURL=schemas.js.map

package/dist/extensions/pipelines/ingestion/scribe/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scribe/schemas.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,uEAAuE;AACvE,mEAAmE;AACnE,kEAAkE;AAClE,mEAAmE;AACnE,qCAAqC;AACrC,qEAAqE;AACrE,+DAA+D;AAC/D,wDAAwD;AACxD,EAAE;AACF,kEAAkE;AAClE,qEAAqE;AACrE,wCAAwC;AAExC,OAAO,IAAI,EAAE,EAAe,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAA;AAE3E,mEAAmE;AACnE,oEAAoE;AACpE,mEAAmE;AACnE,+DAA+D;AAC/D,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC,MAAM,CAClD;IACI,SAAS,EAAE,8BAA8B,CAAC,UAAU,CAAC,SAAS;IAC9D,oBAAoB,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;IAC/C,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE;CAC3B,EACD,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAClC,CAAA"}

package/dist/extensions/pipelines/ingestion/scribe/scribe.d.ts

@@ -0,0 +1,20 @@
+import type { TPipeline } from "../../../../lib/pipelines/index.js";
+import type { TParsedArgumentResponse } from "../../../../lib/parsing/index.js";
+import type { TIngestionExtension, TIngestionInput, TIngestionLlmOptions } from "../../base/types.js";
+/**
+ * Options for `createScribePipeline`. Same `{ llm }` surface as scholar:
+ * `llm.defaults` applies to both cheap LLM stages; per-stage
+ * `llm.overrides` are keyed by `STAGE_IDS.extract` / `.scribeStructure`.
+ */
+export type TCreateScribePipelineOptions = {
+    llm?: TIngestionLlmOptions;
+};
+/**
+ * Build the scribe (fast) ingestion pipeline for the supplied
+ * extension: `extract` + `structure` cheap LLM calls, their
+ * deterministic adapters, then scholar's 4 deterministic stages +
+ * `finalizeResponseV2`. Emits the same `TParsedArgumentResponse` as
+ * scholar.
+ */
+export declare function createScribePipeline(extension: TIngestionExtension, options?: TCreateScribePipelineOptions): TPipeline<TIngestionInput, TParsedArgumentResponse>;
+//# sourceMappingURL=scribe.d.ts.map

package/dist/extensions/pipelines/ingestion/scribe/scribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scribe.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/pipelines/ingestion/scribe/scribe.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAAU,MAAM,oCAAoC,CAAA;AAC3E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAU/E,OAAO,KAAK,EACR,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACvB,MAAM,qBAAqB,CAAA;AAkB5B;;;;GAIG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACvC,GAAG,CAAC,EAAE,oBAAoB,CAAA;CAC7B,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAChC,SAAS,EAAE,mBAAmB,EAC9B,OAAO,CAAC,EAAE,4BAA4B,GACvC,SAAS,CAAC,eAAe,EAAE,uBAAuB,CAAC,CAoDrD"}

package/dist/extensions/pipelines/ingestion/scribe/scribe.js

@@ -0,0 +1,81 @@
+// scribe — the fast, low-cost ingestion pipeline.
+//
+// Two cheap LLM calls (`extract` → `structure`) feed scholar's
+// deterministic backend, producing the same `TParsedArgumentResponse`
+// shape scholar emits. Each combined LLM stage is paired with
+// deterministic adapter stages that republish its parts under the six
+// standard stage-output slots scholar's 4 deterministic stages +
+// `finalizeResponseV2` read — so that backend + finalize are reused
+// verbatim (the deterministic stage consts are shared by reference).
+//
+// DAG:
+//
+//   extract ──┬─ (adapter) claim-canonicalization ─┬─ claim-reference-validation
+//             └─ (adapter) claim-type-classification ┤
+//                                                    └─ variable-assignment
+//   structure ─┬─ (adapter) relation-extraction
+//              └─ (adapter) conclusion-selection
+//                                          formula-compilation
+//                                          formula-validation
+//                                          finalize
+//
+// `structure` depends on the canonicalization + classification slots,
+// so `extract` (+ its adapters) runs first.
+import { optional } from "../../../../lib/pipelines/index.js";
+import { STAGE_IDS, claimReferenceValidationStage, variableAssignmentStage, formulaCompilationStage, formulaValidationStage, } from "../../base/stages/index.js";
+import { finalizeResponseV2 } from "../../base/finalize-response-v2.js";
+import { resolveLlmStageOptions } from "../../base/resolve-llm-stage-options.js";
+import { INGESTION_INPUT_SCHEMA } from "../scholar/scholar.js";
+import { createExtractStage, createExtractCanonicalizationAdapterStage, extractClassificationAdapterStage, EXTRACT_STAGE_DEFAULTS, } from "./extract-stage.js";
+import { createStructureStage, structureRelationAdapterStage, structureConclusionAdapterStage, STRUCTURE_STAGE_DEFAULTS, } from "./structure-stage.js";
+const PIPELINE_ID = "argument-ingestion-scribe";
+const PIPELINE_VERSION = "1.0.0";
+/**
+ * Build the scribe (fast) ingestion pipeline for the supplied
+ * extension: `extract` + `structure` cheap LLM calls, their
+ * deterministic adapters, then scholar's 4 deterministic stages +
+ * `finalizeResponseV2`. Emits the same `TParsedArgumentResponse` as
+ * scholar.
+ */
+export function createScribePipeline(extension, options) {
+    const llm = options?.llm;
+    const extractStage = createExtractStage(extension, resolveLlmStageOptions(STAGE_IDS.extract, EXTRACT_STAGE_DEFAULTS, llm));
+    const extractCanonicalizationAdapterStage = createExtractCanonicalizationAdapterStage(extension);
+    const structureStage = createStructureStage(resolveLlmStageOptions(STAGE_IDS.scribeStructure, STRUCTURE_STAGE_DEFAULTS, llm));
+    const stages = [
+        extractStage,
+        extractCanonicalizationAdapterStage,
+        extractClassificationAdapterStage,
+        claimReferenceValidationStage,
+        variableAssignmentStage,
+        structureStage,
+        structureRelationAdapterStage,
+        structureConclusionAdapterStage,
+        formulaCompilationStage,
+        formulaValidationStage,
+    ];
+    return {
+        id: PIPELINE_ID,
+        version: PIPELINE_VERSION,
+        inputSchema: INGESTION_INPUT_SCHEMA,
+        // Mirrors scholar: the advertised outputSchema is the
+        // extension's response schema; finalize attaches a
+        // `processingFailures` slot at runtime.
+        outputSchema: extension.responseSchema,
+        stages,
+        finalize: {
+            dependsOn: [
+                STAGE_IDS.claimCanonicalization,
+                STAGE_IDS.variableAssignment,
+                STAGE_IDS.formulaCompilation,
+                optional(STAGE_IDS.claimTypeClassification),
+                optional(STAGE_IDS.relationExtraction),
+                optional(STAGE_IDS.conclusionSelection),
+                optional(STAGE_IDS.formulaValidation),
+                optional(STAGE_IDS.claimReferenceValidation),
+            ],
+            run: (ctx) => finalizeResponseV2({ ctx, extension }),
+        },
+    };
+}
+//# sourceMappingURL=scribe.js.map