intentdna 1.8.4 → 1.8.6

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.8.4",
+      "version": "1.8.6",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.8.4"
+  "version": "1.8.6"
 }

package/.claude-plugin/plugin.json

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

package/README.md

@@ -17,11 +17,11 @@ IntentDNA is not a model company, generic agent framework, prompt library, canva
 ## Install or update
 
 ```bash
-npm install --global intentdna@1.8.4
+npm install --global intentdna@1.8.5
 dna --version
 ```
 
-Version `1.8.4` makes delegated workflow completion gates enforceable at the real Claude handoff boundary, returns bounded validator diagnostics to retries, and links C5-backed suggestions to concrete capture event IDs. Online generates copyable local commands only; you still run and review them in your own project.
+Version `1.8.5` keeps Claude plugin Hook delivery in `hooks/hooks.json`: plugin sync does not register project `settings.json` Hooks, retracts exact stale bin-mode `dna-hook` entries once, and leaves user settings untouched in steady state. Online generates copyable local commands only; you still run and review them in your own project.
 
 ## Product Shape
 

package/dist/cli/commands/sync.js

@@ -612,6 +612,13 @@ export async function runSync(opts) {
         opts.skillsDir = resolve(projectDir, ".agents", "skills");
         process.stderr.write("Codex workflow projection: .agents/skills\n");
     }
+    const requestedMode = opts.mode ?? (opts.plugin === true ? "plugin" : opts.plugin === false ? "bin" : "auto");
+    let resolvedMode = requestedMode === "auto" ? "bin" : requestedMode;
+    if (!opts.remove && requestedMode === "auto") {
+        resolvedMode = await detectMode();
+        process.stderr.write(`Auto-detect: ${resolvedMode} mode${resolvedMode === "plugin" ? " (intentdna registered as Claude Code plugin)" : ""}\n`);
+    }
+    opts.plugin = resolvedMode === "plugin";
     if (!opts.remove && !opts.inject && !opts.hooksDir && !opts.agentsDir && !opts.workflowDir && !opts.skillsDir && !opts.settingsPath && !opts.codex) {
         // Auto-detect Claude Code environment → fill all outputs
         const hasClaudeDir = await fileExists(resolve(projectDir, ".claude"));
@@ -621,16 +628,11 @@ export async function runSync(opts) {
             opts.agentsDir = resolve(projectDir, ".claude", "agents");
             opts.skillsDir = resolve(projectDir, ".claude", "skills");
             opts.settingsPath = resolve(projectDir, ".claude", "settings.json");
-            process.stderr.write(`Auto-detect: Claude Code → CLAUDE.md + agents + skills + settings\n`);
+            process.stderr.write(resolvedMode === "plugin"
+                ? "Auto-detect: Claude Code → CLAUDE.md + agents + skills; plugin hooks (no settings injection)\n"
+                : "Auto-detect: Claude Code → CLAUDE.md + agents + skills + settings\n");
         }
     }
-    const requestedMode = opts.mode ?? (opts.plugin === true ? "plugin" : opts.plugin === false ? "bin" : "auto");
-    let resolvedMode = requestedMode === "auto" ? "bin" : requestedMode;
-    if (!opts.remove && requestedMode === "auto") {
-        resolvedMode = await detectMode();
-        process.stderr.write(`Auto-detect: ${resolvedMode} mode${resolvedMode === "plugin" ? " (intentdna registered as Claude Code plugin)" : ""}\n`);
-    }
-    opts.plugin = resolvedMode === "plugin";
     // Handle --remove
     if (opts.remove) {
         if (!opts.inject && !opts.hooksDir && !opts.agentsDir && !opts.workflowDir && !opts.skillsDir && !opts.codex) {
@@ -919,7 +921,7 @@ export async function runSync(opts) {
             }
             const configPath = opts.files.length === 1 ? opts.files[0] : null;
             const variables = await resolveVariables(rawVars, configPath, { dryRun: opts.dryRun });
-            // Step 8: Generate .claude/.mcp.json only for Claude Code skills.
+            // Step 8: Generate project-root .mcp.json only for Claude Code skills.
             if (skillSurface === "claude_code") {
                 const mcpDeps = {};
                 for (const d of dnas) {
@@ -927,7 +929,7 @@ export async function runSync(opts) {
                         Object.assign(mcpDeps, d.mcp);
                 }
                 if (Object.keys(mcpDeps).length > 0) {
-                    const mcpJsonPath = resolve(projectDir, ".claude", ".mcp.json");
+                    const mcpJsonPath = resolve(projectDir, ".mcp.json");
                     if (opts.dryRun) {
                         process.stderr.write(`Dry-run: would write ${Object.keys(mcpDeps).length} MCP server(s) to ${mcpJsonPath}\n`);
                     }
@@ -1061,7 +1063,7 @@ export async function runSync(opts) {
     }
 }
 /**
- * Write MCP server configuration to .claude/.mcp.json.
+ * Write MCP server configuration to the Claude project-root .mcp.json.
  * Merges with existing config — DNA-declared servers are added/updated,
  * but existing user-configured servers are NOT overwritten.
  */
@@ -1072,7 +1074,12 @@ async function writeMCPConfig(mcpDeps, mcpJsonPath, variables) {
         const raw = await readFile(mcpJsonPath, "utf-8");
         existing = JSON.parse(raw);
     }
-    catch { /* doesn't exist yet */ }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+        if (code !== "ENOENT") {
+            throw new Error(`Cannot read Claude MCP config: ${mcpJsonPath}`);
+        }
+    }
     const mcpServers = (existing.mcpServers ?? {});
     for (const [name, server] of Object.entries(mcpDeps)) {
         // Don't overwrite existing user-configured servers

package/dist/cli/commands/verify.js

@@ -524,7 +524,7 @@ export async function runHealth() {
     }
     catch {
         // Check for plugin registration instead
-        const mcpPath = resolve(cwd, ".claude", ".mcp.json");
+        const mcpPath = resolve(cwd, ".mcp.json");
         try {
             const raw = await rf(mcpPath, "utf-8");
             const mcp = JSON.parse(raw);

package/dist/runtime/claude-sync-target.d.ts

@@ -1,7 +1,7 @@
 import type { ConstraintIR, RoleDef } from "../schema/types.js";
 import type { SyncOutputArtifactId } from "./output-artifact-registry.js";
 import { type CompiledIRFile } from "./plugin-adapter.js";
-import { type DNASettings, type HookEventKey } from "./settings-adapter.js";
+import { type DNASettings, type HookEventKey, type IntentDNASettingsHookCleanupResult } from "./settings-adapter.js";
 import type { AdapterCapabilityReport, CapabilityReportEntry, PlannedArtifact, SyncTargetPlan } from "./sync-target-plan.js";
 export type ClaudeSyncMode = "plugin" | "bin";
 export interface ClaudeCorePlannedArtifact extends PlannedArtifact {
@@ -31,6 +31,7 @@ export interface ClaudeCoreSyncTargetPlan extends SyncTargetPlan {
     legacyHooksDir: string;
     mcpConfigPath: string;
     settingsHookRegistration?: ClaudeSettingsHookRegistration;
+    pluginSettingsPath?: string;
     pluginSkipsSettings: boolean;
     plannedArtifacts: ClaudeCorePlannedArtifact[];
     capabilityReport: ClaudeCoreAdapterCapabilityReport;
@@ -38,6 +39,7 @@ export interface ClaudeCoreSyncTargetPlan extends SyncTargetPlan {
 export interface ExecuteClaudeCoreSyncTargetPlanResult {
     messages: string[];
     removedLegacyHooks: string[];
+    settingsHookCleanup?: IntentDNASettingsHookCleanupResult;
 }
 /**
  * Remove legacy bash hook scripts written by previous Intent DNA versions.

package/dist/runtime/claude-sync-target.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { createCompiledIR, writeCompiledIR } from "./plugin-adapter.js";
-import { compilePluginSettings, detectEnabledEvents, mergeSettingsFile, recommendHookTimeouts } from "./settings-adapter.js";
+import { compilePluginSettings, detectEnabledEvents, mergeSettingsFile, recommendHookTimeouts, removeIntentDNASettingsHooks, } from "./settings-adapter.js";
 import { formatSyncTargetPlanDiagnostics } from "./sync-target-plan.js";
 const LEGACY_BASH_HOOKS = [
     "dna-pre-tool-use.sh",
@@ -46,7 +46,7 @@ export function createClaudeCoreSyncTargetPlan(options) {
     const compiledIR = createCompiledIR(options.ir, options.roles);
     const compiledIRPath = resolve(options.projectDir, ".dna", "compiled", "ir.json");
     const legacyHooksDir = resolve(options.projectDir, ".claude", "hooks");
-    const mcpConfigPath = resolve(options.projectDir, ".claude", ".mcp.json");
+    const mcpConfigPath = resolve(options.projectDir, ".mcp.json");
     const settingsHookRegistration = createSettingsHookRegistration(options.ir, options.mode, options.settingsPath);
     const plannedArtifacts = [
         {
@@ -83,6 +83,7 @@ export function createClaudeCoreSyncTargetPlan(options) {
         legacyHooksDir,
         mcpConfigPath,
         settingsHookRegistration,
+        pluginSettingsPath: options.mode === "plugin" ? options.settingsPath : undefined,
         pluginSkipsSettings: options.mode === "plugin" && !!options.settingsPath,
         plannedArtifacts,
         capabilityReport: createClaudeCapabilityReport(plannedArtifacts, options.mode, settingsHookRegistration),
@@ -217,13 +218,18 @@ function createClaudeEvidencePlan(plannedArtifacts) {
     };
 }
 async function registerDNAMCPServer(projectDir) {
-    const mcpJsonPath = resolve(projectDir, ".claude", ".mcp.json");
+    const mcpJsonPath = resolve(projectDir, ".mcp.json");
     let existing = {};
     try {
         const raw = await readFile(mcpJsonPath, "utf-8");
         existing = JSON.parse(raw);
     }
-    catch { /* doesn't exist yet */ }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+        if (code !== "ENOENT") {
+            throw new Error(`Cannot read Claude MCP config: ${mcpJsonPath}`);
+        }
+    }
     const mcpServers = (existing.mcpServers ?? {});
     if (mcpServers["intentdna"])
         return { path: mcpJsonPath, registered: false };
@@ -238,6 +244,7 @@ async function registerDNAMCPServer(projectDir) {
 }
 export async function executeClaudeCoreSyncTargetPlan(plan, projectDir) {
     const messages = [];
+    let settingsHookCleanup;
     const writtenIrPath = await writeCompiledIR(projectDir, plan.compiledIR);
     messages.push(`Wrote compiled IR: ${writtenIrPath}`);
     const removedLegacyHooks = await removeLegacyBashHooks(plan.legacyHooksDir);
@@ -253,9 +260,19 @@ export async function executeClaudeCoreSyncTargetPlan(plan, projectDir) {
         messages.push(`Bin mode: registered ${plan.settingsHookRegistration.enabledEvents.length} hook event(s) in ${plan.settingsHookRegistration.path}`);
     }
     else if (plan.pluginSkipsSettings) {
-        messages.push("Plugin mode: hooks managed by plugin framework (skipping settings.json)");
+        settingsHookCleanup = await removeIntentDNASettingsHooks(plan.pluginSettingsPath);
+        if (settingsHookCleanup.removedCommands > 0) {
+            const action = settingsHookCleanup.removedFile ? "removed" : "cleaned";
+            messages.push(`Plugin mode: ${action} ${settingsHookCleanup.removedCommands} stale bin-mode dna-hook command(s) from ${plan.pluginSettingsPath}; hooks are managed by plugin framework`);
+        }
+        else {
+            messages.push("Plugin mode: hooks managed by plugin framework (settings.json not written)");
+        }
+        if (settingsHookCleanup.warning) {
+            messages.push(`Plugin mode: preserved settings.json without cleanup (${settingsHookCleanup.warning})`);
+        }
     }
-    return { messages, removedLegacyHooks };
+    return { messages, removedLegacyHooks, settingsHookCleanup };
 }
 export function formatClaudeCoreSyncTargetPlanDryRun(plan) {
     const lines = [
@@ -267,7 +284,7 @@ export function formatClaudeCoreSyncTargetPlanDryRun(plan) {
         lines.push(`Dry-run: would register ${plan.settingsHookRegistration.enabledEvents.length} hook event(s) in ${plan.settingsHookRegistration.path}`);
     }
     else if (plan.pluginSkipsSettings) {
-        lines.push("Plugin mode: hooks managed by plugin framework (skipping settings.json)");
+        lines.push("Plugin mode: hooks managed by plugin framework; would remove stale bin-mode dna-hook commands if present and would not register settings hooks");
     }
     const capabilityEntries = Object.entries(plan.capabilityReport.capabilities)
         .sort(([left], [right]) => left.localeCompare(right));

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

@@ -18,6 +18,13 @@ export interface SettingsHookEntry {
 export interface DNASettings {
     hooks: Record<string, SettingsHookEntry[]>;
 }
+export interface IntentDNASettingsHookCleanupResult {
+    changed: boolean;
+    removedCommands: number;
+    removedEvents: string[];
+    removedFile: boolean;
+    warning?: string;
+}
 /**
  * Compile settings.json hook configuration for dna-hook binary.
  * Uses `dna-hook <event>` commands.
@@ -34,3 +41,8 @@ export declare function detectEnabledEvents(ir: import("../schema/types.js").Con
  * Replaces DNA hooks (identified by "dna-" prefix), keeps user hooks.
  */
 export declare function mergeSettingsFile(dnaSettings: DNASettings, settingsPath: string): Promise<void>;
+/**
+ * Remove bin-mode IntentDNA hook commands when Claude plugin hooks own dispatch.
+ * Invalid or user-owned settings are preserved without rewriting the file.
+ */
+export declare function removeIntentDNASettingsHooks(settingsPath: string): Promise<IntentDNASettingsHookCleanupResult>;

package/dist/runtime/settings-adapter.js

@@ -6,9 +6,9 @@
  *
  * See docs/archive/2026H1/references/cc-source-analysis.md §2 for the full hook event catalog.
  */
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, unlink, writeFile } from "node:fs/promises";
 import { getHookEventBySettingsKey, settingsHookEventKeys } from "../hooks/event-registry.js";
-// ── Plugin Mode (Node.js hooks via dna-hook binary) ───────
+// ── Bin Mode (project settings via dna-hook binary) ───────
 /**
  * Compile settings.json hook configuration for dna-hook binary.
  * Uses `dna-hook <event>` commands.
@@ -131,3 +131,120 @@ export async function mergeSettingsFile(dnaSettings, settingsPath) {
     existing.hooks = mergedHooks;
     await writeFile(settingsPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
 }
+const INTENTDNA_SETTINGS_HOOK_COMMANDS = new Set(settingsHookEventKeys().map((key) => `dna-hook ${getHookEventBySettingsKey(key).event}`));
+function isIntentDNASettingsHookCommand(value, eventName) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const hook = value;
+    const expectedCommand = `dna-hook ${eventName}`;
+    return hook.type === "command"
+        && typeof hook.command === "string"
+        && hook.command === expectedCommand
+        && INTENTDNA_SETTINGS_HOOK_COMMANDS.has(expectedCommand);
+}
+function isGeneratedIntentDNASettingsHookEntry(entry) {
+    return entry.matcher === ""
+        && Object.keys(entry).every((key) => key === "matcher" || key === "hooks");
+}
+/**
+ * Remove bin-mode IntentDNA hook commands when Claude plugin hooks own dispatch.
+ * Invalid or user-owned settings are preserved without rewriting the file.
+ */
+export async function removeIntentDNASettingsHooks(settingsPath) {
+    const unchanged = (warning) => ({
+        changed: false,
+        removedCommands: 0,
+        removedEvents: [],
+        removedFile: false,
+        ...(warning ? { warning } : {}),
+    });
+    let raw;
+    try {
+        raw = await readFile(settingsPath, "utf-8");
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+        return code === "ENOENT" ? unchanged() : unchanged("could not read settings.json");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return unchanged("settings.json is not valid JSON");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return unchanged("settings.json root is not an object");
+    }
+    const settings = parsed;
+    const rawHooks = settings.hooks;
+    if (!rawHooks || typeof rawHooks !== "object" || Array.isArray(rawHooks)) {
+        return unchanged();
+    }
+    const cleanedHooks = {};
+    const removedEvents = [];
+    let removedCommands = 0;
+    for (const [eventName, rawEntries] of Object.entries(rawHooks)) {
+        if (!Array.isArray(rawEntries)) {
+            cleanedHooks[eventName] = rawEntries;
+            continue;
+        }
+        let eventRemoved = false;
+        const cleanedEntries = [];
+        for (const rawEntry of rawEntries) {
+            if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+                cleanedEntries.push(rawEntry);
+                continue;
+            }
+            const entry = rawEntry;
+            if (!Array.isArray(entry.hooks)) {
+                cleanedEntries.push(rawEntry);
+                continue;
+            }
+            let entryRemovedCommands = 0;
+            const retainedCommands = entry.hooks.filter((hook) => {
+                const owned = isIntentDNASettingsHookCommand(hook, eventName);
+                if (owned) {
+                    removedCommands += 1;
+                    entryRemovedCommands += 1;
+                    eventRemoved = true;
+                }
+                return !owned;
+            });
+            if (entryRemovedCommands === 0) {
+                cleanedEntries.push(rawEntry);
+            }
+            else if (retainedCommands.length > 0 || !isGeneratedIntentDNASettingsHookEntry(entry)) {
+                cleanedEntries.push({ ...entry, hooks: retainedCommands });
+            }
+        }
+        if (eventRemoved)
+            removedEvents.push(eventName);
+        if (!eventRemoved || cleanedEntries.length > 0)
+            cleanedHooks[eventName] = cleanedEntries;
+    }
+    if (removedCommands === 0)
+        return unchanged();
+    if (Object.keys(cleanedHooks).length > 0) {
+        settings.hooks = cleanedHooks;
+    }
+    else {
+        delete settings.hooks;
+    }
+    if (Object.keys(settings).length === 0) {
+        await unlink(settingsPath);
+        return {
+            changed: true,
+            removedCommands,
+            removedEvents,
+            removedFile: true,
+        };
+    }
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    return {
+        changed: true,
+        removedCommands,
+        removedEvents,
+        removedFile: false,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",