salmon-loop 0.2.13 → 0.3.0

package/dist/core/llm/utils.js

@@ -10,32 +10,22 @@ export function formatContextForPrompt(context, options = {}) {
     }
     return formatContextForXmlPrompt(context);
 }
-export function extractJson(content) {
-    // 1. Try to find JSON block
-    const jsonBlockMatch = content.match(/```json\s*\n([\s\S]*?)\n```/);
-    if (jsonBlockMatch) {
-        try {
-            return JSON.parse(jsonBlockMatch[1]);
-        }
-        catch (__e) {
-            // Fallback to raw content if block is invalid
-        }
+export function parsePlanFromLLMContent(content) {
+    const trimmed = String(content ?? '').trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+        throw new Error(text.llm.planInvalidJson);
     }
-    // 2. Try to find anything that looks like a JSON object
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-        try {
-            return JSON.parse(jsonMatch[0]);
-        }
-        catch (__e) {
-            // Fallback
-        }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
     }
-    // 3. Final fallback: try parsing the whole content
-    return JSON.parse(content);
-}
-export function parsePlanFromLLMContent(content) {
-    const plan = extractJson(content);
+    catch {
+        throw new Error(text.llm.planInvalidJson);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(text.llm.planInvalidJson);
+    }
+    const plan = parsed;
     if (!plan.goal || !Array.isArray(plan.files) || !Array.isArray(plan.changes) || !plan.verify) {
         throw new Error(text.llm.planInvalid);
     }
@@ -46,10 +36,9 @@ export function extractUnifiedDiffFromLLMContent(content) {
         throw wrapPatchEmpty();
     }
     const looksLikeUnifiedDiff = (text) => {
-        return /^\s*(diff --git |--- a\/)/m.test(text);
+        return /^\s*diff --git /m.test(text);
     };
-    // 1) Prefer fenced code blocks and always pick the LAST diff-like block (LLM may generate multiple attempts).
-    // Accept both git-style (`diff --git`) and minimal unified diffs (`--- a/...` + `+++ b/...`).
+    // 1) Prefer fenced code blocks and always pick the LAST canonical diff block (LLM may generate multiple attempts).
     const fencedBlocks = [];
     const fenceRegex = /```(?:diff)?\s*\n([\s\S]*?)\n```/gi;
     let fenceMatch = null;
@@ -62,10 +51,10 @@ export function extractUnifiedDiffFromLLMContent(content) {
     if (fencedBlocks.length > 0) {
         return fencedBlocks[fencedBlocks.length - 1].trim();
     }
-    // 2) Raw diff without markdown: keep the first diff-like section.
+    // 2) Raw diff without markdown: keep the first canonical diff section.
     // In "pure diff" mode, LLMs typically return only the patch, so selecting the first marker
     // avoids accidentally dropping the leading `diff --git` header.
-    const rawStart = content.search(/^\s*(diff --git |--- a\/)/m);
+    const rawStart = content.search(/^\s*diff --git /m);
     if (rawStart !== -1)
         return content.slice(rawStart).trim();
     // Final fallback: original simple cleanup

package/dist/core/memory/relevant-retrieval.js

@@ -0,0 +1,144 @@
+import { extractKeywords } from '../context/keywords.js';
+const DEFAULT_MAX_ITEMS = 3;
+const DEFAULT_MAX_SUMMARY_CHARS = 220;
+function trimToUndefined(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function clampText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function normalizeCandidate(candidate, maxSummaryChars) {
+    const path = trimToUndefined(candidate.path);
+    const title = trimToUndefined(candidate.title);
+    const summary = trimToUndefined(candidate.summary);
+    if (!path || !title || !summary)
+        return undefined;
+    const tags = Array.isArray(candidate.tags)
+        ? candidate.tags
+            .map((tag) => trimToUndefined(tag)?.toLowerCase())
+            .filter((tag) => Boolean(tag))
+        : undefined;
+    return {
+        path,
+        title,
+        summary: clampText(summary, maxSummaryChars),
+        tags,
+    };
+}
+function buildAlreadySurfacedHaystack(values) {
+    return (values ?? []).join('\n').toLowerCase();
+}
+function hasToolConflict(candidate, activeToolNames) {
+    const toolTags = (candidate.tags ?? []).filter((tag) => tag.startsWith('tool:'));
+    if (toolTags.length === 0)
+        return false;
+    const active = new Set(activeToolNames.map((name) => name.trim().toLowerCase()).filter(Boolean));
+    if (active.size === 0)
+        return false;
+    return toolTags.some((tag) => active.has(tag.slice('tool:'.length)));
+}
+function computeCandidateScore(candidate, keywords) {
+    if (keywords.length === 0)
+        return 0;
+    const pathLower = candidate.path.toLowerCase();
+    const titleLower = candidate.title.toLowerCase();
+    const summaryLower = candidate.summary.toLowerCase();
+    const tagsLower = candidate.tags ?? [];
+    let score = 0;
+    for (const keyword of keywords) {
+        const normalized = keyword.trim().toLowerCase();
+        if (!normalized)
+            continue;
+        if (pathLower.includes(normalized))
+            score += 6;
+        if (titleLower.includes(normalized))
+            score += 5;
+        if (summaryLower.includes(normalized))
+            score += 4;
+        if (tagsLower.some((tag) => tag.includes(normalized)))
+            score += 3;
+    }
+    return score;
+}
+export function buildRelevantMemoryCandidates(context) {
+    const candidates = [];
+    const knowledge = context.knowledgeBase;
+    const metadata = context.projectMetadata;
+    if (Array.isArray(knowledge?.project_rules) && knowledge.project_rules.length > 0) {
+        candidates.push({
+            path: '.salmonloop/knowledge/project_rules',
+            title: 'Project rules',
+            summary: knowledge.project_rules.join('; '),
+            tags: ['rules', 'project'],
+        });
+    }
+    if (trimToUndefined(knowledge?.user_preferences)) {
+        candidates.push({
+            path: '.salmonloop/knowledge/user_preferences',
+            title: 'User preferences',
+            summary: knowledge.user_preferences,
+            tags: ['preferences', 'user'],
+        });
+    }
+    for (const [index, decision] of (knowledge?.architectural_decisions ?? []).entries()) {
+        const summary = trimToUndefined(decision?.decision);
+        if (!summary)
+            continue;
+        candidates.push({
+            path: `.salmonloop/knowledge/architectural_decisions/${index + 1}`,
+            title: `Architectural decision ${index + 1}`,
+            summary,
+            tags: ['architecture', ...(decision.related_files ?? []).map((file) => file.toLowerCase())],
+        });
+    }
+    if (trimToUndefined(metadata?.aiInstructions)) {
+        candidates.push({
+            path: '.salmonloop/project/ai-instructions',
+            title: 'Project AI instructions',
+            summary: metadata.aiInstructions,
+            tags: ['instructions', 'project'],
+        });
+    }
+    return candidates;
+}
+export function selectRelevantMemory(args) {
+    const maxItems = Math.max(1, Math.floor(args.maxItems ?? DEFAULT_MAX_ITEMS));
+    const maxSummaryChars = Math.max(48, Math.floor(args.maxSummaryChars ?? DEFAULT_MAX_SUMMARY_CHARS));
+    const haystack = buildAlreadySurfacedHaystack(args.alreadySurfacedText);
+    const activeToolNames = args.activeToolNames ?? [];
+    const keywords = extractKeywords(args.instruction ?? '');
+    const deduped = new Map();
+    for (const rawCandidate of args.candidates) {
+        const candidate = normalizeCandidate(rawCandidate, maxSummaryChars);
+        if (!candidate)
+            continue;
+        if (deduped.has(candidate.path))
+            continue;
+        if (haystack.includes(candidate.path.toLowerCase()) ||
+            haystack.includes(candidate.title.toLowerCase()) ||
+            haystack.includes(candidate.summary.toLowerCase())) {
+            continue;
+        }
+        if (hasToolConflict(candidate, activeToolNames))
+            continue;
+        deduped.set(candidate.path, candidate);
+    }
+    const scored = [...deduped.values()].map((candidate) => ({
+        candidate,
+        score: computeCandidateScore(candidate, keywords),
+    }));
+    const ranked = scored
+        .filter((entry) => entry.score > 0 || keywords.length === 0)
+        .sort((left, right) => {
+        if (left.score !== right.score)
+            return right.score - left.score;
+        return left.candidate.path.localeCompare(right.candidate.path);
+    });
+    return ranked.slice(0, maxItems).map((entry) => entry.candidate);
+}
+//# sourceMappingURL=relevant-retrieval.js.map

package/dist/core/observability/logger.js

@@ -3,6 +3,17 @@ import { FileAdapter } from '../adapters/fs/index.js';
 import { sanitizeObject, sanitizeErrorMessage } from '../utils/sanitizer.js';
 import { recordAuditEvent } from './audit-trail.js';
 import { mapErrorForDisplay } from './error-mapping.js';
+/**
+ * Reporter for machine-readable modes where stdout/stderr are protocol channels.
+ */
+export class SilentReporter {
+    log(_level, _message, _metadata) {
+        // Intentionally empty.
+    }
+    clear() {
+        // Intentionally empty.
+    }
+}
 /**
  * Standard Console Reporter
  */
@@ -418,8 +429,6 @@ export class Logger {
         const auditMeta = typeof meta === 'string' ? { source: meta } : meta;
         recordAuditEvent(action, sanitizedDetails, auditMeta);
         this.writeToLog('audit', formatted);
-        if (!this.silent)
-            this.reporter.log('audit', formatted);
     }
     sanitizeLogMessage(message) {
         let result = '';

package/dist/core/patch/diff.js

@@ -31,6 +31,7 @@ const cleanPath = (path) => {
                 'src',
                 'lib',
                 'app',
+                'scripts',
                 'tests',
                 'test',
                 'packages',

package/dist/core/prompts/registry.js

@@ -10,9 +10,14 @@ const TEMPLATE_URLS = {
     'system/plan_system.hbs': new URL('./templates/system/plan_system.hbs', import.meta.url),
     'system/reflection.hbs': new URL('./templates/system/reflection.hbs', import.meta.url),
     'system/patch_system.hbs': new URL('./templates/system/patch_system.hbs', import.meta.url),
+    'system/autopilot_system.hbs': new URL('./templates/system/autopilot_system.hbs', import.meta.url),
+    'system/answer_system.hbs': new URL('./templates/system/answer_system.hbs', import.meta.url),
+    'system/research_system.hbs': new URL('./templates/system/research_system.hbs', import.meta.url),
     'phases/explore_user.hbs': new URL('./templates/phases/explore_user.hbs', import.meta.url),
     'phases/plan_user.hbs': new URL('./templates/phases/plan_user.hbs', import.meta.url),
     'phases/patch_user.hbs': new URL('./templates/phases/patch_user.hbs', import.meta.url),
+    'phases/research_user.hbs': new URL('./templates/phases/research_user.hbs', import.meta.url),
+    'phases/review_user.hbs': new URL('./templates/phases/review_user.hbs', import.meta.url),
 };
 export class PromptRegistry {
     templates = new Map();
@@ -30,10 +35,15 @@ export class PromptRegistry {
             await this.loadTemplate('explore_system', 'system/explore_system.hbs');
             await this.loadTemplate('plan_system', 'system/plan_system.hbs');
             await this.loadTemplate('patch_system', 'system/patch_system.hbs');
+            await this.loadTemplate('autopilot_system', 'system/autopilot_system.hbs');
+            await this.loadTemplate('answer_system', 'system/answer_system.hbs');
+            await this.loadTemplate('research_system', 'system/research_system.hbs');
             await this.loadTemplate('reflection', 'system/reflection.hbs');
             await this.loadTemplate('explore', 'phases/explore_user.hbs');
             await this.loadTemplate('plan', 'phases/plan_user.hbs');
             await this.loadTemplate('patch', 'phases/patch_user.hbs');
+            await this.loadTemplate('research', 'phases/research_user.hbs');
+            await this.loadTemplate('review', 'phases/review_user.hbs');
         })();
         return this.initPromise;
     }
@@ -73,8 +83,8 @@ export class PromptRegistry {
     /**
      * Get serializable tool definitions for template rendering
      */
-    getToolsForTemplate() {
-        return this.tools.map((spec) => ({
+    serializeToolsForTemplate(tools) {
+        return tools.map((spec) => ({
             name: spec.name,
             source: spec.source,
             intent: spec.intent,
@@ -90,6 +100,12 @@ export class PromptRegistry {
             examples: spec.examples,
         }));
     }
+    /**
+     * Get serializable tool definitions for template rendering
+     */
+    getToolsForTemplate(tools = this.tools) {
+        return this.serializeToolsForTemplate(tools);
+    }
     /**
      * Convert Zod schema to a JSON Schema representation
      */
@@ -142,15 +158,30 @@ export class PromptRegistry {
     renderPlanSystemWithRuntime(runtime) {
         return this.render('plan_system', { tools: this.getToolsForTemplate(), runtime });
     }
+    renderPlanSystemWithTools(tools, runtime) {
+        return this.render('plan_system', { tools: this.getToolsForTemplate(tools), runtime });
+    }
     renderPatchSystem() {
         return this.render('patch_system', { tools: this.getToolsForTemplate() });
     }
     renderPatchSystemWithRuntime(runtime) {
         return this.render('patch_system', { tools: this.getToolsForTemplate(), runtime });
     }
+    renderPatchSystemWithTools(tools, runtime) {
+        return this.render('patch_system', { tools: this.getToolsForTemplate(tools), runtime });
+    }
     renderExploreSystem() {
         return this.render('explore_system', { tools: this.getToolsForTemplate() });
     }
+    renderAutopilotSystem() {
+        return this.render('autopilot_system', {});
+    }
+    renderAnswerSystem() {
+        return this.render('answer_system', {});
+    }
+    renderResearchSystem() {
+        return this.render('research_system', {});
+    }
     renderExploreSystemWithRuntime(runtime) {
         return this.render('explore_system', { tools: this.getToolsForTemplate(), runtime });
     }
@@ -163,6 +194,12 @@ export class PromptRegistry {
     renderPatch(vars) {
         return this.render('patch', vars);
     }
+    renderResearch(vars) {
+        return this.render('research', vars);
+    }
+    renderReview(vars) {
+        return this.render('review', vars);
+    }
     renderReflection(vars) {
         return this.render('reflection', vars);
     }

package/dist/core/prompts/runtime.js

@@ -1,4 +1,13 @@
+import { resolvePhaseVisibleTools } from '../tools/tool-visibility.js';
+import { Phase } from '../types/runtime.js';
 import { getPromptRegistry } from './registry.js';
+function resolveToolSpecs(toolRegistry) {
+    if (!toolRegistry)
+        return [];
+    if (Array.isArray(toolRegistry))
+        return toolRegistry;
+    return toolRegistry.listAll();
+}
 function extractTargetFiles(plan) {
     try {
         const parsed = JSON.parse(plan);
@@ -20,14 +29,26 @@ export async function getExplorePrompt(context, instruction, lastError) {
         lastError,
     });
 }
-export async function getExploreSystemPrompt(toolRegistry, runtime) {
+export async function getExploreSystemPrompt(runtime) {
     const promptRegistry = getPromptRegistry();
     await promptRegistry.init();
-    if (toolRegistry) {
-        promptRegistry.setTools(toolRegistry.listAll());
-    }
     return promptRegistry.renderExploreSystemWithRuntime(runtime);
 }
+export async function getAutopilotSystemPrompt() {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderAutopilotSystem();
+}
+export async function getAnswerSystemPrompt() {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderAnswerSystem();
+}
+export async function getResearchSystemPrompt() {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderResearchSystem();
+}
 export async function getPlanPrompt(context, instruction, maxFilesChanged, lastError) {
     const promptRegistry = getPromptRegistry();
     await promptRegistry.init();
@@ -50,20 +71,37 @@ export async function getPatchPrompt(plan, context, maxFilesChanged, maxDiffLine
         lastError,
     });
 }
+export async function getResearchPrompt(context, instruction) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderResearch({
+        context,
+        instruction,
+    });
+}
+export async function getReviewPrompt(contextJson) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderReview({ contextJson });
+}
 export async function getPlanSystemPrompt(toolRegistry, runtime) {
     const promptRegistry = getPromptRegistry();
     await promptRegistry.init();
-    if (toolRegistry) {
-        promptRegistry.setTools(toolRegistry.listAll());
-    }
-    return promptRegistry.renderPlanSystemWithRuntime(runtime);
+    const promptVisibleTools = resolvePhaseVisibleTools({
+        phase: Phase.PLAN,
+        tools: resolveToolSpecs(toolRegistry),
+        runtime,
+    });
+    return promptRegistry.renderPlanSystemWithTools(promptVisibleTools, runtime);
 }
 export async function getPatchSystemPrompt(toolRegistry, runtime) {
     const promptRegistry = getPromptRegistry();
     await promptRegistry.init();
-    if (toolRegistry) {
-        promptRegistry.setTools(toolRegistry.listAll());
-    }
-    return promptRegistry.renderPatchSystemWithRuntime(runtime);
+    const promptVisibleTools = resolvePhaseVisibleTools({
+        phase: Phase.PATCH,
+        tools: resolveToolSpecs(toolRegistry),
+        runtime,
+    });
+    return promptRegistry.renderPatchSystemWithTools(promptVisibleTools, runtime);
 }
 //# sourceMappingURL=runtime.js.map

package/dist/core/prompts/templates/phases/patch_user.hbs

@@ -34,7 +34,7 @@ The previous attempt failed with the following error. Please fix the issue descr
 1. **Format**: Is it standard git unified diff (starting with `diff --git`)?
 2. **Paths**: Do `--- a/path` and `+++ b/path` exactly match target files?
 3. **Scope**: Does it only modify what's requested in the instruction?
-4. **Context**: Are there 8-12 lines of EXACT surrounding context for each hunk?
+4. **Context**: Are there enough exact context lines for each hunk to apply cleanly?
 5. **Cleanliness**: Is there ANY text other than the diff itself? (If yes, remove it).
 
 # Requirements
@@ -43,13 +43,10 @@ The previous attempt failed with the following error. Please fix the issue descr
 - **If you need to fix an error, regenerate the ENTIRE diff correctly in one block.**
 - **CRITICAL**: Use EXACT relative paths from the repository root in diff headers.
   - Example: `--- a/src/index.js` and `+++ b/src/index.js`
-- **Context Matching**: Provide 8-12 lines of surrounding code.
-  - Indentation and whitespace must match EXACTLY.
-- **DO NOT include `index <old>..<new>` lines** (the host may strip them for safety).
+- **Context Matching**: Provide exact context lines; indentation and whitespace must match EXACTLY.
 - Constraints:
   - Maximum {{maxFilesChanged}} files.
   - Maximum {{maxDiffLines}} total diff lines.
-  - No file creation, deletion, or renaming.
   - No unrelated refactoring or formatting.
   - **DO NOT translate or modify comments unless explicitly instructed.**
 

package/dist/core/prompts/templates/phases/research_user.hbs

@@ -0,0 +1,11 @@
+You are running in deep research mode.
+Use available tools to gather external information as needed.
+Return JSON with keys: researchNotes, researchFindings, sources, researchText.
+Each researchFinding should include: summary, confidence (0-1), uncertainty (string).
+Each source should include: toolName, summary, ok, timestamp (epoch ms).
+
+Instruction:
+{{{instruction}}}
+
+Context:
+{{{context}}}

package/dist/core/prompts/templates/phases/review_user.hbs

@@ -0,0 +1,3 @@
+Please review the following context and provide suggestions for improvement:
+
+{{{contextJson}}}

package/dist/core/prompts/templates/system/answer_system.hbs

@@ -0,0 +1,5 @@
+You are a coding assistant in "answer" mode.
+You may use read-only tools to inspect the repository when helpful.
+Never write files, never apply patches, and never run shell commands.
+If repository inspection is not required, answer directly without tools.
+Answer in the same language as the user.

package/dist/core/prompts/templates/system/autopilot_system.hbs

@@ -0,0 +1,11 @@
+You are a coding assistant running in "autopilot" mode.
+Drive the task forward autonomously and answer in the same language as the user.
+Use the repository context available in the current turn when present.
+If no repository action is possible yet, explain the next best action succinctly.
+Prefer taking a reasonable repository action over asking the user for confirmation.
+Treat simple repo-relative paths like "smoke.txt", "README.md", or "src/index.ts" as valid paths from the repository root.
+Do not ask the user to validate a path that is already a valid relative path or can be inferred directly from the instruction.
+Use `interaction.ask_user` only when the task is genuinely ambiguous and you cannot safely infer the next action.
+When calling `interaction.ask_user`, the arguments MUST be valid JSON with exactly this shape: {"questions":[{"header":"Short header","question":"One clear question","options":[{"label":"Option 1","description":"Why pick it"},{"label":"Option 2","description":"Why pick it"}],"multiSelect":false}]}.
+Do not call `interaction.ask_user` with free-form strings, a single question field, string-only options, or empty options arrays.
+For simple file creation or edits, call `fs.write_file` directly with {"file":"relative/path.ext","content":"..."} instead of asking the user for the path again.

package/dist/core/prompts/templates/system/explore_system.hbs

@@ -1,26 +1,17 @@
-{{> main_system phaseInstruction="You are a code investigator. Your goal is to locate and read the files relevant to the user's request.
+You are in EXPLORE. Find the files relevant to the user's request and read them before planning. Do not modify files.
 
-**Capabilities:**
-- You can list directories (`fs.list`), search code (`code.search`), and read files (`fs.read`).
-- You can ask the user a short clarification question (`interaction.ask_user`) when the request is ambiguous.
-- You CANNOT modify files. Your role is purely investigative.
+Use only these exact tool names in EXPLORE: `fs.list`, `code.search`, `fs.read`, `interaction.ask_user`.
 
-**Workflow:**
-1. Analyze the user's request to identify key terms and potential file locations.
-1. If the request does not clearly specify which files or area to focus on, ask ONE clarification question using `interaction.ask_user` with 2-4 options (for example: Focus area: `src/`, `tests/`, `docs/`, `config`).
-2. Use `fs.list` or `code.search` to locate relevant files.
-3. Use `fs.read` to examine the content of promising files.
-4. Continue exploring until you are confident you have identified the files that need to be modified.
-5. When you have found the relevant context, reply with a concise summary of your findings to complete the phase.
+Default sequence:
+- If the user gives a file path, call `fs.read` first using `{"file":"path/to/file"}`.
+- Otherwise, use `code.search` with `{"pattern":"keyword"}` or `fs.list` with `{"path":"."}` to find a plausible file, then call `fs.read` on it as soon as possible.
+- Use `interaction.ask_user` only if the request is too ambiguous to choose a reasonable first file or search target.
 
-**Important:**
-- **MANDATORY: YOU MUST READ AT LEAST ONE FILE.** Any exploration that concludes without at least one successful `fs.read` call is a violation of the execution contract and will be rejected.
-- **DO NOT GUESS file contents.** You must always use `fs.read` to see the actual content of a file before claiming it is relevant.
-- If you find a file that looks relevant, **YOU MUST READ IT**. The content will be automatically added to the context for the next phase.
-- Tool calls must use valid JSON arguments that match the tool input schema.
-  - `fs.list` requires `{\"path\":\"relative/dir/from/repo/root\"}` (example: `{\"path\":\".\"}`); optionally add `includeHidden`, `maxEntries`.
-  - `fs.read` requires `{\"file\":\"relative/path/from/repo/root\"}` (example: `{\"file\":\"README.md\"}`).
-  - `code.search` requires `{\"pattern\":\"...\"}`; optionally add `glob`, `cwd`, `maxMatches`, `isRegex`.
-- Be efficient. Do not read the entire codebase.
-- If the user provides specific file paths, read them first.
-"}}
+Rules:
+- Do not finish EXPLORE until at least one `fs.read` call succeeds.
+- Do not mention a file as relevant unless you have read it with `fs.read`.
+- Do not guess file contents.
+- Use valid JSON arguments only.
+- Be efficient: prefer short list/search/read loops over broad exploration.
+
+When you have enough read-backed context, reply with a concise summary of the files you read and why they matter.

package/dist/core/prompts/templates/system/main_system.hbs

@@ -1,18 +1,6 @@
-You are SalmonLoop. {{phaseInstruction}}
+You are SalmonLoop.
 
-{{#if runtime.plan}}
-## Runtime Plan (Local, gitignored)
-Session ID: {{runtime.plan.sessionId}}
-Path hint: {{runtime.plan.planPathHint}}
-
-Guidelines:
-- Use `plan.read` to obtain `baseHash`.
-- Use `plan.update` with this `sessionId` to update plan steps by stable `sl:id`.
-- Prefer appending tasks under `work_root` and tracking progress via `sl:status` and checkboxes.
-- Keep phase outputs strictly compliant (PLAN must still be pure JSON, PATCH must still be a unified diff). Tool calls are allowed, but your final content must remain valid.
+Primary text is authoritative. Do not guess missing file contents. If required content is missing, use the available read-only tools to fetch it before finalizing.
+{{#if phaseInstruction}}
+{{phaseInstruction}}
 {{/if}}
-
-## Knowledge Retention
-You have access to a cross-session knowledge base. When you learn important project-specific rules, long-term architectural decisions, or user preferences, use the `update_knowledge` tool to persist them. This helps you stay consistent in future sessions.
-
-{{> tool_defs}}

package/dist/core/prompts/templates/system/patch_system.hbs

@@ -1,10 +1,41 @@
-{{> main_system phaseInstruction="Use tool calls to inspect the repository when needed. Output only a valid unified diff when patching.
+You are PATCH, a phase-native diff compiler. Produce only a canonical unified diff document.
 
-CRITICAL CHARACTER FIDELITY RULE:
-You MUST replicate context lines (lines starting with ' ') EXACTLY as they appear in the provided snippets.
-- DO NOT remove or add hyphens.
-- DO NOT normalize casing.
-- DO NOT fix typos in context lines.
-Failure to maintain 100% character fidelity will cause git-apply to fail.
+Output contract:
+- The very first line must be `diff --git a/... b/...`.
+- The document may contain multiple file sections.
+- Each file section must use `--- a/...` and `+++ b/...`.
+- For file add/delete, use `--- /dev/null` or `+++ /dev/null` as appropriate.
+- An `index` line is optional and not required.
 
-If you used a sub-agent, prefer referencing its proposal artifacts (s8p handles) in your reasoning rather than copying large diff text. Only read artifacts via 'artifact.read' when necessary for correctness."}}
+Tooling rules:
+- Default tool set is read-only and minimal: `fs.read`, `code.search`.
+- Use tools only when necessary to read plan-relevant files.
+- Any further context lookups must remain read-only and target plan-relevant files.
+- Never call or mention write tools.
+
+{{> tool_defs}}
+
+Fidelity rule:
+- Context lines (lines starting with a single space) must match the source text exactly, byte-for-byte.
+
+Strict bans (do not output any of these):
+- Prose, explanations, or commentary.
+- Markdown fences or code blocks.
+- JSON or other structured wrappers.
+- Multiple alternatives or options.
+- Tool calls, tool schemas, or tool instructions.
+
+LEGAL EXAMPLE (verbatim):
+diff --git a/README.md b/README.md
+--- a/README.md
++++ b/README.md
+@@ -1 +1 @@
+-Hello
++Hello world
+
+ILLEGAL PATTERNS (each is invalid):
+Here is the diff:
+Fenced diff blocks that start with triple backticks.
+{"diff":"diff --git a/x b/x"}
+Option A: diff --git a/x b/x
+Tool calls, tool schemas, or tool instructions.