oh-my-harness 0.7.0 → 0.8.0

package/dist/catalog/blocks/compact-context.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const compactContext: BuildingBlock;

package/dist/catalog/blocks/compact-context.js

@@ -0,0 +1,27 @@
+export const compactContext = {
+    id: "compact-context",
+    name: "Compact Context",
+    description: "Re-injects project context after context compaction",
+    category: "automation",
+    event: "SessionStart",
+    matcher: "compact",
+    canBlock: false,
+    params: [
+        {
+            name: "contextFile",
+            type: "string",
+            description: "Path to the context file to re-inject",
+            default: "CLAUDE.md",
+            required: false,
+        },
+    ],
+    tags: ["context", "compaction", "session", "automation"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+CONTEXT_FILE="{{{contextFile}}}"
+if [[ -f "$CONTEXT_FILE" ]]; then
+  cat "$CONTEXT_FILE"
+fi
+exit 0`,
+};

package/dist/catalog/blocks/config-audit.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const configAudit: BuildingBlock;

package/dist/catalog/blocks/config-audit.js

@@ -0,0 +1,29 @@
+export const configAudit = {
+    id: "config-audit",
+    name: "Config Audit",
+    description: "Logs configuration changes for audit trail",
+    category: "audit",
+    event: "ConfigChange",
+    matcher: "",
+    canBlock: false,
+    params: [
+        {
+            name: "logFile",
+            type: "string",
+            description: "Path to the audit log file",
+            default: ".claude/hooks/.state/config-audit.log",
+            required: false,
+        },
+    ],
+    tags: ["audit", "config", "logging"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+LOG_FILE="{{{logFile}}}"
+mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null || true
+SOURCE=$(echo "$INPUT" | jq -r '.source // "unknown"' 2>/dev/null)
+FILE=$(echo "$INPUT" | jq -r '.file_path // "unknown"' 2>/dev/null)
+TS=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+echo "{\\"ts\\":\\"$TS\\",\\"source\\":\\"$SOURCE\\",\\"file\\":\\"$FILE\\"}" >> "$LOG_FILE"
+exit 0`,
+};

package/dist/catalog/blocks/desktop-notify.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const desktopNotify: BuildingBlock;

package/dist/catalog/blocks/desktop-notify.js

@@ -0,0 +1,21 @@
+export const desktopNotify = {
+    id: "desktop-notify",
+    name: "Desktop Notify",
+    description: "Sends desktop notification when Claude needs attention",
+    category: "notification",
+    event: "Notification",
+    matcher: "",
+    canBlock: false,
+    params: [],
+    tags: ["notification", "desktop", "alert"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+MESSAGE=$(echo "$INPUT" | jq -r '.message // "Claude Code needs your attention"' 2>/dev/null)
+if [[ "$(uname)" == "Darwin" ]]; then
+  osascript -e "display notification \\"$MESSAGE\\" with title \\"Claude Code\\"" 2>/dev/null || true
+elif command -v notify-send &>/dev/null; then
+  notify-send "Claude Code" "$MESSAGE" 2>/dev/null || true
+fi
+exit 0`,
+};

package/dist/catalog/blocks/index.js

@@ -9,6 +9,12 @@ import { formatOnSave } from "./format-on-save.js";
 import { autoPr } from "./auto-pr.js";
 import { secretFileGuard } from "./secret-file-guard.js";
 import { tddGuard } from "./tdd-guard.js";
+import { sqlGuard } from "./sql-guard.js";
+import { testOnSave } from "./test-on-save.js";
+import { desktopNotify } from "./desktop-notify.js";
+import { configAudit } from "./config-audit.js";
+import { compactContext } from "./compact-context.js";
+import { worktreeSetup } from "./worktree-setup.js";
 export const builtinBlocks = [
     branchGuard,
     commitTestGate,
@@ -21,4 +27,10 @@ export const builtinBlocks = [
     autoPr,
     secretFileGuard,
     tddGuard,
+    sqlGuard,
+    testOnSave,
+    desktopNotify,
+    configAudit,
+    compactContext,
+    worktreeSetup,
 ];

package/dist/catalog/blocks/sql-guard.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const sqlGuard: BuildingBlock;

package/dist/catalog/blocks/sql-guard.js

@@ -0,0 +1,34 @@
+export const sqlGuard = {
+    id: "sql-guard",
+    name: "SQL Guard",
+    description: "Blocks dangerous SQL commands in shell",
+    category: "security",
+    event: "PreToolUse",
+    matcher: "Bash",
+    canBlock: true,
+    params: [
+        {
+            name: "patterns",
+            type: "string[]",
+            description: "Dangerous SQL patterns to block",
+            default: ["DROP TABLE", "DROP DATABASE", "TRUNCATE TABLE", "DELETE FROM", "DROP COLUMN", "DROP INDEX"],
+            required: true,
+        },
+    ],
+    tags: ["security", "sql", "guard", "database"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+[[ -z "$COMMAND" ]] && exit 0
+COMMAND_LOWER=$(echo "$COMMAND" | tr '[:upper:]' '[:lower:]')
+PATTERNS=({{#each patterns}}"{{{this}}}" {{/each}})
+for PATTERN in "\${PATTERNS[@]}"; do
+  PATTERN_LOWER=$(echo "$PATTERN" | tr '[:upper:]' '[:lower:]')
+  if echo "$COMMAND_LOWER" | grep -qF -- "$PATTERN_LOWER"; then
+    echo "{\\"decision\\": \\"block\\", \\"reason\\": \\"oh-my-harness: SQL command matches blocked pattern: $PATTERN\\"}"
+    exit 0
+  fi
+done
+exit 0`,
+};

package/dist/catalog/blocks/test-on-save.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const testOnSave: BuildingBlock;

package/dist/catalog/blocks/test-on-save.js

@@ -0,0 +1,37 @@
+export const testOnSave = {
+    id: "test-on-save",
+    name: "Test on Save",
+    description: "Runs related tests after source file edits",
+    category: "quality",
+    event: "PostToolUse",
+    matcher: "Edit|Write",
+    canBlock: false,
+    params: [
+        {
+            name: "testCommand",
+            type: "string",
+            description: "Command to run tests (e.g. npx vitest run)",
+            required: true,
+        },
+        {
+            name: "filePattern",
+            type: "string",
+            description: "Regex pattern to match source files",
+            default: "\\.(ts|tsx|js|jsx|py)$",
+            required: false,
+        },
+    ],
+    tags: ["quality", "testing", "auto-run", "save"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.path // empty' 2>/dev/null)
+[[ -z "$FILE_PATH" ]] && exit 0
+FILE_RE='{{{filePattern}}}'
+FILE_RE="\${FILE_RE//\\\\\\\\/\\\\}"
+if [[ "$FILE_PATH" =~ $FILE_RE ]]; then
+  echo "oh-my-harness: Running tests after edit..." >&2
+  {{{testCommand}}} >&2 2>&1 || true
+fi
+exit 0`,
+};

package/dist/catalog/blocks/worktree-setup.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const worktreeSetup: BuildingBlock;

package/dist/catalog/blocks/worktree-setup.js

@@ -0,0 +1,91 @@
+export const worktreeSetup = {
+    id: "worktree-setup",
+    name: "Worktree Setup",
+    description: "Initializes new git worktrees with symlinked dependencies and copied config files",
+    category: "automation",
+    event: "WorktreeCreate",
+    matcher: "",
+    canBlock: false,
+    params: [
+        {
+            name: "symlinkPaths",
+            type: "string[]",
+            description: "Paths to symlink from main worktree (heavy dependencies)",
+            required: false,
+            default: ["node_modules", ".venv", "vendor", "target", ".build"],
+        },
+        {
+            name: "copyPaths",
+            type: "string[]",
+            description: "Paths to hard-copy from main worktree (config files)",
+            required: false,
+            default: [".env", ".env.local"],
+        },
+        {
+            name: "installCommand",
+            type: "string",
+            description: "Package install command to run if symlink source missing",
+            required: false,
+            default: "",
+        },
+    ],
+    tags: ["worktree", "git", "dependencies", "symlink", "automation"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+
+# Parse worktree info from stdin
+WORKTREE_PATH=$(echo "$INPUT" | jq -r '.worktree_path // empty' 2>/dev/null)
+if [[ -z "$WORKTREE_PATH" ]]; then
+  echo "oh-my-harness: worktree-setup — no worktree_path in input" >&2
+  exit 0
+fi
+
+# Find the main worktree (parent repo)
+MAIN_WORKTREE=$(git -C "$WORKTREE_PATH" worktree list --porcelain 2>/dev/null | head -1 | sed 's/^worktree //')
+if [[ -z "$MAIN_WORKTREE" ]]; then
+  echo "oh-my-harness: worktree-setup — cannot determine main worktree" >&2
+  exit 0
+fi
+
+echo "oh-my-harness: worktree-setup — setting up $WORKTREE_PATH"
+
+# Symlink heavy directories from main worktree
+SYMLINKS=({{#each symlinkPaths}}"{{{this}}}" {{/each}})
+for rel in "\${SYMLINKS[@]}"; do
+  [[ -z "$rel" ]] && continue
+  src="$MAIN_WORKTREE/$rel"
+  dst="$WORKTREE_PATH/$rel"
+  if [[ -e "$src" && ! -e "$dst" ]]; then
+    mkdir -p "$(dirname "$dst")"
+    ln -s "$src" "$dst"
+    echo "  symlinked: $rel"
+  fi
+done
+
+# Hard-copy config files from main worktree
+COPIES=({{#each copyPaths}}"{{{this}}}" {{/each}})
+for rel in "\${COPIES[@]}"; do
+  [[ -z "$rel" ]] && continue
+  src="$MAIN_WORKTREE/$rel"
+  dst="$WORKTREE_PATH/$rel"
+  if [[ -f "$src" && ! -f "$dst" ]]; then
+    mkdir -p "$(dirname "$dst")"
+    cp "$src" "$dst"
+    echo "  copied: $rel"
+  fi
+done
+
+# Run install command if provided and no symlinked deps exist
+INSTALL_CMD="{{{installCommand}}}"
+if [[ -n "$INSTALL_CMD" ]]; then
+  first_symlink="\${SYMLINKS[0]}"
+  if [[ -n "$first_symlink" && ! -e "$WORKTREE_PATH/$first_symlink" ]]; then
+    echo "  running: $INSTALL_CMD"
+    cd "$WORKTREE_PATH" && eval "$INSTALL_CMD"
+  fi
+fi
+
+echo "oh-my-harness: worktree-setup complete"
+exit 0`,
+};

package/dist/catalog/converter.js

@@ -4,7 +4,7 @@ export async function convertHookEntries(entries, registry, projectDir) {
     const hooksConfig = {};
     const scripts = new Map();
     const errors = [];
-    const seenBlockIds = new Set();
+    const blockInstanceCount = new Map();
     for (const entry of entries) {
         const block = registry.get(entry.block);
         if (!block) {
@@ -17,11 +17,6 @@ export async function convertHookEntries(entries, registry, projectDir) {
             errors.push(...paramErrors);
             continue;
         }
-        if (seenBlockIds.has(entry.block)) {
-            errors.push(`Duplicate block id skipped: "${entry.block}"`);
-            continue;
-        }
-        seenBlockIds.add(entry.block);
         let scriptContent;
         try {
             scriptContent = renderTemplate(block.template, resolvedParams);
@@ -30,7 +25,10 @@ export async function convertHookEntries(entries, registry, projectDir) {
             errors.push(`Failed to render block "${entry.block}": ${err.message}`);
             continue;
         }
-        const scriptName = `${entry.block}.sh`;
+        // Support multiple instances of the same block with different params
+        const count = blockInstanceCount.get(entry.block) ?? 0;
+        blockInstanceCount.set(entry.block, count + 1);
+        const scriptName = count === 0 ? `${entry.block}.sh` : `${entry.block}-${count}.sh`;
         const scriptPath = path.join(projectDir, ".claude", "hooks", scriptName);
         scripts.set(scriptPath, scriptContent);
         const hookEntry = {

package/dist/catalog/types.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-export type HookEvent = "PreToolUse" | "PostToolUse" | "PreCompact" | "PostCompact" | "Notification" | "Stop" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionStart" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "UserPromptSubmit";
-export type BuildingBlockCategory = "git" | "quality" | "security" | "notification" | "formatting" | "custom" | "auto-fix" | "automation" | "file-protection";
+export type HookEvent = "PreToolUse" | "PostToolUse" | "PreCompact" | "PostCompact" | "Notification" | "Stop" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionStart" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "UserPromptSubmit" | "ConfigChange" | "WorktreeCreate" | "WorktreeRemove";
+export type BuildingBlockCategory = "git" | "quality" | "security" | "notification" | "formatting" | "custom" | "auto-fix" | "automation" | "file-protection" | "audit";
 export interface ParamDefinition {
     name: string;
     type: "string" | "boolean" | "number" | "string[]";
@@ -47,8 +47,8 @@ export declare const BuildingBlockSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     description: z.ZodString;
-    category: z.ZodEnum<["git", "quality", "security", "notification", "formatting", "custom", "auto-fix", "automation", "file-protection"]>;
-    event: z.ZodEnum<["PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Notification", "Stop", "SubagentStop", "PreBash", "PostBash", "PreEdit", "PostEdit", "PreRead", "PostRead", "PreWrite", "PostWrite", "SessionStart", "SessionEnd", "PreToolResult", "PostToolResult", "UserPromptSubmit"]>;
+    category: z.ZodEnum<["git", "quality", "security", "notification", "formatting", "custom", "auto-fix", "automation", "file-protection", "audit"]>;
+    event: z.ZodEnum<["PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Notification", "Stop", "SubagentStop", "PreBash", "PostBash", "PreEdit", "PostEdit", "PreRead", "PostRead", "PreWrite", "PostWrite", "SessionStart", "SessionEnd", "PreToolResult", "PostToolResult", "UserPromptSubmit", "ConfigChange", "WorktreeCreate", "WorktreeRemove"]>;
     matcher: z.ZodOptional<z.ZodString>;
     canBlock: z.ZodBoolean;
     params: z.ZodArray<z.ZodObject<{
@@ -85,8 +85,8 @@ export declare const BuildingBlockSchema: z.ZodObject<{
     template: string;
     name: string;
     tags: string[];
-    category: "custom" | "git" | "quality" | "security" | "notification" | "formatting" | "auto-fix" | "automation" | "file-protection";
-    event: "PreToolUse" | "PostToolUse" | "PreCompact" | "PostCompact" | "Notification" | "Stop" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionStart" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "UserPromptSubmit";
+    event: "PreToolUse" | "PostToolUse" | "SessionStart" | "Notification" | "ConfigChange" | "WorktreeCreate" | "PreCompact" | "PostCompact" | "Stop" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "UserPromptSubmit" | "WorktreeRemove";
+    category: "notification" | "custom" | "git" | "quality" | "security" | "formatting" | "auto-fix" | "automation" | "file-protection" | "audit";
     canBlock: boolean;
     matcher?: string | undefined;
 }, {
@@ -102,8 +102,8 @@ export declare const BuildingBlockSchema: z.ZodObject<{
     template: string;
     name: string;
     tags: string[];
-    category: "custom" | "git" | "quality" | "security" | "notification" | "formatting" | "auto-fix" | "automation" | "file-protection";
-    event: "PreToolUse" | "PostToolUse" | "PreCompact" | "PostCompact" | "Notification" | "Stop" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionStart" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "UserPromptSubmit";
+    event: "PreToolUse" | "PostToolUse" | "SessionStart" | "Notification" | "ConfigChange" | "WorktreeCreate" | "PreCompact" | "PostCompact" | "Stop" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "UserPromptSubmit" | "WorktreeRemove";
+    category: "notification" | "custom" | "git" | "quality" | "security" | "formatting" | "auto-fix" | "automation" | "file-protection" | "audit";
     canBlock: boolean;
     matcher?: string | undefined;
 }>;

package/dist/catalog/types.js

@@ -10,8 +10,8 @@ export const BuildingBlockSchema = z.object({
     id: z.string(),
     name: z.string(),
     description: z.string(),
-    category: z.enum(["git", "quality", "security", "notification", "formatting", "custom", "auto-fix", "automation", "file-protection"]),
-    event: z.enum(["PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Notification", "Stop", "SubagentStop", "PreBash", "PostBash", "PreEdit", "PostEdit", "PreRead", "PostRead", "PreWrite", "PostWrite", "SessionStart", "SessionEnd", "PreToolResult", "PostToolResult", "UserPromptSubmit"]),
+    category: z.enum(["git", "quality", "security", "notification", "formatting", "custom", "auto-fix", "automation", "file-protection", "audit"]),
+    event: z.enum(["PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Notification", "Stop", "SubagentStop", "PreBash", "PostBash", "PreEdit", "PostEdit", "PreRead", "PostRead", "PreWrite", "PostWrite", "SessionStart", "SessionEnd", "PreToolResult", "PostToolResult", "UserPromptSubmit", "ConfigChange", "WorktreeCreate", "WorktreeRemove"]),
     matcher: z.string().optional(),
     canBlock: z.boolean(),
     params: z.array(ParamDefinitionSchema),

package/dist/cli/commands/catalog.js

@@ -11,6 +11,7 @@ const CATEGORY_EMOJI = {
     notification: "🔔",
     prompt: "💬",
     permission: "🔐",
+    audit: "📝",
 };
 function categoryLabel(category) {
     const emoji = CATEGORY_EMOJI[category] ?? "•";

package/dist/cli/commands/doctor.d.ts

@@ -3,6 +3,7 @@ export interface DoctorOptions {
 }
 export interface DoctorResult {
     healthy: boolean;
+    exitCode: number;
     checks: {
         stateFile: boolean;
         claudeMd: boolean;

package/dist/cli/commands/doctor.js

@@ -71,6 +71,7 @@ export async function doctorCommand(options = {}) {
         checks.hooksExecutable = true;
     }
     const healthy = Object.values(checks).every(Boolean);
+    const exitCode = healthy ? 0 : 1;
     if (healthy) {
         console.log("oh-my-harness: all checks passed");
     }
@@ -80,5 +81,5 @@ export async function doctorCommand(options = {}) {
             console.log(`  ${msg}`);
         }
     }
-    return { healthy, checks, messages };
+    return { healthy, exitCode, checks, messages };
 }

package/dist/cli/commands/init.js

@@ -59,7 +59,17 @@ export async function initCommand(presetNames, options = {}) {
     const presetsDir = options.presetsDir ?? getDefaultPresetsDir();
     // If --preset flag is used, go through preset flow
     if (options.preset && options.preset.length > 0) {
-        await initWithPresets(options.preset, projectDir, presetsDir, options);
+        try {
+            await initWithPresets(options.preset, projectDir, presetsDir, options);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`oh-my-harness: ${message}`);
+            if (!message.includes("Preset not found")) {
+                console.error("Run `oh-my-harness init --help` for usage information.");
+            }
+            process.exitCode = 1;
+        }
         return;
     }
     // If preset names are provided as positional args, use legacy flow

package/dist/cli/index.js

@@ -36,7 +36,10 @@ export function createCli() {
         .description("Validate harness configuration health")
         .action(async () => {
         const { doctorCommand } = await import("./commands/doctor.js");
-        await doctorCommand();
+        const result = await doctorCommand();
+        if (result.exitCode !== 0) {
+            process.exitCode = result.exitCode;
+        }
     });
     program
         .command("test")

package/dist/cli/stats/index.js

@@ -3,6 +3,10 @@ import React from "react";
 import { loadStatsData } from "./data.js";
 import { App } from "./App.js";
 export async function statsCommand(options = {}) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.error("oh-my-harness: stats requires an interactive terminal (TTY). Run this command directly in your terminal.");
+        return;
+    }
     const projectDir = options.projectDir ?? process.cwd();
     const data = await loadStatsData(projectDir);
     const { waitUntilExit } = render(React.createElement(App, { initialData: data, projectDir }));

package/dist/core/config-merger.js

@@ -3,6 +3,10 @@ export function mergePresets(presets) {
     const sectionsMap = new Map();
     const preToolUseMap = new Map();
     const postToolUseMap = new Map();
+    const sessionStartMap = new Map();
+    const notificationMap = new Map();
+    const configChangeMap = new Map();
+    const worktreeCreateMap = new Map();
     const allowSet = new Set();
     const denySet = new Set();
     const presetNames = [];
@@ -29,6 +33,26 @@ export function mergePresets(presets) {
                 postToolUseMap.set(hook.id, hook);
             }
         }
+        if (preset.hooks?.sessionStart) {
+            for (const hook of preset.hooks.sessionStart) {
+                sessionStartMap.set(hook.id, hook);
+            }
+        }
+        if (preset.hooks?.notification) {
+            for (const hook of preset.hooks.notification) {
+                notificationMap.set(hook.id, hook);
+            }
+        }
+        if (preset.hooks?.configChange) {
+            for (const hook of preset.hooks.configChange) {
+                configChangeMap.set(hook.id, hook);
+            }
+        }
+        if (preset.hooks?.worktreeCreate) {
+            for (const hook of preset.hooks.worktreeCreate) {
+                worktreeCreateMap.set(hook.id, hook);
+            }
+        }
         // Merge settings (accumulate)
         if (preset.settings?.permissions?.allow) {
             for (const a of preset.settings.permissions.allow)
@@ -48,6 +72,10 @@ export function mergePresets(presets) {
         hooks: {
             preToolUse: Array.from(preToolUseMap.values()),
             postToolUse: Array.from(postToolUseMap.values()),
+            sessionStart: Array.from(sessionStartMap.values()),
+            notification: Array.from(notificationMap.values()),
+            configChange: Array.from(configChangeMap.values()),
+            worktreeCreate: Array.from(worktreeCreateMap.values()),
         },
         settings: {
             permissions: {

package/dist/core/harness-converter-v2.js

@@ -1,6 +1,15 @@
 import { harnessToMergedConfig, mergeEnforcementAndHooks } from "./harness-converter.js";
 import { createDefaultRegistry } from "../catalog/registry.js";
 import { convertHookEntries } from "../catalog/converter.js";
+/** Maps Claude Code event names to HooksConfig field names */
+const eventToField = {
+    PreToolUse: "preToolUse",
+    PostToolUse: "postToolUse",
+    SessionStart: "sessionStart",
+    Notification: "notification",
+    ConfigChange: "configChange",
+    WorktreeCreate: "worktreeCreate",
+};
 export async function harnessToMergedConfigV2(harness, registry, projectDir) {
     // Start with base conversion (rules, variables, permissions — no inline enforcement scripts)
     const base = harnessToMergedConfig(harness);
@@ -15,9 +24,14 @@ export async function harnessToMergedConfigV2(harness, registry, projectDir) {
     const catalogResult = await convertHookEntries(allHookEntries, resolvedRegistry, projectDir ?? ".");
     // Convert hooksConfig entries from catalog into HookDefinition format.
     // Errors are reported as warnings but don't block valid hooks.
-    const additionalPreToolUse = [];
-    const additionalPostToolUse = [];
+    const additionalHooks = {};
     for (const [event, entries] of Object.entries(catalogResult.hooksConfig)) {
+        const field = eventToField[event];
+        if (!field)
+            continue; // unknown event — skip
+        if (!additionalHooks[field]) {
+            additionalHooks[field] = [];
+        }
         for (const entry of entries) {
             // Find the block id from the script path: .claude/hooks/<block-id>.sh
             const blockId = entry.command.replace(/.*\/(.+)\.sh$/, "$1");
@@ -27,21 +41,20 @@ export async function harnessToMergedConfigV2(harness, registry, projectDir) {
                 description: `Catalog block: ${blockId}`,
                 inline: catalogResult.scripts.get(entry.command),
             };
-            if (event === "PreToolUse") {
-                additionalPreToolUse.push(hookDef);
-            }
-            else if (event === "PostToolUse") {
-                additionalPostToolUse.push(hookDef);
-            }
-            // Other events (SessionStart, etc.) are not yet mapped to MergedConfig hooks
+            additionalHooks[field].push(hookDef);
         }
     }
+    const mergedHooks = {
+        preToolUse: [...base.hooks.preToolUse, ...(additionalHooks.preToolUse ?? [])],
+        postToolUse: [...base.hooks.postToolUse, ...(additionalHooks.postToolUse ?? [])],
+        sessionStart: [...(base.hooks.sessionStart ?? []), ...(additionalHooks.sessionStart ?? [])],
+        notification: [...(base.hooks.notification ?? []), ...(additionalHooks.notification ?? [])],
+        configChange: [...(base.hooks.configChange ?? []), ...(additionalHooks.configChange ?? [])],
+        worktreeCreate: [...(base.hooks.worktreeCreate ?? []), ...(additionalHooks.worktreeCreate ?? [])],
+    };
     return {
         ...base,
-        hooks: {
-            preToolUse: [...base.hooks.preToolUse, ...additionalPreToolUse],
-            postToolUse: [...base.hooks.postToolUse, ...additionalPostToolUse],
-        },
+        hooks: mergedHooks,
         ...(catalogResult.errors.length > 0 ? { catalogErrors: catalogResult.errors } : {}),
     };
 }

package/dist/core/harness-converter.js

@@ -76,6 +76,10 @@ export function harnessToMergedConfig(harness) {
         hooks: {
             preToolUse: [],
             postToolUse: [],
+            sessionStart: [],
+            notification: [],
+            configChange: [],
+            worktreeCreate: [],
         },
         settings: {
             permissions: {

package/dist/core/preset-types.d.ts

@@ -87,6 +87,94 @@ export declare const HooksConfigSchema: z.ZodObject<{
         inline?: string | undefined;
         variables?: Record<string, unknown> | undefined;
     }>, "many">>;
+    sessionStart: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        matcher: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        script: z.ZodOptional<z.ZodString>;
+        inline: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    notification: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        matcher: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        script: z.ZodOptional<z.ZodString>;
+        inline: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    configChange: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        matcher: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        script: z.ZodOptional<z.ZodString>;
+        inline: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    worktreeCreate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        matcher: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        script: z.ZodOptional<z.ZodString>;
+        inline: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     preToolUse?: {
         id: string;
@@ -104,6 +192,38 @@ export declare const HooksConfigSchema: z.ZodObject<{
         inline?: string | undefined;
         variables?: Record<string, unknown> | undefined;
     }[] | undefined;
+    sessionStart?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    notification?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    configChange?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    worktreeCreate?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
 }, {
     preToolUse?: {
         id: string;
@@ -121,6 +241,38 @@ export declare const HooksConfigSchema: z.ZodObject<{
         inline?: string | undefined;
         variables?: Record<string, unknown> | undefined;
     }[] | undefined;
+    sessionStart?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    notification?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    configChange?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    worktreeCreate?: {
+        id: string;
+        matcher: string;
+        description?: string | undefined;
+        script?: string | undefined;
+        inline?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }[] | undefined;
 }>;
 export type HooksConfig = z.infer<typeof HooksConfigSchema>;
 export declare const SettingsConfigSchema: z.ZodObject<{
@@ -238,6 +390,94 @@ export declare const PresetConfigSchema: z.ZodObject<{
             inline?: string | undefined;
             variables?: Record<string, unknown> | undefined;
         }>, "many">>;
+        sessionStart: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            matcher: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            script: z.ZodOptional<z.ZodString>;
+            inline: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }>, "many">>;
+        notification: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            matcher: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            script: z.ZodOptional<z.ZodString>;
+            inline: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }>, "many">>;
+        configChange: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            matcher: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            script: z.ZodOptional<z.ZodString>;
+            inline: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }>, "many">>;
+        worktreeCreate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            matcher: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            script: z.ZodOptional<z.ZodString>;
+            inline: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }, {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         preToolUse?: {
             id: string;
@@ -255,6 +495,38 @@ export declare const PresetConfigSchema: z.ZodObject<{
             inline?: string | undefined;
             variables?: Record<string, unknown> | undefined;
         }[] | undefined;
+        sessionStart?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        notification?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        configChange?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        worktreeCreate?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
     }, {
         preToolUse?: {
             id: string;
@@ -272,6 +544,38 @@ export declare const PresetConfigSchema: z.ZodObject<{
             inline?: string | undefined;
             variables?: Record<string, unknown> | undefined;
         }[] | undefined;
+        sessionStart?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        notification?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        configChange?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        worktreeCreate?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
     }>>;
     settings: z.ZodOptional<z.ZodObject<{
         permissions: z.ZodOptional<z.ZodObject<{
@@ -329,6 +633,38 @@ export declare const PresetConfigSchema: z.ZodObject<{
             inline?: string | undefined;
             variables?: Record<string, unknown> | undefined;
         }[] | undefined;
+        sessionStart?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        notification?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        configChange?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        worktreeCreate?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
     } | undefined;
     settings?: {
         permissions?: {
@@ -370,6 +706,38 @@ export declare const PresetConfigSchema: z.ZodObject<{
             inline?: string | undefined;
             variables?: Record<string, unknown> | undefined;
         }[] | undefined;
+        sessionStart?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        notification?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        configChange?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        worktreeCreate?: {
+            id: string;
+            matcher: string;
+            description?: string | undefined;
+            script?: string | undefined;
+            inline?: string | undefined;
+            variables?: Record<string, unknown> | undefined;
+        }[] | undefined;
     } | undefined;
     settings?: {
         permissions?: {

package/dist/core/preset-types.js

@@ -20,6 +20,10 @@ export const ClaudeMdSectionSchema = z.object({
 export const HooksConfigSchema = z.object({
     preToolUse: z.array(HookDefinitionSchema).optional(),
     postToolUse: z.array(HookDefinitionSchema).optional(),
+    sessionStart: z.array(HookDefinitionSchema).optional(),
+    notification: z.array(HookDefinitionSchema).optional(),
+    configChange: z.array(HookDefinitionSchema).optional(),
+    worktreeCreate: z.array(HookDefinitionSchema).optional(),
 });
 // --- Settings Config ---
 export const SettingsConfigSchema = z.object({

package/dist/detector/detectors/index.js

@@ -12,6 +12,7 @@ import { dartDetector } from "./dart.js";
 import { elixirDetector } from "./elixir.js";
 import { scalaDetector } from "./scala.js";
 import { zigDetector } from "./zig.js";
+import { terraformDetector } from "./terraform.js";
 export const allDetectors = [
     nodeDetector,
     pythonDetector,
@@ -27,4 +28,5 @@ export const allDetectors = [
     elixirDetector,
     scalaDetector,
     zigDetector,
+    terraformDetector,
 ];

package/dist/detector/detectors/terraform.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const terraformDetector: Detector;

package/dist/detector/detectors/terraform.js

@@ -0,0 +1,46 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const terraformDetector = {
+    name: "terraform",
+    detect: async (projectDir) => {
+        // Check for *.tf files
+        let hasTfFiles = false;
+        const detectedFiles = [];
+        try {
+            const entries = await fs.readdir(projectDir);
+            for (const entry of entries) {
+                if (entry.endsWith(".tf")) {
+                    hasTfFiles = true;
+                    detectedFiles.push(entry);
+                }
+            }
+        }
+        catch {
+            return {};
+        }
+        // Fallback: check for .terraform.lock.hcl
+        if (!hasTfFiles) {
+            try {
+                await fs.access(path.join(projectDir, ".terraform.lock.hcl"));
+                hasTfFiles = true;
+                detectedFiles.push(".terraform.lock.hcl");
+            }
+            catch {
+                // not found
+            }
+        }
+        if (!hasTfFiles) {
+            return {};
+        }
+        return {
+            languages: ["hcl"],
+            frameworks: ["terraform"],
+            packageManagers: ["terraform"],
+            testCommands: ["terraform test"],
+            lintCommands: ["tflint"],
+            buildCommands: ["terraform plan"],
+            blockedPaths: [".terraform/", "*.tfstate", "*.tfstate.backup"],
+            detectedFiles,
+        };
+    },
+};

package/dist/generators/hooks.js

@@ -35,22 +35,34 @@ export function wrapWithLogger(script, event = "unknown") {
 export async function generateHooks(options) {
     const { projectDir, config } = options;
     const hooksDir = join(projectDir, ".claude/hooks");
-    const allHooks = [
-        ...config.hooks.preToolUse.map((h) => ({ ...h, event: "PreToolUse" })),
-        ...config.hooks.postToolUse.map((h) => ({ ...h, event: "PostToolUse" })),
+    const eventMap = [
+        ["PreToolUse", config.hooks.preToolUse],
+        ["PostToolUse", config.hooks.postToolUse],
+        ["SessionStart", config.hooks.sessionStart ?? []],
+        ["Notification", config.hooks.notification ?? []],
+        ["ConfigChange", config.hooks.configChange ?? []],
+        ["WorktreeCreate", config.hooks.worktreeCreate ?? []],
     ];
+    const allHooks = eventMap.flatMap(([event, hooks]) => hooks.map((h) => ({ ...h, event })));
     if (allHooks.length === 0) {
         return { hooksConfig: {}, generatedFiles: [] };
     }
     await mkdir(hooksDir, { recursive: true });
     const generatedFiles = [];
     const hooksConfig = {};
+    const usedScriptNames = new Set();
     for (const hook of allHooks) {
         if (!hook.inline) {
             continue;
         }
         const safeId = hook.id.replace(/[^a-zA-Z0-9_-]/g, "");
-        const scriptName = `${safeId}.sh`;
+        let scriptName = `${safeId}.sh`;
+        // Prevent collisions when different events share the same hook.id
+        if (usedScriptNames.has(scriptName)) {
+            const safeEvent = hook.event.replace(/[^a-zA-Z0-9_-]/g, "").toLowerCase();
+            scriptName = `${safeEvent}-${safeId}.sh`;
+        }
+        usedScriptNames.add(scriptName);
         const scriptPath = join(hooksDir, scriptName);
         const wrappedScript = wrapWithLogger(hook.inline, hook.event);
         await writeFile(scriptPath, wrappedScript, "utf8");
@@ -58,7 +70,7 @@ export async function generateHooks(options) {
         generatedFiles.push(scriptPath);
         const entry = {
             matcher: hook.matcher,
-            hooks: [{ type: "command", command: `bash .claude/hooks/${safeId}.sh` }],
+            hooks: [{ type: "command", command: `bash .claude/hooks/${scriptName}` }],
         };
         if (!hooksConfig[hook.event]) {
             hooksConfig[hook.event] = [];

package/dist/generators/settings.js

@@ -17,6 +17,9 @@ export async function generateSettings(options) {
     const existingPermissions = (existing.permissions ?? {});
     const mergedAllow = Array.from(new Set([...(existingPermissions.allow ?? []), ...(config.settings.permissions.allow ?? [])]));
     const mergedDeny = Array.from(new Set([...(existingPermissions.deny ?? []), ...(config.settings.permissions.deny ?? [])]));
+    // Preserve managedAt if content is unchanged
+    const existingMeta = (existing._ohMyHarness ?? {});
+    const previousManagedAt = existingMeta.managedAt;
     const result = {
         ...existing,
         permissions: {
@@ -26,10 +29,27 @@ export async function generateSettings(options) {
         },
         hooks: hooksOutput.hooksConfig,
         _ohMyHarness: {
-            managedAt: new Date().toISOString(),
+            managedAt: "__PLACEHOLDER__",
             presets: config.presets,
         },
     };
+    // Compare content without timestamp to decide if managedAt should update
+    const newContent = JSON.stringify(result, null, 2) + "\n";
+    const oldMeta = existing._ohMyHarness && typeof existing._ohMyHarness === "object" && !Array.isArray(existing._ohMyHarness)
+        ? { ...existing._ohMyHarness }
+        : {};
+    const oldResultForCompare = {
+        ...existing,
+        _ohMyHarness: oldMeta,
+    };
+    if (oldMeta.managedAt) {
+        oldMeta.managedAt = "__PLACEHOLDER__";
+    }
+    const oldContent = JSON.stringify(oldResultForCompare, null, 2) + "\n";
+    const managedAt = newContent === oldContent && previousManagedAt
+        ? previousManagedAt
+        : new Date().toISOString();
+    result._ohMyHarness.managedAt = managedAt;
     await fs.mkdir(claudeDir, { recursive: true });
     await fs.writeFile(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-harness",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Tame your AI coding agents with natural language",
   "type": "module",
   "bin": {

package/presets/terraform/preset.yaml

@@ -0,0 +1,65 @@
+name: terraform
+displayName: "Terraform"
+description: "Infrastructure as Code with Terraform/OpenTofu, tflint, and tfsec"
+version: "1.0.0"
+extends: ["_base"]
+tags: ["terraform", "iac", "infrastructure", "hcl"]
+variables:
+  language: "hcl"
+  framework: "terraform"
+  testRunner: "terraform test"
+  linter: "tflint"
+claudeMd:
+  sections:
+    - id: "terraform-rules"
+      title: "Terraform Rules"
+      content: |
+        ## Terraform Development Rules
+
+        - Run `terraform fmt` before every commit
+        - Run `terraform validate` to check syntax before applying
+        - NEVER modify `.tfstate` files directly — use `terraform state` commands
+        - NEVER hardcode secrets in `.tf` or `.tfvars` files — use variables with sensitive flag
+        - Use `terraform plan` to preview changes before `terraform apply`
+        - NEVER use `terraform apply -auto-approve` without explicit user confirmation
+        - Use consistent naming: snake_case for resources, variables, and outputs
+        - Pin provider versions in `required_providers` block
+        - Use modules for reusable infrastructure components
+      priority: 20
+    - id: "terraform-testing"
+      title: "Terraform Testing"
+      content: |
+        ## Terraform Testing Rules
+
+        - Write tests in `tests/` directory using `terraform test` (HCL-based)
+        - Validate all modules with `terraform validate` before commit
+        - Run `tflint` to catch common misconfigurations
+        - Run `tfsec` for security scanning
+        - Use `terraform plan` as a smoke test for syntax and dependency checks
+      priority: 21
+    - id: "terraform-structure"
+      title: "Terraform Structure"
+      content: |
+        ## Terraform Project Structure
+
+        - `main.tf` — Primary resource definitions
+        - `variables.tf` — Input variable declarations
+        - `outputs.tf` — Output value declarations
+        - `providers.tf` — Provider configuration and version constraints
+        - `terraform.tfvars` — Variable values (DO NOT commit secrets)
+        - `modules/` — Reusable module definitions
+        - `tests/` — Terraform test files
+      priority: 22
+settings:
+  permissions:
+    allow:
+      - "Bash(terraform *)"
+      - "Bash(tofu *)"
+      - "Bash(tflint *)"
+      - "Bash(tfsec *)"
+      - "Bash(terraform-docs *)"
+    deny:
+      - "Bash(sudo *)"
+      - "Bash(rm -rf *)"
+      - "Bash(terraform apply -auto-approve*)"
+      - "Bash(terraform apply --auto-approve*)"