salmon-loop 0.2.3 → 0.2.16

package/dist/cli/slash/runtime.js

@@ -1,17 +1,26 @@
 import { createSlashRegistry, createStandardToolstack, executeSkill, logIgnoredError, getLogger, RuntimeEnvironment, SkillLoader, SlashRouter, } from '../../core/facades/cli-slash-runtime.js';
+import { formatHelpRows } from '../commands/help-format.js';
 import { suggestSubcommands } from '../commands/subcommand-suggestions.js';
 import { text } from '../locales/index.js';
 function isSafeSkillId(id) {
     return /^[a-z0-9][a-z0-9-_]*$/i.test(id);
 }
-function skillToSlashSpec(skill) {
-    const id = String(skill.id || '').trim();
+/**
+ * Build a SlashCommandSpec from a Tier 1 catalog entry (lightweight metadata).
+ *
+ * This supports the AgentSkills progressive disclosure pattern: only name and
+ * description are needed at startup to populate the slash command registry.
+ * Full skill content is loaded on demand via SkillLoader.activateSkill().
+ *
+ * @see https://agentskills.io/specification — Progressive disclosure
+ */
+function catalogEntryToSlashSpec(entry) {
+    const id = String(entry.id || '').trim();
     if (!id || !isSafeSkillId(id))
         return null;
     return {
         name: `/${id}`,
-        description: skill.metadata?.description || `Skill: ${id}`,
-        hidden: skill.metadata?.userInvocable === false,
+        description: entry.description || `Skill: ${id}`,
         order: 220,
     };
 }
@@ -27,11 +36,15 @@ function commandToSlashSpec(cmd) {
 export async function createCliSlashRuntime(options) {
     const skillLoader = new SkillLoader({
         repoRoot: options.repoRoot,
-        useDefaults: options.skillDiscovery?.useDefaults,
         extraPaths: options.skillDiscovery?.paths,
     });
-    const skills = await skillLoader.initialize();
-    const skillSpecs = skills.map(skillToSlashSpec).filter((s) => Boolean(s));
+    // Tier 1: Load lightweight catalog (name + description only, ~50-100 tokens per skill).
+    // Full skill content is loaded on demand via activateSkill() (Tier 2).
+    // @see https://agentskills.io/specification — Progressive disclosure
+    const catalog = await skillLoader.loadCatalog();
+    const skillSpecs = catalog
+        .map(catalogEntryToSlashSpec)
+        .filter((s) => Boolean(s));
     const commandSpecs = options.baseCommands.map(commandToSlashSpec);
     // /help is best-effort and must reflect the effective registry (including skills).
     const helpSpec = {
@@ -50,11 +63,11 @@ export async function createCliSlashRuntime(options) {
         }
     }
     const skillBySlash = new Map();
-    for (const skill of skills) {
-        const spec = skillToSlashSpec(skill);
+    for (const entry of catalog) {
+        const spec = catalogEntryToSlashSpec(entry);
         if (!spec)
             continue;
-        skillBySlash.set(spec.name.toLowerCase(), skill);
+        skillBySlash.set(spec.name.toLowerCase(), entry);
     }
     const handlers = {
         getHandler(commandName) {
@@ -63,12 +76,11 @@ export async function createCliSlashRuntime(options) {
                 const handler = {
                     execute: async (_req) => {
                         const visible = registry.list().filter((c) => !c.hidden);
-                        const maxName = Math.max(...visible.map((c) => c.name.length), 0);
-                        const rows = visible.map((c) => `${c.name}`.padEnd(maxName + 2) + c.description);
+                        const rows = formatHelpRows(visible);
                         options.emit({
                             type: 'log',
                             level: 'info',
-                            message: text.cli.helpAvailableCommands(rows.join('\n')),
+                            message: text.cli.helpAvailableCommands(rows),
                             timestamp: new Date(),
                         });
                         return { kind: 'consumed' };
@@ -115,10 +127,13 @@ export async function createCliSlashRuntime(options) {
                         : undefined,
                 };
             }
-            const skill = skillBySlash.get(normalized);
-            if (skill) {
+            const catalogEntry = skillBySlash.get(normalized);
+            if (catalogEntry) {
                 return {
                     execute: async (req) => {
+                        // Tier 2: Activate skill on demand — load full SKILL.md content.
+                        // @see https://agentskills.io/specification — Progressive disclosure
+                        const skill = await skillLoader.activateSkill(catalogEntry.id);
                         const meta = (req.meta ?? {});
                         const signal = meta?.signal;
                         // Prepare an isolated worktree environment for governed shell execution.

package/dist/cli/ui/components/CommandInput.js

@@ -9,6 +9,7 @@ import { useCommandSuggestions } from '../hooks/useCommandSuggestions.js';
 import { useInputHistory } from '../hooks/useInputHistory.js';
 import { rejectSelection, resolveSelection } from '../selection/bus.js';
 import { useUIStore } from '../store/context.js';
+import { COLORS } from '../styles/theme.js';
 import { CommandSuggestionList } from './CommandSuggestionList.js';
 export const CommandInput = ({ value, onChange, onSubmit, placeholder, getSuggestions, findCommand, }) => {
     const { state, dispatch } = useUIStore();
@@ -185,16 +186,19 @@ export const CommandInput = ({ value, onChange, onSubmit, placeholder, getSugges
                                 : en.gui.selectionPlaceholder
                             : isIntercepting && activeChallenge
                                 ? en.gui.confirmationChallenge(activeChallenge)
-                                : placeholder }, inputKey), ghostText && (_jsx(Text, { color: "gray", dimColor: true, children: ghostText }))] }), isIntercepting && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", bold: true, children: isSelecting
+                                : placeholder }, inputKey), ghostText && (_jsx(Text, { color: COLORS.text.muted, dimColor: true, children: ghostText }))] }), isIntercepting && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.semantic.yellow, paddingX: 1, children: [_jsx(Text, { color: COLORS.semantic.yellow, bold: true, children: isSelecting
                             ? pendingSelection?.title
                             : isAuthorizing
                                 ? en.gui.authorizationTitle
-                                : en.gui.confirmationTitle }), !isSelecting && (_jsx(Text, { color: "white", children: isAuthorizing ? pendingAuthorization?.message : pendingConfirmation?.message })), _jsx(Text, { color: "gray", dimColor: true, children: isSelecting
+                                : en.gui.confirmationTitle }), !isSelecting && (_jsx(Text, { color: COLORS.text.primary, children: isAuthorizing ? pendingAuthorization?.message : pendingConfirmation?.message })), _jsx(Text, { color: COLORS.text.muted, dimColor: true, children: isSelecting
                             ? isMultiSelecting
                                 ? en.gui.selectionHintMulti
                                 : en.gui.selectionHint
                             : isAuthorizing
                                 ? en.gui.authorizationWarning
-                                : en.gui.highRiskWarning }), isAuthorizing && (_jsx(Text, { color: "gray", dimColor: true, children: en.gui.authorizationHint })), isSelecting && pendingSelection && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: pendingSelection.items.map((item, idx) => (_jsxs(Text, { color: idx === selectionIndex ? 'green' : 'gray', children: [isMultiSelecting && (_jsx(Text, { color: selectedItems.includes(item.id) ? 'green' : 'gray', children: selectedItems.includes(item.id) ? '[x] ' : '[ ] ' })), item.label, item.description ? ` - ${item.description}` : ''] }, item.id))) }))] })), !isIntercepting && suggestions.length > 0 && !isListClosed && (_jsx(CommandSuggestionList, { suggestions: visibleSuggestions, selectedIndex: selectedIndex - startIndex, parentCommand: activeCommand }))] }));
+                                : en.gui.highRiskWarning }), isAuthorizing && (_jsx(Text, { color: COLORS.text.muted, dimColor: true, children: en.gui.authorizationHint })), isSelecting && pendingSelection && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: pendingSelection.items.map((item, idx) => {
+                            const isSelected = idx === selectionIndex;
+                            return (_jsxs(Text, { color: isSelected ? COLORS.semantic.cyan : COLORS.text.muted, children: [isSelected ? '❯ ' : '  ', isMultiSelecting && (_jsx(Text, { color: selectedItems.includes(item.id) ? COLORS.semantic.cyan : COLORS.text.muted, children: selectedItems.includes(item.id) ? '[x] ' : '[ ] ' })), item.label, item.description ? ` - ${item.description}` : ''] }, item.id));
+                        }) }))] })), !isIntercepting && suggestions.length > 0 && !isListClosed && (_jsx(CommandSuggestionList, { suggestions: visibleSuggestions, selectedIndex: selectedIndex - startIndex, parentCommand: activeCommand }))] }));
 };
 //# sourceMappingURL=CommandInput.js.map

package/dist/cli/ui/components/CommandSuggestionList.js

@@ -14,7 +14,7 @@ export const CommandSuggestionList = ({ suggestions, selectedIndex, parentComman
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: COLORS.border.subtle, marginTop: 0, marginBottom: 0, paddingX: 0, width: "100%", children: [_jsx(Box, { flexDirection: "column", paddingY: 0, children: suggestions.map((item, index) => {
                     const isSelected = index === selectedIndex;
                     const hasSubcommands = !!item.command?.subcommands?.length;
-                    return (_jsxs(Box, { flexDirection: "row", paddingX: 1, children: [_jsx(Box, { width: 2, children: _jsx(Text, { color: COLORS.semantic.salmon, children: isSelected ? '│ ' : '  ' }) }), _jsx(Box, { width: maxNameLength + 4, children: _jsx(Text, { color: isSelected ? COLORS.semantic.cyan : COLORS.semantic.blue, bold: isSelected, children: item.name }) }), _jsx(Box, { width: 2, marginRight: 1, children: hasSubcommands ? _jsx(Text, { color: COLORS.text.muted, children: " " }) : _jsx(Text, { children: " " }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { color: isSelected ? COLORS.text.primary : COLORS.text.muted, wrap: "truncate", children: item.description }) })] }, `${item.name}-${index}`));
+                    return (_jsxs(Box, { flexDirection: "row", paddingX: 1, children: [_jsx(Box, { width: 2, children: _jsx(Text, { color: COLORS.semantic.salmon, children: isSelected ? '│ ' : '  ' }) }), _jsx(Box, { width: maxNameLength + 4, children: _jsx(Text, { color: isSelected ? COLORS.semantic.cyan : COLORS.semantic.blue, bold: isSelected, children: item.name }) }), _jsx(Box, { width: 2, marginRight: 1, children: hasSubcommands ? _jsx(Text, { color: COLORS.text.muted, children: "\u203A" }) : _jsx(Text, { children: " " }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { color: isSelected ? COLORS.text.primary : COLORS.text.muted, wrap: "truncate", children: item.description }) })] }, `${item.name}-${index}`));
                 }) }), suggestions[selectedIndex]?.command?.usage && (_jsxs(Box, { flexDirection: "row", borderStyle: "single", borderTop: true, borderLeft: false, borderRight: false, borderBottom: false, borderColor: COLORS.border.subtle, paddingX: 1, paddingY: 0, children: [_jsx(Text, { color: COLORS.semantic.blue, children: "TIP: " }), _jsx(Text, { color: COLORS.text.muted, children: "Usage: " }), _jsx(Text, { color: COLORS.text.primary, children: suggestions[selectedIndex].command?.usage })] })), _jsxs(Box, { flexDirection: "row", borderStyle: "single", borderTop: true, borderLeft: false, borderRight: false, borderBottom: false, borderColor: COLORS.border.subtle, paddingX: 1, paddingY: 0, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(Text, { color: COLORS.semantic.salmon, children: "\u2502 " }), _jsx(Text, { color: COLORS.semantic.blue, bold: true, children: title })] }), _jsx(Box, { children: _jsx(Text, { color: COLORS.text.muted, dimColor: true, children: "\u2191\u2193 nav \u00B7 \u23CE select \u00B7 esc close" }) })] })] }));
 };
 //# sourceMappingURL=CommandSuggestionList.js.map

package/dist/cli/utils/command-option-source.js

@@ -0,0 +1,13 @@
+export function getOptionValueSourceWithGlobalFallback(command, optionName) {
+    if (typeof command.getOptionValueSource === 'function') {
+        const direct = command.getOptionValueSource(optionName);
+        if (direct)
+            return direct;
+    }
+    const parent = command.parent;
+    if (parent && typeof parent.getOptionValueSource === 'function') {
+        return parent.getOptionValueSource(optionName);
+    }
+    return undefined;
+}
+//# sourceMappingURL=command-option-source.js.map

package/dist/cli/utils/output-format.js

@@ -0,0 +1,6 @@
+export function resolveOutputFormat(raw) {
+    if (raw === 'text' || raw === 'stream-json' || raw === 'json')
+        return raw;
+    return undefined;
+}
+//# sourceMappingURL=output-format.js.map

package/dist/cli/utils/resolve-cli-config.js

@@ -0,0 +1,98 @@
+import { defaultPathAdapter } from '../../core/adapters/path/path-adapter.js';
+import { ConfigError, normalizeUiLogMode, resolveConfig } from '../../core/config/index.js';
+import { text } from '../locales/index.js';
+import { resolveAuditScope } from './audit-scope.js';
+import { resolveOutputFormat } from './output-format.js';
+import { resolveVerboseLevel } from './verbose-level.js';
+export async function resolveCliConfig(params) {
+    const common = resolveCliCommonOptions({
+        repoPath: params.repoPath,
+        repo: params.repo,
+        cwd: params.cwd,
+        verbose: params.verbose,
+        outputFormat: params.outputFormat,
+    });
+    if (!common.ok) {
+        return { ok: false, message: common.message };
+    }
+    const { repoPath, verboseLevel, outputFormat, headlessOutput } = common.options;
+    let resolvedConfig;
+    try {
+        resolvedConfig = await resolveConfig({
+            repoRoot: repoPath,
+            configFilePath: params.configPath,
+            enableConfigFile: params.enableConfigFile !== false,
+        });
+    }
+    catch (err) {
+        if (err instanceof ConfigError) {
+            return {
+                ok: false,
+                message: text.config.error(err.code || err.message, err.details),
+                errorCode: err.code,
+            };
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, message: text.config.loadFailed(msg) };
+    }
+    const auditScopeResolution = resolveAuditScope({
+        cliValue: params.auditScope,
+        configValue: resolvedConfig.observability.audit.scope,
+    });
+    if (!auditScopeResolution.ok) {
+        return {
+            ok: false,
+            message: text.cli.invalidAuditScope(auditScopeResolution.invalid),
+        };
+    }
+    if (params.logMode !== undefined) {
+        const normalized = normalizeUiLogMode(params.logMode);
+        if (!normalized) {
+            return { ok: false, message: text.cli.logModeInvalid(String(params.logMode)) };
+        }
+        resolvedConfig = {
+            ...resolvedConfig,
+            ui: {
+                ...resolvedConfig.ui,
+                logMode: normalized,
+            },
+        };
+    }
+    return {
+        ok: true,
+        repoPath,
+        verboseLevel,
+        outputFormat,
+        headlessOutput,
+        resolvedConfig,
+        auditScope: auditScopeResolution.value,
+    };
+}
+export function resolveRepoPath(params) {
+    return defaultPathAdapter.resolve(params.repo || params.cwd || process.cwd());
+}
+export function resolveCliCommonOptions(params) {
+    const repoPath = params.repoPath ?? resolveRepoPath({ repo: params.repo, cwd: params.cwd });
+    const verboseLevel = resolveVerboseLevel(params.verbose);
+    let outputFormat;
+    let headlessOutput;
+    if (params.outputFormat !== undefined) {
+        const raw = String(params.outputFormat || '');
+        const resolved = resolveOutputFormat(raw);
+        if (!resolved) {
+            return { ok: false, message: text.cli.invalidOutputFormat(raw) };
+        }
+        outputFormat = resolved;
+        headlessOutput = resolved !== 'text';
+    }
+    return {
+        ok: true,
+        options: {
+            repoPath,
+            verboseLevel,
+            outputFormat,
+            headlessOutput,
+        },
+    };
+}
+//# sourceMappingURL=resolve-cli-config.js.map

package/dist/cli/utils/verbose-level.js

@@ -0,0 +1,8 @@
+export function resolveVerboseLevel(raw) {
+    if (raw === true)
+        return 'basic';
+    if (typeof raw === 'string')
+        return raw;
+    return undefined;
+}
+//# sourceMappingURL=verbose-level.js.map

package/dist/cli/utils/verify-resolver.js

@@ -1,4 +1,4 @@
-import { getLogger } from '../../core/facades/cli-observability.js';
+import { tryGetLogger } from '../../core/facades/cli-observability.js';
 import { text } from '../../locales/index.js';
 import { autoDetectVerifyCommand } from './detectors/index.js';
 /**
@@ -8,11 +8,11 @@ import { autoDetectVerifyCommand } from './detectors/index.js';
  * 3. Config file command -> "cmd"
  * 4. Auto-detection -> "detected-cmd"
  */
-export async function resolveVerifyOption(repoPath, cliVerify, configVerify) {
+export async function resolveVerifyOption(repoPath, cliVerify, configVerify, options = {}) {
     // 1. Explicitly disabled via --no-verify
     // Commander sets options.verify to false when --no-verify is used
     if (cliVerify === false) {
-        getLogger().debug(text.verify.explicitlyDisabled);
+        tryGetLogger()?.debug(text.verify.explicitlyDisabled);
         return undefined;
     }
     // 2. Explicitly provided via CLI --verify "cmd"
@@ -26,7 +26,11 @@ export async function resolveVerifyOption(repoPath, cliVerify, configVerify) {
     // 4. Auto-detect
     const detected = await autoDetectVerifyCommand(repoPath);
     if (detected) {
-        getLogger().info(text.verify.autoDetected(detected));
+        const logger = tryGetLogger();
+        if (options.quiet)
+            logger?.debug(text.verify.autoDetected(detected));
+        else
+            logger?.info(text.verify.autoDetected(detected));
         return detected;
     }
     return undefined;

package/dist/cli/utils/worktree-prepare-resolver.js

@@ -1,7 +1,7 @@
-import { getLogger } from '../../core/facades/cli-utils-worktree.js';
+import { tryGetLogger } from '../../core/facades/cli-utils-worktree.js';
 import { text } from '../../locales/index.js';
 import { autoDetectWorktreePrepareCommand } from './detectors/index.js';
-export async function resolveWorktreePrepareOption(repoPath, strategy, cliWorktreePrepare) {
+export async function resolveWorktreePrepareOption(repoPath, strategy, cliWorktreePrepare, options = {}) {
     if (typeof cliWorktreePrepare === 'string' && cliWorktreePrepare.trim()) {
         return cliWorktreePrepare;
     }
@@ -10,7 +10,11 @@ export async function resolveWorktreePrepareOption(repoPath, strategy, cliWorktr
     }
     const detected = await autoDetectWorktreePrepareCommand(repoPath);
     if (detected) {
-        getLogger().info(text.verify.autoDetectedWorktreePrepare(detected));
+        const logger = tryGetLogger();
+        if (options.quiet)
+            logger?.debug(text.verify.autoDetectedWorktreePrepare(detected));
+        else
+            logger?.info(text.verify.autoDetectedWorktreePrepare(detected));
         return detected;
     }
     return undefined;

package/dist/core/adapters/fs/file-adapter.js

@@ -73,6 +73,12 @@ export class FileAdapter {
     async stat(filePath) {
         return fs.stat(filePath);
     }
+    /**
+     * Get file stats without following symlinks.
+     */
+    async lstat(filePath) {
+        return fs.lstat(filePath);
+    }
     /**
      * Create directory recursively
      */

package/dist/core/adapters/fs/filesystem.js

@@ -1,3 +1,4 @@
+import { resolveExecutionProfile } from '../../runtime/execution-profile.js';
 import { FileAdapter } from './file-adapter.js';
 import { ReadOnlyFileSystem } from './readonly-filesystem.js';
 class FileAdapterFileSystem {
@@ -23,7 +24,7 @@ class FileAdapterFileSystem {
  * Review mode returns a ReadOnlyFileSystem to block writes.
  */
 export function createFileSystemAdapter(mode, realFs = new FileAdapterFileSystem()) {
-    if (mode === 'review' || mode === 'research' || mode === 'answer') {
+    if (resolveExecutionProfile(mode).readOnly) {
         return new ReadOnlyFileSystem(realFs);
     }
     return realFs;

package/dist/core/adapters/git/git-adapter.js

@@ -8,7 +8,7 @@ import { LIMITS } from '../../config/limits.js';
 import { logIgnoredError } from '../../observability/ignored-error.js';
 import { getLogger } from '../../observability/logger.js';
 import { GitError } from '../../types/index.js';
-import { isPathWithinDirectory, normalizePath } from '../../utils/path.js';
+import { isPathWithinDirectory, isSafeRelativePath, normalizePath } from '../../utils/path.js';
 import { runGitCommand } from './git-runner.js';
 import { FileHandleManager } from './lock-manager.js';
 // Singleton map to ensure one lock manager per repository path
@@ -126,6 +126,32 @@ export class GitAdapter {
         this.assertQueryAllowed(args);
         return this.exec(args, options);
     }
+    /**
+     * Generate a git-formatted patch for one repo-relative file that is not in
+     * the index, without staging or otherwise mutating repository state.
+     */
+    async diffUntrackedFileAgainstNull(relativePath, options = {}) {
+        const normalizedPath = normalizePath(relativePath);
+        if (!isSafeRelativePath(normalizedPath)) {
+            throw new Error(text.git.securityViolation('diff --no-index'));
+        }
+        return this.execMeta([
+            'diff',
+            '--no-index',
+            '--binary',
+            '--no-color',
+            '--no-ext-diff',
+            '--src-prefix=a/',
+            '--dst-prefix=b/',
+            '--',
+            '/dev/null',
+            normalizedPath,
+        ], {
+            cwd: options.cwd,
+            limits: options.limits,
+            timeoutMs: options.timeoutMs,
+        });
+    }
     // ==================== Business Layer ====================
     /**
      * Generates a blob hash for the given content without writing to the object database.
@@ -363,6 +389,54 @@ export class GitAdapter {
             await this.lockManager.releaseLock(this.repoPath);
         }
     }
+    async checkPatchApplyability(diffText, options = {}) {
+        const tempFile = path.join(tmpdir(), `salmon-patch-check-${Date.now()}-${randomBytes(4).toString('hex')}.patch`);
+        const tempIndex = path.join(tmpdir(), `salmon-patch-check-index-${Date.now()}-${randomBytes(4).toString('hex')}`);
+        await fs.writeFile(tempFile, diffText, 'utf8');
+        try {
+            const readTree = await this.execMeta(['read-tree', 'HEAD'], {
+                env: { ...options.env, GIT_INDEX_FILE: tempIndex },
+                limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+                timeoutMs: LIMITS.gitTimeoutMs,
+            });
+            if (!readTree.ok) {
+                const output = [readTree.stdout.toString('utf8'), readTree.stderr]
+                    .filter(Boolean)
+                    .join('\n')
+                    .trim();
+                return {
+                    ok: false,
+                    exitCode: readTree.code,
+                    output,
+                };
+            }
+            const args = ['apply', '--cached', '--check', '--recount'];
+            if (options.ignoreWhitespace)
+                args.push('--ignore-whitespace');
+            if (options.contextLines)
+                args.push(`-C${options.contextLines}`);
+            args.push(tempFile);
+            const res = await this.execMeta(args, {
+                env: { ...options.env, GIT_INDEX_FILE: tempIndex },
+                limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+                timeoutMs: LIMITS.gitTimeoutMs,
+            });
+            const output = [res.stdout.toString('utf8'), res.stderr].filter(Boolean).join('\n').trim();
+            return {
+                ok: res.ok,
+                exitCode: res.code,
+                output,
+            };
+        }
+        finally {
+            await fs
+                .unlink(tempFile)
+                .catch((error) => logIgnoredError(`[GitAdapter] cleanup ${tempFile}`, error));
+            await fs
+                .unlink(tempIndex)
+                .catch((error) => logIgnoredError(`[GitAdapter] cleanup ${tempIndex}`, error));
+        }
+    }
     /**
      * Precision rollback protecting staged changes.
      */
@@ -407,6 +481,9 @@ export class GitAdapter {
             }
         }
         catch (error) {
+            if (!this.isShadowWorktreePath()) {
+                throw error;
+            }
             try {
                 await this.resolveConflicts();
             }

package/dist/core/benchmark/patch-artifact.js

@@ -0,0 +1,124 @@
+import { createHash } from 'crypto';
+import { EOL } from 'os';
+import path from 'path';
+import { FileAdapter } from '../adapters/fs/file-adapter.js';
+import { GitAdapter } from '../adapters/git/git-adapter.js';
+import { LIMITS } from '../config/limits.js';
+import { isPathWithinDirectory, isSafeRelativePath, normalizePath } from '../utils/path.js';
+export class BenchmarkPatchArtifactError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BenchmarkPatchArtifactError';
+    }
+}
+const DIFF_ARGS = [
+    'diff',
+    '--binary',
+    '--no-color',
+    '--no-ext-diff',
+    '--src-prefix=a/',
+    '--dst-prefix=b/',
+    'HEAD',
+    '--',
+    '.',
+];
+function normalizeGitPatch(text) {
+    const normalized = text.replace(/\r\n/g, '\n').replace(/\s+$/, '');
+    return normalized.length > 0 ? `${normalized}\n` : '';
+}
+function splitLines(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+async function buildUntrackedFilePatch(params) {
+    if (!isSafeRelativePath(params.relativePath) || params.relativePath.startsWith('.salmonloop/')) {
+        throw new BenchmarkPatchArtifactError(`Unsafe untracked patch path: ${params.relativePath}`);
+    }
+    const result = await params.git.diffUntrackedFileAgainstNull(params.relativePath, {
+        cwd: params.repoPath,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes },
+    });
+    if (result.code !== 0 && result.code !== 1) {
+        throw new BenchmarkPatchArtifactError(result.stderr || 'Failed to diff untracked file.');
+    }
+    return normalizeGitPatch(result.stdout.toString('utf8'));
+}
+function parseChangedFilesFromPatch(patch) {
+    const files = new Set();
+    for (const line of patch.split('\n')) {
+        const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (!match)
+            continue;
+        const next = match[2];
+        if (next !== '/dev/null')
+            files.add(next);
+    }
+    return Array.from(files).sort();
+}
+export async function buildBenchmarkPatchArtifact(params) {
+    const git = new GitAdapter(params.repoPath);
+    const fileAdapter = new FileAdapter();
+    const excluded = await resolveRepoRelativeExcludes(params.repoPath, params.excludePaths ?? []);
+    const pathspecs = buildPatchPathspecs(excluded);
+    const trackedPatch = normalizeGitPatch(await git.query([...DIFF_ARGS, ...pathspecs], {
+        trim: false,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes },
+    }));
+    const candidateUntracked = new Set([
+        ...splitLines(await git.query(['ls-files', '--others', '--exclude-standard'])),
+        ...(params.changedFilesHint ?? []),
+    ]);
+    const untrackedPatches = [];
+    for (const relativePath of Array.from(candidateUntracked).sort()) {
+        const normalizedPath = normalizePath(relativePath);
+        if (!normalizedPath || normalizedPath.startsWith('.salmonloop/'))
+            continue;
+        if (excluded.has(normalizedPath))
+            continue;
+        const status = await git.getStatusForPath(normalizedPath);
+        if (!status?.untracked)
+            continue;
+        if (!(await fileAdapter.exists(path.join(params.repoPath, normalizedPath))))
+            continue;
+        untrackedPatches.push(await buildUntrackedFilePatch({
+            repoPath: params.repoPath,
+            git,
+            relativePath: normalizedPath,
+        }));
+    }
+    const patch = normalizeGitPatch([trackedPatch, ...untrackedPatches].filter(Boolean).join(EOL));
+    const bytes = Buffer.byteLength(patch, 'utf8');
+    return {
+        patch,
+        bytes,
+        sha256: createHash('sha256').update(patch, 'utf8').digest('hex'),
+        changedFiles: parseChangedFilesFromPatch(patch),
+        isEmpty: patch.length === 0,
+    };
+}
+function buildPatchPathspecs(excluded) {
+    return Array.from(excluded)
+        .sort()
+        .map((relativePath) => `:(top,literal,exclude)${relativePath}`);
+}
+async function resolveRepoRelativeExcludes(repoPath, paths) {
+    const resolvedRepoPath = path.resolve(repoPath);
+    const excluded = new Set();
+    for (const candidate of paths) {
+        if (!candidate)
+            continue;
+        const absolutePath = path.isAbsolute(candidate)
+            ? path.resolve(candidate)
+            : path.resolve(resolvedRepoPath, candidate);
+        const relativePath = normalizePath(path.relative(resolvedRepoPath, absolutePath));
+        if (!isSafeRelativePath(relativePath))
+            continue;
+        if (!isPathWithinDirectory(resolvedRepoPath, absolutePath))
+            continue;
+        excluded.add(relativePath);
+    }
+    return excluded;
+}
+//# sourceMappingURL=patch-artifact.js.map

package/dist/core/benchmark/swe-bench.js

@@ -0,0 +1,25 @@
+export function buildSweBenchPrediction(input) {
+    return {
+        instance_id: input.instanceId,
+        model_name_or_path: input.modelNameOrPath,
+        model_patch: input.modelPatch,
+    };
+}
+export function encodeSweBenchPredictionJsonl(input) {
+    return `${JSON.stringify(buildSweBenchPrediction(input))}\n`;
+}
+export function parseSweBenchInstance(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('SWE-bench instance must be a JSON object.');
+    }
+    const instance = parsed;
+    if (typeof instance.instance_id !== 'string' || !instance.instance_id.trim()) {
+        throw new Error('SWE-bench instance requires a non-empty instance_id.');
+    }
+    return {
+        ...instance,
+        instance_id: instance.instance_id,
+    };
+}
+//# sourceMappingURL=swe-bench.js.map