@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/core/hook-chains.js

@@ -0,0 +1,392 @@
+/**
+ * Hook chains — `PostToolUseFailure` + `TaskCompleted` first-class events.
+ *
+ * #24 (CEO P1). Pugi already had primitives for
+ * `PostToolUseFailure` in the legacy `core/hooks.ts` registry but no
+ * way to declare a **fallback chain** that fires automatically when a
+ * tool dispatch fails or when an entire `pugi <command>` dispatch
+ * completes. the upstream tool exposes both events as first-class hook
+ * sources; this module wires them on the Pugi side.
+ *
+ * Why a fresh module rather than extending `core/hooks.ts`:
+ *  - The legacy registry reads flat `hooks: [{event, match, run}]`
+ *    arrays from `~/.pugi/hooks.json` + `.pugi/hooks.json`. Chains
+ *    are declared in a nested `hooks: { EventName: [{matcher, run}] }`
+ *    shape from `.pugi/settings.json` — a different file, different
+ *    shape, and importantly a different opt-out grammar (per-chain
+ *    `enabled: false`). Mixing the two readers would force every
+ *    legacy caller to learn the chain shape.
+ *  - Chains have richer payloads (TaskCompleted ships durationMs,
+ *    toolCalls, filesChanged). Stuffing them through the legacy
+ *    stdin/env contract would silently break v1 scripts that key on
+ *    the existing payload shape.
+ *  - Chain failures MUST NOT crash the dispatch (the model already
+ *    finished). The legacy registry's `onFailure: 'block'` semantics
+ *    would propagate the error — chains explicitly swallow it and
+ *    log instead.
+ *
+ * The chain runner is intentionally self-contained: no dependency on
+ * `HookRegistry`, no trust-ledger gating (project settings are already
+ * trusted by virtue of being in the workspace's `.pugi/` dir, same as
+ * persona prompts), and a single `firePostToolUseFailureChain` /
+ * `fireTaskCompletedChain` entry point per event.
+ *
+ * Brand voice: ASCII only, no emoji, no em-dashes.
+ */
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { loadSettings } from './settings.js';
+/**
+ * Per-hook matcher. Both keys are optional and AND together — a hook
+ * with `matcher: { tool: 'write' }` fires for every PostToolUseFailure
+ * whose tool is `write`, regardless of command. A hook with no matcher
+ * at all (or `matcher: {}`) fires on every event of its kind.
+ */
+const chainMatcherSchema = z
+    .object({
+    /** Compare against the failing tool name (PostToolUseFailure). */
+    tool: z.string().min(1).optional(),
+    /** Compare against the completed command name (TaskCompleted). */
+    command: z.string().min(1).optional(),
+})
+    .strict();
+/**
+ * Single chain entry. `run` is an array so chain authors can express
+ * "do A, then B, then C" without needing shell `&&` chaining — the
+ * runner executes the list sequentially.
+ *
+ * Hard-coded constants:
+ *  - Default timeout per command: 10s.
+ *  - Max timeout: 60s (matches legacy hooks.ts cap).
+ *  - Stream cap: 256KB per stream (smaller than legacy 1MB because
+ *    chain hooks are post-hoc notifications, not blocking gates).
+ */
+const chainEntrySchema = z
+    .object({
+    matcher: chainMatcherSchema.optional(),
+    run: z.array(z.string().min(1)).min(1),
+    timeoutMs: z.number().int().positive().max(60_000).optional(),
+})
+    .strict();
+/**
+ * Per-event chain config. `enabled: false` short-circuits the whole
+ * chain (opt-out switch the operator can flip without deleting the
+ * entries). `entries` defaults to empty so the operator can declare
+ * `{ enabled: false }` to suppress a chain inherited from a parent
+ * config layer later.
+ */
+const chainConfigSchema = z
+    .object({
+    enabled: z.boolean().default(true),
+    entries: z.array(chainEntrySchema).default([]),
+})
+    .strict();
+/**
+ * Settings-level `hooks` block. We accept BOTH:
+ *  1. The canonical nested form
+ *     `hooks: { PostToolUseFailure: { enabled, entries: [...] } }`
+ *  2. The shorthand array form
+ *     `hooks: { PostToolUseFailure: [...entries] }`
+ *     — which the CEO spec uses as the example. The reader normalises
+ *     it to the canonical form before handing back to callers.
+ */
+const settingsHooksShape = z
+    .object({
+    PostToolUseFailure: z
+        .union([chainConfigSchema, z.array(chainEntrySchema)])
+        .optional(),
+    TaskCompleted: z
+        .union([chainConfigSchema, z.array(chainEntrySchema)])
+        .optional(),
+})
+    .strict()
+    .optional();
+const DEFAULT_TIMEOUT_MS = 10_000;
+const SIGKILL_GRACE_MS = 2_000;
+const STREAM_CAP_BYTES = 256 * 1024;
+/**
+ * Resolve chain config from settings. Accepts both the canonical
+ * `{ enabled, entries }` shape and the shorthand array form the CEO
+ * spec example uses.
+ */
+export function resolveChain(settings, event) {
+    const rawHooks = settings.hooks;
+    const parsed = settingsHooksShape.safeParse(rawHooks);
+    if (!parsed.success || !parsed.data) {
+        return { enabled: true, entries: [] };
+    }
+    const raw = parsed.data[event];
+    if (!raw)
+        return { enabled: true, entries: [] };
+    if (Array.isArray(raw)) {
+        return { enabled: true, entries: raw };
+    }
+    return raw;
+}
+/**
+ * Parse the `hooks` section out of a raw settings JSON value. Exposed
+ * for tests and the settings reload path. Returns the normalised shape
+ * (both events present, canonical `{enabled, entries}` form) so the
+ * caller can assert structure without re-running Zod.
+ */
+export function parseHookChains(rawHooks) {
+    const parsed = settingsHooksShape.safeParse(rawHooks);
+    const out = {
+        PostToolUseFailure: { enabled: true, entries: [] },
+        TaskCompleted: { enabled: true, entries: [] },
+    };
+    if (!parsed.success || !parsed.data)
+        return out;
+    const pf = parsed.data.PostToolUseFailure;
+    if (pf) {
+        out.PostToolUseFailure = Array.isArray(pf) ? { enabled: true, entries: pf } : pf;
+    }
+    const tc = parsed.data.TaskCompleted;
+    if (tc) {
+        out.TaskCompleted = Array.isArray(tc) ? { enabled: true, entries: tc } : tc;
+    }
+    return out;
+}
+/**
+ * Decide whether a chain entry matches a `PostToolUseFailure` payload.
+ * An entry with no matcher (or only the empty object) fires on every
+ * failure of its event kind.
+ */
+function matchesPostToolUseFailure(entry, payload) {
+    const m = entry.matcher;
+    if (!m || (!m.tool && !m.command))
+        return true;
+    if (m.tool !== undefined && m.tool !== payload.toolName)
+        return false;
+    return true;
+}
+/**
+ * Decide whether a chain entry matches a `TaskCompleted` payload.
+ */
+function matchesTaskCompleted(entry, payload) {
+    const m = entry.matcher;
+    if (!m || (!m.tool && !m.command))
+        return true;
+    if (m.command !== undefined && m.command !== payload.command)
+        return false;
+    return true;
+}
+/**
+ * Fire the `PostToolUseFailure` chain. Best-effort: a hook crash, a
+ * spawn error, or a timeout never propagates back to the caller.
+ *
+ * Caller responsibility: the engine's tool-bridge invokes this AFTER
+ * the existing legacy `PostToolUseFailure` registry fire so legacy
+ * scripts and chain entries both run on the same failure (the legacy
+ * registry is the strict per-tool gate; chains are the fallback hook).
+ */
+export async function firePostToolUseFailureChain(workspaceRoot, payload, settingsOverride) {
+    const settings = settingsOverride ?? safeLoadSettings(workspaceRoot);
+    const config = resolveChain(settings, 'PostToolUseFailure');
+    if (!config.enabled) {
+        return { event: 'PostToolUseFailure', enabled: false, entries: [] };
+    }
+    const out = {
+        event: 'PostToolUseFailure',
+        enabled: true,
+        entries: [],
+    };
+    for (const entry of config.entries) {
+        const matched = matchesPostToolUseFailure(entry, payload);
+        if (!matched) {
+            out.entries.push({ matched: false, commands: [] });
+            continue;
+        }
+        const commands = await runChainEntry(entry, {
+            PUGI_HOOK_EVENT: 'PostToolUseFailure',
+            PUGI_HOOK_PAYLOAD: JSON.stringify(payload),
+            PUGI_HOOK_TOOL: payload.toolName,
+            PUGI_HOOK_EXIT_CODE: String(payload.exitCode),
+        });
+        out.entries.push({ matched: true, commands });
+    }
+    return out;
+}
+/**
+ * Fire the `TaskCompleted` chain. Same best-effort semantics as the
+ * PostToolUseFailure chain above. Caller invokes this at the dispatch
+ * exit in `native-pugi.ts` regardless of completion status (the
+ * payload carries `exitCode` so the hook can branch on success vs
+ * failure).
+ */
+export async function fireTaskCompletedChain(workspaceRoot, payload, settingsOverride) {
+    const settings = settingsOverride ?? safeLoadSettings(workspaceRoot);
+    const config = resolveChain(settings, 'TaskCompleted');
+    if (!config.enabled) {
+        return { event: 'TaskCompleted', enabled: false, entries: [] };
+    }
+    const out = {
+        event: 'TaskCompleted',
+        enabled: true,
+        entries: [],
+    };
+    for (const entry of config.entries) {
+        const matched = matchesTaskCompleted(entry, payload);
+        if (!matched) {
+            out.entries.push({ matched: false, commands: [] });
+            continue;
+        }
+        const commands = await runChainEntry(entry, {
+            PUGI_HOOK_EVENT: 'TaskCompleted',
+            PUGI_HOOK_PAYLOAD: JSON.stringify(payload),
+            PUGI_HOOK_COMMAND: payload.command,
+            PUGI_HOOK_EXIT_CODE: String(payload.exitCode),
+            PUGI_HOOK_DURATION_MS: String(payload.durationMs),
+            PUGI_HOOK_TOOL_CALLS: String(payload.toolCalls),
+        });
+        out.entries.push({ matched: true, commands });
+    }
+    return out;
+}
+/** Run every command in one chain entry sequentially. */
+async function runChainEntry(entry, baseEnv) {
+    const timeoutMs = entry.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const results = [];
+    for (const command of entry.run) {
+        try {
+            const result = await executeOne(command, timeoutMs, baseEnv);
+            results.push(result);
+        }
+        catch (error) {
+            // Spawn failure (binary missing, fork limit hit, etc). Swallow
+            // and record so the chain marches on to the next command.
+            results.push({
+                command,
+                exitCode: -1,
+                durationMs: 0,
+                stdout: '',
+                stderr: `chain spawn error: ${error.message}`,
+                timedOut: false,
+            });
+        }
+    }
+    return results;
+}
+/** Spawn ONE shell command and capture the result. */
+function executeOne(command, timeoutMs, baseEnv) {
+    return new Promise((resolvePromise) => {
+        const startedAt = Date.now();
+        const child = spawn('/bin/sh', ['-c', command], {
+            env: { ...process.env, ...baseEnv },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let killedForTimeout = false;
+        let killedForStreamCap = false;
+        let sigKillTimer;
+        const enforceStreamCap = () => {
+            if (killedForStreamCap)
+                return;
+            if (stdout.length + stderr.length <= STREAM_CAP_BYTES)
+                return;
+            killedForStreamCap = true;
+            child.kill('SIGTERM');
+            if (!sigKillTimer) {
+                sigKillTimer = setTimeout(() => {
+                    if (!child.killed)
+                        child.kill('SIGKILL');
+                }, SIGKILL_GRACE_MS);
+                if (sigKillTimer.unref)
+                    sigKillTimer.unref();
+            }
+        };
+        child.stdout?.on('data', (chunk) => {
+            if (killedForStreamCap)
+                return;
+            stdout += chunk.toString('utf8');
+            enforceStreamCap();
+        });
+        child.stderr?.on('data', (chunk) => {
+            if (killedForStreamCap)
+                return;
+            stderr += chunk.toString('utf8');
+            enforceStreamCap();
+        });
+        // Close stdin so commands that block on read (cat, jq) do not hang
+        // the chain. Errors are swallowed because the child may have
+        // already exited before we write.
+        if (child.stdin) {
+            child.stdin.on('error', () => {
+                /* ignore EPIPE */
+            });
+            child.stdin.end();
+        }
+        const timer = setTimeout(() => {
+            killedForTimeout = true;
+            child.kill('SIGTERM');
+            sigKillTimer = setTimeout(() => {
+                if (!child.killed)
+                    child.kill('SIGKILL');
+            }, SIGKILL_GRACE_MS);
+            if (sigKillTimer.unref)
+                sigKillTimer.unref();
+        }, timeoutMs);
+        if (timer.unref)
+            timer.unref();
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            if (sigKillTimer)
+                clearTimeout(sigKillTimer);
+            resolvePromise({
+                command,
+                exitCode: -1,
+                durationMs: Date.now() - startedAt,
+                stdout,
+                stderr: stderr || `hook spawn error: ${error.message}`,
+                timedOut: false,
+            });
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            if (sigKillTimer)
+                clearTimeout(sigKillTimer);
+            const durationMs = Date.now() - startedAt;
+            let exitCode;
+            if (code !== null) {
+                exitCode = code;
+            }
+            else if (signal === 'SIGTERM') {
+                exitCode = -15;
+            }
+            else if (signal === 'SIGKILL') {
+                exitCode = -9;
+            }
+            else {
+                exitCode = -1;
+            }
+            resolvePromise({
+                command,
+                exitCode,
+                durationMs,
+                stdout,
+                stderr,
+                timedOut: killedForTimeout || killedForStreamCap,
+            });
+        });
+    });
+}
+/**
+ * `loadSettings` throws on schema-invalid configs. Chains MUST NOT
+ * crash the dispatch — swallow + log to stderr so the caller proceeds
+ * with a default (no-hooks) settings object.
+ */
+function safeLoadSettings(root) {
+    try {
+        return loadSettings(root);
+    }
+    catch (error) {
+        process.stderr.write(`[pugi hook-chains] settings load failed: ${error.message}\n`);
+        // Build a minimal settings object that parses through the Zod
+        // schema. The shape is built by re-parsing an empty settings dir
+        // which `loadSettings` already does for missing files (returns
+        // the schema's default-applied object).
+        return loadSettings('/this-path-does-not-exist-fallback');
+    }
+}
+//# sourceMappingURL=hook-chains.js.map

package/dist/core/hooks/citation-verify-hook.js

@@ -0,0 +1,138 @@
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+const DEFAULT_DESTRUCTIVE_RULES = [
+    {
+        pattern: /\bgit\s+push\s+(?:--force-with-lease|--force|-f)(?=\s|$)/i,
+        kind: 'force-push',
+        label: 'git push --force',
+    },
+    {
+        pattern: /\bgit\s+push\s+origin\s+(?:main|master)(?=\s|$)/i,
+        kind: 'origin-main-push',
+        label: 'git push origin main',
+    },
+    { pattern: /\brm\s+-rf\b/i, kind: 'destructive-command', label: 'rm -rf' },
+    { pattern: /\bsudo\s+rm\b/i, kind: 'destructive-command', label: 'sudo rm' },
+    { pattern: /\bDROP\s+TABLE\b/i, kind: 'destructive-command', label: 'DROP TABLE' },
+    { pattern: /\bDROP\s+DATABASE\b/i, kind: 'destructive-command', label: 'DROP DATABASE' },
+];
+const CITATION_RE = /\[([^\[\]\s:]+):(\d+)\]/g;
+function lineColumnOf(text, index) {
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < index; i++) {
+        if (text.charCodeAt(i) === 10) {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column };
+}
+async function countLines(filePath) {
+    const data = await fs.readFile(filePath, 'utf8');
+    if (data.length === 0)
+        return 0;
+    const parts = data.split('\n');
+    if (parts[parts.length - 1] === '')
+        parts.pop();
+    return parts.length;
+}
+function withinWorkspace(workspaceRoot, candidate) {
+    if (path.isAbsolute(candidate))
+        return false;
+    const root = path.resolve(workspaceRoot);
+    const target = path.resolve(root, candidate);
+    const rel = path.relative(root, target);
+    if (rel === '')
+        return true;
+    return !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+function ensureGlobal(pattern) {
+    if (pattern.flags.includes('g'))
+        return pattern;
+    return new RegExp(pattern.source, pattern.flags + 'g');
+}
+export async function verifyOutput(text, options) {
+    const signals = [];
+    const validateCitations = options.validateCitations !== false;
+    if (validateCitations) {
+        const citations = [];
+        for (const m of text.matchAll(CITATION_RE)) {
+            if (m.index === undefined)
+                continue;
+            citations.push({
+                raw: m[0],
+                filePath: m[1],
+                line: Number(m[2]),
+                index: m.index,
+            });
+        }
+        const invalidSignals = [];
+        for (const c of citations) {
+            const loc = lineColumnOf(text, c.index);
+            if (!withinWorkspace(options.workspaceRoot, c.filePath)) {
+                invalidSignals.push({
+                    kind: 'invalid-citation',
+                    detail: `${c.raw} resolves outside workspace`,
+                    location: loc,
+                    severity: 'warn',
+                });
+                continue;
+            }
+            const abs = path.resolve(options.workspaceRoot, c.filePath);
+            let lineCount;
+            try {
+                lineCount = await countLines(abs);
+            }
+            catch {
+                invalidSignals.push({
+                    kind: 'invalid-citation',
+                    detail: `${c.raw} file not found`,
+                    location: loc,
+                    severity: 'warn',
+                });
+                continue;
+            }
+            if (c.line < 1 || c.line > lineCount) {
+                invalidSignals.push({
+                    kind: 'invalid-citation',
+                    detail: `${c.raw} line ${c.line} out of range (file has ${lineCount} lines)`,
+                    location: loc,
+                    severity: 'warn',
+                });
+            }
+        }
+        if (citations.length > 0 && invalidSignals.length === citations.length) {
+            for (const s of invalidSignals)
+                s.severity = 'block';
+        }
+        signals.push(...invalidSignals);
+    }
+    const rules = options.allowedDestructivePatterns
+        ? options.allowedDestructivePatterns.map((p) => ({
+            pattern: p,
+            kind: 'destructive-command',
+            label: p.source,
+        }))
+        : DEFAULT_DESTRUCTIVE_RULES;
+    for (const rule of rules) {
+        const re = ensureGlobal(rule.pattern);
+        for (const m of text.matchAll(re)) {
+            if (m.index === undefined)
+                continue;
+            const loc = lineColumnOf(text, m.index);
+            signals.push({
+                kind: rule.kind,
+                detail: `${rule.label}: ${m[0]}`,
+                location: loc,
+                severity: 'block',
+            });
+        }
+    }
+    const allowed = !signals.some((s) => s.severity === 'block');
+    return { allowed, signals };
+}
+//# sourceMappingURL=citation-verify-hook.js.map

package/dist/core/hooks/citation-verify.js

@@ -0,0 +1,112 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+const CITATION_REGEX = /\[([^\]\s]+\.[a-zA-Z0-9]+):(\d+)(?:-(\d+))?(?:#([\w]+))?\]/g;
+/**
+ * Parses citation-like strings from a block of text.
+ * @param text The text to parse.
+ * @returns An array of parsed CitationCheck objects.
+ */
+export function parseCitations(text) {
+    const matches = text.matchAll(CITATION_REGEX);
+    const citations = [];
+    for (const match of matches) {
+        const raw = match[0];
+        const path = match[1];
+        const lineStart = match[2];
+        const lineEnd = match[3];
+        const symbol = match[4];
+        if (!path || !lineStart)
+            continue;
+        citations.push({
+            raw,
+            path,
+            lineStart: parseInt(lineStart, 10),
+            lineEnd: lineEnd ? parseInt(lineEnd, 10) : undefined,
+            symbol: symbol || undefined,
+            status: 'valid',
+        });
+    }
+    return citations;
+}
+/**
+ * Parses citations from text and validates them against the filesystem.
+ * @param text The text containing citations.
+ * @param repoRoot The absolute path to the root of the repository.
+ * @returns A promise that resolves to an object containing valid and invalid citations,
+ *         and the original text with all citation markers removed.
+ */
+export async function validateCitations(text, repoRoot) {
+    const citations = parseCitations(text);
+    const valid = [];
+    const invalid = [];
+    for (const citation of citations) {
+        const fullPath = path.join(repoRoot, citation.path);
+        let fileContent;
+        try {
+            await fs.stat(fullPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                citation.status = 'file_missing';
+                invalid.push(citation);
+                continue;
+            }
+            // Re-throw other errors
+            throw error;
+        }
+        try {
+            fileContent = await fs.readFile(fullPath, 'utf-8');
+        }
+        catch (e) {
+            citation.status = 'file_missing';
+            invalid.push(citation);
+            continue;
+        }
+        const lines = fileContent.split('\n');
+        const maxLines = lines.length;
+        if (citation.lineStart <= 0 || citation.lineStart > maxLines) {
+            citation.status = 'line_out_of_range';
+            invalid.push(citation);
+            continue;
+        }
+        if (citation.lineEnd && (citation.lineEnd > maxLines || citation.lineEnd < citation.lineStart)) {
+            citation.status = 'line_out_of_range';
+            invalid.push(citation);
+            continue;
+        }
+        // Symbol validation is not implemented in this version.
+        // We can add it here if needed by parsing the file content (e.g. with AST).
+        if (citation.symbol) {
+            citation.status = 'symbol_not_found'; // Placeholder for future implementation
+        }
+        // If we are here, file exists and line numbers are in range.
+        citation.status = 'valid';
+        valid.push(citation);
+    }
+    const cleaned = text.replace(CITATION_REGEX, '').trim();
+    return { valid, invalid, cleaned };
+}
+/**
+ * Checks if a given command string is potentially destructive.
+ * This is a safeguard and not exhaustive.
+ * @param cmd The command string to check.
+ * @returns An object indicating if the command is dangerous and why.
+ */
+export function isDestructiveGitCommand(cmd) {
+    const checks = [
+        { re: /\bgit\s+push\s+(--force|-f)\b/, reason: '`git push --force` can overwrite remote history.' },
+        { re: /\bgit\s+push\s+.*--force-with-lease.*\s(main|master)\b/, reason: '`git push --force-with-lease` on a main branch is risky.' },
+        { re: /\bgit\s+reset\s+--hard\b/, reason: '`git reset --hard` discards all local changes and commits.' },
+        { re: /\bgit\s+clean\s+-[dfx]+/, reason: '`git clean -fd` permanently deletes untracked files and directories.' },
+        { re: /\brm\s+-rf\b/, reason: '`rm -rf` can recursively delete files and directories forcefully.' },
+        { re: /\bDROP\s+DATABASE\b/i, reason: '`DROP DATABASE` permanently deletes an entire database.' },
+        { re: /\bDROP\s+TABLE\b/i, reason: '`DROP TABLE` permanently deletes a table.' },
+    ];
+    for (const check of checks) {
+        if (check.re.test(cmd)) {
+            return { dangerous: true, reason: check.reason };
+        }
+    }
+    return { dangerous: false };
+}
+//# sourceMappingURL=citation-verify.js.map

package/dist/core/hooks/events.js

@@ -0,0 +1,46 @@
+/**
+ * Pugi hooks MVP — typed event payloads ().
+ *
+ * This module ships the MINIMAL FIRST PASS of the user-config hook
+ * matrix. Two lifecycle events out of the eventual 8 land here:
+ *
+ *  - `SessionStart` — fired once when the REPL boots (`session.ts`).
+ *  - `PreToolUse`   — fired before each tool dispatch
+ *                      (`engine/tool-bridge.ts`). Non-zero exit from a
+ *                      hook with `blocking: true` aborts the dispatch.
+ *
+ * The remaining 6 events (`PostToolUse`, `UserPromptSubmit`, `Stop`,
+ * `SubagentStop`, `PreCompact`, `Notification`) are deferred to a
+ * fast-follow PR. The pattern established here — discriminated union
+ * payloads + registry-driven dispatch — is the reusable template.
+ *
+ * Design note (parallel surface): an older surface lives at
+ * `apps/pugi-cli/src/core/hooks.ts` and uses a flat-array `hooks: [{
+ * event, match, run }]` config shape with per-hook events. THIS module
+ * adopts the the upstream tool-style nested `hooks: { EventName: [{ matcher,
+ * command }] }` config shape. The two surfaces co-exist intentionally
+ * for the MVP — they read different files (`~/.pugi/hooks.json` vs.
+ * `~/.pugi/hooks-mvp.json`) so operator configs do not collide. The
+ * fast-follow PR consolidates the two readers.
+ *
+ * Brand voice: ASCII only, no emoji, no em-dashes, no marketing prose.
+ */
+/** Events the MVP actually fires. The remaining events live in the */
+/** type but no integration point emits them yet. */
+export const MVP_HOOK_EVENTS = [
+    'SessionStart',
+    'PreToolUse',
+];
+export const ALL_HOOK_EVENTS_V2 = [
+    'SessionStart',
+    'PreToolUse',
+    'PostToolUse',
+    'UserPromptSubmit',
+    'Stop',
+    'SubagentStop',
+    'PreCompact',
+    'Notification',
+    'WorktreeCreate',
+    'WorktreeRemove',
+];
+//# sourceMappingURL=events.js.map