@latysh-development/monolith 0.0.0-stage → 0.1.0-alpha.1

package/dist/durable/seams.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Test seams of the stores. INTERNAL: nothing here is exported from the package entry point (`index.ts`), and the public
+ * constructors never read these fields from their options. A store takes its seams from a one-shot hand-over slot that
+ * only `testing.ts` fills, immediately before it calls the constructor. The package `exports` map exposes `.` alone, so
+ * `testing.ts` cannot be imported from outside the package. This is API hygiene, not a security boundary: code running
+ * inside the process can reach anything the process can.
+ */
+import type { FsOps } from '../root/index.js';
+import type { TaskEvent } from './types.js';
+export interface FsStoreSeams {
+    /** fault injection for the write primitive. */
+    ops?: Partial<FsOps>;
+    /** called between the pre-publish checks and the publication of an event. */
+    beforePublish?: (event: TaskEvent) => void | Promise<void>;
+    /** called in `readLog` right after the directory listings, before any file is read. */
+    afterListing?: (attempt: number) => void;
+    /** Design A G1 (section 24.6): refuse early on a pruned or corrupt task before publishing. Default `true`. Safety does not depend on it. */
+    earlyPruneCheck?: boolean;
+    /** lowers `MAX_PRUNE_ATTEMPTS` so a test need not write a thousand attempts. */
+    maxPruneAttempts?: number;
+    /** returns a different (e.g. incomplete) listing of a task directory for the register: listings are not atomic (A7). */
+    registerListing?: (taskId: string, names: string[]) => string[];
+    /**
+     * Register-protocol tests only: skip the F-1 precondition of an irreversible prune, to exercise the register (G2, first
+     * writer wins) over logs that are not prunable. Never a production setting.
+     */
+    skipPrunePrecondition?: boolean;
+    /** replaces `fs.unlinkSync` in the roll-forward of a committed prune, to stop it after a chosen number of removals. */
+    removeFile?: (abs: string) => void;
+    /** called by the audit of a committed prune: `listed` after the loose events were listed (nothing read yet, segments not yet listed), `surveyed` after it was read, before `tombstone.json` is. */
+    auditHook?: (point: 'listed' | 'surveyed') => void;
+    /** simulate an I/O error on reading a file of the store: return an errno code (`'EIO'`) to fail with, or nothing. */
+    readFault?: (abs: string) => string | null | undefined;
+}
+export interface MemoryStoreSeams {
+    /** lowers `MAX_PRUNE_ATTEMPTS` so a test need not write a thousand attempts. */
+    maxPruneAttempts?: number;
+}
+/** Fills the slot for the next constructor call. Used by `testing.ts` only. */
+export declare function handOver(kind: 'fs', seams: FsStoreSeams): void;
+export declare function handOver(kind: 'memory', seams: MemoryStoreSeams): void;
+export declare function takeFsSeams(): FsStoreSeams;
+export declare function takeMemorySeams(): MemoryStoreSeams;
+//# sourceMappingURL=seams.d.ts.map

package/dist/durable/seams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seams.d.ts","sourceRoot":"","sources":["../../src/durable/seams.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,GAAG,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACrB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,uFAAuF;IACvF,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,4IAA4I;IAC5I,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wHAAwH;IACxH,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IAChE;;;OAGG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,uHAAuH;IACvH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,mMAAmM;IACnM,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,KAAK,IAAI,CAAC;IACnD,qHAAqH;IACrH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACxD;AAED,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;AAChE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;AAKxE,wBAAgB,WAAW,IAAI,YAAY,CAI1C;AAED,wBAAgB,eAAe,IAAI,gBAAgB,CAIlD"}

package/dist/durable/seams.js

@@ -0,0 +1,21 @@
+/**
+ * Test seams of the stores. INTERNAL: nothing here is exported from the package entry point (`index.ts`), and the public
+ * constructors never read these fields from their options. A store takes its seams from a one-shot hand-over slot that
+ * only `testing.ts` fills, immediately before it calls the constructor. The package `exports` map exposes `.` alone, so
+ * `testing.ts` cannot be imported from outside the package. This is API hygiene, not a security boundary: code running
+ * inside the process can reach anything the process can.
+ */
+const slot = { fs: null, memory: null };
+export function handOver(kind, seams) {
+    slot[kind] = seams;
+}
+export function takeFsSeams() {
+    const s = slot.fs ?? {};
+    slot.fs = null;
+    return s;
+}
+export function takeMemorySeams() {
+    const s = slot.memory ?? {};
+    slot.memory = null;
+    return s;
+}

package/dist/durable/testing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Stores with test seams. INTERNAL: not exported from `index.ts`, so not part of the published API (see `seams.ts`).
+ */
+import { FsEventStore, type FsStoreOptions } from './fs-store.js';
+import { MemoryEventStore } from './memory-store.js';
+import { type FsStoreSeams, type MemoryStoreSeams } from './seams.js';
+export type { FsStoreSeams, MemoryStoreSeams };
+export type FsStoreInternalOptions = FsStoreOptions & FsStoreSeams;
+export declare function createFsStoreWithSeams(opts: FsStoreInternalOptions): FsEventStore;
+export declare function createMemoryStoreWithSeams(seams?: MemoryStoreSeams): MemoryEventStore;
+//# sourceMappingURL=testing.d.ts.map

package/dist/durable/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../src/durable/testing.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAA0C,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9G,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG,YAAY,CAAC;AAEnE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,sBAAsB,GAAG,YAAY,CAQjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,GAAE,gBAAqB,GAAG,gBAAgB,CAOzF"}

package/dist/durable/testing.js

@@ -0,0 +1,25 @@
+/**
+ * Stores with test seams. INTERNAL: not exported from `index.ts`, so not part of the published API (see `seams.ts`).
+ */
+import { FsEventStore } from './fs-store.js';
+import { MemoryEventStore } from './memory-store.js';
+import { handOver, takeFsSeams, takeMemorySeams } from './seams.js';
+export function createFsStoreWithSeams(opts) {
+    const { ops, beforePublish, afterListing, earlyPruneCheck, maxPruneAttempts, registerListing, skipPrunePrecondition, readFault, removeFile, auditHook, ...pub } = opts;
+    handOver('fs', { ops, beforePublish, afterListing, earlyPruneCheck, maxPruneAttempts, registerListing, skipPrunePrecondition, readFault, removeFile, auditHook });
+    try {
+        return new FsEventStore(pub);
+    }
+    finally {
+        takeFsSeams(); // an unused hand-over never leaks into the next constructor call
+    }
+}
+export function createMemoryStoreWithSeams(seams = {}) {
+    handOver('memory', seams);
+    try {
+        return new MemoryEventStore();
+    }
+    finally {
+        takeMemorySeams();
+    }
+}

package/dist/durable/types.d.ts

@@ -0,0 +1,442 @@
+/**
+ * Durable State — event and state types.
+ *
+ * The source of truth of a task is its append-only, hash-chained event log.
+ * `TaskState` is a pure fold of that log (projection.ts); it is never stored
+ * as authority and can always be rebuilt. Nothing here knows about SphynX, an
+ * LLM, or any business domain: `kind`, `goal`, `input`, payloads and results
+ * are opaque application data.
+ */
+import type { Json } from './canonical.js';
+export type { Json };
+/** Bumped only for an incompatible change of the envelope. Readers refuse unknown versions. */
+export declare const EVENT_FORMAT_VERSION = 1;
+/** `prev` of the first event of every task. */
+export declare const GENESIS_HASH: string;
+export interface Evidence {
+    /** Opaque reference: a URL, a document id, an event id of another system. */
+    ref: string;
+    note: string | null;
+}
+export interface PlanStepDecl {
+    id: string;
+    title: string;
+    dependsOn: string[];
+}
+export type Criticality = 'blocking' | 'advisory';
+/** Payload of every event type. The keys are the closed set of event types of format v1. */
+export interface EventDataMap {
+    'task.created': {
+        kind: string;
+        goal: string;
+        input: Json | null;
+        parentTaskId: string | null;
+        dependsOn: string[];
+        labels: Record<string, string>;
+    };
+    'run.claimed': {
+        owner: string;
+        epoch: number;
+        leaseUntil: string;
+        takeover: boolean;
+    };
+    'run.heartbeat': {
+        owner: string;
+        epoch: number;
+        leaseUntil: string;
+    };
+    'run.released': {
+        owner: string;
+        epoch: number;
+    };
+    'plan.declared': {
+        steps: PlanStepDecl[];
+        reason: string | null;
+    };
+    'plan.step_done': {
+        stepId: string;
+        result: Json | null;
+    };
+    'plan.step_skipped': {
+        stepId: string;
+        reason: string;
+    };
+    'decision.recorded': {
+        id: string;
+        summary: string;
+        rationale: string | null;
+        basedOn: string[];
+    };
+    'assumption.recorded': {
+        key: string;
+        statement: string;
+        criticality: Criticality;
+        fingerprint: string;
+        value: Json | null;
+        evidence: Evidence[];
+    };
+    'assumption.retracted': {
+        key: string;
+        reason: string;
+    };
+    'fact.observed': {
+        key: string;
+        fingerprint: string;
+        value: Json | null;
+        source: string | null;
+    };
+    'effect.intended': {
+        key: string;
+        description: string;
+        params: Json | null;
+        epoch: number | null;
+    };
+    'effect.completed': {
+        key: string;
+        result: Json | null;
+    };
+    /**
+     * `uncertain: true` — the call threw, but the exception does not prove the external operation did not happen
+     * (a timeout after the request was sent). Recorded together with `retryable: false`, so a reader that predates
+     * the field also refuses to run it again. Absent (older logs) means a certain failure, as before.
+     */
+    'effect.failed': {
+        key: string;
+        error: string;
+        retryable: boolean;
+        uncertain?: boolean;
+    };
+    'await.registered': {
+        awaitId: string;
+        token: string;
+        purpose: string;
+        stepId: string | null;
+        request: Json | null;
+        deadlineAt: string | null;
+        /** Head of the log when the request was sent: the state "at send" is `foldUntil(basisSeq)`. */
+        basisSeq: number;
+    };
+    'await.resolved': {
+        awaitId: string;
+        idempotencyKey: string;
+        payload: Json;
+        source: string | null;
+        late: boolean;
+    };
+    'await.delivery_rejected': {
+        awaitId: string;
+        idempotencyKey: string;
+        reason: 'already-resolved';
+        payload: Json;
+    };
+    'await.expired': {
+        awaitId: string;
+    };
+    'task.completed': {
+        result: Json | null;
+    };
+    'task.failed': {
+        error: string;
+        detail: Json | null;
+    };
+    'task.cancelled': {
+        reason: string;
+    };
+}
+export type EventType = keyof EventDataMap;
+export declare const EVENT_TYPES: readonly EventType[];
+/**
+ * Events whose `'adopted'` append result counts as success (Amendment-004G, section 2.11 / 8.2). A closed list: none of
+ * these confers the right to an irreversible action, that right comes from another event won through the CAS.
+ * Everything not named here (the rights-bearing `task.created`, `run.claimed`, `effect.intended`, `await.resolved`,
+ * and any type added later) is deny-by-default: `'adopted'` is treated like `'conflict'`.
+ */
+export declare const ADOPTED_IS_SUCCESS_EVENT_TYPES: readonly EventType[];
+/** True only for a type named in the closed list; an unknown string is false (fail closed). */
+export declare function adoptedIsSuccess(type: string): boolean;
+export declare const TERMINAL_EVENT_TYPES: readonly EventType[];
+export type EventOf<T extends EventType> = {
+    v: typeof EVENT_FORMAT_VERSION;
+    taskId: string;
+    seq: number;
+    at: string;
+    type: T;
+    actor: string | null;
+    data: EventDataMap[T];
+    prev: string;
+    hash: string;
+};
+/** A stored event. Distributes over the type so `switch (e.type)` narrows `e.data`. */
+export type TaskEvent = {
+    [T in EventType]: EventOf<T>;
+}[EventType];
+/** What a caller proposes; the runtime stamps `seq`, `at`, `prev`, `hash`. */
+export type EventDraft = {
+    [T in EventType]: {
+        type: T;
+        actor: string | null;
+        data: EventDataMap[T];
+    };
+}[EventType];
+export type TaskStatus = 'active' | 'completed' | 'failed' | 'cancelled';
+export interface PlanStepState {
+    id: string;
+    title: string;
+    dependsOn: string[];
+    status: 'pending' | 'done' | 'skipped';
+    result: Json | null;
+    skipReason: string | null;
+    closedAtSeq: number | null;
+}
+export interface DecisionState {
+    id: string;
+    seq: number;
+    at: string;
+    summary: string;
+    rationale: string | null;
+    basedOn: string[];
+}
+export interface AssumptionState {
+    key: string;
+    statement: string;
+    criticality: Criticality;
+    fingerprint: string;
+    value: Json | null;
+    evidence: Evidence[];
+    status: 'active' | 'retracted';
+    recordedAtSeq: number;
+    retractedReason: string | null;
+}
+export interface ObservationState {
+    key: string;
+    fingerprint: string;
+    value: Json | null;
+    source: string | null;
+    seq: number;
+    at: string;
+}
+export interface EffectState {
+    key: string;
+    description: string;
+    params: Json | null;
+    status: 'intended' | 'completed' | 'failed';
+    intendedAtSeq: number;
+    intendedEpoch: number | null;
+    result: Json | null;
+    error: string | null;
+    retryable: boolean;
+    /**
+     * The last attempt threw and it is not known whether the external operation took effect. Such an effect is in
+     * doubt: it is neither run again nor treated as done until `reconcile` (or an operator) settles it.
+     */
+    uncertain: boolean;
+}
+export interface AwaitState {
+    awaitId: string;
+    token: string;
+    purpose: string;
+    stepId: string | null;
+    request: Json | null;
+    deadlineAt: string | null;
+    basisSeq: number;
+    registeredAtSeq: number;
+    status: 'pending' | 'resolved' | 'expired';
+    resolvedAtSeq: number | null;
+    payload: Json | null;
+    idempotencyKey: string | null;
+    source: string | null;
+    late: boolean;
+    rejectedDeliveries: number;
+}
+export interface LeaseState {
+    owner: string;
+    epoch: number;
+    leaseUntil: string;
+    released: boolean;
+}
+export interface TaskState {
+    taskId: string;
+    kind: string;
+    goal: string;
+    input: Json | null;
+    parentTaskId: string | null;
+    dependsOn: string[];
+    labels: Record<string, string>;
+    status: TaskStatus;
+    createdAt: string;
+    updatedAt: string;
+    closedAt: string | null;
+    result: Json | null;
+    error: string | null;
+    headSeq: number;
+    headHash: string;
+    /** Highest epoch ever issued (fencing counter). */
+    epoch: number;
+    lease: LeaseState | null;
+    plan: PlanStepState[] | null;
+    decisions: DecisionState[];
+    assumptions: Record<string, AssumptionState>;
+    observations: Record<string, ObservationState>;
+    effects: Record<string, EffectState>;
+    awaits: Record<string, AwaitState>;
+    /** `awaitId:idempotencyKey` -> seq of the delivery that carried it (duplicate suppression, scoped per await). */
+    deliveryKeys: Record<string, number>;
+    eventCount: number;
+}
+export declare function isTerminal(status: TaskStatus): boolean;
+export interface Tombstone {
+    v: 1;
+    taskId: string;
+    kind: string;
+    finalStatus: TaskStatus;
+    createdAt: string;
+    closedAt: string;
+    prunedAt: string;
+    headSeq: number;
+    headHash: string;
+    /** sha256 of the canonical final result/error, so "what did it return" can be audited without keeping the data. */
+    outcomeDigest: string;
+}
+export interface StoreDiagnostic {
+    code: 'LOOSE_COPY_OF_COMPACTED_EVENT' | 'STAGING_RESIDUE_REPAIRED' | 'STAGING_FILE_PRESENT' | 'UNKNOWN_ENTRY'
+    /** A tombstone exists but event/segment files of the pruned task are still on disk: an interrupted prune. */
+     | 'PRUNE_INCOMPLETE'
+    /** The prune decision register has an artifact that is not part of its grammar (an operator's `.bak`, say). */
+     | 'UNKNOWN_PRUNE_ARTIFACT';
+    taskId: string;
+    name: string;
+}
+export interface LogRead {
+    /** False when the task directory does not exist and no tombstone is present. */
+    exists: boolean;
+    /**
+     * Set when the task is pruned (`committed`), AND — for consumers written against the pre-register protocol — while a
+     * prune attempt is open (`preparing`): they treat "tombstone visible, data intact" as a prune that is not settled.
+     * `prune.kind` tells the two apart.
+     */
+    tombstone: Tombstone | null;
+    /** The observed prune state when it is anything but `live`. Informational; the register is the authority. */
+    prune?: PruneState;
+    /** Verified-contiguous in seq, ascending, `seq > afterSeq`. Hash chain is verified by the caller. */
+    events: TaskEvent[];
+    /** Highest seq already packed into immutable segments (0 if none). Informational; used to plan compaction. */
+    compactedThrough: number;
+    diagnostics: StoreDiagnostic[];
+}
+export interface CompactionResult {
+    segment: string | null;
+    packedEvents: number;
+    removedFiles: number;
+}
+/** Number of prune attempts a task may ever use. A liveness limit; attempt numbers are never reused or reset. */
+export declare const MAX_PRUNE_ATTEMPTS = 1000;
+export type PruneOutcome = 'commit' | 'abort';
+/** Who published an `abort`. Diagnostic only; it never changes the semantics of the decision. */
+export type DecisionBy = 'pruner' | 'child' | 'creator' | 'claim' | 'append' | 'compact' | 'pin';
+export type PruneStateKind = 'live' | 'preparing' | 'committed' | 'missing' | 'corrupt' | 'unreadable' | 'legacy';
+/**
+ * What the register says about a task, derived from the names and contents of its directory (Design A, section 20.2).
+ * Nothing here is persisted and nothing is written by computing it. `corrupt`, `unreadable`, `missing` and `legacy`
+ * never grant the right to an irreversible action.
+ */
+export interface PruneState {
+    kind: PruneStateKind;
+    /** `preparing` / `committed`: the attempt number. `live`: the highest attempt number seen (0 if none). */
+    attempt?: number;
+    /** `preparing` / `committed`: the tombstone of the attempt. `legacy`: the legacy tombstone. */
+    tombstone?: Tombstone;
+    /** `corrupt`: the finding; `unreadable`: what could not be read or confirmed. */
+    reason?: string;
+    /** `corrupt` / `legacy`: whether the finding rests on present files (`present`) or on confirmed absence (`lookup`). */
+    basis?: 'present' | 'lookup';
+    /** `corrupt`: the register file the finding is about, if any. */
+    file?: string;
+    /** `committed`: files of the pruned task that are still on disk (`> 0` means deleting, `0` means gone). Not monotonic. */
+    residue?: number;
+    /** `committed`: the commit was written by the legacy migration procedure. */
+    migrated?: boolean;
+    /** Findings that do not change the verdict (`UNKNOWN_PRUNE:<name>`). */
+    anomalies?: string[];
+    /** `committed`. Mode A only: the commit is visible to every process, but survival of an OS crash is NOT guaranteed. */
+    durability?: 'NOT_GUARANTEED';
+}
+/** Result of `EventStore.append` (Amendment-004G, CEI-6). Only `'appended'` carries the right of the slot's winner. */
+export type AppendOutcome = 'appended' | 'adopted' | 'conflict';
+/**
+ * The persistence contract. A backend must provide ONE linearizable primitive:
+ * `append` publishes an event at `event.seq` if and only if that slot is free,
+ * atomically, and reports `'conflict'` otherwise. Everything else (locking-free
+ * concurrency, idempotency, fencing, integrity) is built on it above this line,
+ * so a SQL/KV backend can implement it with a unique key.
+ */
+export interface EventStore {
+    /**
+     * `rawEvents`: return the events of a task whose prune attempt is open (`prune.kind === 'preparing'`) instead of
+     * hiding them behind the transitional tombstone. A pruner needs the head of the log AFTER its `prepare` is visible.
+     */
+    readLog(taskId: string, opts?: {
+        afterSeq?: number;
+        rawEvents?: boolean;
+    }): Promise<LogRead>;
+    /**
+     * Amendment-004G. `'appended'`: this call created the first file of the slot and the canonical content is the event
+     * (the right derived from winning the slot). `'adopted'`: the canonical content equals the event, but this call cannot
+     * prove it created the slot (EEXIST, evidence through a segment, a retry). `'conflict'`: the slot holds another event.
+     */
+    append(event: TaskEvent): Promise<AppendOutcome>;
+    listTaskIds(): Promise<string[]>;
+    /** Pack verified events `1..throughSeq` into immutable storage, then drop the loose copies. Idempotent. */
+    compact(taskId: string, throughSeq: number, events: TaskEvent[]): Promise<CompactionResult>;
+    /**
+     * Low-level prune, always through the decision register: make sure there is a `commit` for the tombstone (publishing
+     * the attempt and the commit itself when there is none and `requireCommit` is not set — this form does NOT look for
+     * referrers), publish `tombstone.json` from the commit, then remove the task's data. Idempotent: a second call
+     * finishes an interrupted one. With `requireCommit` it refuses unless a verified `commit` already exists.
+     */
+    prune(tombstone: Tombstone, opts?: {
+        requireCommit?: boolean;
+    }): Promise<{
+        removedFiles: number;
+    }>;
+    /**
+     * Optional. Finish an interrupted compaction: remove loose event copies that a verified segment already covers.
+     * A copy is removed only if it is byte-identical to the event in the segment; anything else is kept (`keptFiles`)
+     * because it cannot be proven redundant. Idempotent; safe to run concurrently with readers, writers and itself.
+     */
+    sweepCompacted?(taskId: string): Promise<{
+        removedFiles: number;
+        keptFiles: number;
+    }>;
+    /** Record that `childId` is being created with a reference to `parentId`. Create-only and idempotent. */
+    pinReference?(parentId: string, childId: string, at: string): Promise<'pinned' | 'parent-pruned' | 'parent-missing'>;
+    /** The references recorded by `pinReference` (pins stay until the parent is pruned). */
+    listReferences?(parentId: string): Promise<Array<{
+        childId: string;
+        at: string;
+    }>>;
+    /** Adapter of the pre-register protocol: open a prune attempt (`preparePrune`), remove nothing. Idempotent. */
+    markPruned?(tombstone: Tombstone): Promise<void>;
+    /**
+     * Adapter of the pre-register protocol: `decidePrune(abort)` for the open attempt. Throws `TombstoneCommittedError`
+     * when the register says `commit`: a committed prune cannot be taken back.
+     */
+    withdrawTombstone?(tombstone: Tombstone): Promise<void>;
+    /**
+     * Publish the next attempt (`prune-<n>.prepare.json`, create-only) for a task in state `live`, or accept the attempt
+     * that is already open (`preparing`). `n = 1 + the highest attempt ever seen`; numbers are never reused. Refuses
+     * (`PruneAttemptLimitError`) when `n > MAX_PRUNE_ATTEMPTS`, and in every other state.
+     */
+    preparePrune?(tombstone: Tombstone): Promise<{
+        attempt: number;
+        created: boolean;
+    }>;
+    /**
+     * Publish the decision of an attempt (create-only, first writer wins) and return the VALUE OF THE REGISTER, which is
+     * not necessarily the value asked for. Only for an attempt whose valid `prepare` is visible. A `commit` must carry the
+     * tombstone of the attempt. It never deletes or rewrites a decision.
+     */
+    decidePrune?(taskId: string, attempt: number, outcome: PruneOutcome, tombstone?: Tombstone, by?: DecisionBy): Promise<PruneOutcome>;
+    /** Derive the state of the register (Design A, section 20.2). Read-only; never repairs and never deletes. */
+    pruneState?(taskId: string): Promise<PruneState>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/durable/types.d.ts.map

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

package/dist/durable/types.js

@@ -0,0 +1,75 @@
+/**
+ * Durable State — event and state types.
+ *
+ * The source of truth of a task is its append-only, hash-chained event log.
+ * `TaskState` is a pure fold of that log (projection.ts); it is never stored
+ * as authority and can always be rebuilt. Nothing here knows about SphynX, an
+ * LLM, or any business domain: `kind`, `goal`, `input`, payloads and results
+ * are opaque application data.
+ */
+/** Bumped only for an incompatible change of the envelope. Readers refuse unknown versions. */
+export const EVENT_FORMAT_VERSION = 1;
+/** `prev` of the first event of every task. */
+export const GENESIS_HASH = '0'.repeat(64);
+export const EVENT_TYPES = [
+    'task.created',
+    'run.claimed',
+    'run.heartbeat',
+    'run.released',
+    'plan.declared',
+    'plan.step_done',
+    'plan.step_skipped',
+    'decision.recorded',
+    'assumption.recorded',
+    'assumption.retracted',
+    'fact.observed',
+    'effect.intended',
+    'effect.completed',
+    'effect.failed',
+    'await.registered',
+    'await.resolved',
+    'await.delivery_rejected',
+    'await.expired',
+    'task.completed',
+    'task.failed',
+    'task.cancelled',
+];
+/**
+ * Events whose `'adopted'` append result counts as success (Amendment-004G, section 2.11 / 8.2). A closed list: none of
+ * these confers the right to an irreversible action, that right comes from another event won through the CAS.
+ * Everything not named here (the rights-bearing `task.created`, `run.claimed`, `effect.intended`, `await.resolved`,
+ * and any type added later) is deny-by-default: `'adopted'` is treated like `'conflict'`.
+ */
+export const ADOPTED_IS_SUCCESS_EVENT_TYPES = [
+    'effect.completed',
+    'effect.failed',
+    'task.completed',
+    'task.failed',
+    'task.cancelled',
+    'plan.declared',
+    'plan.step_done',
+    'plan.step_skipped',
+    'decision.recorded',
+    'assumption.recorded',
+    'assumption.retracted',
+    'fact.observed',
+    'run.heartbeat',
+    'run.released',
+    'await.registered',
+    'await.expired',
+    'await.delivery_rejected',
+];
+const ADOPTED_IS_SUCCESS = new Set(ADOPTED_IS_SUCCESS_EVENT_TYPES);
+/** True only for a type named in the closed list; an unknown string is false (fail closed). */
+export function adoptedIsSuccess(type) {
+    return ADOPTED_IS_SUCCESS.has(type);
+}
+export const TERMINAL_EVENT_TYPES = ['task.completed', 'task.failed', 'task.cancelled'];
+export function isTerminal(status) {
+    return status !== 'active';
+}
+// ---------------------------------------------------------------------------
+// Prune decision register (ADR-019, Design A)
+// ---------------------------------------------------------------------------
+/** Number of prune attempts a task may ever use. A liveness limit; attempt numbers are never reused or reset. */
+export const MAX_PRUNE_ATTEMPTS = 1000;

package/dist/graph/builder.d.ts

@@ -0,0 +1,11 @@
+import type { ScriptoriumResult } from '../scriptorium/types.js';
+import type { ExplicitRelationshipGraph } from './types.js';
+/**
+ * Builds the explicit relationship graph.
+ *
+ * Nodes are KnowledgeObjects declared by Scriptorium (document `id:` and `{#ID}` sections).
+ * Concepts are not nodes. An edge exists only when its target resolves (RESOLVED) from a
+ * source that itself has a unique canonical identity. Output is independent of input order.
+ */
+export declare function buildGraph(results: ScriptoriumResult[]): ExplicitRelationshipGraph;
+//# sourceMappingURL=builder.d.ts.map

package/dist/graph/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/graph/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EACV,yBAAyB,EAK1B,MAAM,YAAY,CAAC;AAKpB;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,yBAAyB,CAiKlF"}