salmon-loop 0.3.1 → 0.4.1

package/dist/core/context/gatherers/ast-gatherer.js

@@ -181,25 +181,17 @@ export class AstGatherer {
     async gatherCallNames(parsedTree, lang, callsQuery) {
         if (!parsedTree || !lang || !callsQuery)
             return [];
-        const queryFn = AstParser.queryCapturesFromQuery;
-        if (typeof queryFn !== 'function')
-            return [];
-        const captures = (await queryFn(parsedTree, lang, callsQuery));
+        const captures = await AstParser.queryCapturesFromQuery(parsedTree, lang, callsQuery);
         return Array.from(new Set(captures
             .filter((c) => c.name === 'callee' && c.text.trim().length > 0)
             .map((c) => c.text.trim())));
     }
     async gatherDeepAnalysis(primaryText, parsedTree, lang, flowPack) {
-        const queryFn = AstParser.queryCapturesFromQuery;
-        if (!parsedTree ||
-            !lang ||
-            !flowPack?.control ||
-            !flowPack?.exceptions ||
-            typeof queryFn !== 'function') {
+        if (!parsedTree || !lang || !flowPack?.control || !flowPack?.exceptions) {
             return summarizeControlFlow(primaryText);
         }
-        const controlCaptures = (await queryFn(parsedTree, lang, flowPack.control));
-        const exceptionCaptures = (await queryFn(parsedTree, lang, flowPack.exceptions));
+        const controlCaptures = await AstParser.queryCapturesFromQuery(parsedTree, lang, flowPack.control);
+        const exceptionCaptures = await AstParser.queryCapturesFromQuery(parsedTree, lang, flowPack.exceptions);
         const branchCount = controlCaptures.filter((c) => c.name === 'branch').length;
         const loopCount = controlCaptures.filter((c) => c.name === 'loop').length;
         const asyncBoundaryCount = controlCaptures.filter((c) => c.name === 'async').length;

package/dist/core/context/gatherers/ghost-dependency-gatherer.js

@@ -39,7 +39,6 @@ export class GhostDependencyGatherer {
             mode: 'outline',
             content: `// Ghost Dependency: Shares tokens [${Array.from(data.tokens).join(', ')}]
 `,
-            reason: 'ghost_dependency',
         }));
     }
 }

package/dist/core/context/gatherers/knowledge-gatherer.js

@@ -50,6 +50,9 @@ export class KnowledgeGatherer {
                         data.deprecated_rules.forEach((r) => allDeprecated.add(r));
                     }
                     if (data.architectural_decisions) {
+                        if (!Array.isArray(aggregated.architectural_decisions)) {
+                            aggregated.architectural_decisions = [];
+                        }
                         aggregated.architectural_decisions.push(...data.architectural_decisions);
                     }
                     if (data.user_preferences) {

package/dist/core/context/service.js

@@ -119,6 +119,7 @@ export class ContextService {
             expectedTargetSetSignature;
         if (recordedTargetSetSignature !== expectedTargetSetSignature) {
             await this.cacheStore.delete(cacheKey);
+            this.deleteUpdater(cacheKey);
             this.cacheMetrics.misses += 1;
             return {
                 missReason: 'target_signature_mismatch',
@@ -128,6 +129,7 @@ export class ContextService {
         const nextSignature = await this.computeTrackedFilesSignature(repoPath, entry.trackedFiles);
         if (nextSignature !== entry.signature) {
             await this.cacheStore.delete(cacheKey);
+            this.deleteUpdater(cacheKey);
             this.cacheMetrics.misses += 1;
             return { missReason: 'signature_mismatch', targetSetSignature: expectedTargetSetSignature };
         }
@@ -210,29 +212,55 @@ export class ContextService {
         if (!last || Date.now() - last <= this.cacheTtlMs)
             return false;
         await this.cacheStore.delete(cacheKey);
+        this.deleteUpdater(cacheKey);
         this.cacheMetrics.evictions += 1;
         return true;
     }
     async evictExpiredEntries() {
-        for (const [key, entry] of await this.cacheStore.entries()) {
-            await this.isExpired(key, entry);
+        const entries = Array.from(await this.cacheStore.entries());
+        const now = Date.now();
+        const expiredEntries = entries.filter(([, entry]) => {
+            const last = this.getEntryTimestamp(entry);
+            return last && now - last > this.cacheTtlMs;
+        });
+        for (let i = 0; i < expiredEntries.length; i += 10) {
+            const chunk = expiredEntries.slice(i, i + 10);
+            await Promise.all(chunk.map(([key, entry]) => this.isExpired(key, entry)));
         }
     }
     async evictLruIfNeeded() {
-        while ((await this.cacheStore.size()) > this.cacheMaxEntries) {
+        const size = await this.cacheStore.size();
+        if (size <= this.cacheMaxEntries)
+            return;
+        const excess = size - this.cacheMaxEntries;
+        const entries = Array.from(await this.cacheStore.entries());
+        if (excess === 1) {
             let victimKey;
             let victimTs = Number.POSITIVE_INFINITY;
-            for (const [key, entry] of await this.cacheStore.entries()) {
+            for (const [key, entry] of entries) {
                 const ts = this.getEntryTimestamp(entry);
                 if (ts < victimTs) {
                     victimTs = ts;
                     victimKey = key;
                 }
             }
-            if (!victimKey)
-                break;
-            await this.cacheStore.delete(victimKey);
-            this.cacheMetrics.evictions += 1;
+            if (victimKey) {
+                await this.cacheStore.delete(victimKey);
+                this.deleteUpdater(victimKey);
+                this.cacheMetrics.evictions += 1;
+            }
+        }
+        else {
+            entries.sort((a, b) => (this.getEntryTimestamp(a[1]) || 0) - (this.getEntryTimestamp(b[1]) || 0));
+            const victims = entries.slice(0, excess);
+            for (let i = 0; i < victims.length; i += 10) {
+                const chunk = victims.slice(i, i + 10);
+                await Promise.all(chunk.map(async ([key]) => {
+                    await this.cacheStore.delete(key);
+                    this.deleteUpdater(key);
+                    this.cacheMetrics.evictions += 1;
+                }));
+            }
         }
     }
     async getCacheStats() {
@@ -262,6 +290,9 @@ export class ContextService {
         }
         return updater;
     }
+    deleteUpdater(key) {
+        this.updaters.delete(key);
+    }
     logDiff(key, diff) {
         if (!diff.addedFiles.length && !diff.modifiedFiles.length && !diff.removedFiles.length) {
             return;

package/dist/core/context/token/encoding-registry.js

@@ -24,13 +24,13 @@ class TiktokenEncoding {
         this.initialized = true;
     }
     encode(text) {
-        this.ensureInitialized();
-        return Array.from(this.encoder.encode(text));
+        const encoder = this.getEncoder();
+        return Array.from(encoder.encode(text));
     }
     decode(tokens) {
-        this.ensureInitialized();
+        const encoder = this.getEncoder();
         const uint32Tokens = new Uint32Array(tokens);
-        const decoded = this.encoder.decode(uint32Tokens);
+        const decoded = encoder.decode(uint32Tokens);
         return new TextDecoder().decode(decoded);
     }
     count(text) {
@@ -43,10 +43,11 @@ class TiktokenEncoding {
         }
         this.initialized = false;
     }
-    ensureInitialized() {
-        if (!this.initialized || !this.encoder) {
+    getEncoder() {
+        if (!this.encoder) {
             throw new Error(`Encoding ${this.name} not initialized. Call initialize() first.`);
         }
+        return this.encoder;
     }
 }
 /**

package/dist/core/extensions/index.js

@@ -3,9 +3,9 @@ import { buildResolvedMcpServersV2 } from '../mcp/config/index.js';
 import { getLogger } from '../observability/logger.js';
 import { loadConfig } from './load.js';
 import { mergeScopedEntries } from './merge.js';
-import { expandHome, getRepoMcpConfigPath, getRepoSkillConfigPath, getRepoToolConfigPath, getUserMcpConfigPath, getUserSkillConfigPath, getUserToolConfigPath, isWithinRoot, resolveRepoRelative, resolveUserRelative, } from './paths.js';
+import { expandHome, getRepoAgentsConfigPath, getRepoMcpConfigPath, getRepoSkillConfigPath, getRepoToolConfigPath, getUserAgentsConfigPath, getUserMcpConfigPath, getUserSkillConfigPath, getUserToolConfigPath, isWithinRoot, resolveRepoRelative, resolveUserRelative, } from './paths.js';
 import { redactExtensions } from './redact.js';
-import { McpConfigSchema, SkillsConfigSchema, ToolsConfigSchema } from './schemas.js';
+import { AgentsConfigSchema, McpConfigSchema, SkillsConfigSchema, ToolsConfigSchema, } from './schemas.js';
 function defaultEnabled(scope) {
     return scope === 'repo';
 }
@@ -29,6 +29,47 @@ function buildResolvedPlugins(entries, repoRoot) {
         };
     });
 }
+function buildResolvedAgentProfiles(user, repo) {
+    const seen = new Map();
+    // User profiles first (lower priority)
+    if (user) {
+        for (const agent of user.agents) {
+            if (agent.enabled === false)
+                continue;
+            seen.set(agent.id, toResolvedProfile(agent, 'user'));
+        }
+    }
+    // Repo profiles override user profiles (higher priority)
+    if (repo) {
+        for (const agent of repo.agents) {
+            if (agent.enabled === false) {
+                seen.delete(agent.id);
+                continue;
+            }
+            seen.set(agent.id, toResolvedProfile(agent, 'repo'));
+        }
+    }
+    return Array.from(seen.values());
+}
+function toResolvedProfile(raw, scope) {
+    return {
+        id: raw.id,
+        name: raw.name,
+        role: raw.role,
+        description: raw.description,
+        allowedTools: raw.allowedTools ?? ['code.search', 'fs.read'],
+        readOnly: raw.readOnly ?? false,
+        stratagem: raw.stratagem ?? 'investigator',
+        toolInheritance: raw.toolInheritance,
+        permissionMode: raw.permissionMode,
+        systemPrompt: raw.systemPrompt,
+        maxTokens: raw.maxTokens,
+        maxAttempts: raw.maxAttempts,
+        timeoutMs: raw.timeoutMs,
+        model: raw.model,
+        scope,
+    };
+}
 function buildResolvedSkills(user, repo, repoRoot) {
     const repoDiscovery = repo?.discovery;
     const userDiscovery = user?.discovery;
@@ -73,13 +114,15 @@ function buildResolvedSkills(user, repo, repoRoot) {
 }
 export async function resolveExtensions(options) {
     const { repoRoot } = options;
-    const [userMcp, repoMcp, userTools, repoTools, userSkills, repoSkills] = await Promise.all([
+    const [userMcp, repoMcp, userTools, repoTools, userSkills, repoSkills, userAgents, repoAgents] = await Promise.all([
         loadConfig(getUserMcpConfigPath(), McpConfigSchema),
         loadConfig(getRepoMcpConfigPath(repoRoot), McpConfigSchema),
         loadConfig(getUserToolConfigPath(), ToolsConfigSchema),
         loadConfig(getRepoToolConfigPath(repoRoot), ToolsConfigSchema),
         loadConfig(getUserSkillConfigPath(), SkillsConfigSchema),
         loadConfig(getRepoSkillConfigPath(repoRoot), SkillsConfigSchema),
+        loadConfig(getUserAgentsConfigPath(), AgentsConfigSchema),
+        loadConfig(getRepoAgentsConfigPath(repoRoot), AgentsConfigSchema),
     ]);
     const mergedServers = mergeScopedEntries(userMcp?.config.servers, repoMcp?.config.servers);
     const mergedPlugins = mergeScopedEntries(userTools?.config.plugins, repoTools?.config.plugins);
@@ -87,11 +130,13 @@ export async function resolveExtensions(options) {
         mcpServers: buildResolvedMcpServersV2(mergedServers, repoRoot),
         toolPlugins: buildResolvedPlugins(mergedPlugins, repoRoot),
         skillDiscovery: buildResolvedSkills(userSkills?.config, repoSkills?.config, repoRoot),
+        agentProfiles: buildResolvedAgentProfiles(userAgents?.config, repoAgents?.config),
     };
     const rawEffective = {
         mcp: repoMcp?.config ?? userMcp?.config ?? null,
         tools: repoTools?.config ?? userTools?.config ?? null,
         skills: repoSkills?.config ?? userSkills?.config ?? null,
+        agents: repoAgents?.config ?? userAgents?.config ?? null,
     };
     return {
         resolved,

package/dist/core/extensions/load.js

@@ -1,4 +1,5 @@
 import { syncFs as fs } from '../adapters/fs/node-fs.js';
+import { errorMessage } from '../utils/error.js';
 export class ExtensionConfigError extends Error {
     path;
     constructor(path, message) {
@@ -18,7 +19,7 @@ export async function tryLoadJsonFile(path) {
             : undefined) === 'ENOENT') {
             return { exists: false };
         }
-        throw new ExtensionConfigError(path, (error instanceof Error ? error.message : String(error)) || 'Unable to read file');
+        throw new ExtensionConfigError(path, errorMessage(error) || 'Unable to read file');
     }
 }
 export async function loadConfig(path, schema) {
@@ -30,7 +31,7 @@ export async function loadConfig(path, schema) {
         return { path, config };
     }
     catch (error) {
-        throw new ExtensionConfigError(path, (error instanceof Error ? error.message : String(error)) || 'Schema validation failed');
+        throw new ExtensionConfigError(path, errorMessage(error) || 'Schema validation failed');
     }
 }
 //# sourceMappingURL=load.js.map

package/dist/core/extensions/merge.js

@@ -11,7 +11,10 @@ export function mergeScopedEntries(user, repo) {
             if (previous) {
                 merged.set(key, {
                     key,
-                    entry: { ...previous.entry, ...entry },
+                    entry: {
+                        ...previous.entry,
+                        ...entry,
+                    },
                     scope: 'repo',
                 });
             }
@@ -38,6 +41,7 @@ export function mergeResolvedExtensions(base, overlay) {
                 : base.skillDiscovery.scope,
             paths: [...base.skillDiscovery.paths, ...overlay.skillDiscovery.paths],
         },
+        agentProfiles: [...base.agentProfiles, ...overlay.agentProfiles],
     };
 }
 //# sourceMappingURL=merge.js.map

package/dist/core/extensions/paths.js

@@ -39,6 +39,12 @@ export function getUserToolConfigPath() {
 export function getUserSkillConfigPath() {
     return path.join(USER_CONFIG_DIR, 'skills-user.json');
 }
+export function getRepoAgentsConfigPath(repoRoot) {
+    return path.join(repoRoot, REPO_CONFIG_DIR, 'agents.json');
+}
+export function getUserAgentsConfigPath() {
+    return path.join(USER_CONFIG_DIR, 'agents-user.json');
+}
 /**
  * Check whether a candidate path resides within (or equals) a given root directory.
  *

package/dist/core/extensions/schemas.js

@@ -21,4 +21,25 @@ export const SkillsConfigSchema = z
     discovery: skillDiscoverySchema.optional().default({}),
 })
     .strict();
+export const AgentProfileConfigSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    role: z.string().min(1),
+    description: z.string(),
+    allowedTools: z.array(z.string()).optional(),
+    toolInheritance: z.enum(['none', 'safe', 'all']).optional(),
+    permissionMode: z.enum(['default', 'plan', 'bypassPermissions']).optional(),
+    systemPrompt: z.string().optional(),
+    readOnly: z.boolean().optional(),
+    stratagem: z.enum(['investigator', 'surgeon', 'janitor']).optional(),
+    maxTokens: z.number().positive().optional(),
+    maxAttempts: z.number().positive().optional(),
+    timeoutMs: z.number().positive().optional(),
+    model: z.string().optional(),
+    enabled: z.boolean().optional(),
+});
+export const AgentsConfigSchema = z.object({
+    version: z.literal(1),
+    agents: z.array(AgentProfileConfigSchema),
+});
 //# sourceMappingURL=schemas.js.map

package/dist/core/facades/cli-command-chat.js

@@ -1,9 +1,11 @@
 export { ConfigError, normalizePermissionMode, resolveConfig } from '../config/index.js';
 export { ExtensionConfigError, resolveExtensions } from '../extensions/index.js';
 export { createRuntimeLlm } from '../llm/factory.js';
+export { createSubAgentLlmFactory } from '../llm/sub-agent-factory.js';
 export { getLogger } from '../observability/logger.js';
 export { PluginLoader } from '../plugin/loader.js';
 export { resolveExecutionProfile } from '../runtime/execution-profile.js';
 export { clearPluginRegistry, createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { clearPromptRegistry, createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';
+export { getString } from '../utils/serialize.js';
 //# sourceMappingURL=cli-command-chat.js.map

package/dist/core/facades/cli-run-handler.js

@@ -1,4 +1,5 @@
 export { normalizePermissionMode } from '../config/index.js';
+export { createSubAgentLlmFactory } from '../llm/sub-agent-factory.js';
 export { getLogger, PlainReporter, SilentReporter } from '../observability/logger.js';
 export { createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';

package/dist/core/facades/cli-utils-serialize.js

@@ -0,0 +1,2 @@
+export { isRecord } from '../utils/serialize.js';
+//# sourceMappingURL=cli-utils-serialize.js.map

package/dist/core/grizzco/dsl/llm-strategy.js

@@ -1,5 +1,6 @@
 import { resolveLlmCapabilities } from '../../llm/capabilities.js';
 import { Phase } from '../../types/runtime.js';
+import { FileStatus, OpType } from '../domain/grizzco-types.js';
 import { DecisionEngine, PlanBuilder } from './DecisionEngine.js';
 function defaultMaxRoundsForPhase(phase) {
     // Explore needs more rounds to navigate the codebase
@@ -24,7 +25,7 @@ export function resolveLlmToolCallingPolicy(phase, llm) {
         repoRoot: '',
         file: {
             path: '',
-            status: 0,
+            status: FileStatus.CLEAN,
             isBinary: false,
             isSymlink: false,
             isIgnored: false,
@@ -32,7 +33,7 @@ export function resolveLlmToolCallingPolicy(phase, llm) {
             size: 0,
         },
         operation: {
-            type: 0,
+            type: OpType.PATCH,
             path: '',
         },
         options: {

package/dist/core/grizzco/engine/outcome/loop-result-mapper.js

@@ -5,6 +5,7 @@ import { buildFailureEnvelope } from '../../../observability/error-envelope.js';
 import { getTokenUsageFromAuditTrail } from '../../../observability/token-usage.js';
 import { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
 import { ErrorType, Phase } from '../../../types/runtime.js';
+import { isRecord } from '../../../utils/serialize.js';
 const ROOT_CAUSE_CODES = [
     'LLM_RATE_LIMITED',
     'LLM_UPSTREAM_5XX',
@@ -34,17 +35,19 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
                 : 'NON_RETRYABLE_FAILURE';
     const ctx = executionReport.lastContext ??
         executionReport.flowReport.data;
+    const ctxObj = isRecord(ctx) ? ctx : null;
     const contextHash = (() => {
-        const hashFromBudget = ctx?.contextResult?.meta?.contextHash;
+        const contextResult = isRecord(ctxObj?.contextResult) ? ctxObj.contextResult : null;
+        const meta = isRecord(contextResult?.meta) ? contextResult.meta : null;
+        const hashFromBudget = meta?.contextHash;
         if (typeof hashFromBudget === 'string')
             return hashFromBudget;
-        const hashFromContext = ctx && typeof ctx === 'object' && 'context' in ctx
-            ? ctx.context?.contextHash
-            : undefined;
+        const context = isRecord(ctxObj?.context) ? ctxObj.context : null;
+        const hashFromContext = context?.contextHash;
         return typeof hashFromContext === 'string' ? hashFromContext : undefined;
     })();
-    const verifyArtifact = ctx && typeof ctx === 'object' && 'verifyArtifact' in ctx
-        ? ctx.verifyArtifact
+    const verifyArtifact = ctxObj && typeof ctxObj.verifyArtifact !== 'undefined'
+        ? ctxObj.verifyArtifact
         : executionReport.lastVerifyArtifact;
     const artifactHints = (() => {
         const hints = {
@@ -71,12 +74,14 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         }
         return hints;
     })();
+    const report = isRecord(ctxObj?.report) ? ctxObj.report : null;
     const assistantMessage = ((flowMode === 'answer' || profile.driver === 'agent') &&
-        ctx?.report?.summary?.trim?.()
-        ? String(ctx.report.summary).trim()
+        typeof report?.summary === 'string' &&
+        report.summary.trim()
+        ? report.summary.trim()
         : undefined) ?? undefined;
-    const finalPatch = ctx && typeof ctx === 'object' && 'diff' in ctx ? ctx.diff : undefined;
-    const changedFiles = ctx && typeof ctx === 'object' && 'changedFiles' in ctx ? ctx.changedFiles : undefined;
+    const finalPatch = ctxObj && typeof ctxObj.diff === 'string' ? ctxObj.diff : undefined;
+    const changedFiles = Array.isArray(ctxObj?.changedFiles) ? ctxObj.changedFiles : undefined;
     const authorizationDecisions = (() => {
         if (!options.eventPayload?.includeAuthorizationDecisions)
             return undefined;