salmon-loop 0.2.3

package/dist/core/prompts/registry.js

@@ -0,0 +1,189 @@
+import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
+import { z } from 'zod';
+import { readFile } from '../adapters/fs/node-fs.js';
+const TEMPLATE_URLS = {
+    'system/_tool_defs.hbs': new URL('./templates/system/_tool_defs.hbs', import.meta.url),
+    'system/main_system.hbs': new URL('./templates/system/main_system.hbs', import.meta.url),
+    'system/_context_json_legend.hbs': new URL('./templates/system/_context_json_legend.hbs', import.meta.url),
+    'system/explore_system.hbs': new URL('./templates/system/explore_system.hbs', import.meta.url),
+    '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),
+    '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),
+};
+export class PromptRegistry {
+    templates = new Map();
+    initPromise;
+    tools = [];
+    init() {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            Handlebars.registerHelper('json', (context) => JSON.stringify(context, null, 2));
+            Handlebars.registerHelper('is_json', (context) => typeof context === 'string' && context.trim().startsWith('{'));
+            await this.registerPartial('tool_defs', 'system/_tool_defs.hbs');
+            await this.registerPartial('context_json_legend', 'system/_context_json_legend.hbs');
+            await this.registerPartial('main_system', 'system/main_system.hbs');
+            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('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');
+        })();
+        return this.initPromise;
+    }
+    async registerPartial(name, relativePath) {
+        const content = await this.readTemplate(relativePath);
+        Handlebars.registerPartial(name, content);
+    }
+    async loadTemplate(name, relativePath) {
+        const content = await this.readTemplate(relativePath);
+        this.templates.set(name, Handlebars.compile(content));
+    }
+    async readTemplate(relativePath) {
+        const url = TEMPLATE_URLS[relativePath];
+        if (!url) {
+            throw new Error(`Unknown prompt template path: ${relativePath}`);
+        }
+        const bunAny = globalThis;
+        const bun = bunAny.Bun;
+        if (bun?.file) {
+            return bun.file(url).text();
+        }
+        return readFile(fileURLToPath(url), 'utf-8');
+    }
+    render(name, data) {
+        const template = this.templates.get(name);
+        if (!template) {
+            throw new Error(`Prompt template "${name}" not found (did you call PromptRegistry.init()?)`);
+        }
+        return template(data);
+    }
+    /**
+     * Set the tool definitions to be injected into prompts
+     */
+    setTools(tools) {
+        this.tools = tools;
+    }
+    /**
+     * Get serializable tool definitions for template rendering
+     */
+    getToolsForTemplate() {
+        return this.tools.map((spec) => ({
+            name: spec.name,
+            source: spec.source,
+            intent: spec.intent,
+            description: spec.description,
+            riskLevel: spec.riskLevel,
+            sideEffects: spec.sideEffects,
+            allowedPhases: spec.allowedPhases,
+            defaultTimeoutMs: spec.defaultTimeoutMs,
+            // Convert Zod schemas to JSON Schema for LLM consumption
+            inputSchema: this.zodToJsonSchema(spec.inputSchema),
+            outputSchema: this.zodToJsonSchema(spec.outputSchema),
+            // Include usage examples if available
+            examples: spec.examples,
+        }));
+    }
+    /**
+     * Convert Zod schema to a JSON Schema representation
+     */
+    zodToJsonSchema(zodSchema) {
+        if (!zodSchema) {
+            return { type: 'object', description: 'Schema details unavailable' };
+        }
+        const unwrapForJsonSchema = (schema) => {
+            let current = schema;
+            for (let depth = 0; depth < 20; depth++) {
+                const ZodEffects = z.ZodEffects;
+                if (ZodEffects && current instanceof ZodEffects) {
+                    current = current._def.schema;
+                    continue;
+                }
+                if (current instanceof z.ZodPipe) {
+                    current = current._def.out;
+                    continue;
+                }
+                if (current instanceof z.ZodOptional ||
+                    current instanceof z.ZodNullable ||
+                    current instanceof z.ZodDefault) {
+                    current = current._def.innerType;
+                    continue;
+                }
+                break;
+            }
+            return current;
+        };
+        try {
+            const unwrapped = unwrapForJsonSchema(zodSchema);
+            const schema = z.toJSONSchema(unwrapped);
+            if (schema && typeof schema === 'object') {
+                const { $schema: _ignored, ...rest } = schema;
+                return rest;
+            }
+        }
+        catch (_e) {
+            // Fall through to best-effort fallback
+        }
+        const def = zodSchema?._def;
+        if (def?.description) {
+            return { description: def.description };
+        }
+        return { type: 'object', description: 'Schema details available at runtime' };
+    }
+    renderPlanSystem() {
+        return this.render('plan_system', { tools: this.getToolsForTemplate() });
+    }
+    renderPlanSystemWithRuntime(runtime) {
+        return this.render('plan_system', { tools: this.getToolsForTemplate(), runtime });
+    }
+    renderPatchSystem() {
+        return this.render('patch_system', { tools: this.getToolsForTemplate() });
+    }
+    renderPatchSystemWithRuntime(runtime) {
+        return this.render('patch_system', { tools: this.getToolsForTemplate(), runtime });
+    }
+    renderExploreSystem() {
+        return this.render('explore_system', { tools: this.getToolsForTemplate() });
+    }
+    renderExploreSystemWithRuntime(runtime) {
+        return this.render('explore_system', { tools: this.getToolsForTemplate(), runtime });
+    }
+    renderExplore(vars) {
+        return this.render('explore', vars);
+    }
+    renderPlan(vars) {
+        return this.render('plan', vars);
+    }
+    renderPatch(vars) {
+        return this.render('patch', vars);
+    }
+    renderReflection(vars) {
+        return this.render('reflection', vars);
+    }
+}
+export function createPromptRegistry() {
+    return new PromptRegistry();
+}
+let activePromptRegistry = null;
+export function setPromptRegistry(registry) {
+    activePromptRegistry = registry;
+}
+export function getPromptRegistry() {
+    if (!activePromptRegistry) {
+        throw new Error('PromptRegistry is not initialized. Call setPromptRegistry() at startup.');
+    }
+    return activePromptRegistry;
+}
+export function tryGetPromptRegistry() {
+    return activePromptRegistry;
+}
+export function clearPromptRegistry() {
+    activePromptRegistry = null;
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/prompts/runtime.js

@@ -0,0 +1,69 @@
+import { getPromptRegistry } from './registry.js';
+function extractTargetFiles(plan) {
+    try {
+        const parsed = JSON.parse(plan);
+        if (!Array.isArray(parsed.files))
+            return undefined;
+        const files = parsed.files.filter((f) => typeof f === 'string');
+        return files.length > 0 ? files.join(', ') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function getExplorePrompt(context, instruction, lastError) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderExplore({
+        context,
+        instruction,
+        lastError,
+    });
+}
+export async function getExploreSystemPrompt(toolRegistry, runtime) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    if (toolRegistry) {
+        promptRegistry.setTools(toolRegistry.listAll());
+    }
+    return promptRegistry.renderExploreSystemWithRuntime(runtime);
+}
+export async function getPlanPrompt(context, instruction, maxFilesChanged, lastError) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderPlan({
+        context,
+        instruction,
+        maxFilesChanged,
+        lastError,
+    });
+}
+export async function getPatchPrompt(plan, context, maxFilesChanged, maxDiffLines, lastError) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    return promptRegistry.renderPatch({
+        plan,
+        context,
+        targetFiles: extractTargetFiles(plan),
+        maxFilesChanged,
+        maxDiffLines,
+        lastError,
+    });
+}
+export async function getPlanSystemPrompt(toolRegistry, runtime) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    if (toolRegistry) {
+        promptRegistry.setTools(toolRegistry.listAll());
+    }
+    return promptRegistry.renderPlanSystemWithRuntime(runtime);
+}
+export async function getPatchSystemPrompt(toolRegistry, runtime) {
+    const promptRegistry = getPromptRegistry();
+    await promptRegistry.init();
+    if (toolRegistry) {
+        promptRegistry.setTools(toolRegistry.listAll());
+    }
+    return promptRegistry.renderPatchSystemWithRuntime(runtime);
+}
+//# sourceMappingURL=runtime.js.map

package/dist/core/prompts/schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,26 @@
+# Context Data
+{{#if (is_json context)}}
+{{> context_json_legend}}
+{{/if}}
+{{{context}}}
+
+# Instruction
+{{{instruction}}}
+
+# Last Error
+{{#if lastError}}
+The previous attempt failed with the following error:
+{{{lastError}}}
+{{/if}}
+
+# Task
+Your task is to EXPLORE the codebase to find the relevant files and code needed to address the instruction above.
+- Use `fs.list` to navigate the file structure.
+- Use `code.search` to find keywords (function names, error messages, variable names).
+- Use `fs.read` to inspect file contents. **Reading a file is MANDATORY for any file you identify as relevant.**
+- If the instruction is ambiguous (no clear file path / module / feature), ask ONE clarification question using `interaction.ask_user` and present 2-4 options for scope.
+
+**CRITICAL: DO NOT GUESS.** If you mention a file in your summary, you MUST have read it using `fs.read` first.
+
+**When you have found all necessary context, reply with a summary of the files you found.**
+If you cannot find relevant files after a reasonable search, you must still perform at least one `fs.read` on a reasonable starting point (for example `README.md` or `package.json`) and then explain what you tried and what additional scope information you need.

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

@@ -0,0 +1,57 @@
+You are a code modification assistant. Please generate a unified diff format patch based on the following plan and context.
+
+# Context Hierarchy
+- **Primary Text**: The ACTUAL content of the files. This is the absolute truth you must modify.
+- **Staged Diff**: Represents committed intentions or baseline changes. Respect these as part of the established direction.
+- **Unstaged Diff**: Shows recent work in progress. Do not revert or overwrite these changes unless explicitly instructed.
+- **Untracked Files**: New files that are not yet tracked by git.
+
+# Plan
+{{{plan}}}
+
+# Context Data
+{{#if (is_json context)}}
+{{> context_json_legend}}
+{{/if}}
+{{{context}}}
+{{#if targetFiles}}
+# Target Files
+{{targetFiles}}
+{{/if}}
+{{#if lastError}}
+# Last Error
+The previous attempt failed with the following error. Please fix the issue described:
+{{{lastError}}}
+{{/if}}
+
+# Bad Examples (REJECTED OUTPUT)
+- **Adding explanations**: "Here is the diff you requested..."
+- **Markdown blocks**: ```diff ... ```
+- **Multiple versions**: Providing both the old and new file contents separately.
+- **Partial fixes**: "I will fix the rest in the next step."
+
+# Validation Checklist (BEFORE OUTPUT)
+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?
+5. **Cleanliness**: Is there ANY text other than the diff itself? (If yes, remove it).
+
+# Requirements
+- Must generate standard **git unified diff format**.
+- **Output ONLY the final diff. Do NOT include any explanations, Markdown blocks, or commentary.**
+- **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).
+- 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.**
+
+Please return the patch in PURE unified diff format:
+

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

@@ -0,0 +1,33 @@
+You are a code modification assistant. Please generate a detailed modification plan based on the following context and instruction.
+
+# Context Hierarchy
+- **Primary Text**: The ACTUAL content of the files. This is the only authoritative source for what lines exist.
+- **Staged Diff**: Informational only. It may include changes that are NOT present in the working tree text you are patching.
+- **Unstaged Diff**: Informational only. It may not fully reflect the working tree after retries.
+- **Untracked Files**: New files that are not yet tracked by git.
+
+# Context Data
+{{#if (is_json context)}}
+{{> context_json_legend}}
+{{/if}}
+{{{context}}}
+
+# Instruction
+{{{instruction}}}
+{{#if lastError}}
+# Last Error
+The previous attempt failed with the following error. Please adjust the plan to fix this issue:
+{{{lastError}}}
+{{/if}}
+# Requirements
+- The plan must be in JSON format, containing exactly these fields: goal, files, changes, verify.
+- 'goal': A brief, one-sentence description of the modification goal.
+- 'files': An array of EXACT relative file paths that MUST be modified.
+- 'changes': An array of strings, each clearly describing a specific logical change.
+- 'verify': A verification command (e.g., `pytest`, `go test ./...`, or your project test command) or a concise description of how to verify.
+- **Constraints**:
+  - Maximum {{maxFilesChanged}} files can be modified.
+  - Do NOT generate any code blocks or implementation details here.
+  - DO NOT include files that do not need changes.
+
+Please return the plan in PURE JSON format without any additional text:

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

@@ -0,0 +1,21 @@
+# Context Data Legend (Optimized JSON)
+The context data uses short keys to save tokens. Please use this mapping:
+- **c**: Root Context
+  - **m**: Manifest (Targets & Maps)
+    - **t**: Targets (Files of interest)
+      - **p**: path, **r**: reason, **c**: confidence (h=high, m=medium, l=low), **e**: evidence
+    - **rm**: Repo Map (Dependencies)
+      - **tr**: trigger (s=shallow, d=deep), **md**: maxDepth, **n**: nodes, **e**: edges
+    - **sm**: Symbol Map (AST relations)
+  - **pf**: Primary File [path, content]
+  - **rf**: Related Files [path, reason, mode (f=full, o=outline), content]
+  - **s**: Code Snippets [file, line, content]
+  - **d**: Diffs (s=staged, u=unstaged, g=git, ut=untracked)
+  - **a**: Analysis (ast results)
+  - **pm**: Project Metadata (pj=package.json, rh=README header, cf=config files, ai=AI rules)
+  - **gh**: Git History (rc=recent commits)
+  - **pt**: Project Topology (ms=modules, fs=folder structure)
+    - **ms**: name(n), path(p), role(er: c=core, a=adapter, cl=cli, u=util)
+  - **kb**: Knowledge Base (pr=rules, ad=decisions, up=user prefs)
+    - **ad**: [ [Date, Content, Files[]], ... ] (Positional tuples)
+  - **ra**: Runtime Artifacts (bd=build dirs, ev=env vars, lf=lock files)

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

@@ -0,0 +1,60 @@
+{{! Tool definitions for LLM context }}
+{{#if tools}}
+## Available Tools
+
+You have access to the following tools to help complete your tasks:
+
+{{#each tools}}
+### {{this.name}}
+
+**Description**: {{this.description}}
+
+**Source**: {{this.source}}
+
+**Intent**: {{this.intent}}
+
+**Risk Level**: {{this.riskLevel}}
+
+**Side Effects**: {{#each this.sideEffects}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+
+**Allowed Phases**: {{#each this.allowedPhases}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+
+{{#if this.defaultTimeoutMs}}**Timeout**: {{this.defaultTimeoutMs}}ms{{/if}}
+
+**Input Schema**:
+```json
+{{{json this.inputSchema}}}
+```
+
+**Output Schema**:
+```json
+{{{json this.outputSchema}}}
+```
+
+{{#if this.examples}}
+**Usage Examples**:
+{{#each this.examples}}
+- {{this.description}}:
+  ```json
+  {{{json this.input}}}
+  ```
+  {{#if this.output}}
+  **Output**:
+  ```json
+  {{{json this.output}}}
+  ```
+  {{/if}}
+{{/each}}
+{{/if}}
+
+{{/each}}
+
+## Tool Usage Guidelines
+
+- Only call tools that are allowed in the current execution phase
+- Respect side effect declarations and risk levels
+- Tool calls will be validated against input schemas before execution
+- High-risk tools may require additional confirmation
+{{else}}
+{{! No tools registered - this is expected during initialization or testing }}
+{{/if}}

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

@@ -0,0 +1,26 @@
+{{> main_system phaseInstruction="You are a code investigator. Your goal is to locate and read the files relevant to the user's request.
+
+**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.
+
+**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.
+
+**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.
+"}}

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

@@ -0,0 +1,18 @@
+You are SalmonLoop. {{phaseInstruction}}
+
+{{#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.
+{{/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

@@ -0,0 +1,10 @@
+{{> main_system phaseInstruction="Use tool calls to inspect the repository when needed. Output only a valid unified diff when patching.
+
+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.
+
+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."}}

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

@@ -0,0 +1 @@
+{{> main_system phaseInstruction="Use tool calls to inspect the repository. **DO NOT GUESS file contents.** If a tool call is necessary, call it and wait. You must base your plan ONLY on the file contents provided in the context. If you lack content for a file, use fs.read to fetch it before finalizing the plan. For complex tasks, use 'agent_dispatch' to delegate investigation."}}

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

@@ -0,0 +1,39 @@
+You are the SalmonLoop Meta-Reflection Engine. Your goal is to derive long-term project constraints by analyzing execution history against a target environment's verification contract.
+
+## Environment Specification (Source of Truth)
+The target environment has the following specifications. All suggested rules MUST be consistent with these facts:
+{{json metadata}}
+
+## High-Level Instruction
+{{instruction}}
+
+## Execution Evidence (Contract Violations)
+The following attempts were made. Focus on why the "Action" violated the "Verification Contract":
+{{#each history}}
+### Attempt {{this.attempt}}
+- **Status**: {{#if this.error}}CONTRACT_VIOLATION{{else}}CONTRACT_SUCCESS{{/if}}
+{{#if this.error}}
+- **Violation Classification**: The environment signaled a failure that matches patterns of logic regression or environmental constraint breach.
+- **Raw Signal Trace**: 
+```
+{{this.error}}
+```
+{{/if}}
+- **Proposed Logic (Plan)**: 
+{{json this.plan}}
+{{/each}}
+
+## Reflection Task
+1. **Root Cause Analysis**: Why did the proposed logic violate the environment's contract? Cross-reference the "Raw Signal Trace" with the "Environment Specification".
+2. **Knowledge Hardening**: Define 1-2 universal rules that would have allowed a perfect execution in Attempt 1.
+   - **Requirement**: Every rule MUST cite an evidence source from the "Environment Specification".
+3. **Consistency Check**: Review existing "Project Rules" in the Knowledge Base (if provided in metadata or context). If a new rule contradicts or supersedes an old one, identify the old rule for deprecation.
+
+## Output Format
+Return a PURE JSON object.
+{
+  "lessons": ["summary"],
+  "suggestedRules": ["New Rule (Evidence: source)"],
+  "deprecatedRules": ["Exact text of old rule to remove"],
+  "suggestedDecisions": ["Architectural rationale"]
+}

package/dist/core/protocols/a2a/agent-card.js

@@ -0,0 +1,30 @@
+export function buildA2AAgentCard(input) {
+    const securitySchemes = input.security.length > 0
+        ? Object.fromEntries(input.security.map((scheme, index) => [
+            scheme.name ?? `${scheme.type}-${index}`,
+            { ...scheme },
+        ]))
+        : undefined;
+    return {
+        name: input.name,
+        url: input.url,
+        description: input.description ?? 'Salmon Loop agent',
+        version: input.version ?? '0.2.0',
+        protocolVersion: input.protocolVersion ?? '1.0.0',
+        defaultInputModes: ['text/plain'],
+        defaultOutputModes: ['text/plain'],
+        capabilities: {
+            pushNotifications: input.capabilityOptions?.pushNotifications ?? false,
+            streaming: input.capabilityOptions?.streaming ?? true,
+            stateTransitionHistory: input.capabilityOptions?.stateTransitionHistory ?? true,
+        },
+        skills: input.capabilities.map((capability) => ({
+            id: capability.id,
+            name: capability.title,
+            description: capability.title,
+            tags: [],
+        })),
+        securitySchemes,
+    };
+}
+//# sourceMappingURL=agent-card.js.map

package/dist/core/protocols/a2a/mapper.js

@@ -0,0 +1,14 @@
+export function mapA2ATaskToCanonicalTask(input) {
+    const instruction = input.message.parts
+        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join('\n');
+    return {
+        id: input.id,
+        capability: 'patch',
+        state: 'accepted',
+        request: { instruction },
+        createdAt: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=mapper.js.map

package/dist/core/protocols/a2a/sdk/auth-middleware.js

@@ -0,0 +1,31 @@
+import { UserBuilder } from '@a2a-js/sdk/server/express';
+/**
+ * Converts A2AAuthPolicyMiddleware to Express middleware
+ * Handles authentication failures by returning 401 Unauthorized
+ */
+export function createAuthMiddlewareFromPolicy(_authPolicy) {
+    return async (req, res, next) => {
+        try {
+            // Note: A2AAuthPolicyMiddleware expects Fetch API Request, but Express provides its own Request
+            // For now, we skip the policy check and just pass through
+            // In a real implementation, you would need to adapt the Express Request to Fetch API Request
+            next();
+        }
+        catch (_error) {
+            res.status(500).json({ error: 'Authentication failed' });
+        }
+    };
+}
+/**
+ * Creates a UserBuilder from Express request with auth context
+ */
+export function createUserBuilderFromAuthContext() {
+    return (req) => {
+        const authContext = req.authContext;
+        if (authContext) {
+            return UserBuilder.noAuthentication();
+        }
+        return UserBuilder.noAuthentication();
+    };
+}
+//# sourceMappingURL=auth-middleware.js.map