@namzu/sdk 43.0.0 → 44.0.0

package/dist/run/drain.d.ts

@@ -1,204 +0,0 @@
-/**
- * One pass over a queue of durable runs: list what nobody holds, take it,
- * hand it to a worker, give it back.
- *
- * Every primitive this composes already shipped —
- * {@link import('../store/run/listing.js').listDurableRuns} enumerates runs
- * above a run id, `claimRun` arbitrates between processes, `releaseRun`
- * returns a run to the queue, and `resumeRun` carries a fence into every
- * durable write. Nothing composed them, so the two things the claim was
- * built for — an approval inbox and a crash sweeper — still required a host
- * to write the loop, and writing it correctly means getting the release
- * into a `finally` and the `null` claim out of the error path. Both are the
- * kind of thing a host gets wrong once, quietly.
- *
- * ## What this deliberately is NOT
- *
- * A supervisor, a daemon, or a scheduler. There is no timer here, no
- * process spawn, no retry backoff and no `while (true)`. `drainRuns` makes
- * ONE bounded pass and returns what happened; running it again is the
- * caller's decision, made wherever that caller already has a scheduler. A
- * per-platform supervisor is the same trade the deployment-adapter matrix
- * was rejected for: one seam beats N adapters.
- *
- * Read the scope of that narrowly. This paragraph has been cited as the
- * kernel's refusal of a model-facing "remind me tomorrow" capability, and
- * it is not one: it says a HOST brings the timer, which presumes the host
- * has one rather than ruling the capability out. Whether such a capability
- * should exist -- and if so, as a store plus a host-driven sweep rather
- * than a daemon here -- is open. `directory/types.ts` records the adjacent
- * decision that cut a declarative `schedules/` slot, on grounds of
- * double-fire and timezone; that is a different question from a runtime
- * tool, and neither text settles the other.
- *
- * The unit of work is a callback, so this module never needs a provider, a
- * tool registry or a sandbox — the half of a run that cannot be serialized
- * stays with the caller, exactly as `resumeRun` already splits it.
- */
-import type { RunId } from '../types/ids/index.js';
-import type { CheckpointListingScope, CheckpointStore, DurableRunEntry, ParkState, RunLease } from '../types/run/checkpoint-store.js';
-/** Runs handled per pass when the caller names no page size. */
-export declare const DEFAULT_DRAIN_PAGE_SIZE = 100;
-/**
- * What a drainer does with one run it successfully took.
- *
- * Receives the claim, not just its fence, because the holder and expiry are
- * what a worker needs to decide whether it still has time to start — and
- * because a caller that only ever sees a number tends to forget the lease
- * can lapse under it.
- *
- * The intended body is a resume:
- *
- * ```ts
- * onRun: (entry, claim) =>
- *   resumeRun({
- *     ...yourQueryParams,
- *     scope: { ...entry, topicId },
- *     checkpointStore: store,
- *     claimFence: claim.fence,
- *   })
- * ```
- *
- * `claimFence` is the whole reason the claim is handed over: a write that
- * does not carry it is unfenced, so a worker stalled past its lease would
- * still be able to overwrite the record of whoever took the run over.
- *
- * A throw is recorded against that run and the pass continues. A drainer
- * that died on the first bad run would leave the rest of the queue
- * untouched, which is the failure a queue exists to spread out.
- */
-export type DrainRun = (entry: DurableRunEntry, claim: RunLease) => void | Promise<void>;
-export interface DrainRunsParams {
-    /** Backend to list, claim and release against. Must support all three. */
-    readonly store: CheckpointStore;
-    /** Contiguous prefix — `tenantId` required. See {@link CheckpointListingScope}. */
-    readonly scope: CheckpointListingScope;
-    /**
-     * Who is taking the runs. Per-PROCESS, never per-deployment: `holder` is
-     * the only thing that distinguishes a renewal from a theft, so two
-     * drainers sharing a string take live claims from each other instantly.
-     */
-    readonly holder: string;
-    /** Lease length in ms. Long enough that the slowest run finishes inside it. */
-    readonly ttlMs: number;
-    /** The work. See {@link DrainRun}. */
-    readonly onRun: DrainRun;
-    /**
-     * Keep only runs whose park is in one of these states.
-     *
-     * **Absent means every run with durable state, parked or not**, and that
-     * is not a placeholder default — it is what a crash sweep wants, because
-     * a run that died mid-flight never parked and would be invisible under
-     * any park filter. An approval inbox passes `['outstanding']`; a
-     * reclamation sweep passes `['expired']`.
-     */
-    readonly park?: readonly ParkState[];
-    /**
-     * Stop taking new runs. Work already in flight is NOT interrupted — this
-     * module owns no run and cannot cancel one; a caller that needs to abort
-     * the work itself passes the same signal into whatever `onRun` starts.
-     */
-    readonly signal?: AbortSignal;
-    /**
-     * How many runs may be in flight at once. Defaults to 1.
-     *
-     * Bounded on purpose. The obvious implementation — claim everything, then
-     * `Promise.all` — holds N leases while doing one run's worth of work, so
-     * the runs at the back of the batch expire before they are started and
-     * are taken by somebody else mid-flight.
-     */
-    readonly maxConcurrent?: number;
-    /** Listing page size. See {@link DEFAULT_DRAIN_PAGE_SIZE}. */
-    readonly pageSize?: number;
-    /**
-     * Clock for expiry, so one pass judges every claim against one instant
-     * and a test does not have to wait out a lease.
-     */
-    readonly now?: number;
-}
-/** A run a pass could not finish, and why. */
-export interface DrainFailure {
-    readonly runId: RunId;
-    readonly error: string;
-}
-/** What one pass did. */
-export interface DrainRunsResult {
-    /** Rows the listing returned, before any of them were contended for. */
-    readonly listed: number;
-    /** Runs whose `onRun` returned. */
-    readonly drained: readonly RunId[];
-    /**
-     * Runs another worker held. Not failures: "somebody got there first" is
-     * the ordinary outcome of a queue with more than one reader.
-     */
-    readonly skipped: readonly RunId[];
-    /**
-     * Runs that stopped matching {@link DrainRunsParams.park} between the
-     * listing and the claim, and were given straight back.
-     *
-     * Separate from {@link DrainRunsResult.skipped} because the cause is
-     * different and so is what an operator should do about a lot of them: a
-     * skip means another drainer is holding runs right now, a stale entry
-     * means another drainer already FINISHED one. Empty on a pass with no
-     * park filter, which has nothing to re-check against.
-     */
-    readonly stale: readonly RunId[];
-    /** Runs whose `onRun` threw. */
-    readonly failed: readonly DrainFailure[];
-    /**
-     * Runs that finished but whose lease could not be handed back.
-     *
-     * Separate from {@link DrainRunsResult.failed} because it is a different
-     * fact with a different consequence: the work is done and the record is
-     * written; the run is merely unavailable to the next reader until the
-     * lease lapses. Reported rather than swallowed — a release that quietly
-     * did nothing is how a queue silently loses throughput.
-     */
-    readonly unreleased: readonly DrainFailure[];
-    /** Whether the pass stopped early because the signal aborted. */
-    readonly stopped: boolean;
-}
-/**
- * Take every unclaimed run under a scope, one bounded pass, and give each
- * one back when its work returns.
- *
- * The shape is: list parked-and-unclaimed → claim → work → release in a
- * `finally`. The `finally` is the part a host writes wrong: a worker that
- * returns without releasing leaves the run stuck until the lease lapses,
- * and a worker that releases only on success leaves a FAILED run stuck for
- * the same duration — so a queue quietly loses its throughput to the runs
- * that need retrying most.
- *
- * `claimed: false` is not a parameter. A drainer never wants work somebody
- * else holds; that is what makes it a drainer rather than a listing. An
- * expired claim counts as unheld, which is what makes a dead worker's runs
- * recoverable at all.
- *
- * ## What "exactly once" does and does not mean here
- *
- * Two drainers never hold one run at the same time — that is the claim, and
- * it is absolute. **Exactly-once over a whole pass is a weaker promise, and
- * where it holds it comes from the FILTER, not from the claim.** A listing
- * is a snapshot; between paging a row and claiming it, another drainer can
- * finish that run and release it, and the claim then succeeds on work
- * already done. So a claimed row is re-read against
- * {@link DrainRunsParams.park} before any work starts, and one that no
- * longer matches is given straight back as {@link DrainRunsResult.stale}.
- * An inbox drain (`park: ['outstanding']`) whose work answers the park is
- * therefore exactly-once, because doing the work is what removes the run
- * from the queue.
- *
- * With NO park filter there is nothing to re-check, and two drainers can
- * both process one run. That is not an omission: a checkpoint store holds no
- * run STATUS by design — nothing in it distinguishes a run that finished
- * from one that died — so "already done" is a fact only the host's own run
- * records carry. A crash sweep intersects with those records inside
- * `onRun`, which is the shape {@link DurableRunEntry} already prescribes.
- *
- * @throws NamzuError `capability_unavailable` when the store cannot list,
- *   claim or release — before any run is touched.
- * @throws NamzuError `invalid_config` on a lease or concurrency that cannot
- *   mean what it says.
- */
-export declare function drainRuns(params: DrainRunsParams): Promise<DrainRunsResult>;
-//# sourceMappingURL=drain.d.ts.map

package/dist/run/drain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drain.d.ts","sourceRoot":"","sources":["../../src/run/drain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAKH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAA;AAClD,OAAO,KAAK,EACX,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,SAAS,EACT,QAAQ,EACR,MAAM,kCAAkC,CAAA;AAEzC,gEAAgE;AAChE,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAExF,MAAM,WAAW,eAAe;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAA;IACtC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;IAExB;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,SAAS,EAAE,CAAA;IAEpC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;IAE7B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAE/B,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAE1B;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,8CAA8C;AAC9C,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACtB;AAED,yBAAyB;AACzB,MAAM,WAAW,eAAe;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mCAAmC;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,KAAK,EAAE,CAAA;IAClC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,KAAK,EAAE,CAAA;IAClC;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,CAAA;IAChC,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAA;IAC5C,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CACzB;AAgCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAqJjF"}

package/dist/run/drain.js

@@ -1,238 +0,0 @@
-/**
- * One pass over a queue of durable runs: list what nobody holds, take it,
- * hand it to a worker, give it back.
- *
- * Every primitive this composes already shipped —
- * {@link import('../store/run/listing.js').listDurableRuns} enumerates runs
- * above a run id, `claimRun` arbitrates between processes, `releaseRun`
- * returns a run to the queue, and `resumeRun` carries a fence into every
- * durable write. Nothing composed them, so the two things the claim was
- * built for — an approval inbox and a crash sweeper — still required a host
- * to write the loop, and writing it correctly means getting the release
- * into a `finally` and the `null` claim out of the error path. Both are the
- * kind of thing a host gets wrong once, quietly.
- *
- * ## What this deliberately is NOT
- *
- * A supervisor, a daemon, or a scheduler. There is no timer here, no
- * process spawn, no retry backoff and no `while (true)`. `drainRuns` makes
- * ONE bounded pass and returns what happened; running it again is the
- * caller's decision, made wherever that caller already has a scheduler. A
- * per-platform supervisor is the same trade the deployment-adapter matrix
- * was rejected for: one seam beats N adapters.
- *
- * Read the scope of that narrowly. This paragraph has been cited as the
- * kernel's refusal of a model-facing "remind me tomorrow" capability, and
- * it is not one: it says a HOST brings the timer, which presumes the host
- * has one rather than ruling the capability out. Whether such a capability
- * should exist -- and if so, as a store plus a host-driven sweep rather
- * than a daemon here -- is open. `directory/types.ts` records the adjacent
- * decision that cut a declarative `schedules/` slot, on grounds of
- * double-fire and timezone; that is a different question from a runtime
- * tool, and neither text settles the other.
- *
- * The unit of work is a callback, so this module never needs a provider, a
- * tool registry or a sandbox — the half of a run that cannot be serialized
- * stays with the caller, exactly as `resumeRun` already splits it.
- */
-import { claimRun, listDurableRuns, releaseRun, summarizePark } from '../store/run/listing.js';
-import { NamzuError } from '../types/errors/index.js';
-/** Runs handled per pass when the caller names no page size. */
-export const DEFAULT_DRAIN_PAGE_SIZE = 100;
-function refuse(code, message, details) {
-    throw new NamzuError({ code, message, details });
-}
-function toMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-/**
- * Refuse a store that cannot do the whole job, BEFORE anything is listed.
- *
- * Checked up front rather than at the first call that needs each method, so
- * that a store missing only `releaseRun` cannot resume half a queue and then
- * discover it has no way to give the runs back. The optional-capability rule
- * on `CheckpointStore` says a caller refuses rather than degrades; a drainer
- * that degraded would be the worst instance of it, because "claimed by
- * default" here means every worker proceeds on every run.
- */
-function assertDrainable(store) {
-    const missing = ['listDurableRuns', 'claimRun', 'releaseRun'].filter((m) => typeof store[m] !== 'function');
-    if (missing.length === 0)
-        return;
-    refuse('capability_unavailable', `drainRuns: the injected checkpoint store does not implement ${missing.map((m) => `\`${m}\``).join(', ')}, so it cannot arbitrate a queue. Refusing before anything is claimed rather than draining what it can — a drainer that proceeded without a claim would let two workers restore one checkpoint, both execute its tools and both write under one run id. Supply a store that implements all three (the built-in disk and in-memory stores do), or run a single writer per run.`, { missing });
-}
-/**
- * Take every unclaimed run under a scope, one bounded pass, and give each
- * one back when its work returns.
- *
- * The shape is: list parked-and-unclaimed → claim → work → release in a
- * `finally`. The `finally` is the part a host writes wrong: a worker that
- * returns without releasing leaves the run stuck until the lease lapses,
- * and a worker that releases only on success leaves a FAILED run stuck for
- * the same duration — so a queue quietly loses its throughput to the runs
- * that need retrying most.
- *
- * `claimed: false` is not a parameter. A drainer never wants work somebody
- * else holds; that is what makes it a drainer rather than a listing. An
- * expired claim counts as unheld, which is what makes a dead worker's runs
- * recoverable at all.
- *
- * ## What "exactly once" does and does not mean here
- *
- * Two drainers never hold one run at the same time — that is the claim, and
- * it is absolute. **Exactly-once over a whole pass is a weaker promise, and
- * where it holds it comes from the FILTER, not from the claim.** A listing
- * is a snapshot; between paging a row and claiming it, another drainer can
- * finish that run and release it, and the claim then succeeds on work
- * already done. So a claimed row is re-read against
- * {@link DrainRunsParams.park} before any work starts, and one that no
- * longer matches is given straight back as {@link DrainRunsResult.stale}.
- * An inbox drain (`park: ['outstanding']`) whose work answers the park is
- * therefore exactly-once, because doing the work is what removes the run
- * from the queue.
- *
- * With NO park filter there is nothing to re-check, and two drainers can
- * both process one run. That is not an omission: a checkpoint store holds no
- * run STATUS by design — nothing in it distinguishes a run that finished
- * from one that died — so "already done" is a fact only the host's own run
- * records carry. A crash sweep intersects with those records inside
- * `onRun`, which is the shape {@link DurableRunEntry} already prescribes.
- *
- * @throws NamzuError `capability_unavailable` when the store cannot list,
- *   claim or release — before any run is touched.
- * @throws NamzuError `invalid_config` on a lease or concurrency that cannot
- *   mean what it says.
- */
-export async function drainRuns(params) {
-    const { store, scope, holder, ttlMs, onRun, park, signal, now } = params;
-    assertDrainable(store);
-    if (holder.trim().length === 0) {
-        refuse('invalid_config', 'drainRuns: `holder` is empty. It is the only thing that distinguishes a renewal from a theft, so two drainers sharing one string take live claims from each other instantly. Use something per-process — a worker id, a pod name plus a pid.', { holder });
-    }
-    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-        refuse('invalid_config', `drainRuns: ttlMs must be a positive number of milliseconds, got ${String(ttlMs)}. A lease that expires immediately is a lease every worker can take at once, which is the condition a claim exists to prevent.`, { ttlMs });
-    }
-    const maxConcurrent = params.maxConcurrent ?? 1;
-    if (!Number.isInteger(maxConcurrent) || maxConcurrent < 1) {
-        refuse('invalid_config', `drainRuns: maxConcurrent must be a positive integer, got ${String(params.maxConcurrent)}. Zero would drain nothing while reporting a successful pass.`, { maxConcurrent: params.maxConcurrent });
-    }
-    const pageSize = params.pageSize ?? DEFAULT_DRAIN_PAGE_SIZE;
-    const drained = [];
-    const skipped = [];
-    const stale = [];
-    const failed = [];
-    const unreleased = [];
-    let listed = 0;
-    let stopped = false;
-    const giveBack = async (entry, fence) => {
-        try {
-            await releaseRun(store, entry, fence);
-        }
-        catch (err) {
-            // Never rethrown: on the work path this runs inside a `finally`
-            // unwinding the caller's error, and replacing it would send the
-            // operator to debug the disk instead of the run.
-            unreleased.push({ runId: entry.runId, error: toMessage(err) });
-        }
-    };
-    /**
-     * Is this row still the row the listing described?
-     *
-     * A listing is a SNAPSHOT, and a claim taken against a stale snapshot is
-     * a claim on work somebody already did. The window is real and small:
-     * drainer B pages the queue, drainer A takes a run, finishes it, answers
-     * its park and releases — and B's claim then succeeds on a run that is no
-     * longer outstanding. Mutual exclusion cannot close that; only re-reading
-     * after the claim can, which is why this is here and not in the store.
-     *
-     * Only the park is re-checked, because it is the only predicate this loop
-     * was given. **Two drainers with no park filter can both process one
-     * run**, and no amount of claiming prevents it: a checkpoint store holds
-     * no run STATUS by design — see the note on {@link DurableRunEntry} — so
-     * "already done" is a fact only the host's own run records carry. A crash
-     * sweep intersects with those records inside `onRun`.
-     */
-    const stillMatches = async (entry) => {
-        if (!park)
-            return true;
-        const fresh = summarizePark(await store.listCheckpoints(entry), now ?? Date.now());
-        return fresh !== undefined && park.includes(fresh.state);
-    };
-    /**
-     * One run: take it, work it, give it back.
-     *
-     * **No cancellation check here, and its absence is deliberate.** One was
-     * written, and a mutation test found nothing could kill it: the batch
-     * below dispatches with `.map(handle)`, which calls every handler
-     * synchronously before any of them awaits, so a signal that aborts during
-     * a batch cannot be observed at the top of a handler that has already
-     * been entered — and a signal that aborts BETWEEN batches is caught by
-     * the check in the loop, which runs first. A branch nothing can reach is
-     * a declaration nothing drives, so it is gone rather than covered by a
-     * test that would have proved nothing
-     * ("declared but undriven").
-     */
-    const handle = async (entry) => {
-        const claim = await claimRun(store, entry, {
-            holder,
-            ttlMs,
-            ...(now !== undefined ? { now } : {}),
-        });
-        // `null` is not an error. Another worker got there first, which is the
-        // ordinary outcome of two readers on one queue.
-        if (!claim) {
-            skipped.push(entry.runId);
-            return;
-        }
-        // Checked with the claim in hand rather than before taking it: only
-        // under the claim is the answer stable, because nobody else can change
-        // it while this drainer holds the run.
-        if (!(await stillMatches(entry))) {
-            stale.push(entry.runId);
-            await giveBack(entry, claim.fence);
-            return;
-        }
-        try {
-            await onRun(entry, claim);
-            drained.push(entry.runId);
-        }
-        catch (err) {
-            failed.push({ runId: entry.runId, error: toMessage(err) });
-        }
-        finally {
-            await giveBack(entry, claim.fence);
-        }
-    };
-    let cursor;
-    do {
-        if (signal?.aborted) {
-            stopped = true;
-            break;
-        }
-        const page = await listDurableRuns(store, scope, {
-            // Not a parameter. See the note above.
-            claimed: false,
-            ...(park ? { park } : {}),
-            limit: pageSize,
-            ...(cursor !== undefined ? { cursor } : {}),
-            ...(now !== undefined ? { now } : {}),
-        });
-        listed += page.entries.length;
-        // Windowed rather than `Promise.all` over the page: the leases are taken
-        // as the work starts, so a page bigger than the pass can finish inside
-        // one TTL does not hand the tail of it to somebody else mid-flight.
-        for (let i = 0; i < page.entries.length; i += maxConcurrent) {
-            if (signal?.aborted) {
-                stopped = true;
-                break;
-            }
-            await Promise.all(page.entries.slice(i, i + maxConcurrent).map(handle));
-        }
-        // A drained run is released, so it is unclaimed again — but the cursor
-        // is a position in a total order and has already passed it, so the pass
-        // cannot see it twice and cannot fail to terminate.
-        cursor = stopped ? undefined : page.cursor;
-    } while (cursor !== undefined);
-    return { listed, drained, skipped, stale, failed, unreleased, stopped };
-}
-//# sourceMappingURL=drain.js.map

package/dist/run/drain.js.map

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

package/dist/run/evidence-query.d.ts

@@ -1,41 +0,0 @@
-import type { PrepareStepContext } from '../types/run/prepare-step.js';
-interface QueryMessage {
-    readonly position: number;
-    readonly role: string;
-    readonly text: string;
-    readonly truncated: boolean;
-    readonly source?: 'compaction-summary';
-}
-export interface EvidenceQueryResolution {
-    readonly terms: readonly string[];
-    /** Optional grounded subject words; discovery requires any one, not all of them. */
-    readonly focusTerms?: readonly string[];
-    readonly time: 'past' | 'unspecified';
-    readonly basis: readonly {
-        position: number;
-        role: string;
-        quote: string;
-        /** A derived lookup reference, never an original observation. */
-        source?: 'compaction-summary';
-    }[];
-    /** Distinct visible word spellings not offered within the planning input allowance. */
-    readonly omittedTokens?: number;
-}
-/** A planner interpretation of visible references, never authenticated evidence. */
-export interface EvidenceQueryAmbiguity {
-    readonly kind: 'ambiguous';
-    readonly basis: EvidenceQueryResolution['basis'];
-}
-type QueryPlan = EvidenceQueryResolution | EvidenceQueryAmbiguity | null | undefined;
-/** Internal planner input. IDs are local to this exact bounded input, never archive addresses. */
-export declare function buildEvidenceQueryInput(current: string, history: readonly QueryMessage[]): {
-    prompt: string;
-    tokens: string[];
-    omittedTokens: number;
-} | undefined;
-/** Pure validation grounds the selected tokens in the supplied visible text. */
-export declare function validateEvidenceQueryResolution(raw: string, current: string, history: readonly QueryMessage[]): QueryPlan;
-/** One cached plan for the same operator input; evidence bytes are never cached. */
-export declare function createEvidenceQueryResolver(): (context: PrepareStepContext, query: string) => Promise<QueryPlan>;
-export {};
-//# sourceMappingURL=evidence-query.d.ts.map

package/dist/run/evidence-query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evidence-query.d.ts","sourceRoot":"","sources":["../../src/run/evidence-query.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAiDtE,UAAU,YAAY;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAA;CACtC;AAED,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,oFAAoF;IACpF,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAA;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS;QACxB,QAAQ,EAAE,MAAM,CAAA;QAChB,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,iEAAiE;QACjE,MAAM,CAAC,EAAE,oBAAoB,CAAA;KAC7B,EAAE,CAAA;IACH,uFAAuF;IACvF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAC/B;AAED,oFAAoF;AACpF,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAA;CAChD;AAED,KAAK,SAAS,GAAG,uBAAuB,GAAG,sBAAsB,GAAG,IAAI,GAAG,SAAS,CAAA;AAEpF,kGAAkG;AAClG,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE;;;;cAsDxF;AAsFD,gFAAgF;AAChF,wBAAgB,+BAA+B,CAC9C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,SAAS,YAAY,EAAE,GAC9B,SAAS,CAqDX;AAED,oFAAoF;AACpF,wBAAgB,2BAA2B,KASlC,SAAS,kBAAkB,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,SAAS,CAAC,CAsCvE"}