brainclaw 0.28.0 → 1.5.3

package/dist/core/messaging.js

@@ -0,0 +1,278 @@
+/**
+ * Inter-agent messaging operations.
+ *
+ * Messages are stored per-recipient agent in:
+ *   .brainclaw/coordination/inbox/{agent_name}/{msg_id}.json
+ *
+ * No console.log, no process.exit, no MCP formatting.
+ * Both CLI commands and MCP handlers call these functions.
+ *
+ * @module
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { generateIdWithLabel, nowISO } from './ids.js';
+import { memoryDir } from './io.js';
+import { mutate } from './mutation-pipeline.js';
+import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
+import { InboxMessageSchema } from './schema.js';
+import { commitMemoryChange } from './memory-git.js';
+import { resolveAgentAlias } from './agent-capability.js';
+// ── Paths ───────────────────────────────────────────────────
+function inboxDir(cwd) {
+    return path.join(memoryDir(cwd), 'coordination', 'inbox');
+}
+function agentInboxDir(agent, cwd) {
+    // Resolve aliases (e.g. 'copilot' → 'github-copilot') then normalise for filesystem
+    const canonical = resolveAgentAlias(agent.toLowerCase());
+    const safe = canonical.replace(/[^a-z0-9_-]/g, '_');
+    return path.join(inboxDir(cwd), safe);
+}
+function ensureAgentInboxDir(agent, cwd) {
+    const dir = agentInboxDir(agent, cwd);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+// ── Load helpers ────────────────────────────────────────────
+function loadMessagesFromDir(dirPath) {
+    if (!fs.existsSync(dirPath))
+        return [];
+    const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+    const items = [];
+    for (const file of files) {
+        try {
+            const result = loadVersionedJsonFile('message', path.join(dirPath, file));
+            items.push(InboxMessageSchema.parse(result.document));
+        }
+        catch {
+            // skip invalid files
+        }
+    }
+    return items.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+export function sendMessage(input, cwd) {
+    return mutate({ cwd }, () => {
+        const { id, short_label } = generateIdWithLabel('inbox_messages', cwd);
+        const timestamp = nowISO();
+        const resolvedTo = resolveAgentAlias(input.to);
+        const message = {
+            id,
+            short_label,
+            from: input.from,
+            to: resolvedTo,
+            type: input.type,
+            text: input.text,
+            ref: input.ref,
+            payload: input.payload,
+            scope: input.scope,
+            requires_ack: input.requires_ack ?? false,
+            thread_id: input.thread_id,
+            status: 'pending',
+            created_at: timestamp,
+            updated_at: timestamp,
+            author: input.from,
+            author_id: input.author_id,
+            model: input.model,
+            project_id: input.project_id,
+            host_id: input.host_id,
+            session_id: input.session_id,
+            claim_id: input.claim_id,
+            assignment_id: input.assignment_id,
+            tags: input.tags ?? [],
+        };
+        const dir = ensureAgentInboxDir(input.to, cwd);
+        saveVersionedJsonFile('message', path.join(dir, `${id}.json`), message);
+        commitMemoryChange(`message ${id} sent to ${resolvedTo}`, cwd);
+        return { id, shortLabel: short_label, to: resolvedTo, type: input.type };
+    });
+}
+/** Apply all inbox filters (status, type, thread_id, claim_id) to a message list. */
+function applyInboxFilters(messages, input) {
+    let filtered = messages;
+    if (input.status)
+        filtered = filtered.filter(m => m.status === input.status);
+    if (input.type)
+        filtered = filtered.filter(m => m.type === input.type);
+    if (input.thread_id)
+        filtered = filtered.filter(m => m.thread_id === input.thread_id);
+    if (input.claimId) {
+        filtered = filtered.filter(m => m.claim_id === input.claimId ||
+            m.payload?.claim_id === input.claimId);
+    }
+    return filtered;
+}
+export function readInbox(input, cwd) {
+    const dir = agentInboxDir(input.agent, cwd);
+    // If markAsRead, do everything under a single lock to avoid race conditions.
+    // Re-read from disk inside the lock to get fresh state.
+    if (input.markAsRead) {
+        return mutate({ cwd }, () => {
+            // Fresh read inside lock
+            let messages = applyInboxFilters(loadMessagesFromDir(dir), input);
+            const total = messages.length;
+            const offset = input.offset ?? 0;
+            const limit = input.limit ?? 20;
+            const page = messages.slice(offset, offset + limit);
+            const timestamp = nowISO();
+            for (const msg of page) {
+                if (msg.status === 'pending') {
+                    msg.status = 'read';
+                    msg.read_at = timestamp;
+                    msg.updated_at = timestamp;
+                    saveVersionedJsonFile('message', path.join(dir, `${msg.id}.json`), msg);
+                }
+            }
+            commitMemoryChange(`inbox read by ${input.agent}`, cwd);
+            return { total, offset, limit, messages: page };
+        });
+    }
+    // Read-only path: no lock needed
+    let messages = applyInboxFilters(loadMessagesFromDir(dir), input);
+    const total = messages.length;
+    const offset = input.offset ?? 0;
+    const limit = input.limit ?? 20;
+    const page = messages.slice(offset, offset + limit);
+    return { total, offset, limit, messages: page };
+}
+export function ackMessage(messageId, agent, cwd) {
+    return mutate({ cwd }, () => {
+        const dir = agentInboxDir(agent, cwd);
+        const messages = loadMessagesFromDir(dir);
+        const msg = messages.find(m => m.id === messageId || m.short_label === messageId);
+        if (!msg) {
+            throw new Error(`Message '${messageId}' not found in ${agent}'s inbox.`);
+        }
+        const timestamp = nowISO();
+        msg.status = 'acknowledged';
+        msg.ack_at = timestamp;
+        msg.updated_at = timestamp;
+        saveVersionedJsonFile('message', path.join(dir, `${msg.id}.json`), msg);
+        commitMemoryChange(`message ${msg.id} acknowledged by ${agent}`, cwd);
+        return { id: msg.id, status: msg.status };
+    });
+}
+// ── Archive Message ─────────────────────────────────────────
+export function archiveMessage(messageId, agent, cwd) {
+    return mutate({ cwd }, () => {
+        const dir = agentInboxDir(agent, cwd);
+        const messages = loadMessagesFromDir(dir);
+        const msg = messages.find(m => m.id === messageId || m.short_label === messageId);
+        if (!msg) {
+            throw new Error(`Message '${messageId}' not found in ${agent}'s inbox.`);
+        }
+        msg.status = 'archived';
+        msg.updated_at = nowISO();
+        saveVersionedJsonFile('message', path.join(dir, `${msg.id}.json`), msg);
+        commitMemoryChange(`message ${msg.id} archived by ${agent}`, cwd);
+        return { id: msg.id, status: msg.status };
+    });
+}
+// ── Get Thread ──────────────────────────────────────────────
+export function getThread(threadId, cwd, options) {
+    // Search across all agent inboxes for messages in this thread
+    const baseDir = inboxDir(cwd);
+    if (!fs.existsSync(baseDir))
+        return [];
+    const agents = fs.readdirSync(baseDir).filter(f => {
+        try {
+            return fs.statSync(path.join(baseDir, f)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    const allMessages = [];
+    for (const agent of agents) {
+        const agentDir = path.join(baseDir, agent);
+        const messages = loadMessagesFromDir(agentDir);
+        allMessages.push(...messages.filter(m => m.thread_id === threadId));
+    }
+    const sorted = allMessages.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    if (options?.truncateText) {
+        const limit = options.truncateText;
+        for (const msg of sorted) {
+            if (msg.text && msg.text.length > limit) {
+                msg.text = msg.text.slice(0, limit) + '\n[...truncated]';
+            }
+        }
+    }
+    return sorted;
+}
+/**
+ * Lightweight thread message count — reads file content as raw strings
+ * and checks for the thread_id without full JSON parsing. Used for polling
+ * to avoid OOM from repeated full-message loads.
+ */
+export function getThreadCount(threadId, cwd) {
+    const baseDir = inboxDir(cwd);
+    if (!fs.existsSync(baseDir))
+        return 0;
+    let agents;
+    try {
+        agents = fs.readdirSync(baseDir).filter(f => {
+            try {
+                return fs.statSync(path.join(baseDir, f)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return 0;
+    }
+    let count = 0;
+    const needle = `"thread_id":"${threadId}"`;
+    const needleSpaced = `"thread_id": "${threadId}"`;
+    for (const agent of agents) {
+        const agentDir = path.join(baseDir, agent);
+        let files;
+        try {
+            files = fs.readdirSync(agentDir).filter(f => f.endsWith('.json'));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            try {
+                const raw = fs.readFileSync(path.join(agentDir, file), 'utf-8');
+                if (raw.includes(needle) || raw.includes(needleSpaced)) {
+                    count++;
+                }
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    return count;
+}
+// ── Count Pending ───────────────────────────────────────────
+export function countPending(agent, cwd) {
+    const dir = agentInboxDir(agent, cwd);
+    const messages = loadMessagesFromDir(dir);
+    return messages.filter(m => m.status === 'pending').length;
+}
+/**
+ * Count actionable messages: pending + read-but-requires-ack (not yet acknowledged).
+ * This is the correct metric for board/session_start — a message that has been
+ * read but not acked is still actionable.
+ */
+export function countActionable(agent, cwd) {
+    const dir = agentInboxDir(agent, cwd);
+    const messages = loadMessagesFromDir(dir);
+    return messages.filter(m => m.status === 'pending' ||
+        (m.status === 'read' && m.requires_ack)).length;
+}
+/**
+ * Check if there's already a non-archived assign message for a given plan+agent combo.
+ * Used by dispatcher to avoid duplicate assignments.
+ */
+export function hasActiveAssignment(agent, planId, cwd) {
+    const dir = agentInboxDir(agent, cwd);
+    const messages = loadMessagesFromDir(dir);
+    return messages.some(m => m.type === 'assign' &&
+        m.ref === planId &&
+        m.status !== 'archived');
+}
+//# sourceMappingURL=messaging.js.map

package/dist/core/migration.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import YAML from 'yaml';
 import { memoryDir, memoryPath, readFileSync, writeFileAtomic, resolveEntityDir } from './io.js';
-import { BootstrapApplicationReceiptSchema, BootstrapImportPlanDocumentSchema, AgentIdentityDocumentSchema, BootstrapProfileDocumentSchema, CandidateSchema, ClaimSchema, ConfigSchema, MemorySeedDocumentSchema, ConstraintSchema, CurrentSessionStateSchema, DecisionSchema, HandoffSchema, InstructionEntrySchema, PlanItemSchema, ProjectIdentityDocumentSchema, RuntimeNoteSchema, SessionSnapshotSchema, TrapSchema, AiSurfaceTaskRequestSchema, ProjectCapabilitySchema, ProjectToolSchema, } from './schema.js';
+import { BootstrapApplicationReceiptSchema, BootstrapImportPlanDocumentSchema, AgentIdentityDocumentSchema, BootstrapProfileDocumentSchema, CandidateSchema, ClaimSchema, ConfigSchema, MemorySeedDocumentSchema, ConstraintSchema, CurrentSessionStateSchema, DecisionSchema, HandoffSchema, InstructionEntrySchema, PlanItemSchema, SequenceSchema, ProjectIdentityDocumentSchema, RuntimeNoteSchema, SessionSnapshotSchema, TrapSchema, AiSurfaceTaskRequestSchema, ProjectCapabilitySchema, ProjectToolSchema, InboxMessageSchema, AssignmentSchema, AgentRunSchema, ActionRequiredSchema, } from './schema.js';
 export class MigrationError extends Error {
     kind;
     documentType;
@@ -14,6 +14,7 @@ export class MigrationError extends Error {
     }
 }
 const CURRENT_SCHEMA_VERSION = 2;
+const NON_MESSAGE_INBOX_SUBDIRS = new Set(['accepted', 'rejected', 'cross-project']);
 const registry = {
     agent_identity: createRegistryEntry(AgentIdentityDocumentSchema),
     bootstrap_application: createRegistryEntry(BootstrapApplicationReceiptSchema),
@@ -29,6 +30,7 @@ const registry = {
     instruction: createRegistryEntry(InstructionEntrySchema),
     memory_seed: createRegistryEntry(MemorySeedDocumentSchema),
     plan: createRegistryEntry(PlanItemSchema),
+    sequence: createRegistryEntry(SequenceSchema),
     project_identity: createRegistryEntry(ProjectIdentityDocumentSchema),
     runtime_note: createRegistryEntry(RuntimeNoteSchema),
     ai_surface_task: createRegistryEntry(AiSurfaceTaskRequestSchema),
@@ -36,6 +38,10 @@ const registry = {
     capability: createRegistryEntry(ProjectCapabilitySchema),
     tool: createRegistryEntry(ProjectToolSchema),
     trap: createRegistryEntry(TrapSchema),
+    message: createRegistryEntry(InboxMessageSchema),
+    assignment: createRegistryEntry(AssignmentSchema),
+    agent_run: createRegistryEntry(AgentRunSchema),
+    action_required: createRegistryEntry(ActionRequiredSchema),
 };
 function createRegistryEntry(schema) {
     return {
@@ -160,7 +166,9 @@ export function scanMigrationStatus(cwd) {
     collectDirectory(entries, resolveEntityDir('traps-private', effectiveCwd, 'read'), 'trap', true);
     collectDirectory(entries, resolveEntityDir('handoffs', effectiveCwd, 'read'), 'handoff');
     collectDirectory(entries, resolveEntityDir('plans', effectiveCwd, 'read'), 'plan');
+    collectDirectory(entries, resolveEntityDir('sequences', effectiveCwd, 'read'), 'sequence');
     collectDirectory(entries, resolveEntityDir('inbox', effectiveCwd, 'read'), 'candidate');
+    collectInboxMessages(entries, resolveEntityDir('inbox', effectiveCwd, 'read'));
     collectDirectory(entries, resolveEntityDir('inbox/accepted', effectiveCwd, 'read'), 'candidate');
     collectDirectory(entries, resolveEntityDir('inbox/rejected', effectiveCwd, 'read'), 'candidate');
     collectDirectory(entries, resolveEntityDir('claims', effectiveCwd, 'read'), 'claim');
@@ -168,6 +176,8 @@ export function scanMigrationStatus(cwd) {
     collectDirectory(entries, resolveEntityDir('runtime-hosts', effectiveCwd, 'read'), 'runtime_note', true);
     collectDirectory(entries, resolveEntityDir('runtime-private', effectiveCwd, 'read'), 'runtime_note', true);
     collectDirectory(entries, resolveEntityDir('surface-tasks', effectiveCwd, 'read'), 'ai_surface_task');
+    collectDirectory(entries, resolveEntityDir('runs', effectiveCwd, 'read'), 'agent_run');
+    collectDirectory(entries, resolveEntityDir('actions', effectiveCwd, 'read'), 'action_required');
     collectDirectory(entries, resolveEntityDir('instructions', effectiveCwd, 'read'), 'instruction');
     collectDirectory(entries, path.join(resolveEntityDir('bootstrap', effectiveCwd, 'read'), 'seeds'), 'memory_seed');
     collectDirectory(entries, resolveEntityDir('agents', effectiveCwd, 'read'), 'agent_identity');
@@ -188,6 +198,27 @@ function collectDirectory(entries, dirPath, documentType, recursive = false) {
         entries.push(buildCheckEntry(filepath, documentType));
     }
 }
+function collectInboxMessages(entries, inboxRoot) {
+    if (!fs.existsSync(inboxRoot)) {
+        return;
+    }
+    for (const entry of fs.readdirSync(inboxRoot).sort()) {
+        const fullPath = path.join(inboxRoot, entry);
+        let stat;
+        try {
+            stat = fs.statSync(fullPath);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory() || NON_MESSAGE_INBOX_SUBDIRS.has(entry)) {
+            continue;
+        }
+        for (const filepath of listJsonFiles(fullPath, true)) {
+            entries.push(buildCheckEntry(filepath, 'message'));
+        }
+    }
+}
 function listJsonFiles(dirPath, recursive) {
     if (!fs.existsSync(dirPath)) {
         return [];

package/dist/core/mutation-pipeline.js

@@ -19,11 +19,13 @@ export function mutate(optionsOrFn, maybeFn) {
     const fn = typeof optionsOrFn === 'function' ? optionsOrFn : maybeFn;
     const cwd = options.cwd ?? process.cwd();
     const timeoutMs = options.timeoutMs ?? STORE_LOCK_TIMEOUT_MS;
-    ensureMemoryDir(cwd, options.preferredDirName);
     const lockTarget = storeLockPath(cwd, options.preferredDirName);
     const start = performance.now();
     try {
-        const value = withLock(lockTarget, () => fn(cwd), timeoutMs);
+        const value = withLock(lockTarget, () => {
+            ensureMemoryDir(cwd, options.preferredDirName);
+            return fn(cwd);
+        }, timeoutMs);
         const durationMs = performance.now() - start;
         if (durationMs > 1_000) {
             logger.debug(`Slow mutation: ${durationMs.toFixed(0)}ms (cwd=${cwd})`);

package/dist/core/operations/memory-mutation.js

@@ -0,0 +1,129 @@
+/**
+ * Pure business logic for updating and deleting memory items across store chains.
+ *
+ * Handles constraint, decision, and trap mutations with store chain resolution.
+ * No console.log, no process.exit, no MCP formatting.
+ *
+ * @module
+ */
+import { loadState, persistState } from '../state.js';
+import { resolveStoreChain, resolveTargetStore } from '../store-resolution.js';
+/**
+ * Walk the store chain to find a memory item by type and id.
+ * Searches by both id and short_label.
+ */
+export function findMemoryItemInChain(itemId, itemType, cwd) {
+    const chain = resolveStoreChain(cwd);
+    for (const store of chain) {
+        const state = loadState(store.cwd);
+        let item;
+        if (itemType === 'constraint') {
+            item = state.active_constraints.find((c) => c.id === itemId || c.short_label === itemId);
+        }
+        else if (itemType === 'decision') {
+            item = state.recent_decisions.find((d) => d.id === itemId || d.short_label === itemId);
+        }
+        else if (itemType === 'trap') {
+            item = state.known_traps.find((t) => t.id === itemId || t.short_label === itemId);
+        }
+        if (item) {
+            return { item, store, itemType };
+        }
+    }
+    return undefined;
+}
+export function deleteMemoryItem(itemId, itemType, cwd) {
+    const found = findMemoryItemInChain(itemId, itemType, cwd);
+    if (!found) {
+        throw new Error(`${itemType} with id '${itemId}' not found in any store`);
+    }
+    const state = loadState(found.store.cwd);
+    if (itemType === 'constraint') {
+        state.active_constraints = state.active_constraints.filter((c) => c.id !== itemId && c.short_label !== itemId);
+    }
+    else if (itemType === 'decision') {
+        state.recent_decisions = state.recent_decisions.filter((d) => d.id !== itemId && d.short_label !== itemId);
+    }
+    else if (itemType === 'trap') {
+        state.known_traps = state.known_traps.filter((t) => t.id !== itemId && t.short_label !== itemId);
+    }
+    persistState(state, found.store.cwd);
+    return {
+        deletedId: itemId,
+        itemType,
+        storeRole: found.store.role,
+    };
+}
+export function updateMemoryItem(input, cwd) {
+    const found = findMemoryItemInChain(input.id, input.type, cwd);
+    if (!found) {
+        throw new Error(`${input.type} with id '${input.id}' not found in any store`);
+    }
+    const { item, store: sourceStore } = found;
+    const previousStore = sourceStore.role;
+    // Apply field updates
+    if (input.text)
+        item.text = input.text;
+    if (input.tags)
+        item.tags = input.tags;
+    if (input.status && input.type === 'trap') {
+        item.status = input.status;
+    }
+    if (input.patch) {
+        Object.assign(item, input.patch);
+    }
+    if (input.moveToStore) {
+        const targetCwd = resolveTargetStore(cwd, input.moveToStore);
+        // Delete from source
+        const sourceState = loadState(sourceStore.cwd);
+        if (input.type === 'constraint') {
+            sourceState.active_constraints = sourceState.active_constraints.filter((c) => c.id !== input.id);
+        }
+        else if (input.type === 'decision') {
+            sourceState.recent_decisions = sourceState.recent_decisions.filter((d) => d.id !== input.id);
+        }
+        else if (input.type === 'trap') {
+            sourceState.known_traps = sourceState.known_traps.filter((t) => t.id !== input.id);
+        }
+        persistState(sourceState, sourceStore.cwd);
+        // Add to target
+        const targetState = loadState(targetCwd);
+        if (input.type === 'constraint') {
+            targetState.active_constraints.push(item);
+        }
+        else if (input.type === 'decision') {
+            targetState.recent_decisions.push(item);
+        }
+        else if (input.type === 'trap') {
+            targetState.known_traps.push(item);
+        }
+        persistState(targetState, targetCwd);
+    }
+    else {
+        // Update in place
+        const state = loadState(sourceStore.cwd);
+        if (input.type === 'constraint') {
+            const idx = state.active_constraints.findIndex((c) => c.id === input.id);
+            if (idx >= 0)
+                state.active_constraints[idx] = item;
+        }
+        else if (input.type === 'decision') {
+            const idx = state.recent_decisions.findIndex((d) => d.id === input.id);
+            if (idx >= 0)
+                state.recent_decisions[idx] = item;
+        }
+        else if (input.type === 'trap') {
+            const idx = state.known_traps.findIndex((t) => t.id === input.id);
+            if (idx >= 0)
+                state.known_traps[idx] = item;
+        }
+        persistState(state, sourceStore.cwd);
+    }
+    return {
+        updatedId: input.id,
+        itemType: input.type,
+        previousStore,
+        newStore: input.moveToStore,
+    };
+}
+//# sourceMappingURL=memory-mutation.js.map

package/dist/core/operations/memory-write.js

@@ -0,0 +1,78 @@
+/**
+ * Pure business logic for creating memory items (decision, constraint, trap).
+ *
+ * No console.log, no process.exit, no MCP formatting.
+ * Both CLI commands and MCP handlers call these functions.
+ *
+ * @module
+ */
+import { mutateState } from '../state.js';
+import { generateIdWithLabel, nowISO } from '../ids.js';
+import { generateTrapIdWithLabel, saveOperationalTrap } from '../traps.js';
+export function createDecision(input, cwd) {
+    const result = mutateState((state) => {
+        const { id, short_label } = generateIdWithLabel('recent_decisions', cwd);
+        const entry = {
+            id,
+            short_label,
+            text: input.text,
+            created_at: nowISO(),
+            author: input.author,
+            outcome: input.outcome,
+            tags: input.tags ?? [],
+            related_paths: input.relatedPaths,
+            plan_id: input.planId,
+        };
+        state.recent_decisions.push(entry);
+        return { id, shortLabel: short_label, text: input.text };
+    }, cwd);
+    return result;
+}
+export function createConstraint(input, cwd) {
+    const result = mutateState((state) => {
+        const { id, short_label } = generateIdWithLabel('active_constraints', cwd);
+        const entry = {
+            id,
+            short_label,
+            text: input.text,
+            created_at: nowISO(),
+            author: input.author,
+            status: 'active',
+            category: input.category,
+            tags: input.tags ?? [],
+            related_paths: input.relatedPaths,
+        };
+        state.active_constraints.push(entry);
+        return { id, shortLabel: short_label, text: input.text };
+    }, cwd);
+    return result;
+}
+export function createTrap(input, cwd) {
+    const visibility = input.visibility ?? 'shared';
+    const { id, short_label } = generateTrapIdWithLabel();
+    const entry = {
+        id,
+        short_label,
+        text: input.text,
+        created_at: nowISO(),
+        author: input.author,
+        status: input.status ?? 'active',
+        severity: input.severity ?? 'medium',
+        tags: input.tags ?? [],
+        related_paths: input.relatedPaths,
+        plan_id: input.planId,
+        visibility,
+        host_id: input.hostId,
+        expires_at: input.expiresAt,
+    };
+    if (visibility === 'shared') {
+        mutateState((state) => {
+            state.known_traps.push(entry);
+        }, cwd);
+    }
+    else {
+        saveOperationalTrap(entry, cwd);
+    }
+    return { id, shortLabel: short_label, text: input.text, visibility, hostId: input.hostId };
+}
+//# sourceMappingURL=memory-write.js.map