intentdna 1.6.3 → 1.6.5

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "Declarative policy layer for AI agent behavior with plugin-managed hook runtime for Claude Code.",
-      "version": "1.6.3",
+      "version": "1.6.5",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.6.3"
+  "version": "1.6.5"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "Declarative policy layer for AI agent behavior",
   "author": {
     "name": "Samuel"

package/dist/cli/commands/generate.js

@@ -11,51 +11,23 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { TEMPLATE_MATCH_METADATA } from "../../templates/metadata.js";
 const SPEC_PATH = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "spec", "schema-spec.md");
 const TEMPLATES_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "templates");
-/** Keyword → template name mapping for scoring */
-const TEMPLATE_KEYWORDS = {
-    "code-review-pipeline": ["review", "code review", "pr review", "pull request", "审查"],
-    "safe-refactoring": ["refactor", "refactoring", "restructure", "rewrite safely", "重构"],
-    "tdd-strict": ["tdd", "test driven", "test first", "red green", "测试驱动"],
-    "full-pipeline": ["pipeline", "plan implement test", "full workflow", "完整流水线"],
-    "systematic-debugging": ["debug", "debugging", "bug fix", "troubleshoot", "调试"],
-    "verification-loop": ["verify", "verification", "validate", "check", "验证"],
-    "secure-dev": ["security", "secure", "owasp", "vulnerability", "安全"],
-    "enterprise-baseline": ["enterprise", "organization", "company", "corporate", "企业"],
-    "frontend-quality": ["frontend", "react", "vue", "css", "ui", "前端"],
-    "api-backend": ["api", "backend", "rest", "graphql", "server", "后端"],
-    "mobile-dev": ["mobile", "ios", "android", "react native", "移动"],
-    "documentation-writer": ["doc", "documentation", "readme", "wiki", "文档"],
-    "devops-cicd": ["devops", "ci", "cd", "deploy", "pipeline", "运维"],
-    "monorepo-governance": ["monorepo", "workspace", "packages", "governance"],
-    "flutter-behavior-lock": ["flutter", "behavior lock", "behavior spec", "行为锁定"],
-    "flutter-rewrite": ["flutter", "rewrite", "migration", "flutter rewrite"],
-    "flutter-refactoring-rescue": ["flutter", "rescue", "refactoring rescue"],
-    "multi-perspective-review": ["multi perspective", "multiple reviewer", "多角度"],
-    "subagent-parallel": ["parallel", "subagent", "concurrent", "并行"],
-    "yolo-with-guardrails": ["yolo", "fast", "guardrails", "move fast"],
-    "brainstorming-first": ["brainstorm", "explore", "ideation", "探索"],
-    "branch-finishing": ["branch", "finish", "cleanup", "pr prep"],
-    "pr-submitter": ["pr", "pull request", "submit"],
-    "migration-safety": ["migration", "migrate", "upgrade", "database migration", "dependency upgrade", "迁移"],
-    "incident-response": ["incident", "production issue", "hotfix", "outage", "postmortem", "事故"],
-    "performance-audit": ["performance", "profiling", "benchmark", "optimize", "latency", "性能"],
-};
 function scoreTemplates(description) {
     const lower = description.toLowerCase();
     const scores = [];
-    for (const [template, keywords] of Object.entries(TEMPLATE_KEYWORDS)) {
+    for (const template of TEMPLATE_MATCH_METADATA) {
         const matched = [];
-        for (const kw of keywords) {
+        for (const kw of template.keywords) {
             if (lower.includes(kw)) {
                 matched.push(kw);
             }
         }
         if (matched.length > 0) {
             scores.push({
-                name: template,
-                displayName: template.replace(/-/g, " "),
+                name: template.name,
+                displayName: template.name.replace(/-/g, " "),
                 score: matched.length,
                 matchedKeywords: matched,
             });

package/dist/cli/commands/sync.js

@@ -18,6 +18,8 @@ import { createInterface } from "node:readline";
 import { loadDNA, compileFromFiles } from "../../compiler/index.js";
 import { parseYAML } from "../../schema/yaml-parser.js";
 import { compileToMarkdown, injectIntoFile, removeFromFile } from "../../runtime/markdown.js";
+import { syncInjectMarkdownTargets } from "../../runtime/markdown-target-registry.js";
+import { getSyncOutputArtifactMetadata } from "../../runtime/output-artifact-registry.js";
 import { compileAllRolesToAgentMD, writeAgentMDFiles, removeAgentMDFiles } from "../../runtime/agent-md.js";
 import { removeWorkflowScripts } from "../../runtime/workflow-runner.js";
 import { compileWorkflowToSkill, compileControllerToSkill, writeSkillFiles } from "../../runtime/skill-adapter.js";
@@ -25,7 +27,7 @@ import { compilePluginSettings, detectEnabledEvents, mergeSettingsFile, recommen
 import { createCompiledIR, writeCompiledIR } from "../../runtime/plugin-adapter.js";
 import { cascadeDNA } from "../../compiler/cascade.js";
 import { EvolutionEngine } from "../../evolution/index.js";
-const VALID_TARGETS = ["claude-md", "soul-md", "cursorrules", "system-prompt"];
+const VALID_TARGETS = syncInjectMarkdownTargets();
 /**
  * Detect whether intentdna is running as a Claude Code plugin or standalone binary.
  *
@@ -392,6 +394,17 @@ async function computeFileHash(filePath) {
     const content = await readFile(filePath, "utf-8");
     return fileSha256(content);
 }
+function trackSyncOutput(trackedOutputs, artifact, path) {
+    if (!getSyncOutputArtifactMetadata(artifact)) {
+        throw new Error(`Unknown sync output artifact: ${artifact}`);
+    }
+    trackedOutputs.push({ artifact, path: resolve(path) });
+}
+function lockTrackedOutputPaths(trackedOutputs) {
+    return trackedOutputs
+        .filter((output) => getSyncOutputArtifactMetadata(output.artifact)?.trackedByLock)
+        .map((output) => output.path);
+}
 async function generateLockFile(lockPath, dnaSources, outputFiles) {
     const outputs = {};
     for (const f of outputFiles) {
@@ -541,7 +554,7 @@ export async function runSync(opts) {
             else {
                 process.stderr.write(`No changes needed in ${opts.inject}\n`);
             }
-            trackedOutputs.push(resolve(opts.inject));
+            trackSyncOutput(trackedOutputs, "markdown-injection", opts.inject);
         }
         // Step 3.5: Write compiled IR (needed for both plugin and bin mode)
         {
@@ -552,7 +565,7 @@ export async function runSync(opts) {
             const compiled = createCompiledIR(ir, roles);
             const irPath = await writeCompiledIR(cwd, compiled);
             process.stderr.write(`Wrote compiled IR: ${irPath}\n`);
-            trackedOutputs.push(resolve(irPath));
+            trackSyncOutput(trackedOutputs, "compiled-ir", irPath);
             // Clean up old bash hooks if they exist
             const oldHooksDir = resolve(cwd, ".claude", "hooks");
             const removed = await removeLegacyBashHooks(oldHooksDir);
@@ -560,7 +573,8 @@ export async function runSync(opts) {
                 process.stderr.write(`Cleaned ${removed} legacy bash hook(s) from ${oldHooksDir}\n`);
             }
             // G2/G3: Register built-in DNA MCP server in .claude/.mcp.json
-            await registerDNAMCPServer(cwd);
+            const mcpPath = await registerDNAMCPServer(cwd);
+            trackSyncOutput(trackedOutputs, "mcp-config", mcpPath);
         }
         // Step 3.6: Register hooks in settings.json (bin mode only)
         // Plugin mode: hooks managed by plugin framework — skip settings.json
@@ -570,7 +584,7 @@ export async function runSync(opts) {
                 const pluginSettings = compilePluginSettings(enabledEvents, 10, recommendHookTimeouts(ir));
                 await mergeSettingsFile(pluginSettings, opts.settingsPath);
                 process.stderr.write(`Bin mode: registered ${enabledEvents.length} hook event(s) in ${opts.settingsPath}\n`);
-                trackedOutputs.push(resolve(opts.settingsPath));
+                trackSyncOutput(trackedOutputs, "settings-hooks", opts.settingsPath);
             }
         }
         else if (opts.plugin && opts.settingsPath) {
@@ -601,7 +615,8 @@ export async function runSync(opts) {
                     for (const f of written) {
                         process.stderr.write(`  ${f}\n`);
                     }
-                    trackedOutputs.push(...written.map(f => resolve(f)));
+                    for (const file of written)
+                        trackSyncOutput(trackedOutputs, "agents", file);
                 }
             }
         }
@@ -636,7 +651,7 @@ export async function runSync(opts) {
                         const shellResult = compileWorkflowToShell(result.plan);
                         const written = await writeWorkflowScript(shellResult, opts.workflowDir);
                         process.stderr.write(`Generated workflow script: ${written}\n`);
-                        trackedOutputs.push(resolve(written));
+                        trackSyncOutput(trackedOutputs, "workflows", written);
                     }
                 }
             }
@@ -696,7 +711,8 @@ export async function runSync(opts) {
                     for (const f of written) {
                         process.stderr.write(`  ${f}\n`);
                     }
-                    trackedOutputs.push(...written.map(f => resolve(f)));
+                    for (const file of written)
+                        trackSyncOutput(trackedOutputs, "skills-controllers", file);
                 }
             }
         }
@@ -708,7 +724,7 @@ export async function runSync(opts) {
         // Step 9: Generate .dna/lock file (only when --lock is specified or outputs exist)
         if (opts.lockFile && trackedOutputs.length > 0) {
             const lockPath = resolve(opts.lockFile);
-            await generateLockFile(lockPath, expandedFiles, trackedOutputs);
+            await generateLockFile(lockPath, expandedFiles, lockTrackedOutputPaths(trackedOutputs));
             process.stderr.write(`Lock file: ${lockPath}\n`);
         }
         return 0;
@@ -781,7 +797,7 @@ async function registerDNAMCPServer(cwd) {
     const mcpServers = (existing.mcpServers ?? {});
     // Don't overwrite if user already configured it
     if (mcpServers["intentdna"])
-        return;
+        return mcpJsonPath;
     mcpServers["intentdna"] = {
         command: "dna-mcp",
         args: ["--project-dir", cwd],
@@ -790,4 +806,5 @@ async function registerDNAMCPServer(cwd) {
     await mkdir(dirname(mcpJsonPath), { recursive: true });
     await writeFileAsync(mcpJsonPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
     process.stderr.write(`MCP: registered dna-mcp server in ${mcpJsonPath}\n`);
+    return mcpJsonPath;
 }

package/dist/hooks/cli.js

@@ -22,13 +22,11 @@ import { readStdin, writeOutput, silentOutput, allowOutput, blockOutput, stopOut
 import { validateHookInput } from "./schema.js";
 import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, extractBashWritePaths, checkReflectionLimit, checkContextReadiness, checkWorkflowBoundary, } from "./enforce.js";
 import { appendAudit, readWorkflowState, appendTrace, rotateTraces, readTraces, cleanStaleState, readSurgeonAttempts, writeSurgeonAttempts, appendSessionRead, readSessionReads, appendVerifierResult, appendCompletedArtifact, artifactIdentity, buildArtifactKey, readArtifactManifest, resolveArtifactTemplate, safePathComponent, writeArtifactManifest } from "./state.js";
+import { hookEventsForSurface } from "./event-registry.js";
 import { writeAuditEvent } from "../audit/index.js";
 // ── Constants ──────────────────────────────────────────────
 const DEFAULT_IR_PATH = ".dna/compiled/ir.json";
-const VALID_EVENTS = new Set([
-    "PreToolUse", "PostToolUse", "UserPromptSubmit",
-    "SubagentStop", "PreCompact", "Notification", "Stop", "SessionStart",
-]);
+const VALID_EVENTS = new Set(hookEventsForSurface("cli"));
 export function computeSummary(traces) {
     let blocks = 0, warns = 0;
     const toolCounts = new Map();

package/dist/hooks/event-registry.d.ts

@@ -0,0 +1,17 @@
+export declare const HOOK_EVENT_NAMES: readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "SubagentStop", "PreCompact", "Notification", "Stop", "SessionStart"];
+export type HookEvent = typeof HOOK_EVENT_NAMES[number];
+export declare const SETTINGS_HOOK_EVENT_KEYS: readonly ["preToolUse", "postToolUse", "userPromptSubmit", "subagentStop", "preCompact", "notification", "stop"];
+export type SettingsHookEventKey = typeof SETTINGS_HOOK_EVENT_KEYS[number];
+export type HookSurface = "protocol" | "cli" | "settings" | "manifest" | "mcp";
+export interface HookEventMetadata {
+    event: HookEvent;
+    settingsKey?: SettingsHookEventKey;
+    manifestTimeout: number;
+    surfaces: Record<HookSurface, boolean>;
+}
+export declare const HOOK_EVENT_REGISTRY: readonly HookEventMetadata[];
+export declare function getHookEventMetadata(event: unknown): HookEventMetadata | undefined;
+export declare function getHookEventBySettingsKey(key: unknown): HookEventMetadata | undefined;
+export declare function hookEventsForSurface(surface: HookSurface): HookEvent[];
+export declare function settingsHookEventKeys(): SettingsHookEventKey[];
+export declare function isHookEventSupportedBySurface(event: unknown, surface: HookSurface): event is HookEvent;

package/dist/hooks/event-registry.js

@@ -0,0 +1,89 @@
+export const HOOK_EVENT_NAMES = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "SubagentStop",
+    "PreCompact",
+    "Notification",
+    "Stop",
+    "SessionStart",
+];
+export const SETTINGS_HOOK_EVENT_KEYS = [
+    "preToolUse",
+    "postToolUse",
+    "userPromptSubmit",
+    "subagentStop",
+    "preCompact",
+    "notification",
+    "stop",
+];
+export const HOOK_EVENT_REGISTRY = [
+    {
+        event: "PreToolUse",
+        settingsKey: "preToolUse",
+        manifestTimeout: 5,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
+    },
+    {
+        event: "PostToolUse",
+        settingsKey: "postToolUse",
+        manifestTimeout: 3,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
+    },
+    {
+        event: "UserPromptSubmit",
+        settingsKey: "userPromptSubmit",
+        manifestTimeout: 5,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
+    },
+    {
+        event: "SubagentStop",
+        settingsKey: "subagentStop",
+        manifestTimeout: 3,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
+    },
+    {
+        event: "PreCompact",
+        settingsKey: "preCompact",
+        manifestTimeout: 3,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
+    },
+    {
+        event: "Notification",
+        settingsKey: "notification",
+        manifestTimeout: 3,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
+    },
+    {
+        event: "Stop",
+        settingsKey: "stop",
+        manifestTimeout: 45,
+        surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: false },
+    },
+    {
+        event: "SessionStart",
+        manifestTimeout: 5,
+        surfaces: { protocol: true, cli: true, settings: false, manifest: true, mcp: true },
+    },
+];
+const EVENT_BY_NAME = new Map(HOOK_EVENT_REGISTRY.map((entry) => [entry.event, entry]));
+const EVENT_BY_SETTINGS_KEY = new Map(HOOK_EVENT_REGISTRY.flatMap((entry) => entry.settingsKey ? [[entry.settingsKey, entry]] : []));
+export function getHookEventMetadata(event) {
+    return typeof event === "string" ? EVENT_BY_NAME.get(event) : undefined;
+}
+export function getHookEventBySettingsKey(key) {
+    return typeof key === "string" ? EVENT_BY_SETTINGS_KEY.get(key) : undefined;
+}
+export function hookEventsForSurface(surface) {
+    return HOOK_EVENT_REGISTRY
+        .filter((entry) => entry.surfaces[surface])
+        .map((entry) => entry.event);
+}
+export function settingsHookEventKeys() {
+    return HOOK_EVENT_REGISTRY
+        .filter((entry) => entry.surfaces.settings && entry.settingsKey)
+        .map((entry) => entry.settingsKey);
+}
+export function isHookEventSupportedBySurface(event, surface) {
+    return getHookEventMetadata(event)?.surfaces[surface] === true;
+}

package/dist/hooks/protocol.d.ts

@@ -6,7 +6,7 @@
  *
  * Protocol reference: docs/references/cc-source-analysis.md §2
  */
-export type HookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "SubagentStop" | "PreCompact" | "Notification" | "Stop" | "SessionStart";
+export type { HookEvent } from "./event-registry.js";
 /** Base fields present in all hook inputs */
 export interface HookInputBase {
     cwd?: string;

package/dist/hooks/schema.js

@@ -3,6 +3,7 @@
  * Zero external dependencies. Hand-written validators.
  * Fail-open: invalid input → log warning + return { valid: false, ... }
  */
+import { isHookEventSupportedBySurface } from "./event-registry.js";
 /**
  * Validate hook input against expected schema for each event type.
  * Returns normalized input (camelCase) on success.
@@ -20,6 +21,9 @@ export function validateHookInput(event, raw) {
         normalized.sessionId = sessionId;
         delete normalized.session_id;
     }
+    if (!isHookEventSupportedBySurface(event, "protocol")) {
+        return { valid: false, errors: [`Unknown event type: ${event}`] };
+    }
     switch (event) {
         case "PreToolUse":
             if (typeof input.tool_name !== "string") {
@@ -58,7 +62,7 @@ export function validateHookInput(event, raw) {
             // Minimal validation — these events have no required fields beyond base
             break;
         default:
-            errors.push(`Unknown event type: ${event}`);
+            break;
     }
     return {
         valid: errors.length === 0,

package/dist/mcp/tools-enforce.js

@@ -10,6 +10,7 @@
 import { resolve } from "node:path";
 import { stat, readFile } from "node:fs/promises";
 import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, } from "../hooks/enforce.js";
+import { hookEventsForSurface } from "../hooks/event-registry.js";
 import { textResult, errorResult } from "./server.js";
 // ── IR Cache ────────────────────────────────────────────────
 /** In-memory IR cache with mtime-based invalidation. */
@@ -61,10 +62,7 @@ export class IRCache {
         this.lastMtime = 0;
     }
 }
-const VALID_EVENTS = new Set([
-    "PreToolUse", "PostToolUse", "UserPromptSubmit",
-    "SubagentStop", "PreCompact", "Notification", "SessionStart",
-]);
+const VALID_EVENTS = new Set(hookEventsForSurface("mcp"));
 function dispatchEnforce(event, ir, input, roles) {
     const result = dispatchEnforceInner(event, ir, input, roles);
     return result?.output ?? { continue: true, suppressOutput: true };

package/dist/runtime/markdown-target-registry.d.ts

@@ -0,0 +1,17 @@
+export declare const MARKDOWN_TARGET_IDS: readonly ["claude-md", "soul-md", "cursorrules", "system-prompt", "agents-md"];
+export type MarkdownTarget = typeof MARKDOWN_TARGET_IDS[number];
+export type MarkdownRenderer<TIR = unknown> = (ir: TIR) => string;
+export interface MarkdownTargetMetadata {
+    id: MarkdownTarget;
+    label: string;
+    supportsSyncInject: boolean;
+}
+export interface MarkdownTargetRuntime<TIR = unknown> extends MarkdownTargetMetadata {
+    render: MarkdownRenderer<TIR>;
+}
+export declare const MARKDOWN_TARGET_REGISTRY: readonly MarkdownTargetMetadata[];
+export declare function getMarkdownTargetMetadata(target: unknown): MarkdownTargetMetadata | undefined;
+export declare function isMarkdownTarget(target: unknown): target is MarkdownTarget;
+export declare function syncInjectMarkdownTargets(): MarkdownTarget[];
+export declare function bindMarkdownTargetRenderers<TIR>(renderers: Record<MarkdownTarget, MarkdownRenderer<TIR>>): readonly MarkdownTargetRuntime<TIR>[];
+export declare function getMarkdownTargetRuntime<TIR>(target: unknown, renderers: Record<MarkdownTarget, MarkdownRenderer<TIR>>): MarkdownTargetRuntime<TIR> | undefined;

package/dist/runtime/markdown-target-registry.js

@@ -0,0 +1,37 @@
+export const MARKDOWN_TARGET_IDS = [
+    "claude-md",
+    "soul-md",
+    "cursorrules",
+    "system-prompt",
+    "agents-md",
+];
+export const MARKDOWN_TARGET_REGISTRY = [
+    { id: "claude-md", label: "CLAUDE.md", supportsSyncInject: true },
+    { id: "soul-md", label: "SOUL.md", supportsSyncInject: true },
+    { id: "cursorrules", label: ".cursorrules", supportsSyncInject: true },
+    { id: "system-prompt", label: "System prompt", supportsSyncInject: true },
+    { id: "agents-md", label: "AGENTS.md", supportsSyncInject: false },
+];
+const TARGET_BY_ID = new Map(MARKDOWN_TARGET_REGISTRY.map((entry) => [entry.id, entry]));
+export function getMarkdownTargetMetadata(target) {
+    return typeof target === "string" ? TARGET_BY_ID.get(target) : undefined;
+}
+export function isMarkdownTarget(target) {
+    return getMarkdownTargetMetadata(target) !== undefined;
+}
+export function syncInjectMarkdownTargets() {
+    return MARKDOWN_TARGET_REGISTRY
+        .filter((entry) => entry.supportsSyncInject)
+        .map((entry) => entry.id);
+}
+export function bindMarkdownTargetRenderers(renderers) {
+    return MARKDOWN_TARGET_REGISTRY.map((entry) => ({
+        ...entry,
+        render: renderers[entry.id],
+    }));
+}
+export function getMarkdownTargetRuntime(target, renderers) {
+    if (typeof target !== "string")
+        return undefined;
+    return bindMarkdownTargetRenderers(renderers).find((entry) => entry.id === target);
+}

package/dist/runtime/markdown.d.ts

@@ -13,7 +13,8 @@
  *   <!-- intentdna:end -->
  */
 import type { ConstraintIR } from "../schema/types.js";
-export type MarkdownTarget = "claude-md" | "soul-md" | "cursorrules" | "system-prompt" | "agents-md";
+import { type MarkdownTarget } from "./markdown-target-registry.js";
+export type { MarkdownTarget } from "./markdown-target-registry.js";
 /**
  * Compile Constraint IR to a markdown block suitable for the target format.
  */

package/dist/runtime/markdown.js

@@ -13,24 +13,21 @@
  *   <!-- intentdna:end -->
  */
 import { readFile, writeFile } from "node:fs/promises";
+import { getMarkdownTargetRuntime } from "./markdown-target-registry.js";
 const SENTINEL_START = "<!-- intentdna:start -->";
 const SENTINEL_END = "<!-- intentdna:end -->";
+const MARKDOWN_RENDERERS = {
+    "claude-md": renderClaudeMd,
+    "soul-md": renderSoulMd,
+    cursorrules: renderCursorrules,
+    "system-prompt": renderSystemPrompt,
+    "agents-md": renderAgentsMd,
+};
 /**
  * Compile Constraint IR to a markdown block suitable for the target format.
  */
 export function compileToMarkdown(ir, target) {
-    switch (target) {
-        case "claude-md":
-            return renderClaudeMd(ir);
-        case "soul-md":
-            return renderSoulMd(ir);
-        case "cursorrules":
-            return renderCursorrules(ir);
-        case "system-prompt":
-            return renderSystemPrompt(ir);
-        case "agents-md":
-            return renderAgentsMd(ir);
-    }
+    return getMarkdownTargetRuntime(target, MARKDOWN_RENDERERS).render(ir);
 }
 /**
  * Wrap content in sentinel comments for idempotent injection.

package/dist/runtime/output-artifact-registry.d.ts

@@ -0,0 +1,11 @@
+export declare const SYNC_OUTPUT_ARTIFACT_IDS: readonly ["markdown-injection", "compiled-ir", "settings-hooks", "agents", "workflows", "skills-controllers", "mcp-config", "lock-file"];
+export type SyncOutputArtifactId = typeof SYNC_OUTPUT_ARTIFACT_IDS[number];
+export interface SyncOutputArtifactMetadata {
+    id: SyncOutputArtifactId;
+    order: number;
+    label: string;
+    trackedByLock: boolean;
+}
+export declare const SYNC_OUTPUT_ARTIFACT_REGISTRY: readonly SyncOutputArtifactMetadata[];
+export declare function getSyncOutputArtifactMetadata(id: unknown): SyncOutputArtifactMetadata | undefined;
+export declare function syncOutputArtifactIds(): SyncOutputArtifactId[];

package/dist/runtime/output-artifact-registry.js

@@ -0,0 +1,30 @@
+export const SYNC_OUTPUT_ARTIFACT_IDS = [
+    "markdown-injection",
+    "compiled-ir",
+    "settings-hooks",
+    "agents",
+    "workflows",
+    "skills-controllers",
+    "mcp-config",
+    "lock-file",
+];
+export const SYNC_OUTPUT_ARTIFACT_REGISTRY = [
+    { id: "markdown-injection", order: 30, label: "Markdown injection", trackedByLock: true },
+    { id: "compiled-ir", order: 35, label: "Compiled IR", trackedByLock: true },
+    { id: "settings-hooks", order: 36, label: "Settings hooks", trackedByLock: true },
+    { id: "agents", order: 50, label: "Agents", trackedByLock: true },
+    { id: "workflows", order: 60, label: "Workflows", trackedByLock: true },
+    { id: "skills-controllers", order: 70, label: "Skills and controllers", trackedByLock: true },
+    { id: "mcp-config", order: 80, label: "MCP config", trackedByLock: false },
+    { id: "lock-file", order: 90, label: "Lock file", trackedByLock: false },
+];
+const ARTIFACT_BY_ID = new Map(SYNC_OUTPUT_ARTIFACT_REGISTRY.map((entry) => [entry.id, entry]));
+export function getSyncOutputArtifactMetadata(id) {
+    return typeof id === "string" ? ARTIFACT_BY_ID.get(id) : undefined;
+}
+export function syncOutputArtifactIds() {
+    return SYNC_OUTPUT_ARTIFACT_REGISTRY
+        .slice()
+        .sort((a, b) => a.order - b.order)
+        .map((entry) => entry.id);
+}

package/dist/runtime/settings-adapter.d.ts

@@ -6,7 +6,8 @@
  *
  * See docs/references/cc-source-analysis.md §2 for the full hook event catalog.
  */
-export type HookEventKey = "preToolUse" | "postToolUse" | "userPromptSubmit" | "subagentStop" | "preCompact" | "notification" | "stop";
+import { type SettingsHookEventKey } from "../hooks/event-registry.js";
+export type HookEventKey = SettingsHookEventKey;
 export interface SettingsHookEntry {
     matcher: string;
     hooks: Array<{

package/dist/runtime/settings-adapter.js

@@ -7,17 +7,8 @@
  * See docs/references/cc-source-analysis.md §2 for the full hook event catalog.
  */
 import { readFile, writeFile } from "node:fs/promises";
+import { getHookEventBySettingsKey, settingsHookEventKeys } from "../hooks/event-registry.js";
 // ── Plugin Mode (Node.js hooks via dna-hook binary) ───────
-/** Hook event key → Claude Code settings event name */
-const HOOK_EVENT_MAP = {
-    preToolUse: "PreToolUse",
-    postToolUse: "PostToolUse",
-    userPromptSubmit: "UserPromptSubmit",
-    subagentStop: "SubagentStop",
-    preCompact: "PreCompact",
-    notification: "Notification",
-    stop: "Stop",
-};
 /**
  * Compile settings.json hook configuration for dna-hook binary.
  * Uses `dna-hook <event>` commands.
@@ -25,7 +16,7 @@ const HOOK_EVENT_MAP = {
 export function compilePluginSettings(enabledEvents, timeout = 10, timeouts) {
     const settings = { hooks: {} };
     for (const key of enabledEvents) {
-        const eventName = HOOK_EVENT_MAP[key];
+        const eventName = getHookEventBySettingsKey(key)?.event;
         if (!eventName)
             continue;
         const eventTimeout = timeouts?.[key] ?? timeout;
@@ -120,7 +111,8 @@ export async function mergeSettingsFile(dnaSettings, settingsPath) {
         mergedHooks[eventName] = [...nonDNA, ...entries];
     }
     // Remove DNA hook events that are no longer generated
-    for (const eventName of Object.values(HOOK_EVENT_MAP)) {
+    for (const key of settingsHookEventKeys()) {
+        const eventName = getHookEventBySettingsKey(key).event;
         if (!dnaSettings.hooks[eventName] && mergedHooks[eventName]) {
             const entries = mergedHooks[eventName];
             const nonDNA = entries.filter((h) => {