@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/core/harnesses/shared/hooks/adapters/gemini.js

@@ -1,114 +0,0 @@
-'use strict';
-
-/**
- * Gemini CLI payload/decision adapter for the Cross-Harness Hook Runner (design.md C2's
- * Payload Adapter / Decision Adapter seam, D2).
- *
- * Gemini's own native contract — evidenced by core/harnesses/gemini/hooks/*.sh and
- * core/harnesses/gemini/hooks/hooks.json, all currently invoked directly by bash rather than
- * through this runner — already speaks field names close to Claude/Codex/Kiro's, NOT
- * Antigravity's toolCall/args envelope:
- *
- *   SessionStart           : stdin  { session_id, cwd }                          (session-start.sh)
- *   BeforeTool (~PreToolUse): stdin  { tool_name, tool_input: { file_path, command } }
- *                             stdout { decision: "allow"|"deny", reason } — TOP-LEVEL, not
- *                             nested under hookSpecificOutput.permissionDecision like
- *                             Claude/Codex (confirmed in gemini/hooks/pre-bash-guard.sh's header).
- *   AfterTool (~PostToolUse): stdin { tool_name, tool_input: { file_path }, session_id }
- *                             (post-edit-lint.sh) — stdout {} (ack; no Phase A policy owns this
- *                             event, post-edit-lint.sh's collector role is out of FR-001's scope)
- *   Stop                    : NOT a documented Gemini lifecycle event — gemini/hooks/
- *                             post-edit-lint.sh's own comment states "Gemini has no
- *                             Stop-equivalent event," and no stop-check.sh ships under
- *                             gemini/hooks/ today. Handled defensively below (same field-name
- *                             union stop-check.sh itself accepts) in case a future Gemini
- *                             version adds one, or in case core/harnesses/shared/hooks/hooks.json's
- *                             existing (currently dangling) Stop entry is corrected to a real target.
- *
- * NFR-002 note: core/harnesses/shared/hooks/hooks.json has historically routed PreToolUse through
- * this runner using Antigravity's { toolCall: { name, args } } envelope — inherited from this
- * runner's original Antigravity-only design (see the runner's own prior header comment), not
- * verified against Gemini's own documented schema above. toCanonical() below reads the
- * tool_name/tool_input shape first (Gemini's own evidenced contract) and falls back to the
- * toolCall envelope only if that shape isn't present, so this adapter is correct once that
- * wiring is corrected without silently breaking before it is.
- */
-
-const { FILE_PATH_ARG_FIELDS, COMMAND_ARG_FIELDS, firstArgField } = require('./arg-fields');
-
-function toCanonical(event, payload) {
-  const safePayload = payload && typeof payload === 'object' ? payload : {};
-
-  switch (event) {
-    case 'SessionStart':
-      return { session_id: safePayload.session_id || '', cwd: safePayload.cwd || '' };
-
-    case 'PreToolUse': {
-      if (safePayload.tool_name !== undefined || safePayload.tool_input !== undefined) {
-        const toolInput = safePayload.tool_input || {};
-        return {
-          tool_name: safePayload.tool_name || '',
-          tool_input: {
-            file_path: toolInput.file_path || '',
-            command: toolInput.command || '',
-          },
-        };
-      }
-      // Defensive fallback: Antigravity-shaped envelope (see header note).
-      const toolCall = safePayload.toolCall || {};
-      const args = toolCall.args || {};
-      return {
-        tool_name: toolCall.name || '',
-        tool_input: {
-          file_path: firstArgField(args, FILE_PATH_ARG_FIELDS),
-          command: firstArgField(args, COMMAND_ARG_FIELDS),
-        },
-      };
-    }
-
-    case 'PostToolUse':
-      return {
-        tool_name: safePayload.tool_name || '',
-        session_id: safePayload.session_id || '',
-        tool_input: { file_path: (safePayload.tool_input && safePayload.tool_input.file_path) || '' },
-      };
-
-    case 'Stop':
-      return {
-        session_id: safePayload.session_id || '',
-        transcript_path: safePayload.transcript_path || safePayload.transcriptPath || '',
-      };
-
-    default:
-      return safePayload;
-  }
-}
-
-function toNative(event, decision) {
-  const safeDecision = decision || { decision: 'allow' };
-
-  switch (event) {
-    case 'PreToolUse':
-      if (safeDecision.decision === 'deny') {
-        return { decision: 'deny', reason: safeDecision.reason };
-      }
-      return { decision: 'allow' };
-
-    case 'PostToolUse':
-      return {};
-
-    case 'Stop':
-      if (safeDecision.decision === 'deny') {
-        return { decision: 'deny', reason: safeDecision.reason };
-      }
-      return { decision: 'allow' };
-
-    case 'SessionStart':
-      return {};
-
-    default:
-      return { decision: 'allow' };
-  }
-}
-
-module.exports = { toCanonical, toNative };

package/core/harnesses/shared/hooks/hooks.json

@@ -1,47 +0,0 @@
-{
-  "description": "DoFlow shared lifecycle hooks schema for Antigravity, Gemini, and Claude.",
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/session-start.sh\""
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "^(run_command|run_shell_command|replace_file_content|write_to_file|multi_replace_file_content|edit_file|Edit|Write)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$DOFLOW_PROJECT_DIR/.doflow/scripts/stream-hook-runner.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "^(replace_file_content|write_to_file|multi_replace_file_content|edit_file|Edit|Write)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/post-edit-lint.sh\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/stop-check.sh\""
-          }
-        ]
-      }
-    ]
-  }
-}

package/core/shared/guidance/FLAGS.md

@@ -1,25 +0,0 @@
-# Runtime Behavior and Flags
-
-Loaded into **every** session on every harness. What a flag used to request is now mostly
-unconditional, so this states the behavior once rather than listing knobs.
-
-## Always on
-
-**Readiness gating** — a stage that edits source is graded against its class contract first;
-the verdict is one of four states, never a number.
-**Recovery bounds** — a failed verification is classified and retried under a bound the runtime
-sets. You do not pick a cycle count.
-**Run tracing** — every runtime call is recorded as it happens and read back; where a run
-stopped is read from that record, never reconstructed.
-**Capability routing** — an information need resolves to a provider healthy on this machine, not to
-a habitual tool.
-
-## Flags
-
-What the user typed beats auto-detection. Every flag belongs to one skill and is declared in that
-skill's `argument-hint`, except this one, which crosses them:
-
-**--focus [quality|security|performance|architecture]** — narrows analysis to one domain. Consumed
-by `do-diagnose`.
-
-MCP short flags are generated per install into `MCP_INDEX.md`; this file names no server.

package/core/shared/guidance/rules/RULE_01_SAFETY.md

@@ -1,25 +0,0 @@
-# Safety Rules (CRITICAL)
-
-## Priority System
-**CRITICAL** — Security, data safety, production — never compromise
-**IMPORTANT** — Quality, maintainability, professionalism — strong preference
-**RECOMMENDED** — Optimization, style, best practices — apply when practical
-
-Conflict order: Safety > Scope > Quality > Speed. Prototype != Production requirements.
-
-<important if="debugging, fixing a bug, or investigating a failure">
-## Failure Investigation
-- Root cause always — understand WHY, not just THAT; fix the cause, not the symptom
-- Never skip/disable/comment-out tests or validation to pass builds
-</important>
-
-<important if="performing git operations or starting work on a codebase">
-## Git Workflow
-- `git status && git branch` first; feature branches for ALL work; never force-push main
-- Commit incrementally with descriptive messages; `git diff` before staging; restore-point commit
-  before anything risky
-</important>
-
-## Temporal Awareness
-- Read the date from `<env>` before any temporal claim; never infer it from your knowledge cutoff,
-  and state its source

package/core/shared/guidance/rules/RULE_02_WORKFLOW.md

@@ -1,23 +0,0 @@
-# Workflow Rules
-
-## Planning
-- **Parallel by default** — sequential only for hard dependencies; a task list once past 3 tasks, when the session offers one
-- Validate before execution, verify after; run lint/typecheck before marking complete
-- Check deps (package.json) and existing patterns before any changes
-- Feature delivery follows the doflow chain — see `references/DOFLOW_CHAIN.md` for the phase-gated
-  flow, artifact contracts, and the enforced gate
-
-<important if="planning or starting a multi-step task">
-## Planning Efficiency
-- Identify concurrent vs sequential operations
-- Map dependencies; batch tool calls; estimate parallelization gains
-</important>
-
-## Implementation Completeness
-- Start it = Finish it. No partial features, TODO stubs, mocks, or "not implemented" throws
-- All generated code must work as specified; no scaffolding placeholders
-
-## Scope Discipline
-- Build ONLY what's asked — no bonus features, no enterprise bloat (auth/monitoring/deployment
-  unless requested)
-- MVP first; YAGNI; single responsibility per component

package/core/shared/guidance/rules/RULE_03_QUALITY.md

@@ -1,14 +0,0 @@
-# Quality Rules
-
-## Organization & Hygiene
-**Naming**: Follow language standards (camelCase JS, snake_case Python); no mixed conventions
-**Files**: Organize by feature/domain; tests → `tests/`; scripts → `scripts/`; reports → `agent-docs/`
-**Workspace**: Remove temp files, debug scripts, build artifacts after use; never leave clutter in VCS
-
-## Professional Honesty
-- No marketing language ("blazingly fast", "100% secure", "magnificent")
-- No invented sources, figures, citations or quotes; leave out what you cannot trace; state "untested/MVP/needs validation" honestly
-- If you are not sure, say so plainly and name what is unknown; do not present a guess as established
-- Warn when a claim may be outdated: information from memory or an old source can have changed since it was written
-- Never attribute a statement or view to a real person unless you have verified it; otherwise omit the name
-- Push back on bad approaches; evidence-based claims only

package/core/shared/guidance/rules/RULE_04_QUESTIONS.md

@@ -1,46 +0,0 @@
-# Question & Clarification Rules
-
-## When to Ask
-- Ask ONLY for genuine user-owned decisions unresolved by the request, the code, or sensible defaults
-- Enough to act → act; don't ask to confirm the obvious (see RULE_02 Scope Discipline)
-- One question that unblocks beats three that re-litigate settled choices
-
-<important if="asking the user a clarifying question or choosing between approaches">
-## How to Ask (MANDATORY format)
-Structured multiple-choice — never a free-form question buried in prose.
-- **A native question tool exists in this session** (Claude Code's `AskUserQuestion`, or any
-  harness tool that presents options and returns the user's choice): use it. Which harness this
-  is is not the test — what THIS session offers is; Codex and Gemini sessions increasingly
-  carry one.
-- **No native question tool** (truly non-interactive runs): write a `{stage}-questions.md` file
-  with `[Answer]:` tags — the fallback, never the preference.
-
-Each question:
-- 2–4 **meaningful, mutually-exclusive** options covering the real scenarios
-- NEVER invent filler; an "Other"/free-text escape is always the last choice
-- One topic per question; specific and unambiguous; lead with your recommended default
-</important>
-
-<important if="writing a question file because this session has no native question tool">
-## Question-File Format
-```markdown
-## Question 1 — [the question]
-A) [option]  B) [option]  X) Other (free text after the tag)
-
-[Answer]:
-```
-Naming: `{stage}-questions.md` (e.g. `spec-questions.md`) in the directory the stage writes
-its output to — not a fixed path outside the repo's layout.
-
-Lifecycle: write the file → tell the user and wait for "done" → read answers →
-**Validate Before Proceeding** (below) → act. A missing `[Answer]:`, or one that is not a listed
-letter, means ask again — never guess, and never reinterpret free text as a letter choice.
-</important>
-
-<important if="reading the user's answers before you act on them">
-## Validate Before Proceeding
-- Scan answers for contradictions (scope vs risk, quick fix vs multi-subsystem) and ambiguity
-- Conflict found → name it and ask one targeted follow-up in `{stage}-clarification-questions.md`,
-  same format, citing the conflicting answer; never proceed on an unresolved contradiction, and
-  never assume an answer to an ambiguous response
-</important>

package/src/adapters/gemini/hooks.js

@@ -1,210 +0,0 @@
-'use strict';
-
-// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
-
-// Gemini hook planning. Unlike Codex (which owns a standalone hooks.json file), Gemini's hooks
-// live as a "hooks" key inside settings.json — a file DoFlow does not fully own (it commonly
-// pre-exists with unrelated content: mcpServers, ui, telemetry, model, etc.). planGeminiHooks
-// therefore returns a key-scoped merge plan, never a full-file replace.
-//
-// NOTE: validateHooksConfig below intentionally duplicates codex-hooks.js's shape-checking logic
-// (event -> array of {matcher, hooks:[{type,command,...}]} groups) rather than sharing it, since
-// unifying it would mean introducing a new shared module beyond this feature's planned scope
-// (agent-docs/doflow/013-codex-gemini-hooks-parity/plan.md's component list). Worth factoring out
-// if a third harness with the same shape is ever added.
-const fs = require('node:fs');
-const path = require('node:path');
-const { verifyHookCommands } = require('../hook-commands.js');
-const { mergeHooks } = require('../../helper/settings-merge.js');
-
-const SUPPORTED_EVENTS = new Set([
-  'SessionStart', 'SessionEnd', 'BeforeAgent', 'AfterAgent', 'BeforeModel', 'AfterModel',
-  'BeforeToolSelection', 'BeforeTool', 'AfterTool', 'PreCompress', 'Notification',
-]);
-
-// Claude guardrail event -> Gemini event, only where a real Gemini event has matching semantics
-// (source: geminicli.com/docs/hooks/reference.md). UserPromptSubmit,
-// Stop, SubagentStart/Stop, and ConfigChange have no correct Gemini equivalent and are
-// intentionally omitted rather than approximated onto BeforeAgent/AfterAgent (design.md §7/§8 —
-// no false parity).
-const CLAUDE_TO_GEMINI_EVENT                         = {
-  SessionStart: 'SessionStart',
-  SessionEnd: 'SessionEnd',
-  PreToolUse: 'BeforeTool',
-  PostToolUse: 'AfterTool',
-  PreCompact: 'PreCompress',
-};
-
-function validationError(errors          , message        )       { errors.push(message); }
-
-function validateHooksConfig(config     )                                                      {
-  const errors           = [];
-  if (!config || typeof config !== 'object' || Array.isArray(config)) {
-    return { ok: false, errors: ['Hook configuration must be an object'], events: [] };
-  }
-  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
-    return { ok: false, errors: ['Hook configuration requires a hooks object'], events: [] };
-  }
-  for (const [event, groups] of Object.entries(config.hooks)) {
-    if (!SUPPORTED_EVENTS.has(event)) {
-      validationError(errors, `Unsupported Gemini hook event '${event}'`);
-      continue;
-    }
-    if (!Array.isArray(groups) || groups.length === 0) {
-      validationError(errors, `Hook event '${event}' requires a non-empty array of matcher groups`);
-      continue;
-    }
-    groups.forEach((group     , groupIndex        ) => {
-      if (!group || typeof group !== 'object' || Array.isArray(group)) {
-        validationError(errors, `Hook event '${event}' group ${groupIndex} must be an object`);
-        return;
-      }
-      if (group.matcher !== undefined && typeof group.matcher !== 'string') {
-        validationError(errors, `Hook event '${event}' group ${groupIndex} matcher must be a string`);
-      }
-      if (!Array.isArray(group.hooks) || group.hooks.length === 0) {
-        validationError(errors, `Hook event '${event}' group ${groupIndex} requires a non-empty hooks array`);
-        return;
-      }
-      group.hooks.forEach((handler     , handlerIndex        ) => {
-        const label = `Hook event '${event}' group ${groupIndex} handler ${handlerIndex}`;
-        if (!handler || typeof handler !== 'object' || Array.isArray(handler)) {
-          validationError(errors, `${label} must be an object`); return;
-        }
-        if (handler.type !== 'command') validationError(errors, `${label} must have type 'command'`);
-        if (typeof handler.command !== 'string' || !handler.command.trim()) {
-          validationError(errors, `${label} requires a non-empty command string`);
-        }
-        if (handler.timeout !== undefined && typeof handler.timeout !== 'number') {
-          validationError(errors, `${label} timeout must be a number`);
-        }
-      });
-    });
-  }
-  return { ok: errors.length === 0, errors, events: Object.keys(config.hooks) };
-}
-
-/** Maps Claude guardrail intent, never fabricating a Gemini equivalent for unavailable events. */
-function classifyClaudeGuardrails(claudeHooks      = {})                                           {
-  const supported        = [];
-  const unsupported        = [];
-  for (const [event, groups] of Object.entries(claudeHooks || {})) {
-    const targetEvent = CLAUDE_TO_GEMINI_EVENT[event] || null;
-    const item = { sourceEvent: event, targetEvent, groups: Array.isArray(groups) ? groups.length : 0 };
-    if (targetEvent) supported.push(item);
-    else unsupported.push({ ...item, reason: `Gemini has no equivalent lifecycle event for Claude's '${event}'` });
-  }
-  return { supported, unsupported };
-}
-
-/**
- * Plan a key-scoped merge of a "hooks" config into an existing (or absent) settings.json, never
- * touching any other key. Mirrors src/mcp.js's readJsonOrThrow discipline: a settings.json that
- * exists but fails to parse is a hard error, not silently treated as empty (this path merges
- * into content DoFlow does not own — a malformed-file work-around here risks losing it).
- */
-function planGeminiHooks({ config, sourceFile, sourceHooksDir, settingsFile, destinationHooksDir: declaredHooksDir, trusted = false, fsImpl = fs }      = {})      {
-  let desired = config;
-  try {
-    if (!desired && sourceFile) desired = JSON.parse(fsImpl.readFileSync(sourceFile, 'utf8'));
-  } catch (error     ) {
-    return { ok: false, status: 'malformed', changes: [], errors: [`Could not parse ${sourceFile}: ${error.message}`] };
-  }
-  if (!settingsFile) return { ok: false, status: 'invalid-request', changes: [], errors: ['settingsFile is required'] };
-  const schema = validateHooksConfig(desired);
-  const commands = verifyHookCommands(desired || {}, { scriptsDir: sourceHooksDir, trusted, fsImpl });
-  const errors = [...schema.errors, ...commands.checks.filter((check     ) => !check.ok).map((check     ) => `${check.event}: ${check.reason}${check.script ? ` (${check.script})` : ''}`)];
-
-  let existing      = {};
-  if (fsImpl.existsSync(settingsFile)) {
-    try { existing = JSON.parse(fsImpl.readFileSync(settingsFile, 'utf8')); }
-    catch (error     ) { return { ok: false, status: 'malformed', changes: [], errors: [`Refusing to touch malformed ${settingsFile}: ${error.message}`] }; }
-  }
-  if (errors.length) return { ok: false, status: 'invalid-request', settingsFile, existing, changes: [], errors, commands };
-
-  const mergedHooks = existing.hooks ? mergeHooks(existing.hooks, desired.hooks) : desired.hooks;
-  const merged = { ...existing, hooks: mergedHooks };
-  const changed = JSON.stringify(existing.hooks) !== JSON.stringify(mergedHooks);
-  // Preferred: the declared hooks directory (harnesses.json "paths".hooksDirectory); the derived
-  // sibling-of-settings fallback stays for direct callers passing raw inputs, and resolves to the
-  // same location.
-  const destinationHooksDir = declaredHooksDir || path.join(path.dirname(settingsFile), 'hooks');
-  // The scripts deployGeminiHooks copies beside settings.json, so a backup of this change holds them too.
-  const shipped = sourceHooksDir && fsImpl.existsSync(sourceHooksDir)
-    ? fsImpl.readdirSync(sourceHooksDir).filter((name        ) => !name.endsWith('.json') && fsImpl.statSync(path.join(sourceHooksDir, name)).isFile())
-    : [];
-  const companionTargets = [...new Set([
-    ...commands.checks.map((check     ) => path.join(destinationHooksDir, check.script)),
-    ...shipped.map((name        ) => path.join(destinationHooksDir, name)),
-  ])].sort();
-  return { ok: true, status: changed ? 'change' : 'unchanged', settingsFile, existing, merged,
-    changes: changed ? [{ type: fsImpl.existsSync(settingsFile) ? 'update' : 'create', file: settingsFile, key: 'hooks' }] : [],
-    errors: [], commands, trust: commands.trust, scriptsDir: sourceHooksDir, destinationHooksDir, companionTargets };
-}
-
-function deployGeminiHooks(plan     , { dryRun = false, fsImpl = fs }                                     = {})      {
-  if (!plan.ok) return { ...plan, applied: false };
-  if (dryRun || plan.status === 'unchanged') return { ...plan, applied: false };
-  fsImpl.mkdirSync(path.dirname(plan.settingsFile), { recursive: true });
-  const content = `${JSON.stringify(plan.merged, null, 2)}\n`;
-  const temporary = path.join(path.dirname(plan.settingsFile), `.${path.basename(plan.settingsFile)}.${process.pid}.${Date.now()}.tmp`);
-  try {
-    fsImpl.writeFileSync(temporary, content, { flag: 'wx' });
-    fsImpl.renameSync(temporary, plan.settingsFile);
-  } finally {
-    if (fsImpl.existsSync(temporary)) fsImpl.unlinkSync(temporary);
-  }
-  const deployed = new Set        ();
-  for (const check of plan.commands.checks) {
-    const target = path.join(plan.destinationHooksDir, check.script);
-    fsImpl.mkdirSync(path.dirname(target), { recursive: true });
-    fsImpl.copyFileSync(check.file, target);
-    fsImpl.chmodSync(target, fsImpl.statSync(check.file).mode & 0o777);
-    deployed.add(check.script);
-  }
-  if (plan.scriptsDir && fsImpl.existsSync(plan.scriptsDir)) {
-    for (const name of fsImpl.readdirSync(plan.scriptsDir)) {
-      if (deployed.has(name) || name.endsWith('.json')) continue;
-      const source = path.join(plan.scriptsDir, name);
-      if (!fsImpl.statSync(source).isFile()) continue;
-      const target = path.join(plan.destinationHooksDir, name);
-      fsImpl.mkdirSync(path.dirname(target), { recursive: true });
-      fsImpl.copyFileSync(source, target);
-      fsImpl.chmodSync(target, fsImpl.statSync(source).mode & 0o777);
-    }
-  }
-  return { ...plan, applied: true };
-}
-
-/**
- * Plan stripping just the "hooks" key back out of settings.json — mirrors this codebase's
- * existing GEMINI.md-instructions removal (structural presence check, not a ledger fingerprint
- * cross-check): if the key isn't present, there's nothing to do; otherwise propose removing only
- * that key, leaving every other key in the shared file untouched (FR-002).
- */
-function planRemoveGeminiHooks({ settingsFile, fsImpl = fs }                                          = {})      {
-  if (!settingsFile) return { ok: false, status: 'invalid-request', changes: [], errors: ['settingsFile is required'] };
-  if (!fsImpl.existsSync(settingsFile)) return { ok: true, status: 'unchanged', settingsFile, changes: [] };
-  let existing;
-  try { existing = JSON.parse(fsImpl.readFileSync(settingsFile, 'utf8')); }
-  catch (error     ) { return { ok: false, status: 'malformed', changes: [], errors: [`Could not parse ${settingsFile}: ${error.message}`] }; }
-  if (existing.hooks === undefined) return { ok: true, status: 'unchanged', settingsFile, changes: [] };
-  const { hooks: _dropped, ...merged } = existing;
-  return { ok: true, status: 'change', settingsFile, merged, changes: [{ type: 'update', file: settingsFile, key: 'hooks', operation: 'remove' }] };
-}
-
-function deployRemoveGeminiHooks(plan     , { dryRun = false, fsImpl = fs }                                     = {})      {
-  if (!plan.ok || plan.status !== 'change' || dryRun) return { ...plan, applied: false };
-  fsImpl.mkdirSync(path.dirname(plan.settingsFile), { recursive: true });
-  const content = `${JSON.stringify(plan.merged, null, 2)}\n`;
-  const temporary = path.join(path.dirname(plan.settingsFile), `.${path.basename(plan.settingsFile)}.${process.pid}.${Date.now()}.tmp`);
-  try {
-    fsImpl.writeFileSync(temporary, content, { flag: 'wx' });
-    fsImpl.renameSync(temporary, plan.settingsFile);
-  } finally {
-    if (fsImpl.existsSync(temporary)) fsImpl.unlinkSync(temporary);
-  }
-  return { ...plan, applied: true };
-}
-
-module.exports = { SUPPORTED_EVENTS, validateHooksConfig, classifyClaudeGuardrails, verifyHookCommands, planGeminiHooks, deployGeminiHooks, planRemoveGeminiHooks, deployRemoveGeminiHooks };