@abarcenas/ai-workflow-template 1.34.0 → 1.38.0

package/scripts/knowledgebase-init.sql

@@ -0,0 +1,193 @@
+-- ═══════════════════════════════════════════════════════════════════════════
+-- knowledgebase-init.sql — Manual Database Provisioning Script
+-- ═══════════════════════════════════════════════════════════════════════════
+--
+-- Purpose:
+--   Creates the PostgreSQL + pgvector schema for the centralized
+--   cross-project knowledgebase. This is the MANUAL fallback when
+--   auto-provision via knowledgebase-index.js fails due to insufficient
+--   superuser privileges for CREATE EXTENSION vector.
+--
+-- Usage:
+--   psql $DATABASE_URL -f scripts/knowledgebase-init.sql
+--
+-- Auto-provision fallback:
+--   The core engine (knowledgebase-index.js) attempts the same DDL
+--   programmatically via pg.Pool.query(). If it fails on CREATE EXTENSION
+--   (common on managed PostgreSQL where you lack superuser), the error
+--   message directs you to run this script manually.
+--
+-- Requirements:
+--   - PostgreSQL 16+ with pgvector extension installed
+--   - A user with CREATEROLE or superuser for CREATE EXTENSION
+--   - A database already created (e.g. createdb knowledgebase)
+--
+-- Schema:
+--   Two tables with HNSW vector index for cosine similarity search.
+--   See docs/adr-knowledgebase-pgvector.md §2 for full design rationale.
+--
+-- ═══════════════════════════════════════════════════════════════════════════
+
+-- ══ 1. Extension ══════════════════════════════════════════════════════════
+-- Requires superuser privileges. On managed PostgreSQL (Supabase, Neon,
+-- Aiven, etc.), pgvector is typically pre-installed. If you see:
+--   ERROR: permission denied to create extension "vector"
+-- ask your database admin to run: CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- ══ 2. Projects table ═════════════════════════════════════════════════════
+-- Each consumer project is registered once. The project_id is derived from
+-- the consumer's package.json "name" field, which is stable across sessions
+-- and unique within an organization.
+
+CREATE TABLE IF NOT EXISTS projects (
+    id                  TEXT PRIMARY KEY,          -- package.json "name" field (e.g. "my-consumer-app")
+    name                TEXT NOT NULL,             -- human-readable display name
+    first_indexed_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    last_indexed_at     TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- ══ 3. Knowledge chunks table ════════════════════════════════════════════
+-- Each row represents one session's "New knowledge" bullet set from a
+-- learned-knowledge.instructions.md file. Content is embedded using
+-- all-MiniLM-L6-v2 (384 dimensions) for cosine similarity search.
+--
+-- The uq_knowledge_chunk constraint ensures idempotency: re-indexing the
+-- same project + session + content produces no duplicates.
+
+CREATE TABLE IF NOT EXISTS knowledge_chunks (
+    id              BIGSERIAL PRIMARY KEY,
+    project_id      TEXT            NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    session_date    DATE            NOT NULL,                        -- from ## Session: heading
+    session_title   TEXT,                                             -- full heading text (e.g. "Session: 2026-07-24 — Feature Pipeline")
+    pipeline        TEXT,                                             -- from **Pipeline:** field
+    coverage        TEXT,                                             -- from **Coverage:** field
+    tdd_iterations  INTEGER         NOT NULL DEFAULT 0,               -- from **TDD Iterations:** field
+    content         TEXT            NOT NULL,                        -- the "New knowledge" bullet text
+    content_hash    TEXT            NOT NULL,                        -- SHA-256(content + session_date + pipeline)
+    embedding       VECTOR(384),                                     -- from all-MiniLM-L6-v2 (384d)
+    indexed_at      TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
+
+    -- Idempotency: same project + session date + content hash → skip silently
+    CONSTRAINT uq_knowledge_chunk UNIQUE (project_id, session_date, content_hash)
+);
+
+-- ══ 4. Indexes ═══════════════════════════════════════════════════════════
+
+-- ── 4a. HNSW index for approximate nearest neighbor (ANN) search ─────────
+-- Enables fast cosine similarity lookups (~1ms for 10k vectors).
+-- Uses vector_cosine_ops operator class for the <=> (cosine distance) operator.
+-- Parameters:
+--   m = 16              — max connections per element (higher = more accurate but slower build)
+--   ef_construction = 64 — dynamic candidate list size during build
+
+CREATE INDEX IF NOT EXISTS idx_knowledge_chunks_embedding
+    ON knowledge_chunks
+    USING hnsw (embedding vector_cosine_ops)
+    WITH (m = 16, ef_construction = 64);
+
+-- ── 4b. B-tree indexes for structured queries and filters ────────────────
+
+-- Filter knowledge by project (used by knowledgebase_search tool)
+CREATE INDEX IF NOT EXISTS idx_knowledge_chunks_project_id
+    ON knowledge_chunks (project_id);
+
+-- Temporal queries: "show me knowledge from the last month"
+CREATE INDEX IF NOT EXISTS idx_knowledge_chunks_session_date
+    ON knowledge_chunks (session_date DESC);
+
+-- Filter by pipeline type (e.g. "TDD Infrastructure Bootstrap", "Feature Pipeline")
+CREATE INDEX IF NOT EXISTS idx_knowledge_chunks_pipeline
+    ON knowledge_chunks (pipeline);
+
+-- Recently indexed projects (used by knowledgebase_list tool)
+CREATE INDEX IF NOT EXISTS idx_projects_last_indexed
+    ON projects (last_indexed_at DESC);
+
+-- ══ 5. Match function ════════════════════════════════════════════════════
+-- Convenience function for cosine similarity search with optional
+-- project_id filtering. Returns results ordered by similarity descending.
+--
+-- Usage examples:
+--
+--   -- Find top 5 chunks similar to a query embedding
+--   SELECT * FROM match_knowledge('[0.01, 0.02, ...]'::vector(384), 0.7, 5);
+--
+--   -- Filter to a specific project
+--   SELECT * FROM match_knowledge('[0.01, 0.02, ...]'::vector(384), 0.7, 5, 'my-app');
+--
+--   -- Use with knowledgebase-index.js generated embeddings
+--   -- (the core engine builds embedding vector from query text)
+
+CREATE OR REPLACE FUNCTION match_knowledge(
+    query_embedding     VECTOR(384),
+    match_threshold     DOUBLE PRECISION,  -- minimum similarity (0.0 to 1.0); 0.7 is a good default
+    match_count         INTEGER,           -- max results to return (1-20 recommended)
+    filter_project_id   TEXT DEFAULT NULL   -- optional: restrict to a single project
+)
+RETURNS TABLE(
+    id              BIGINT,
+    project_id      TEXT,
+    session_date    DATE,
+    session_title   TEXT,
+    pipeline        TEXT,
+    coverage        TEXT,
+    tdd_iterations  INTEGER,
+    content         TEXT,
+    content_hash    TEXT,
+    similarity      DOUBLE PRECISION,
+    indexed_at      TIMESTAMPTZ
+)
+LANGUAGE SQL
+STABLE
+AS $$
+    SELECT
+        id,
+        project_id,
+        session_date,
+        session_title,
+        pipeline,
+        coverage,
+        tdd_iterations,
+        content,
+        content_hash,
+        1 - (embedding <=> query_embedding) AS similarity,
+        indexed_at
+    FROM knowledge_chunks
+    WHERE 1 - (embedding <=> query_embedding) > match_threshold
+        AND (filter_project_id IS NULL OR project_id = filter_project_id)
+    ORDER BY embedding <=> query_embedding
+    LIMIT match_count;
+$$;
+
+-- ══ 6. OpenAI upgrade path ═══════════════════════════════════════════════
+-- The default embedding model is Xenova/all-MiniLM-L6-v2 (384 dimensions).
+-- To upgrade to OpenAI text-embedding-3-small (1536 dimensions):
+--
+--   1. Set OPENAI_API_KEY in your .env file
+--   2. Resize the embedding column (requires dropping and recreating the
+--      HNSW index first — HNSW indexes cannot be built on expression columns)
+--   3. Rebuild the HNSW index for the new dimension
+--
+--   -- Step 1: Drop the old HNSW index (required before ALTER COLUMN TYPE)
+--   DROP INDEX IF EXISTS idx_knowledge_chunks_embedding;
+--
+--   -- Step 2: Change column type to 1536 dimensions
+--   ALTER TABLE knowledge_chunks ALTER COLUMN embedding TYPE VECTOR(1536);
+--
+--   -- Step 3: Rebuild the HNSW index
+--   CREATE INDEX idx_knowledge_chunks_embedding
+--       ON knowledge_chunks
+--       USING hnsw (embedding vector_cosine_ops)
+--       WITH (m = 16, ef_construction = 64);
+--
+-- ═══════════════════════════════════════════════════════════════════════════
+
+-- ══ Done ═════════════════════════════════════════════════════════════════
+-- Verify installation by running:
+--   \dt knowledge_chunks projects
+--   \di idx_*
+--   \df match_knowledge
+--   SELECT * FROM match_knowledge('[0,0,0,0]'::vector(384), 0.0, 1);
+-- (the last query should return 0 rows — confirming the function works)

package/scripts/mcp-knowledgebase-server.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+
+/**
+ * mcp-knowledgebase-server.js — MCP server exposing knowledgebase tools to AI agents.
+ *
+ * Provides: knowledgebase_search, knowledgebase_index, knowledgebase_stats, knowledgebase_list
+ * Uses stdio transport — OpenCode spawns this as a child process.
+ *
+ * Configuration (opencode.json):
+ *   "knowledgebase": {
+ *     "type": "local",
+ *     "command": ["node", "scripts/mcp-knowledgebase-server.js"],
+ *     "enabled": true
+ *   }
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import {
+  search,
+  upsertChunks,
+  chunkLearnedKnowledge,
+  getStats,
+  listProjects,
+  getPool,
+  closePool,
+} from './knowledgebase-index.js';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const server = new Server(
+  {
+    name: 'knowledgebase',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// ── List tools ───────────────────────────────────────────────────────
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'knowledgebase_search',
+      description:
+        'Semantic search across learned knowledge from all indexed projects. ' +
+        'Use this when planning tasks, encountering errors, or seeking patterns from past pipeline sessions.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: {
+            type: 'string',
+            description:
+              'Natural language query about patterns, conventions, gotchas, or agent behavior ' +
+              '(e.g. "how to handle verbose logging in child processes")',
+          },
+          projectId: {
+            type: 'string',
+            description: 'Optional: filter to a specific project by its package.json name',
+          },
+          threshold: {
+            type: 'number',
+            default: 0.6,
+            description: 'Minimum similarity threshold (0.0–1.0). Higher values return fewer but more relevant results.',
+          },
+          limit: {
+            type: 'number',
+            default: 5,
+            description: 'Number of results to return (1–50)',
+          },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'knowledgebase_index',
+      description:
+        'Index or re-index a project\'s learned knowledge content. ' +
+        'Use after adding new sessions to learned-knowledge.instructions.md. ' +
+        'Idempotent — unchanged sessions are skipped.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          projectId: {
+            type: 'string',
+            description: 'Project identifier (from package.json "name")',
+          },
+          content: {
+            type: 'string',
+            description:
+              'Optional: markdown content of learned-knowledge.instructions.md to index. ' +
+              'If omitted, reads from .agents/instructions/learned-knowledge.instructions.md',
+          },
+        },
+        required: ['projectId'],
+      },
+    },
+    {
+      name: 'knowledgebase_stats',
+      description:
+        'Get statistics about the centralized knowledgebase, ' +
+        'including total projects, chunks, database size, and last sync timestamp.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    },
+    {
+      name: 'knowledgebase_list',
+      description:
+        'List all projects currently indexed in the knowledgebase. ' +
+        'Useful for discovering which projects have shared knowledge.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    },
+  ],
+}));
+
+// ── Handle tool calls ────────────────────────────────────────────────
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'knowledgebase_search': {
+        const results = await search(args.query, {
+          project_id: args.projectId || undefined,
+          threshold: args.threshold || 0.6,
+          limit: args.limit || 5,
+        });
+
+        if (results.length === 0) {
+          const pool = await getPool();
+          if (!pool) {
+            return {
+              content: [{
+                type: 'text',
+                text: 'Knowledgebase not available: DATABASE_URL is not configured. ' +
+                  'Set DATABASE_URL in your .env file to enable cross-project knowledge search.',
+              }],
+            };
+          }
+          return {
+            content: [{
+              type: 'text',
+              text: 'No results found. The knowledgebase may be empty.',
+            }],
+          };
+        }
+
+        const formatted = results
+          .map((r, i) =>
+            `### Result ${i + 1} (similarity: ${r.similarity})\n` +
+            `**Project:** \`${r.project_id}\`\n` +
+            `**Date:** ${r.session_date}\n` +
+            `**Pipeline:** ${r.pipeline || 'N/A'}\n\n` +
+            `${r.content}`
+          )
+          .join('\n\n---\n\n');
+
+        return {
+          content: [{ type: 'text', text: formatted }],
+        };
+      }
+
+      case 'knowledgebase_index': {
+        const projectId = args.projectId;
+        if (!projectId) {
+          return {
+            content: [{
+              type: 'text',
+              text: 'Error: projectId is required for knowledgebase_index.',
+            }],
+            isError: true,
+          };
+        }
+
+        let content = args.content;
+        if (!content) {
+          try {
+            content = readFileSync(
+              resolve(
+                process.cwd(),
+                '.agents/instructions/learned-knowledge.instructions.md'
+              ),
+              'utf8'
+            );
+          } catch {
+            return {
+              content: [{
+                type: 'text',
+                text: 'No content provided and the default file ' +
+                  '.agents/instructions/learned-knowledge.instructions.md ' +
+                  'could not be read. Provide the "content" parameter or ensure the file exists.',
+              }],
+              isError: true,
+            };
+          }
+        }
+
+        const chunks = chunkLearnedKnowledge(content, projectId);
+        if (chunks.length === 0) {
+          return {
+            content: [{
+              type: 'text',
+              text: `No valid knowledge chunks found for project "${projectId}". ` +
+                'Ensure the content contains "## Session:" headers with ' +
+                '"**New knowledge:**" sections.',
+            }],
+          };
+        }
+
+        const result = await upsertChunks(chunks);
+        return {
+          content: [{
+            type: 'text',
+            text:
+              `Indexed ${result.inserted} chunks, updated ${result.updated}, ` +
+              `skipped ${result.skipped} for project "${projectId}".`,
+          }],
+        };
+      }
+
+      case 'knowledgebase_stats': {
+        const stats = await getStats();
+
+        if (stats.total_chunks === 0 && stats.total_projects === 0) {
+          const pool = await getPool();
+          if (!pool) {
+            return {
+              content: [{
+                type: 'text',
+                text: 'Knowledgebase not available: DATABASE_URL is not configured.',
+              }],
+            };
+          }
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text:
+              `**Knowledgebase Stats**\n` +
+              `- Total projects: ${stats.total_projects}\n` +
+              `- Total chunks: ${stats.total_chunks}\n` +
+              `- Database size: ${stats.db_size}\n` +
+              `- Last sync: ${stats.last_sync || 'Never'}`,
+          }],
+        };
+      }
+
+      case 'knowledgebase_list': {
+        const projects = await listProjects();
+
+        if (projects.length === 0) {
+          const pool = await getPool();
+          if (!pool) {
+            return {
+              content: [{
+                type: 'text',
+                text: 'Knowledgebase not available: DATABASE_URL is not configured.',
+              }],
+            };
+          }
+          return {
+            content: [{
+              type: 'text',
+              text: 'No projects indexed yet.',
+            }],
+          };
+        }
+
+        const formatted = projects
+          .map((p) =>
+            `- ${p.name || p.project_id} (${p.chunk_count} chunks, ` +
+            `last indexed: ${p.last_indexed || 'Never'})`
+          )
+          .join('\n');
+
+        return {
+          content: [{
+            type: 'text',
+            text: `**Indexed Projects:**\n${formatted}`,
+          }],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Error: ${err.message}`,
+      }],
+      isError: true,
+    };
+  }
+});
+
+// ── Start server ─────────────────────────────────────────────────────
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[knowledgebase-mcp] Server started via stdio transport');
+}
+
+process.on('SIGTERM', () => {
+  console.error('[knowledgebase-mcp] SIGTERM received, closing pool');
+  closePool().catch(() => {});
+  process.exit(0);
+});
+
+main().catch((err) => {
+  console.error('[knowledgebase-mcp] Fatal error:', err);
+  process.exit(1);
+});

package/scripts/setup/constants.js

@@ -41,8 +41,14 @@ export const HOOK_MERGE_SEPARATOR = '# --- @abarcenas/ai-workflow-template ---'
 export const TEMPLATE_HOOKS = {
   'pre-commit': {
     source: '.husky/pre-commit',
-    content:
-      '# Managed by @abarcenas/ai-workflow-template setup\n\nnode scripts/bump-version.js\nnode scripts/validate-memory-schema.js\n',
+    content: [
+      '# Managed by @abarcenas/ai-workflow-template setup',
+      '#!/bin/sh',
+      '',
+      'node scripts/bump-version.js',
+      'node scripts/validate-memory-schema.js',
+      '',
+    ].join('\n'),
     description:
       'Auto-bump version + validate memory-bank schema before commits',
   },
@@ -51,7 +57,6 @@ export const TEMPLATE_HOOKS = {
     content: [
       '# Managed by @abarcenas/ai-workflow-template setup',
       '#!/bin/sh',
-      '. "$(dirname "$0")/_/husky.sh"',
       '',
       '# After git pull/merge, check if memory-bank files changed',
       '# and update the vector index incrementally',
@@ -65,6 +70,26 @@ export const TEMPLATE_HOOKS = {
     description:
       'Auto-update memory bank vector index after pull/merge',
   },
+  'post-commit': {
+    source: '.husky/post-commit',
+    content: [
+      '# Managed by @abarcenas/ai-workflow-template setup',
+      '#!/bin/sh',
+      '',
+      '# After commit, check if learned knowledge file changed',
+      '# and sync to the centralized knowledgebase',
+      '',
+      'CHANGED=$(git diff HEAD~1 --name-only 2>/dev/null | grep ".agents/instructions/learned-knowledge.instructions.md")',
+      '',
+      'if [ -n "$CHANGED" ]; then',
+      '  echo "[knowledgebase] Learned knowledge file changed. Syncing to knowledgebase..."',
+      '  node scripts/knowledgebase-cli.js sync 2>/dev/null || echo "[knowledgebase] Sync skipped (DATABASE_URL not configured or service unavailable)"',
+      'fi',
+      '',
+    ].join('\n'),
+    description:
+      'Auto-sync learned knowledge to centralized knowledgebase after commits',
+  },
 }
 
 // ── CI/CD environment detection ───────────────────────────────────────────────
@@ -113,6 +138,7 @@ export const SUPPORTED_FLAGS = {
   '--skip-hooks': 'skipHooks',
   '--skip-prepare': 'skipPrepare',
   '--skip-sync': 'skipSync',
+  '--skip-knowledgebase': 'skipKnowledgebase',
   '--help': 'help',
   '-h': 'help',
   '--version': 'version',
@@ -222,5 +248,12 @@ export const MEMORY_BANK_STUBS = {
 - **To Build**: {{what remains}}
 - **Status**: {{overall project status}}
 - **Known Issues**: {{list known issues}}
+`,
+  'learned-knowledge.instructions.md': `# Learned Knowledge
+
+Cross-session knowledge accumulated by agent pipelines. Each session records discoveries, patterns, gotchas, and agent tuning notes for future reference.
+
+---
+
 `,
 }

package/scripts/setup/hooks.js

@@ -52,8 +52,8 @@ function buildHookContent(hookName) {
   const template = TEMPLATE_HOOKS[hookName]
   // The `content` field is always a string in our constants (pre-composed).
   const raw = template.content
-  // Marker is first line, then content.
-  return HOOK_MARKER + '\n' + raw
+  // Template content already has the marker on its first line.
+  return raw
 }
 
 // ── Hook file path helper ────────────────────────────────────────────────────

package/scripts/setup/hooks.test.js

@@ -66,15 +66,16 @@ function cleanupTempDirs() {
 }
 
 /**
- * Replicates the internal `buildHookContent()` logic so we can assert on
- * expected file content without exporting a private function.
+ * Returns the expected hook file content as produced by `buildHookContent()`.
  *
- * @param {string} hookName - Key from `TEMPLATE_HOOKS` ('pre-commit' | 'post-merge')
+ * The template content in `TEMPLATE_HOOKS` already includes `HOOK_MARKER`
+ * as its first line, so this just returns the raw content directly.
+ *
+ * @param {string} hookName - Key from `TEMPLATE_HOOKS` ('pre-commit' | 'post-merge' | 'post-commit')
  * @returns {string} The full hook file content as written by hooks.js.
  */
 function expectedContent(hookName) {
-  const raw = TEMPLATE_HOOKS[hookName].content
-  return HOOK_MARKER + '\n' + raw
+  return TEMPLATE_HOOKS[hookName].content
 }
 
 /**
@@ -169,6 +170,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: true },
         'post-merge': { exists: true, isManaged: true },
+        'post-commit': { exists: true, isManaged: true },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
@@ -203,6 +205,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: false },
         'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
@@ -240,6 +243,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: false },
         'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
@@ -400,12 +404,14 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: false },
         'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
     mkdirSync(huskyDir)
     writeFileSync(join(huskyDir, 'pre-commit'), '# orig\n')
     writeFileSync(join(huskyDir, 'post-merge'), '# orig\n')
+    writeFileSync(join(huskyDir, 'post-commit'), '# orig\n')
 
     const results = await installHooks(ctx)
 
@@ -414,6 +420,7 @@ describe('installHooks', () => {
     }
     expect(existsSync(join(huskyDir, 'pre-commit.bak'))).toBe(true)
     expect(existsSync(join(huskyDir, 'post-merge.bak'))).toBe(true)
+    expect(existsSync(join(huskyDir, 'post-commit.bak'))).toBe(true)
   })
 
   // ── 12. Partial existingHooks map ─────────────────────────────────────
@@ -424,6 +431,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: true },
         // post-merge absent → treated as exists=false, isManaged=false
+        // post-commit absent → treated as exists=false, isManaged=false
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')