@nexrall/code-core 1.4.71 → 1.4.73

package/dist/agent/hooks.js

@@ -85,7 +85,9 @@ function loadHooks(workDir) {
         if (fs.existsSync(p))
             fromSettings = JSON.parse(fs.readFileSync(p, 'utf-8')).hooks ?? {};
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     // `--settings`: hooks from the run's own settings object run after the project's.
     const sess = (0, rules_1.getSessionSettings)()?.hooks;
     if (sess && typeof sess === 'object') {
@@ -103,10 +105,7 @@ function loadHooks(workDir) {
         const extra = fromPlugins[phase];
         if (!Array.isArray(extra) || !extra.length)
             continue;
-        merged[phase] = [
-            ...((merged[phase]) ?? []),
-            ...extra,
-        ];
+        merged[phase] = [...(merged[phase] ?? []), ...extra];
     }
     // One normalising pass over every entry-list phase, whatever source it came from.
     for (const phase of ENTRY_LIST_PHASES) {
@@ -119,13 +118,34 @@ function loadHooks(workDir) {
 }
 /** The phases whose value is an array of ENTRIES (each carrying a matcher + handlers). */
 const ENTRY_LIST_PHASES = [
-    'PreToolUse', 'PostToolUse', 'SessionStart', 'UserPromptSubmit', 'PreCompact',
-    'PermissionRequest', 'Notification', 'PostToolUseFailure', 'SubagentStart',
-    'PostCompact', 'SessionEnd', 'FileChanged', 'InstructionsLoaded', 'StopFailure',
-    'PermissionDenied', 'PreModelSwitch', 'PostModelSwitch', 'CwdChanged', 'DirectoryAdded',
-    'ConfigChange', 'WorktreeCreate', 'WorktreeRemove', 'Setup',
-    'PostToolBatch', 'TaskCreated', 'TaskCompleted',
-    'Elicitation', 'ElicitationResult',
+    'PreToolUse',
+    'PostToolUse',
+    'SessionStart',
+    'UserPromptSubmit',
+    'PreCompact',
+    'PermissionRequest',
+    'Notification',
+    'PostToolUseFailure',
+    'SubagentStart',
+    'PostCompact',
+    'SessionEnd',
+    'FileChanged',
+    'InstructionsLoaded',
+    'StopFailure',
+    'PermissionDenied',
+    'PreModelSwitch',
+    'PostModelSwitch',
+    'CwdChanged',
+    'DirectoryAdded',
+    'ConfigChange',
+    'WorktreeCreate',
+    'WorktreeRemove',
+    'Setup',
+    'PostToolBatch',
+    'TaskCreated',
+    'TaskCompleted',
+    'Elicitation',
+    'ElicitationResult',
 ];
 /**
  * Accept BOTH config shapes for the same list, so a hook can never be silently dropped:
@@ -159,11 +179,17 @@ const _hookDeliveries = [];
 let _hookWakeListener = null;
 let _hookStatusListener = null;
 /** Called (if set) the moment a wake lands, so an idle host can react at once. */
-function setHookWakeListener(fn) { _hookWakeListener = fn; }
+function setHookWakeListener(fn) {
+    _hookWakeListener = fn;
+}
 /** Where `statusMessage` goes. The message is null when no hook is running. */
-function setHookStatusListener(fn) { _hookStatusListener = fn; }
+function setHookStatusListener(fn) {
+    _hookStatusListener = fn;
+}
 /** Everything queued so far — the loop calls this before each request. */
-function drainHookDeliveries() { return _hookDeliveries.splice(0); }
+function drainHookDeliveries() {
+    return _hookDeliveries.splice(0);
+}
 /** Only the wakes — an idle host must not start a turn just for async context. */
 function takeHookWakes() {
     const out = _hookDeliveries.filter((d) => d.kind === 'wake');
@@ -172,7 +198,9 @@ function takeHookWakes() {
             _hookDeliveries.splice(i, 1);
     return out;
 }
-function hasPendingHookWake() { return _hookDeliveries.some((d) => d.kind === 'wake'); }
+function hasPendingHookWake() {
+    return _hookDeliveries.some((d) => d.kind === 'wake');
+}
 /** The text a delivery batch becomes in the conversation — the same envelope sync hooks use. */
 function formatHookDeliveries(list) {
     return list.map((d) => `<hook-context source="${d.source}">\n${d.text}\n</hook-context>`).join('\n\n');
@@ -189,7 +217,9 @@ function hookIdentity(event, hook, matcher, dir) {
     return `${dir ?? ''}|${event}|${matcher ?? ''}|${hook.plugin ?? ''}|${body}`;
 }
 /** Forget which `once` hooks have run (a new session: /clear, a fresh run). */
-function resetHookOnceState() { _hookOnceDone.clear(); }
+function resetHookOnceState() {
+    _hookOnceDone.clear();
+}
 // While any hook with a statusMessage is running the UI shows the NEWEST of those
 // messages — null once they all finish. Ref-counted because parallel sub-agents run
 // hooks concurrently, and "the first hook to finish" must not clear the label of one
@@ -213,22 +243,30 @@ function hookStatusEnd(id) {
 }
 let _hookMcpCaller = null;
 /** Hosts with connected MCP servers register their caller once; null = mcp_tool hooks report "no MCP client". */
-function setHookMcpCaller(fn) { _hookMcpCaller = fn; }
+function setHookMcpCaller(fn) {
+    _hookMcpCaller = fn;
+}
 let _hookEventListener = null;
 /**
  * Install (or clear) the sink that receives every hook run's lifecycle records.
  * One per process: hooks fire from the loop, the lifecycle host and the permission
  * gate, but they all belong to the same session's stream.
  */
-function setHookEventListener(fn) { _hookEventListener = fn; }
+function setHookEventListener(fn) {
+    _hookEventListener = fn;
+}
 /** True when a sink is installed, for hosts skipping work that would only feed the stream. */
-function hasHookEventListener() { return _hookEventListener !== null; }
+function hasHookEventListener() {
+    return _hookEventListener !== null;
+}
 let _hookIdSeq = 0;
 function emitHookLifecycle(evt) {
     try {
         _hookEventListener?.(evt);
     }
-    catch { /* the host's listener must not break the hook */ }
+    catch {
+        /* the host's listener must not break the hook */
+    }
 }
 /** The stream's hook_name: what the handler IS, in the config author's terms. */
 function hookDisplayName(hook) {
@@ -276,7 +314,15 @@ async function runWithHookEvents(hook, event, run) {
         pendingOut = '';
         pendingErr = '';
         lastFlush = Date.now();
-        emitHookLifecycle({ kind: 'progress', hookId, hookName, hookEvent: event, stdout, stderr, output: stdout + stderr });
+        emitHookLifecycle({
+            kind: 'progress',
+            hookId,
+            hookName,
+            hookEvent: event,
+            stdout,
+            stderr,
+            output: stdout + stderr,
+        });
     };
     const onData = (d) => {
         if (Date.now() - startedAt < HOOK_PROGRESS_AFTER_MS)
@@ -301,7 +347,16 @@ async function runWithHookEvents(hook, event, run) {
         if (flushTimer)
             clearTimeout(flushTimer);
         const message = err?.message ?? String(err);
-        emitHookLifecycle({ kind: 'response', hookId, hookName, hookEvent: event, stdout: '', stderr: message, output: message, outcome: 'error' });
+        emitHookLifecycle({
+            kind: 'response',
+            hookId,
+            hookName,
+            hookEvent: event,
+            stdout: '',
+            stderr: message,
+            output: message,
+            outcome: 'error',
+        });
         throw err;
     }
     if (flushTimer)
@@ -349,11 +404,17 @@ function startBackgroundHook(hook, payload, opts) {
         const out = (r.stdout ?? '').toString().trim();
         if (hook.asyncRewake && r.status === 2) {
             const text = (r.stderr ?? '').toString().trim() || out;
-            _hookDeliveries.push({ kind: 'wake', text: text || 'Hook asked the session to wake (exit 2).', source: opts.eventLabel });
+            _hookDeliveries.push({
+                kind: 'wake',
+                text: text || 'Hook asked the session to wake (exit 2).',
+                source: opts.eventLabel,
+            });
             try {
                 _hookWakeListener?.();
             }
-            catch { /* the host's listener must not break the hook */ }
+            catch {
+                /* the host's listener must not break the hook */
+            }
             return;
         }
         const context = directiveContext(out);
@@ -362,8 +423,12 @@ function startBackgroundHook(hook, payload, opts) {
     };
     // Through runHookHandler, not spawnHook directly: background runs get the same
     // start/finish lifecycle records, and command dispatch stays in one place.
-    void runHookHandler(hook, payload, { cwd: opts.cwd, timeoutMs: opts.timeoutMs, env: opts.env, event: opts.event })
-        .then(done, () => done({ status: null, stdout: '', stderr: '' }));
+    void runHookHandler(hook, payload, {
+        cwd: opts.cwd,
+        timeoutMs: opts.timeoutMs,
+        env: opts.env,
+        event: opts.event,
+    }).then(done, () => done({ status: null, stdout: '', stderr: '' }));
 }
 /** additionalContext + systemMessage from a background hook's JSON stdout — both go to the model. */
 function directiveContext(out) {
@@ -410,7 +475,12 @@ function spawnHook(command, opts) {
         };
         let child;
         try {
-            child = (0, child_process_1.spawn)(command, { shell: true, cwd: opts.cwd, env: opts.env ?? process.env, stdio: ['pipe', 'pipe', 'pipe'] });
+            child = (0, child_process_1.spawn)(command, {
+                shell: true,
+                cwd: opts.cwd,
+                env: opts.env ?? process.env,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
         }
         catch {
             resolve({ status: null, stdout: '', stderr: '' });
@@ -419,10 +489,17 @@ function spawnHook(command, opts) {
         // timeout === null = no timer at all: plain `async` hooks are not bounded
         // (Claude Code enforces no timeout on them), and a clamped setTimeout would
         // fire immediately and kill the hook instead of never firing.
-        const timer = opts.timeout === null ? null : setTimeout(() => { try {
-            child.kill('SIGTERM');
-        }
-        catch { /* gone */ } done(null); }, opts.timeout);
+        const timer = opts.timeout === null
+            ? null
+            : setTimeout(() => {
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch {
+                    /* gone */
+                }
+                done(null);
+            }, opts.timeout);
         const cap = 16 * 1024 * 1024;
         // `onData` is how `--include-hook-events` sees a long hook's output as it
         // arrives; without such a listener it is undefined and costs one check.
@@ -440,7 +517,9 @@ function spawnHook(command, opts) {
         });
         child.on('error', () => done(null));
         child.on('close', (code) => done(code));
-        child.stdin?.on('error', () => { });
+        child.stdin?.on('error', () => {
+            /* hook ignored stdin */
+        });
         child.stdin?.end(opts.input ?? '');
     });
 }
@@ -463,7 +542,7 @@ async function httpHook(hook, payload, timeoutMs) {
     for (const [k, v] of Object.entries(hook.headers ?? {})) {
         // Unlisted variables expand to nothing rather than leaking the whole environment
         // into a request header.
-        headers[k] = String(v).replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_m, a1, a2) => (allowed.has(a1 ?? a2) ? (process.env[a1 ?? a2] ?? '') : ''));
+        headers[k] = String(v).replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_m, a1, a2) => allowed.has(a1 ?? a2) ? (process.env[a1 ?? a2] ?? '') : '');
     }
     try {
         const res = await fetch(url, { method: 'POST', headers, body: payload, signal: AbortSignal.timeout(timeoutMs) });
@@ -526,7 +605,9 @@ function mcpHookInput(input, payload) {
         if (j && typeof j === 'object' && !Array.isArray(j))
             root = j;
     }
-    catch { /* non-JSON payload: nothing to substitute from */ }
+    catch {
+        /* non-JSON payload: nothing to substitute from */
+    }
     const nav = (parts) => {
         let cur = root;
         for (const p of parts) {
@@ -537,7 +618,10 @@ function mcpHookInput(input, payload) {
         return cur;
     };
     const lookup = (path) => {
-        const parts = path.split('.').map((s) => s.trim()).filter(Boolean);
+        const parts = path
+            .split('.')
+            .map((s) => s.trim())
+            .filter(Boolean);
         if (!parts.length)
             return undefined;
         const candidates = [parts];
@@ -591,7 +675,13 @@ async function runHookHandler(hook, payload, opts) {
         if (hook.type === 'prompt' || hook.type === 'agent') {
             return promptHook(hook, payload, { ...opts, timeoutMs: opts.timeoutMs ?? 60000, envCtx: opts.hookEnv });
         }
-        return spawnHook(String(hook.command ?? ''), { cwd: opts.cwd, timeout: opts.timeoutMs, input: payload, env, onData });
+        return spawnHook(String(hook.command ?? ''), {
+            cwd: opts.cwd,
+            timeout: opts.timeoutMs,
+            input: payload,
+            env,
+            onData,
+        });
     });
 }
 // ─── Prompt / agent hooks ──────────────────────────────────────────────────────
@@ -646,7 +736,11 @@ const HOOK_AGENT_TOOLS = [
     {
         name: 'glob',
         description: 'Find files matching a glob pattern, e.g. "**/*.ts".',
-        input_schema: { type: 'object', properties: { pattern: { type: 'string' }, path: { type: 'string' } }, required: ['pattern'] },
+        input_schema: {
+            type: 'object',
+            properties: { pattern: { type: 'string' }, path: { type: 'string' } },
+            required: ['pattern'],
+        },
     },
 ];
 /** A model name that cannot exist — the allowlist filter then sends NO tools at all. */
@@ -674,7 +768,7 @@ function parsePromptHookReply(reply) {
     }
 }
 const PROMPT_HOOK_RULES = 'You are a hook evaluator for a coding agent. The hook input JSON is given below, followed by ' +
-    'the hook\'s own instruction. Decide whether the agent action described in the input should ' +
+    "the hook's own instruction. Decide whether the agent action described in the input should " +
     'proceed. Reply with ONLY one JSON object and nothing else: {"ok":true} to allow, or ' +
     '{"ok":false,"reason":"short explanation"} to block.';
 async function promptHook(hook, payload, opts) {
@@ -682,15 +776,22 @@ async function promptHook(hook, payload, opts) {
     if (!instruction)
         return { status: 1, stdout: '', stderr: 'prompt hook has no "prompt"' };
     // `\$ARGUMENTS` escapes the substitution (Claude Code's own rule).
-    // eslint-disable-next-line no-control-regex -- U+0001 sentinel protects a literal $ARGUMENTS from being substituted twice
-    const body = instruction.replace(/\\\$ARGUMENTS/g, '\u0001').replace(/\$ARGUMENTS/g, payload).replace(/\u0001/g, '$ARGUMENTS');
+    const body = instruction
+        .replace(/\\\$ARGUMENTS/g, '\u0001')
+        .replace(/\$ARGUMENTS/g, payload)
+        // eslint-disable-next-line no-control-regex -- U+0001 sentinel protects a literal $ARGUMENTS from being substituted twice
+        .replace(/\u0001/g, '$ARGUMENTS');
     // Abort bridge: streamChat polls a plain {aborted} object, and a hook must never hang
     // the turn — the timer flips it at the hook's own timeout, the outer signal aborts too.
     const ctl = { aborted: false };
-    const timer = setTimeout(() => { ctl.aborted = true; }, Math.max(1000, opts.timeoutMs));
+    const timer = setTimeout(() => {
+        ctl.aborted = true;
+    }, Math.max(1000, opts.timeoutMs));
     const outerPoll = opts.abortSignal
-        ? setInterval(() => { if (opts.abortSignal?.aborted)
-            ctl.aborted = true; }, 100)
+        ? setInterval(() => {
+            if (opts.abortSignal?.aborted)
+                ctl.aborted = true;
+        }, 100)
         : undefined;
     if (opts.abortSignal?.aborted) {
         clearTimeout(timer);
@@ -707,10 +808,17 @@ async function promptHook(hook, payload, opts) {
             clearInterval(outerPoll);
     }
     async function runModel() {
-        const messages = [{
+        const messages = [
+            {
                 role: 'user',
-                content: [{ type: 'text', text: `${PROMPT_HOOK_RULES}\n\nHook input:\n${payload}\n\nHook instruction:\n${body}` }],
-            }];
+                content: [
+                    {
+                        type: 'text',
+                        text: `${PROMPT_HOOK_RULES}\n\nHook input:\n${payload}\n\nHook instruction:\n${body}`,
+                    },
+                ],
+            },
+        ];
         const isAgent = hook.type === 'agent';
         try {
             let replyText = '';
@@ -724,11 +832,18 @@ async function promptHook(hook, payload, opts) {
                     // read-only tools and a prompt hook sees none (the marker matches nothing).
                     toolAllowlist: isAgent ? HOOK_AGENT_TOOLS.map((t) => t.name) : [NO_TOOLS_MARKER],
                     extraTools: isAgent ? HOOK_AGENT_TOOLS : undefined,
-                }, () => { });
-                const blocks = Array.isArray(msg.content) ? msg.content : [];
+                }, () => {
+                    /* streaming not needed; the final message carries the text */
+                });
+                const blocks = Array.isArray(msg.content)
+                    ? msg.content
+                    : [];
                 const toolUses = blocks.filter((b) => b.type === 'tool_use');
                 if (!toolUses.length || !isAgent) {
-                    replyText = blocks.filter((b) => b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n');
+                    replyText = blocks
+                        .filter((b) => b.type === 'text' && typeof b.text === 'string')
+                        .map((b) => b.text)
+                        .join('\n');
                     break;
                 }
                 // Run the read-only tool round and feed the results back.
@@ -739,7 +854,9 @@ async function promptHook(hook, payload, opts) {
                     try {
                         out = getHookToolExecutors().includes(String(tu.name))
                             ? await (0, executor_1.executeTool)(String(tu.name), tu.input ?? {}, ctl, undefined, opts.cwd)
-                            : { error: `Tool ${String(tu.name)} is not available to a hook — only ${getHookToolExecutors().join(', ')}.` };
+                            : {
+                                error: `Tool ${String(tu.name)} is not available to a hook — only ${getHookToolExecutors().join(', ')}.`,
+                            };
                     }
                     catch (err) {
                         out = { error: err.message || 'tool failed' };
@@ -747,7 +864,11 @@ async function promptHook(hook, payload, opts) {
                     results.push({
                         type: 'tool_result',
                         tool_use_id: String(tu.id),
-                        content: out.error ? (out.output ? `Error: ${out.error}\n\n${out.output}` : `Error: ${out.error}`) : (out.output ?? ''),
+                        content: out.error
+                            ? out.output
+                                ? `Error: ${out.error}\n\n${out.output}`
+                                : `Error: ${out.error}`
+                            : (out.output ?? ''),
                         is_error: out.error !== undefined,
                     });
                 }
@@ -763,7 +884,9 @@ async function promptHook(hook, payload, opts) {
             if (decided)
                 return { status: 2, stdout: '', stderr: parsed.reason || `Blocked by ${hook.type} hook` };
             // Allow — carry additionalContext through the same JSON channel callers parse.
-            const passthrough = parsed.additionalContext ? JSON.stringify({ additionalContext: parsed.additionalContext }) : '';
+            const passthrough = parsed.additionalContext
+                ? JSON.stringify({ additionalContext: parsed.additionalContext })
+                : '';
             return { status: 0, stdout: passthrough, stderr: '' };
         }
         catch (err) {
@@ -842,7 +965,11 @@ function hookTimeoutMs(hook, fallbackMs = 60000) {
 function hookMatches(matcher, toolName) {
     if (!matcher || matcher === '*')
         return true;
-    return matcher.split('|').map((m) => m.trim()).filter(Boolean).some((alt) => {
+    return matcher
+        .split('|')
+        .map((m) => m.trim())
+        .filter(Boolean)
+        .some((alt) => {
         const norm = (0, agentTypes_1.normaliseToolName)(alt);
         return norm === toolName || (norm === alt && toolName.includes(alt));
     });
@@ -914,7 +1041,9 @@ async function runToolHooks(entries, phase, toolName, input, workDir, result, ho
                         outcome.context = (outcome.context ? outcome.context + '\n' : '') + j.additionalContext;
                     }
                 }
-                catch { /* not a directive — ignore */ }
+                catch {
+                    /* not a directive — ignore */
+                }
             }
             // Exit code 2 → hard block; stderr is the reason fed back to the model
             if (r.status === 2) {
@@ -941,10 +1070,23 @@ async function runSimpleHooks(defs, workDir, extraEnv, hookOpts, event = 'hook')
         if (gate.skip)
             continue;
         if (gate.background) {
-            startBackgroundHook(hook, '', { cwd: workDir, env, eventLabel: event, event, timeoutMs: hook.asyncRewake ? hookTimeoutMs(hook, 10000) : null, key: gate.key });
+            startBackgroundHook(hook, '', {
+                cwd: workDir,
+                env,
+                eventLabel: event,
+                event,
+                timeoutMs: hook.asyncRewake ? hookTimeoutMs(hook, 10000) : null,
+                key: gate.key,
+            });
             continue;
         }
-        const r = await runHookHandler(hook, '', { cwd: workDir, timeoutMs: hookTimeoutMs(hook, 10000), env, event, ...hookOpts });
+        const r = await runHookHandler(hook, '', {
+            cwd: workDir,
+            timeoutMs: hookTimeoutMs(hook, 10000),
+            env,
+            event,
+            ...hookOpts,
+        });
         if (gate.statusId !== undefined)
             hookStatusEnd(gate.statusId);
         if (r.status === 0 && gate.key)
@@ -964,7 +1106,13 @@ function flattenHookDefs(items, matchValue) {
             const m = it.matcher;
             // For these events the matcher (if any) selects on a plain value (e.g. the compact
             // trigger "auto"/"manual"); empty or "*" matches all.
-            if (m && m !== '*' && matchValue !== undefined && !m.split('|').map((x) => x.trim()).includes(matchValue))
+            if (m &&
+                m !== '*' &&
+                matchValue !== undefined &&
+                !m
+                    .split('|')
+                    .map((x) => x.trim())
+                    .includes(matchValue))
                 continue;
             out.push(...it.hooks);
         }
@@ -1013,19 +1161,30 @@ async function runLifecycleHooks(items, event, workDir, payload, matchValue, hoo
             continue;
         }
         const timeout = hookTimeoutMs(hook, hook.type === 'agent' ? 60000 : hook.type === 'prompt' ? 30000 : 30000);
-        const r = await runHookHandler(hook, input, { cwd: workDir, timeoutMs: timeout, env: { ...process.env, NEXRALL_HOOK_PHASE: event }, event, ...hookOpts });
+        const r = await runHookHandler(hook, input, {
+            cwd: workDir,
+            timeoutMs: timeout,
+            env: { ...process.env, NEXRALL_HOOK_PHASE: event },
+            event,
+            ...hookOpts,
+        });
         const out = (r.stdout ?? '').toString().trim();
         if (out.startsWith('{')) {
             try {
                 const j = JSON.parse(out);
                 // PermissionRequest answers, in nex's flat form or Claude Code's hookSpecificOutput form.
                 if (event === 'PermissionRequest') {
-                    const d = j.hookSpecificOutput?.decision?.behavior ?? (typeof j.decision === 'string' ? j.decision : j.decision?.behavior);
+                    const d = j.hookSpecificOutput?.decision?.behavior ??
+                        (typeof j.decision === 'string' ? j.decision : j.decision?.behavior);
                     if (d === 'allow' || d === 'approve')
                         outcome.allow = true;
                     else if (d === 'deny' || d === 'block') {
                         outcome.block = true;
-                        outcome.reason = j.reason ?? j.hookSpecificOutput?.decision?.message ?? outcome.reason ?? 'Denied by PermissionRequest hook';
+                        outcome.reason =
+                            j.reason ??
+                                j.hookSpecificOutput?.decision?.message ??
+                                outcome.reason ??
+                                'Denied by PermissionRequest hook';
                     }
                 }
                 if (j.decision === 'block') {
@@ -1040,7 +1199,9 @@ async function runLifecycleHooks(items, event, workDir, payload, matchValue, hoo
                 if (typeof j.systemMessage === 'string' && j.systemMessage)
                     outcome.systemMessage = j.systemMessage;
             }
-            catch { /* not a directive */ }
+            catch {
+                /* not a directive */
+            }
         }
         else if (out && (event === 'SessionStart' || event === 'UserPromptSubmit') && r.status === 0) {
             // Claude Code parity: plain stdout from these two events is added as context.
@@ -1074,7 +1235,9 @@ async function runPermissionRequestHooks(workDir, tool, input, sessionId = '') {
         if (o.allow)
             return { answer: 'allow' };
     }
-    catch { /* a hook must never break the prompt */ }
+    catch {
+        /* a hook must never break the prompt */
+    }
     return { answer: null };
 }
 /** `hookSpecificOutput:{action,content}` (Claude Code's shape) or the flat form; null = no answer. */
@@ -1110,7 +1273,13 @@ async function runElicitationHooks(workDir, server, input, sessionId = '') {
         const defs = flattenHookDefs(items, server);
         if (!defs.length)
             return null;
-        const payload = JSON.stringify({ session_id: sessionId, cwd: workDir, hook_event_name: 'Elicitation', mcp_server_name: server, ...input });
+        const payload = JSON.stringify({
+            session_id: sessionId,
+            cwd: workDir,
+            hook_event_name: 'Elicitation',
+            mcp_server_name: server,
+            ...input,
+        });
         for (const hook of defs) {
             if (!isRunnableHook(hook))
                 continue;
@@ -1118,10 +1287,22 @@ async function runElicitationHooks(workDir, server, input, sessionId = '') {
             if (gate.skip)
                 continue;
             if (gate.background) {
-                startBackgroundHook(hook, payload, { cwd: workDir, env: { ...process.env, NEXRALL_HOOK_PHASE: 'Elicitation' }, eventLabel: 'Elicitation', event: 'Elicitation', timeoutMs: hook.asyncRewake ? hookTimeoutMs(hook, 60000) : null, key: gate.key });
+                startBackgroundHook(hook, payload, {
+                    cwd: workDir,
+                    env: { ...process.env, NEXRALL_HOOK_PHASE: 'Elicitation' },
+                    eventLabel: 'Elicitation',
+                    event: 'Elicitation',
+                    timeoutMs: hook.asyncRewake ? hookTimeoutMs(hook, 60000) : null,
+                    key: gate.key,
+                });
                 continue;
             }
-            const r = await runHookHandler(hook, payload, { cwd: workDir, timeoutMs: hookTimeoutMs(hook, 30000), env: { ...process.env, NEXRALL_HOOK_PHASE: 'Elicitation' }, event: 'Elicitation' });
+            const r = await runHookHandler(hook, payload, {
+                cwd: workDir,
+                timeoutMs: hookTimeoutMs(hook, 30000),
+                env: { ...process.env, NEXRALL_HOOK_PHASE: 'Elicitation' },
+                event: 'Elicitation',
+            });
             if (gate.statusId !== undefined)
                 hookStatusEnd(gate.statusId);
             if (r.status === 0 && gate.key)
@@ -1133,7 +1314,9 @@ async function runElicitationHooks(workDir, server, input, sessionId = '') {
                 return answer;
         }
     }
-    catch { /* a hook must never break elicitation */ }
+    catch {
+        /* a hook must never break elicitation */
+    }
     return null;
 }
 /**
@@ -1157,14 +1340,32 @@ async function runElicitationResultHooks(workDir, server, answer, meta = {}) {
             if (gate.skip)
                 continue;
             const payload = JSON.stringify({
-                session_id: meta.sessionId ?? '', cwd: workDir, hook_event_name: 'ElicitationResult', mcp_server_name: server,
-                action: current.action, content: current.content, mode: meta.mode, elicitation_id: meta.elicitationId,
+                session_id: meta.sessionId ?? '',
+                cwd: workDir,
+                hook_event_name: 'ElicitationResult',
+                mcp_server_name: server,
+                action: current.action,
+                content: current.content,
+                mode: meta.mode,
+                elicitation_id: meta.elicitationId,
             });
             if (gate.background) {
-                startBackgroundHook(hook, payload, { cwd: workDir, env: { ...process.env, NEXRALL_HOOK_PHASE: 'ElicitationResult' }, eventLabel: 'ElicitationResult', event: 'ElicitationResult', timeoutMs: hook.asyncRewake ? hookTimeoutMs(hook, 60000) : null, key: gate.key });
+                startBackgroundHook(hook, payload, {
+                    cwd: workDir,
+                    env: { ...process.env, NEXRALL_HOOK_PHASE: 'ElicitationResult' },
+                    eventLabel: 'ElicitationResult',
+                    event: 'ElicitationResult',
+                    timeoutMs: hook.asyncRewake ? hookTimeoutMs(hook, 60000) : null,
+                    key: gate.key,
+                });
                 continue;
             }
-            const r = await runHookHandler(hook, payload, { cwd: workDir, timeoutMs: hookTimeoutMs(hook, 30000), env: { ...process.env, NEXRALL_HOOK_PHASE: 'ElicitationResult' }, event: 'ElicitationResult' });
+            const r = await runHookHandler(hook, payload, {
+                cwd: workDir,
+                timeoutMs: hookTimeoutMs(hook, 30000),
+                env: { ...process.env, NEXRALL_HOOK_PHASE: 'ElicitationResult' },
+                event: 'ElicitationResult',
+            });
             if (gate.statusId !== undefined)
                 hookStatusEnd(gate.statusId);
             if (r.status === 0 && gate.key)
@@ -1213,9 +1414,13 @@ function fireNotificationHooks(workDir, message, type = 'permission_prompt') {
         const items = loadHooks(workDir).Notification;
         if (!items?.length)
             return;
-        void runLifecycleHooks(items, 'Notification', workDir, { message, notification_type: type }).catch(() => { });
+        void runLifecycleHooks(items, 'Notification', workDir, { message, notification_type: type }).catch(() => {
+            /* a hook must never break the prompt */
+        });
+    }
+    catch {
+        /* ignore */
     }
-    catch { /* ignore */ }
 }
 /** For hosts that run their own manual /compact: fire PreCompact (trigger "manual"), awaited, never blocking. */
 /** The manual /compact counterpart of the auto PostCompact hook (trigger "manual"). */
@@ -1226,7 +1431,9 @@ async function fireManualPostCompactHook(workDir, sessionId, messagesSummarized)
             return;
         await runLifecycleHooks(items, 'PostCompact', workDir, { trigger: 'manual', session_id: sessionId, messages_summarized: messagesSummarized }, 'manual');
     }
-    catch { /* a hook must never break compaction */ }
+    catch {
+        /* a hook must never break compaction */
+    }
 }
 async function fireManualPreCompactHook(workDir, sessionId, messagesToSummarize) {
     try {
@@ -1235,6 +1442,8 @@ async function fireManualPreCompactHook(workDir, sessionId, messagesToSummarize)
             return;
         await runLifecycleHooks(items, 'PreCompact', workDir, { trigger: 'manual', session_id: sessionId, messages_to_summarize: messagesToSummarize }, 'manual');
     }
-    catch { /* a hook must never break compaction */ }
+    catch {
+        /* a hook must never break compaction */
+    }
 }
 //# sourceMappingURL=hooks.js.map