memkin 0.4.2 → 0.4.3

package/dist/distiller/contract.d.ts.map

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

package/dist/distiller/contract.js

@@ -0,0 +1,166 @@
+/**
+ * Distillation output contract v4 (spec §5).
+ *
+ * A `DistilledPayload` is the target-agnostic, immutable product of session
+ * distillation: a set of signals, each a member of a Zod discriminated union
+ * keyed by `type`. PR-2 only produces and persists this payload; it never
+ * writes pages (that is PR-4's apply engine).
+ *
+ * Design notes:
+ * - Discriminated union: every `type` carries its own additional fields and
+ *   admission rules. Strict validation — the distiller retries once on failure
+ *   before parking the revision in `retrying`.
+ * - authority is a three-value ladder (user_confirmed / assistant_claimed /
+ *   assistant_proposed). The per-type admissibility matrix lives in
+ *   authority-matrix.ts (spec §5).
+ * - Dates use ISO 8601 (z.string().datetime()).
+ * - preference.category and knowledge.source_kind are closed enums, not free
+ *   text.
+ * - reference.url is required and must additionally be locatable inside the
+ *   evidence message text — that cross-check lives in msg-id.ts (it needs the
+ *   transcript), not here.
+ * - Payload-internal dedup: no two signals may share (type, slugify(topic)).
+ *   That guarantee is why the two-layer ID scheme (spec §6.1) needs no ordinal.
+ */
+import { z } from "zod";
+// ── Enums ──────────────────────────────────────────────────────────────────
+export const SignalTypeSchema = z.enum([
+    "decision",
+    "task",
+    "reference",
+    "preference",
+    "knowledge",
+    "discovery",
+]);
+export const AuthoritySchema = z.enum([
+    "user_confirmed",
+    "assistant_claimed",
+    "assistant_proposed",
+]);
+export const TaskStatusSchema = z.enum(["open", "in_progress", "done", "cancelled"]);
+export const PreferenceCategorySchema = z.enum([
+    "tooling",
+    "workflow",
+    "communication",
+    "coding_style",
+    "ui",
+    "personal",
+    "other",
+]);
+export const KnowledgeSourceKindSchema = z.enum([
+    "documentation",
+    "experiment",
+    "external_reference",
+    "domain_fact",
+    "observation",
+]);
+export const DiscoverySubtypeSchema = z.enum(["insight", "pattern", "risk", "procedure"]);
+// ── Evidence ─────────────────────────────────────────────────────────────────
+// A programmatic msg_id range. IDs are assigned by the pipeline (msg-id.ts);
+// the model may only reference given IDs, and bounds are checked there.
+export const MsgRangeSchema = z.object({
+    start: z.string().min(1),
+    end: z.string().min(1),
+});
+// ── Common fields (all signals) ──────────────────────────────────────────────
+const commonShape = {
+    topic: z.string().min(1),
+    what: z.string().min(1),
+    why: z.string().optional(),
+    project: z.string().optional(),
+    entities: z.array(z.string()),
+    authority: AuthoritySchema,
+    supersedes_topic: z.string().optional(),
+    evidence: z.array(MsgRangeSchema).min(1),
+    persistence_reason: z.string().min(1),
+};
+// An ISO 8601 date-time string. z.string().datetime() rejects date-only forms.
+const isoDate = z.string().datetime();
+// ── Per-type variants ─────────────────────────────────────────────────────────
+export const DecisionSignalSchema = z.object({
+    type: z.literal("decision"),
+    ...commonShape,
+});
+export const TaskSignalSchema = z.object({
+    type: z.literal("task"),
+    ...commonShape,
+    owner: z.string().optional(),
+    due_date: isoDate.optional(),
+    status: TaskStatusSchema,
+});
+export const ReferenceSignalSchema = z.object({
+    type: z.literal("reference"),
+    ...commonShape,
+    url: z.string().min(1),
+    trigger: z.string().optional(),
+});
+export const PreferenceSignalSchema = z.object({
+    type: z.literal("preference"),
+    ...commonShape,
+    subject: z.string().min(1),
+    category: PreferenceCategorySchema,
+});
+export const KnowledgeSignalSchema = z.object({
+    type: z.literal("knowledge"),
+    ...commonShape,
+    source_kind: KnowledgeSourceKindSchema,
+    valid_at: isoDate.optional(),
+    invalid_at: isoDate.optional(),
+});
+export const DiscoverySignalSchema = z.object({
+    type: z.literal("discovery"),
+    ...commonShape,
+    subtype: DiscoverySubtypeSchema,
+});
+export const DistilledSignalSchema = z.discriminatedUnion("type", [
+    DecisionSignalSchema,
+    TaskSignalSchema,
+    ReferenceSignalSchema,
+    PreferenceSignalSchema,
+    KnowledgeSignalSchema,
+    DiscoverySignalSchema,
+]);
+// ── Payload ───────────────────────────────────────────────────────────────────
+// Payload-internal dedup on (type, slugify(topic)) is enforced by a superRefine
+// so callers get a single validation surface.
+export const DistilledPayloadSchema = z
+    .object({
+    signals: z.array(DistilledSignalSchema),
+})
+    .superRefine((payload, ctx) => {
+    const seen = new Set();
+    for (let i = 0; i < payload.signals.length; i++) {
+        const s = payload.signals[i];
+        const key = `${s.type}::${slugifyTopic(s.topic)}`;
+        if (seen.has(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["signals", i, "topic"],
+                message: `duplicate (type, slugify(topic)): "${key}" — merge these signals`,
+            });
+        }
+        seen.add(key);
+    }
+});
+/**
+ * Deterministic topic slug used both for payload-internal dedup and downstream
+ * ID derivation (spec §6.1 normalized_topic). Lowercase, collapse whitespace,
+ * strip punctuation, hyphenate.
+ */
+export function slugifyTopic(topic) {
+    return topic
+        .toLowerCase()
+        .trim()
+        .replace(/[^\p{L}\p{N}\s-]/gu, "")
+        .replace(/[\s_]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+/** Safe-parse wrapper returning a discriminated result rather than throwing. */
+export function parsePayload(input) {
+    const res = DistilledPayloadSchema.safeParse(input);
+    if (res.success)
+        return { ok: true, payload: res.data };
+    return { ok: false, error: res.error };
+}
+//# sourceMappingURL=contract.js.map

package/dist/distiller/contract.js.map

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

package/dist/distiller/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * SessionDistiller — orchestration (spec §4, §5, §11 PR-2).
+ *
+ * Ties the ledger → distill → outbox flow together, with the HARD PR-2 boundary
+ * that NOTHING is applied and NO page is written. Per tick:
+ *
+ *   1. Pick up pending revisions (discovered, or retrying whose backoff elapsed).
+ *   2. Silence gate: only distill sessions idle ≥ silence window (default 30 min).
+ *   3. Stale guard: the ledger revision's content_hash must still match the file
+ *      (a torn/updated snapshot is left for a later tick).
+ *   4. Replay guard: if a payload already exists for the revision, never call the
+ *      LLM — just ensure the ledger is linked/advanced.
+ *   5. Distill: pre-LLM raw privacy → segment → sequential map-reduce → evidence
+ *      validation → second-pass payload privacy → persist to outbox → distilled.
+ *   6. On invalid output: retry ONCE in-tick; still bad → retrying (+ retry_count),
+ *      or dead_letter once retries are exhausted.
+ *
+ * The orchestrator reads transcripts through an injectable TranscriptSource so it
+ * is testable with in-memory content and independent of the collector's file IO.
+ */
+import type { PrivacyConfig } from "../core/config.js";
+import type { LLMProvider } from "../extractors/providers/types.js";
+import type { AgentSessionStore } from "../store/agent-sessions.js";
+import type { DistilledPayloadStore } from "../store/distilled-payload.js";
+import { type RawInputMessage } from "./msg-id.js";
+/** A source of transcript content, keyed by (sourceInstance, sessionId). */
+export interface TranscriptSource {
+    load(sourceInstance: string, sessionId: string): Promise<{
+        content: string;
+        mtimeMs: number;
+    } | null>;
+}
+export interface DistillerOpts {
+    /** Silence window before a session is eligible for its first distillation. */
+    silenceMs?: number;
+    /** Max retries before dead-lettering a revision. */
+    maxRetries?: number;
+    /** Backoff before a retrying revision is retried. */
+    retryBackoffMs?: number;
+    /** Segment token budget for map-reduce. */
+    maxSegmentTokens?: number;
+    /** Injectable clock (ms). */
+    now?: () => number;
+}
+export interface SessionDistillerDeps {
+    sessions: AgentSessionStore;
+    payloads: DistilledPayloadStore;
+    provider: LLMProvider;
+    privacy: PrivacyConfig;
+    transcripts: TranscriptSource;
+    opts?: DistillerOpts;
+}
+export interface TickResult {
+    considered: number;
+    distilled: number;
+    skipped: number;
+    failed: number;
+    deadLettered: number;
+    replayed: number;
+}
+export declare class SessionDistiller {
+    private readonly deps;
+    private readonly now;
+    constructor(deps: SessionDistillerDeps);
+    private opt;
+    /** Process one tick over pending revisions. */
+    runTick(): Promise<TickResult>;
+    private processRevision;
+    /**
+     * Run the distill pipeline once with a single in-tick retry. Returns the
+     * validated payload + reversible restoration map, or a failure.
+     */
+    private distillOnce;
+    private handleFailure;
+    private safeMark;
+}
+/**
+ * Parse a claude-code / codex-style JSONL transcript into ordered role+text
+ * messages. Tolerant: skips non-conversation lines and unparseable content.
+ * Kept local so the distiller does not depend on the collector's file IO.
+ */
+export declare function parseTranscript(content: string): RawInputMessage[];
+//# sourceMappingURL=index.d.ts.map

package/dist/distiller/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/distiller/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAiC,MAAM,4BAA4B,CAAC;AACnG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,OAAO,EAAgB,KAAK,eAAe,EAAoB,MAAM,aAAa,CAAC;AAKnF,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CACF,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2CAA2C;IAC3C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,6BAA6B;IAC7B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,QAAQ,EAAE,qBAAqB,CAAC;IAChC,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AASD,qBAAa,gBAAgB;IAGf,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEN,IAAI,EAAE,oBAAoB;IAIvD,OAAO,CAAC,GAAG;IAKX,+CAA+C;IACzC,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;YAsBtB,eAAe;IAsE7B;;;OAGG;YACW,WAAW;YAiCX,aAAa;YAkBb,QAAQ;CAOvB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAgClE"}

package/dist/distiller/index.js

@@ -0,0 +1,226 @@
+/**
+ * SessionDistiller — orchestration (spec §4, §5, §11 PR-2).
+ *
+ * Ties the ledger → distill → outbox flow together, with the HARD PR-2 boundary
+ * that NOTHING is applied and NO page is written. Per tick:
+ *
+ *   1. Pick up pending revisions (discovered, or retrying whose backoff elapsed).
+ *   2. Silence gate: only distill sessions idle ≥ silence window (default 30 min).
+ *   3. Stale guard: the ledger revision's content_hash must still match the file
+ *      (a torn/updated snapshot is left for a later tick).
+ *   4. Replay guard: if a payload already exists for the revision, never call the
+ *      LLM — just ensure the ledger is linked/advanced.
+ *   5. Distill: pre-LLM raw privacy → segment → sequential map-reduce → evidence
+ *      validation → second-pass payload privacy → persist to outbox → distilled.
+ *   6. On invalid output: retry ONCE in-tick; still bad → retrying (+ retry_count),
+ *      or dead_letter once retries are exhausted.
+ *
+ * The orchestrator reads transcripts through an injectable TranscriptSource so it
+ * is testable with in-memory content and independent of the collector's file IO.
+ */
+import { createHash } from "node:crypto";
+import { mapReduceDistill } from "./map-reduce.js";
+import { assignMsgIds, validateEvidence } from "./msg-id.js";
+import { redactPayload } from "./payload-privacy.js";
+import { RawMessagePrivacyProcessor } from "./raw-privacy.js";
+import { segmentMessages } from "./segmenter.js";
+const DEFAULTS = {
+    silenceMs: 30 * 60_000,
+    maxRetries: 3,
+    retryBackoffMs: 5 * 60_000,
+    maxSegmentTokens: 3000,
+};
+export class SessionDistiller {
+    deps;
+    now;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.opts?.now ?? (() => Date.now());
+    }
+    opt(key) {
+        const v = this.deps.opts?.[key];
+        return typeof v === "number" ? v : DEFAULTS[key];
+    }
+    /** Process one tick over pending revisions. */
+    async runTick() {
+        const result = {
+            considered: 0,
+            distilled: 0,
+            skipped: 0,
+            failed: 0,
+            deadLettered: 0,
+            replayed: 0,
+        };
+        const pending = [
+            ...(await this.deps.sessions.listSessions({ state: "discovered" })),
+            ...(await this.deps.sessions.listSessions({ state: "retrying" })),
+        ];
+        for (const rev of pending) {
+            result.considered++;
+            await this.processRevision(rev, result);
+        }
+        return result;
+    }
+    async processRevision(rev, result) {
+        // Replay guard: a payload already exists → never call the LLM again.
+        const existing = await this.deps.payloads.getByRevision(rev.id);
+        if (existing) {
+            result.replayed++;
+            if (rev.state === "discovered") {
+                await this.safeMark(rev.id, "distilled");
+            }
+            return;
+        }
+        const file = await this.deps.transcripts.load(rev.sourceInstance, rev.sessionId);
+        if (!file) {
+            result.skipped++;
+            return;
+        }
+        // Silence gate.
+        if (this.now() - file.mtimeMs < this.opt("silenceMs")) {
+            result.skipped++;
+            return;
+        }
+        // Stale guard: the ledger revision must match the current file content.
+        const currentHash = createHash("sha256").update(file.content).digest("hex");
+        if (currentHash !== rev.contentHash) {
+            result.skipped++;
+            return;
+        }
+        // Retry backoff: a retrying revision waits before its next attempt.
+        if (rev.state === "retrying") {
+            const since = Date.parse(rev.updatedAt);
+            if (Number.isFinite(since) && this.now() - since < this.opt("retryBackoffMs")) {
+                result.skipped++;
+                return;
+            }
+        }
+        const messages = parseTranscript(file.content);
+        if (messages.length === 0) {
+            result.skipped++;
+            return;
+        }
+        const outcome = await this.distillOnce(messages);
+        if (outcome.ok) {
+            // Second-pass privacy + persist to outbox.
+            const clean = redactPayload(outcome.payload, this.deps.privacy);
+            await this.deps.payloads.persist({
+                sourceInstance: rev.sourceInstance,
+                sessionId: rev.sessionId,
+                revisionId: rev.id,
+                contentHash: rev.contentHash,
+                payload: clean,
+                restorationMap: outcome.restorationMap,
+            });
+            // persist() advances discovered→distilled; a retrying revision needs an
+            // explicit transition back to distilled.
+            if (rev.state === "retrying") {
+                await this.safeMark(rev.id, "distilled");
+            }
+            result.distilled++;
+            return;
+        }
+        // Failure path: retry / dead-letter.
+        await this.handleFailure(rev, result);
+    }
+    /**
+     * Run the distill pipeline once with a single in-tick retry. Returns the
+     * validated payload + reversible restoration map, or a failure.
+     */
+    async distillOnce(messages) {
+        const parsed = assignMsgIds(messages);
+        // First pass: redact raw text BEFORE the LLM sees it.
+        const rawPrivacy = new RawMessagePrivacyProcessor(this.deps.privacy);
+        const { messages: redacted, restorationMap } = rawPrivacy.redactMessages(parsed);
+        const segments = segmentMessages(redacted, {
+            maxSegmentTokens: this.opt("maxSegmentTokens"),
+        });
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const { payload } = await mapReduceDistill(segments, this.deps.provider);
+                // Evidence bounds + reference.url locatability against the (redacted)
+                // messages actually shown to the model.
+                const ev = validateEvidence(payload.signals, redacted);
+                if (!ev.ok)
+                    continue;
+                return { ok: true, payload, restorationMap };
+            }
+            catch {
+                // fall through to retry / failure
+            }
+        }
+        return { ok: false };
+    }
+    async handleFailure(rev, result) {
+        if (rev.state === "retrying") {
+            // Already retrying: dead-letter once retries are exhausted, else bump count.
+            if (rev.retryCount >= this.opt("maxRetries")) {
+                await this.safeMark(rev.id, "dead_letter");
+                result.deadLettered++;
+            }
+            else {
+                await this.deps.sessions.incrementRetry(rev.id);
+                result.failed++;
+            }
+            return;
+        }
+        // First failure for a discovered revision → retrying (+1).
+        await this.safeMark(rev.id, "retrying");
+        await this.deps.sessions.incrementRetry(rev.id);
+        result.failed++;
+    }
+    async safeMark(id, next) {
+        try {
+            await this.deps.sessions.markState(id, next);
+        }
+        catch {
+            // Illegal transition (already advanced by a concurrent tick) — ignore.
+        }
+    }
+}
+/**
+ * Parse a claude-code / codex-style JSONL transcript into ordered role+text
+ * messages. Tolerant: skips non-conversation lines and unparseable content.
+ * Kept local so the distiller does not depend on the collector's file IO.
+ */
+export function parseTranscript(content) {
+    const out = [];
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const type = obj.type;
+        if (type !== "user" && type !== "assistant")
+            continue;
+        const message = obj.message;
+        if (!message)
+            continue;
+        const role = message.role === "assistant" ? "assistant" : "user";
+        let text;
+        const content = message.content;
+        if (typeof content === "string") {
+            text = content;
+        }
+        else if (Array.isArray(content)) {
+            text = content
+                .filter((b) => b.type === "text" && b.text)
+                .map((b) => b.text ?? "")
+                .join("\n\n");
+        }
+        else {
+            continue;
+        }
+        if (!text.trim())
+            continue;
+        out.push({ role, content: text });
+    }
+    return out;
+}
+//# sourceMappingURL=index.js.map

package/dist/distiller/index.js.map

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

package/dist/distiller/map-reduce.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Sequential map-reduce distillation (spec §5.1).
+ *
+ * MAP (sequential, not parallel): each segment is distilled in order; the prompt
+ * for segment N carries forward segment N-1's `carry_forward` (in-progress topics
+ * / undecided items) so `overturned` can be filled reliably. Session counts are
+ * low, so sequential cost is acceptable.
+ *
+ * Intermediate per-segment schema:
+ *   { seg_no, summary, tentative_signals[], overturned[], carry_forward }
+ *
+ * REDUCE: merges the tentative signals into a final payload. The reduce prompt
+ * carries the explicit rule "conclusions appearing in any `overturned` must not
+ * enter the final signals". We additionally post-filter overturned topics
+ * programmatically so a model slip cannot leak a retracted conclusion back in.
+ *
+ * The final payload is only structurally validated here (parsePayload). Evidence
+ * bounds + reference.url locatability (msg-id.ts) and second-pass privacy run in
+ * the orchestrator, which has the full transcript.
+ */
+import { z } from "zod";
+import type { LLMProvider } from "../extractors/providers/types.js";
+import { type DistilledPayload } from "./contract.js";
+import type { Segment } from "./segmenter.js";
+export declare const OverturnedSchema: z.ZodObject<{
+    topic: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    topic: string;
+    reason?: string | undefined;
+}, {
+    topic: string;
+    reason?: string | undefined;
+}>;
+export declare const SegmentSummarySchema: z.ZodObject<{
+    seg_no: z.ZodNumber;
+    summary: z.ZodString;
+    tentative_signals: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    overturned: z.ZodArray<z.ZodObject<{
+        topic: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        topic: string;
+        reason?: string | undefined;
+    }, {
+        topic: string;
+        reason?: string | undefined;
+    }>, "many">;
+    carry_forward: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    seg_no: number;
+    tentative_signals: Record<string, unknown>[];
+    overturned: {
+        topic: string;
+        reason?: string | undefined;
+    }[];
+    carry_forward: string;
+}, {
+    summary: string;
+    seg_no: number;
+    tentative_signals: Record<string, unknown>[];
+    overturned: {
+        topic: string;
+        reason?: string | undefined;
+    }[];
+    carry_forward: string;
+}>;
+export type SegmentSummary = z.infer<typeof SegmentSummarySchema>;
+export interface MapReduceResult {
+    payload: DistilledPayload;
+    overturnedTopics: string[];
+    segmentSummaries: SegmentSummary[];
+}
+/**
+ * Run sequential map over segments then a single reduce.
+ * `criteria` is the judgment-declaration prompt fragment (spec §5 / §11 task 2.9);
+ * callers inject the embedded distill criteria.
+ */
+export declare function mapReduceDistill(segments: Segment[], provider: LLMProvider, criteria?: string): Promise<MapReduceResult>;
+//# sourceMappingURL=map-reduce.d.ts.map

package/dist/distiller/map-reduce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-reduce.d.ts","sourceRoot":"","sources":["../../src/distiller/map-reduce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EACL,KAAK,gBAAgB,EAItB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAK9C,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,EAAE,cAAc,EAAE,CAAC;CACpC;AAWD;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,WAAW,EACrB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,CAAC,CAoD1B"}