@pugi/cli 0.1.0-beta.98 → 1.0.0-alpha.1

package/dist/core/hook-chains.js

@@ -1,392 +0,0 @@
-/**
- * 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

@@ -1,138 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,46 +0,0 @@
-/**
- * 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