@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/memory/secret-filter.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Secret-pattern filter for recallable writes.
+ *
+ * The one real leak path a chat-reachable caller has is memory: a secret saved
+ * as a "decision" resurfaces later through search or recall. This filter
+ * refuses the write at the choke point, which is the action contract — every
+ * write that recall can return passes through here. Minimal gitleaks-style
+ * set: shapes, not entropy heuristics, so false positives stay near zero.
+ *
+ * It lives in core because the contract does. The patterns name provider key
+ * shapes and prompt-injection phrasing; nothing here knows a product.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretMaterialRefusedError = void 0;
+exports.scanForSecrets = scanForSecrets;
+exports.scanMemoryWriteInput = scanMemoryWriteInput;
+exports.redactSecretPatterns = redactSecretPatterns;
+const SECRET_PATTERNS = [
+    {
+        name: 'invisible-unicode',
+        pattern: /[\u200b-\u200d\ufeff\u2060\u202a-\u202e\u2066-\u2069]/,
+    },
+    // Built via concatenation so the literals never form secret shapes at rest
+    // (the repo's own PII/secret scanners would flag them - correctly).
+    { name: 'anthropic-key', pattern: new RegExp('\\bsk-' + 'ant-[a-zA-Z0-9_-]{8,}') },
+    {
+        name: 'openai-key',
+        pattern: new RegExp('\\bsk-' + '(?:proj-[A-Za-z0-9_-]{20,}|[A-Za-z0-9]{20,}\\b)'),
+    },
+    {
+        name: 'github-token',
+        pattern: new RegExp('\\b(?:gh' + '[pousr]_[A-Za-z0-9]{20,}\\b|github_pat_[A-Za-z0-9_]{20,})'),
+    },
+    { name: 'slack-token', pattern: new RegExp('\\bxox' + '[baprs]-[A-Za-z0-9-]{10,}\\b') },
+    {
+        name: 'telegram-bot-token',
+        pattern: new RegExp('\\b\\d{8,12}:' + 'AA[A-Za-z0-9_-]{30,}\\b'),
+    },
+    { name: 'aws-access-key', pattern: new RegExp('\\bAKIA' + '[0-9A-Z]{16}\\b') },
+    {
+        name: 'private-key-block',
+        pattern: new RegExp('-----BEGIN [A-Z ]*' + 'PRIVATE KEY' + '-----'),
+    },
+    { name: 'generic-bearer', pattern: new RegExp('\\bBearer\\s+' + '[A-Za-z0-9_-]{25,}\\b') },
+];
+const PROMPT_INJECTION_PATTERNS = [
+    /\bignore\s+(?:(?:all|any)\s+)?(?:previous|prior)\s+instructions\b/i,
+    /\bdisregard\s+.{0,20}(?:rules|instructions)\b/i,
+    /\byou\s+are\s+now\b/i,
+    /\bsystem\s+prompt\b/i,
+];
+class SecretMaterialRefusedError extends Error {
+    constructor(matches) {
+        super(`refusing to persist content matching ${matches.join(', ')} — a secret written here comes back through recall`);
+        this.name = 'secret_material_refused';
+    }
+}
+exports.SecretMaterialRefusedError = SecretMaterialRefusedError;
+/** Scan text for secret-shaped material. */
+function scanForSecrets(text) {
+    const matches = SECRET_PATTERNS.filter(({ pattern }) => pattern.test(text)).map(({ name }) => name);
+    const warnings = PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(text))
+        ? ['prompt-injection-suspect']
+        : [];
+    return { clean: matches.length === 0, matches, warnings };
+}
+/**
+ * Scan every string reachable in a memory-write input (nested objects and
+ * arrays included, container-depth-capped): open_files arrays, scope ids, and source
+ * objects are persisted too and must not smuggle secrets past a top-level
+ * scan (review m1).
+ */
+function scanMemoryWriteInput(input) {
+    const texts = [];
+    let truncated = false;
+    const visit = (value, depth) => {
+        if (value === null || value === undefined) {
+            return;
+        }
+        // Scan leaves of the deepest supported container too. Recallable page
+        // batches carry evidence at pages[].sourceRefs[].id (a depth-five leaf).
+        if (typeof value === 'string') {
+            texts.push(value);
+            return;
+        }
+        if (typeof value !== 'object') {
+            return;
+        }
+        if (depth > 4) {
+            // Fail CLOSED: an abnormally deep memory-write payload is refused, never
+            // silently under-scanned (a secret below the cap must not pass as clean).
+            truncated = true;
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                visit(item, depth + 1);
+            }
+            return;
+        }
+        if (typeof value === 'object') {
+            for (const item of Object.values(value)) {
+                visit(item, depth + 1);
+            }
+        }
+    };
+    visit(input, 0);
+    if (truncated) {
+        return { clean: false, matches: ['scan-depth-limit-exceeded'], warnings: [] };
+    }
+    return scanForSecrets(texts.join('\n'));
+}
+/** Mask the same credential shapes in observations without treating hashes as tokens. */
+function redactSecretPatterns(text) {
+    let redacted = text.replace(new RegExp('-----BEGIN [A-Z ]*' +
+        'PRIVATE KEY-----[\\s\\S]*?(?:-----END [A-Z ]*' +
+        'PRIVATE KEY-----|$)', 'g'), '[REDACTED]');
+    for (const { name, pattern } of SECRET_PATTERNS) {
+        if (name !== 'invisible-unicode') {
+            redacted = redacted.replace(new RegExp(pattern.source, 'g'), '[REDACTED]');
+        }
+    }
+    return redacted;
+}
+//# sourceMappingURL=secret-filter.js.map

package/dist/memory/truth-store.d.ts

@@ -1,5 +1,6 @@
+import type { DatabaseAdapter } from '../db-manager.js';
 import type { MemoryScopeRef, MemoryTruthRow } from './types.js';
-export declare function queryRelevantTruth(params: {
+export declare function queryRelevantTruth(adapter: DatabaseAdapter, params: {
     query: string;
     scopes: MemoryScopeRef[];
     includeHistory?: boolean;

package/dist/memory/truth-store.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryRelevantTruth = queryRelevantTruth;
-const db_manager_js_1 = require("../db-manager.js");
 function decisionToTruthRow(row) {
     return {
         memory_id: row.id,
@@ -30,9 +29,7 @@ function matchesQuery(row, query) {
         ? haystack.includes(query.toLowerCase())
         : tokens.some((token) => haystack.includes(token));
 }
-async function queryRelevantTruth(params) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
+async function queryRelevantTruth(adapter, params) {
     const scopeMatch = params.scopes
         .map(() => '(scope_filter.kind = ? AND scope_filter.external_id = ?)')
         .join(' OR ');

package/dist/memory/types.d.ts

@@ -1,10 +1,31 @@
-import type { ConnectorEventSearchHit } from '../connectors/types.js';
-import type { ReadIdentity } from '../entities/read-identity.js';
-import type { SearchHitDiagnostics, SearchQualityOptions, SearchStrictness } from '../search/search-quality.js';
+import type { RecordActor } from '../registry/types.js';
+import type { RecordLink } from './judgment-types.js';
+import type { SearchHitDiagnostics, SearchQualityOptions, SearchStrictness } from '../knowledge/search-quality.js';
+/**
+ * The scope kinds this repository's own products happen to use.
+ *
+ * NOT the set of kinds that exist. A scope is a (kind, id) pair; the pair is the
+ * core's, the vocabulary is the consumer's. These are exported so a product can
+ * reuse a familiar word, and so nothing that already writes them has to change --
+ * they are not a gate. A consumer with a kind of its own passes it and the core
+ * carries it, because the core does not read the kind, it matches it.
+ */
+export declare const COMMON_MEMORY_SCOPE_KINDS: readonly ["global", "user", "channel", "project"];
+/** Kept as the old name for callers that import it; same list, still not a gate. */
 export declare const MEMORY_SCOPE_KINDS: readonly ["global", "user", "channel", "project"];
-export type MemoryScopeKind = (typeof MEMORY_SCOPE_KINDS)[number];
-export declare const MEMORY_KINDS: readonly ["decision", "preference", "constraint", "lesson", "fact", "task", "schedule", "compiled"];
+export type MemoryScopeKind = string;
+/**
+ * What a memory can be.
+ *
+ * `task`, `schedule` and `compiled` were here and are not any more. Nothing writes
+ * them -- no call site in either package, no row in the live database -- and they name
+ * one product's board, cron and context-packet vocabulary rather than anything a
+ * memory is. The stored kind check still accepts the retired task and schedule values;
+ * adding a new kind needs a migration because that check constrains the column.
+ */
+export declare const MEMORY_KINDS: readonly ["decision", "preference", "constraint", "lesson", "fact", "workflow"];
 export type MemoryKind = (typeof MEMORY_KINDS)[number];
+export type MemoryKindFilter = MemoryKind | [MemoryKind, ...MemoryKind[]];
 export declare const MEMORY_STATUSES: readonly ["active", "superseded", "contradicted", "stale"];
 export type MemoryStatus = (typeof MEMORY_STATUSES)[number];
 export declare const MEMORY_TRUTH_STATUSES: readonly ["active", "superseded", "contradicted", "stale", "quarantined"];
@@ -22,7 +43,12 @@ export interface MemoryScopeRef {
     id: string;
 }
 export interface MemorySourceRef {
-    package: 'mama-core' | 'mcp-server' | 'standalone' | 'claude-code-plugin';
+    /**
+     * Which package wrote this. A free string, not a union of the four packages that
+     * happened to exist when it was written: a second product installing this core would
+     * have had to be added to the core's own type before it could save anything.
+     */
+    package: string;
     source_type: string;
     user_id?: string;
     channel_id?: string;
@@ -34,6 +60,12 @@ export interface MemoryRecord {
     kind: MemoryKind;
     summary: string;
     details: string;
+    /** One-line context that tells an agent when this guidance applies. */
+    applies_when?: string;
+    /** Ordered procedure steps for workflow records. */
+    steps?: string[];
+    /** Evidence checks a workflow must complete, in order. */
+    evidence_checks?: string[];
     confidence: number;
     status: MemoryStatus;
     scopes: MemoryScopeRef[];
@@ -44,10 +76,12 @@ export interface MemoryRecord {
     event_date?: string | null;
     /** Source event timestamp in milliseconds when known. Null if not set. */
     event_datetime?: number | null;
-    read_identity?: ReadIdentity;
+    /** Maintained outcome projection (SUCCESS | FAILED | PARTIAL | pending). Null when unset. */
+    outcome?: string | null;
     retrieval_diagnostics?: SearchHitDiagnostics;
 }
 export type RecallMemoryOptions = SearchQualityOptions & {
+    kind?: MemoryKindFilter;
     scopes?: MemoryScopeRef[];
     includeProfile?: boolean;
     includeHistory?: boolean;
@@ -58,7 +92,6 @@ export interface RecallSearchDiagnostics {
     candidate_counts: {
         vector: number;
         lexical: number;
-        entity: number;
         graph_expanded: number;
         vector_only: number;
         rejected_by_strictness: number;
@@ -84,8 +117,15 @@ export interface ProfileSnapshot {
 export interface RecallBundle {
     profile: ProfileSnapshot;
     memories: MemoryRecord[];
-    /** Phase 3: cross-connector event hits, populated when searchWithConnectorEvents=true */
-    connector_event_hits?: ConnectorEventSearchHit[];
+    /**
+     * Hits from a source outside the judgment log, when the caller asked for them.
+     *
+     * This was typed as the connector event index's row, which made the core's
+     * recall bundle depend on a package three of four consumers do not install. The
+     * shape is whatever the source produced; what the core states is that a hit is
+     * ranked and scored.
+     */
+    connector_event_hits?: SourceSearchHit[];
     graph_context: {
         primary: MemoryRecord[];
         expanded: MemoryRecord[];
@@ -98,8 +138,13 @@ export interface RecallBundle {
         diagnostics?: RecallSearchDiagnostics;
     };
 }
-/** Phase 3: unified search result type — memory-authored or connector-enriched. */
-export type MemorySearchResultHit = MemoryRecord | ConnectorEventSearchHit;
+/** A ranked hit from a source the core did not author. Its fields are the source's. */
+export interface SourceSearchHit extends Record<string, unknown> {
+    rank: number;
+    score: number;
+}
+/** A search result: authored by the judgment log, or found in a source. */
+export type MemorySearchResultHit = MemoryRecord | SourceSearchHit;
 export interface MemoryEventRecord {
     event_id: string;
     event_type: 'observed_conversation' | 'save' | 'supersede' | 'contradict' | 'mark_stale' | 'quarantine' | 'no_op' | 'audit_failed' | 'notice_sent' | 'provenance.empty_batch' | 'provenance.link_write_failed' | 'connector_event_index.retention_swept' | 'case.link_created' | 'case.link_revoked' | 'case.membership_pinned' | 'case.membership_unpinned' | 'case.source_promoted' | 'case.freshness_drifted' | 'automation.job.started' | 'automation.job.succeeded' | 'automation.job.failed' | 'automation.job.skipped_concurrent' | 'review.bulk.approved' | 'review.bulk.rejected' | 'review.bulk.deferred' | 'canary.drift.false_merge_rate' | 'canary.drift.projection_fragmentation_rate' | 'canary.drift.replay_stale' | 'auth.role_denied' | 'ontology.proposal' | 'ontology.approval' | 'repair.approval' | 'case.fast_write_applied' | 'case.fast_write_lock_skipped' | 'case.correction_applied' | 'case.correction_reverted' | 'case.correction_superseded' | 'case.membership_tombstoned' | 'case.merged' | 'case.split' | 'case.membership_matched' | 'case.membership_candidate';
@@ -139,6 +184,9 @@ export interface PublicSaveMemoryInput {
     kind: MemoryKind;
     summary: string;
     details: string;
+    appliesWhen?: string;
+    steps?: string[];
+    evidenceChecks?: string[];
     confidence?: number;
     status?: MemoryStatus;
     scopes: MemoryScopeRef[];
@@ -147,18 +195,15 @@ export interface PublicSaveMemoryInput {
     eventDate?: string;
     eventDateTime?: number;
     entityObservationIds?: string[];
-    timelineEvent?: {
-        id?: string;
-        entity_id?: string;
-        event_type: string;
-        role?: string | null;
-        valid_from?: number | null;
-        valid_to?: number | null;
-        observed_at?: number | null;
-        source_ref?: string | null;
-        summary: string;
-        details?: string | null;
-    };
+    itemId?: string | null;
+    actors?: RecordActor[];
+    /** Explicit, scope-checked relationships from this new judgment. */
+    links?: RecordLink[];
+    /** Earlier records this judgment explicitly replaces; matching topic is not enough. */
+    replaces?: Array<{
+        id: string;
+        reason: string;
+    }>;
 }
 export interface PublicIngestMemoryInput {
     content: string;
@@ -345,4 +390,9 @@ export interface IngestConversationResult {
         topic: string;
     }>;
 }
+export declare function canonicalizeContextScopes(scopes: readonly MemoryScopeRef[] | undefined): {
+    scopes: MemoryScopeRef[];
+    scopeJson: string;
+    scopeHash: string;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/memory/types.js

@@ -1,18 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMORY_AUDIT_ACK_STATUSES = exports.MEMORY_CONSULT_INTENTS = exports.MEMORY_AGENT_ACTIONS = exports.MEMORY_EDGE_TYPES = exports.MEMORY_TRUTH_STATUSES = exports.MEMORY_STATUSES = exports.MEMORY_KINDS = exports.MEMORY_SCOPE_KINDS = void 0;
+exports.MEMORY_AUDIT_ACK_STATUSES = exports.MEMORY_CONSULT_INTENTS = exports.MEMORY_AGENT_ACTIONS = exports.MEMORY_EDGE_TYPES = exports.MEMORY_TRUTH_STATUSES = exports.MEMORY_STATUSES = exports.MEMORY_KINDS = exports.MEMORY_SCOPE_KINDS = exports.COMMON_MEMORY_SCOPE_KINDS = void 0;
 exports.createEmptyRecallBundle = createEmptyRecallBundle;
 exports.createMemoryAuditAck = createMemoryAuditAck;
-exports.MEMORY_SCOPE_KINDS = ['global', 'user', 'channel', 'project'];
+exports.canonicalizeContextScopes = canonicalizeContextScopes;
+const node_crypto_1 = require("node:crypto");
+/**
+ * The scope kinds this repository's own products happen to use.
+ *
+ * NOT the set of kinds that exist. A scope is a (kind, id) pair; the pair is the
+ * core's, the vocabulary is the consumer's. These are exported so a product can
+ * reuse a familiar word, and so nothing that already writes them has to change --
+ * they are not a gate. A consumer with a kind of its own passes it and the core
+ * carries it, because the core does not read the kind, it matches it.
+ */
+exports.COMMON_MEMORY_SCOPE_KINDS = ['global', 'user', 'channel', 'project'];
+/** Kept as the old name for callers that import it; same list, still not a gate. */
+exports.MEMORY_SCOPE_KINDS = exports.COMMON_MEMORY_SCOPE_KINDS;
+/**
+ * What a memory can be.
+ *
+ * `task`, `schedule` and `compiled` were here and are not any more. Nothing writes
+ * them -- no call site in either package, no row in the live database -- and they name
+ * one product's board, cron and context-packet vocabulary rather than anything a
+ * memory is. The stored kind check still accepts the retired task and schedule values;
+ * adding a new kind needs a migration because that check constrains the column.
+ */
 exports.MEMORY_KINDS = [
     'decision',
     'preference',
     'constraint',
     'lesson',
     'fact',
-    'task',
-    'schedule',
-    'compiled',
+    'workflow',
 ];
 exports.MEMORY_STATUSES = ['active', 'superseded', 'contradicted', 'stale'];
 exports.MEMORY_TRUTH_STATUSES = [
@@ -67,4 +87,54 @@ function createMemoryAuditAck(input) {
         reason: input.reason,
     };
 }
+// --- Scope identity -------------------------------------------------------------
+//
+// Two scope lists naming the same scopes are the same list. The order and the hash below
+// are what makes that true, so they live with the type rather than with any one reader.
+const SCOPE_ORDER = new Map([
+    ['project', 0],
+    ['channel', 1],
+    ['user', 2],
+    ['global', 3],
+]);
+function assertScope(scope) {
+    // A kind is nonblank text. Which kinds exist is the consumer's statement, not a
+    // list kept here -- this used to compare against COMMON_MEMORY_SCOPE_KINDS, so a
+    // consumer whose world had a kind of its own could not store one.
+    if (typeof scope.kind !== 'string' || scope.kind.trim().length === 0) {
+        throw new Error(`Memory scope kind must be nonblank text, got: ${String(scope.kind)}`);
+    }
+    const id = scope.id.trim();
+    if (id.length === 0) {
+        throw new Error('Memory scope id must not be empty');
+    }
+    return { kind: scope.kind, id };
+}
+function scopeKey(scope) {
+    return `${scope.kind}\0${scope.id}`;
+}
+function sortScopes(scopes) {
+    return [...scopes].sort((left, right) => {
+        const orderDiff = (SCOPE_ORDER.get(left.kind) ?? 4) - (SCOPE_ORDER.get(right.kind) ?? 4);
+        if (orderDiff !== 0) {
+            return orderDiff;
+        }
+        return left.kind.localeCompare(right.kind) || left.id.localeCompare(right.id);
+    });
+}
+function canonicalizeContextScopes(scopes) {
+    const unique = new Map();
+    for (const scope of scopes ?? []) {
+        const normalized = assertScope(scope);
+        unique.set(scopeKey(normalized), normalized);
+    }
+    const canonicalScopes = sortScopes([...unique.values()]);
+    const scopeJson = JSON.stringify(canonicalScopes);
+    const scopeHash = (0, node_crypto_1.createHash)('sha256').update(scopeJson).digest('hex');
+    return {
+        scopes: canonicalScopes,
+        scopeJson,
+        scopeHash,
+    };
+}
 //# sourceMappingURL=types.js.map

package/dist/memory/write-adapters.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Mechanical adapters between the public memory write surfaces and the
+ * knowledge command boundary.
+ *
+ * Every write funnels through `appendJudgment` (or `ingestSource` for raw
+ * evidence): the adapter builds exactly one command, derives honest access —
+ * never fabricating authority the caller did not present — and maps the receipt
+ * back to the legacy result shape.
+ */
+import type { DatabaseAdapter, DatabaseInstance, DecisionInput } from '../db-manager.js';
+import type { JudgmentAccess } from '../knowledge/judgments.js';
+import type { JudgmentProjections, JsonValue, RecordLink } from './judgment-types.js';
+import type { MemoryScopeRef } from './types.js';
+import type { NormalizedMemoryProvenance } from './provenance.js';
+/** Access for a caller with no signed identity: it is admitted to exactly the
+ * scopes it declared, nothing more. */
+export declare function unsignedWriteAccess(scopes: readonly MemoryScopeRef[]): JudgmentAccess;
+/**
+ * Access derived from normalized write provenance — the legacy direct-write
+ * path, where the caller is the process itself and declares its own scopes.
+ * Unified-action writes do NOT come through here: dispatch passes the real
+ * `JudgmentAccess` (the call authority) straight to `appendJudgment`.
+ */
+export declare function writeAccessForProvenance(provenance: NormalizedMemoryProvenance, requestedScopes: readonly MemoryScopeRef[]): JudgmentAccess;
+/** Scope refs currently bound to a memory row — the partition a write into
+ * that row must be admitted to. */
+export declare function boundScopesOf(adapter: Pick<DatabaseAdapter, 'prepare'>, memoryId: string): MemoryScopeRef[];
+/**
+ * Fail-first visibility check for explicitly authored relationship targets,
+ * preserving the legacy error contract.
+ *
+ * Trusted envelopes check visibility strictly inside admitted scopes (unbound
+ * legacy rows are not reachable — same as the pre-boundary envelope check).
+ * Unsigned callers keep the legacy existence check for the original error
+ * text; scope admission is then enforced by the command boundary itself.
+ */
+export declare function assertRelationshipTargetsVisible(adapter: Pick<DatabaseAdapter, 'prepare'>, targetIds: readonly string[], admittedScopes: readonly MemoryScopeRef[], trustedEnvelope: boolean): void;
+export interface ExplicitRelationship {
+    type: string;
+    targetId: string;
+}
+/**
+ * Map deduplicated legacy relationships onto command fields.
+ *
+ * Trusted envelopes get the authored form: `supersedes` targets become
+ * scope-checked `replaces`, and link-able relations also enter the twin edge
+ * graph as explicit `links` — both fail closed inside the boundary.
+ *
+ * Unsigned callers keep the legacy contract: the adapter already checked that
+ * each target exists, so relationships are written only as `decision_edges`
+ * projection rows and `supersedes` targets are moved out of current truth
+ * through the `supersedeTargets` projection — never as scope-checked authored
+ * links the caller was not admitted to.
+ */
+export declare function relationshipsToCommandFields(relationships: readonly ExplicitRelationship[], options?: {
+    trusted?: boolean;
+}): {
+    links: RecordLink[];
+    replaces: Array<{
+        id: string;
+        reason: string;
+    }>;
+    decisionEdges: NonNullable<JudgmentProjections['decisionEdges']>;
+    supersedeTargets: string[];
+};
+/**
+ * Embedder for the command boundary that preserves the legacy enhanced
+ * embedding input.
+ */
+export declare function commandEmbedder(decision: DecisionInput): {
+    embed(text: string, role: 'query' | 'passage'): Promise<Float32Array | null>;
+};
+export interface OutcomeAmendmentInput {
+    outcome?: string | null;
+    failureReason?: string | null;
+    limitation?: string | null;
+    confidence?: number | null;
+    durationDays?: number | null;
+    /** Extra fields written on the amendment record's payload for audit. */
+    payload?: Record<string, JsonValue>;
+    /** Callers that can name their own command id get replay for free. */
+    commandId?: string;
+    recordedAt?: number;
+    eventReason?: string;
+}
+/**
+ * Append one judgment record carrying an authored outcome change and apply the
+ * maintained `decisions` projection columns on the target in the same
+ * transaction. Identical payloads on the same target replay the stored receipt
+ * instead of appending a second record.
+ */
+export declare function appendOutcomeAmendment(decisionId: string, input: OutcomeAmendmentInput, options: {
+    adapter: DatabaseInstance;
+}): Promise<{
+    recordId: string;
+    commandId: string;
+}>;
+//# sourceMappingURL=write-adapters.d.ts.map