@phuetz/code-buddy 1.1.0 → 1.2.0

package/dist/goals/goal-manager.js

@@ -13,7 +13,7 @@ import path from 'path';
 import { getSettingsHierarchy } from '../config/settings-hierarchy.js';
 import { getSessionStore } from '../persistence/session-store.js';
 import { logger } from '../utils/logger.js';
-import { DEFAULT_JUDGE_MAX_TOKENS, DEFAULT_JUDGE_TIMEOUT_MS, DEFAULT_MAX_TURNS, applyJudgeOutcome, buildContinuationPrompt, createGoalState, formatGoalStatusLine, renderSubgoalsBlock, } from './goal-state.js';
+import { DEFAULT_JUDGE_MAX_TOKENS, DEFAULT_JUDGE_TIMEOUT_MS, DEFAULT_MAX_TURNS, applyJudgeOutcome, buildContinuationPrompt, createGoalState, formatGoalStatusLine, getGoalJudgeCriteria, renderSubgoalsBlock, } from './goal-state.js';
 import { GoalStore } from './goal-store.js';
 export class GoalManager {
     sessionKey;
@@ -47,13 +47,40 @@ export class GoalManager {
         if (!text) {
             throw new Error('goal text is empty');
         }
-        const state = createGoalState(text, options.maxTurns || this.defaultMaxTurns);
+        const state = createGoalState(text, options.maxTurns ?? this.defaultMaxTurns);
+        if (options.goalPlan)
+            state.goalPlan = options.goalPlan;
+        if (typeof options.goalPlanAttempted === 'boolean') {
+            state.goalPlanAttempted = options.goalPlanAttempted;
+        }
         this._state = state;
         this.store.save(this.sessionKey, state);
         return state;
     }
+    attachGoalPlan(plan) {
+        if (!this.hasGoal() || !this._state)
+            return null;
+        this._state.goalPlan = plan;
+        this._state.goalPlanAttempted = true;
+        delete this._state.goalPlanLastError;
+        this.store.save(this.sessionKey, this._state);
+        return this._state;
+    }
+    markGoalPlanAttempted(error) {
+        if (!this.hasGoal() || !this._state)
+            return null;
+        this._state.goalPlanAttempted = true;
+        if (error) {
+            this._state.goalPlanLastError = error;
+        }
+        else {
+            delete this._state.goalPlanLastError;
+        }
+        this.store.save(this.sessionKey, this._state);
+        return this._state;
+    }
     pause(reason = 'user-paused') {
-        if (!this._state)
+        if (!this._state || !['active', 'paused'].includes(this._state.status))
             return null;
         this._state.status = 'paused';
         this._state.pausedReason = reason;
@@ -61,10 +88,13 @@ export class GoalManager {
         return this._state;
     }
     resume(options = {}) {
-        if (!this._state)
+        if (!this._state || this._state.status !== 'paused')
             return null;
         this._state.status = 'active';
         delete this._state.pausedReason;
+        delete this._state.lastVerdict;
+        delete this._state.lastReason;
+        this._state.consecutiveParseFailures = 0;
         if (options.resetBudget ?? true) {
             this._state.turnsUsed = 0;
         }
@@ -103,7 +133,10 @@ export class GoalManager {
         if (!this.hasGoal() || !this._state) {
             throw new Error('no active goal');
         }
-        const idx = Math.trunc(index1Based) - 1;
+        if (!Number.isSafeInteger(index1Based) || index1Based < 1) {
+            throw new Error('index must be a positive integer');
+        }
+        const idx = index1Based - 1;
         if (idx < 0 || idx >= this._state.subgoals.length) {
             throw new Error(`index out of range (1..${this._state.subgoals.length})`);
         }
@@ -145,10 +178,11 @@ export class GoalManager {
                 message: '',
             };
         }
+        const criteria = getGoalJudgeCriteria(state);
         const outcome = await deps.judge({
             goal: state.goal,
             lastResponse,
-            ...(state.subgoals.length ? { subgoals: state.subgoals } : {}),
+            ...(criteria.length ? { subgoals: criteria } : {}),
         });
         const decision = applyJudgeOutcome(state, outcome);
         this.store.save(this.sessionKey, state);
@@ -166,7 +200,9 @@ export class GoalManager {
 export function resolveGoalsConfig() {
     let raw = {};
     try {
-        const settings = getSettingsHierarchy().getAllSettings();
+        const hierarchy = getSettingsHierarchy(process.cwd());
+        hierarchy.loadAllLevels?.();
+        const settings = hierarchy.getAllSettings();
         if (settings && typeof settings.goals === 'object' && settings.goals !== null) {
             raw = settings.goals;
         }
@@ -174,21 +210,38 @@ export function resolveGoalsConfig() {
     catch (error) {
         logger.debug('goals: settings hierarchy unavailable, using defaults', { error: String(error) });
     }
-    const envMaxTurns = Number(process.env.CODEBUDDY_GOAL_MAX_TURNS);
-    const maxTurns = Number.isFinite(envMaxTurns) && envMaxTurns > 0
-        ? Math.trunc(envMaxTurns)
-        : positiveInt(raw.maxTurns, DEFAULT_MAX_TURNS);
-    const judgeModel = process.env.CODEBUDDY_GOAL_JUDGE_MODEL || String(raw.judgeModel ?? '').trim();
+    const maxTurns = positiveInt(process.env.CODEBUDDY_GOAL_MAX_TURNS, 0)
+        || positiveInt(raw.maxTurns, DEFAULT_MAX_TURNS);
+    const judgeModel = nonEmptyString(process.env.CODEBUDDY_GOAL_JUDGE_MODEL)
+        || nonEmptyString(raw.judgeModel);
+    const plannerModel = nonEmptyString(process.env.CODEBUDDY_GOAL_PLANNER_MODEL)
+        || nonEmptyString(raw.plannerModel);
     return {
         maxTurns,
         judgeModel,
+        plannerModel,
         judgeMaxTokens: positiveInt(raw.judgeMaxTokens, DEFAULT_JUDGE_MAX_TOKENS),
         judgeTimeoutMs: positiveInt(raw.judgeTimeoutMs, DEFAULT_JUDGE_TIMEOUT_MS),
     };
 }
 function positiveInt(value, fallback) {
-    const n = Number(value);
-    return Number.isFinite(n) && n > 0 ? Math.trunc(n) : fallback;
+    const n = parsePositiveSafeInteger(value);
+    return Number.isSafeInteger(n) && n > 0 ? n : fallback;
+}
+function nonEmptyString(value) {
+    if (typeof value !== 'string')
+        return '';
+    return value.trim();
+}
+function parsePositiveSafeInteger(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return Number.NaN;
+    const trimmed = value.trim();
+    if (!/^[1-9]\d*$/.test(trimmed))
+        return Number.NaN;
+    return Number(trimmed);
 }
 // ============================================================================
 // Singleton registry (one manager per session key)

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

@@ -16,6 +16,7 @@
  * - A real user message mid-loop preempts the continuation prompt; the judge
  *   re-runs after that turn.
  */
+import type { GoalPlan } from './goal-decomposer.js';
 export type GoalStatus = 'active' | 'paused' | 'done' | 'cleared';
 export type GoalVerdict = 'done' | 'continue' | 'skipped';
 export interface GoalState {
@@ -37,6 +38,16 @@ export interface GoalState {
      * empty so old persisted state loads unchanged.
      */
     subgoals: string[];
+    /**
+     * Optional Hermes-style decomposition graph generated for complex goals.
+     * Its acceptance criteria are fed to the judge alongside user-added
+     * subgoals, while remaining separate so /subgoal stays a manual control.
+     */
+    goalPlan?: GoalPlan;
+    /** True once an LLM planning attempt was made for this goal. */
+    goalPlanAttempted?: boolean;
+    /** Last planning failure, kept for status/debug without retrying forever. */
+    goalPlanLastError?: string;
 }
 export declare const DEFAULT_MAX_TURNS = 20;
 export declare const DEFAULT_JUDGE_TIMEOUT_MS = 30000;
@@ -47,12 +58,14 @@ export declare const JUDGE_RESPONSE_SNIPPET_CHARS = 4000;
 export declare const MAX_CONSECUTIVE_PARSE_FAILURES = 3;
 export declare const CONTINUATION_PROMPT_TEMPLATE: string;
 export declare const CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATE: string;
+export declare const CONTINUATION_PROMPT_WITH_PLAN_TEMPLATE: string;
 export declare const JUDGE_SYSTEM_PROMPT: string;
 export declare const JUDGE_USER_PROMPT_TEMPLATE: string;
 export declare const JUDGE_USER_PROMPT_WITH_SUBGOALS_TEMPLATE: string;
 export declare function truncateText(text: string, limit: number): string;
 /** Render subgoals as a numbered `- N. text` block. Empty string when none. */
 export declare function renderSubgoalsBlock(subgoals: string[]): string;
+export declare function getGoalJudgeCriteria(state: Pick<GoalState, 'goalPlan' | 'subgoals'>): string[];
 export declare function createGoalState(goal: string, maxTurns?: number): GoalState;
 /**
  * Defensive deserialization of a persisted goal state. Returns null when the

package/dist/goals/goal-state.js

@@ -16,6 +16,7 @@
  * - 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
 // ──────────────────────────────────────────────────────────────────────
@@ -47,27 +48,56 @@ export const CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATE = '[Continuing toward yo
     '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' +
-    '- The response explicitly confirms the goal was completed, OR\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' +
-    "Agent's most recent response:\n{response}\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' +
-    "Agent's most recent response:\n{response}\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 " +
@@ -92,7 +122,13 @@ export function renderSubgoalsBlock(subgoals) {
         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',
@@ -121,19 +157,28 @@ export function normalizeGoalState(raw) {
     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: toInt(data.turnsUsed, 0),
-        maxTurns: toInt(data.maxTurns, DEFAULT_MAX_TURNS) || DEFAULT_MAX_TURNS,
+        turnsUsed: toNonNegativeInt(data.turnsUsed, 0),
+        maxTurns: toPositiveInt(data.maxTurns, DEFAULT_MAX_TURNS),
         createdAt: toNumber(data.createdAt, 0),
         lastTurnAt: toNumber(data.lastTurnAt, 0),
-        consecutiveParseFailures: toInt(data.consecutiveParseFailures, 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')
@@ -142,9 +187,23 @@ export function normalizeGoalState(raw) {
         state.pausedReason = data.pausedReason;
     return state;
 }
-function toInt(value, fallback) {
-    const n = Number(value);
-    return Number.isFinite(n) ? Math.trunc(n) : fallback;
+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);
@@ -159,20 +218,31 @@ export function formatGoalStatusLine(state) {
     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}): ${state.goal}`;
+        return `⊙ Goal (active, ${turns}${sub}${plan}): ${state.goal}`;
     }
     if (state.status === 'paused') {
         const extra = state.pausedReason ? ` — ${state.pausedReason}` : '';
-        return `⏸ Goal (paused, ${turns}${sub}${extra}): ${state.goal}`;
+        return `⏸ Goal (paused, ${turns}${sub}${plan}${extra}): ${state.goal}`;
     }
     if (state.status === 'done') {
-        return `✓ Goal done (${turns}${sub}): ${state.goal}`;
+        return `✓ Goal done (${turns}${sub}${plan}): ${state.goal}`;
     }
-    return `Goal (${state.status}, ${turns}${sub}): ${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));
     }

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

@@ -22,4 +22,7 @@ export declare class GoalStore {
     save(key: string, state: GoalState): void;
     delete(key: string): void;
     private fileFor;
+    private fileCandidatesForRead;
+    private legacyFileFor;
+    private fileLabel;
 }

package/dist/goals/goal-store.js

@@ -9,6 +9,7 @@
  * 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';
@@ -25,17 +26,18 @@ export class GoalStore {
     load(key) {
         if (!key)
             return null;
-        const file = this.fileFor(key);
-        try {
-            if (!fs.existsSync(file))
-                return null;
-            const raw = fs.readFileSync(file, 'utf-8');
-            return normalizeGoalState(JSON.parse(raw));
-        }
-        catch (error) {
-            logger.debug('GoalStore: failed to load goal state', { key, error: String(error) });
-            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)
@@ -54,18 +56,32 @@ export class GoalStore {
     delete(key) {
         if (!key)
             return;
-        try {
-            fs.rmSync(this.fileFor(key), { force: true });
-        }
-        catch (error) {
-            logger.debug('GoalStore: failed to delete goal state', { key, error: String(error) });
+        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/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