@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/goals/goal-state.js

@@ -0,0 +1,315 @@
+/**
+ * Persistent session goals — the Ralph loop for Code Buddy.
+ *
+ * A goal is a free-form user objective that stays active across turns. After
+ * each turn completes, a small judge call asks an auxiliary model "is this
+ * goal satisfied by the assistant's last response?". If not, Code Buddy feeds
+ * a continuation prompt back into the same session and keeps working until
+ * the goal is done, the turn budget is exhausted, the user pauses/clears it,
+ * or a real user message preempts the loop.
+ *
+ * Ported from Hermes Agent's goal system (hermes_cli/goals.py). Invariants:
+ * - The continuation prompt is a plain user message — no system-prompt
+ *   mutation, no toolset swap, prompt caching stays intact.
+ * - Judge failures are fail-OPEN ("continue"): a broken judge must not wedge
+ *   progress; the turn budget is the backstop.
+ * - A real user message mid-loop preempts the continuation prompt; the judge
+ *   re-runs after that turn.
+ */
+import { formatGoalPlan, goalPlanToCriteria, normalizeGoalPlan, } from './goal-decomposer.js';
+// ──────────────────────────────────────────────────────────────────────
+// Constants & defaults
+// ──────────────────────────────────────────────────────────────────────
+export const DEFAULT_MAX_TURNS = 20;
+export const DEFAULT_JUDGE_TIMEOUT_MS = 30_000;
+// Judge output budget. The judge returns a one-line JSON verdict, but
+// reasoning models burn tokens on hidden reasoning before emitting the
+// visible JSON. Tight caps truncate the JSON and trip the auto-pause.
+export const DEFAULT_JUDGE_MAX_TOKENS = 4096;
+// Caps how much of the inputs we send to the judge.
+export const JUDGE_GOAL_SNIPPET_CHARS = 2000;
+export const JUDGE_SUBGOALS_SNIPPET_CHARS = 2000;
+export const JUDGE_RESPONSE_SNIPPET_CHARS = 4000;
+// After this many consecutive judge *parse* failures (empty output /
+// non-JSON), the loop auto-pauses and points the user at the judge config.
+// Guards against small models that can't follow the strict JSON contract.
+export const MAX_CONSECUTIVE_PARSE_FAILURES = 3;
+export const CONTINUATION_PROMPT_TEMPLATE = '[Continuing toward your standing goal]\n' +
+    'Goal: {goal}\n\n' +
+    'Continue working toward this goal. Take the next concrete step. ' +
+    'If you believe the goal is complete, state so explicitly and stop. ' +
+    'If you are blocked and need input from the user, say so clearly and stop.';
+export const CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATE = '[Continuing toward your standing goal]\n' +
+    'Goal: {goal}\n\n' +
+    'Additional criteria the user added mid-loop:\n' +
+    '{subgoals_block}\n\n' +
+    'Continue working toward the goal AND all additional criteria. Take ' +
+    'the next concrete step. If you believe the goal and every ' +
+    'additional criterion are complete, state so explicitly and stop. ' +
+    'If you are blocked and need input from the user, say so clearly ' +
+    'and stop.';
+export const CONTINUATION_PROMPT_WITH_PLAN_TEMPLATE = '[Continuing toward your standing goal]\n' +
+    'Goal: {goal}\n\n' +
+    'Decomposition plan:\n' +
+    '{goal_plan_block}\n\n' +
+    '{manual_subgoals_block}' +
+    'Continue working through the plan. Prefer ready tasks whose dependencies ' +
+    'are already satisfied, keep independent lanes separate, and produce ' +
+    'concrete evidence for every acceptance criterion. If you believe the goal ' +
+    'and every criterion are complete, state so explicitly and stop. If you are ' +
+    'blocked and need input from the user, say so clearly and stop.';
+export const JUDGE_SYSTEM_PROMPT = "You are a strict judge evaluating whether an autonomous agent has " +
+    "achieved a user's stated goal. You receive the goal text and the " +
+    "agent's most recent response. Your only job is to decide whether " +
+    'the goal is fully satisfied based on that response.\n\n' +
+    'The response may begin with internal evidence metadata such as ' +
+    '`[tool evidence: none]` or `[tool:<name> success]`. Treat those ' +
+    'bracketed metadata lines as evidence annotations only. They are NOT ' +
+    "part of the assistant's answer text for exact-answer goals; ignore " +
+    'the metadata itself when comparing exact requested output. For ' +
+    'side-effect goals, use the metadata and any following tool output to ' +
+    'decide whether concrete evidence exists.\n\n' +
+    'A goal is DONE only when:\n' +
+    '- For answer-only or explanation goals, the response directly answers the requested question, OR\n' +
+    '- The response clearly shows the final deliverable was produced, OR\n' +
+    '- The response explains the goal is unachievable / blocked / needs ' +
+    'user input (treat this as DONE with reason describing the block).\n\n' +
+    'For goals that require external side effects such as creating, editing, ' +
+    'moving, deleting, reading, or verifying files; running commands; calling ' +
+    'tools; changing repository state; or producing artifacts, unsupported ' +
+    'assistant claims are NOT evidence. Do not accept statements like "I ' +
+    'created the file" or "I verified it" unless the response includes concrete ' +
+    'evidence such as a tool result, command output, file contents excerpt, diff, ' +
+    'test output, or artifact path backed by tool output. If a side-effect goal ' +
+    'has no concrete evidence, return CONTINUE.\n\n' +
+    'Otherwise the goal is NOT done — CONTINUE.\n\n' +
+    'Reply ONLY with a single JSON object on one line:\n' +
+    '{"done": <true|false>, "reason": "<one-sentence rationale>"}';
+export const JUDGE_USER_PROMPT_TEMPLATE = 'Goal:\n{goal}\n\n' +
+    'Current time: {current_time}\n\n' +
+    "Agent's most recent response is delimited by <response> tags. " +
+    'Text outside those tags is prompt metadata, not part of the response:\n' +
+    '<response>\n{response}\n</response>\n\n' +
+    'Is the goal satisfied?';
+export const JUDGE_USER_PROMPT_WITH_SUBGOALS_TEMPLATE = 'Goal:\n{goal}\n\n' +
+    'Additional criteria the user added mid-loop (all must also be ' +
+    'satisfied for the goal to be DONE):\n{subgoals_block}\n\n' +
+    'Current time: {current_time}\n\n' +
+    "Agent's most recent response is delimited by <response> tags. " +
+    'Text outside those tags is prompt metadata, not part of the response:\n' +
+    '<response>\n{response}\n</response>\n\n' +
+    'Decision: For each numbered criterion above, find concrete ' +
+    "evidence in the agent's response that the criterion is " +
+    "satisfied. Do not accept generic phrases like 'all requirements " +
+    "met' or 'implying it was done' — require specific evidence (a " +
+    'file contents excerpt, an output line, a command result). If ' +
+    'ANY criterion lacks specific evidence in the response, the goal ' +
+    'is NOT done — return CONTINUE.\n\n' +
+    'Is the goal AND every additional criterion satisfied?';
+// ──────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────
+export function truncateText(text, limit) {
+    if (!text)
+        return '';
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit) + '… [truncated]';
+}
+/** Render subgoals as a numbered `- N. text` block. Empty string when none. */
+export function renderSubgoalsBlock(subgoals) {
+    if (!subgoals.length)
+        return '';
+    return subgoals.map((text, i) => `- ${i + 1}. ${text}`).join('\n');
+}
+export function getGoalJudgeCriteria(state) {
+    return [...goalPlanToCriteria(state.goalPlan), ...state.subgoals];
+}
+export function createGoalState(goal, maxTurns = DEFAULT_MAX_TURNS) {
+    if (!Number.isSafeInteger(maxTurns) || maxTurns <= 0) {
+        throw new Error('maxTurns must be a positive integer');
+    }
+    return {
+        goal,
+        status: 'active',
+        turnsUsed: 0,
+        maxTurns,
+        createdAt: Date.now(),
+        lastTurnAt: 0,
+        consecutiveParseFailures: 0,
+        subgoals: [],
+    };
+}
+/**
+ * Defensive deserialization of a persisted goal state. Returns null when the
+ * payload isn't a usable goal. Old payloads without `subgoals` load unchanged.
+ */
+export function normalizeGoalState(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const data = raw;
+    const goal = typeof data.goal === 'string' ? data.goal : '';
+    if (!goal.trim())
+        return null;
+    const status = ['active', 'paused', 'done', 'cleared'].includes(String(data.status))
+        ? data.status
+        : 'active';
+    const subgoals = Array.isArray(data.subgoals)
+        ? data.subgoals.map(s => String(s).trim()).filter(Boolean)
+        : [];
+    const goalPlan = normalizeGoalPlan(data.goalPlan);
+    const verdict = ['done', 'continue', 'skipped'].includes(String(data.lastVerdict))
+        ? data.lastVerdict
+        : undefined;
+    const state = {
+        goal,
+        status,
+        turnsUsed: toNonNegativeInt(data.turnsUsed, 0),
+        maxTurns: toPositiveInt(data.maxTurns, DEFAULT_MAX_TURNS),
+        createdAt: toNumber(data.createdAt, 0),
+        lastTurnAt: toNumber(data.lastTurnAt, 0),
+        consecutiveParseFailures: toNonNegativeInt(data.consecutiveParseFailures, 0),
+        subgoals,
+    };
+    if (goalPlan)
+        state.goalPlan = goalPlan;
+    if (typeof data.goalPlanAttempted === 'boolean') {
+        state.goalPlanAttempted = data.goalPlanAttempted;
+    }
+    if (typeof data.goalPlanLastError === 'string') {
+        state.goalPlanLastError = data.goalPlanLastError;
+    }
+    if (verdict)
+        state.lastVerdict = verdict;
+    if (typeof data.lastReason === 'string')
+        state.lastReason = data.lastReason;
+    if (typeof data.pausedReason === 'string')
+        state.pausedReason = data.pausedReason;
+    return state;
+}
+function toPositiveInt(value, fallback) {
+    const n = parseSafeInteger(value, /^[1-9]\d*$/);
+    return Number.isSafeInteger(n) && n > 0 ? n : fallback;
+}
+function toNonNegativeInt(value, fallback) {
+    const n = parseSafeInteger(value, /^(?:0|[1-9]\d*)$/);
+    return Number.isSafeInteger(n) && n >= 0 ? n : fallback;
+}
+function parseSafeInteger(value, stringPattern) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return Number.NaN;
+    const trimmed = value.trim();
+    if (!stringPattern.test(trimmed))
+        return Number.NaN;
+    return Number(trimmed);
+}
+function toNumber(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+/** Printable one-liner for /goal status. */
+export function formatGoalStatusLine(state) {
+    if (!state || state.status === 'cleared') {
+        return 'No active goal. Set one with /goal <text>.';
+    }
+    const turns = `${state.turnsUsed}/${state.maxTurns} turns`;
+    const sub = state.subgoals.length
+        ? `, ${state.subgoals.length} subgoal${state.subgoals.length !== 1 ? 's' : ''}`
+        : '';
+    const plan = state.goalPlan
+        ? `, plan ${state.goalPlan.tasks.length} task${state.goalPlan.tasks.length !== 1 ? 's' : ''}`
+        : '';
+    if (state.status === 'active') {
+        return `⊙ Goal (active, ${turns}${sub}${plan}): ${state.goal}`;
+    }
+    if (state.status === 'paused') {
+        const extra = state.pausedReason ? ` — ${state.pausedReason}` : '';
+        return `⏸ Goal (paused, ${turns}${sub}${plan}${extra}): ${state.goal}`;
+    }
+    if (state.status === 'done') {
+        return `✓ Goal done (${turns}${sub}${plan}): ${state.goal}`;
+    }
+    return `Goal (${state.status}, ${turns}${sub}${plan}): ${state.goal}`;
+}
+/** The canonical user-role continuation message for an active goal. */
+export function buildContinuationPrompt(state) {
+    if (state.goalPlan) {
+        const manualSubgoalsBlock = state.subgoals.length
+            ? `Additional user criteria:\n${renderSubgoalsBlock(state.subgoals)}\n\n`
+            : '';
+        return CONTINUATION_PROMPT_WITH_PLAN_TEMPLATE.replace('{goal}', state.goal)
+            .replace('{goal_plan_block}', formatGoalPlan(state.goalPlan))
+            .replace('{manual_subgoals_block}', manualSubgoalsBlock);
+    }
+    if (state.subgoals.length) {
+        return CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATE.replace('{goal}', state.goal).replace('{subgoals_block}', renderSubgoalsBlock(state.subgoals));
+    }
+    return CONTINUATION_PROMPT_TEMPLATE.replace('{goal}', state.goal);
+}
+/**
+ * Apply a judge outcome to an active goal — the exact Hermes ladder.
+ * MUTATES `state` (turn counter, verdict bookkeeping, status transitions)
+ * and returns the decision; the caller persists the state wherever it
+ * lives (GoalStore file, peer-session record, …).
+ */
+export function applyJudgeOutcome(state, outcome, nowMs = Date.now()) {
+    state.turnsUsed += 1;
+    state.lastTurnAt = nowMs;
+    state.lastVerdict = outcome.verdict;
+    state.lastReason = outcome.reason;
+    // Reset the parse-failure streak on any usable reply, including
+    // API/transport errors (parseFailed=false), so a flaky network doesn't
+    // trip the auto-pause meant for bad judge models.
+    state.consecutiveParseFailures = outcome.parseFailed ? state.consecutiveParseFailures + 1 : 0;
+    if (outcome.verdict === 'done') {
+        state.status = 'done';
+        return {
+            status: 'done',
+            shouldContinue: false,
+            continuationPrompt: null,
+            verdict: 'done',
+            reason: outcome.reason,
+            message: `✓ Goal achieved: ${outcome.reason}`,
+        };
+    }
+    if (state.consecutiveParseFailures >= MAX_CONSECUTIVE_PARSE_FAILURES) {
+        state.status = 'paused';
+        state.pausedReason = `judge model returned unparseable output ${state.consecutiveParseFailures} turns in a row`;
+        return {
+            status: 'paused',
+            shouldContinue: false,
+            continuationPrompt: null,
+            verdict: 'continue',
+            reason: outcome.reason,
+            message: `⏸ Goal paused — the judge model (${state.consecutiveParseFailures} turns) ` +
+                'isn\'t returning the required JSON verdict. Route the judge to a stricter ' +
+                'model in .codebuddy/settings.json:\n' +
+                '  { "goals": { "judgeModel": "<a model that follows JSON instructions>" } }\n' +
+                'Then /goal resume to continue.',
+        };
+    }
+    if (state.turnsUsed >= state.maxTurns) {
+        state.status = 'paused';
+        state.pausedReason = `turn budget exhausted (${state.turnsUsed}/${state.maxTurns})`;
+        return {
+            status: 'paused',
+            shouldContinue: false,
+            continuationPrompt: null,
+            verdict: 'continue',
+            reason: outcome.reason,
+            message: `⏸ Goal paused — ${state.turnsUsed}/${state.maxTurns} turns used. ` +
+                'Use /goal resume to keep going, or /goal clear to stop.',
+        };
+    }
+    return {
+        status: 'active',
+        shouldContinue: true,
+        continuationPrompt: buildContinuationPrompt(state),
+        verdict: 'continue',
+        reason: outcome.reason,
+        message: `↻ Continuing toward goal (${state.turnsUsed}/${state.maxTurns}): ${outcome.reason}`,
+    };
+}
+//# sourceMappingURL=goal-state.js.map

package/dist/goals/goal-store.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Durable per-session goal persistence.
+ *
+ * One JSON file per session key under `~/.codebuddy/goals/` (honors
+ * CODEBUDDY_HOME). Files are tiny (<1 KB) so I/O is synchronous — same
+ * trade-off as TodoTracker. Writes are atomic (tmp + rename). Loads are
+ * fail-soft: a corrupt or unreadable file reads as "no goal".
+ *
+ * Cleared goals keep a tombstone (`status: 'cleared'`) for audit, mirroring
+ * Hermes' SessionDB behavior.
+ */
+import { GoalState } from './goal-state.js';
+export interface GoalStoreOptions {
+    /** Override the storage directory (test isolation). */
+    storeDir?: string;
+}
+export declare class GoalStore {
+    private storeDir;
+    constructor(options?: GoalStoreOptions);
+    getStoreDir(): string;
+    load(key: string): GoalState | null;
+    save(key: string, state: GoalState): void;
+    delete(key: string): void;
+    private fileFor;
+    private fileCandidatesForRead;
+    private legacyFileFor;
+    private fileLabel;
+}

package/dist/goals/goal-store.js

@@ -0,0 +1,87 @@
+/**
+ * Durable per-session goal persistence.
+ *
+ * One JSON file per session key under `~/.codebuddy/goals/` (honors
+ * CODEBUDDY_HOME). Files are tiny (<1 KB) so I/O is synchronous — same
+ * trade-off as TodoTracker. Writes are atomic (tmp + rename). Loads are
+ * fail-soft: a corrupt or unreadable file reads as "no goal".
+ *
+ * Cleared goals keep a tombstone (`status: 'cleared'`) for audit, mirroring
+ * Hermes' SessionDB behavior.
+ */
+import { createHash } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { getCodeBuddyPath } from '../utils/codebuddy-home.js';
+import { logger } from '../utils/logger.js';
+import { normalizeGoalState } from './goal-state.js';
+export class GoalStore {
+    storeDir;
+    constructor(options = {}) {
+        this.storeDir = options.storeDir ?? getCodeBuddyPath('goals');
+    }
+    getStoreDir() {
+        return this.storeDir;
+    }
+    load(key) {
+        if (!key)
+            return null;
+        for (const file of this.fileCandidatesForRead(key)) {
+            try {
+                if (!fs.existsSync(file))
+                    continue;
+                const raw = fs.readFileSync(file, 'utf-8');
+                return normalizeGoalState(JSON.parse(raw));
+            }
+            catch (error) {
+                logger.debug('GoalStore: failed to load goal state', { key, file, error: String(error) });
+            }
+        }
+        return null;
+    }
+    save(key, state) {
+        if (!key)
+            return;
+        const file = this.fileFor(key);
+        try {
+            fs.mkdirSync(this.storeDir, { recursive: true });
+            const tmp = `${file}.tmp.${process.pid}`;
+            fs.writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf-8');
+            fs.renameSync(tmp, file);
+        }
+        catch (error) {
+            logger.debug('GoalStore: failed to save goal state', { key, error: String(error) });
+        }
+    }
+    delete(key) {
+        if (!key)
+            return;
+        for (const file of this.fileCandidatesForRead(key)) {
+            try {
+                fs.rmSync(file, { force: true });
+            }
+            catch (error) {
+                logger.debug('GoalStore: failed to delete goal state', { key, file, error: String(error) });
+            }
+        }
+    }
+    fileFor(key) {
+        const label = this.fileLabel(key);
+        const digest = createHash('sha256').update(key).digest('hex').slice(0, 16);
+        return path.join(this.storeDir, `${label}-${digest}.json`);
+    }
+    fileCandidatesForRead(key) {
+        return Array.from(new Set([this.fileFor(key), this.legacyFileFor(key)]));
+    }
+    legacyFileFor(key) {
+        // Session ids and dir-hash keys are already filesystem-safe; sanitize
+        // anyway so a malformed key can't escape the store directory.
+        const safe = key.replace(/[^a-zA-Z0-9._-]/g, '_');
+        return path.join(this.storeDir, `${safe}.json`);
+    }
+    fileLabel(key) {
+        const safe = key.replace(/[^a-zA-Z0-9._-]/g, '_').replace(/^\.+$/, '_').slice(0, 80);
+        return safe || 'goal';
+    }
+}
+//# sourceMappingURL=goal-store.js.map

package/dist/goals/index.d.ts

@@ -0,0 +1,5 @@
+export * from './goal-state.js';
+export * from './goal-store.js';
+export * from './goal-judge.js';
+export * from './goal-manager.js';
+export * from './goal-loop.js';

package/dist/goals/index.js

@@ -0,0 +1,6 @@
+export * from './goal-state.js';
+export * from './goal-store.js';
+export * from './goal-judge.js';
+export * from './goal-manager.js';
+export * from './goal-loop.js';
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-input-handler.js

@@ -16,6 +16,7 @@ import { ClientCommandDispatcher } from "../commands/client-dispatcher.js";
 import { extractFileReference, getFileSuggestions } from "../ui/components/FileAutocomplete.js";
 // Import interaction logger for session tracking
 import { getInteractionLogger } from "../logging/interaction-logger.js";
+import { maybeContinueGoalAfterTurn } from "../goals/goal-loop.js";
 import { logger } from '../utils/logger.js';
 // Import history manager for persistent command history
 import { getHistoryManager } from "../utils/history-manager.js";
@@ -35,6 +36,11 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
     // Track last escape time for double-escape detection
     const lastEscapeTimeRef = useRef(0);
     const DOUBLE_ESCAPE_THRESHOLD = 500; // ms
+    // Goal loop (Ralph loop): monotonically increasing turn sequence. A real
+    // user submit mid-turn bumps it, which voids the stale turn's continuation
+    // (the judge then runs after the user's turn instead — Hermes preemption).
+    const turnSeqRef = useRef(0);
+    const goalInterruptedRef = useRef(false);
     /**
      * Save instruction to .codebuddyrules file (Standard # capture)
      */
@@ -88,6 +94,7 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
             return true;
         }
         if (isProcessing || isStreaming) {
+            goalInterruptedRef.current = true;
             agent.abortCurrentOperation();
             setIsProcessing(false);
             setIsStreaming(false);
@@ -465,6 +472,8 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         return await ClientCommandDispatcher.dispatch(input, context);
     };
     const processUserMessage = async (userInput) => {
+        const mySeq = ++turnSeqRef.current;
+        goalInterruptedRef.current = false;
         const userEntry = {
             type: "user",
             content: userInput,
@@ -484,10 +493,10 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         setIsProcessing(true);
         setCurrentActivity?.('Sending to LLM...');
         clearInput();
+        let fullResponseContent = "";
         try {
             setIsStreaming(true);
             let streamingEntry = null;
-            let fullResponseContent = "";
             for await (const chunk of agent.processUserMessageStream(userInput)) {
                 switch (chunk.type) {
                     case "content":
@@ -677,6 +686,32 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         setIsProcessing(false);
         setCurrentActivity?.('');
         processingStartTime.current = 0;
+        // Goal loop (Ralph loop): judge the finished turn and maybe auto-continue.
+        // Failures here must never break a turn — the goal system is advisory.
+        try {
+            const outcome = await maybeContinueGoalAfterTurn({
+                client: agent.getClient(),
+                lastResponse: fullResponseContent,
+                interrupted: goalInterruptedRef.current,
+            });
+            if (outcome?.message) {
+                setChatHistory((prev) => [
+                    ...prev,
+                    { type: 'assistant', content: outcome.message, timestamp: new Date() },
+                ]);
+            }
+            // Skip the continuation if a newer turn started while we were judging —
+            // the user's message preempts the loop and gets judged after its turn.
+            if (outcome?.continuationPrompt && turnSeqRef.current === mySeq) {
+                const continuation = outcome.continuationPrompt;
+                setTimeout(() => {
+                    void processUserMessage(continuation);
+                }, 50);
+            }
+        }
+        catch (error) {
+            logger.debug('goal after-turn hook failed', { error: String(error) });
+        }
     };
     return {
         input,

package/dist/hooks/user-hooks.js

@@ -188,6 +188,8 @@ export class UserHooksManager {
             const shellFlag = isWindows ? '/c' : '-c';
             const child = spawn(shell, [shellFlag, expandedCommand], {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                detached: !isWindows,
+                windowsHide: true,
                 env: {
                     ...process.env,
                     TOOL_NAME: context.toolName ?? '',
@@ -202,12 +204,24 @@ export class UserHooksManager {
             let timedOut = false;
             const timer = setTimeout(() => {
                 timedOut = true;
-                child.kill('SIGTERM');
+                if (!isWindows && child.pid) {
+                    try {
+                        process.kill(-child.pid, 'SIGTERM');
+                    }
+                    catch {
+                        child.kill('SIGTERM');
+                    }
+                }
+                else {
+                    child.kill('SIGTERM');
+                }
             }, timeout);
             // Write context JSON to stdin
+            child.stdin.on('error', (err) => {
+                logger.debug(`[user-hooks] command stdin closed: ${err.message}`);
+            });
             try {
-                child.stdin.write(JSON.stringify({ event, ...context }));
-                child.stdin.end();
+                child.stdin.end(JSON.stringify({ event, ...context }));
             }
             catch {
                 // stdin may already be closed