@claude-flow/cli 3.55.0 → 3.56.1

package/dist/src/mcp-tools/workflow-tools.js

@@ -41,6 +41,22 @@ function saveWorkflowStore(store) {
     ensureWorkflowDir();
     writeFileSync(getWorkflowPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
+// A paused in-flight step still owns its executor. Resume joins that execution
+// instead of dispatching the same side effect again (within this process).
+const workflowExecutions = new Map();
+const workflowExecutionKey = (workflowId) => JSON.stringify([getWorkflowPath(), workflowId]);
+function withWorkflowExecution(workflowId, execute) {
+    const key = workflowExecutionKey(workflowId);
+    if (workflowExecutions.has(key)) {
+        return Promise.resolve({ workflowId, error: 'Workflow already executing' });
+    }
+    const execution = execute();
+    workflowExecutions.set(key, execution);
+    return execution.finally(() => {
+        if (workflowExecutions.get(key) === execution)
+            workflowExecutions.delete(key);
+    });
+}
 export const workflowTools = [
     {
         name: 'workflow_run',
@@ -227,7 +243,7 @@ export const workflowTools = [
             },
             required: ['workflowId'],
         },
-        handler: async (input) => {
+        handler: async (input) => withWorkflowExecution(input.workflowId, async () => {
             // Validate user-provided input (#1425)
             const vId = validateIdentifier(input.workflowId, 'workflowId');
             if (!vId.valid)
@@ -241,13 +257,50 @@ export const workflowTools = [
             if (workflow.status === 'running') {
                 return { workflowId, error: 'Workflow already running' };
             }
+            // Indices may name a step or the end boundary (used when resuming
+            // after the final step). Reject invalid control flow before any writes.
+            const validIndex = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= workflow.steps.length;
+            const startFromStep = input.startFromStep === undefined ? 0 : input.startFromStep;
+            if (!validIndex(startFromStep)) {
+                return { workflowId, error: `startFromStep must be an integer between 0 and ${workflow.steps.length}` };
+            }
+            for (const step of workflow.steps) {
+                if (step.type !== 'condition')
+                    continue;
+                for (const target of ['thenStep', 'elseStep']) {
+                    if (step.config[target] !== undefined && !validIndex(step.config[target])) {
+                        return { workflowId, error: `${step.stepId}.${target} must be an integer between 0 and ${workflow.steps.length}` };
+                    }
+                }
+            }
+            const persistProgress = () => {
+                // An awaited step may overlap pause/stop/delete or a sibling workflow
+                // mutation. Merge only this workflow into the latest store snapshot.
+                const latest = loadWorkflowStore();
+                const current = latest.workflows[workflowId];
+                if (!current) {
+                    workflow.status = 'failed';
+                    workflow.error = 'Workflow was deleted during execution';
+                    return;
+                }
+                if (current.status === 'failed') {
+                    Object.assign(workflow, current);
+                    return;
+                }
+                if (current.status === 'paused' && workflow.status !== 'failed')
+                    workflow.status = 'paused';
+                latest.workflows[workflowId] = workflow;
+                saveWorkflowStore(latest);
+            };
             // Inject runtime variables
             if (input.variables) {
                 workflow.variables = { ...workflow.variables, ...input.variables };
             }
             workflow.status = 'running';
             workflow.startedAt = new Date().toISOString();
-            workflow.currentStep = input.startFromStep || 0;
+            delete workflow.error;
+            delete workflow.completedAt;
+            workflow.currentStep = startFromStep;
             saveWorkflowStore(store);
             // ADR-095 G3: real workflow runtime. Walk the steps in order;
             // dispatch each by type. Persist progress after each step so a
@@ -277,22 +330,26 @@ export const workflowTools = [
             while (i < workflow.steps.length) {
                 // Honor pause/cancel signals between steps.
                 const live = loadWorkflowStore().workflows[workflowId];
-                if (!live || live.status === 'paused') {
+                if (!live) {
+                    workflow.status = 'failed';
+                    workflow.error = 'Workflow was deleted during execution';
+                    break;
+                }
+                if (live.status === 'paused') {
                     workflow.status = 'paused';
                     workflow.currentStep = i;
-                    saveWorkflowStore(store);
+                    persistProgress();
                     break;
                 }
                 if (live.status === 'failed') {
-                    workflow.status = 'failed';
-                    saveWorkflowStore(store);
+                    Object.assign(workflow, live);
                     break;
                 }
                 const step = workflow.steps[i];
                 step.status = 'running';
                 step.startedAt = new Date().toISOString();
                 const stepStart = Date.now();
-                saveWorkflowStore(store);
+                persistProgress();
                 let stepEntry = { stepId: step.stepId, type: step.type, status: 'running' };
                 try {
                     if (step.type === 'task') {
@@ -364,7 +421,7 @@ export const workflowTools = [
                     workflow.status = 'failed';
                     workflow.error = msg;
                     workflow.completedAt = new Date().toISOString();
-                    saveWorkflowStore(store);
+                    persistProgress();
                     return {
                         workflowId,
                         status: 'failed',
@@ -379,17 +436,18 @@ export const workflowTools = [
                     stepEntry.durationMs = Date.now() - stepStart;
                 stepResults.push(stepEntry);
                 workflow.currentStep = i + 1;
-                saveWorkflowStore(store);
+                persistProgress();
                 i++;
             }
             if (workflow.status === 'running') {
                 workflow.status = 'completed';
                 workflow.completedAt = new Date().toISOString();
-                saveWorkflowStore(store);
+                persistProgress();
             }
             return {
                 workflowId,
                 status: workflow.status,
+                ...(workflow.error ? { error: workflow.error } : {}),
                 totalSteps: workflow.steps.length,
                 stepsCompleted: stepResults.filter(s => s.status === 'completed').length,
                 stepsSkipped: stepResults.filter(s => s.status === 'skipped').length,
@@ -399,7 +457,7 @@ export const workflowTools = [
                 completedAt: workflow.completedAt,
                 durationMs: Date.now() - startedAt,
             };
-        },
+        }),
     },
     {
         name: 'workflow_status',
@@ -560,24 +618,15 @@ export const workflowTools = [
             if (workflow.status !== 'paused') {
                 return { workflowId, error: 'Workflow not paused' };
             }
-            workflow.status = 'running';
-            saveWorkflowStore(store);
-            // Report current step states — do not auto-complete them
-            const stepStates = workflow.steps.map(step => ({
-                stepId: step.stepId,
-                name: step.name,
-                status: step.status,
-            }));
-            const remainingSteps = workflow.steps.length - workflow.currentStep;
-            return {
-                workflowId,
-                status: workflow.status,
-                resumed: true,
-                currentStep: workflow.currentStep,
-                remainingSteps,
-                steps: stepStates,
-                _note: 'Workflow resumed. Steps remain in their current state and must be executed via task tools.',
-            };
+            const active = workflowExecutions.get(workflowExecutionKey(workflowId));
+            if (active) {
+                workflow.status = 'running';
+                saveWorkflowStore(store);
+                return { ...(await active), resumed: true };
+            }
+            const execute = workflowTools.find(tool => tool.name === 'workflow_execute');
+            const result = await execute.handler({ workflowId, startFromStep: workflow.currentStep });
+            return { ...result, resumed: true };
         },
     },
     {

package/dist/src/memory/append-conditions.d.ts

@@ -0,0 +1,28 @@
+export type AppendCondition = {
+    namespace: string;
+} & ({
+    key: string;
+    sha256: string;
+    latestPrefix?: string;
+} | {
+    absent: true;
+    latestPrefix: string;
+} | {
+    keysSha256: string;
+    count: number;
+});
+export declare class AppendConditionFailed extends Error {
+}
+export declare function validateAppendConditions(input: unknown): AppendCondition[];
+interface NativeReader {
+    prepare(sql: string): {
+        all(...parameters: string[]): Array<{
+            key: string;
+            content: string;
+            status: string | null;
+        }>;
+    };
+}
+export declare function assertAppendConditions(db: NativeReader, conditions: AppendCondition[]): void;
+export {};
+//# sourceMappingURL=append-conditions.d.ts.map

package/dist/src/memory/append-conditions.js

@@ -0,0 +1,56 @@
+/** Native append predicates checked in the SAME write transaction as an immutable insert. */
+import { createHash } from 'node:crypto';
+export class AppendConditionFailed extends Error {
+}
+const text = (value, limit) => typeof value === 'string' && value.length > 0 && value.length <= limit;
+const digest = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+export function validateAppendConditions(input) {
+    if (!Array.isArray(input) || input.length < 1 || input.length > 8)
+        throw new TypeError('append conditions must contain 1-8 predicates');
+    return input.map(condition => {
+        if (!condition || typeof condition !== 'object' || Array.isArray(condition))
+            throw new TypeError('invalid append condition');
+        const row = condition;
+        const fields = Object.keys(row).sort().join(',');
+        const validRecord = ['key,namespace,sha256', 'key,latestPrefix,namespace,sha256'].includes(fields)
+            && text(row.key, 1024) && digest(row.sha256) && (row.latestPrefix === undefined || text(row.latestPrefix, 1024));
+        const validAbsent = fields === 'absent,latestPrefix,namespace' && row.absent === true && text(row.latestPrefix, 1024);
+        const validKeys = fields === 'count,keysSha256,namespace' && digest(row.keysSha256)
+            && Number.isSafeInteger(row.count) && row.count >= 0 && row.count <= 100_000;
+        if (!text(row.namespace, 256) || !(validRecord || validAbsent || validKeys))
+            throw new TypeError('invalid append condition');
+        return row;
+    });
+}
+const sha = (value) => createHash('sha256').update(value).digest('hex');
+export function assertAppendConditions(db, conditions) {
+    for (const condition of conditions) {
+        if ('keysSha256' in condition) {
+            const rows = db.prepare("SELECT key FROM memory_entries WHERE namespace = ? AND (status = 'active' OR status IS NULL)")
+                .all(condition.namespace);
+            const keys = rows.map(row => row.key).sort();
+            if (keys.length !== condition.count || sha(JSON.stringify(keys)) !== condition.keysSha256) {
+                throw new AppendConditionFailed('immutable append rejected: namespace membership changed');
+            }
+            continue;
+        }
+        if ('key' in condition) {
+            const rows = db.prepare('SELECT key, content, status FROM memory_entries WHERE namespace = ? AND key = ?')
+                .all(condition.namespace, condition.key);
+            if (rows.length !== 1 || !['active', null].includes(rows[0].status)
+                || typeof rows[0].content !== 'string' || sha(rows[0].content) !== condition.sha256) {
+                throw new AppendConditionFailed('immutable append rejected: expected parent/authority bytes changed or absent');
+            }
+        }
+        if (condition.latestPrefix !== undefined) {
+            // Include tombstones: deleting a new authority slot must never rewind to an older authority.
+            const pattern = condition.latestPrefix.replace(/[\\%_]/g, character => `\\${character}`) + '%';
+            const latest = db.prepare("SELECT key, content, status FROM memory_entries WHERE namespace = ? AND key LIKE ? ESCAPE '\\' ORDER BY key COLLATE BINARY DESC LIMIT 1")
+                .all(condition.namespace, pattern);
+            if ('absent' in condition ? latest.length !== 0 : latest.length !== 1 || latest[0].key !== condition.key) {
+                throw new AppendConditionFailed('immutable append rejected: newer parent/authority slot exists');
+            }
+        }
+    }
+}
+//# sourceMappingURL=append-conditions.js.map

package/dist/src/memory/graph-edge-writer.d.ts

@@ -29,6 +29,15 @@
  *
  * @module v3/cli/memory/graph-edge-writer
  */
+/**
+ * True iff the memory.db bridge at `customDbPath` (or the default location)
+ * is currently RFE1-encrypted-at-rest. Callers that receive `null` from
+ * getBridgeDb()/insertGraphEdge() can use this to avoid recommending the
+ * destructive `memory init` command for this specific, non-corrupt case.
+ */
+export declare function isBridgeDbEncryptedAtRest(customDbPath?: string): boolean;
+/** Test-only: clear the once-per-path warning dedup set. */
+export declare function _resetRfe1WarningFlag(): void;
 /**
  * Checkpoint and close the cached handle if it is open (optionally only if it
  * is open on `dbPath`). Returns true if a handle was released. Never throws.

package/dist/src/memory/graph-edge-writer.js

@@ -35,6 +35,87 @@ import * as crypto from 'crypto';
 import { getMemoryRoot } from './memory-initializer.js';
 import { encodeEmbedding } from './embedding-quantization.js';
 import { loadBetterSqlite3 } from './shared-sqlite.js';
+import { isEncryptedBlob } from '../encryption/vault.js';
+// ============================================================================
+// #2889 — RFE1 encryption-at-rest guard
+// ============================================================================
+//
+// When CLAUDE_FLOW_ENCRYPT_AT_REST is on, memory.db is an opaque RFE1 blob
+// (see encryption/vault.ts). `new BetterSqlite3(dbPath)` has no RFE1 sniff
+// and throws SQLITE_NOTADB on it, which the generic catch below swallows —
+// indistinguishable from genuine corruption, a missing native module, or a
+// permissions failure. That ambiguity is what let #2889 happen: nothing
+// stopped a caller from concluding the store was broken and running the
+// destructive `memory init`, which creates a fresh EMPTY store instead of
+// using the existing encrypted data.
+//
+// Fix: sniff the header bytes (never buffer the whole file — memory.db can
+// be multi-GB) before attempting the native open. If it's RFE1-encrypted,
+// skip the native open (it would only throw) and warn once per distinct
+// dbPath (not once per process — a process can legitimately touch more
+// than one encrypted store via a custom `dbPath` argument).
+/** Read just the first `len` bytes of a file without loading the whole file
+ * into memory. Mirrors the pattern in commands/doctor.ts's readHeaderBytes
+ * (not imported from there — this is a memory-layer module and must not
+ * depend on the command layer). */
+function readHeaderBytes(filePath, len) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buf = Buffer.alloc(len);
+        const bytesRead = fs.readSync(fd, buf, 0, len, 0);
+        return buf.subarray(0, bytesRead);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+// RFE1 wire format is magic(4) + iv(12) + ciphertext(N) + tag(16); the
+// shortest possible blob is 32 bytes. 64 gives headroom.
+const ENCRYPTION_SNIFF_LEN = 64;
+/** True iff `filePath` is a legitimately RFE1-encrypted-at-rest file. A read
+ * failure (permissions, races) is treated as "not encrypted" — the caller's
+ * own open/query error handling still runs right after. */
+function isRfe1EncryptedAtRest(filePath) {
+    try {
+        return isEncryptedBlob(readHeaderBytes(filePath, ENCRYPTION_SNIFF_LEN));
+    }
+    catch {
+        return false;
+    }
+}
+// Keyed by resolved path (not a single process-wide boolean) — a process
+// that touches more than one RFE1-encrypted dbPath (a custom `dbPath` passed
+// to insertGraphEdge/queryEdgesBySource/countGraphEdges, or any multi-store
+// scenario) must still get the warning for EACH distinct path, not just the
+// first one it happens to see.
+const _warnedRfe1EncryptedPaths = new Set();
+function warnRfe1EncryptedOnce(dbPath) {
+    const resolved = path.resolve(dbPath);
+    if (_warnedRfe1EncryptedPaths.has(resolved))
+        return;
+    _warnedRfe1EncryptedPaths.add(resolved);
+    // eslint-disable-next-line no-console
+    console.error(`[graph-edge-writer] ${dbPath} is encrypted at rest (CLAUDE_FLOW_ENCRYPT_AT_REST). ` +
+        'The native graph-edge bridge cannot open an RFE1-encrypted store directly — ' +
+        'this is a known limitation, not corruption. Your existing data is NOT lost ' +
+        'or damaged. Do NOT run `memory init` in response to this — that would create ' +
+        'a fresh, empty store instead of using your existing encrypted data. ' +
+        'See #2889 (https://github.com/ruvnet/ruflo/issues/2889) for details and recovery options.');
+}
+/**
+ * True iff the memory.db bridge at `customDbPath` (or the default location)
+ * is currently RFE1-encrypted-at-rest. Callers that receive `null` from
+ * getBridgeDb()/insertGraphEdge() can use this to avoid recommending the
+ * destructive `memory init` command for this specific, non-corrupt case.
+ */
+export function isBridgeDbEncryptedAtRest(customDbPath) {
+    const dbPath = customDbPath ?? path.join(getMemoryRoot(), 'memory.db');
+    return fs.existsSync(dbPath) && isRfe1EncryptedAtRest(dbPath);
+}
+/** Test-only: clear the once-per-path warning dedup set. */
+export function _resetRfe1WarningFlag() {
+    _warnedRfe1EncryptedPaths.clear();
+}
 // ============================================================================
 // Lazy-cached better-sqlite3 db handle
 // ============================================================================
@@ -134,6 +215,15 @@ export async function getBridgeDb(customDbPath, opts) {
         const dbExists = fs.existsSync(dbPath);
         if (!dbExists && !createIfMissing)
             return null;
+        // #2889 — detect RFE1 encryption-at-rest before even attempting the
+        // native open: `new BetterSqlite3(dbPath)` on an encrypted file would
+        // only throw SQLITE_NOTADB, caught by the generic catch below with no
+        // way to tell it apart from genuine corruption. Skip straight to a
+        // clear, actionable warning instead.
+        if (dbExists && isRfe1EncryptedAtRest(dbPath)) {
+            warnRfe1EncryptedOnce(dbPath);
+            return null;
+        }
         // Ensure parent dir exists for createIfMissing case.
         if (!dbExists && createIfMissing) {
             const dir = path.dirname(dbPath);

package/dist/src/memory/memory-bridge.d.ts

@@ -16,6 +16,7 @@
  *
  * @module v3/cli/memory-bridge
  */
+import { type AppendCondition } from './append-conditions.js';
 /**
  * #3024: AgentDB's optional native controller stack can abort the whole Node
  * process on Windows during registry initialization (a Rust allocation panic),
@@ -67,6 +68,9 @@ export declare function bridgeStoreEntry(options: {
     ttl?: number;
     dbPath?: string;
     upsert?: boolean;
+    requireNative?: boolean;
+    appendOnly?: boolean;
+    appendConditions?: AppendCondition[];
     /** ADR-323: defaults to 'unknown' when omitted. */
     provenanceType?: string;
 }): Promise<{

package/dist/src/memory/memory-bridge.js

@@ -16,6 +16,7 @@
  *
  * @module v3/cli/memory-bridge
  */
+import { AppendConditionFailed, assertAppendConditions, validateAppendConditions } from './append-conditions.js';
 import { liveMemoryRowSql } from './live-memory-row.js';
 import { resolveAgentdbBetterSqlite3 } from './shared-sqlite.js';
 import { encodeEmbeddingQ8, MAX_LIST_EMBEDDINGS } from './embedding-q8.js';
@@ -1025,13 +1026,24 @@ export async function bridgeStoreEntry(options) {
     const ctx = getDb(registry);
     if (!ctx)
         return null;
+    if (options.appendOnly && !options.requireNative) {
+        return { success: false, id: '', error: 'Immutable append requires a native writer' };
+    }
+    if (options.appendConditions && (!options.requireNative || !options.appendOnly)) {
+        return { success: false, id: "", error: "Conditional append requires native append-only storage" };
+    }
+    if (options.requireNative && (ctx.agentdb?.isWasm === true || typeof ctx.db.inTransaction !== 'boolean'
+        || typeof ctx.db.transaction !== 'function' || ctx.db.memory !== false || typeof ctx.db.name !== 'string'
+        || !ctx.db.name || canonicalDbPath(ctx.db.name) !== canonicalDbPath(options.dbPath))) {
+        return { success: false, id: '', error: 'Native memory writer required; refusing non-native bridge driver' };
+    }
     try {
         const { key, value, namespace = 'default', tags = [], ttl } = options;
         let provenanceType = options.provenanceType ?? 'unknown';
         // An omitted type on an upsert means "update the value", not "erase the
         // existing trust label". New rows still receive the backward-compatible
         // unknown default.
-        if (options.upsert && options.provenanceType === undefined) {
+        if (options.upsert && !options.appendOnly && options.provenanceType === undefined) {
             try {
                 const existing = ctx.db.prepare('SELECT provenance_type FROM memory_entries WHERE namespace = ? AND key = ? LIMIT 1').get(namespace, key);
                 provenanceType = existing?.provenance_type || 'unknown';
@@ -1089,7 +1101,12 @@ export async function bridgeStoreEntry(options) {
         //                                       below → typed "already exists"
         //                                       error, NEVER a null demotion).
         // Upsert path (INSERT OR REPLACE) is unchanged.
-        const insertSql = options.upsert
+        const immutableInsertSql = `INSERT INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, provenance_type, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active')`;
+        const insertSql = options.appendOnly ? immutableInsertSql : options.upsert
             ? `INSERT OR REPLACE INTO memory_entries (
           id, key, namespace, content, type,
           embedding, embedding_dimensions, embedding_model,
@@ -1126,7 +1143,28 @@ export async function bridgeStoreEntry(options) {
         }
         catch { /* vector_indexes may not exist on legacy DBs — fall through */ }
         const stmt = ctx.db.prepare(insertSql);
-        const runResult = stmt.run(id, key, namespace, value, embeddingJson, dimensions || null, model, tags.length > 0 ? JSON.stringify(tags) : null, '{}', provenanceType, now, now, ttl ? now + (ttl * 1000) : null);
+        const insert = () => stmt.run(id, key, namespace, value, embeddingJson, dimensions || null, model, tags.length > 0 ? JSON.stringify(tags) : null, '{}', provenanceType, now, now, ttl ? now + (ttl * 1000) : null);
+        let runResult;
+        try {
+            runResult = options.appendOnly
+                ? ctx.db.transaction(() => {
+                    // Legacy native tables may predate UNIQUE(namespace,key). Serialize the exact
+                    // logical-slot check with INSERT, including tombstones, instead of trusting DDL.
+                    if (ctx.db.prepare('SELECT key FROM memory_entries WHERE namespace = ? AND key = ?').all(namespace, key).length) {
+                        throw new AppendConditionFailed('immutable append rejected: logical key already exists');
+                    }
+                    if (options.appendConditions)
+                        assertAppendConditions(ctx.db, validateAppendConditions(options.appendConditions));
+                    return insert();
+                }).immediate()
+                : insert();
+        }
+        catch (error) {
+            if (error instanceof AppendConditionFailed || error instanceof TypeError) {
+                return { success: false, id: '', error: error.message };
+            }
+            throw error;
+        }
         // A completed native write proves the bridge is currently healthy. Do not
         // retain a diagnostic from an earlier transient failure and append it to a
         // later, unrelated sql.js fallback refusal.
@@ -1143,18 +1181,21 @@ export async function bridgeStoreEntry(options) {
                 error: `key "${key}" already exists in namespace "${namespace}" — pass upsert=true (--upsert on the CLI) to update it`,
             };
         }
+        // A non-vector immutable INSERT cannot change the vector count, even with concurrent
+        // writers. Unlike historical strict mode, it never resurrects a vector tombstone.
         // #2558: keep `vector_indexes.total_vectors` accurate so status/tooling
         // stop reporting "HNSW index: 0 vectors" while embedded entries exist.
-        try {
-            ctx.db
-                .prepare(`UPDATE vector_indexes SET
+        if (!(options.appendOnly && embeddingJson === null))
+            try {
+                ctx.db
+                    .prepare(`UPDATE vector_indexes SET
              total_vectors = (SELECT COUNT(*) FROM memory_entries
                               WHERE namespace = ? AND embedding IS NOT NULL),
              updated_at = ?
            WHERE name = ?`)
-                .run(namespace, now, namespace);
-        }
-        catch { /* vector_indexes may not exist on legacy DBs — non-fatal */ }
+                    .run(namespace, now, namespace);
+            }
+            catch { /* vector_indexes may not exist on legacy DBs — non-fatal */ }
         // #2558: better-sqlite3 opens the DB in WAL mode and, for the small write
         // volumes typical of CLI usage, may never reach the auto-checkpoint
         // threshold — leaving committed rows only in the -wal file. WAL-blind

package/dist/src/memory/memory-initializer.d.ts

@@ -8,6 +8,7 @@
  *
  * @module v3/cli/memory-initializer
  */
+import type { AppendCondition } from './append-conditions.js';
 import { type EmbeddingQ8 } from './embedding-q8.js';
 /**
  * ADR-323 — typed memory provenance. Distinguishes WHO/WHAT wrote a memory
@@ -442,6 +443,9 @@ export declare function storeEntry(options: {
     ttl?: number;
     dbPath?: string;
     upsert?: boolean;
+    requireNative?: boolean;
+    appendOnly?: boolean;
+    appendConditions?: AppendCondition[];
     /** ADR-323: defaults to 'unknown' when omitted. */
     provenanceType?: string;
 }): Promise<{