@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/context/project-context.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Project Context — the canonical hierarchical loader for project-instruction
+ * files (the AGENTS.md / CLAUDE.md / GEMINI.md / CODEBUDDY.md hierarchy).
+ *
+ * Single source of truth that replaces the previously fragmented readers
+ * (jit-context, bootstrap-loader's hierarchical walk, context-files). It owns:
+ *   - the config-driven accepted-filename list (`loadContextConfig`),
+ *   - the per-directory probe (incl. `.codebuddy/` + `.claude/` descent),
+ *   - variant precedence (`<name>.local.md` > `<name>.override.md` > `<name>`),
+ *   - `@import` resolution (code-fence-safe), token/byte budgeting,
+ *   - realpath dedup shared across the startup pass and JIT (the `ContextRegistry`).
+ *
+ * Precedence (documented once, here):
+ *   - Tiers: global (`~/.codebuddy/`) is appended FIRST (lowest precedence),
+ *     then the project hierarchy from project-root DOWN to cwd. Files closer to
+ *     cwd appear later in the text → win on conflict (Codex AGENTS.md model).
+ *   - Within a directory, every accepted filename present is COMPOSED (so
+ *     `CODEBUDDY.md` extends `AGENTS.md`), in the configured order.
+ *   - Within a (directory, name), the first existing variant wins and REPLACES
+ *     the base: `<name>.local.md` (gitignored) > `<name>.override.md` > `<name>`.
+ *   - Dedup key is `fs.realpathSync` so a `CLAUDE.md`/`GEMINI.md` symlinked to
+ *     `AGENTS.md` collapses to one injection.
+ *
+ * Determinism: iteration is over the fixed `dirs × probeDirs × names` product
+ * with relative origin headers and no mtimes — the rendered text is byte-stable
+ * across runs, which keeps prompt caching intact.
+ */
+export type ContextTier = 'global' | 'hierarchy' | 'jit';
+export type ContextVariant = 'base' | 'override' | 'local';
+export interface ContextSource {
+    /** Absolute path of the loaded file. */
+    path: string;
+    /** `fs.realpathSync` of `path` — the dedup key. */
+    realpath: string;
+    /** Display path (relative to project root; `~/.codebuddy/...` for global). */
+    relPath: string;
+    tier: ContextTier;
+    variant: ContextVariant;
+    /** Size of this source's rendered body (chars). */
+    bytes: number;
+    /** Whether this source was truncated to fit the budget. */
+    truncated: boolean;
+}
+export interface ResolvedContext {
+    /** Merged, header-decorated text, ready to inject. */
+    text: string;
+    sources: ContextSource[];
+    bytes: number;
+    truncated: boolean;
+}
+export interface ResolveOptions {
+    cwd?: string;
+    /** Project root; resolved via ROOT_MARKERS when omitted. */
+    projectRoot?: string;
+    /** Shared dedup registry (startup ↔ JIT). A private one is used if omitted. */
+    registry?: ContextRegistry;
+    /** Byte budget override (defaults to config `maxBytes` / `jitMaxBytes`). */
+    budgetBytes?: number;
+    /** Accepted filenames override (defaults to config). */
+    fileNames?: string[];
+    /** Home-dir override (for testing). */
+    homeDir?: string;
+}
+/** Tracks realpaths already injected so a file is never loaded twice. */
+export declare class ContextRegistry {
+    private readonly seen;
+    has(realpath: string): boolean;
+    add(realpath: string): void;
+    clear(): void;
+    get size(): number;
+}
+export declare function createContextRegistry(): ContextRegistry;
+export declare function setActiveContextRegistry(registry: ContextRegistry): void;
+export declare function getActiveContextRegistry(): ContextRegistry;
+/** Project root via ROOT_MARKERS, walking up from `cwd` (null if none found). */
+export declare function findProjectRoot(cwd: string, markers?: string[]): string | null;
+/** Accepted instruction filenames for a project (config-driven). */
+export declare function getAcceptedFileNames(projectRoot?: string): string[];
+/**
+ * Startup pass: global tier + the project hierarchy from root DOWN to cwd.
+ * Call once per prompt build. Populates `registry` (if given) so the later JIT
+ * pass skips files already in the system prompt.
+ */
+export declare function resolveProjectContext(opts?: ResolveOptions): ResolvedContext;
+/**
+ * JIT pass: when a tool touches `accessedPath`, load any context files along its
+ * directory chain (root → accessed dir) that weren't already injected at
+ * startup (skipped via the shared `registry`). Smaller per-touch budget.
+ */
+export declare function resolveJitContext(accessedPath: string, opts?: ResolveOptions): ResolvedContext;

package/dist/context/project-context.js

@@ -0,0 +1,295 @@
+/**
+ * Project Context — the canonical hierarchical loader for project-instruction
+ * files (the AGENTS.md / CLAUDE.md / GEMINI.md / CODEBUDDY.md hierarchy).
+ *
+ * Single source of truth that replaces the previously fragmented readers
+ * (jit-context, bootstrap-loader's hierarchical walk, context-files). It owns:
+ *   - the config-driven accepted-filename list (`loadContextConfig`),
+ *   - the per-directory probe (incl. `.codebuddy/` + `.claude/` descent),
+ *   - variant precedence (`<name>.local.md` > `<name>.override.md` > `<name>`),
+ *   - `@import` resolution (code-fence-safe), token/byte budgeting,
+ *   - realpath dedup shared across the startup pass and JIT (the `ContextRegistry`).
+ *
+ * Precedence (documented once, here):
+ *   - Tiers: global (`~/.codebuddy/`) is appended FIRST (lowest precedence),
+ *     then the project hierarchy from project-root DOWN to cwd. Files closer to
+ *     cwd appear later in the text → win on conflict (Codex AGENTS.md model).
+ *   - Within a directory, every accepted filename present is COMPOSED (so
+ *     `CODEBUDDY.md` extends `AGENTS.md`), in the configured order.
+ *   - Within a (directory, name), the first existing variant wins and REPLACES
+ *     the base: `<name>.local.md` (gitignored) > `<name>.override.md` > `<name>`.
+ *   - Dedup key is `fs.realpathSync` so a `CLAUDE.md`/`GEMINI.md` symlinked to
+ *     `AGENTS.md` collapses to one injection.
+ *
+ * Determinism: iteration is over the fixed `dirs × probeDirs × names` product
+ * with relative origin headers and no mtimes — the rendered text is byte-stable
+ * across runs, which keeps prompt caching intact.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { logger } from '../utils/logger.js';
+import { resolveImportDirectives } from './import-directive-parser.js';
+import { loadContextConfig, shouldExcludeInstructionFile, } from './instruction-excludes.js';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Project-root markers, walked upward from cwd. */
+const ROOT_MARKERS = ['.git', 'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml', '.hg'];
+const MAX_HIERARCHY_DEPTH = 10;
+/** Subdirectories probed inside every level of the hierarchy. */
+const SUBDIR_PROBES = ['.codebuddy', '.claude'];
+const TRUNCATION_MARKER = '\n\n... (truncated)';
+// ============================================================================
+// Dedup registry (shared between the startup pass and JIT)
+// ============================================================================
+/** Tracks realpaths already injected so a file is never loaded twice. */
+export class ContextRegistry {
+    seen = new Set();
+    has(realpath) {
+        return this.seen.has(realpath);
+    }
+    add(realpath) {
+        this.seen.add(realpath);
+    }
+    clear() {
+        this.seen.clear();
+    }
+    get size() {
+        return this.seen.size;
+    }
+}
+export function createContextRegistry() {
+    return new ContextRegistry();
+}
+// Module-level "active" registry. The prompt builder publishes its per-build
+// registry here (`setActiveContextRegistry`) so the standalone JIT pass — which
+// has no handle to the PromptBuilder — can dedup against files already injected
+// at startup. Defaults to a persistent registry until the first build.
+let activeRegistry = new ContextRegistry();
+export function setActiveContextRegistry(registry) {
+    activeRegistry = registry;
+}
+export function getActiveContextRegistry() {
+    return activeRegistry;
+}
+// ============================================================================
+// Public API
+// ============================================================================
+/** Project root via ROOT_MARKERS, walking up from `cwd` (null if none found). */
+export function findProjectRoot(cwd, markers = ROOT_MARKERS) {
+    let dir = path.resolve(cwd);
+    let depth = 0;
+    while (depth < MAX_HIERARCHY_DEPTH) {
+        for (const marker of markers) {
+            try {
+                if (fs.existsSync(path.join(dir, marker)))
+                    return dir;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+        depth++;
+    }
+    return null;
+}
+/** Accepted instruction filenames for a project (config-driven). */
+export function getAcceptedFileNames(projectRoot = process.cwd()) {
+    return loadContextConfig(projectRoot).fileNames;
+}
+/**
+ * Startup pass: global tier + the project hierarchy from root DOWN to cwd.
+ * Call once per prompt build. Populates `registry` (if given) so the later JIT
+ * pass skips files already in the system prompt.
+ */
+export function resolveProjectContext(opts = {}) {
+    const cwd = path.resolve(opts.cwd ?? process.cwd());
+    const root = path.resolve(opts.projectRoot ?? findProjectRoot(cwd) ?? cwd);
+    const cfg = loadContextConfig(root);
+    const names = opts.fileNames ?? cfg.fileNames;
+    const homeDir = opts.homeDir ?? os.homedir();
+    const registry = opts.registry ?? new ContextRegistry();
+    const loaded = [];
+    // Tier 1 — global (~/.codebuddy/), lowest precedence (appended first).
+    const globalDir = path.join(homeDir, '.codebuddy');
+    loaded.push(...collectDir(globalDir, 'global', names, root, registry, homeDir, cfg));
+    // Tier 2 — hierarchy, project root → cwd inclusive (closest appended last).
+    for (const dir of getDirectoryChain(root, cwd)) {
+        for (const probe of [dir, ...SUBDIR_PROBES.map((s) => path.join(dir, s))]) {
+            loaded.push(...collectDir(probe, 'hierarchy', names, root, registry, homeDir, cfg));
+        }
+    }
+    return budgetMerge(loaded, opts.budgetBytes ?? cfg.maxBytes);
+}
+/**
+ * JIT pass: when a tool touches `accessedPath`, load any context files along its
+ * directory chain (root → accessed dir) that weren't already injected at
+ * startup (skipped via the shared `registry`). Smaller per-touch budget.
+ */
+export function resolveJitContext(accessedPath, opts = {}) {
+    const accessedDir = path.dirname(path.resolve(accessedPath));
+    const root = path.resolve(opts.projectRoot ?? findProjectRoot(accessedDir) ?? accessedDir);
+    const cfg = loadContextConfig(root);
+    const names = opts.fileNames ?? cfg.fileNames;
+    const homeDir = opts.homeDir ?? os.homedir();
+    const registry = opts.registry ?? new ContextRegistry();
+    const loaded = [];
+    for (const dir of getDirectoryChain(root, accessedDir)) {
+        for (const probe of [dir, ...SUBDIR_PROBES.map((s) => path.join(dir, s))]) {
+            loaded.push(...collectDir(probe, 'jit', names, root, registry, homeDir, cfg));
+        }
+    }
+    return budgetMerge(loaded, opts.budgetBytes ?? cfg.jitMaxBytes);
+}
+/** Directory chain from `root` to `target` (inclusive). */
+function getDirectoryChain(root, target) {
+    const resolved = path.resolve(target);
+    const resolvedRoot = path.resolve(root);
+    const chain = [resolvedRoot];
+    const rel = path.relative(resolvedRoot, resolved);
+    if (!rel || rel.startsWith('..'))
+        return chain;
+    let current = resolvedRoot;
+    for (const seg of rel.split(path.sep).filter(Boolean)) {
+        current = path.join(current, seg);
+        chain.push(current);
+    }
+    return chain;
+}
+/** Variant filenames for a base name, most-specific first. */
+function variantNames(base) {
+    const ext = path.extname(base); // '.md'
+    const stem = ext ? base.slice(0, base.length - ext.length) : base;
+    return [
+        { name: `${stem}.local${ext}`, variant: 'local' },
+        { name: `${stem}.override${ext}`, variant: 'override' },
+        { name: base, variant: 'base' },
+    ];
+}
+/**
+ * Collect every accepted instruction file present in one directory (composed),
+ * applying variant precedence, excludes, realpath dedup and @import resolution.
+ */
+function collectDir(probeDir, tier, names, root, registry, homeDir, cfg) {
+    const out = [];
+    const isGlobal = tier === 'global';
+    for (const base of names) {
+        // First existing variant wins (local > override > base) and replaces it.
+        let chosen = null;
+        for (const v of variantNames(base)) {
+            const filePath = path.join(probeDir, v.name);
+            try {
+                if (fs.statSync(filePath).isFile()) {
+                    chosen = { filePath, variant: v.variant };
+                    break;
+                }
+            }
+            catch {
+                /* not present */
+            }
+        }
+        if (!chosen)
+            continue;
+        // Project files honor codebuddyMdExcludes; global files are never excluded.
+        if (!isGlobal && shouldExcludeInstructionFile(chosen.filePath, root))
+            continue;
+        let realpath;
+        try {
+            realpath = fs.realpathSync(chosen.filePath);
+        }
+        catch {
+            realpath = chosen.filePath;
+        }
+        if (registry.has(realpath))
+            continue;
+        let body;
+        try {
+            body = fs.readFileSync(chosen.filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        if (!body.trim())
+            continue;
+        // User-authored, trusted files: warn (don't drop) on shell-exec-like
+        // patterns — dropping would break legitimate AGENTS.md that documents them.
+        if (containsDangerousPatterns(body)) {
+            logger.warn(`Context file ${chosen.filePath} contains shell-exec-like patterns; loading anyway (user-authored).`);
+        }
+        body = resolveImportDirectives(body, {
+            baseDir: probeDir,
+            projectRoot: root,
+            homeDir,
+            maxDepth: cfg.importMaxDepth,
+            maxBytes: cfg.importMaxBytes,
+        });
+        registry.add(realpath);
+        out.push({
+            path: chosen.filePath,
+            realpath,
+            relPath: displayPath(chosen.filePath, root, homeDir, isGlobal),
+            tier,
+            variant: chosen.variant,
+            body,
+        });
+    }
+    return out;
+}
+/** Deterministic, abs-path-free display path for the origin header. */
+function displayPath(filePath, root, homeDir, isGlobal) {
+    if (isGlobal) {
+        const rel = path.relative(path.join(homeDir, '.codebuddy'), filePath).replace(/\\/g, '/');
+        return `~/.codebuddy/${rel}`;
+    }
+    return path.relative(root, filePath).replace(/\\/g, '/') || path.basename(filePath);
+}
+/** Merge loaded sources under a budget, truncating the overflowing source. */
+function budgetMerge(sources, budget) {
+    let total = 0;
+    let truncated = false;
+    const parts = [];
+    const outSources = [];
+    for (const s of sources) {
+        if (total >= budget) {
+            truncated = true;
+            break;
+        }
+        let body = s.body;
+        let sourceTruncated = false;
+        const remaining = budget - total;
+        if (body.length > remaining) {
+            body = body.slice(0, remaining) + TRUNCATION_MARKER;
+            sourceTruncated = true;
+            truncated = true;
+        }
+        parts.push(`<!-- context: ${s.relPath} (${s.tier}) -->\n${body}`);
+        total += body.length;
+        outSources.push({
+            path: s.path,
+            realpath: s.realpath,
+            relPath: s.relPath,
+            tier: s.tier,
+            variant: s.variant,
+            bytes: body.length,
+            truncated: sourceTruncated,
+        });
+    }
+    return { text: parts.join('\n\n'), sources: outSources, bytes: total, truncated };
+}
+/** Shell-exec-like patterns — used to WARN (not drop) on user-authored files. */
+function containsDangerousPatterns(content) {
+    return [
+        /\beval\s*\(/,
+        /\bnew\s+Function\s*\(/,
+        /\brequire\s*\(\s*['"]child_process['"]\s*\)/,
+        /\bexec(?:Sync)?\s*\(/,
+        /\bspawn(?:Sync)?\s*\(/,
+        /<script\b/i,
+    ].some((p) => p.test(content));
+}
+//# sourceMappingURL=project-context.js.map

package/dist/daemon/autonomous-daemon.d.ts

@@ -89,7 +89,7 @@ export interface DefaultAutonomousLoopOptions {
  * local/network executor. The CLI uses this so the same config drives one-shot
  * and continuous runs.
  */
-export declare function createDefaultAutonomousLoop(opts?: DefaultAutonomousLoopOptions): FleetAutonomousLoop;
+export declare function createDefaultAutonomousLoop(opts?: DefaultAutonomousLoopOptions): Promise<FleetAutonomousLoop>;
 /**
  * Event source for {@link AutonomousDaemonConfig.eventSourceFactory}: watches the
  * fleet queue file (`colab-tasks.json`) and calls `onChange` when it changes —

package/dist/daemon/autonomous-daemon.js

@@ -13,7 +13,7 @@
  * (see {@link createAgentTaskExecutor}).
  */
 import { FleetColabStore } from '../fleet/colab-store.js';
-import { resolveModelTierConfig } from '../agent/model-tier.js';
+import { resolveLiveModelTierConfig, } from '../agent/model-tier.js';
 import { FileWatcherTrigger } from '../agent/file-watcher-trigger.js';
 import { FleetAutonomousLoop } from './autonomous-loop.js';
 import { createLocalModelTaskExecutor } from './ollama-task-executor.js';
@@ -116,12 +116,12 @@ export class FleetAutonomousDaemon {
  * local/network executor. The CLI uses this so the same config drives one-shot
  * and continuous runs.
  */
-export function createDefaultAutonomousLoop(opts = {}) {
+export async function createDefaultAutonomousLoop(opts = {}) {
     const store = new FleetColabStore({
         ...(opts.dir ? { dir: opts.dir } : {}),
         ...(opts.agentId ? { agentId: opts.agentId } : {}),
     });
-    const tierConfig = resolveModelTierConfig();
+    const tierConfig = await resolveLiveModelTierConfig();
     const executorMode = opts.executorMode ?? (process.env['CODEBUDDY_AUTONOMY_EXECUTOR'] === 'agent' ? 'agent' : 'artifact');
     const executor = executorMode === 'agent'
         ? createAgentTaskExecutor({ ...(opts.workspaceRoot ? { workspaceRoot: opts.workspaceRoot } : {}) })

package/dist/daemon/autonomous-loop.d.ts

@@ -37,6 +37,15 @@ export interface TaskExecutionResult {
     output?: string;
 }
 export type TaskExecutor = (task: ColabTask, model: AutonomousModelChoice) => Promise<TaskExecutionResult>;
+/**
+ * Idle-time self-improvement hook. Runs ONE bounded improvement cycle and reports
+ * whether it kept anything. Injected so the loop stays testable and the heavy
+ * engine is swappable; the default (lazy) hook runs the tool-improvement engine.
+ */
+export type SelfImproveHook = () => Promise<{
+    applied: boolean;
+    detail: string;
+}>;
 export interface AutonomousLoopConfig {
     store: FleetColabStore;
     tierConfig: ModelTierConfig;
@@ -49,9 +58,19 @@ export interface AutonomousLoopConfig {
      * goal-mode tasks complete like plain tasks (no judge gate).
      */
     goalJudge?: ColabGoalJudge;
+    /**
+     * Idle-time self-improvement. When the queue is empty AND
+     * `CODEBUDDY_SELF_IMPROVE=true`, run one bounded improvement cycle (cooldown-
+     * gated). Injected for tests; defaults to the tool-improvement engine.
+     */
+    selfImprove?: SelfImproveHook;
+    /** Minimum ms between idle self-improvement cycles (default 15 min). */
+    selfImproveCooldownMs?: number;
+    /** Clock for the cooldown (tests). Default Date.now. */
+    now?: () => number;
 }
 export interface TickResult {
-    outcome: 'disabled' | 'idle' | 'completed' | 'failed' | 'saturated' | 'goal_continue' | 'goal_blocked';
+    outcome: 'disabled' | 'idle' | 'completed' | 'failed' | 'saturated' | 'goal_continue' | 'goal_blocked' | 'self_improved';
     taskId?: string;
     taskTitle?: string;
     model?: AutonomousModelChoice;
@@ -71,7 +90,18 @@ export declare class FleetAutonomousLoop {
      */
     private readonly failures;
     private readonly goalJudge;
+    private readonly selfImprove;
+    private readonly selfImproveCooldownMs;
+    private readonly now;
+    private lastSelfImproveAt;
     constructor(config: AutonomousLoopConfig);
+    /**
+     * Idle hook: when the queue is empty and self-improvement is opted in, run one
+     * bounded, cooldown-gated improvement cycle instead of sitting fully idle.
+     * Double-gated (idle + CODEBUDDY_SELF_IMPROVE) and bounded (cooldown + the
+     * engine no-ops once seed scenarios are covered). Never throws.
+     */
+    private maybeSelfImprove;
     /** Run a single autonomous tick. Never throws — failures are logged + reported. */
     tick(): Promise<TickResult>;
     /**

package/dist/daemon/autonomous-loop.js

@@ -23,6 +23,53 @@
 import { chooseAutonomousModel, } from '../agent/model-tier.js';
 import { beginFleetWork, isFleetSaturated } from '../fleet/fleet-load.js';
 import { DEFAULT_COLAB_GOAL_MAX_TURNS } from './colab-goal.js';
+/**
+ * Default idle self-improvement: author tools for any seed scenario NOT yet in the
+ * evolutionary archive (so it stops once the seed benchmark is covered, and the
+ * bound persists across restarts). Auto-apply; gated by the caller on idle +
+ * CODEBUDDY_SELF_IMPROVE + cooldown.
+ */
+async function defaultSelfImproveHook() {
+    const { EvolutionaryArchive } = await import('../agent/self-improvement/evolutionary-archive.js');
+    const archived = new Set(new EvolutionaryArchive().list().map((e) => e.targetScenarioId));
+    // Tools first.
+    const { ToolImprovementEngine } = await import('../agent/self-improvement/tool-engine.js');
+    const { LlmToolProposer } = await import('../agent/self-improvement/llm-tool-proposer.js');
+    const { SEED_TOOL_SCENARIOS } = await import('../agent/self-improvement/tool-benchmark.js');
+    const uncoveredTools = SEED_TOOL_SCENARIOS.filter((s) => !archived.has(s.id));
+    if (uncoveredTools.length > 0) {
+        const r = await new ToolImprovementEngine({
+            scenarios: uncoveredTools,
+            proposer: new LlmToolProposer(),
+            autonomy: 'auto-apply',
+        }).runCycle();
+        if (r.applied)
+            return { applied: true, detail: `authored tool ${r.gate?.appliedRef}` };
+    }
+    // Then skills.
+    const { SkillImprovementEngine } = await import('../agent/self-improvement/skill-engine.js');
+    const { LlmSkillProposer } = await import('../agent/self-improvement/skill-proposer.js');
+    const { SEED_SKILL_SCENARIOS } = await import('../agent/self-improvement/skill-benchmark.js');
+    const uncoveredSkills = SEED_SKILL_SCENARIOS.filter((s) => !archived.has(s.id));
+    if (uncoveredSkills.length > 0) {
+        const r = await new SkillImprovementEngine({
+            scenarios: uncoveredSkills,
+            proposer: new LlmSkillProposer(),
+            autonomy: 'auto-apply',
+        }).runCycle();
+        if (r.applied)
+            return { applied: true, detail: `authored skill ${r.gate?.appliedRef}` };
+    }
+    return { applied: false, detail: 'all seed tool + skill scenarios already covered (or no proposal)' };
+}
+function resolveGoalMaxTurns(raw) {
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw > 0
+        ? raw
+        : DEFAULT_COLAB_GOAL_MAX_TURNS;
+}
+function resolveGoalTurnsUsed(raw) {
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0 ? raw : 0;
+}
 export class FleetAutonomousLoop {
     store;
     tierConfig;
@@ -37,6 +84,10 @@ export class FleetAutonomousLoop {
      */
     failures = new Map();
     goalJudge;
+    selfImprove;
+    selfImproveCooldownMs;
+    now;
+    lastSelfImproveAt = Number.NEGATIVE_INFINITY;
     constructor(config) {
         this.store = config.store;
         this.tierConfig = config.tierConfig;
@@ -44,6 +95,40 @@ export class FleetAutonomousLoop {
         this.policy = config.policy ?? {};
         this.enabled = config.enabled ?? (() => true);
         this.goalJudge = config.goalJudge;
+        this.selfImprove = config.selfImprove ?? defaultSelfImproveHook;
+        this.selfImproveCooldownMs = config.selfImproveCooldownMs ?? 15 * 60 * 1000;
+        this.now = config.now ?? (() => Date.now());
+    }
+    /**
+     * Idle hook: when the queue is empty and self-improvement is opted in, run one
+     * bounded, cooldown-gated improvement cycle instead of sitting fully idle.
+     * Double-gated (idle + CODEBUDDY_SELF_IMPROVE) and bounded (cooldown + the
+     * engine no-ops once seed scenarios are covered). Never throws.
+     */
+    async maybeSelfImprove() {
+        if (process.env.CODEBUDDY_SELF_IMPROVE !== 'true') {
+            this.store.updatePresence({ status: 'idle', currentTask: null });
+            return { outcome: 'idle' };
+        }
+        const now = this.now();
+        if (now - this.lastSelfImproveAt < this.selfImproveCooldownMs) {
+            this.store.updatePresence({ status: 'idle', currentTask: null });
+            return { outcome: 'idle', detail: 'self-improve on cooldown' };
+        }
+        this.lastSelfImproveAt = now;
+        this.store.updatePresence({ status: 'active', currentTask: 'self-improvement' });
+        const doneLoad = beginFleetWork('autonomy.task');
+        try {
+            const r = await this.selfImprove();
+            return { outcome: r.applied ? 'self_improved' : 'idle', detail: r.detail };
+        }
+        catch (err) {
+            return { outcome: 'idle', detail: `self-improve error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+        finally {
+            doneLoad();
+            this.store.updatePresence({ status: 'idle', currentTask: null });
+        }
     }
     /** Run a single autonomous tick. Never throws — failures are logged + reported. */
     async tick() {
@@ -63,8 +148,9 @@ export class FleetAutonomousLoop {
         this.store.updatePresence({ status: 'active' });
         const next = this.store.nextClaimable();
         if (!next) {
-            this.store.updatePresence({ status: 'idle', currentTask: null });
-            return { outcome: 'idle' };
+            // No real work — use the idle moment for one bounded self-improvement
+            // cycle (opt-in + cooldown), otherwise sit idle.
+            return this.maybeSelfImprove();
         }
         // Claim. If another agent won the race between read and claim, treat it as
         // idle for this tick rather than crashing.
@@ -145,11 +231,12 @@ export class FleetAutonomousLoop {
         }
         if (verdict.verdict !== 'continue')
             return null;
-        const maxTurns = task.goalMaxTurns ?? DEFAULT_COLAB_GOAL_MAX_TURNS;
-        const turnsUsed = (task.goalTurnsUsed ?? 0) + 1;
+        const maxTurns = resolveGoalMaxTurns(task.goalMaxTurns);
+        const turnsUsed = resolveGoalTurnsUsed(task.goalTurnsUsed) + 1;
         if (turnsUsed >= maxTurns) {
             // Hermes rule: block for human review instead of spinning forever.
             const reason = `goal budget exhausted (${turnsUsed}/${maxTurns}) — judge: ${verdict.reason}`;
+            this.store.recordGoalTurn(task.id, verdict.reason);
             this.store.blockTask(task.id, reason);
             this.store.appendWorklog({
                 agent: this.store.agentId,

package/dist/daemon/colab-goal.js

@@ -12,6 +12,7 @@
  * "continue", and the turn budget is the backstop.
  */
 import { CodeBuddyClient } from '../codebuddy/client.js';
+import { resolveGoalJudgeClient } from '../goals/goal-judge-client.js';
 import { judgeGoal } from '../goals/goal-judge.js';
 import { resolveGoalsConfig } from '../goals/goal-manager.js';
 import { logger } from '../utils/logger.js';
@@ -54,12 +55,19 @@ export function createColabGoalJudge() {
     return async (task, result, model) => {
         try {
             const config = resolveGoalsConfig();
-            const client = new CodeBuddyClient(process.env.GROK_API_KEY || process.env.OPENAI_API_KEY || 'local', config.judgeModel || model.model, model.baseUrl);
+            const apiKey = process.env.GROK_API_KEY || process.env.OPENAI_API_KEY || 'local';
+            const baseClient = new CodeBuddyClient(apiKey, model.model, model.baseUrl);
+            const client = await resolveGoalJudgeClient(baseClient, config.judgeModel, {
+                apiKey,
+                ...(model.baseUrl ? { baseURL: model.baseUrl } : {}),
+                providerLabel: model.baseUrl?.includes(':11434') ? 'ollama' : model.tier,
+            });
             return await judgeGoal(client, {
                 goal: goalTextForTask(task),
                 lastResponse: result.output || result.summary,
                 ...(task.acceptanceCriteria?.length ? { subgoals: task.acceptanceCriteria } : {}),
                 ...(config.judgeModel ? { model: config.judgeModel } : {}),
+                maxTokens: config.judgeMaxTokens,
                 timeoutMs: config.judgeTimeoutMs,
             });
         }

package/dist/daemon/cron-agent-bridge.d.ts

@@ -40,6 +40,12 @@ export interface JobExecutionResult {
     skipReason?: string;
     /** For watchdog jobs: false when any check produced an alert/error. */
     watchdogOk?: boolean;
+    /**
+     * Structured output data for cross-job data passing. When this job is part
+     * of a chain (`then`), its outputData is forwarded as the next job's
+     * inputData.
+     */
+    outputData?: string;
 }
 export declare class CronAgentBridge extends EventEmitter {
     private config;
@@ -48,11 +54,11 @@ export declare class CronAgentBridge extends EventEmitter {
     /**
      * Create a task executor function for the CronScheduler
      */
-    createTaskExecutor(): (job: CronJob) => Promise<unknown>;
+    createTaskExecutor(): (job: CronJob, inputData?: string) => Promise<unknown>;
     /**
      * Execute a cron job by creating an agent instance
      */
-    executeJob(job: CronJob): Promise<JobExecutionResult>;
+    executeJob(job: CronJob, inputData?: string): Promise<JobExecutionResult>;
     /**
      * Start a durable run record for a job execution, when an observability store
      * is configured. Returns the run id, or undefined when recording is disabled
@@ -86,8 +92,11 @@ export declare class CronAgentBridge extends EventEmitter {
      * WITHOUT instantiating a CodeBuddyAgent or calling any model provider.
      * A non-zero exit (or timeout) throws so the run is recorded as failed and
      * any chained `then` job does not fire.
+     *
+     * Returns both the combined output (for logging/delivery) and the separate
+     * stdout (for cross-job data passing, capped at 64KB by the script runner).
      */
-    private executeScriptTask;
+    private executeScriptTaskFull;
     /**
      * Execute a skill-type task — resolves a named skill from the SkillRegistry
      * and runs it via the SkillExecutor. Without a configured tool executor the