contextos-agents 1.7.0 → 2.0.0-beta.2

package/.agents/adapters/pure-compiler.js

@@ -0,0 +1,443 @@
+/**
+ * .agents/adapters/pure-compiler.js
+ * ContextOS Pure Adapter Compiler Pipeline
+ *
+ * Implements the Milestone 7 pure adapter contract:
+ * - Pure rendering: Adapters return Artifact[] in-memory with ZERO disk side-effects
+ * - Deterministic provenance headers without volatile timestamps
+ * - Multi-adapter collision detection
+ * - Single-transaction application via JournaledTransaction
+ * - Lockfile v2 recording with exact and semantic CRLF dual hashing
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const {
+  resolveManagedPath,
+  toPosix,
+  ProjectMutationLock,
+  JournaledTransaction,
+  LockfileV2Manager,
+  computeExactHash,
+  computeSemanticHash,
+} = require('../filesystem/index.js');
+
+const adaptersRegistry = new Map();
+
+/**
+ * Creates standardized provenance header for an artifact.
+ *
+ * @param {object} meta
+ * @param {string} meta.generator - e.g. "cursor@2", "gemini@2"
+ * @param {string} meta.sourceGraphHash - Hash of registry/skills graph
+ * @param {string} meta.profileId - Active profile slug
+ * @param {string} meta.profileHash - Active profile hash
+ * @param {string} [format='markdown'] - 'markdown' or 'yaml'
+ * @returns {string}
+ */
+function createProvenanceHeader(meta, format = 'markdown') {
+  const {
+    generator = 'unknown@2',
+    sourceGraphHash = 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+    profileId = 'default',
+    profileHash = 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+  } = meta;
+
+  if (format === 'yaml') {
+    return [
+      '# Generated by ContextOS',
+      `# Adapter: ${generator}`,
+      `# Source graph: ${sourceGraphHash}`,
+      `# Profile: ${profileId} ${profileHash}`,
+      '# Do not edit; use .agents/project overrides.',
+      '',
+    ].join('\n');
+  }
+
+  return [
+    '<!--',
+    'Generated by ContextOS',
+    `Adapter: ${generator}`,
+    `Source graph: ${sourceGraphHash}`,
+    `Profile: ${profileId} ${profileHash}`,
+    'Do not edit; use .agents/project overrides.',
+    '-->\n',
+  ].join('\n');
+}
+
+/**
+ * Loads project context required for adapter rendering.
+ */
+function loadCompilerContext(projectRoot, options = {}) {
+  const absRoot = path.resolve(projectRoot);
+
+  // 1. Registry v2
+  let registry = null;
+  const regPath = path.join(absRoot, '.agents', 'compiled', 'registry.v2.json');
+  if (fs.existsSync(regPath)) {
+    try {
+      registry = JSON.parse(fs.readFileSync(regPath, 'utf8'));
+    } catch {
+      // Fallback below
+    }
+  }
+
+  // 2. Profile v2
+  let profile = null;
+  try {
+    const profiles = require('../profiles.js');
+    profile = options.profile ? profiles.getProfile(options.profile, absRoot) : profiles.getActiveProfile(absRoot);
+  } catch {
+    profile = null;
+  }
+
+  // 3. Workspace Graph
+  let workspace = null;
+  try {
+    const { buildWorkspaceGraph } = require('../workspace/workspace-graph.js');
+    workspace = buildWorkspaceGraph(absRoot);
+  } catch {
+    workspace = null;
+  }
+
+  const sourceGraphHash = registry?.sourceGraphHash || 'sha256:0000000000000000000000000000000000000000000000000000000000000000';
+  const profileId = profile?.id || profile?.name || 'default';
+  const profileHash = profile ? computeExactHash(JSON.stringify(profile)) : 'sha256:0000000000000000000000000000000000000000000000000000000000000000';
+
+  return {
+    projectRoot: absRoot,
+    registry,
+    profile,
+    profileId,
+    profileHash,
+    sourceGraphHash,
+    workspace,
+    config: options.config || {},
+  };
+}
+
+const DEFAULT_ADAPTERS = ['gemini', 'claude', 'cursor', 'copilot', 'aider', 'zed'];
+
+function ensureDefaultAdaptersLoaded() {
+  for (const name of DEFAULT_ADAPTERS) {
+    if (!adaptersRegistry.has(name)) {
+      try {
+        require(`./${name}/export.js`);
+      } catch {
+        // Best effort
+      }
+    }
+  }
+}
+
+/**
+ * Registers an adapter with the pure compiler.
+ */
+function registerAdapter(name, adapter) {
+  adaptersRegistry.set(name, adapter);
+}
+
+/**
+ * Retrieves a registered adapter.
+ */
+function getAdapter(name) {
+  ensureDefaultAdaptersLoaded();
+  return adaptersRegistry.get(name);
+}
+
+/**
+ * Lists names of all registered adapters.
+ */
+function listAdapters() {
+  ensureDefaultAdaptersLoaded();
+  return Array.from(adaptersRegistry.keys());
+}
+
+/**
+ * Renders all requested adapters in-memory with strict collision detection.
+ *
+ * @param {string} projectRoot
+ * @param {string[]|string} adapterNames - e.g. ['cursor', 'claude'] or 'all'
+ * @param {object} [options]
+ * @returns {{ artifacts: object[], collisions: object[], context: object }}
+ */
+function renderAdapters(projectRoot, adapterNames = 'all', options = {}) {
+  const context = loadCompilerContext(projectRoot, options);
+  const targets = adapterNames === 'all'
+    ? listAdapters()
+    : (Array.isArray(adapterNames) ? adapterNames : [adapterNames]);
+
+  const allArtifacts = [];
+  const pathToArtifact = new Map();
+  const collisions = [];
+
+  for (const name of targets) {
+    const adapter = getAdapter(name);
+    if (!adapter) {
+      throw new Error(`Unknown adapter '${name}'. Available: ${listAdapters().join(', ')}`);
+    }
+
+    const rendered = adapter.render(context);
+    for (const art of rendered) {
+      const posixPath = toPosix(art.path);
+      const contentBuf = Buffer.isBuffer(art.content) ? art.content : Buffer.from(String(art.content), 'utf8');
+
+      if (pathToArtifact.has(posixPath)) {
+        const existing = pathToArtifact.get(posixPath);
+        // Collision detected
+        collisions.push({
+          path: posixPath,
+          firstAdapter: existing.generator,
+          secondAdapter: art.generator || `${name}@2`,
+        });
+      } else {
+        const standardized = {
+          ...art,
+          path: posixPath,
+          content: contentBuf,
+          generator: art.generator || `${name}@2`,
+          mediaType: art.mediaType || 'text/markdown',
+          kind: art.kind || 'generated-adapter',
+          sourceSkillIds: art.sourceSkillIds || [],
+          inputsHash: art.inputsHash || computeExactHash(context.sourceGraphHash + context.profileHash),
+        };
+        pathToArtifact.set(posixPath, standardized);
+        allArtifacts.push(standardized);
+      }
+    }
+  }
+
+  return {
+    artifacts: allArtifacts,
+    collisions,
+    context,
+  };
+}
+
+/**
+ * Applies rendered artifacts to disk in a single atomic JournaledTransaction
+ * and updates Lockfile v2.
+ */
+function applyArtifacts(projectRoot, artifacts, options = {}) {
+  const absRoot = path.resolve(projectRoot);
+  const ownLock = !options.lockToken;
+  const lock = ownLock ? new ProjectMutationLock(absRoot) : null;
+  const lockToken = ownLock ? lock.acquire({ command: options.command || 'export' }) : options.lockToken;
+
+  try {
+    const tx = new JournaledTransaction(absRoot);
+    const lockfileManager = new LockfileV2Manager(absRoot);
+    const lockfileData = lockfileManager.read() || lockfileManager.createEmpty({
+      profileId: options.context?.profileId || 'default',
+      profileHash: options.context?.profileHash,
+      sourceGraphHash: options.context?.sourceGraphHash,
+      enabledAdapters: options.enabledAdapters || listAdapters(),
+    });
+
+    let hasModifications = false;
+
+    for (const art of artifacts) {
+      const exactSha256 = computeExactHash(art.content);
+      const semanticTextSha256 = computeSemanticHash(art.content);
+      const existingRecord = lockfileData?.managedFiles?.[art.path];
+      
+      let needsWrite = true;
+      let needsLockfileUpdate = true;
+      
+      if (existingRecord) {
+        if (existingRecord.exactSha256 === exactSha256 && existingRecord.inputsHash === art.inputsHash) {
+          needsLockfileUpdate = false;
+        }
+      }
+      
+      const absPath = path.resolve(absRoot, art.path);
+      if (fs.existsSync(absPath)) {
+         const diskBuf = fs.readFileSync(absPath);
+         if (computeExactHash(diskBuf) === exactSha256) {
+           needsWrite = false;
+         }
+      }
+
+      if (needsWrite) {
+        tx.stageWrite(art.path, art.content, { mode: art.mode || 420 });
+        hasModifications = true;
+      }
+
+      if (needsLockfileUpdate || needsWrite || !existingRecord) {
+        lockfileManager.recordManagedFile(lockfileData, art.path, {
+          exactSha256,
+          semanticTextSha256,
+          kind: art.kind,
+          generator: art.generator,
+          inputsHash: art.inputsHash,
+          mode: art.mode || 420,
+          lastTransaction: needsWrite ? tx.txId : existingRecord?.lastTransaction,
+        });
+        if (needsLockfileUpdate) hasModifications = true;
+      }
+    }
+
+    const activePaths = new Set(artifacts.map(a => toPosix(a.path)));
+    const activeGenerators = new Set(artifacts.map(a => a.generator));
+
+    // Support backward compatibility with Lockfile v1 (.agents/contextos.lock.json)
+    const v1LockPath = path.join(absRoot, '.agents', 'contextos.lock.json');
+    let v1Data = null;
+    if (fs.existsSync(v1LockPath)) {
+      try {
+        v1Data = JSON.parse(fs.readFileSync(v1LockPath, 'utf8'));
+      } catch {}
+    }
+
+    // 1. Prune stale files recorded in Lockfile v2
+    if (lockfileData && lockfileData.managedFiles) {
+      for (const [recordedPath, meta] of Object.entries(lockfileData.managedFiles)) {
+        if (activeGenerators.has(meta.generator) && !activePaths.has(recordedPath)) {
+          const absRecPath = path.resolve(absRoot, recordedPath);
+          if (fs.existsSync(absRecPath)) {
+            tx.stageDelete(recordedPath);
+            hasModifications = true;
+          }
+          lockfileManager.removeManagedFile(lockfileData, recordedPath);
+          hasModifications = true;
+        }
+      }
+    }
+
+    // 2. Cursor adapter rule pruning: scan .cursor/rules/*.mdc for stale managed files
+    if (activeGenerators.has('cursor@2')) {
+      const cursorRulesDir = path.join(absRoot, '.cursor', 'rules');
+      if (fs.existsSync(cursorRulesDir)) {
+        for (const file of fs.readdirSync(cursorRulesDir)) {
+          if (file.endsWith('.mdc')) {
+            const relPath = toPosix(path.relative(absRoot, path.join(cursorRulesDir, file)));
+            if (!activePaths.has(relPath)) {
+              const isManagedInV1 = Boolean(v1Data?.files?.[relPath]?.managed || v1Data?.managedFiles?.[relPath]?.managed);
+              const isManagedInV2 = Boolean(lockfileData?.managedFiles?.[relPath]);
+              let hasContextosMarker = false;
+              try {
+                const content = fs.readFileSync(path.join(cursorRulesDir, file), 'utf8');
+                hasContextosMarker =
+                  content.includes('ContextOS rules for') ||
+                  content.includes('<!-- Auto-generated by: node .agents/ctx.js export cursor -->') ||
+                  content.includes('ContextOS — Project Operating System Rules') ||
+                  content.includes('contextos:generator');
+              } catch {}
+
+              if (isManagedInV1 || isManagedInV2 || hasContextosMarker) {
+                tx.stageDelete(relPath);
+                hasModifications = true;
+                if (v1Data?.files?.[relPath]) { delete v1Data.files[relPath]; hasModifications = true; }
+                if (v1Data?.managedFiles?.[relPath]) { delete v1Data.managedFiles[relPath]; hasModifications = true; }
+                if (lockfileData?.managedFiles?.[relPath]) { lockfileManager.removeManagedFile(lockfileData, relPath); hasModifications = true; }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // 3. Zed adapter prompt pruning: scan .zed/prompts/*.md for stale managed files
+    if (activeGenerators.has('zed@2')) {
+      const zedPromptsDir = path.join(absRoot, '.zed', 'prompts');
+      if (fs.existsSync(zedPromptsDir)) {
+        for (const file of fs.readdirSync(zedPromptsDir)) {
+          if (file.endsWith('.md')) {
+            const relPath = toPosix(path.relative(absRoot, path.join(zedPromptsDir, file)));
+            if (!activePaths.has(relPath)) {
+              const isManagedInV1 = Boolean(v1Data?.files?.[relPath]?.managed || v1Data?.managedFiles?.[relPath]?.managed);
+              const isManagedInV2 = Boolean(lockfileData?.managedFiles?.[relPath]);
+              let hasContextosMarker = false;
+              try {
+                const content = fs.readFileSync(path.join(zedPromptsDir, file), 'utf8');
+                hasContextosMarker =
+                  content.includes('<!-- Auto-generated by: node .agents/ctx.js export zed -->') ||
+                  content.includes('# ContextOS —') ||
+                  content.includes('# ContextOS Master Prompt') ||
+                  content.includes('contextos:generator');
+              } catch {}
+
+              if (isManagedInV1 || isManagedInV2 || hasContextosMarker) {
+                tx.stageDelete(relPath);
+                hasModifications = true;
+                if (v1Data?.files?.[relPath]) { delete v1Data.files[relPath]; hasModifications = true; }
+                if (v1Data?.managedFiles?.[relPath]) { delete v1Data.managedFiles[relPath]; hasModifications = true; }
+                if (lockfileData?.managedFiles?.[relPath]) { lockfileManager.removeManagedFile(lockfileData, relPath); hasModifications = true; }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Clean up empty/orphan skill directories in generated paths
+    const cleanupDirs = [
+      path.join(absRoot, '.agents', 'generated', 'gemini', 'skills'),
+      path.join(absRoot, '.agents', 'generated', 'claude', 'skills'),
+    ];
+    for (const parentDir of cleanupDirs) {
+      if (fs.existsSync(parentDir)) {
+        for (const entry of fs.readdirSync(parentDir)) {
+          const entryPath = path.join(parentDir, entry);
+          if (fs.statSync(entryPath).isDirectory()) {
+            const relMd = toPosix(path.relative(absRoot, path.join(entryPath, 'SKILL.md')));
+            if (!activePaths.has(relMd)) {
+              // Delete orphaned files inside the directory, if any. The generator writes SKILL.md and optional references.
+              for (const child of fs.readdirSync(entryPath)) {
+                tx.stageDelete(toPosix(path.relative(absRoot, path.join(entryPath, child))));
+                hasModifications = true;
+              }
+              const relDir = toPosix(path.relative(absRoot, entryPath));
+              tx.stageDeleteDir(relDir);
+              hasModifications = true;
+            }
+          }
+        }
+      }
+    }
+
+    // ONLY commit and bump revision if modifications occurred
+    let txResult = { txId: tx.txId, appliedCount: 0 };
+    
+    if (hasModifications) {
+      // Persist updated v1 lockfile if present
+      if (v1Data && fs.existsSync(v1LockPath)) {
+        try {
+          const relV1LockPath = toPosix(path.relative(absRoot, v1LockPath));
+          tx.stageWrite(relV1LockPath, JSON.stringify(v1Data, null, 2) + '\n');
+        } catch {}
+      }
+    
+      // Stage lockfile v2 update
+      lockfileData.revision += 1;
+      const relLockPath = toPosix(path.relative(absRoot, lockfileManager.lockfilePath));
+      tx.stageWrite(relLockPath, JSON.stringify(lockfileData, null, 2) + '\n');
+
+      // Commit all file modifications atomically
+      txResult = tx.commit();
+    }
+
+    return {
+      success: true,
+      txId: txResult.txId,
+      appliedCount: hasModifications ? artifacts.length : 0,
+      skipped: !hasModifications
+    };
+  } finally {
+    if (ownLock && lockToken && lock) {
+      lock.release(lockToken);
+    }
+  }
+}
+
+module.exports = {
+  createProvenanceHeader,
+  loadCompilerContext,
+  registerAdapter,
+  getAdapter,
+  listAdapters,
+  renderAdapters,
+  applyArtifacts,
+};

package/.agents/adapters/zed/export.js

@@ -1,26 +1,28 @@
+/**
+ * .agents/adapters/zed/export.js
+ * ContextOS Zed IDE Pure Adapter (.zed/rules.md & .zed/prompts/*.md)
+ */
+
 const fs = require('fs');
 const path = require('path');
-const { AGENTS_MD_PATH, collectSkillDirectories, extractYamlField, stripFrontmatter, readMeaningfulMarkdown } = require('../shared.js');
+const { AGENTS_MD_PATH, collectSkillDirectories, extractYamlField, stripFrontmatter } = require('../shared.js');
+const { registerAdapter, applyArtifacts, createProvenanceHeader } = require('../pure-compiler.js');
 
-// Output destinations for Zed
-const ZED_DIR = path.join(process.cwd(), '.zed');
-const RULES_FILE = path.join(ZED_DIR, 'rules.md');
-const PROMPTS_DIR = path.join(ZED_DIR, 'prompts');
+const GENERATOR_ID = 'zed@2';
 
-/**
- * Zed IDE adapter — export.js
- *
- * Generates:
- *   1. `.zed/rules.md` — Project assistant instructions loaded into Zed's context
- *   2. `.zed/prompts/*.md` — Modular slash-command prompts for Zed Assistant
- *
- * Format spec: https://zed.dev/docs/assistant
- */
+function describe() {
+  return {
+    name: 'zed',
+    version: '2.0.0',
+    description: 'Compiles instructions and prompts for Zed IDE (.zed/rules.md and .zed/prompts/*.md)',
+    targetPattern: '.zed/**',
+  };
+}
 
 function buildSkillSection(skillDir) {
-  const skillName  = path.basename(skillDir);
-  const skillMdPath  = path.join(skillDir, 'SKILL.md');
-  const yamlPath   = path.join(skillDir, 'skill.yaml');
+  const skillName = path.basename(skillDir);
+  const skillMdPath = path.join(skillDir, 'SKILL.md');
+  const yamlPath = path.join(skillDir, 'skill.yaml');
 
   let title = skillName;
   let description = '';
@@ -46,105 +48,111 @@ function buildSkillSection(skillDir) {
     skillName,
     title,
     section: `\n### Skill: ${title}\n${descLine}${promptRef}`,
-    prompt: `<!-- Auto-generated by: node .agents/ctx.js export zed -->\n# ContextOS — ${title}\n\n${descLine}\n${body}\n`,
+    prompt: `# ContextOS — ${title}\n\n${descLine}\n${body}\n`,
   };
 }
 
-function run() {
-  console.log('Starting Zed IDE adapter export...');
-
-  const zedDir = path.join(process.cwd(), '.zed');
-  const rulesFile = path.join(zedDir, 'rules.md');
-  const promptsDir = path.join(zedDir, 'prompts');
-  const agentsMdPath = fs.existsSync(path.join(process.cwd(), '.agents', 'AGENTS.md'))
-    ? path.join(process.cwd(), '.agents', 'AGENTS.md')
+function render(context) {
+  const projectRoot = context?.projectRoot || '.';
+  const agentsMdPath = fs.existsSync(path.join(projectRoot, '.agents', 'AGENTS.md'))
+    ? path.join(projectRoot, '.agents', 'AGENTS.md')
     : AGENTS_MD_PATH;
 
-  fs.mkdirSync(zedDir, { recursive: true });
-  fs.mkdirSync(promptsDir, { recursive: true });
+  const prov = createProvenanceHeader({
+    generator: GENERATOR_ID,
+    sourceGraphHash: context?.sourceGraphHash,
+    profileId: context?.profileId,
+    profileHash: context?.profileHash,
+  });
 
-  const lines = [];
+  const artifacts = [];
+  const rulesLines = [];
 
-  // ── Header ───────────────────────────────────────────────────────────────────
-  lines.push(
-    `# ContextOS — AI Rules for Zed Assistant\n`,
-    `<!-- Auto-generated by: node .agents/ctx.js export zed -->\n`,
-    `<!-- Source: .agents/core/skills/  ·  Do not edit manually. -->\n\n`
+  rulesLines.push(
+    prov +
+    `# ContextOS — AI Rules for Zed Assistant\n\n` +
+    `> **Core law: Do not read everything. Read only what the current task requires.**\n\n`
   );
 
-  // ── Project Rules ────────────────────────────────────────────────────────────
   if (fs.existsSync(agentsMdPath)) {
     const agentsMd = fs.readFileSync(agentsMdPath, 'utf8');
-    lines.push(`## Project Rules (AGENTS.md)\n\n${agentsMd}\n\n---\n`);
-
-    // Also write a master prompt in .zed/prompts/contextos.md
-    fs.writeFileSync(
-      path.join(promptsDir, 'contextos.md'),
-      `<!-- Auto-generated by: node .agents/ctx.js export zed -->\n# ContextOS Master Prompt\n\n${agentsMd}\n`
-    );
+    rulesLines.push(`## Core Rules & Step 0\n\n${agentsMd}\n\n---\n`);
+
+    artifacts.push({
+      path: '.zed/prompts/contextos.md',
+      content: (prov + `# ContextOS Master Prompt\n\n${agentsMd}\n`).replace(/\r\n/g, '\n'),
+      mediaType: 'text/markdown',
+      kind: 'generated-adapter',
+      generator: GENERATOR_ID,
+      sourceSkillIds: ['project-rules'],
+      inputsHash: context?.sourceGraphHash || 'none',
+    });
   }
 
-  // ── Skills ───────────────────────────────────────────────────────────────────
-  lines.push(`\n## Skills Library\n`);
-  lines.push(`The following specialist skills guide architecture and implementation:\n`);
-
-  const skills = collectSkillDirectories();
-  const activePromptFiles = new Set(['contextos.md']);
-  let count = 0;
+  rulesLines.push(
+    `\n## Skills Library\n\n` +
+    `Each skill is also available as a slash-command prompt in \`.zed/prompts/<skill>.md\`.\n\n` +
+    `### Available Skills\n`
+  );
 
+  const skills = collectSkillDirectories(context?.profile);
   for (const skill of skills) {
-    const skillData = buildSkillSection(skill);
-    if (skillData) {
-      lines.push(skillData.section);
-      const promptFileName = `${skillData.skillName}.md`;
-      activePromptFiles.add(promptFileName);
-      fs.writeFileSync(path.join(promptsDir, promptFileName), skillData.prompt);
-      count++;
+    const res = buildSkillSection(skill);
+    if (res) {
+      rulesLines.push(res.section);
+
+      artifacts.push({
+        path: `.zed/prompts/${res.skillName}.md`,
+        content: (prov + res.prompt).replace(/\r\n/g, '\n'),
+        mediaType: 'text/markdown',
+        kind: 'generated-adapter',
+        generator: GENERATOR_ID,
+        sourceSkillIds: [res.skillName],
+        inputsHash: context?.sourceGraphHash || 'none',
+      });
     }
   }
 
-  // Clean up stale prompts from uninstalled skills/plugins safely (provenance-verified only)
-  if (fs.existsSync(promptsDir)) {
-    const lockfilePath = path.join(process.cwd(), '.agents', 'contextos.lock.json');
-    let lockData = null;
-    try {
-      if (fs.existsSync(lockfilePath)) {
-        lockData = JSON.parse(fs.readFileSync(lockfilePath, 'utf8'));
-      }
-    } catch {}
-
-    for (const file of fs.readdirSync(promptsDir)) {
-      if (file.endsWith('.md') && !activePromptFiles.has(file)) {
-        const fullFilePath = path.join(promptsDir, file);
-        const relPath = path.relative(process.cwd(), fullFilePath).replace(/\\/g, '/');
-
-        const isManagedInLock = Boolean(lockData?.managedFiles?.[relPath]?.managed);
-        let hasContextosMarker = false;
-        try {
-          const content = fs.readFileSync(fullFilePath, 'utf8');
-          hasContextosMarker =
-            content.includes('<!-- Auto-generated by: node .agents/ctx.js export zed -->') ||
-            content.includes('# ContextOS —') ||
-            content.includes('# ContextOS Master Prompt');
-        } catch {}
-
-        if (isManagedInLock || hasContextosMarker) {
-          fs.unlinkSync(fullFilePath);
-          if (lockData?.managedFiles?.[relPath]) {
-            delete lockData.managedFiles[relPath];
-            try {
-              fs.writeFileSync(lockfilePath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
-            } catch {}
-          }
-        }
-      }
+  artifacts.push({
+    path: '.zed/rules.md',
+    content: rulesLines.join('').replace(/\r\n/g, '\n'),
+    mediaType: 'text/markdown',
+    kind: 'generated-adapter',
+    generator: GENERATOR_ID,
+    sourceSkillIds: skills.map(s => path.basename(s)),
+    inputsHash: context?.sourceGraphHash || 'none',
+  });
+
+  return artifacts;
+}
+
+function validate(artifacts) {
+  const diagnostics = [];
+  for (const art of artifacts) {
+    if (!art.content || art.content.length === 0) {
+      diagnostics.push({ path: art.path, message: 'Empty artifact content' });
     }
   }
+  return diagnostics;
+}
 
-  // Write master .zed/rules.md
-  fs.writeFileSync(rulesFile, lines.join(''));
-  console.log(`Generated .zed/rules.md (${count} skills) → ${rulesFile}`);
-  console.log(`Generated .zed/prompts/*.md (${count} prompts) → ${promptsDir}`);
+function run(options = {}) {
+  const { loadCompilerContext } = require('../pure-compiler.js');
+  const projectRoot = options.projectRoot || '.';
+  const context = loadCompilerContext(projectRoot, options);
+  const artifacts = render(context);
+  const result = applyArtifacts(projectRoot, artifacts, { command: 'export zed', context });
+  console.log(`✓ Zed export complete: ${result.appliedCount} files applied (tx: ${result.txId})`);
+  return result;
 }
 
-module.exports = { run };
+const adapter = {
+  describe,
+  render,
+  validate,
+  run,
+};
+
+registerAdapter('zed', adapter);
+
+module.exports = adapter;