wyrm-mcp 7.3.2 → 7.3.3

package/dist/render-target.js

@@ -1,10 +1,72 @@
-import{existsSync as E,lstatSync as N,mkdirSync as D,readFileSync as k,realpathSync as L,writeFileSync as A}from"fs";import{dirname as _,isAbsolute as m,join as f,relative as w,resolve as R,sep as S}from"path";const O=200,$="<!-- wyrm:render:start -->",h="<!-- wyrm:render:end -->";function V(e){return{truths(r){return e.prepare(`
+/**
+ * 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 Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. 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(`
         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(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(`
+      `).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(`
         SELECT id, title, description, priority
         FROM quests
         WHERE project_id = ? AND status IN ('pending','in_progress')
@@ -13,30 +75,491 @@ import{existsSync as E,lstatSync as N,mkdirSync as D,readFileSync as k,realpathS
                        WHEN 'medium' THEN 2 ELSE 3 END,
           id ASC
         LIMIT 100
-      `).all(r)},artifacts(r){try{return e.prepare(`
+      `).all(projectId);
+        },
+        artifacts(projectId) {
+            try {
+                return db.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(r)}catch{return[]}},failures(r){try{return e.prepare(`
+        `).all(projectId);
+            }
+            catch {
+                return [];
+            }
+        },
+        failures(projectId) {
+            try {
+                return db.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(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 M(e){return e.truths.length+e.quests.length+e.artifacts.length+e.failures.length}function x(e,r){const n=M(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 T(e,r){const n=x(e,r),t=[];t.push(`# ${e.project_name} \u2014 Project Memory`),t.push("");const s=O-4,a=[];e.truths.length>0&&a.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&&a.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&&a.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&&a.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 o=0;for(const i of a){if(o+4>s)break;t.push(i.heading),t.push(""),o+=2;let l=0;for(const d of i.lines){if(o+1+(l<i.lines.length?1:0)+1>s)break;t.push(d),o+=1,l+=1}l<i.lines.length&&(t.push(`- _\u2026 ${i.lines.length-l} more \u2014 query \`${i.refTool}\`._`),o+=1),t.push(""),o+=1}return t.push("---"),t.push("*Full memory: `wyrm recall` / `wyrm session prime`. This file is a deterministic digest.*"),[...n,...t].join(`
-`)}function W(e,r){const n=x(e,r),t=[],c=(s,a,o)=>{o.length!==0&&t.push({filename:s,content:[...n,`# ${e.project_name} \u2014 ${a}`,"",...o].join(`
-`)})};return c("truths.md","Ground truths",e.truths.map(s=>{const a=s.stale?" [STALE]":"";return`- **${s.category}.${s.key}**${a}: ${u(s.value)}`+(s.rationale?`
-  - rationale: ${u(s.rationale)}`:"")+(s.confidence<1?`
-  - confidence: ${s.confidence}`:"")})),c("quests.md","Open quests",e.quests.map(s=>`- #${s.id} [${s.priority}] ${u(s.title)}`+(s.description?`
-  - ${u(s.description)}`:""))),c("patterns.md","Validated patterns",e.artifacts.map(s=>`- ${u(s.problem)}`+(s.validated_fix?`
-  - fix: ${u(s.validated_fix)}`:""))),c("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 C(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 I(e){switch(e){case"claude":return"CLAUDE.md";case"cursor":return f(".cursor","rules","wyrm-memory.md");case"copilot":return f(".github","copilot-instructions.md");case"agents":return"AGENTS.md";case"windsurf":return f(".windsurf","rules","wyrm-memory.md");case"cline":return f(".clinerules","wyrm-memory.md");case"zed":return".rules";case"gemini":return"GEMINI.md";default:{const r=e;throw new Error(`unknown render client: ${String(r)}`)}}}function q(e,r,n){return{client:e,relPath:I(e),block:T(r,n)}}const j=["claude","cursor","copilot","agents","windsurf","cline","zed","gemini"],v={claude:["CLAUDE.md",".claude"],cursor:[".cursor",".cursorrules"],copilot:[".github/copilot-instructions.md",".github"],agents:["AGENTS.md"],windsurf:[".windsurf",".windsurfrules"],cline:[".clinerules"],zed:[".rules",".zed"],gemini:["GEMINI.md",".gemini"]};function P(e){const r=new Set(e);return j.filter(n=>v[n].some(t=>r.has(t)))}const J=[...new Set(Object.values(v).flat())];function H(e,r){const n=`${$}
-${r}
-${h}`;if(!e)return`${n}
-`;const t=e.indexOf($),c=e.indexOf(h);if(t!==-1&&c!==-1&&c>t){const a=e.slice(0,t),o=e.slice(c+h.length);return`${a}${n}${o}`}const s=e.endsWith(`
-`)?`
-`:`
-
-`;return`${e}${s}${n}
-`}function F(e){const r=e.indexOf($),n=e.indexOf(h);return r!==-1&&n!==-1&&n>r}class y extends Error{}const B={existsSync:E,lstatSync:N,realpathSync:L};function G(e,r,n=B){if(m(r))throw new y(`render target must be relative, got absolute: ${r}`);const t=R(e),c=R(t,r),s=w(t,c);if(s===""||s.startsWith("..")||s.startsWith(`..${S}`)||m(s))throw new y(`render target escapes root: ${r}`);let a;try{a=n.realpathSync(t)}catch{return c}if(n.existsSync(c)){let d=!1;try{d=n.lstatSync(c).isSymbolicLink()}catch{d=!1}if(d)throw new y(`render target is a symlink (refusing to follow): ${r}`)}let o=c;for(;!n.existsSync(o);){const d=_(o);if(d===o)break;o=d}let i;try{i=n.realpathSync(o)}catch{return c}const l=w(a,i);if(l===""&&o===t)return c;if(l.startsWith("..")||l.startsWith(`..${S}`)||m(l))throw new y(`render target escapes root via symlink: ${r}`);return c}const Y={existsSync:E,readFileSync:k,writeFileSync:A,mkdirSync:D};function g(e,r,n,t={}){const c=t.fs??Y,s=G(e,r),a=c.existsSync(s),o=a?c.readFileSync(s,"utf-8"):null;if(a&&o!=null&&!F(o)&&!t.force)return{path:s,action:"skipped",reason:"file exists and is not Wyrm-managed (pass force to append)"};const i=H(o,n);return o!=null&&i===o?{path:s,action:"skipped",reason:"unchanged"}:(c.mkdirSync(_(s),{recursive:!0}),c.writeFileSync(s,i,"utf-8"),{path:s,action:a?"updated":"created"})}function K(e,r,n){const t=b(e,r);return{model:t,memoryMd:T(t,n),topics:W(t,n),sessionBrief:C(t,n)}}function Q(e,r,n,t={}){const c=t.rootDir??r.path,s=t.topicsDir??f(".wyrm","memory"),a=K(e,r,n),o=[];o.push(g(c,"MEMORY.md",a.memoryMd,t));for(const i of a.topics)o.push(g(c,f(s,i.filename),i.content,{...t,force:!0}));for(const i of t.clients??[]){const l=q(i,a.model,n);o.push(g(c,l.relPath,l.block,t))}return{plan:a,writes:o}}function X(e=process.env){const r=(e.WYRM_RENDER_WATCH??"").toLowerCase();return r==="1"||r==="true"||r==="yes"}class Z{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{J as ALL_CLIENT_MARKERS,j as ALL_RENDER_CLIENTS,O as MEMORY_MD_LINE_BUDGET,h as RENDER_MARKER_END,$ as RENDER_MARKER_START,Z as RenderCursorTracker,y as RenderPathError,K as buildRenderPlan,I as clientRelPath,b as compileRenderModel,P as detectClients,F as hasWyrmRegion,V as makeRenderDeps,x as provenanceHeader,q as renderForClient,T as renderMemoryMd,C as renderSessionBrief,Q as renderToDisk,W as renderTopicFiles,X as renderWatchEnabled,G as resolveInsideRoot,H as spliceWyrmRegion,g as writeRenderTarget};
+        `).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.
+ */
+/** The native memory-slot path for a client, relative to the project root. */
+export function clientRelPath(client) {
+    switch (client) {
+        // Claude Code reads a project-root CLAUDE.md as its canonical memory slot.
+        case 'claude': return 'CLAUDE.md';
+        case 'cursor': return join('.cursor', 'rules', 'wyrm-memory.md');
+        case 'copilot': return join('.github', 'copilot-instructions.md');
+        case 'agents': return 'AGENTS.md';
+        case 'windsurf': return join('.windsurf', 'rules', 'wyrm-memory.md');
+        case 'cline': return join('.clinerules', 'wyrm-memory.md');
+        case 'zed': return '.rules';
+        case 'gemini': return 'GEMINI.md';
+        default: {
+            const never = client;
+            throw new Error(`unknown render client: ${String(never)}`);
+        }
+    }
+}
+export function renderForClient(client, m, stamp) {
+    // The BLOCK is identical across clients (the MEMORY.md digest, one source of
+    // truth); only the destination slot differs. Codex shares 'agents' (AGENTS.md).
+    return { client, relPath: clientRelPath(client), block: renderMemoryMd(m, stamp) };
+}
+/** Every client Wyrm can render into, in a stable detection order. */
+export const ALL_RENDER_CLIENTS = ['claude', 'cursor', 'copilot', 'agents', 'windsurf', 'cline', 'zed', 'gemini'];
+/** Per-client repo markers that signal "this harness is in use here". */
+const CLIENT_MARKERS = {
+    claude: ['CLAUDE.md', '.claude'],
+    cursor: ['.cursor', '.cursorrules'],
+    copilot: ['.github/copilot-instructions.md', '.github'],
+    agents: ['AGENTS.md'],
+    windsurf: ['.windsurf', '.windsurfrules'],
+    cline: ['.clinerules'],
+    zed: ['.rules', '.zed'],
+    gemini: ['GEMINI.md', '.gemini'],
+};
+/**
+ * Zero-config harness fingerprint: given the repo-relative paths that EXIST in a
+ * project, return the clients to render for — exactly the harnesses present, in
+ * a stable order. `wyrm init` scans the project then calls this; rendering only
+ * into slots that exist means Wyrm never litters a repo with foreign files.
+ */
+export function detectClients(present) {
+    const set = new Set(present);
+    return ALL_RENDER_CLIENTS.filter((c) => CLIENT_MARKERS[c].some((m) => set.has(m)));
+}
+/** The deduped union of every harness marker — what `wyrm init`/`render` scans
+ *  the project root for (existsSync each) before calling detectClients. */
+export const ALL_CLIENT_MARKERS = [...new Set(Object.values(CLIENT_MARKERS).flat())];
+// ──────────────────────────────────────────────────────────────────────────
+// 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