@namzu/sdk 43.0.0 → 44.0.0

package/dist/runtime/query/checkpoint.d.ts

@@ -1,153 +1,112 @@
 import type { WorkingStateSnapshot } from '../../compaction/wire.js';
-import type { RunPersistence } from '../../manager/run/persistence.js';
+import { type TurnRecorder } from '../../manager/session/turn-recorder.js';
+import type { CheckpointScope, SessionCheckpointStore } from '../../store/checkpoint/index.js';
+import type { SessionLog } from '../../store/session-log/index.js';
 import type { SerializedSpanContext } from '../../telemetry/attributes.js';
-import type { CheckpointId, CheckpointSummary, HITLDecisionRequest, HITLResumeDecision, IterationCheckpoint, PendingDecision } from '../../types/hitl/index.js';
-import type { UserMessage } from '../../types/message/index.js';
-import type { CheckpointRunScope, CheckpointStore, FencingToken } from '../../types/run/checkpoint-store.js';
-import type { EmergencySaveData } from '../../types/run/emergency.js';
-import type { CheckpointListEntry } from '../../types/run/replay.js';
+import type { CheckpointId, CheckpointSummary, HITLDecisionRequest, HITLResumeDecision, PendingDecision } from '../../types/hitl/index.js';
+import type { MessageId, TurnId } from '../../types/ids/index.js';
+import { type Message, type UserMessage } from '../../types/message/index.js';
+import { type Checkpoint } from '../../types/session/checkpoint.js';
+import type { CheckpointListEntry } from '../../types/session/fork.js';
+/** A checkpoint the turn just wrote: its id and the document. */
+export interface CreatedCheckpoint {
+    readonly id: CheckpointId;
+    readonly document: Checkpoint;
+}
 /**
- * Projection from a full checkpoint payload to the public listing entry.
- * Exported for the replay `listCheckpoints` entry point, which projects
- * store results without constructing a `CheckpointManager`.
+ * A checkpoint read back for a resume: the document, the context it
+ * restores (the fold of the session log through `throughSeq`), and the
+ * decision it is parked on, if any.
  */
-export declare function toCheckpointListEntry(cp: IterationCheckpoint): CheckpointListEntry;
+export interface RestoredCheckpoint {
+    readonly id: CheckpointId;
+    readonly document: Checkpoint;
+    readonly messages: Message[];
+    /** Ids of the restored messages that have records, by message. */
+    readonly messageIds: ReadonlyMap<Message, MessageId>;
+    readonly pending?: PendingDecision;
+    readonly latestUserMessage?: UserMessage;
+}
+/** A decision one of a turn's checkpoints was parked on, as the log records it. */
+export interface RecordedPark {
+    readonly decisionId: string;
+    readonly turnId: TurnId;
+    readonly checkpointId: CheckpointId;
+    readonly pending: PendingDecision;
+}
+/** Projection from a checkpoint document to the public listing entry. */
+export declare function toCheckpointListEntry(cp: Checkpoint): CheckpointListEntry;
 /**
- * Project an {@link EmergencySaveData} dump to an {@link IterationCheckpoint}
- * shape so `replay({ fromCheckpoint: 'emergency' })` can consume it through
- * the same restore path as any other checkpoint.
- *
- * The projection is lossy: `costInfo`, `guardState.elapsedMs` and
- * `toolResultHashes` are not captured at emergency-save time. The synthetic
- * checkpoint id is derived deterministically from the emergency save id so
- * re-projecting the same dump yields the same {@link CheckpointId}.
- *
- * ## The cost projection says "unknown", not "zero"
- *
- * `costInfo` used to default to `{ ...ZERO_COST }` beside a `tokenUsage` the
- * dump preserves faithfully — a run that had spent real money coming back as
- * one that had spent nothing. That is the same lie the price catalogue was
- * added to end, arriving through the restore path instead of the accumulation
- * one, and it took `runConfig.costLimitUsd` back to being enforced against a
- * zero with it.
- *
- * It also broke the accumulator downstream. `accumulateCost` decides whether
- * one rate card describes the whole total by asking whether the total is
- * FRESH — zero cost, zero unpriced tokens, no rates — and `ZERO_COST` is
- * exactly that shape. So the first turn after such a resume adopted its own
- * rate card as covering the pre-crash spend too, and reported a number that
- * was confidently wrong while looking like a measured one.
- *
- * Saying instead that the pre-crash tokens are UNPRICED is the true statement,
- * in the vocabulary {@link CostInfo} already has: nobody knows what they cost,
- * because nothing recorded it. It needs no marker of its own to stay correct,
- * and it is not fresh-shaped, so the accumulator does the right thing without
- * being told about this path at all.
- *
- * See ses_005-deterministic-replay design §2 + §5.2.
+ * Every park a session log records, newest last: `decision_requested`, and
+ * whether a `decision_resolved` or `decision_expired` has answered it.
  */
-export declare function projectEmergencyToCheckpoint(dump: EmergencySaveData): IterationCheckpoint;
+export declare function readParks(log: SessionLog, options?: {
+    readonly turnId?: TurnId;
+}): Promise<RecordedPark[]>;
 /**
- * The newest checkpoint of a run that is still awaiting a human decision,
- * or `null` when the run is not parked.
+ * The newest park of a session (or of one of its turns) that is still
+ * awaiting a human decision, or `null` when nothing is parked.
  *
- * Standalone (not a `CheckpointManager` method) so a host can ask the
- * question without constructing a run: an approval-queue worker in a
- * different process has a store and a scope, and nothing else.
+ * Standalone so a host can ask the question without constructing a turn: an
+ * approval-queue worker in a different process has the session log and
+ * nothing else. An expired park is not outstanding.
  */
-export declare function findPendingCheckpoint(store: CheckpointStore, scope: CheckpointRunScope, options?: {
+export declare function findPendingCheckpoint(log: SessionLog, options?: {
+    readonly turnId?: TurnId;
     readonly now?: number;
-}): Promise<IterationCheckpoint | null>;
+}): Promise<RecordedPark | null>;
 /** Whether a park's absolute deadline has passed. No deadline never expires. */
 export declare function isExpiredPark(pending: PendingDecision, now?: number): boolean;
 /**
- * Every outstanding park in a run, expired ones included, so a host can
- * sweep them.
- *
- * The out-of-process timer stays a host concern — consistent with the same
- * decision made for retention — but a host cannot sweep what it cannot
- * enumerate, and this is the read that makes a sweep a few lines rather
- * than a re-implementation of the store contract.
+ * Every outstanding park of a session whose deadline has passed, so a host
+ * can sweep them (`CheckpointManager.expire`, or `decision_expired` appended
+ * under the session lease).
  */
-export declare function listExpiredParks(store: CheckpointStore, scope: CheckpointRunScope, options?: {
+export declare function listExpiredParks(log: SessionLog, options?: {
+    readonly turnId?: TurnId;
     readonly now?: number;
-}): Promise<IterationCheckpoint[]>;
+}): Promise<RecordedPark[]>;
+/**
+ * What a {@link CheckpointManager} needs of the turn it serves: the log it
+ * reads and appends to (in order with the turn's other records), and the
+ * tenant decisions are attributed under. A {@link TurnRecorder} is one.
+ */
+export type CheckpointRecords = Pick<TurnRecorder, 'log' | 'appendRecord' | 'flush' | 'tenantId'>;
+/**
+ * A turn's checkpoints: documents in the session's checkpoint store,
+ * committed by a `checkpoint_written` record, and the parks (`decision_*`
+ * records) that reference them.
+ *
+ * A checkpoint holds no messages. Its context is the fold of the session log
+ * through `throughSeq`; `restore` reads it back from the log and refuses a
+ * checkpoint whose document or covered prefix no longer matches its record.
+ */
 export declare class CheckpointManager {
-    private store;
-    private scope;
-    /**
-     * Compaction's state source, when the run has one.
-     *
-     * Every checkpoint snapshots it, so a resumed run can carry forward the
-     * state its earlier summary was built from. Without that the next
-     * compaction supersedes that summary with one covering only post-resume
-     * activity, and the record of everything before the resume is gone.
-     */
+    private readonly recorder;
+    private readonly store;
+    private readonly scope;
     private workingStateSource?;
     private latestUserMessageSource?;
     private restoredUserMessage?;
+    private restoredUserMessageId?;
     private answerReviewAttemptsSource?;
     private restoredAnswerAttempts;
     private structuredReviewAttemptsSource?;
     private restoredReviewAttempts;
     private nativeStructuredAttemptsSource?;
     private restoredNativeAttempts;
-    /**
-     * The most recent checkpoint this manager wrote, if any.
-     *
-     * A run that fails on a transient error needs to name the state a host
-     * should resume from. Re-listing the store to find it would be a disk
-     * read on the failure path, at the moment the run is least able to
-     * afford one; the id is already in hand.
-     */
     private lastCreatedId?;
-    /** See {@link setTraceSource}. */
     private traceSource?;
-    /** See {@link setParkTtl}. */
     private parkTtlMs?;
     /**
-     * The claim this run holds, presented on every checkpoint write.
-     *
-     * Unset means unfenced, which is correct for a single-writer deployment
-     * and is what every run did before claims existed. Set it and a write from
-     * a superseded holding is refused by the store.
-     *
-     * This existed nowhere for one release, and the omission was invisible in
-     * the worst way: the claim, the fence and the refusal were all built and
-     * tested, and no code path between a run and its store carried the number,
-     * so every checkpoint a RUN wrote went out unfenced. A capability that is
-     * complete except for the wire between its halves reads exactly like a
-     * working one.
+     * The turn's attribution instant, identical on every checkpoint of the
+     * turn: adopted from the checkpoint a resume came back through, or minted
+     * from the turn's own start.
      */
-    private claimFence?;
-    /**
-     * The run's attribution instant, stamped onto every checkpoint this
-     * manager writes.
-     *
-     * Settled exactly once, by whichever of two things happens first, and
-     * never reassigned — every write to it below is `??=`, and there are only
-     * two:
-     *
-     *  - `restore` ADOPTS it from the checkpoint a resume came back through.
-     *    A resumed run is the same run, and its creation is already on the
-     *    record; a fresh process minting a new one would move the key that
-     *    exists specifically because it does not move.
-     *  - `create` MINTS it from the run's own start instant when nothing was
-     *    adopted, which is the fresh-run case.
-     *
-     * Restore runs during run setup, before the first iteration and therefore
-     * before the first `create`, so the adopt always wins on the resume path
-     * without either site needing to know which path it is on.
-     */
-    private runCreatedAt?;
-    /**
-     * @param store scope-keyed checkpoint persistence. The default query
-     *   pipeline passes the run's disk-backed store
-     *   ({@link import('../../store/run/checkpoint-disk.js').DiskCheckpointStore});
-     *   hosts inject their own via `QueryParams.checkpointStore`.
-     * @param scope the run every operation of this manager is keyed to.
-     */
-    constructor(store: CheckpointStore, scope: CheckpointRunScope);
+    private turnCreatedAt?;
+    /** The turn where its iteration loop began; see {@link markLoopStart}. */
+    private loopStart?;
+    constructor(recorder: CheckpointRecords, store: SessionCheckpointStore, scope: CheckpointScope);
     /** Wire compaction's state in, so every checkpoint carries a snapshot. */
     setWorkingStateSource(source: () => WorkingStateSnapshot | undefined): void;
     /** One current intent snapshot, including checkpoints created by tool/HITL paths. */
@@ -159,125 +118,99 @@ export declare class CheckpointManager {
     get restoredNativeStructuredAttempts(): number;
     setStructuredReviewAttemptsSource(source: () => number): void;
     get restoredStructuredReviewAttempts(): number;
+    /** The turn's root span, so every checkpoint records the trace it was taken inside. */
+    setTraceSource(source: () => SerializedSpanContext | undefined): void;
+    /** Default time-to-live applied to every park this manager records. */
+    setParkTtl(ttlMs: number | undefined): void;
     /**
-     * The run's root span, so every checkpoint records the trace it was
-     * taken inside and a resume can join it rather than starting a second,
-     * unlinked one.
+     * Write a checkpoint of the turn as it stands: every queued record lands
+     * first, the document names the log's head as `throughSeq`, and a
+     * `checkpoint_written` record commits it.
      */
-    setTraceSource(source: () => SerializedSpanContext | undefined): void;
-    create(runMgr: RunPersistence, iteration: number, extra?: {
-        toolResults?: Array<{
-            toolCallId: string;
-            toolName: string;
-            input: unknown;
-            output: string;
-        }>;
-        workingState?: WorkingStateSnapshot;
-    }): Promise<IterationCheckpoint>;
-    /** See {@link lastCreatedId}. */
-    get lastCheckpointId(): CheckpointId | undefined;
+    create(recorder: TurnRecorder, iteration: number): Promise<CreatedCheckpoint>;
     /**
-     * The trace a checkpoint was taken inside, for parenting a resumed run.
-     *
-     * Read separately and BEFORE the run's root span, because a span's
-     * parent can only be set at creation and the root is minted before the
-     * restore branch runs.
-     *
-     * Never throws. Telemetry continuity is worth a disk read; it is not
-     * worth failing a resume over, and the restore path immediately after
-     * will report a genuinely unreadable checkpoint far better than a
-     * tracing helper could.
+     * Remember the turn as it stands where its iteration loop begins, before
+     * the loop's first provider request. Nothing is written: the state is
+     * only committed, by {@link createAtLoopStart}, when the turn has to
+     * pause before it wrote a checkpoint of its own.
      */
-    readTraceContext(checkpointId: CheckpointId): Promise<SerializedSpanContext | undefined>;
+    markLoopStart(recorder: TurnRecorder): Promise<void>;
     /**
-     * Record that the run parked at `checkpoint` awaiting a human, and
-     * return the updated checkpoint.
-     *
-     * A park used to exist only as a suspended `await`: the checkpoint
-     * written just before it was indistinguishable from any mid-run
-     * checkpoint, so a host could not tell from durable state that a
-     * decision was outstanding — and a process boundary lost the request
-     * entirely. Writing the request down is what lets an approval queue be
-     * rebuilt, and what lets a resumed run apply the answer to the exact
-     * tool calls the human saw.
-     *
-     * Called after `create` rather than as an argument to it because the
-     * request carries the checkpoint's own id.
+     * A checkpoint of the turn as {@link markLoopStart} found it, so a turn
+     * that fails recoverably before any checkpoint of its own has something
+     * to pause on and resume from. It covers the log only through the loop's
+     * start and counts none of the guards used since, so resuming from it
+     * discards every iteration the turn ran before the fault, completed ones
+     * included (a `max_tokens` continuation request opens a new iteration).
+     * Its iteration is the one the loop began at: 0 for a fresh
+     * turn, the restored count for a resumed one. `undefined` when no loop
+     * start was marked.
      */
-    park(checkpoint: IterationCheckpoint, request: HITLDecisionRequest, options?: {
-        readonly ttlMs?: number;
-    }): Promise<IterationCheckpoint>;
+    createAtLoopStart(recorder: TurnRecorder): Promise<CreatedCheckpoint | undefined>;
+    /** The part of a checkpoint document that describes the turn at one instant. */
+    private captureState;
+    private write;
     /**
-     * Present this claim on every subsequent write. See {@link claimFence}.
-     *
-     * A setter rather than a constructor argument because a run is claimed at
-     * a different moment than it is constructed — a worker draining a queue
-     * takes the run, then builds the pipeline around it — and because a
-     * renewal mints a NEW fence mid-run that has to replace the old one.
+     * The id of the record that carries a message's text: its own record,
+     * or — for operator guidance delivered attached to a tool result — the
+     * record of the tool result that carries it.
      */
-    setClaimFence(fence: FencingToken | undefined): void;
-    /** The claim currently presented on writes, if any. */
-    get presentedFence(): FencingToken | undefined;
-    /** Default time-to-live applied to every park this manager records. */
-    setParkTtl(ttlMs: number | undefined): void;
+    private messageIdOf;
+    /** Found once and kept: a compaction may later drop the carrier from the context. */
+    private readonly steeringCarriers;
+    private steeringCarrierOf;
+    /** The most recent checkpoint this manager wrote, if any. */
+    get lastCheckpointId(): CheckpointId | undefined;
     /**
-     * Mark an expired park as no longer outstanding.
-     *
-     * Recorded rather than deleted: the checkpoint showing what was asked
-     * and that nobody answered in time is the evidence an approval gate is
-     * worth having, and the same reasoning already keeps a resolved
-     * decision on the record.
+     * The trace a checkpoint was taken inside, for parenting a resumed turn.
+     * Never throws: telemetry continuity is not worth failing a resume over.
      */
-    expire(checkpointId: CheckpointId): Promise<IterationCheckpoint | null>;
+    readTraceContext(checkpointId: CheckpointId): Promise<SerializedSpanContext | undefined>;
     /**
-     * Record the answer, so an outstanding park stops looking outstanding.
-     *
-     * The decision is kept rather than erased: a checkpoint that shows both
-     * what was asked and what was answered is the evidence trail an
-     * approval gate is worth having. A no-op when the checkpoint is gone
-     * (pruned) or was never parked.
+     * Record that the turn parked at `checkpoint` awaiting a human: a
+     * `decision_requested` record naming the checkpoint, with an absolute
+     * deadline when the turn has a park time-to-live.
      */
-    unpark(checkpointId: CheckpointId, decision: HITLResumeDecision): Promise<IterationCheckpoint | null>;
+    park(checkpoint: {
+        readonly id: CheckpointId;
+    }, request: HITLDecisionRequest, options?: {
+        readonly ttlMs?: number;
+    }): Promise<PendingDecision>;
     /**
-     * The run's outstanding park, if it has one — the newest checkpoint
-     * whose `pending` has no `resolvedAt`.
-     *
-     * This is the read a host's approval queue is built from, and it works
-     * across a process boundary because it consults the store rather than
-     * in-memory state.
+     * Mark an expired park as no longer outstanding: `decision_expired`. The
+     * request stays in the log as evidence of what was asked.
      */
-    findPending(): Promise<IterationCheckpoint | null>;
-    restore(checkpointId: CheckpointId): Promise<IterationCheckpoint>;
-    list(): Promise<IterationCheckpoint[]>;
+    expire(checkpointId: CheckpointId): Promise<RecordedPark | null>;
     /**
-     * Listing projection used by the public `listCheckpoints` API. Returns
-     * only the fields a consumer needs to pick a fork point for
-     * {@link import('./replay/prepare.js').prepareReplayState} — not the
-     * full checkpoint payload. See ses_005-deterministic-replay design §3.1.
+     * Record the answer, so an outstanding park stops looking outstanding:
+     * `decision_resolved`. A no-op when the checkpoint was never parked or the
+     * park is already answered.
      */
+    unpark(checkpointId: CheckpointId, decision: HITLResumeDecision): Promise<RecordedPark | null>;
+    private openPark;
+    /** The turn's outstanding park, if it has one. */
+    findPending(): Promise<RecordedPark | null>;
+    /**
+     * Read a checkpoint back for a resume. Refused when it is missing, when
+     * its document no longer matches its record, or when the log prefix it
+     * covers changed.
+     */
+    restore(checkpointId: CheckpointId): Promise<RestoredCheckpoint>;
+    /** The turn's checkpoint documents, oldest first. */
+    list(): Promise<Checkpoint[]>;
+    /** Listing projection used by the public `listCheckpoints` API. */
     listEntries(): Promise<CheckpointListEntry[]>;
     /**
-     * Collect old checkpoints until `keepLast` newer ones remain.
-     *
-     * Growth control, and growth control stops at a park. A checkpoint with
-     * an unresolved `pending` is the durable fact that a human was asked
-     * something: it is what `findPendingCheckpoint` serves to an approval
-     * queue and what `listExpiredParks` enumerates for a sweep. Collecting
-     * one deletes the only record of a question somebody may be in the middle
-     * of answering, and their answer then lands nowhere — the store refuses
-     * the unpark and the run it belonged to resumes without it.
-     *
-     * So the candidates are still the oldest `all.length - keepLast`, which
-     * is what keeps the newest `keepLast` — the run's resume point — out of
-     * reach, and a park among them is skipped rather than counted. Pruning
-     * therefore holds a few more rows while a park is outstanding. That is
-     * the right side to err on: parks resolve, and the next prune collects
-     * them. Expired ones are skipped too — the host's sweep is
-     * {@link expire}, which resolves the park by running out of time rather
-     * than by deleting the evidence, and `prune` racing it would take the
-     * question away before it was read.
+     * Collect old checkpoints until `keepLast` newer ones remain, never one an
+     * open decision references; a `checkpoint_pruned` record names what went.
      */
     prune(keepLast: number): Promise<void>;
-    static buildSummary(runMgr: RunPersistence, iteration: number): CheckpointSummary;
+    static buildSummary(recorder: TurnRecorder, iteration: number): CheckpointSummary;
 }
+/**
+ * The context a checkpoint restores: the fold of its session log through
+ * `throughSeq`, the decision it is parked on, and the operator intent it
+ * names.
+ */
+export declare function restoreCheckpointContext(log: SessionLog, document: Checkpoint): Promise<RestoredCheckpoint>;
 //# sourceMappingURL=checkpoint.d.ts.map

package/dist/runtime/query/checkpoint.d.ts.map

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