wyrm-mcp 7.2.1 → 7.2.2

package/dist/render-target.js

@@ -1,72 +1,10 @@
-/**
- * Wyrm Render Target (v7 F4 — T038) — the deterministic DB→memory-file compiler.
- *
- * `wyrm render` is the ZERO-MCP-TOKEN path for casual sessions: instead of an
- * agent spending tool calls to load context, Wyrm compiles the project's
- * authoritative state (ground truths, open quests, validated patterns,
- * unresolved failures) straight into the harness-native memory slot —
- * `MEMORY.md` (hard 200-line budget) + per-topic files + a lean SessionStart
- * brief — plus per-client adapters (Claude Code / Cursor / Copilot / AGENTS.md).
- *
- * Design law (this module is the NET-NEW, TEMPLATE-ISOLATED writer per the spec):
- *  - DETERMINISTIC / BYTE-STABLE: there is NO Date.now()/Math.random() in the
- *    OUTPUT. Every volatile value (the Wyrm version, the compiled-at stamp, the
- *    artifact count) is PASSED IN via {@link RenderStamp}. Same model + same
- *    stamp ⇒ byte-identical bytes, forever (golden-replayable).
- *  - PROVENANCE-STAMPED: every emitted file carries a header that says it was
- *    compiled by Wyrm and that edits are HARVESTED, not lost (the reverse bridge,
- *    T039, picks them up). Wyrm-managed regions are MARKER-BOUNDED so a writer
- *    NEVER clobbers operator prose outside the markers (the autoconfig.ts
- *    idempotent-block discipline, reused here).
- *  - SAFE (Article VII): {@link writeRenderTarget} refuses to escape its target
- *    directory (no `..`, no absolute re-roots) and refuses to overwrite a file
- *    that is NOT Wyrm-managed unless explicitly forced — a human's hand-written
- *    MEMORY.md is never silently destroyed.
- *  - OFFLINE (Article III): pure DB read + string building. No network, no LLM,
- *    no clock of its own.
- *
- * The DB read is injected ({@link RenderDeps}) so the COMPILER is unit-testable
- * against an in-memory fixture, exactly like harvest.ts.
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later — dual-licensed; commercial terms: ghosts.lk@proton.me. See LICENSE.
- */
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'fs';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'path';
-// ──────────────────────────────────────────────────────────────────────────
-// Budgets & markers
-// ──────────────────────────────────────────────────────────────────────────
-/** MEMORY.md hard line budget (spec FR-6). The compiler trims to fit. */
-export const MEMORY_MD_LINE_BUDGET = 200;
-/** Marker delimiting the Wyrm-managed region inside any rendered file. */
-export const RENDER_MARKER_START = '<!-- wyrm:render:start -->';
-export const RENDER_MARKER_END = '<!-- wyrm:render:end -->';
-/**
- * Default DB-backed deps. Pure SQL, bound params, deterministic ORDER BY on a
- * TOTAL order (every query appends an id/key tiebreak so two rows never tie on
- * the wire — the bare-sort-key trap). All listings are hard-capped.
- */
-export function makeRenderDeps(db) {
-    return {
-        truths(projectId) {
-            const rows = db.prepare(`
+import{existsSync as E,lstatSync as T,mkdirSync as k,readFileSync as D,realpathSync as N,writeFileSync as O}from"fs";import{dirname as _,isAbsolute as $,join as f,relative as w,resolve as R,sep as S}from"path";const W=200,m="<!-- wyrm:render:start -->",h="<!-- wyrm:render:end -->";function P(e){return{truths(r){return e.prepare(`
         SELECT category, key, value, rationale, confidence, ttl_days,
                CAST((julianday('now') - julianday(last_verified_at)) AS REAL) AS age_days
         FROM ground_truths
         WHERE project_id = ? AND is_current = 1
         ORDER BY category, key
-      `).all(projectId);
-            return rows.map((r) => ({
-                category: r.category,
-                key: r.key,
-                value: r.value,
-                rationale: r.rationale,
-                confidence: r.confidence,
-                stale: r.ttl_days != null && r.age_days > r.ttl_days,
-            }));
-        },
-        quests(projectId) {
-            return db.prepare(`
+      `).all(r).map(t=>({category:t.category,key:t.key,value:t.value,rationale:t.rationale,confidence:t.confidence,stale:t.ttl_days!=null&&t.age_days>t.ttl_days}))},quests(r){return e.prepare(`
         SELECT id, title, description, priority
         FROM quests
         WHERE project_id = ? AND status IN ('pending','in_progress')
@@ -75,461 +13,30 @@ export function makeRenderDeps(db) {
                        WHEN 'medium' THEN 2 ELSE 3 END,
           id ASC
         LIMIT 100
-      `).all(projectId);
-        },
-        artifacts(projectId) {
-            try {
-                return db.prepare(`
+      `).all(r)},artifacts(r){try{return e.prepare(`
           SELECT id, problem, validated_fix
           FROM memory_artifacts
           WHERE project_id = ? AND (needs_review = 0 OR needs_review IS NULL)
           ORDER BY id DESC LIMIT 50
-        `).all(projectId);
-            }
-            catch {
-                return [];
-            }
-        },
-        failures(projectId) {
-            try {
-                return db.prepare(`
+        `).all(r)}catch{return[]}},failures(r){try{return e.prepare(`
           SELECT id, scope, target, description, severity, occurrences
           FROM failure_patterns
           WHERE (project_id = ? OR project_id IS NULL) AND resolved = 0
           ORDER BY last_seen DESC, id DESC LIMIT 50
-        `).all(projectId);
-            }
-            catch {
-                return [];
-            }
-        },
-    };
-}
-/** Compile the full structured model for a project (pure given deps). */
-export function compileRenderModel(deps, project) {
-    return {
-        project_id: project.id,
-        project_name: project.name,
-        project_path: project.path,
-        truths: deps.truths(project.id),
-        quests: deps.quests(project.id),
-        artifacts: deps.artifacts(project.id),
-        failures: deps.failures(project.id),
-    };
-}
-// ──────────────────────────────────────────────────────────────────────────
-// Provenance
-// ──────────────────────────────────────────────────────────────────────────
-function artifactCount(m) {
-    return m.truths.length + m.quests.length + m.artifacts.length + m.failures.length;
-}
-/**
- * The provenance lines. Deterministic given (model, stamp). States plainly that
- * edits are HARVESTED, not lost (the reverse bridge picks up changes between the
- * markers and routes them to the review queue, T039).
- */
-export function provenanceHeader(m, stamp) {
-    const n = artifactCount(m);
-    return [
-        `<!-- Compiled by Wyrm v${stamp.wyrm_version} from ${n} memory artifact${n === 1 ? '' : 's'}.`,
-        `     Project: ${m.project_name}. Compiled at ${stamp.compiled_at}.`,
-        `     Edits inside the wyrm:render markers are HARVESTED to the review queue, not lost —`,
-        `     but they are OVERWRITTEN on the next \`wyrm render\`; capture durable notes with \`wyrm capture\`. -->`,
-    ];
-}
-// ──────────────────────────────────────────────────────────────────────────
-// MEMORY.md — the 200-line-budgeted master file.
-// ──────────────────────────────────────────────────────────────────────────
-/** Sanitise a one-line cell: collapse newlines so a value never spends >1 line. */
-function oneLine(s) {
-    return s.replace(/\s*\n\s*/g, ' ').trim();
-}
-/** Truncate to a max length with an ellipsis (deterministic). */
-function clip(s, max) {
-    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
-}
-/**
- * Render MEMORY.md body (the lines BETWEEN the markers, provenance included).
- * Hard 200-line budget: sections are emitted in priority order and the LAST
- * section to overflow is truncated with an explicit "N more" note, so the file
- * never exceeds the budget no matter how large the corpus.
- *
- * Returns the full marker-bounded block (markers + provenance + body), ready to
- * splice into a file by {@link spliceWyrmRegion}.
- */
-export function renderMemoryMd(m, stamp) {
-    const header = provenanceHeader(m, stamp);
-    // The marker + provenance lines count against NOTHING extra here; the budget
-    // governs the human-readable body. We reserve a few lines for the title and
-    // the footer so the total stays at/under the budget.
-    const body = [];
-    body.push(`# ${m.project_name} — Project Memory`);
-    body.push('');
-    // Footer is always 2 lines; title+blank is 2 lines. Keep the content within
-    // the remaining budget.
-    const reserved = 4;
-    const contentBudget = MEMORY_MD_LINE_BUDGET - reserved;
-    const sections = [];
-    if (m.truths.length > 0) {
-        sections.push({
-            heading: `## Ground truths (${m.truths.length})`,
-            refTool: 'wyrm_truth_get',
-            lines: m.truths.map((t) => {
-                const marker = t.stale ? ' [STALE]' : '';
-                const conf = t.confidence < 1 ? ` (conf ${t.confidence})` : '';
-                return `- **${t.category}.${t.key}**${marker}: ${clip(oneLine(t.value), 160)}${conf}`;
-            }),
-        });
-    }
-    if (m.failures.length > 0) {
-        sections.push({
-            heading: `## Failures — DO NOT repeat (${m.failures.length})`,
-            refTool: 'wyrm_failure_check',
-            lines: m.failures.map((f) => `- [${f.severity}] ${f.scope}:${f.target} ×${f.occurrences} — ${clip(oneLine(f.description), 140)}`),
-        });
-    }
-    if (m.quests.length > 0) {
-        sections.push({
-            heading: `## Open quests (${m.quests.length})`,
-            refTool: 'wyrm_quest',
-            lines: m.quests.map((q) => `- #${q.id} [${q.priority}] ${clip(oneLine(q.title), 140)}`),
-        });
-    }
-    if (m.artifacts.length > 0) {
-        sections.push({
-            heading: `## Validated patterns (${m.artifacts.length})`,
-            refTool: 'wyrm_recall',
-            lines: m.artifacts.map((a) => `- ${clip(oneLine(a.problem), 120)}${a.validated_fix ? ` → ${clip(oneLine(a.validated_fix), 120)}` : ''}`),
-        });
-    }
-    // Greedily emit sections within the budget. Each section costs: heading + a
-    // blank line + N item lines + a trailing blank. When a section would overflow,
-    // emit as many items as fit and a single "N more — query <tool>" line.
-    let used = 0;
-    for (const s of sections) {
-        // Minimum cost to open a section: heading + blank + at least the "more" note
-        // + trailing blank = 4 lines. If we can't even do that, stop.
-        if (used + 4 > contentBudget)
-            break;
-        body.push(s.heading);
-        body.push('');
-        used += 2;
-        let emitted = 0;
-        for (const line of s.lines) {
-            // Reserve 1 line for a potential "more" note + 1 trailing blank.
-            if (used + 1 + (emitted < s.lines.length ? 1 : 0) + 1 > contentBudget)
-                break;
-            body.push(line);
-            used += 1;
-            emitted += 1;
-        }
-        if (emitted < s.lines.length) {
-            body.push(`- _… ${s.lines.length - emitted} more — query \`${s.refTool}\`._`);
-            used += 1;
-        }
-        body.push('');
-        used += 1;
-    }
-    body.push('---');
-    body.push(`*Full memory: \`wyrm recall\` / \`wyrm session prime\`. This file is a deterministic digest.*`);
-    return [...header, ...body].join('\n');
-}
-/**
- * Render the per-topic files (the full, un-budgeted corpus). Each is its own
- * marker-bounded, provenance-stamped file. Deterministic given (model, stamp).
- */
-export function renderTopicFiles(m, stamp) {
-    const header = provenanceHeader(m, stamp);
-    const out = [];
-    const mk = (filename, title, lines) => {
-        if (lines.length === 0)
-            return;
-        out.push({
-            filename,
-            content: [...header, `# ${m.project_name} — ${title}`, '', ...lines].join('\n'),
-        });
-    };
-    mk('truths.md', 'Ground truths', m.truths.map((t) => {
-        const marker = t.stale ? ' [STALE]' : '';
-        return `- **${t.category}.${t.key}**${marker}: ${oneLine(t.value)}` +
-            (t.rationale ? `\n  - rationale: ${oneLine(t.rationale)}` : '') +
-            (t.confidence < 1 ? `\n  - confidence: ${t.confidence}` : '');
-    }));
-    mk('quests.md', 'Open quests', m.quests.map((q) => `- #${q.id} [${q.priority}] ${oneLine(q.title)}` +
-        (q.description ? `\n  - ${oneLine(q.description)}` : '')));
-    mk('patterns.md', 'Validated patterns', m.artifacts.map((a) => `- ${oneLine(a.problem)}` + (a.validated_fix ? `\n  - fix: ${oneLine(a.validated_fix)}` : '')));
-    mk('failures.md', 'Failures — DO NOT repeat', m.failures.map((f) => `- [${f.severity}] ${f.scope}:${f.target} ×${f.occurrences}\n  - ${oneLine(f.description)}`));
-    return out;
-}
-// ──────────────────────────────────────────────────────────────────────────
-// SessionStart brief — the lean, byte-stable injection payload.
-// ──────────────────────────────────────────────────────────────────────────
-/**
- * The SessionStart brief: a compact, deterministic summary a harness can inject
- * at session start with near-zero cost. Caps each section so the brief stays
- * lean (it is NOT the full corpus — that's the topic files). Byte-stable.
- */
-export function renderSessionBrief(m, stamp) {
-    const lines = [];
-    lines.push(`Wyrm memory for ${m.project_name} (compiled by Wyrm v${stamp.wyrm_version}):`);
-    if (m.failures.length > 0) {
-        lines.push('');
-        lines.push(`Known failures (do not repeat):`);
-        for (const f of m.failures.slice(0, 5)) {
-            lines.push(`- ${f.scope}:${f.target} — ${clip(oneLine(f.description), 120)}`);
-        }
-        if (m.failures.length > 5)
-            lines.push(`- (+${m.failures.length - 5} more — wyrm_failure_check)`);
-    }
-    if (m.truths.length > 0) {
-        lines.push('');
-        lines.push(`Ground truths:`);
-        for (const t of m.truths.slice(0, 8)) {
-            lines.push(`- ${t.category}.${t.key}: ${clip(oneLine(t.value), 120)}`);
-        }
-        if (m.truths.length > 8)
-            lines.push(`- (+${m.truths.length - 8} more — wyrm_truth_get)`);
-    }
-    if (m.quests.length > 0) {
-        lines.push('');
-        lines.push(`Open quests:`);
-        for (const q of m.quests.slice(0, 5)) {
-            lines.push(`- #${q.id} [${q.priority}] ${clip(oneLine(q.title), 100)}`);
-        }
-        if (m.quests.length > 5)
-            lines.push(`- (+${m.quests.length - 5} more — wyrm_quest)`);
-    }
-    lines.push('');
-    lines.push(`Load full context with wyrm_session_prime. (Wyrm is this session's memory; consult it first.)`);
-    return lines.join('\n');
-}
-/**
- * Per-client memory-file layout. Each adapter targets that client's native
- * memory slot with its native filename — no Anthropic-only behaviour leaks into
- * the others. The BLOCK content is identical (the MEMORY.md digest); only the
- * destination differs, so the digest is one source of truth.
- */
-export function renderForClient(client, m, stamp) {
-    const block = renderMemoryMd(m, stamp);
-    switch (client) {
-        case 'claude':
-            // Claude Code reads a project-root CLAUDE.md (or MEMORY.md). We target
-            // CLAUDE.md as the canonical Claude Code project memory slot.
-            return { client, relPath: 'CLAUDE.md', block };
-        case 'cursor':
-            return { client, relPath: join('.cursor', 'rules', 'wyrm-memory.md'), block };
-        case 'copilot':
-            return { client, relPath: join('.github', 'copilot-instructions.md'), block };
-        case 'agents':
-            return { client, relPath: 'AGENTS.md', block };
-        default: {
-            const never = client;
-            throw new Error(`unknown render client: ${String(never)}`);
-        }
-    }
-}
-// ──────────────────────────────────────────────────────────────────────────
-// Marker splicing + safe writing.
-// ──────────────────────────────────────────────────────────────────────────
-/**
- * Splice a marker-bounded Wyrm block into existing file content WITHOUT touching
- * operator prose outside the markers. If a marker region already exists it is
- * replaced; otherwise the block is appended. Returns the new file content.
- *
- * The returned content wraps `block` in the start/end markers exactly once.
- */
-export function spliceWyrmRegion(existing, block) {
-    const region = `${RENDER_MARKER_START}\n${block}\n${RENDER_MARKER_END}`;
-    if (!existing)
-        return `${region}\n`;
-    const startIdx = existing.indexOf(RENDER_MARKER_START);
-    const endIdx = existing.indexOf(RENDER_MARKER_END);
-    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-        const before = existing.slice(0, startIdx);
-        const after = existing.slice(endIdx + RENDER_MARKER_END.length);
-        return `${before}${region}${after}`;
-    }
-    const sep = existing.endsWith('\n') ? '\n' : '\n\n';
-    return `${existing}${sep}${region}\n`;
-}
-/** Does this file content already carry a Wyrm-managed region? */
-export function hasWyrmRegion(content) {
-    const s = content.indexOf(RENDER_MARKER_START);
-    const e = content.indexOf(RENDER_MARKER_END);
-    return s !== -1 && e !== -1 && e > s;
-}
-export class RenderPathError extends Error {
-}
-const NODE_STAT_FS = { existsSync, lstatSync, realpathSync };
-/**
- * Resolve `relPath` strictly inside `rootDir`. Rejects absolute paths and any
- * traversal that escapes the root (Article VII: a writer/watcher must never
- * escape its target dir). Returns the absolute, validated path.
- *
- * The lexical `resolve`/`relative` gate blocks `..` traversal, but it does NOT
- * stop a SYMLINK that lives inside the root and points outside it — `writeFile`/
- * `readFile` follow symlinks, so a target like `MEMORY.md` symlinked to
- * `~/.ssh/config` would be written/read THROUGH the link, escaping the dir. So
- * we additionally:
- *   1. refuse when the existing target is itself a symlink (lstat isSymbolicLink),
- *   2. re-assert the REAL path of the target (or its nearest existing ancestor,
- *      for a not-yet-created target) is inside the REAL path of the root —
- *      defeating an in-root symlinked ancestor directory.
- * The stat surface is injected so the symlink lens is unit-testable without a
- * live filesystem.
- */
-export function resolveInsideRoot(rootDir, relPath, statFs = NODE_STAT_FS) {
-    if (isAbsolute(relPath)) {
-        throw new RenderPathError(`render target must be relative, got absolute: ${relPath}`);
-    }
-    const root = resolve(rootDir);
-    const target = resolve(root, relPath);
-    const rel = relative(root, target);
-    if (rel === '' || rel.startsWith('..') || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-        throw new RenderPathError(`render target escapes root: ${relPath}`);
-    }
-    // Symlink defence (Article VII). The lexical check above passed, so now guard
-    // against in-root symlinks that resolve outside the root.
-    let realRoot;
-    try {
-        realRoot = statFs.realpathSync(root);
-    }
-    catch {
-        // Root itself does not resolve (does not exist / broken) — fall back to the
-        // lexically validated path; nothing on disk to escape through yet.
-        return target;
-    }
-    // 1. The target, if it already exists, must not BE a symlink.
-    if (statFs.existsSync(target)) {
-        let isLink = false;
-        try {
-            isLink = statFs.lstatSync(target).isSymbolicLink();
-        }
-        catch {
-            isLink = false;
-        }
-        if (isLink) {
-            throw new RenderPathError(`render target is a symlink (refusing to follow): ${relPath}`);
-        }
-    }
-    // 2. The REAL path of the target's nearest existing ancestor must stay inside
-    //    the real root — catches a symlinked intermediate directory.
-    let probe = target;
-    // Walk up to the nearest ancestor that exists on disk.
-    while (!statFs.existsSync(probe)) {
-        const parent = dirname(probe);
-        if (parent === probe)
-            break; // reached filesystem root
-        probe = parent;
-    }
-    let realProbe;
-    try {
-        realProbe = statFs.realpathSync(probe);
-    }
-    catch {
-        return target; // ancestor vanished mid-check — degrade to the lexical path
-    }
-    const realRel = relative(realRoot, realProbe);
-    if (realRel === '' && probe === root) {
-        return target; // the existing ancestor IS the root — fine
-    }
-    if (realRel.startsWith('..') || realRel.startsWith(`..${sep}`) || isAbsolute(realRel)) {
-        throw new RenderPathError(`render target escapes root via symlink: ${relPath}`);
-    }
-    return target;
-}
-const NODE_FS = { existsSync, readFileSync, writeFileSync, mkdirSync };
-/**
- * Write a marker-bounded block into `rootDir/relPath` safely:
- *  - the path is validated to stay inside rootDir (no escape),
- *  - an existing Wyrm region is replaced; operator prose outside is untouched,
- *  - a file that exists but is NOT Wyrm-managed is SKIPPED unless `force` (then
- *    the block is APPENDED, never overwriting the human content),
- *  - the write is idempotent: identical content ⇒ 'skipped' (no churn, lets the
- *    daemon re-render cheaply).
- */
-export function writeRenderTarget(rootDir, relPath, block, opts = {}) {
-    const fs = opts.fs ?? NODE_FS;
-    const abs = resolveInsideRoot(rootDir, relPath);
-    const exists = fs.existsSync(abs);
-    const existing = exists ? fs.readFileSync(abs, 'utf-8') : null;
-    if (exists && existing != null && !hasWyrmRegion(existing) && !opts.force) {
-        return { path: abs, action: 'skipped', reason: 'file exists and is not Wyrm-managed (pass force to append)' };
-    }
-    const next = spliceWyrmRegion(existing, block);
-    if (existing != null && next === existing) {
-        return { path: abs, action: 'skipped', reason: 'unchanged' };
-    }
-    fs.mkdirSync(dirname(abs), { recursive: true });
-    fs.writeFileSync(abs, next, 'utf-8');
-    return { path: abs, action: exists ? 'updated' : 'created' };
-}
-/** Build the full deterministic render plan for a project (no I/O). */
-export function buildRenderPlan(deps, project, stamp) {
-    const model = compileRenderModel(deps, project);
-    return {
-        model,
-        memoryMd: renderMemoryMd(model, stamp),
-        topics: renderTopicFiles(model, stamp),
-        sessionBrief: renderSessionBrief(model, stamp),
-    };
-}
-/**
- * Render a project's memory to disk: MEMORY.md + topic files (+ optional client
- * adapter files). All writes are safe (no escape, no clobber of human prose).
- */
-export function renderToDisk(deps, project, stamp, opts = {}) {
-    const root = opts.rootDir ?? project.path;
-    const topicsDir = opts.topicsDir ?? join('.wyrm', 'memory');
-    const plan = buildRenderPlan(deps, project, stamp);
-    const writes = [];
-    writes.push(writeRenderTarget(root, 'MEMORY.md', plan.memoryMd, opts));
-    for (const t of plan.topics) {
-        writes.push(writeRenderTarget(root, join(topicsDir, t.filename), t.content, { ...opts, force: true }));
-    }
-    for (const client of opts.clients ?? []) {
-        const target = renderForClient(client, plan.model, stamp);
-        writes.push(writeRenderTarget(root, target.relPath, target.block, opts));
-    }
-    return { plan, writes };
-}
-// ──────────────────────────────────────────────────────────────────────────
-// Daemon re-render on Live Memory events (opt-in).
-// ──────────────────────────────────────────────────────────────────────────
-/**
- * Whether daemon re-render is enabled. Off by default (Article VII) — the
- * operator opts in with WYRM_RENDER_WATCH=1. Kept as a function so tests and the
- * daemon read a fresh value, never a cached one.
- */
-export function renderWatchEnabled(env = process.env) {
-    const v = (env.WYRM_RENDER_WATCH ?? '').toLowerCase();
-    return v === '1' || v === 'true' || v === 'yes';
-}
-/**
- * Tracks a project's Live Memory cursor and decides whether a re-render is due.
- * Pure given the cursor inputs — the daemon supplies "the latest cursor I saw"
- * and this returns whether it ADVANCED past the last render. No clock, no I/O.
- *
- * The daemon pattern: keep a RenderCursorTracker per project; on each tick poll
- * eventsSince(db, projectId, tracker.last) for the head cursor; call
- * tracker.advance(headCursor) — if it returns true, re-render and the tracker
- * records the new head as rendered.
- */
-export class RenderCursorTracker {
-    rendered;
-    constructor(initialCursor = 0) { this.rendered = initialCursor; }
-    /** The cursor value last rendered. */
-    get last() { return this.rendered; }
-    /**
-     * Given the current head cursor, returns true (and records it) iff it is
-     * strictly greater than the last rendered cursor — i.e. new events arrived
-     * since the last render. Idempotent: a stale/equal cursor never re-renders.
-     */
-    advance(headCursor) {
-        if (!Number.isFinite(headCursor) || headCursor <= this.rendered)
-            return false;
-        this.rendered = headCursor;
-        return true;
-    }
-}
-//# sourceMappingURL=render-target.js.map
+        `).all(r)}catch{return[]}}}}function b(e,r){return{project_id:r.id,project_name:r.name,project_path:r.path,truths:e.truths(r.id),quests:e.quests(r.id),artifacts:e.artifacts(r.id),failures:e.failures(r.id)}}function L(e){return e.truths.length+e.quests.length+e.artifacts.length+e.failures.length}function v(e,r){const n=L(e);return[`<!-- Compiled by Wyrm v${r.wyrm_version} from ${n} memory artifact${n===1?"":"s"}.`,`     Project: ${e.project_name}. Compiled at ${r.compiled_at}.`,"     Edits inside the wyrm:render markers are HARVESTED to the review queue, not lost \u2014","     but they are OVERWRITTEN on the next `wyrm render`; capture durable notes with `wyrm capture`. -->"]}function u(e){return e.replace(/\s*\n\s*/g," ").trim()}function p(e,r){return e.length>r?`${e.slice(0,r-1)}\u2026`:e}function x(e,r){const n=v(e,r),t=[];t.push(`# ${e.project_name} \u2014 Project Memory`),t.push("");const s=W-4,c=[];e.truths.length>0&&c.push({heading:`## Ground truths (${e.truths.length})`,refTool:"wyrm_truth_get",lines:e.truths.map(i=>{const l=i.stale?" [STALE]":"",d=i.confidence<1?` (conf ${i.confidence})`:"";return`- **${i.category}.${i.key}**${l}: ${p(u(i.value),160)}${d}`})}),e.failures.length>0&&c.push({heading:`## Failures \u2014 DO NOT repeat (${e.failures.length})`,refTool:"wyrm_failure_check",lines:e.failures.map(i=>`- [${i.severity}] ${i.scope}:${i.target} \xD7${i.occurrences} \u2014 ${p(u(i.description),140)}`)}),e.quests.length>0&&c.push({heading:`## Open quests (${e.quests.length})`,refTool:"wyrm_quest",lines:e.quests.map(i=>`- #${i.id} [${i.priority}] ${p(u(i.title),140)}`)}),e.artifacts.length>0&&c.push({heading:`## Validated patterns (${e.artifacts.length})`,refTool:"wyrm_recall",lines:e.artifacts.map(i=>`- ${p(u(i.problem),120)}${i.validated_fix?` \u2192 ${p(u(i.validated_fix),120)}`:""}`)});let a=0;for(const i of c){if(a+4>s)break;t.push(i.heading),t.push(""),a+=2;let l=0;for(const d of i.lines){if(a+1+(l<i.lines.length?1:0)+1>s)break;t.push(d),a+=1,l+=1}l<i.lines.length&&(t.push(`- _\u2026 ${i.lines.length-l} more \u2014 query \`${i.refTool}\`._`),a+=1),t.push(""),a+=1}return t.push("---"),t.push("*Full memory: `wyrm recall` / `wyrm session prime`. This file is a deterministic digest.*"),[...n,...t].join(`
+`)}function A(e,r){const n=v(e,r),t=[],o=(s,c,a)=>{a.length!==0&&t.push({filename:s,content:[...n,`# ${e.project_name} \u2014 ${c}`,"",...a].join(`
+`)})};return o("truths.md","Ground truths",e.truths.map(s=>{const c=s.stale?" [STALE]":"";return`- **${s.category}.${s.key}**${c}: ${u(s.value)}`+(s.rationale?`
+  - rationale: ${u(s.rationale)}`:"")+(s.confidence<1?`
+  - confidence: ${s.confidence}`:"")})),o("quests.md","Open quests",e.quests.map(s=>`- #${s.id} [${s.priority}] ${u(s.title)}`+(s.description?`
+  - ${u(s.description)}`:""))),o("patterns.md","Validated patterns",e.artifacts.map(s=>`- ${u(s.problem)}`+(s.validated_fix?`
+  - fix: ${u(s.validated_fix)}`:""))),o("failures.md","Failures \u2014 DO NOT repeat",e.failures.map(s=>`- [${s.severity}] ${s.scope}:${s.target} \xD7${s.occurrences}
+  - ${u(s.description)}`)),t}function M(e,r){const n=[];if(n.push(`Wyrm memory for ${e.project_name} (compiled by Wyrm v${r.wyrm_version}):`),e.failures.length>0){n.push(""),n.push("Known failures (do not repeat):");for(const t of e.failures.slice(0,5))n.push(`- ${t.scope}:${t.target} \u2014 ${p(u(t.description),120)}`);e.failures.length>5&&n.push(`- (+${e.failures.length-5} more \u2014 wyrm_failure_check)`)}if(e.truths.length>0){n.push(""),n.push("Ground truths:");for(const t of e.truths.slice(0,8))n.push(`- ${t.category}.${t.key}: ${p(u(t.value),120)}`);e.truths.length>8&&n.push(`- (+${e.truths.length-8} more \u2014 wyrm_truth_get)`)}if(e.quests.length>0){n.push(""),n.push("Open quests:");for(const t of e.quests.slice(0,5))n.push(`- #${t.id} [${t.priority}] ${p(u(t.title),100)}`);e.quests.length>5&&n.push(`- (+${e.quests.length-5} more \u2014 wyrm_quest)`)}return n.push(""),n.push("Load full context with wyrm_session_prime. (Wyrm is this session's memory; consult it first.)"),n.join(`
+`)}function q(e,r,n){const t=x(r,n);switch(e){case"claude":return{client:e,relPath:"CLAUDE.md",block:t};case"cursor":return{client:e,relPath:f(".cursor","rules","wyrm-memory.md"),block:t};case"copilot":return{client:e,relPath:f(".github","copilot-instructions.md"),block:t};case"agents":return{client:e,relPath:"AGENTS.md",block:t};default:{const o=e;throw new Error(`unknown render client: ${String(o)}`)}}}function C(e,r){const n=`${m}
+${r}
+${h}`;if(!e)return`${n}
+`;const t=e.indexOf(m),o=e.indexOf(h);if(t!==-1&&o!==-1&&o>t){const c=e.slice(0,t),a=e.slice(o+h.length);return`${c}${n}${a}`}const s=e.endsWith(`
+`)?`
+`:`
+
+`;return`${e}${s}${n}
+`}function I(e){const r=e.indexOf(m),n=e.indexOf(h);return r!==-1&&n!==-1&&n>r}class y extends Error{}const j={existsSync:E,lstatSync:T,realpathSync:N};function H(e,r,n=j){if($(r))throw new y(`render target must be relative, got absolute: ${r}`);const t=R(e),o=R(t,r),s=w(t,o);if(s===""||s.startsWith("..")||s.startsWith(`..${S}`)||$(s))throw new y(`render target escapes root: ${r}`);let c;try{c=n.realpathSync(t)}catch{return o}if(n.existsSync(o)){let d=!1;try{d=n.lstatSync(o).isSymbolicLink()}catch{d=!1}if(d)throw new y(`render target is a symlink (refusing to follow): ${r}`)}let a=o;for(;!n.existsSync(a);){const d=_(a);if(d===a)break;a=d}let i;try{i=n.realpathSync(a)}catch{return o}const l=w(c,i);if(l===""&&a===t)return o;if(l.startsWith("..")||l.startsWith(`..${S}`)||$(l))throw new y(`render target escapes root via symlink: ${r}`);return o}const F={existsSync:E,readFileSync:D,writeFileSync:O,mkdirSync:k};function g(e,r,n,t={}){const o=t.fs??F,s=H(e,r),c=o.existsSync(s),a=c?o.readFileSync(s,"utf-8"):null;if(c&&a!=null&&!I(a)&&!t.force)return{path:s,action:"skipped",reason:"file exists and is not Wyrm-managed (pass force to append)"};const i=C(a,n);return a!=null&&i===a?{path:s,action:"skipped",reason:"unchanged"}:(o.mkdirSync(_(s),{recursive:!0}),o.writeFileSync(s,i,"utf-8"),{path:s,action:c?"updated":"created"})}function B(e,r,n){const t=b(e,r);return{model:t,memoryMd:x(t,n),topics:A(t,n),sessionBrief:M(t,n)}}function U(e,r,n,t={}){const o=t.rootDir??r.path,s=t.topicsDir??f(".wyrm","memory"),c=B(e,r,n),a=[];a.push(g(o,"MEMORY.md",c.memoryMd,t));for(const i of c.topics)a.push(g(o,f(s,i.filename),i.content,{...t,force:!0}));for(const i of t.clients??[]){const l=q(i,c.model,n);a.push(g(o,l.relPath,l.block,t))}return{plan:c,writes:a}}function V(e=process.env){const r=(e.WYRM_RENDER_WATCH??"").toLowerCase();return r==="1"||r==="true"||r==="yes"}class K{rendered;constructor(r=0){this.rendered=r}get last(){return this.rendered}advance(r){return!Number.isFinite(r)||r<=this.rendered?!1:(this.rendered=r,!0)}}export{W as MEMORY_MD_LINE_BUDGET,h as RENDER_MARKER_END,m as RENDER_MARKER_START,K as RenderCursorTracker,y as RenderPathError,B as buildRenderPlan,b as compileRenderModel,I as hasWyrmRegion,P as makeRenderDeps,v as provenanceHeader,q as renderForClient,x as renderMemoryMd,M as renderSessionBrief,U as renderToDisk,A as renderTopicFiles,V as renderWatchEnabled,H as resolveInsideRoot,C as spliceWyrmRegion,g as writeRenderTarget};