@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/services/prompt-builder.js

@@ -13,6 +13,7 @@ import { logger } from "../utils/logger.js";
 import { getErrorMessage } from "../errors/index.js";
 import { getSystemPromptForMode, getPromptManager, autoSelectPromptId, getChatOnlySystemPrompt, } from "../prompts/index.js";
 import { getModelToolConfig } from "../config/model-tools.js";
+import { resolveProjectContext, createContextRegistry, setActiveContextRegistry } from "../context/project-context.js";
 import { classifyQuery } from "../agent/execution/query-classifier.js";
 import { filterToolNames, getToolFilter, isToolNameAllowed, } from "../utils/tool-filter.js";
 const ALL_BLOCKS = {
@@ -30,6 +31,7 @@ const ALL_BLOCKS = {
     includeWritingRules: true,
     includeCodingStyle: true,
     includeWorkflowRules: true,
+    includeExecutionDiscipline: true,
     includeVariation: true,
 };
 const EXTERNAL_PROMPT_MANAGER_TOOLS = [
@@ -64,6 +66,13 @@ export class PromptBuilder {
     memory;
     moltbotHooksManager;
     persistentMemory;
+    /**
+     * Dedup registry for project-instruction files, recreated fresh at the start
+     * of each system-prompt build. The JIT context pass reads it (via
+     * `getContextRegistry()`) so files already injected at startup are not
+     * re-injected when a tool later touches a file in the same tree.
+     */
+    contextRegistry = null;
     constructor(config, promptCacheManager, memory, moltbotHooksManager, persistentMemory) {
         this.config = config;
         this.promptCacheManager = promptCacheManager;
@@ -71,6 +80,10 @@ export class PromptBuilder {
         this.moltbotHooksManager = moltbotHooksManager;
         this.persistentMemory = persistentMemory;
     }
+    /** The registry from the most recent system-prompt build (for the JIT pass). */
+    getContextRegistry() {
+        return this.contextRegistry;
+    }
     /**
      * Build the system prompt for the agent. The optional `options`
      * parameter gates per-block injection. All gates default to `true`
@@ -83,13 +96,17 @@ export class PromptBuilder {
         // confuse the LLM into hallucinating JSON tool calls. Force-off here.
         const toolCfg = getModelToolConfig(modelName);
         const activeToolFilter = getToolFilter();
-        if (toolCfg.supportsToolCalls === false) {
+        const forceTools = process.env.GROK_FORCE_TOOLS === 'true';
+        if (toolCfg.supportsToolCalls === false && !forceTools) {
             gates.includeMemoryDirective = false;
             gates.includeLessonsDirective = false;
             gates.includeUserModelDirective = false;
             gates.includeWorkflowRules = false;
+            gates.includeExecutionDiscipline = false;
         }
-        if (!isToolNameAllowed('remember', activeToolFilter)) {
+        const rememberToolAllowed = isToolNameAllowed('remember', activeToolFilter);
+        const memoryProposeToolAllowed = isToolNameAllowed('memory_propose', activeToolFilter);
+        if (!rememberToolAllowed && !memoryProposeToolAllowed) {
             gates.includeMemoryDirective = false;
         }
         if (!['lessons_add', 'lessons_search', 'lessons_graph'].every(toolName => isToolNameAllowed(toolName, activeToolFilter))) {
@@ -188,7 +205,7 @@ export class PromptBuilder {
                 });
                 logger.debug(`Auto-selected prompt: ${autoId} (based on ${modelName})`);
             }
-            else if (toolCfg.supportsToolCalls === false) {
+            else if (toolCfg.supportsToolCalls === false && !forceTools) {
                 // Chat-only base prompt for models that can't dispatch tool calls.
                 // The default body lists `bash`, `view_file`, `str_replace_editor`,
                 // etc. by name — small Ollama models read those mentions and try to
@@ -223,18 +240,56 @@ export class PromptBuilder {
                 systemPrompt = `# Role & Instructions (from intro_hook.txt)\n\n${introHookContent}\n\n---\n\n${systemPrompt}`;
                 logger.debug("Prepended intro hook content to system prompt");
             }
-            // Inject bootstrap context files (BOOTSTRAP.md, AGENTS.md, SOUL.md, etc.)
+            // Inject execution-discipline guidance (tool-use enforcement, anti-stub
+            // completion, mandatory-tool, pre-finalize self-check). Borrowed from the
+            // Hermes Agent prompt audit — its highest-leverage agentic-reliability
+            // block. Placed HERE in the STABLE PREFIX (not near the footer) on
+            // purpose: the footer reminder section is shuffled by the variation
+            // injector (varySystemPrompt → extractBlocks splits on bullet lines), so
+            // a late placement fragmented this block — foreign bullets got interleaved
+            // between its lines. Up here it stays contiguous, cache-stable, and
+            // survives head-truncation. Gated off for trivial/lite + tool-callless
+            // models (see gating above).
+            if (gates.includeExecutionDiscipline) {
+                try {
+                    const { getExecutionDisciplineBlock } = await import('../prompts/execution-discipline.js');
+                    systemPrompt += '\n\n' + getExecutionDisciplineBlock();
+                    logger.debug('Injected execution-discipline guidance into system prompt');
+                }
+                catch (err) {
+                    logger.warn('Failed to inject execution-discipline block', { error: getErrorMessage(err) });
+                }
+            }
+            // Inject project-instruction context (AGENTS.md / CODEBUDDY.md / CLAUDE.md
+            // / GEMINI.md / CONTEXT.md / INSTRUCTIONS.md) via the unified hierarchical
+            // loader, then soul/bootstrap files. A fresh dedup registry is created per
+            // build and reused by the JIT pass (`getContextRegistry`).
             if (gates.includeBootstrap) {
+                this.contextRegistry = createContextRegistry();
+                // Publish for the JIT pass so it skips files injected here at startup.
+                setActiveContextRegistry(this.contextRegistry);
+                try {
+                    const ctx = resolveProjectContext({ cwd: this.config.cwd, registry: this.contextRegistry });
+                    if (ctx.text) {
+                        systemPrompt += '\n\n# Workspace Context\n\n' + ctx.text;
+                        logger.debug(`Loaded project context from ${ctx.sources.length} file(s)`, {
+                            sources: ctx.sources.map((s) => s.relPath),
+                            chars: ctx.bytes,
+                            truncated: ctx.truncated,
+                        });
+                    }
+                }
+                catch (err) {
+                    logger.warn("Failed to load project context", { error: getErrorMessage(err) });
+                }
+                // Soul/identity bootstrap files (SOUL.md, USER.md, …) + PROJECT_KNOWLEDGE.md.
+                // Instruction files are handled above by the unified loader, not here.
                 try {
                     const { BootstrapLoader } = await import('../context/bootstrap-loader.js');
                     const bootstrap = await new BootstrapLoader().load(this.config.cwd);
                     if (bootstrap.content) {
-                        systemPrompt += '\n\n# Workspace Context\n\n' + bootstrap.content;
-                        logger.debug(`Loaded bootstrap context from ${bootstrap.sources.length} file(s)`, {
-                            sources: bootstrap.sources,
-                            chars: bootstrap.tokenCount,
-                            truncated: bootstrap.truncated,
-                        });
+                        systemPrompt += '\n\n' + bootstrap.content;
+                        logger.debug(`Loaded bootstrap/soul context from ${bootstrap.sources.length} file(s)`);
                     }
                 }
                 catch (err) {
@@ -300,6 +355,31 @@ export class PromptBuilder {
                 }
                 catch { /* rules module optional */ }
             }
+            // Steer toward Code Explorer (gitnexus) when it is connected. Conditional:
+            // when Code Explorer is absent this injects nothing, so the built-in
+            // code_graph/codebase_map behaviour is unchanged. Presence is session-
+            // stable, so this stays in the cache-stable prefix.
+            try {
+                const { isCodeExplorerAvailable } = await import('../codebuddy/tools.js');
+                if (isCodeExplorerAvailable()) {
+                    systemPrompt +=
+                        `\n\n<code_explorer_priority>\n` +
+                            `Code Explorer (gitnexus) is connected. For ANY question about code relationships — ` +
+                            `callers/callees, blast radius / impact ("what breaks if I change X"), dead code, cycles, ` +
+                            `coupling, complexity — PREFER its MCP tools (\`mcp__gitnexus__impact\`, ` +
+                            `\`mcp__gitnexus__context\`, \`mcp__gitnexus__query\`, \`mcp__gitnexus__find_cycles\`, …) ` +
+                            `over the built-in \`code_graph\` / \`codebase_map\`: the gitnexus graph is broader and more ` +
+                            `complete (whole-repo, 14 languages).\n` +
+                            `Usage: first call \`mcp__gitnexus__list_repos\` once to get the repo \`path\`/\`id\`, then call ` +
+                            `\`mcp__gitnexus__impact\` with the REQUIRED \`target\` = the symbol name (e.g. \`target: "executePlan"\`, ` +
+                            `optionally \`direction: "both"\`) and \`repo\` = that path; or \`mcp__gitnexus__context\` with \`name\` = ` +
+                            `the symbol. Always include \`target\`/\`name\` — never call these tools with empty arguments. ` +
+                            `Use the built-in \`code_graph\`/\`codebase_map\` only as a fallback if a gitnexus tool errors.\n` +
+                            `</code_explorer_priority>`;
+                    logger.debug('Injected Code Explorer priority directive');
+                }
+            }
+            catch { /* tools module optional */ }
             // Inject active skill prompt enhancement
             if (gates.includeSkills) {
                 try {
@@ -313,10 +393,11 @@ export class PromptBuilder {
                 }
                 catch { /* skills module optional */ }
             }
-            // Inject identity (SOUL.md, USER.md, AGENTS.md) — skip if already present to avoid duplication
+            // Inject identity (SOUL.md, USER.md, …) — skip if already present to avoid duplication.
+            // AGENTS.md/INSTRUCTIONS.md are owned by the unified loader, not identity.
             if (gates.includeIdentity) {
                 try {
-                    if (!systemPrompt.includes('## SOUL.md') && !systemPrompt.includes('## AGENTS.md')) {
+                    if (!systemPrompt.includes('## SOUL.md')) {
                         const { getIdentityManager } = await import('../identity/identity-manager.js');
                         const identityMgr = getIdentityManager();
                         await identityMgr.load(this.config.cwd);
@@ -361,17 +442,32 @@ export class PromptBuilder {
                 }
                 catch { /* fleet registry optional — module not loaded yet */ }
             }
-            // Inject auto-memory directive — tells the LLM WHEN to call the
-            // `remember` tool to auto-persist non-obvious facts to
+            // Inject auto-memory directive — tells the LLM WHEN to call `remember`
+            // or the review-gated `memory_propose` tool for non-obvious facts from
             // .codebuddy/CODEBUDDY_MEMORY.md (project) or ~/.codebuddy/memory.md
             // (user). Without this directive, the tool is registered but the LLM
             // has no instruction on when to use it, so the file stays empty.
-            // Paired with `alwaysInclude: ['remember']` in tool-selection-strategy.
+            // Paired with `alwaysInclude: ['remember', 'memory_propose']` in
+            // tool-selection-strategy.
             if (this.config.memoryEnabled && this.persistentMemory && gates.includeMemoryDirective) {
+                const memoryWriteInstruction = memoryProposeToolAllowed
+                    ? 'Use `remember` only for explicit, high-confidence durable facts. Use `memory_propose` for inferred, ambiguous, or model-derived facts so the user can review them before they become prompt-injected memory.'
+                    : 'Use `remember` only for explicit, high-confidence durable facts. Do not store inferred or ambiguous facts silently.';
+                const inferredFactInstruction = memoryProposeToolAllowed
+                    ? 'When to call `memory_propose`:'
+                    : 'When to consider durable memory, but skip if it is only inferred or ambiguous:';
+                const closingMemoryInstruction = memoryProposeToolAllowed
+                    ? 'Prefer `memory_propose` over `remember` when the fact came from your interpretation rather than an explicit user instruction.'
+                    : 'Only call `remember` when the fact came from an explicit user instruction or correction.';
                 systemPrompt += `\n\n<auto_memory_directive>
-You have a persistent memory system at .codebuddy/CODEBUDDY_MEMORY.md (project-scoped) and ~/.codebuddy/memory.md (user-scoped, all projects). Use the \`remember\` tool to save facts that will be useful in future sessions.
+You have a persistent memory system at .codebuddy/CODEBUDDY_MEMORY.md (project-scoped) and ~/.codebuddy/memory.md (user-scoped, all projects).
+${memoryWriteInstruction}
 
 When to call \`remember\`:
+- The user explicitly says to remember/store a fact or preference
+- The user directly corrects an existing stable fact
+
+${inferredFactInstruction}
 - User preferences ("user prefers single quotes", "always use Vitest, not Jest")
 - Architectural decisions ("API uses JWT in HttpOnly cookies, not localStorage")
 - Non-obvious gotchas ("vi.hoisted() needed for mock factories in this repo")
@@ -388,7 +484,7 @@ Format:
 - \`scope\`: \`project\` (default — fact is specific to THIS repo) or \`user\` (preference across all projects)
 - \`category\`: \`preferences\`, \`decisions\`, \`patterns\`, \`project\`, or \`custom\`
 
-Call \`remember\` proactively when you learn something worth remembering — don't wait for the user to ask.
+${closingMemoryInstruction}
 </auto_memory_directive>`;
                 logger.debug('Injected auto-memory directive into system prompt');
             }
@@ -435,6 +531,16 @@ Lessons complement \`remember\`: \`remember\` stores facts (preferences, decisio
 </lessons_directive>`;
                 logger.debug('Injected lessons directive into system prompt');
             }
+            // Self-knowledge — only when self-improvement is explicitly opted in. Makes
+            // the agent aware it can author its own tools/skills (and the hard `src/` limit).
+            if (process.env.CODEBUDDY_SELF_IMPROVE === 'true') {
+                try {
+                    const { buildSelfKnowledgeBlock } = await import('../agent/self-improvement/self-knowledge.js');
+                    systemPrompt += `\n\n<self_knowledge>\n${buildSelfKnowledgeBlock()}\n</self_knowledge>`;
+                    logger.debug('Injected self-knowledge block into system prompt');
+                }
+                catch { /* self-improvement module optional */ }
+            }
             if (this.config.memoryEnabled && gates.includeUserModelDirective) {
                 systemPrompt += `\n\n<user_model_directive>
 You have a persistent user model that builds a deepening profile of who you are, your traits, preferences, expertise, and working style.
@@ -642,6 +748,7 @@ export function gatesForComplexity(complexity) {
                 includeWritingRules: true,
                 includeCodingStyle: false,
                 includeWorkflowRules: false,
+                includeExecutionDiscipline: false,
                 includeVariation: false,
             };
         case 'simple':

package/dist/shared/engine-types.d.ts

@@ -7,7 +7,7 @@
  *
  * @module shared/engine-types
  */
-export type EngineStreamEventType = 'content' | 'thinking' | 'tool_start' | 'tool_end' | 'tool_stream' | 'token_count' | 'cost' | 'done' | 'error' | 'ask_user' | 'plan_progress' | 'diff_preview';
+export type EngineStreamEventType = 'content' | 'thinking' | 'tool_start' | 'tool_end' | 'tool_stream' | 'token_count' | 'cost' | 'done' | 'error' | 'ask_user' | 'plan_progress' | 'steer' | 'diff_preview' | 'goal_status';
 export interface EngineStreamEvent {
     type: EngineStreamEventType;
     /** Incremental text delta */
@@ -47,6 +47,11 @@ export interface EngineStreamEvent {
         completed: number;
         message?: string;
     };
+    /** User guidance delivered to an active run. */
+    steer?: {
+        content: string;
+        source: string;
+    };
     /** Diff preview */
     diffPreview?: {
         turnId: number;
@@ -59,6 +64,15 @@ export interface EngineStreamEvent {
         }>;
         plan?: string;
     };
+    /** Autonomous goal-loop progress (for host UIs like the Cowork goal banner). */
+    goalStatus?: {
+        goal: string;
+        status: 'active' | 'paused' | 'done' | 'cleared';
+        turnsUsed: number;
+        maxTurns: number;
+        lastVerdict?: 'done' | 'continue' | 'skipped';
+        lastReason?: string;
+    };
 }
 export interface EngineMessage {
     role: 'user' | 'assistant' | 'system';

package/dist/sidecar/sidecar-bridge.d.ts

@@ -46,6 +46,7 @@ export declare class SidecarBridge {
      * Find the sidecar binary
      */
     private findBinary;
+    private isExecutableCandidate;
     /**
      * Check if sidecar is available
      */

package/dist/sidecar/sidecar-bridge.js

@@ -11,7 +11,7 @@
 import { spawn } from 'child_process';
 import { createInterface } from 'readline';
 import { join } from 'path';
-import { existsSync } from 'fs';
+import { accessSync, constants, existsSync } from 'fs';
 import { logger } from '../utils/logger.js';
 // ============================================================================
 // Sidecar Bridge
@@ -27,23 +27,34 @@ export class SidecarBridge {
      * Find the sidecar binary
      */
     findBinary() {
+        const localBinary = process.platform === 'win32' ? 'codebuddy-sidecar.exe' : 'codebuddy-sidecar';
         const candidates = [
             // Development: built via `cargo build`
-            join(process.cwd(), 'src-sidecar', 'target', 'release', 'codebuddy-sidecar.exe'),
-            join(process.cwd(), 'src-sidecar', 'target', 'release', 'codebuddy-sidecar'),
-            join(process.cwd(), 'src-sidecar', 'target', 'debug', 'codebuddy-sidecar.exe'),
-            join(process.cwd(), 'src-sidecar', 'target', 'debug', 'codebuddy-sidecar'),
+            join(process.cwd(), 'src-sidecar', 'target', 'release', localBinary),
+            join(process.cwd(), 'src-sidecar', 'target', 'debug', localBinary),
             // Installed globally
-            join(process.env.HOME || process.env.USERPROFILE || '', '.cargo', 'bin', 'codebuddy-sidecar.exe'),
-            join(process.env.HOME || process.env.USERPROFILE || '', '.cargo', 'bin', 'codebuddy-sidecar'),
+            join(process.env.HOME || process.env.USERPROFILE || '', '.cargo', 'bin', localBinary),
         ];
-        for (const path of candidates) {
-            if (existsSync(path)) {
-                return path;
+        for (const candidate of candidates) {
+            if (this.isExecutableCandidate(candidate)) {
+                return candidate;
             }
         }
         return null;
     }
+    isExecutableCandidate(filePath) {
+        if (!existsSync(filePath))
+            return false;
+        if (process.platform === 'win32')
+            return true;
+        try {
+            accessSync(filePath, constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Check if sidecar is available
      */

package/dist/skills/parser.js

@@ -92,6 +92,9 @@ function parseMetadata(yamlContent, sourcePath) {
             // CC11: context fork and disable-model-invocation
             contextFork: parsed.context === 'fork' || parsed.contextFork === true,
             disableModelInvocation: parsed['disable-model-invocation'] === true || parsed.disableModelInvocation === true,
+            pinned: parsed.pinned === true,
+            imported: parsed.imported === true,
+            source: parsed.source,
         };
     }
     catch (error) {

package/dist/skills/skill-importer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Skill importer — bring EXTERNAL skills (a Hermes repo, any skills directory)
+ * into Code Buddy, safely. External skills are untrusted and get injected into the
+ * agent's context, so the firewall gates every one (SKILL.md + its scripts) before
+ * install. Hermes nests 1–3 levels but our registry walks 1 level → flatten; Hermes
+ * tags live under `metadata.hermes.tags` but our discovery scores top-level `tags` +
+ * `nativeEngine.triggers` → remap, else an imported skill is invisible to matching.
+ *
+ * Imported skills are namespaced `imported-*` (distinct provenance; never touched by
+ * the self-improvement engine) and installed flat (1 level) under a tier root.
+ *
+ * @module skills/skill-importer
+ */
+export declare const IMPORTED_PREFIX = "imported-";
+export interface ImportOptions {
+    /** Tier dir to install under. Default ~/.codebuddy/skills/managed. */
+    destRoot?: string;
+    /** Provenance label written to frontmatter (e.g. "hermes"). */
+    source?: string;
+    /** When true, scan + report but write nothing. */
+    dryRun?: boolean;
+    /** Import skills the firewall flags as 'review' (default: skip them). */
+    includeReview?: boolean;
+    /** Overwrite an existing imported-<name> (default: skip). */
+    overwrite?: boolean;
+    /** Only import skills whose source path contains this substring. */
+    category?: string;
+    /** Pin imported skills so curation leaves them alone (default true). */
+    pinByDefault?: boolean;
+}
+export interface ImportedSkill {
+    name: string;
+    sourcePath: string;
+    verdict: string;
+}
+export interface SkippedSkill {
+    sourcePath: string;
+    reason: string;
+    verdict?: string;
+}
+export interface ImportReport {
+    imported: ImportedSkill[];
+    quarantined: SkippedSkill[];
+    review: SkippedSkill[];
+    skipped: SkippedSkill[];
+    total: number;
+    dryRun: boolean;
+}
+/** Recursively find skill directories (those containing a SKILL.md). Skips operational dirs. */
+export declare function findSkillDirs(root: string): string[];
+/** Build a Code-Buddy-shaped SKILL.md from a raw (e.g. Hermes) frontmatter object + body. */
+export declare function remapSkill(rawFm: Record<string, unknown>, body: string, opts: {
+    slug: string;
+    source: string;
+    pinned: boolean;
+}): string;
+/** Import skills from a directory. Pure-ish: writes nothing when dryRun. */
+export declare function importSkills(sourceDir: string, options?: ImportOptions): ImportReport;