@jungjaehoon/mama-core 2.4.1 → 4.1.0

package/dist/knowledge/question-type.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUESTION_VOCABULARY = exports.QUESTION_TYPES = void 0;
+exports.declareQuestionVocabulary = declareQuestionVocabulary;
+exports.resetQuestionVocabulary = resetQuestionVocabulary;
+exports.classifyQuestionType = classifyQuestionType;
+exports.isQuestionType = isQuestionType;
+exports.QUESTION_TYPES = [
+    'correction',
+    'artifact',
+    'timeline',
+    'status',
+    'decision_reason',
+    'how_to',
+    'unknown',
+];
+// Korean: patterns for classifyQuestionType() multilingual query routing.
+// A language is not a product: these words name no deployment, no connector and no
+// package. Domain words belong in a caller's vocabulary, not here.
+exports.DEFAULT_QUESTION_VOCABULARY = [
+    {
+        type: 'correction',
+        pattern: /\b(fix|revert|correct|correction|supersede|superseded|revise|revision)\b|수정|되돌|정정|교정/i,
+    },
+    {
+        type: 'artifact',
+        pattern: /\b(file|doc|docs|document|image|video|pdf|attachment|artifact)\b|파일|문서|이미지|영상|첨부/i,
+    },
+    {
+        type: 'timeline',
+        pattern: /\b(when|history|before|after|around|timeline|chronology)\b|언제|이력|히스토리|(?:^|\s)(?:전|후)(?=$|\s|[?.!,]|에|의|로|부터|까지|는|를|가|와|도)|즈음|\bon\s+\d{4}(?:-\d{1,2})?(?:-\d{1,2})?\b|\b\d{4}-\d{1,2}-\d{1,2}\b/i,
+    },
+    {
+        type: 'status',
+        pattern: /\b(status|state|current|currently|now|latest|progress|blocked|done)\b|상태|현재|최신|진행|진척/i,
+    },
+    { type: 'decision_reason', pattern: /\b(why|reason|because|rationale)\b|근거|이유|왜|때문/i },
+    {
+        type: 'how_to',
+        pattern: /\b(how\s+to|how\s+do|setup|set\s+up|configure|configuration|install)\b|설정|구성|어떻게/i,
+    },
+];
+let vocabulary = exports.DEFAULT_QUESTION_VOCABULARY;
+/**
+ * Declare the words this deployment asks questions with. Call once, at boot.
+ *
+ * Replaces the default outright rather than merging: a caller that wants the general
+ * words plus its own spreads DEFAULT_QUESTION_VOCABULARY itself, and can see in one
+ * place what its classifier actually knows.
+ */
+function declareQuestionVocabulary(next) {
+    vocabulary = next;
+}
+/** Restore the default. For tests that declared their own. */
+function resetQuestionVocabulary() {
+    vocabulary = exports.DEFAULT_QUESTION_VOCABULARY;
+}
+function classifyQuestionType(query) {
+    const normalized = query.trim();
+    for (const entry of vocabulary) {
+        if (entry.pattern.test(normalized)) {
+            return entry.type;
+        }
+    }
+    return 'unknown';
+}
+function isQuestionType(value) {
+    return exports.QUESTION_TYPES.includes(value);
+}
+//# sourceMappingURL=question-type.js.map

package/dist/{search → knowledge}/ranker-features.js

@@ -40,7 +40,7 @@ function sourceTypeKey(row) {
         case 'wiki_page':
             return 'artifact';
         case 'connector_event':
-        case 'standalone_connector_hit':
+        case 'ungrouped_connector_hit':
             return 'connector_event';
         default:
             return null;

package/dist/{search → knowledge}/search-quality.d.ts

@@ -22,7 +22,6 @@ export interface SearchHitDiagnostics {
     retrieval_source: string;
     vector_similarity: number | null;
     lexical_support: boolean;
-    entity_support: boolean;
     scope_support: boolean;
     graph_source: 'primary' | 'expanded' | null;
     is_vector_only: boolean;

package/dist/knowledge/search.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Knowledge search: what the corpus can be asked for by meaning and by word.
+ *
+ * Both functions take the adapter they read through, so a caller cannot run a
+ * search against a database it did not open.
+ *
+ * @module knowledge/search
+ */
+import type { DatabaseInstance, DecisionRecord } from '../db-manager.js';
+import type { MemoryKindFilter } from '../memory/types.js';
+/**
+ * Brute-force cosine similarity search over stored embeddings.
+ *
+ * Errors are not swallowed: an empty array means the corpus held nothing above
+ * `threshold`, never that the search failed.
+ *
+ * @param adapter - Database to read through
+ * @param queryEmbedding - Query embedding (1024-dim)
+ * @param limit - Max results to return
+ * @param threshold - Minimum similarity
+ * @param topicPrefix - Optional topic prefix pre-filter
+ * @param excludeStatuses - Optional decision statuses to pre-filter out
+ * @param kind - Optional memory kind pre-filter
+ */
+export declare function vectorSearch(adapter: DatabaseInstance, queryEmbedding: Float32Array | number[], limit?: number, threshold?: number, topicPrefix?: string, excludeStatuses?: readonly string[], kind?: MemoryKindFilter): Promise<DecisionRecord[]>;
+/**
+ * FTS5 keyword search on the decisions table.
+ *
+ * @param adapter - Database to read through
+ * @param query - FTS5 MATCH expression
+ * @param limit - Max rows to return
+ * @returns Matching decision IDs with BM25 rank scores
+ */
+export declare function fts5Search(adapter: DatabaseInstance, query: string, limit?: number, kind?: MemoryKindFilter): Promise<{
+    id: string;
+    rank: number;
+}[]>;
+//# sourceMappingURL=search.d.ts.map

package/dist/knowledge/search.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Knowledge search: what the corpus can be asked for by meaning and by word.
+ *
+ * Both functions take the adapter they read through, so a caller cannot run a
+ * search against a database it did not open.
+ *
+ * @module knowledge/search
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vectorSearch = vectorSearch;
+exports.fts5Search = fts5Search;
+/**
+ * Brute-force cosine similarity search over stored embeddings.
+ *
+ * Errors are not swallowed: an empty array means the corpus held nothing above
+ * `threshold`, never that the search failed.
+ *
+ * @param adapter - Database to read through
+ * @param queryEmbedding - Query embedding (1024-dim)
+ * @param limit - Max results to return
+ * @param threshold - Minimum similarity
+ * @param topicPrefix - Optional topic prefix pre-filter
+ * @param excludeStatuses - Optional decision statuses to pre-filter out
+ * @param kind - Optional memory kind pre-filter
+ */
+async function vectorSearch(adapter, queryEmbedding, limit = 5, threshold = 0.7, topicPrefix, excludeStatuses, kind) {
+    const results = await adapter.vectorSearch(queryEmbedding, limit * 3, topicPrefix, excludeStatuses, kind);
+    if (!results || results.length === 0) {
+        return [];
+    }
+    const stmt = adapter.prepare(`SELECT * FROM decisions WHERE rowid = ?`);
+    const decisions = [];
+    for (const row of results) {
+        const decision = stmt.get(row.rowid);
+        if (!decision) {
+            continue;
+        }
+        const similarity = row.similarity ?? Math.max(0, 1.0 - (row.distance ?? 1));
+        const distance = row.distance ?? Math.max(0, 1.0 - similarity);
+        if (similarity >= threshold) {
+            decisions.push({
+                ...decision,
+                distance,
+                similarity,
+            });
+        }
+        if (decisions.length >= limit) {
+            break;
+        }
+    }
+    return decisions;
+}
+/**
+ * FTS5 keyword search on the decisions table.
+ *
+ * @param adapter - Database to read through
+ * @param query - FTS5 MATCH expression
+ * @param limit - Max rows to return
+ * @returns Matching decision IDs with BM25 rank scores
+ */
+async function fts5Search(adapter, query, limit = 10, kind) {
+    // An absent FTS table is a real answer - no rows. A failing adapter is not,
+    // so this lookup is left unguarded and its errors reach the caller.
+    const tableCheck = adapter
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='decisions_fts'")
+        .get();
+    if (!tableCheck)
+        return [];
+    // Query execution - let errors propagate to the caller
+    const kindClause = Array.isArray(kind)
+        ? `AND d.kind IN (${kind.map(() => '?').join(', ')})`
+        : kind === undefined
+            ? ''
+            : 'AND d.kind = ?';
+    const stmt = adapter.prepare(`
+    SELECT d.id, rank
+    FROM decisions_fts
+    JOIN decisions d ON decisions_fts.rowid = d.rowid
+    WHERE decisions_fts MATCH ?
+      ${kindClause}
+    ORDER BY rank
+    LIMIT ?
+  `);
+    return (Array.isArray(kind)
+        ? stmt.all(query, ...kind, limit)
+        : kind === undefined
+            ? stmt.all(query, limit)
+            : stmt.all(query, kind, limit));
+}
+//# sourceMappingURL=search.js.map

package/dist/knowledge/source-ingest.d.ts

@@ -0,0 +1,65 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { JsonValue } from '../memory/judgment-types.js';
+import type { MemoryEventRecord, MemoryScopeRef } from '../memory/types.js';
+import { type JudgmentAccess } from './judgments.js';
+/**
+ * `source.ingest` — the raw-evidence half of the command boundary.
+ *
+ * One command stores exactly one immutable `observation_versions` row plus its
+ * provenance event. Observations are evidence, not judgments: no decisions row
+ * is created, no edges are inferred, and nothing is extracted. The command id
+ * binds the request through `command_bindings` so a retried ingest replays the
+ * recorded receipt instead of writing a second observation.
+ */
+export interface SourceIngestCommand {
+    /** Idempotency key. A repeated id replays the stored receipt; the same id
+     * bound to different content fails with COMMAND_CONFLICT. */
+    commandId: string;
+    /** Producing connector and the source-side identity of what was captured. */
+    source: {
+        connector: string;
+        id: string;
+    };
+    producerVersionId?: string | null;
+    /** The raw payload as observed. Never rewritten or summarized. */
+    body: string;
+    author?: string | null;
+    /** Source-side event time (ms epoch) when known. */
+    sourceAt?: number | null;
+    /** Capture time (ms epoch); defaults to commit time. */
+    observedAt?: number;
+    /** sha256 of body when omitted. */
+    contentHash?: string;
+    metadata?: Record<string, JsonValue>;
+    /** Free-form scope metadata persisted on the observation row. */
+    scope?: Record<string, JsonValue>;
+    /**
+     * Memory scopes this ingest is bound to. An explicit `[]` stores an unscoped
+     * observation; an omitted field inherits the access scope.
+     */
+    scopes?: MemoryScopeRef[];
+    /** Provenance metadata for the observation's memory_events row. */
+    event?: {
+        eventType?: MemoryEventRecord['event_type'];
+        actor?: MemoryEventRecord['actor'];
+        sourceTurnId?: string;
+        reason?: string;
+        evidenceRefs?: string[];
+    };
+}
+export interface SourceIngestReceipt {
+    status: 'committed';
+    commandId: string;
+    observationId: string;
+    eventId: string;
+    watermark: number;
+    diagnostics: Array<{
+        stage: string;
+        code: string;
+        message: string;
+    }>;
+}
+export declare function ingestSource(command: SourceIngestCommand, access: JudgmentAccess, options: {
+    adapter: DatabaseAdapter;
+}): Promise<SourceIngestReceipt>;
+//# sourceMappingURL=source-ingest.d.ts.map

package/dist/knowledge/source-ingest.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ingestSource = ingestSource;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const canonicalize_js_1 = require("../canonicalize.js");
+const observations_js_1 = require("../knowledge/observations.js");
+const event_store_js_1 = require("../memory/event-store.js");
+const judgments_js_1 = require("./judgments.js");
+function requireNonblank(value, field) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new judgments_js_1.JudgmentError('INVALID_COMMAND', `${field} must be nonblank`);
+    }
+}
+function commandHash(command) {
+    return node_crypto_1.default.createHash('sha256').update((0, canonicalize_js_1.canonicalizeJSON)(command)).digest('hex');
+}
+function parseReceipt(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error('source_commands.receipt_json is malformed', { cause: error });
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('source_commands.receipt_json must contain an object');
+    }
+    return parsed;
+}
+function assertReplay(adapter, command, access, hash) {
+    const binding = adapter
+        .prepare('SELECT principal_id, action, payload_hash, receipt_key FROM command_bindings WHERE command_id = ?')
+        .get(command.commandId);
+    if (!binding)
+        return null;
+    if (binding.principal_id !== access.principalId ||
+        binding.action !== 'source.ingest' ||
+        binding.payload_hash !== hash) {
+        throw new judgments_js_1.JudgmentError('COMMAND_CONFLICT', 'The command id is already bound to another request');
+    }
+    const row = adapter
+        .prepare('SELECT receipt_json FROM source_commands WHERE command_id = ?')
+        .get(command.commandId);
+    if (!row) {
+        throw new Error('Command binding has no source ingest receipt');
+    }
+    return parseReceipt(row.receipt_json);
+}
+async function ingestSourceOnAdapter(adapter, command, access) {
+    requireNonblank(command.commandId, 'commandId');
+    requireNonblank(command.source?.connector, 'source.connector');
+    requireNonblank(command.source?.id, 'source.id');
+    requireNonblank(command.body, 'body');
+    requireNonblank(access.principalId, 'principalId');
+    requireNonblank(access.agentId, 'agentId');
+    if (command.sourceAt !== undefined &&
+        command.sourceAt !== null &&
+        (!Number.isFinite(command.sourceAt) || command.sourceAt < 0)) {
+        throw new judgments_js_1.JudgmentError('INVALID_TIME', 'sourceAt must be a finite nonnegative epoch');
+    }
+    if (command.observedAt !== undefined &&
+        (!Number.isFinite(command.observedAt) || command.observedAt < 0)) {
+        throw new judgments_js_1.JudgmentError('INVALID_TIME', 'observedAt must be a finite nonnegative epoch');
+    }
+    // Admission is validated before any write: every scope the command claims
+    // must already be inside the caller's admitted access.
+    (0, judgments_js_1.admittedScopeIds)(access);
+    const boundScopes = (0, judgments_js_1.boundScopeIdsFor)(access, command);
+    const effectiveScopes = command.scopes ?? [...access.scopes];
+    const effectiveCommand = command.scopes
+        ? command
+        : { ...command, scopes: [...access.scopes] };
+    const hash = commandHash(effectiveCommand);
+    const replay = assertReplay(adapter, command, access, hash);
+    if (replay) {
+        return replay;
+    }
+    const observedAt = command.observedAt ?? Date.now();
+    const contentHash = command.contentHash ?? node_crypto_1.default.createHash('sha256').update(command.body).digest('hex');
+    const observationInput = {
+        source: command.source.connector,
+        sourceId: command.source.id,
+        producerVersionId: command.producerVersionId ?? null,
+        body: command.body,
+        author: command.author ?? null,
+        sourceAt: command.sourceAt ?? null,
+        observedAt,
+        contentHash,
+        metadata: command.metadata ?? {},
+        scope: {
+            ...(command.scope ?? {}),
+            scopes: boundScopes.map((scopeId, index) => ({
+                scopeId,
+                kind: effectiveScopes[index]?.kind,
+                externalId: effectiveScopes[index]?.id,
+                primary: index === 0,
+            })),
+        },
+    };
+    const boundObservationId = (0, observations_js_1.observationVersionId)(observationInput);
+    let replayedReceipt = null;
+    let committed = null;
+    const now = Date.now();
+    const transaction = adapter.transactionImmediate
+        ? adapter.transactionImmediate.bind(adapter)
+        : adapter.transaction.bind(adapter);
+    transaction(() => {
+        const bindingResult = adapter
+            .prepare(`INSERT OR IGNORE INTO command_bindings
+         (command_id, principal_id, action, payload_hash, receipt_kind, receipt_key, created_at)
+         VALUES (?, ?, 'source.ingest', ?, 'observation', ?, ?)`)
+            .run(command.commandId, access.principalId, hash, boundObservationId, now);
+        if (bindingResult.changes === 0) {
+            replayedReceipt = assertReplay(adapter, command, access, hash);
+            if (!replayedReceipt) {
+                throw new Error('Command binding was not readable after a conflict-free insert');
+            }
+            return;
+        }
+        const observation = (0, observations_js_1.appendObservationVersion)(adapter, observationInput);
+        const eventId = (0, event_store_js_1.insertMemoryEventInTransaction)(adapter, {
+            event_type: command.event?.eventType ?? 'observed_conversation',
+            actor: command.event?.actor ?? `actor:${access.principalId}`,
+            source_turn_id: command.event?.sourceTurnId,
+            memory_id: observation.observationId,
+            topic: command.source.id,
+            scope_refs: effectiveScopes,
+            evidence_refs: command.event?.evidenceRefs,
+            reason: command.event?.reason ?? 'source ingest command',
+            created_at: observedAt,
+        });
+        const receipt = {
+            status: 'committed',
+            commandId: command.commandId,
+            observationId: observation.observationId,
+            eventId,
+            watermark: now,
+            diagnostics: [],
+        };
+        adapter
+            .prepare(`INSERT INTO source_commands
+         (command_id, observation_id, event_id, committed_watermark, receipt_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(command.commandId, observation.observationId, eventId, receipt.watermark, (0, canonicalize_js_1.canonicalizeJSON)(receipt), now);
+        committed = { observationId: observation.observationId, eventId };
+    });
+    if (replayedReceipt) {
+        return replayedReceipt;
+    }
+    if (!committed) {
+        throw new Error('source.ingest committed no observation');
+    }
+    const committedRef = committed;
+    return {
+        status: 'committed',
+        commandId: command.commandId,
+        observationId: committedRef.observationId,
+        eventId: committedRef.eventId,
+        watermark: now,
+        diagnostics: [],
+    };
+}
+async function ingestSource(command, access, options) {
+    // The ingest boundary no longer reaches the process-global store: the
+    // caller names the database this observation commits to.
+    if (!options?.adapter) {
+        throw new judgments_js_1.JudgmentError('INVALID_COMMAND', 'ingestSource requires an explicit adapter; the process-global store is not a write path');
+    }
+    return ingestSourceOnAdapter(options.adapter, command, access);
+}
+//# sourceMappingURL=source-ingest.js.map

package/dist/{edges/types.d.ts → knowledge/twin-edge-types.d.ts}

@@ -1,9 +1,9 @@
 import type { Buffer } from 'node:buffer';
-export declare const TWIN_REF_KINDS: readonly ["memory", "case", "entity", "report", "edge", "raw"];
+export declare const TWIN_REF_KINDS: readonly ["memory", "case", "report", "edge", "raw", "registry", "observation"];
 export type TwinRefKind = (typeof TWIN_REF_KINDS)[number];
 export declare const TWIN_EDGE_SOURCES: readonly ["agent", "human", "code"];
 export type TwinEdgeSource = (typeof TWIN_EDGE_SOURCES)[number];
-export declare const TWIN_EDGE_TYPES: readonly ["supersedes", "builds_on", "debates", "synthesizes", "mentions", "derived_from", "case_member", "alias_of", "next_action_for", "blocks"];
+export declare const TWIN_EDGE_TYPES: readonly ["supersedes", "refines", "contradicts", "builds_on", "debates", "synthesizes", "mentions", "derived_from", "case_member", "alias_of", "next_action_for", "blocks", "amends"];
 export type TwinEdgeType = (typeof TWIN_EDGE_TYPES)[number];
 export type TwinRef = {
     [Kind in TwinRefKind]: {
@@ -15,7 +15,11 @@ export type TwinEdgeSubjectRef = Exclude<TwinRef, {
     kind: 'raw';
 }>;
 export interface TwinScopeRef {
-    kind: 'global' | 'user' | 'channel' | 'project';
+    /**
+     * The consumer's word for what kind of scope this is. The core matches it; it
+     * does not read it. Closed lists of kinds used to live here, in three copies.
+     */
+    kind: string;
     id: string;
 }
 export interface TwinProjectRef {
@@ -23,12 +27,18 @@ export interface TwinProjectRef {
     id: string;
 }
 export interface TwinVisibility {
+    principalId?: string;
+    agentId?: string;
     scopes?: TwinScopeRef[];
     connectors?: string[];
+    /** Host-stated connector-wide stored read, such as the configured owner has on source.read. */
+    connectorWideRead?: string[];
     projectRefs?: TwinProjectRef[];
     tenantId?: string | null;
     startMs?: number | null;
     asOfMs?: number | null;
+    /** Inclusive source/event-time ceiling for replay raw reads. */
+    maxSourceMs?: number | null;
     /**
      * Which channels of each connector may be read. When present it DECIDES raw visibility
      * here exactly as it does in the reader, so a ref reached through an edge or named as a
@@ -36,6 +46,13 @@ export interface TwinVisibility {
      * caller could reach past the read path by citing what it could not have read.
      */
     channels?: Record<string, readonly string[]>;
+    /**
+     * Read replaced records as history: lifts the superseded/superseded_by
+     * retirement check while every other rule — scope, connector, channel,
+     * tenant, time window — still applies. Quarantined, contradicted and stale
+     * records stay excluded in every mode; they are holds, not history.
+     */
+    includeReplaced?: boolean;
 }
 export interface InsertTwinEdgeInput {
     edge_id?: string;
@@ -57,6 +74,16 @@ export interface InsertTwinEdgeInput {
     reason_text?: string;
     evidence_refs?: unknown;
 }
+/**
+ * One fully resolved twin_edges row to write. Callers own edge_id, content_hash,
+ * and created_at because each write path derives them differently (deterministic
+ * command hashes vs fresh UUIDs); the writer owns the INSERT itself.
+ */
+export interface TwinEdgeInsert extends InsertTwinEdgeInput {
+    edge_id: string;
+    content_hash: Buffer;
+    created_at: number;
+}
 export interface TwinEdgeRecord {
     edge_id: string;
     edge_type: TwinEdgeType;
@@ -95,4 +122,4 @@ export interface ListVisibleTwinEdgesOptions {
      * cannot silently drop the grant - it crossed this seam as an undeclared property. */
     channels?: Record<string, readonly string[]>;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=twin-edge-types.d.ts.map

package/dist/{edges/types.js → knowledge/twin-edge-types.js}

@@ -1,10 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TWIN_EDGE_TYPES = exports.TWIN_EDGE_SOURCES = exports.TWIN_REF_KINDS = void 0;
-exports.TWIN_REF_KINDS = ['memory', 'case', 'entity', 'report', 'edge', 'raw'];
+exports.TWIN_REF_KINDS = [
+    'memory',
+    'case',
+    'report',
+    'edge',
+    'raw',
+    'registry',
+    'observation',
+];
 exports.TWIN_EDGE_SOURCES = ['agent', 'human', 'code'];
 exports.TWIN_EDGE_TYPES = [
     'supersedes',
+    'refines',
+    'contradicts',
     'builds_on',
     'debates',
     'synthesizes',
@@ -14,5 +24,6 @@ exports.TWIN_EDGE_TYPES = [
     'alias_of',
     'next_action_for',
     'blocks',
+    'amends',
 ];
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=twin-edge-types.js.map

package/dist/knowledge/work-dates.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The grammar of the OwnerWorkPatch date fields.
+ *
+ * A patch can state a deadline two ways: `dueAt` is an exact instant (RFC 3339
+ * with an explicit offset) and `deadline` is a bare calendar date. Readers fold
+ * the patch and parse both fields strictly, so a malformed value committed here
+ * makes the whole row unreadable. The writers validate before commit rather
+ * than letting a strict read discover the damage at boot.
+ *
+ * This module owns the field grammar only. Zone arithmetic — which local date
+ * an instant lands on, where a deadline day starts — belongs to the product's
+ * board projection, not the commitment log.
+ *
+ * @module knowledge/work-dates
+ */
+import type { OwnerWorkPatch } from '../memory/judgment-types.js';
+export declare const WORK_PATCH_DUE_AT_PATTERN: string;
+export declare const WORK_PATCH_DEADLINE_PATTERN: string;
+export interface ParsedExactDueAt {
+    dueAt: number;
+    deadline: string;
+    offsetMinutes: number;
+}
+/**
+ * Parse a `dueAt` value: an RFC 3339 timestamp with an explicit offset.
+ *
+ * A bare date is not an instant and a bare instant without an offset does not
+ * say where midnight falls, so neither is accepted - the caller states the
+ * offset it means.
+ */
+export declare function parseExactDueAt(value: string): ParsedExactDueAt;
+/**
+ * Reject a `deadline` value that is not a real calendar date.
+ *
+ * `2026-02-30` matches the date pattern but is not a day that exists, and a
+ * reader that computes the start of that day has no honest answer for it.
+ */
+export declare function assertIsoDate(value: string, field: string): void;
+/**
+ * Reject a work patch whose declared date fields cannot be read back.
+ *
+ * `null` is an absent statement, not a malformed one - the fold reads it as the
+ * field cleared. A non-null value must be a well-formed string of its grammar.
+ * What the fields mean together (whether `dueAt` and `deadline` may disagree)
+ * is the board's contract, not the log's: this checks only that each stated
+ * value parses.
+ */
+export declare function assertWorkPatchValues(set: OwnerWorkPatch): void;
+//# sourceMappingURL=work-dates.d.ts.map