salmon-loop 0.2.3 → 0.2.16

package/dist/core/tools/tool-visibility.js

@@ -0,0 +1,62 @@
+import { Phase } from '../types/runtime.js';
+const PLAN_RUNTIME_TOOL_NAMES = new Set(['plan.read', 'plan.update']);
+const PATCH_VISIBLE_TOOL_NAMES = new Set(['fs.read', 'code.search']);
+function isPhaseAllowed(tool, phase) {
+    return Array.isArray(tool.allowedPhases) && tool.allowedPhases.includes(phase);
+}
+export function resolvePlanVisibleTools(tools, runtime) {
+    const hasRuntimePlan = Boolean(runtime?.plan);
+    return tools.filter((tool) => {
+        if (!isPhaseAllowed(tool, Phase.PLAN))
+            return false;
+        if (!tool.name.startsWith('plan.'))
+            return true;
+        if (!hasRuntimePlan)
+            return false;
+        return PLAN_RUNTIME_TOOL_NAMES.has(tool.name);
+    });
+}
+export function resolvePatchVisibleTools(tools) {
+    return tools.filter((tool) => isPhaseAllowed(tool, Phase.PATCH) && PATCH_VISIBLE_TOOL_NAMES.has(tool.name));
+}
+export function resolveAutopilotVisibleTools(tools, runtime) {
+    const hasRuntimePlan = Boolean(runtime?.plan);
+    return tools.filter((tool) => {
+        if (!isPhaseAllowed(tool, Phase.AUTOPILOT))
+            return false;
+        if (!tool.name.startsWith('plan.'))
+            return true;
+        if (!hasRuntimePlan)
+            return false;
+        return PLAN_RUNTIME_TOOL_NAMES.has(tool.name);
+    });
+}
+export function resolvePhaseVisibleTools(params) {
+    if (params.phase === Phase.PLAN) {
+        return resolvePlanVisibleTools(params.tools, params.runtime);
+    }
+    if (params.phase === Phase.PATCH) {
+        return resolvePatchVisibleTools(params.tools);
+    }
+    if (params.phase === Phase.AUTOPILOT) {
+        return resolveAutopilotVisibleTools(params.tools, params.runtime);
+    }
+    return params.tools;
+}
+export function resolveVisibleToolSpecs(params) {
+    if (!params.toolstack)
+        return [];
+    const allowedSpecs = params.toolstack.registry.listAll().filter((spec) => params.toolstack.policy.decide(params.phase, spec, {
+        worktreeRoot: params.worktreeRoot,
+        flowMode: params.flowMode,
+    }).allowed);
+    return resolvePhaseVisibleTools({
+        phase: params.phase,
+        tools: allowedSpecs,
+        runtime: params.runtime,
+    });
+}
+export function resolveVisibleToolNames(params) {
+    return resolveVisibleToolSpecs(params).map((spec) => spec.name);
+}
+//# sourceMappingURL=tool-visibility.js.map

package/dist/core/tools/types.js

@@ -1,2 +1,10 @@
-export const TOOL_INTENTS = ['READ', 'SEARCH', 'LIST', 'WRITE', 'INFRA', 'AGENT'];
+export const TOOL_INTENTS = [
+    'READ',
+    'SEARCH',
+    'LIST',
+    'WRITE',
+    'INFRA',
+    'AGENT',
+    'REPORT',
+];
 //# sourceMappingURL=types.js.map

package/dist/core/types/execution.js

@@ -30,6 +30,9 @@ export const Phase = {
     // SLASH is an out-of-band interactive phase used for adapter-level slash routing and skill expansion.
     // It is intentionally excluded from EXECUTION_PHASES to avoid impacting the main SalmonLoop flow.
     SLASH: 'SLASH',
+    // AUTOPILOT is introduced as a driver-owned business phase. It is intentionally excluded from
+    // EXECUTION_PHASES until the dedicated AutopilotFlow lands.
+    AUTOPILOT: 'AUTOPILOT',
     PREFLIGHT: 'PREFLIGHT',
     PREPARE_DEPS: 'PREPARE_DEPS',
     CONTEXT: 'CONTEXT',
@@ -47,6 +50,7 @@ export const Phase = {
 };
 export const ALL_VISIBLE_STEPS = [
     ...EXECUTION_PHASES,
+    'AUTOPILOT',
     'REVIEW',
     'REPORT',
     'ANALYZE_ISSUES',

package/dist/core/types/flow-mode.js

@@ -0,0 +1,8 @@
+export const FLOW_MODES = ['patch', 'review', 'debug', 'research', 'answer', 'autopilot'];
+export function parseFlowMode(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    return FLOW_MODES.includes(value) ? value : undefined;
+}
+//# sourceMappingURL=flow-mode.js.map

package/dist/core/utils/path.js

@@ -17,6 +17,16 @@ function shouldUseWin32PathSemantics(p) {
     // This enables correct behavior for inputs like "src\\components\\file.ts" on POSIX.
     return p.includes('\\');
 }
+function selectPathImplForAbsolutePath(p) {
+    const normalized = normalizePath(p);
+    if (isWindowsAbsolutePath(normalized) || normalized.startsWith('//')) {
+        return path.win32;
+    }
+    if (normalized.startsWith('/')) {
+        return path.posix;
+    }
+    return path;
+}
 /**
  * Normalize a path to use forward slashes, regardless of the operating system.
  * This ensures consistency across Windows and Linux/macOS.
@@ -30,6 +40,19 @@ export function normalizePath(p) {
     }
     return replaced.replace(/\/{2,}/g, '/');
 }
+/**
+ * Normalize a path-like input into a stable repo-relative form.
+ *
+ * Intended for:
+ * - Permission rules matching (stable normalization across platforms)
+ * - Tool argument normalization and auditing
+ *
+ * This function does NOT validate safety (absolute/traversal); use isSafeRelativePath() or
+ * sandbox resolution checks for security-sensitive operations.
+ */
+export function normalizeRepoRelativePath(input) {
+    return normalizePath(String(input ?? '').trim()).replace(/^(\.\/|\/)+/, '');
+}
 /**
  * Join path segments and normalize the result to use forward slashes.
  */
@@ -56,6 +79,35 @@ export function safeDirname(p) {
 export function safeRelative(from, to) {
     return normalizePath(path.relative(from, to));
 }
+/**
+ * Normalize an absolute or canonical path into a stable form for comparisons.
+ * Windows-style paths are compared case-insensitively; POSIX paths preserve case.
+ */
+export function normalizeComparableAbsolutePath(input) {
+    const normalized = normalizePath(String(input ?? '').trim());
+    const impl = selectPathImplForAbsolutePath(normalized);
+    const resolved = normalizePath(impl.resolve(normalized));
+    return impl === path.win32 ? resolved.toLowerCase() : resolved;
+}
+/**
+ * Compare canonical paths using platform-appropriate semantics.
+ */
+export function arePathsEquivalent(left, right) {
+    return normalizeComparableAbsolutePath(left) === normalizeComparableAbsolutePath(right);
+}
+/**
+ * Check whether a canonical target path is contained within a canonical root path.
+ * Inputs should already be resolved/canonicalized by the caller when used for security checks.
+ */
+export function isCanonicalPathWithinDirectory(root, target, options = {}) {
+    const { allowEqual = true } = options;
+    const normalizedRoot = normalizeComparableAbsolutePath(root);
+    const normalizedTarget = normalizeComparableAbsolutePath(target);
+    if (normalizedTarget === normalizedRoot) {
+        return allowEqual;
+    }
+    return normalizedTarget.startsWith(`${normalizedRoot}/`);
+}
 /**
  * Check whether a path is a safe relative path (no absolute paths or traversal).
  */

package/dist/core/verification/runner.js

@@ -53,7 +53,10 @@ export function classifyError(output) {
     }
     if (lowerOutput.includes('eslint') ||
         lowerOutput.includes('prettier') ||
-        lowerOutput.includes('prettier/prettier')) {
+        lowerOutput.includes('prettier/prettier') ||
+        lowerOutput.includes('oxfmt') ||
+        lowerOutput.includes('format issues found') ||
+        lowerOutput.includes('script "format:check" exited with code')) {
         return ErrorType.LINT;
     }
     if (lowerOutput.includes('fail ') ||

package/dist/interfaces/cli/task-runner.js

@@ -1,10 +1,11 @@
+import { buildCanonicalExecutionRequest } from '../../core/protocols/shared/execution-request.js';
 export function createCliTaskRunner(deps) {
     return {
         async run(input) {
-            return deps.facade.createTask({
+            return deps.facade.createTask(buildCanonicalExecutionRequest({
                 capability: input.capability,
-                request: { instruction: input.instruction },
-            });
+                instruction: input.instruction,
+            }));
         },
     };
 }

package/dist/languages/typescript/index.js

@@ -58,7 +58,10 @@ const commonDiagnostics = {
         // Lint error keywords
         if (lowerOutput.includes('eslint') ||
             lowerOutput.includes('prettier') ||
-            lowerOutput.includes('stylelint')) {
+            lowerOutput.includes('stylelint') ||
+            lowerOutput.includes('oxfmt') ||
+            lowerOutput.includes('format issues found') ||
+            lowerOutput.includes('script "format:check" exited with code')) {
             return ErrorType.LINT;
         }
         return undefined;

package/dist/locales/en.js

@@ -86,6 +86,57 @@ export const en = {
         allowlistAtomicWriteBackupFailed: 'Allowlist atomic write backup failed.',
         allowlistAtomicRestoreFailed: 'Allowlist atomic restore failed.',
         allowlistPathBlocked: 'Allowlist blocked the requested path.',
+        // File system security errors
+        pathOutsideRepo: 'Access denied: Path is outside of repository root.',
+        reservedPathPrefix: (prefix) => `Access denied: Reserved path prefix: ${prefix}`,
+        pathNotFound: (p) => `Path not found: ${p}`,
+        // Worktree errors
+        worktreePathMustBeUnderParityRoot: 'Worktree path must be under parity worktree root',
+        worktreePathMustBeInTempDir: 'Worktree path must be in system temp directory',
+        worktreePathMustNotBeInsideRepo: 'Worktree path must not be inside repo path',
+        worktreePathNotInManagedRoots: 'Worktree path not in managed roots, refusing to delete',
+        // Shadow driver errors
+        aggressiveStrategyLinuxOnly: 'AGGRESSIVE strategy only supported on Linux',
+        commandTimedOut: 'Command timed out',
+        // Lock errors
+        failedToAcquireLock: 'Failed to acquire lock due to concurrent lock updates',
+        lockAcquisitionAborted: 'Lock acquisition aborted',
+        // Checkpoint errors
+        workspaceDirtyUseForce: 'Workspace is dirty. Use --force to overwrite.',
+        // Session errors
+        noActiveSession: 'No active session',
+        // Runtime errors
+        bunRuntimeNotAvailable: 'Bun runtime is not available',
+        runtimeAlreadyStarted: 'Runtime already started',
+        // Protocol errors
+        acpSessionPersistLockTimeout: 'ACP_SESSION_PERSIST_LOCK_TIMEOUT',
+        // Registry errors
+        subAgentRegistryNotInitialized: 'SubAgentRegistry is not initialized. Call setSubAgentRegistry() at startup.',
+        promptRegistryNotInitialized: 'PromptRegistry is not initialized. Call setPromptRegistry() at startup.',
+        pluginRegistryNotInitialized: 'PluginRegistry is not initialized. Call setPluginRegistry() at startup.',
+        monitorNotInitialized: 'Monitor is not initialized. Call setMonitor(createMonitor()) at startup.',
+        loggerNotInitialized: 'Logger is not initialized. Call setLogger(createLogger()) at startup.',
+        // Plan storage errors
+        invalidSessionId: 'Invalid sessionId (expected 6-64 chars of [a-zA-Z0-9_-]).',
+        invalidStepId: 'Invalid stepId.',
+        // Audit errors
+        invalidAuditFile: 'Invalid audit file: context.eventsRef.path is required',
+        // LLM errors
+        operationAborted: 'Operation aborted',
+        emptyLlmResponse: 'Empty LLM response',
+        streamAborted: 'Stream aborted',
+        // Worker errors
+        repoRootRequired: 'repoRoot context is required for union-merge reading',
+        patchContentEmpty: 'Patch content is empty',
+        // Transaction errors
+        runtimeEnvironmentMissingWorkspace: 'Runtime environment missing workspace after setup',
+        executionTerminatedWithoutReport: 'SalmonLoop execution terminated without a FlowReport',
+        // Decision engine errors
+        planBuilderContextNotBound: 'PlanBuilder: context not bound',
+        // Pipeline errors
+        operationCancelledByUser: 'Operation cancelled by user',
+        // Sub-agent errors
+        stopRequestedBeforeLaunch: 'Stop requested before launching Smallfry',
     },
     acp: {
         slashHelpDescription: 'Show available ACP slash commands',
@@ -102,6 +153,8 @@ export const en = {
         permissionPolicyAskDescription: 'Request user permission for side-effecting operations.',
         permissionPolicyDenyAllName: 'Deny all',
         permissionPolicyDenyAllDescription: 'Automatically deny side-effecting operations.',
+        permissionPolicyAllowAllName: 'Allow all',
+        permissionPolicyAllowAllDescription: 'Automatically allow side-effecting operations.',
         modeInteractiveDescription: 'Request permission before running side-effecting operations.',
         modeYoloDescription: 'Bypass permission prompts for side-effecting operations.',
     },
@@ -505,7 +558,12 @@ Please return the patch in PURE unified diff format:`;
         codeSearchDescription: 'Fast file pattern matching tool that works with any codebase size',
         fsReadDescription: 'Read the full content of a file from the repository',
         codeReadDescription: 'Read the full content of a source file from the repository',
-        fsListDescription: 'List files and directories under a repository path',
+        fsListDescription: 'List directory entries under a repository path (legacy name). Prefer fs.list_directory for clarity.',
+        fsListDirectoryDescription: 'List directory entries (files and subdirectories) under a repository path',
+        fsListFilesDescription: 'List files (excluding subdirectories) under a repository path',
+        fsWriteFileDescription: 'Write a UTF-8 text file atomically (slash-only)',
+        fsCreateDirectoryDescription: 'Create a directory under the repository root (slash-only)',
+        fsDeleteFileDescription: 'Delete a file under the repository root (slash-only)',
         gitStatusDescription: 'Show the working tree status',
         gitCatDescription: 'Read file content from a specific git revision',
         codeAstDescription: 'Query AST definitions and references for symbols',
@@ -617,8 +675,35 @@ Please return the patch in PURE unified diff format:`;
             findingItem: (index, summary, confidence, uncertainty) => `Finding ${index}: ${summary}${typeof confidence === 'number' ? ` (confidence: ${confidence})` : ''}${uncertainty ? ` [uncertainty: ${uncertainty}]` : ''}`,
         },
     },
+    intent: {
+        researchKeywords: ['deep research', 'research', 'investigate', 'investigation'],
+    },
     skills: {
         maxRetriesExceeded: (id) => `Max retries exceeded for skill: ${id}. Possible circular dependency in dynamic data.`,
+        legacyRunnerForbidden: 'Legacy MicroTaskRunner is restricted to test context only. Use executeSkill() from SkillRunner.ts for production execution.',
+        missingFrontmatter: (filePath) => `Skill at ${filePath}: missing or malformed YAML frontmatter (expected --- delimiters).`,
+        invalidFrontmatter: (filePath, reason) => `Skill at ${filePath}: frontmatter validation failed — ${reason}`,
+        yamlParseError: (filePath, reason) => `Skill at ${filePath}: YAML parse error — ${reason}`,
+        nameDirMismatch: (filePath, expected, actual) => `Skill at ${filePath}: frontmatter name "${actual}" does not match parent directory "${expected}"`,
+        legacyDirectMdDeprecation: (filePath) => `Skill at ${filePath}: direct .md format is deprecated. Convert to subdirectory format: move to <skill-name>/SKILL.md`,
+        skillNotFoundInCatalog: (id) => `Skill "${id}" not found in catalog. Ensure loadCatalog() has been called and the skill exists.`,
+        skillActivated: (id) => `Skill "${id}" activated (Tier 2: full content loaded).`,
+        newSkillDiscovered: (id, location) => `New skill "${id}" discovered at ${location} during session.`,
+        conditionalSkillActivated: (id, matchedPattern) => `Conditional skill "${id}" activated: file matched pattern "${matchedPattern}".`,
+        permissionFileInvalidFormat: (filePath) => `Skill permissions file at ${filePath} has invalid format; starting with empty allowlist.`,
+        permissionFileLoadError: (filePath) => `Failed to load skill permissions from ${filePath}; starting with empty allowlist.`,
+        permissionFileSaveError: (filePath, reason) => `Failed to save skill permissions to ${filePath}: ${reason}`,
+        // Lenient validation warnings
+        nameTooLong: (filePath, name, len) => `Skill at ${filePath}: name "${name}" exceeds 64 characters (${len}); loading anyway`,
+        nameFormatWarning: (filePath, name) => `Skill at ${filePath}: name "${name}" does not match naming convention; loading anyway`,
+        descriptionTooLong: (filePath, len) => `Skill at ${filePath}: description exceeds 1024 characters (${len}); loading anyway`,
+        // YAML fallback
+        yamlFallbackApplied: (filePath, lines) => `Skill at ${filePath}: YAML fallback applied to fix common issues (${lines}); loading with corrected values`,
+        yamlFallbackFailed: (filePath) => `Skill at ${filePath}: YAML fallback recovery also failed; skipping skill`,
+        // Catalog disclosure
+        catalogDisclosurePreamble: 'The following skills provide specialized instructions for specific tasks. ' +
+            'When a task matches a skill description, read the SKILL.md file at the listed location to load detailed instructions before proceeding. ' +
+            'When a skill references relative paths, resolve them against the skill directory (the parent of SKILL.md).',
     },
     // Symbols for UI feedback
     symbols: {
@@ -671,7 +756,7 @@ Please return the patch in PURE unified diff format:`;
             missionFailedWithReason: (reason) => `Smallfry mission failed: ${reason}`,
         },
         ui: {
-            spawnToolDescription: 'Deploy a specialized Smallfry (sub-agent) for autonomous task execution.',
+            spawnToolDescription: 'Delegate a concrete sub-task to a specialized sub-agent. This is not a no-argument action: always provide agent_ref and task. Use agent_ref="explorer" for read-only investigation, "reviewer" for audit, "surgeon" for implementation proposals, or "cleaner" for lint/format cleanup. Keep task self-contained with relevant files and the exact deliverable. Omit session_target unless shared context is explicitly required.',
             progressTitle: (id) => `[Smallfry: ${id}]`,
         },
     },

package/dist/utils/eol.js

@@ -7,7 +7,7 @@ export class TextNormalizer {
     static read(content) {
         // 1. Count frequencies to handle mixed line endings
         const crlfCount = (content.match(/\r\n/g) || []).length;
-        const lfCount = (content.match(/[^\r]\n/g) || []).length;
+        const lfCount = (content.match(/(?<!\r)\n/g) || []).length;
         // 2. Determine style (default to LF if LF >= CRLF)
         const eol = crlfCount > lfCount ? '\r\n' : '\n';
         // 3. Normalize to LF

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salmon-loop",
-  "version": "0.2.3",
+  "version": "0.2.16",
   "description": "A chat-first coding agent CLI for safe, reviewable repository changes",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "dist/locales/**/*.js",
     "dist/utils/**/*.js",
     "dist/core/prompts/templates/**/*.hbs",
+    "scripts/fix-es-abstract-compat.js",
     "README.md",
     "README.zh-CN.md",
     "LICENSE"
@@ -29,12 +30,16 @@
     "t": "bun run test:unit",
     "test:unit": "bun scripts/run-bun-file-tests.ts tests/unit",
     "test:integration": "bun scripts/run-bun-file-tests.ts tests/integration",
+    "test:integration:network": "RUN_A2A_NETWORK_INTEGRATION=1 bun test --timeout 90000 --preload ./tests/setup-bun.ts tests/integration/a2a-sdk-server.test.ts",
     "test:e2e": "bun scripts/run-bun-file-tests.ts tests/e2e",
-    "test:full": "bun run test:unit && bun run test:integration && bun run test:perf",
+    "test:full": "bun run test:unit && bun run test:integration",
+    "test:all": "bun run test:full && bun run test:perf",
     "test:runtime-boundary": "bun test --preload ./tests/setup-bun.ts tests/unit/scripts/target-runtime-boundary.test.ts tests/unit/scripts/bun-purity.test.ts",
     "test:worktree-smoke": "bun scripts/worktree-smoke.js",
     "test:headless-smoke": "bun scripts/headless-smoke.ts",
+    "test:contract-smoke": "bun test --timeout 15000 --preload ./tests/setup-bun.ts tests/unit/architecture/request-assembly-invariant.test.ts tests/unit/architecture/replacement-preview-boundary-invariant.test.ts tests/unit/architecture/sub-agent-prefix-consistency-invariant.test.ts tests/unit/architecture/tool-naming-contract.test.ts tests/unit/architecture/verify-contract-smoke-gate.test.ts tests/unit/tools/session-streaming.test.ts tests/unit/core/grizzco/steps/plan-patch-toolcalling.test.ts tests/unit/core/session/replacement-state.test.ts",
     "setup:hooks": "git config core.hooksPath .githooks",
+    "postinstall": "node scripts/fix-es-abstract-compat.js",
     "check:bun-purity": "bun scripts/check-bun-purity.ts",
     "check:bun-purity:staged": "bun scripts/check-bun-purity.ts --staged",
     "check:target-runtime-boundary": "bun scripts/check-target-runtime-hardcoding.ts",
@@ -51,17 +56,20 @@
     "check:test-runner-migration": "bun scripts/check-test-runner-migration.ts",
     "lint": "bun ./node_modules/eslint/bin/eslint.js .",
     "typecheck": "bun ./node_modules/typescript/bin/tsc --noEmit",
-    "verify": "bun run check:bun-purity && bun run check:target-runtime-boundary && bun run check:unit-boundary && bun run check:fs-git-boundary && bun run check:bun-native-boundary && bun run check:test-runner-migration && bun run lint && bun run typecheck && bun run test:full",
+    "verify": "bun run check:bun-purity && bun run check:target-runtime-boundary && bun run check:unit-boundary && bun run check:fs-git-boundary && bun run check:bun-native-boundary && bun run check:test-runner-migration && bun run format:check && bun run lint && bun run typecheck && bun run test:contract-smoke && bun run test:full",
     "test:watch": "bun test --watch --preload ./tests/setup-bun.ts tests",
     "test:watch:unit": "bun test --watch --preload ./tests/setup-bun.ts tests/unit",
     "test:watch:integration": "bun test --watch --preload ./tests/setup-bun.ts tests/integration",
     "test:perf": "bun scripts/run-bun-file-tests.ts tests/perf",
+    "test:perf:network": "RUN_A2A_PERF_BENCHMARKS=1 bun test tests/perf/a2a-performance-benchmark.test.ts",
+    "test:perf:all": "RUN_A2A_PERF_BENCHMARKS=1 bun scripts/run-bun-file-tests.ts tests/perf",
     "test:watch:perf": "bun test --watch --preload ./tests/setup-bun.ts tests/perf",
     "test:coverage": "bun test --coverage --preload ./tests/setup-bun.ts tests",
     "test:report": "bun test --reporter=junit --reporter-outfile=test-report.xml --preload ./tests/setup-bun.ts tests",
     "test:ci": "bun run verify",
     "pack:dry": "npm pack --dry-run",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format": "oxfmt --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "oxfmt --check \"src/**/*.ts\" \"tests/**/*.ts\"",
     "release": "bun scripts/release.ts cut",
     "release:cut": "bun scripts/release.ts cut",
     "release:publish": "bun scripts/release.ts publish"
@@ -106,10 +114,9 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.5",
-    "fast-check": "^4.5.3",
+    "fast-check": "^4.6.0",
     "jsdom": "^27.4.0",
-    "prettier": "^3.4.2",
+    "oxfmt": "^0.42.0",
     "react-devtools-core": "^7.0.1",
     "simple-git": "^3.30.0",
     "sinon": "^21.0.1",
@@ -138,7 +145,7 @@
     "ink-gradient": "^3.0.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
-    "marked": "^17.0.1",
+    "marked": "^16.4.2",
     "marked-terminal": "^7.3.0",
     "openai": "^6.16.0",
     "progress": "^2.0.3",

package/scripts/fix-es-abstract-compat.js

@@ -0,0 +1,77 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listJsFiles(rootDir, baseDir = rootDir) {
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const full = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await listJsFiles(full, baseDir)));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith('.js')) {
+      files.push(path.relative(baseDir, full));
+    }
+  }
+
+  return files;
+}
+
+function toPosixPath(value) {
+  return value.split(path.sep).join('/');
+}
+
+async function writeCompatModule(dir2024, relativePath) {
+  const target = path.join(dir2024, relativePath);
+  const withoutExt = relativePath.replace(/\.js$/, '');
+  const requirePath = path.posix.join('..', '2025', toPosixPath(withoutExt));
+  const content = `'use strict';\n\nmodule.exports = require('${requirePath}');\n`;
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.writeFile(target, content, 'utf8');
+}
+
+async function main() {
+  const root = path.resolve(process.cwd(), 'node_modules', 'es-abstract');
+  const dir2024 = path.join(root, '2024');
+  const dir2025 = path.join(root, '2025');
+
+  if (!(await fileExists(root)) || !(await fileExists(dir2025))) {
+    return;
+  }
+
+  await fs.mkdir(dir2024, { recursive: true });
+
+  const entries2025 = await listJsFiles(dir2025);
+  const missing = [];
+
+  for (const rel of entries2025) {
+    const target = path.join(dir2024, rel);
+    if (!(await fileExists(target))) {
+      missing.push(rel);
+    }
+  }
+
+  if (missing.length === 0) {
+    return;
+  }
+
+  for (const rel of missing) {
+    await writeCompatModule(dir2024, rel);
+  }
+}
+
+main().catch((error) => {
+  console.error(`Failed to apply es-abstract compatibility patch: ${error}`);
+  process.exitCode = 1;
+});

package/dist/core/runtime/fastify-server-bundle.js

@@ -1,26 +0,0 @@
-export function createFastifyServerBundle(deps) {
-    const a2aServer = deps.createFastify();
-    const sidecarServer = deps.createFastify();
-    async function start() {
-        if (deps.configureA2A) {
-            await deps.configureA2A(a2aServer);
-        }
-        await a2aServer.register(deps.a2aPlugin);
-        if (deps.configureSidecar) {
-            await deps.configureSidecar(sidecarServer);
-        }
-        await sidecarServer.register(deps.sidecarPlugin);
-        await a2aServer.listen(deps.a2aListen);
-        await sidecarServer.listen(deps.sidecarListen);
-    }
-    async function close() {
-        await Promise.all([a2aServer.close(), sidecarServer.close()]);
-    }
-    return {
-        a2aServer,
-        sidecarServer,
-        start,
-        close,
-    };
-}
-//# sourceMappingURL=fastify-server-bundle.js.map

package/dist/core/runtime/sidecar-fastify-plugin.js

@@ -1,35 +0,0 @@
-import { buildFetchRequest, sendFetchResponse, } from './fastify-fetch-bridge.js';
-export function createSidecarFastifyPlugin(deps) {
-    const baseUrl = deps.baseUrl ?? 'http://localhost';
-    const allowConditional = deps.allowConditional ?? false;
-    return async function sidecarFastifyPlugin(fastify) {
-        for (const route of deps.routes) {
-            if (route.exposure === 'forbidden')
-                continue;
-            if (route.scope !== 'both' && route.scope !== deps.scope)
-                continue;
-            if (!allowConditional && route.exposure === 'conditional')
-                continue;
-            const handler = async (request, reply) => {
-                const fetchRequest = buildFetchRequest(request, baseUrl);
-                if (deps.authorize) {
-                    const decision = await deps.authorize({
-                        request: fetchRequest,
-                        policyTag: route.policyTag,
-                        scope: deps.scope,
-                    });
-                    if (!decision.allowed) {
-                        await sendFetchResponse(reply, new Response(decision.message ?? 'Forbidden', {
-                            status: decision.status ?? 403,
-                        }));
-                        return;
-                    }
-                }
-                const response = await route.handler(fetchRequest);
-                await sendFetchResponse(reply, response);
-            };
-            fastify.route({ method: route.method, url: route.path, handler });
-        }
-    };
-}
-//# sourceMappingURL=sidecar-fastify-plugin.js.map

package/dist/core/runtime/sidecar-paths.js

@@ -1,47 +0,0 @@
-import os from 'node:os';
-import { defaultPathAdapter } from '../adapters/path/path-adapter.js';
-const DEFAULT_APP_NAME = 'SalmonLoop';
-export function resolveUserDataDir(options) {
-    const platform = options?.platform ?? process.platform;
-    const env = options?.env ?? process.env;
-    const home = options?.homedir ?? os.homedir();
-    const pathAdapter = options?.pathAdapter ?? defaultPathAdapter;
-    const appName = options?.appName ?? DEFAULT_APP_NAME;
-    if (platform === 'win32') {
-        const base = env.APPDATA ?? env.LOCALAPPDATA ?? pathAdapter.join(home, 'AppData', 'Roaming');
-        return pathAdapter.join(base, appName);
-    }
-    if (platform === 'darwin') {
-        return pathAdapter.join(home, 'Library', 'Application Support', appName);
-    }
-    const xdg = env.XDG_DATA_HOME;
-    const base = xdg && xdg.length > 0 ? xdg : pathAdapter.join(home, '.local', 'share');
-    return pathAdapter.join(base, appName);
-}
-export function getSidecarSocketPath(options) {
-    const platform = options?.platform ?? process.platform;
-    const socketName = options?.socketName ?? 'agent-message.sock';
-    if (platform === 'win32') {
-        return '\\\\.\\pipe\\salmonloop-agent-message';
-    }
-    const dataDir = resolveUserDataDir(options);
-    const pathAdapter = options?.pathAdapter ?? defaultPathAdapter;
-    return pathAdapter.join(dataDir, 'sidecar', socketName);
-}
-export function isBunRuntime() {
-    return typeof globalThis.Bun !== 'undefined';
-}
-export function createPipeListenOptions(path) {
-    return { type: 'pipe', path };
-}
-export function createTcpListenOptions(port, host = '127.0.0.1') {
-    return { type: 'tcp', port, host };
-}
-export function getSidecarListenOptions(options) {
-    const platform = options?.platform ?? process.platform;
-    if (platform === 'win32' && isBunRuntime()) {
-        return { type: 'tcp', port: options?.sidecarPort ?? 7432, host: '127.0.0.1' };
-    }
-    return { type: 'pipe', path: getSidecarSocketPath(options) };
-}
-//# sourceMappingURL=sidecar-paths.js.map