@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/knowledge/case-errors.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Case errors.
+ *
+ * `CaseMergeChainCycleError` used to live in `entities/errors.ts` and extend
+ * that module's `EntityError`. Nothing about a cycle in `case_truth` belongs to
+ * the entity substrate; it sat there because the two subsystems were written
+ * together. It carries its own shape now.
+ *
+ * @module cases/errors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseMergeChainCycleError = void 0;
+class CaseMergeChainCycleError extends Error {
+    code = 'case.merge_chain_cycle';
+    doc_section = '#case-merge-chain-cycle';
+    context;
+    hint;
+    constructor(context) {
+        super(`Case merge chain cycle detected at depth ${context.detected_at_depth} starting from case_id=${context.case_id}. Chain=${context.chain.join(' -> ')}.`);
+        this.name = new.target.name;
+        this.context = context;
+        this.hint = 'Inspect case_truth.canonical_case_id links and remove the cycle before retrying.';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, new.target);
+        }
+    }
+    toErrorEnvelope() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                hint: this.hint,
+                doc_url: `docs/guides/troubleshooting.md${this.doc_section}`,
+            },
+        };
+    }
+}
+exports.CaseMergeChainCycleError = CaseMergeChainCycleError;
+//# sourceMappingURL=case-errors.js.map

package/dist/{cases/search-rollup.d.ts → knowledge/case-search-rollup.d.ts}

@@ -1,5 +1,6 @@
-import type { AdapterLike } from './wiki-page-index.js';
-import type { SearchHitDiagnostics } from '../search/search-quality.js';
+import type { DatabaseAdapter } from '../db-manager.js';
+type AdapterLike = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+import type { SearchHitDiagnostics } from '../knowledge/search-quality.js';
 export type { AdapterLike };
 export interface SearchRollupLeafHit {
     source_type: 'decision' | 'checkpoint' | 'wiki_page' | 'connector_event';
@@ -11,7 +12,7 @@ export interface SearchRollupLeafHit {
     retrieval_diagnostics?: SearchHitDiagnostics;
 }
 export interface SearchRollupResult {
-    source_type: 'decision' | 'checkpoint' | 'wiki_page' | 'case' | 'standalone_connector_hit';
+    source_type: 'decision' | 'checkpoint' | 'wiki_page' | 'case' | 'ungrouped_connector_hit';
     source_id: string;
     case_id: string | null;
     score: number;
@@ -24,4 +25,4 @@ export declare function rollUpSearchHits(input: {
     fusedHits: SearchRollupLeafHit[];
     adapter: AdapterLike;
 }): SearchRollupResult[];
-//# sourceMappingURL=search-rollup.d.ts.map
+//# sourceMappingURL=case-search-rollup.d.ts.map

package/dist/{cases/search-rollup.js → knowledge/case-search-rollup.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollUpSearchHits = rollUpSearchHits;
-const store_js_1 = require("./store.js");
+const case_store_js_1 = require("./case-store.js");
 function sourceKey(sourceType, sourceId) {
     return `${sourceType}:${sourceId}`;
 }
@@ -26,7 +26,6 @@ function searchHitDiagnostics(value) {
         !(object.vector_similarity === null || typeof object.vector_similarity === 'number') ||
         typeof object.is_vector_only !== 'boolean' ||
         typeof object.lexical_support !== 'boolean' ||
-        typeof object.entity_support !== 'boolean' ||
         typeof object.scope_support !== 'boolean' ||
         (object.graph_source !== 'primary' &&
             object.graph_source !== 'expanded' &&
@@ -50,9 +49,6 @@ function diagnosticsRank(diagnostics) {
     if (diagnostics.lexical_support) {
         rank += 20;
     }
-    if (diagnostics.entity_support) {
-        rank += 20;
-    }
     if (diagnostics.graph_source === 'primary') {
         rank += 10;
     }
@@ -101,7 +97,7 @@ function loadCaseRecord(adapter, caseId) {
     return row ?? { case_id: caseId };
 }
 function canonicalCaseId(adapter, caseId) {
-    return (0, store_js_1.resolveCanonicalCaseChain)(adapter, caseId).terminal_case_id;
+    return (0, case_store_js_1.resolveCanonicalCaseChain)(adapter, caseId).terminal_case_id;
 }
 function listActiveMembershipCaseIds(adapter, sourceType, sourceId) {
     const rows = adapter
@@ -173,7 +169,9 @@ function upsertOrphan(orphans, leaf) {
     const diagnostics = leafDiagnostics(leaf);
     const contributingLeafDiagnostics = diagnostics ? { [leaf.source_id]: diagnostics } : undefined;
     orphans.set(key, {
-        source_type: leaf.source_type === 'connector_event' ? 'standalone_connector_hit' : leaf.source_type,
+        // A connector hit that belongs to no case. Its old name began with the word a
+        // product in this repo is called, so it read as one and was counted as one.
+        source_type: leaf.source_type === 'connector_event' ? 'ungrouped_connector_hit' : leaf.source_type,
         source_id: leaf.source_id,
         case_id: null,
         score: leaf.fused_rank_score,
@@ -306,4 +304,4 @@ function rollUpSearchHits(input) {
         ...Array.from(orphans.values()),
     ].sort(compareResults);
 }
-//# sourceMappingURL=search-rollup.js.map
+//# sourceMappingURL=case-search-rollup.js.map

package/dist/{cases/store.d.ts → knowledge/case-store.d.ts}

@@ -1,5 +1,5 @@
-import { type DatabaseAdapter } from '../db-manager.js';
-import type { CanonicalCaseResolution, CaseAssembly, CaseAssemblyMembership, CaseBlocker, CaseConfidence, CaseCorrectionRecord, CaseMembershipRecord, CaseMembershipSourceType, CasePrimaryActor, CaseProposalKind, CaseProposalQueueRecord, CaseTruthRecord } from './types.js';
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { CanonicalCaseResolution, CaseAssembly, CaseAssemblyMembership, CaseBlocker, CaseConfidence, CaseCorrectionRecord, CaseMembershipRecord, CaseMembershipSourceType, CasePrimaryActor, CaseProposalKind, CaseProposalQueueRecord, CaseTruthRecord } from './case-types.js';
 type CaseStoreAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
 export interface UpsertCaseTruthSlowFieldsInput {
     case_id: string;
@@ -43,9 +43,7 @@ export interface AssembleCaseOptions {
 }
 export declare function resolveCanonicalCaseChain(adapter: CaseStoreAdapter, caseId: string, maxDepth?: number): CanonicalCaseResolution;
 export declare function expandCaseChainForAssembly(adapter: Pick<DatabaseAdapter, 'prepare'>, terminalCaseId: string, resolvedChain: string[]): string[];
-export declare function upsertCaseTruthSlowFields(input: UpsertCaseTruthSlowFieldsInput): CaseTruthRecord;
 export declare function upsertCaseTruthSlowFields(adapter: CaseStoreAdapter, input: UpsertCaseTruthSlowFieldsInput): CaseTruthRecord;
-export declare function upsertExplicitCaseMemberships(input: UpsertExplicitCaseMembershipsInput): CaseMembershipRecord[];
 export declare function upsertExplicitCaseMemberships(adapter: CaseStoreAdapter, input: UpsertExplicitCaseMembershipsInput): CaseMembershipRecord[];
 export declare function listActiveMembershipsForCaseChain(adapter: CaseStoreAdapter, caseIds: string[], limit?: number): CaseAssemblyMembership[];
 export interface ListActiveCorrectionsForCaseResult {
@@ -64,7 +62,6 @@ export interface ListActiveCorrectionsForCaseResult {
 export declare function listActiveCorrectionsForCase(adapter: CaseStoreAdapter, caseId: string): ListActiveCorrectionsForCaseResult;
 export declare function listActiveCorrectionsForCaseChain(adapter: CaseStoreAdapter, caseIds: string[]): CaseCorrectionRecord[];
 export declare function listUnresolvedCaseProposals(adapter: CaseStoreAdapter, project: string): CaseProposalQueueRecord[];
-export declare function assembleCase(caseId: string, options?: AssembleCaseOptions): CaseAssembly;
 export declare function assembleCase(adapter: CaseStoreAdapter, caseId: string, options?: AssembleCaseOptions): CaseAssembly;
 export {};
-//# sourceMappingURL=store.d.ts.map
+//# sourceMappingURL=case-store.d.ts.map

package/dist/{cases/store.js → knowledge/case-store.js}

@@ -9,39 +9,7 @@ exports.listActiveCorrectionsForCase = listActiveCorrectionsForCase;
 exports.listActiveCorrectionsForCaseChain = listActiveCorrectionsForCaseChain;
 exports.listUnresolvedCaseProposals = listUnresolvedCaseProposals;
 exports.assembleCase = assembleCase;
-const db_manager_js_1 = require("../db-manager.js");
-const errors_js_1 = require("../entities/errors.js");
-function isAdapter(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.prepare === 'function' &&
-        typeof value.transaction === 'function');
-}
-function resolveWriteArgs(adapterOrInput, input) {
-    if (input !== undefined) {
-        if (!isAdapter(adapterOrInput)) {
-            throw new Error('First argument must be a database adapter when input is provided.');
-        }
-        return { adapter: adapterOrInput, input };
-    }
-    if (isAdapter(adapterOrInput)) {
-        throw new Error('Input is required when first argument is a database adapter.');
-    }
-    return { adapter: (0, db_manager_js_1.getAdapter)(), input: adapterOrInput };
-}
-function resolveAssembleArgs(adapterOrCaseId, caseIdOrOptions, options) {
-    if (isAdapter(adapterOrCaseId)) {
-        if (typeof caseIdOrOptions !== 'string') {
-            throw new Error('caseId is required when first argument is a database adapter.');
-        }
-        return { adapter: adapterOrCaseId, caseId: caseIdOrOptions, options };
-    }
-    return {
-        adapter: (0, db_manager_js_1.getAdapter)(),
-        caseId: adapterOrCaseId,
-        options: typeof caseIdOrOptions === 'object' ? caseIdOrOptions : undefined,
-    };
-}
+const case_errors_js_1 = require("./case-errors.js");
 function nowIso() {
     return new Date().toISOString();
 }
@@ -277,14 +245,14 @@ function resolveCanonicalCaseChain(adapter, caseId, maxDepth = 64) {
         const detectedAtDepth = chain.length + 1;
         const cycleChain = [...chain, current];
         if (visited.has(current)) {
-            throw new errors_js_1.CaseMergeChainCycleError({
+            throw new case_errors_js_1.CaseMergeChainCycleError({
                 case_id: caseId,
                 chain: cycleChain,
                 detected_at_depth: detectedAtDepth,
             });
         }
         if (detectedAtDepth > maxDepth) {
-            throw new errors_js_1.CaseMergeChainCycleError({
+            throw new case_errors_js_1.CaseMergeChainCycleError({
                 case_id: caseId,
                 chain: cycleChain,
                 detected_at_depth: detectedAtDepth,
@@ -336,8 +304,7 @@ function expandCaseChainForAssembly(adapter, terminalCaseId, resolvedChain) {
     }
     return chain;
 }
-function upsertCaseTruthSlowFields(adapterOrInput, maybeInput) {
-    const { adapter, input } = resolveWriteArgs(adapterOrInput, maybeInput);
+function upsertCaseTruthSlowFields(adapter, input) {
     const createdAt = nowIso();
     const updatedAt = createdAt;
     return adapter.transaction(() => {
@@ -368,8 +335,7 @@ function upsertCaseTruthSlowFields(adapterOrInput, maybeInput) {
         return saved;
     });
 }
-function upsertExplicitCaseMemberships(adapterOrInput, maybeInput) {
-    const { adapter, input } = resolveWriteArgs(adapterOrInput, maybeInput);
+function upsertExplicitCaseMemberships(adapter, input) {
     const updatedAt = nowIso();
     return adapter.transaction(() => {
         // wiki-compiler memberships are hard-coded to status='active' and
@@ -577,8 +543,7 @@ function buildLinkedCases(adapter, chain, terminalCaseId) {
     }
     return linked;
 }
-function assembleCase(adapterOrCaseId, caseIdOrOptions, maybeOptions) {
-    const { adapter, caseId, options } = resolveAssembleArgs(adapterOrCaseId, caseIdOrOptions, maybeOptions);
+function assembleCase(adapter, caseId, options) {
     const resolution = resolveCanonicalCaseChain(adapter, caseId);
     const assemblyChain = expandCaseChainForAssembly(adapter, resolution.terminal_case_id, resolution.chain);
     const caseTruth = loadCaseTruth(adapter, resolution.terminal_case_id);
@@ -747,4 +712,4 @@ function assembleCase(adapterOrCaseId, caseIdOrOptions, maybeOptions) {
     }
     return assembly;
 }
-//# sourceMappingURL=store.js.map
+//# sourceMappingURL=case-store.js.map

package/dist/{cases/timeline-range.d.ts → knowledge/case-timeline-range.d.ts}

@@ -1,6 +1,6 @@
 import type { DatabaseAdapter } from '../db-manager.js';
-import type { CaseTimelineRangeInput, CaseTimelineRangeResult } from './types.js';
+import type { CaseTimelineRangeInput, CaseTimelineRangeResult } from './case-types.js';
 type CaseTimelineRangeAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
 export declare function caseTimelineRange(adapter: CaseTimelineRangeAdapter, input: CaseTimelineRangeInput): CaseTimelineRangeResult;
-export type { CaseTimelineRangeInput, CaseTimelineRangeItem, CaseTimelineRangeResult, } from './types.js';
-//# sourceMappingURL=timeline-range.d.ts.map
+export type { CaseTimelineRangeInput, CaseTimelineRangeItem, CaseTimelineRangeResult, } from './case-types.js';
+//# sourceMappingURL=case-timeline-range.d.ts.map

package/dist/{cases/timeline-range.js → knowledge/case-timeline-range.js}

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.caseTimelineRange = caseTimelineRange;
-const event_index_js_1 = require("../connectors/event-index.js");
-const store_js_1 = require("./store.js");
+const case_store_js_1 = require("./case-store.js");
 function codedError(code, message, context) {
     const error = new Error(`${code}: ${message}`);
     error.code = code;
@@ -124,15 +123,16 @@ function connectorEventSnapshot(row) {
         return null;
     }
     return {
-        event_index_id: row.event_index_id,
-        source_connector: row.source_connector,
+        event_index_id: row.observation_id,
+        source_connector: row.source,
         source_id: row.source_id,
         source_locator: row.source_locator,
         artifact_locator: row.artifact_locator,
         title: row.title,
-        content: row.content,
-        event_datetime: row.event_datetime,
+        content: row.body,
+        event_datetime: row.source_at,
         event_date: row.event_date,
+        observation_ref: row.observation_id,
     };
 }
 function membershipById(memberships, sourceType) {
@@ -229,10 +229,13 @@ function loadObservationItems(adapter, memberships, bounds, includeConnectorEnri
         const sourceId = String(row.id);
         const membership = membershipMap.get(sourceId);
         const eventDatetime = timestampMs(row.timestamp_observed) ?? timestampMs(row.created_at);
+        // Same move as the artifact branch: the source detail is the observation's,
+        // and reaching for the connector index made a core read depend on a package
+        // three of four consumers do not install.
         const connectorEvent = includeConnectorEnrichments &&
             typeof row.source_connector === 'string' &&
             typeof row.source_raw_record_id === 'string'
-            ? (0, event_index_js_1.getConnectorEventIndexRecord)(adapter, String(row.source_connector), String(row.source_raw_record_id))
+            ? loadObservationBySource(adapter, String(row.source_connector), String(row.source_raw_record_id))
             : null;
         return {
             item_type: 'observation',
@@ -253,30 +256,49 @@ function loadObservationItems(adapter, memberships, bounds, includeConnectorEnri
     })
         .filter((item) => withinBounds(item.event_datetime, bounds));
 }
-function loadArtifactConnectorEvent(adapter, sourceId) {
+/**
+ * The observation an artifact membership points at.
+ *
+ * This read the connector event index, which is how a core read came to require
+ * the connector package to be installed -- a consumer without it got no timeline
+ * and, worse, a migration chain that stopped at 072. Every field the caller uses
+ * is on the observation, which is the core's own table and the thing a judgment
+ * actually rests on.
+ */
+/** One observation by the (source, id-within-it) pair that produced it. */
+function loadObservationBySource(adapter, source, sourceId) {
     const row = adapter
         .prepare(`
-        SELECT *
-        FROM connector_event_index
-        WHERE event_index_id = ?
+        SELECT observation_id, source, source_id, source_type, source_locator, title,
+               artifact_locator, artifact_title, body, source_at, observed_at, event_date
+        FROM observation_versions
+        WHERE source = ? AND source_id = ?
+        ORDER BY observed_at DESC, observation_id DESC
+        LIMIT 1
+      `)
+        .get(source, sourceId);
+    return row ? row : null;
+}
+function loadArtifactObservation(adapter, sourceId) {
+    const row = adapter
+        .prepare(`
+        SELECT observation_id, source, source_id, source_type, source_locator, title,
+               artifact_locator, artifact_title, body, source_at, observed_at, event_date
+        FROM observation_versions
+        WHERE observation_id = ?
            OR artifact_locator = ?
-        ORDER BY event_datetime ASC, event_index_id ASC
+        ORDER BY observed_at ASC, observation_id ASC
         LIMIT 1
       `)
         .get(sourceId, sourceId);
-    if (!row) {
-        return null;
-    }
-    const sourceConnector = String(row.source_connector);
-    const connectorSourceId = String(row.source_id);
-    return (0, event_index_js_1.getConnectorEventIndexRecord)(adapter, sourceConnector, connectorSourceId);
+    return row ? row : null;
 }
 function loadArtifactItems(adapter, memberships, bounds, includeConnectorEnrichments) {
     const artifactMemberships = memberships.filter((membership) => membership.source_type === 'artifact');
     return artifactMemberships
         .map((membership) => {
-        const connectorEvent = loadArtifactConnectorEvent(adapter, membership.source_id);
-        const eventDatetime = connectorEvent?.event_datetime ?? null;
+        const connectorEvent = loadArtifactObservation(adapter, membership.source_id);
+        const eventDatetime = connectorEvent?.source_at ?? null;
         return {
             item_type: 'artifact',
             source_type: 'artifact',
@@ -287,7 +309,7 @@ function loadArtifactItems(adapter, memberships, bounds, includeConnectorEnrichm
             event_datetime: eventDatetime,
             event_date: connectorEvent?.event_date ?? eventDateFromMs(eventDatetime),
             title: connectorEvent?.artifact_title ?? connectorEvent?.title ?? membership.source_id,
-            summary: connectorEvent?.content ?? null,
+            summary: connectorEvent?.body ?? null,
             role: membership.role,
             confidence: membership.confidence,
             membership_reason: membership.reason,
@@ -301,10 +323,10 @@ function loadArtifactItems(adapter, memberships, bounds, includeConnectorEnrichm
 function caseTimelineRange(adapter, input) {
     const bounds = parseBounds(input);
     const limit = normalizeLimit(input.limit);
-    const resolution = (0, store_js_1.resolveCanonicalCaseChain)(adapter, input.case_id);
-    const chainResult = (0, store_js_1.listActiveCorrectionsForCase)(adapter, input.case_id);
+    const resolution = (0, case_store_js_1.resolveCanonicalCaseChain)(adapter, input.case_id);
+    const chainResult = (0, case_store_js_1.listActiveCorrectionsForCase)(adapter, input.case_id);
     const chain = chainResult.chain;
-    const memberships = (0, store_js_1.listActiveMembershipsForCaseChain)(adapter, chain);
+    const memberships = (0, case_store_js_1.listActiveMembershipsForCaseChain)(adapter, chain);
     const items = [
         ...loadDecisionItems(adapter, memberships, bounds),
         ...loadEventItems(adapter, memberships, bounds),
@@ -319,4 +341,4 @@ function caseTimelineRange(adapter, input) {
         items: orderedItems.slice(0, limit),
     };
 }
-//# sourceMappingURL=timeline-range.js.map
+//# sourceMappingURL=case-timeline-range.js.map

package/dist/{cases/types.d.ts → knowledge/case-types.d.ts}

@@ -223,6 +223,11 @@ export interface CaseTimelineRangeItem {
     role: string | null;
     confidence: number | null;
     membership_reason: string | null;
+    /**
+     * The observation this item rests on, when the caller asked for source detail.
+     * The field names are the wire shape callers already read; what fills them is
+     * the observation, which is the core's own table.
+     */
     connector_event?: {
         event_index_id: string;
         source_connector: string;
@@ -230,9 +235,10 @@ export interface CaseTimelineRangeItem {
         source_locator: string | null;
         artifact_locator: string | null;
         title: string | null;
-        content: string;
+        content: string | null;
         event_datetime: number | null;
         event_date: string | null;
+        observation_ref: string | null;
     } | null;
 }
 export interface CaseTimelineRangeResult {
@@ -241,4 +247,4 @@ export interface CaseTimelineRangeResult {
     chain: string[];
     items: CaseTimelineRangeItem[];
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=case-types.d.ts.map

package/dist/{cases/types.js → knowledge/case-types.js}

@@ -44,4 +44,4 @@ exports.CASE_PROPOSAL_KINDS = [
 ];
 exports.CASE_PROPOSAL_RESOLUTIONS = ['accepted', 'rejected', 'modified', 'merged'];
 exports.CASE_CONFIDENCE_LEVELS = ['high', 'medium', 'low'];
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=case-types.js.map

package/dist/knowledge/commitments.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Reading owner work back out of the commitment log.
+ *
+ * `appendJudgment` has written `commitments` and `commitment_assignments` since
+ * migration 075: a commitment row carries identity, the current revision and the
+ * head record, and one assignment row per revision carries the patch that
+ * revision applied. Nothing read them back. The only SELECT against either table
+ * was the writer's own CAS check, so the substrate could be written and never
+ * answered from - the shape this refactor exists to close.
+ *
+ * Current values are a fold, not a column. Each assignment states `set` and
+ * `clear` for that revision only, and the view is those applied in revision
+ * order. That is what keeps a correction from erasing what it corrected: the
+ * revision that changed a title is still readable next to the one that set it,
+ * and `history: 'all'` returns them.
+ *
+ * @module knowledge/commitments
+ */
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { JudgmentAccess, JudgmentKnowledgeOptions } from './judgments.js';
+import type { JudgmentEventMeta, JudgmentReceipt, OwnerWorkPatch, RecordLink, WorkReference } from '../memory/judgment-types.js';
+import type { MemoryScopeRef } from '../memory/types.js';
+/** One revision of a commitment, as the assignment row recorded it. */
+export interface CommitmentRevision {
+    revision: number;
+    operation: 'create' | 'revise' | 'withdraw';
+    recordRef: WorkReference;
+    set: OwnerWorkPatch;
+    clear: Array<keyof OwnerWorkPatch>;
+    /** Source event time; null means this legacy revision had no event time. */
+    eventDatetime: number | null;
+    createdAt: number;
+}
+/** The compact lifecycle entry returned for a progress-oriented chain read. */
+export interface CommitmentChainEntry {
+    revision: number;
+    operation: CommitmentRevision['operation'];
+    eventDatetime: number | null;
+    status: string | null;
+    stage: string | null;
+    summary: string | null;
+}
+export interface CommitmentView {
+    commitmentId: string;
+    rowId: number;
+    revision: number;
+    latestJudgmentRef: WorkReference;
+    /** The fold of every assignment up to `revision`. */
+    values: OwnerWorkPatch;
+    withdrawn: boolean;
+    /** The judgment record each surviving revision was written by, oldest first. */
+    basis: WorkReference[];
+    createdAt: number;
+    updatedAt: number;
+    /** Present only when the caller asked for `history: 'all'`. */
+    history?: CommitmentRevision[];
+    /** Present only when the caller asked for the internal `history: 'chain'`. */
+    chain?: CommitmentChainEntry[];
+}
+export interface CommitmentPage {
+    items: CommitmentView[];
+    nextCursor: string | null;
+    coverage: {
+        returned: number;
+        total: number | null;
+        complete: boolean;
+        /**
+         * Why the page is not the whole answer. Empty when it is. A caller that
+         * cannot tell a complete page from a truncated one will read the first page
+         * as the board, which is the failure this field exists to prevent.
+         */
+        reasons: string[];
+    };
+}
+export interface WorkRead {
+    commitmentId?: string;
+    rowId?: number;
+    /** Only revisions effective at or before this epoch millisecond are folded. */
+    asOf?: number;
+    history?: 'current' | 'chain' | 'all';
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Read owner work: one commitment, or a bounded page of them.
+ *
+ * `asOf` folds revisions by their source event time when recorded, or by the
+ * commit clock for judgments without an event time. A backfill committed today
+ * can therefore answer what was current at a historical instant. A commitment
+ * whose first revision is later than `asOf` is absent, not empty.
+ */
+export declare function readWork(adapter: DatabaseAdapter, query: WorkRead, access: JudgmentAccess): CommitmentPage;
+/**
+ * What the caller states when it commits owner work.
+ *
+ * `commandId` is the caller's idempotency key and `summary` is what the record
+ * says; both are required because a commitment is a judgment first. Everything
+ * else about the work lives in the patch, which is the only vocabulary this
+ * module knows - no product's task shape reaches here.
+ */
+export interface WorkCommand {
+    commandId: string;
+    /** Native run that authored this work, when it was written during a model turn. */
+    modelRunId?: string | null;
+    /** What this commitment is about; becomes the record topic. */
+    topic: string;
+    /** What the caller is committing to, in its own words. */
+    summary: string;
+    reasoning?: string;
+    scopes?: MemoryScopeRef[];
+    /** Carried onto the record so a commitment names what caused it. */
+    sourceRefs?: string[];
+    /**
+     * Relations this command records as edges in the same transaction as the
+     * work. A commitment is a judgment first: a revision that only states how
+     * this work relates to other records is still a revision.
+     */
+    links?: RecordLink[];
+    eventDatetime?: number | null;
+    /**
+     * When this command happened, if the caller keeps its own clock. It stamps
+     * the record and the commitment row alike, so a board that filters on
+     * `updatedAt` reads the time the caller states rather than the wall clock.
+     */
+    recordedAt?: number;
+    /**
+     * Provenance carried onto the record's memory_events row. An importer names
+     * itself here so an imported row's history says who wrote it - not the agent
+     * that merely ran the migration.
+     */
+    event?: JudgmentEventMeta;
+}
+export interface CreateWorkCommand extends WorkCommand {
+    set: OwnerWorkPatch;
+    /**
+     * Import vocabulary: the identity this work already had in a predecessor
+     * store. A migration that brings existing owner rows into the commitment log
+     * names their task id and revision so the log keeps the row's number and CAS
+     * history instead of minting a new identity. Absent for work first stated
+     * through this command log.
+     */
+    imported?: {
+        rowId: number;
+        revision?: number;
+        createdAt?: number;
+    };
+}
+export interface ReviseWorkCommand extends WorkCommand {
+    commitmentId: string;
+    expectedRevision?: number;
+    set?: OwnerWorkPatch;
+    clear?: Array<keyof OwnerWorkPatch>;
+}
+export interface WithdrawWorkCommand extends WorkCommand {
+    commitmentId: string;
+    expectedRevision: number;
+}
+export interface WorkWriteResult {
+    commitmentId: string;
+    revision: number;
+    recordRef: WorkReference;
+    receipt: JudgmentReceipt;
+}
+/**
+ * Commit new owner work.
+ *
+ * The work and the record that states it commit together: `appendJudgment` owns
+ * the transaction, and this is the vocabulary in front of it. A caller that
+ * wrote a task row here and a record there is the split this replaces.
+ */
+export declare function createWork(command: CreateWorkCommand, access: JudgmentAccess, options: JudgmentKnowledgeOptions): Promise<WorkWriteResult>;
+/**
+ * Revise owner work at an expected revision.
+ *
+ * The revision is the caller's claim about what it read. A concurrent write
+ * moves it and this fails loudly rather than overwriting what the caller never
+ * saw - the same compare-and-set the ledger it replaces performed.
+ */
+export declare function reviseWork(command: ReviseWorkCommand, access: JudgmentAccess, options: JudgmentKnowledgeOptions): Promise<WorkWriteResult>;
+/**
+ * Withdraw owner work.
+ *
+ * Withdrawal is a revision like any other: the values stay readable and the
+ * commitment is marked. Nothing is deleted, so a withdrawn commitment can still
+ * answer what it held and who withdrew it.
+ */
+export declare function withdrawWork(command: WithdrawWorkCommand, access: JudgmentAccess, options: JudgmentKnowledgeOptions): Promise<WorkWriteResult>;
+//# sourceMappingURL=commitments.d.ts.map