brainclaw 0.29.2 → 1.5.3

package/dist/core/staleness.js

@@ -0,0 +1,246 @@
+/**
+ * Lightweight staleness detection for brainclaw memory entities.
+ *
+ * Staleness is a soft signal — items are warned, not auto-archived.
+ * Users choose to dismiss, resolve, or archive via explicit commands.
+ */
+import { resolvedSource } from './candidates.js';
+/** Thresholds in days. Adjust via config in the future. */
+export const STALENESS_THRESHOLDS = {
+    /** in_progress plan with no update in N days */
+    plan_in_progress_days: 7,
+    /** todo/blocked plan not started in N days */
+    plan_idle_days: 30,
+    /** open handoff older than N days */
+    handoff_open_days: 14,
+    /** pending candidate older than N days */
+    candidate_pending_days: 21,
+    /** auto-generated pending candidate older than N days */
+    candidate_auto_pending_days: 30,
+    /**
+     * Observation runtime_note older than N days without explicit
+     * expiry. Session start/end notes are transient by nature and
+     * never flagged regardless of age.
+     */
+    runtime_note_observation_days: 30,
+};
+function ageDays(isoDate, nowMs) {
+    return Math.floor((nowMs - Date.parse(isoDate)) / 86_400_000);
+}
+function truncate(text, max = 80) {
+    return text.length > max ? text.slice(0, max - 3) + '...' : text;
+}
+/**
+ * Detect stale plans based on status and last-update age.
+ * Returns one warning per stale plan.
+ */
+export function detectStalePlans(plans, nowMs = Date.now(), thresholds = STALENESS_THRESHOLDS) {
+    const warnings = [];
+    for (const plan of plans) {
+        if (plan.status === 'done' || plan.status === 'dropped')
+            continue;
+        // Use most recent step update, fall back to plan updated_at, then created_at
+        const lastActivity = getLastPlanActivity(plan);
+        const age = ageDays(lastActivity, nowMs);
+        if (plan.status === 'in_progress' && age >= thresholds.plan_in_progress_days) {
+            warnings.push({
+                id: plan.id,
+                entity: 'plan',
+                text: truncate(plan.text),
+                age_days: age,
+                reason: `Plan in_progress for ${age} day${age === 1 ? '' : 's'} without recent activity`,
+                suggested_action: `brainclaw plan update ${plan.short_label ?? plan.id} --status done  # or --status dropped`,
+            });
+        }
+        else if ((plan.status === 'todo' || plan.status === 'blocked') && age >= thresholds.plan_idle_days) {
+            warnings.push({
+                id: plan.id,
+                entity: 'plan',
+                text: truncate(plan.text),
+                age_days: age,
+                reason: `Plan ${plan.status} for ${age} day${age === 1 ? '' : 's'} without progress`,
+                suggested_action: `brainclaw plan update ${plan.short_label ?? plan.id} --status in_progress  # or --status dropped`,
+            });
+        }
+    }
+    return warnings;
+}
+function getLastPlanActivity(plan) {
+    // If steps exist, find the most recently updated step
+    if (plan.steps && plan.steps.length > 0) {
+        const stepDates = plan.steps.map((s) => s.updated_at).filter(Boolean);
+        if (stepDates.length > 0) {
+            const latest = stepDates.reduce((a, b) => (a > b ? a : b));
+            // Only use step date if it's more recent than plan.updated_at
+            if (latest > plan.updated_at)
+                return latest;
+        }
+    }
+    return plan.updated_at;
+}
+/**
+ * Detect traps that have passed their expiry date but are still marked active.
+ */
+export function detectExpiredTraps(traps, nowIso = new Date().toISOString(), nowMs = Date.now()) {
+    const warnings = [];
+    for (const trap of traps) {
+        if (trap.status !== 'active')
+            continue;
+        if (!trap.expires_at || trap.expires_at > nowIso)
+            continue;
+        const age = ageDays(trap.expires_at, nowMs);
+        warnings.push({
+            id: trap.id,
+            entity: 'trap',
+            text: truncate(trap.text),
+            age_days: age,
+            reason: `Trap expired ${age} day${age === 1 ? '' : 's'} ago (expires_at: ${trap.expires_at.slice(0, 10)})`,
+            suggested_action: `brainclaw trap resolve ${trap.short_label ?? trap.id}`,
+        });
+    }
+    return warnings;
+}
+/**
+ * Detect open handoffs that have not been acted on for a long time.
+ */
+export function detectStaleHandoffs(handoffs, nowMs = Date.now(), thresholds = STALENESS_THRESHOLDS) {
+    const warnings = [];
+    for (const handoff of handoffs) {
+        if (handoff.status !== 'open')
+            continue;
+        const age = ageDays(handoff.created_at, nowMs);
+        if (age >= thresholds.handoff_open_days) {
+            warnings.push({
+                id: handoff.id,
+                entity: 'handoff',
+                text: truncate(handoff.text),
+                age_days: age,
+                reason: `Open handoff from ${handoff.from} → ${handoff.to} has been open for ${age} day${age === 1 ? '' : 's'}`,
+                suggested_action: `brainclaw update-handoff ${handoff.short_label ?? handoff.id} --status closed  # or accept the handoff`,
+            });
+        }
+    }
+    return warnings;
+}
+/**
+ * Detect candidates that have been pending without a decision for a long time.
+ */
+export function detectStaleCandidates(candidates, nowMs = Date.now(), thresholds = STALENESS_THRESHOLDS) {
+    const warnings = [];
+    for (const candidate of candidates) {
+        if (candidate.status !== 'pending')
+            continue;
+        const age = ageDays(candidate.created_at, nowMs);
+        const source = resolvedSource(candidate);
+        const threshold = source === 'auto'
+            ? thresholds.candidate_auto_pending_days
+            : thresholds.candidate_pending_days;
+        if (age >= threshold) {
+            const sourceLabel = source === 'auto' ? 'Auto-generated' : 'Pending';
+            warnings.push({
+                id: candidate.id,
+                entity: 'candidate',
+                text: truncate(candidate.text),
+                age_days: age,
+                reason: `${sourceLabel} ${candidate.type} candidate for ${age} day${age === 1 ? '' : 's'} — no accept/reject decision`,
+                suggested_action: `brainclaw accept ${candidate.short_label ?? candidate.id}  # or: brainclaw reject ${candidate.short_label ?? candidate.id}`,
+            });
+        }
+    }
+    return warnings;
+}
+/**
+ * Detect observation runtime_notes older than the threshold that
+ * lack an explicit `expires_at`. Session start/end notes are
+ * transient markers and never flagged.
+ *
+ * Notes with `expires_at` in the future are treated as operator-managed
+ * and skipped. Notes that have already expired are flagged separately
+ * with a short age relative to the expiry (matches the trap pattern).
+ */
+export function detectStaleRuntimeNotes(notes, nowMs = Date.now(), thresholds = STALENESS_THRESHOLDS) {
+    const warnings = [];
+    const nowIso = new Date(nowMs).toISOString();
+    for (const note of notes) {
+        if (note.note_type !== 'observation')
+            continue;
+        // Honour operator-set expiries: expired → flag with the expiry age.
+        if (note.expires_at) {
+            if (note.expires_at > nowIso)
+                continue; // not yet expired
+            const age = ageDays(note.expires_at, nowMs);
+            warnings.push({
+                id: note.id,
+                entity: 'runtime_note',
+                text: truncate(note.text),
+                age_days: age,
+                reason: `Runtime note expired ${age} day${age === 1 ? '' : 's'} ago (expires_at: ${note.expires_at.slice(0, 10)})`,
+                suggested_action: `bclaw_remove(entity: "runtime_note", id: "${note.id}")`,
+            });
+            continue;
+        }
+        const age = ageDays(note.created_at, nowMs);
+        if (age >= thresholds.runtime_note_observation_days) {
+            warnings.push({
+                id: note.id,
+                entity: 'runtime_note',
+                text: truncate(note.text),
+                age_days: age,
+                reason: `Observation runtime note from ${note.agent} is ${age} day${age === 1 ? '' : 's'} old with no expiry set`,
+                suggested_action: `bclaw_remove(entity: "runtime_note", id: "${note.id}")  # or bclaw_update to set expires_at`,
+            });
+        }
+    }
+    return warnings;
+}
+/**
+ * Run all staleness detectors and return a combined report.
+ * Warnings are sorted by age (oldest first) so the most urgent surface first.
+ *
+ * @param plans Active (non-done/non-dropped) plans
+ * @param traps All known traps (active)
+ * @param handoffs Open handoffs
+ * @param candidates Pending candidates
+ * @param nowMs Optional timestamp override (for testing)
+ */
+export function detectStaleness(plans, traps, handoffs, candidates, nowMs = Date.now(), runtimeNotes = []) {
+    const nowIso = new Date(nowMs).toISOString();
+    const planWarnings = detectStalePlans(plans, nowMs);
+    const trapWarnings = detectExpiredTraps(traps, nowIso, nowMs);
+    const handoffWarnings = detectStaleHandoffs(handoffs, nowMs);
+    const candidateWarnings = detectStaleCandidates(candidates, nowMs);
+    const noteWarnings = detectStaleRuntimeNotes(runtimeNotes, nowMs);
+    const warnings = [
+        ...planWarnings,
+        ...trapWarnings,
+        ...handoffWarnings,
+        ...candidateWarnings,
+        ...noteWarnings,
+    ].sort((a, b) => b.age_days - a.age_days);
+    return {
+        warnings,
+        plan_count: planWarnings.length,
+        trap_count: trapWarnings.length,
+        handoff_count: handoffWarnings.length,
+        candidate_count: candidateWarnings.length,
+        runtime_note_count: noteWarnings.length,
+    };
+}
+/** Total warning count across all entity types. */
+export function staleSummary(report) {
+    if (report.warnings.length === 0)
+        return 'No stale items detected';
+    const parts = [];
+    if (report.plan_count > 0)
+        parts.push(`${report.plan_count} plan${report.plan_count > 1 ? 's' : ''}`);
+    if (report.trap_count > 0)
+        parts.push(`${report.trap_count} expired trap${report.trap_count > 1 ? 's' : ''}`);
+    if (report.handoff_count > 0)
+        parts.push(`${report.handoff_count} open handoff${report.handoff_count > 1 ? 's' : ''}`);
+    if (report.candidate_count > 0)
+        parts.push(`${report.candidate_count} pending candidate${report.candidate_count > 1 ? 's' : ''}`);
+    if (report.runtime_note_count > 0)
+        parts.push(`${report.runtime_note_count} stale runtime note${report.runtime_note_count > 1 ? 's' : ''}`);
+    return parts.join(', ');
+}
+//# sourceMappingURL=staleness.js.map

package/dist/core/state.js

@@ -7,6 +7,8 @@ import { commitMemoryChange } from './memory-git.js';
 import { appendEvent } from './event-log.js';
 import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
 import { rebuildProjectMd } from './markdown.js';
+import { refreshLiveCompanions } from '../commands/export.js';
+import { logger } from './logger.js';
 export function emptyState() {
     return {
         version: 1,
@@ -27,8 +29,10 @@ function loadDirectoryItems(dirPath, schema, documentType) {
         try {
             items.push(schema.parse(loadVersionedJsonFile(documentType, path.join(dirPath, file)).document));
         }
-        catch {
-            // skip invalid files
+        catch (error) {
+            // Record-level schema failure. We preserve the file on disk (see syncDirectory)
+            // so nothing is silently lost, but surface the drift so operators can repair.
+            logger.warn(`Invalid ${documentType} file ${file} in ${dirPath}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     return items;
@@ -50,7 +54,7 @@ export function loadState(cwd) {
     state.plan_items.sort((a, b) => a.created_at.localeCompare(b.created_at));
     return state;
 }
-function syncDirectory(dirPath, items, documentType) {
+function syncDirectory(dirPath, items, documentType, schema) {
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
@@ -61,41 +65,113 @@ function syncDirectory(dirPath, items, documentType) {
         const filepath = path.join(dirPath, `${item.id}.json`);
         saveVersionedJsonFile(documentType, filepath, item);
     }
-    // Remove files that are no longer in the state (e.g. if deleted/pruned)
+    // Remove files that are no longer in the state (e.g. if deleted/pruned).
+    // CRITICAL: we must distinguish "file dropped from state intentionally" from
+    // "file silently dropped by loadDirectoryItems because its schema.parse threw".
+    // Deleting the second kind corrupts data (see trap: silent-data-loss via
+    // load-swallow + write-sync-GC). So before unlinking, we re-validate the file
+    // against the schema. Parseable + not in state = intentional remove → unlink.
+    // Unparseable = preserved, operator can inspect/repair.
     const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
     for (const file of files) {
         const id = file.replace('.json', '');
-        if (!currentIds.has(id)) {
-            fs.unlinkSync(path.join(dirPath, file));
+        if (currentIds.has(id))
+            continue;
+        const filepath = path.join(dirPath, file);
+        let parseable = false;
+        try {
+            schema.parse(loadVersionedJsonFile(documentType, filepath).document);
+            parseable = true;
+        }
+        catch {
+            // Already logged by loadDirectoryItems — leave the file in place.
+        }
+        if (parseable) {
+            fs.unlinkSync(filepath);
         }
     }
 }
 export function saveState(state, cwd) {
     persistState(state, cwd, { writeProjectMarkdown: false });
 }
+function persistStateUnlocked(state, cwd, options = {}) {
+    writeStateDirectories(state, cwd);
+    if (options.writeProjectMarkdown ?? true) {
+        rebuildProjectMd(state, cwd);
+    }
+    appendEvent({
+        action: options.eventAction ?? 'update',
+        item_type: 'state',
+        agent: 'system',
+        summary: options.eventSummary,
+    }, cwd);
+    commitMemoryChange(options.commitMessage ?? 'state update', cwd);
+    // Auto-refresh live companion files (Tier B/C agents) after state mutations.
+    // Non-fatal: failures are logged but don't break the mutation.
+    try {
+        refreshLiveCompanions(cwd);
+    }
+    catch { /* best-effort */ }
+}
+function cleanupLegacyDir(entityName, currentIds, cwd, documentType, schema) {
+    const writeDir = resolveEntityDir(entityName, cwd, 'write');
+    const readDir = resolveEntityDir(entityName, cwd, 'read');
+    // If read resolves to a different (legacy) directory, clean orphans there too.
+    // Match syncDirectory's safety condition: only delete parseable records that
+    // are absent from the current state. Schema-invalid legacy files may be drifted
+    // data that operators still need to inspect or repair.
+    if (readDir !== writeDir && fs.existsSync(readDir)) {
+        const files = fs.readdirSync(readDir).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            const id = file.replace('.json', '');
+            if (currentIds.has(id))
+                continue;
+            const filepath = path.join(readDir, file);
+            let parseable = false;
+            try {
+                schema.parse(loadVersionedJsonFile(documentType, filepath).document);
+                parseable = true;
+            }
+            catch {
+                logger.warn(`Preserving unparseable legacy ${entityName} file ${file}`);
+                continue;
+            }
+            if (parseable) {
+                fs.unlinkSync(filepath);
+            }
+        }
+    }
+}
 function writeStateDirectories(state, cwd) {
     ensureMemoryDir(cwd);
     const effectiveCwd = cwd ?? process.cwd();
-    syncDirectory(resolveEntityDir('constraints', effectiveCwd, 'write'), state.active_constraints, 'constraint');
-    syncDirectory(resolveEntityDir('decisions', effectiveCwd, 'write'), state.recent_decisions, 'decision');
-    syncDirectory(resolveEntityDir('traps', effectiveCwd, 'write'), state.known_traps, 'trap');
-    syncDirectory(resolveEntityDir('handoffs', effectiveCwd, 'write'), state.open_handoffs, 'handoff');
-    syncDirectory(resolveEntityDir('plans', effectiveCwd, 'write'), state.plan_items, 'plan');
+    const entities = [
+        { name: 'constraints', items: state.active_constraints, docType: 'constraint', schema: ConstraintSchema },
+        { name: 'decisions', items: state.recent_decisions, docType: 'decision', schema: DecisionSchema },
+        { name: 'traps', items: state.known_traps, docType: 'trap', schema: TrapSchema },
+        { name: 'handoffs', items: state.open_handoffs, docType: 'handoff', schema: HandoffSchema },
+        { name: 'plans', items: state.plan_items, docType: 'plan', schema: PlanItemSchema },
+    ];
+    for (const { name, items, docType, schema } of entities) {
+        const writeDir = resolveEntityDir(name, effectiveCwd, 'write');
+        syncDirectory(writeDir, items, docType, schema);
+        const currentIds = new Set(items.map(item => item.id));
+        cleanupLegacyDir(name, currentIds, effectiveCwd, docType, schema);
+    }
 }
 export function persistState(state, cwd, options = {}) {
     const effectiveCwd = cwd ?? process.cwd();
     mutate({ cwd: effectiveCwd }, () => {
-        writeStateDirectories(state, effectiveCwd);
-        if (options.writeProjectMarkdown ?? true) {
-            rebuildProjectMd(state, effectiveCwd);
-        }
-        appendEvent({
-            action: options.eventAction ?? 'update',
-            item_type: 'state',
-            agent: 'system',
-            summary: options.eventSummary,
-        }, effectiveCwd);
-        commitMemoryChange(options.commitMessage ?? 'state update', effectiveCwd);
+        persistStateUnlocked(state, effectiveCwd, options);
+    });
+}
+export function mutateState(mutateFn, cwd, options = {}) {
+    const effectiveCwd = cwd ?? process.cwd();
+    return mutate({ cwd: effectiveCwd }, () => {
+        const state = loadState(effectiveCwd);
+        const result = mutateFn(state);
+        persistStateUnlocked(state, effectiveCwd, options);
+        return result;
     });
 }
 //# sourceMappingURL=state.js.map

package/dist/core/store-resolution.js

@@ -91,17 +91,24 @@ export function resolveTargetStore(cwd = process.cwd(), target = 'local', option
  *
  * Priority:
  * 1. explicitCwd (--cwd flag)
- * 2. BRAINCLAW_PROJECT env var → resolved by name/path from workspace
- * 3. Session-scoped active project (from .current-session)
- * 4. Global active-project.json in workspace root
- * 5. process.cwd()
+ * 2. BRAINCLAW_CWD env var → absolute workspace path injected by MCP configs
+ * 3. BRAINCLAW_PROJECT env var → resolved by name/path from workspace
+ * 4. Session-scoped active project (from .current-session)
+ * 5. Global active-project.json in workspace root
+ * 6. process.cwd()
  */
 export function resolveEffectiveCwd(options = {}) {
     // 1. Explicit --cwd flag
     if (options.explicitCwd) {
         return path.resolve(options.explicitCwd);
     }
-    // 2. BRAINCLAW_PROJECT env var
+    // 2. BRAINCLAW_CWD env var — set by MCP configs to bind to the workspace
+    //    regardless of the IDE's process.cwd() at launch time
+    const envCwd = process.env.BRAINCLAW_CWD?.trim();
+    if (envCwd && fs.existsSync(path.join(path.resolve(envCwd), MEMORY_DIR, 'config.yaml'))) {
+        return path.resolve(envCwd);
+    }
+    // 3. BRAINCLAW_PROJECT env var
     const envProject = process.env.BRAINCLAW_PROJECT;
     if (envProject) {
         const resolved = resolveProjectRef(envProject, process.cwd(), options.storeChainOptions);
@@ -143,7 +150,10 @@ export function resolveWorkspaceRoot(cwd = process.cwd(), options = {}) {
  * Returns undefined when the reference cannot be resolved to a valid brainclaw project.
  */
 export function resolveProjectRef(ref, cwd = process.cwd(), storeChainOptions) {
-    const wsRoot = resolveWorkspaceRoot(cwd, storeChainOptions);
+    // Walk UP from real cwd to find the outermost .brainclaw/ — this avoids
+    // circular resolution when an active project narrows the workspace view.
+    const wsRoot = findOutermostBrainclawRoot(process.cwd())
+        ?? resolveWorkspaceRoot(cwd, storeChainOptions);
     if (!wsRoot)
         return undefined;
     // Try as absolute path
@@ -155,27 +165,29 @@ export function resolveProjectRef(ref, cwd = process.cwd(), storeChainOptions) {
     if (fs.existsSync(path.join(asPath, MEMORY_DIR, 'config.yaml'))) {
         return asPath;
     }
-    // Try by project name: scan child stores for matching project_name
+    // Try by project name or project ID: scan child stores
     const chain = resolveStoreChain(wsRoot, storeChainOptions);
     for (const store of chain) {
         if (store.cwd === wsRoot)
-            continue; // skip workspace itself
+            continue;
         try {
             const config = loadConfig(store.cwd);
-            if (config.project_name === ref)
+            if (config.project_name === ref || config.project_id === ref)
                 return store.cwd;
         }
         catch {
             // skip unreadable configs
         }
     }
-    // Try discovering child projects by scanning filesystem
+    // Try discovering child projects by scanning filesystem (deep scan for monorepos)
     try {
         const wsConfig = loadConfig(wsRoot);
         const summary = summarizeWorkspaceProjects(wsRoot, wsConfig);
         for (const project of summary.discovered_projects) {
             const projectPath = path.resolve(wsRoot, project.path);
-            if (project.project_name === ref) {
+            if (project.project_name === ref
+                || project.project_id === ref
+                || path.basename(project.path) === ref) {
                 if (fs.existsSync(path.join(projectPath, MEMORY_DIR, 'config.yaml'))) {
                     return projectPath;
                 }
@@ -187,6 +199,26 @@ export function resolveProjectRef(ref, cwd = process.cwd(), storeChainOptions) {
     }
     return undefined;
 }
+/**
+ * Walk UP from a directory and return the outermost .brainclaw/ root found.
+ * This bypasses resolveEffectiveCwd / active project to find the true workspace root.
+ */
+export function findOutermostBrainclawRoot(startDir) {
+    let dir = path.resolve(startDir);
+    const root = path.parse(dir).root;
+    const home = os.homedir();
+    let outermost;
+    while (dir !== root && dir !== home) {
+        if (fs.existsSync(path.join(dir, MEMORY_DIR, 'config.yaml'))) {
+            outermost = dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return outermost;
+}
 /**
  * Resolve the most specific child store that should answer a context request.
  *

package/dist/core/toml-writer.js

@@ -0,0 +1,76 @@
+/**
+ * Minimal TOML writer for the small subset brainclaw needs (Mistral Vibe MCP
+ * config). Zero runtime dependency by policy. Supports:
+ *   - inline tables `[name]`
+ *   - array-of-tables `[[name]]`
+ *   - string keys
+ *   - string and string-array values
+ *   - basic escaping for strings (`\` and `"` and control chars)
+ *
+ * Does NOT support: numbers, booleans, dates, nested tables, mixed-type arrays,
+ * multi-line strings, comments. If you need any of those, reach for `@iarna/toml`
+ * — but every brainclaw call site so far fits this subset.
+ */
+/** Escape a string for a TOML basic string literal. */
+export function escapeTomlString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+}
+function renderValue(value) {
+    if (Array.isArray(value)) {
+        const items = value.map((v) => `"${escapeTomlString(v)}"`).join(', ');
+        return `[${items}]`;
+    }
+    return `"${escapeTomlString(value)}"`;
+}
+function renderTable(name, entries, header) {
+    const close = header === '[[' ? ']]' : ']';
+    const lines = [`${header}${name}${close}`];
+    for (const [key, value] of Object.entries(entries)) {
+        lines.push(`${key} = ${renderValue(value)}`);
+    }
+    return lines.join('\n');
+}
+/** Serialize a TomlDocument to a string. Tables come first, then array-of-tables. */
+export function renderToml(doc) {
+    const blocks = [];
+    for (const table of doc.tables ?? []) {
+        blocks.push(renderTable(table.name, table.entries, '['));
+    }
+    for (const arrayTable of doc.arrayTables ?? []) {
+        for (const entry of arrayTable.entries) {
+            blocks.push(renderTable(arrayTable.name, entry, '[['));
+        }
+    }
+    return blocks.join('\n\n') + (blocks.length > 0 ? '\n' : '');
+}
+/**
+ * Heuristic line-based check for "does this TOML already declare a
+ * [[<sectionName>]] block whose `name = "<entryName>"` field matches?".
+ * Used by writers to remain idempotent without a full TOML parser.
+ *
+ * Limitations: assumes the `name = "..."` field appears in the first ~10 lines
+ * after the `[[sectionName]]` header (true for our writer's output and for
+ * hand-written files that follow the convention `name` first).
+ */
+export function tomlArrayTableHasEntry(source, sectionName, entryNameValue) {
+    const headerPattern = new RegExp(String.raw `^\[\[\s*${escapeRegex(sectionName)}\s*\]\]\s*$`);
+    const namePattern = new RegExp(String.raw `^name\s*=\s*"${escapeRegex(entryNameValue)}"\s*$`);
+    const lines = source.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        if (headerPattern.test(lines[i])) {
+            // Look in the next ~10 lines (until next blank or next header) for `name = "<value>"`
+            for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+                const line = lines[j].trim();
+                if (line.startsWith('['))
+                    break; // next section
+                if (namePattern.test(line))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=toml-writer.js.map