salmon-loop 0.3.2 → 0.4.1

package/dist/core/sub-agent/tools/task-await.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { Phase } from '../../types/runtime.js';
+import { createSubAgentController } from '../controller.js';
+const AgentAwaitInputSchema = z.object({
+    agentId: z.string().min(1).describe('The agent ID returned by agent_dispatch in async mode.'),
+    timeout_seconds: z
+        .number()
+        .positive()
+        .optional()
+        .describe('Maximum time to wait for the result. Defaults to the agent profile timeout.'),
+});
+/**
+ * agent_await (Internal: Smallfry Result Collector)
+ * Waits for an asynchronously dispatched sub-agent to complete and returns its result.
+ * Polls the shared controller (same instance used by agent_dispatch) for agent status.
+ */
+export const agentAwaitTaskSpec = {
+    name: 'agent_await',
+    source: 'builtin',
+    intent: 'AGENT',
+    description: text.smallfry.ui.awaitToolDescription,
+    riskLevel: 'low',
+    defaultTimeoutMs: 300_000,
+    sideEffects: ['none'],
+    concurrency: 'parallel_ok',
+    allowedPhases: [Phase.PLAN, Phase.CONTEXT, Phase.AUTOPILOT],
+    inputSchema: AgentAwaitInputSchema,
+    outputSchema: z.any(), // Maps to SubAgentResult
+    examples: [
+        {
+            description: 'Await the result of an async sub-agent',
+            input: {
+                agentId: 'smallfry-a1b2c3d4',
+            },
+            output: {
+                success: true,
+                agent_ref: 'explorer',
+                summary: '<diagnosis and findings>',
+            },
+        },
+    ],
+    executor: async (input, ctx) => {
+        const parsed = AgentAwaitInputSchema.parse(input);
+        const controller = ctx.subAgentController ?? createSubAgentController();
+        const timeoutMs = parsed.timeout_seconds ? parsed.timeout_seconds * 1000 : 300_000;
+        try {
+            // Try awaiting the specific agent ID first (short timeout — if the ID is a
+            // placeholder like '{{handle}}' that no one will resolve, we must fall through
+            // to the scanning fallback quickly).
+            let result = await controller.awaitResult(parsed.agentId, Math.min(timeoutMs, 200));
+            // If not found (e.g., LLM used a placeholder), wait for any pending agent.
+            if (!result) {
+                const agents = controller.listAgents();
+                for (const agent of agents) {
+                    if (agent.status === 'terminated') {
+                        // Already completed — try to get the stored result
+                        result = await controller.awaitResult(agent.id, 0);
+                        if (result)
+                            break;
+                    }
+                }
+            }
+            // If still no result, wait for the first agent to complete
+            if (!result) {
+                const deadline = Date.now() + timeoutMs;
+                while (Date.now() < deadline) {
+                    const agents = controller.listAgents();
+                    for (const agent of agents) {
+                        if (agent.status === 'terminated') {
+                            result = await controller.awaitResult(agent.id, 0);
+                            if (result)
+                                break;
+                        }
+                    }
+                    if (result)
+                        break;
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                }
+            }
+            if (result)
+                return result;
+            // Timeout
+            return {
+                success: false,
+                agent_ref: parsed.agentId,
+                summary: `Timed out waiting for agent ${parsed.agentId}`,
+                reason: `Timed out after ${timeoutMs}ms`,
+                reasonCode: 'AWAIT_FAILED',
+                tokenUsage: 0,
+                attempts: 1,
+                logs: [],
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                agent_ref: parsed.agentId,
+                summary: error instanceof Error ? error.message : String(error),
+                reason: error instanceof Error ? error.message : String(error),
+                reasonCode: 'AWAIT_FAILED',
+                tokenUsage: 0,
+                attempts: 1,
+                logs: [],
+            };
+        }
+    },
+};
+//# sourceMappingURL=task-await.js.map

package/dist/core/sub-agent/tools/task-spawn.js

@@ -6,8 +6,8 @@ import { mergeSubAgentContextSnapshot } from '../context-snapshot.js';
 import { createSubAgentController } from '../controller.js';
 import { SubAgentManager } from '../core/manager.js';
 import { validateSharedPrefixConsistency } from '../prefix-consistency.js';
-import { SubAgentRequestSchema } from '../types.js';
-function normalizeDispatchRequest(input, ctx) {
+import { SubAgentRequestSchema, } from '../types.js';
+export function normalizeDispatchRequest(input, ctx) {
     const requested = {
         ...input,
         session_target: input.session_target ?? 'isolated',
@@ -18,6 +18,17 @@ function normalizeDispatchRequest(input, ctx) {
                     ? 'review'
                     : 'diagnosis'),
     };
+    if (requested.session_target === 'fork') {
+        // Fork mode: inherit parent's conversation context with cache sharing
+        return {
+            ...requested,
+            contextSnapshot: {
+                ...requested.contextSnapshot,
+                conversationContext: ctx.contextSnapshot?.conversationContext,
+                cacheSharing: ctx.contextSnapshot?.cacheSharing,
+            },
+        };
+    }
     if (requested.session_target !== 'shared') {
         return requested;
     }
@@ -52,6 +63,7 @@ function normalizeDispatchRequest(input, ctx) {
 /**
  * agent_dispatch (Internal: Smallfry Dispatcher)
  * The primary tool for spawning autonomous sub-agents to handle specialized sub-tasks.
+ * Supports async mode: set async=true to get a handle immediately, then use agent_await.
  */
 export const subAgentTaskSpec = {
     name: 'agent_dispatch',
@@ -66,7 +78,7 @@ export const subAgentTaskSpec = {
     concurrency: 'parallel_ok', // Smallfrys handle their own isolation
     allowedPhases: [Phase.PLAN, Phase.CONTEXT, Phase.AUTOPILOT],
     inputSchema: SubAgentRequestSchema,
-    outputSchema: z.any(), // Maps to SubAgentResult
+    outputSchema: z.any(), // Maps to SubAgentResult | SubAgentHandle
     examples: [
         {
             description: 'Ask a read-only explorer to inspect failing tests before editing',
@@ -95,12 +107,42 @@ export const subAgentTaskSpec = {
                 summary: '<review findings>',
             },
         },
+        {
+            description: 'Async dispatch: spawn an explorer and continue working',
+            input: {
+                agent_ref: 'explorer',
+                task: 'Scan src/utils/ for unused exports.',
+                async: true,
+            },
+            output: {
+                agentId: 'smallfry-a1b2c3d4',
+                status: 'working',
+                taskId: 'smallfry-a1b2c3d4',
+            },
+        },
     ],
     executor: async (input, ctx) => {
-        const manager = new SubAgentManager(ctx, ctx.subAgentController ?? createSubAgentController());
-        const request = normalizeDispatchRequest(input, ctx);
-        // Launch the Smallfry via the manager
-        return await manager.execute(request);
+        const parsed = SubAgentRequestSchema.parse(input);
+        const manager = new SubAgentManager(ctx, ctx.subAgentController ?? createSubAgentController(), {
+            llmFactory: ctx.llmFactory,
+            onSubAgentComplete: ctx.onSubAgentComplete,
+        });
+        const request = normalizeDispatchRequest(parsed, ctx);
+        try {
+            return await manager.execute(request);
+        }
+        catch (error) {
+            return {
+                success: false,
+                agent_ref: request.agent_ref,
+                summary: error instanceof Error ? error.message : String(error),
+                reason: error instanceof Error ? error.message : String(error),
+                reasonCode: 'DISPATCH_FAILED',
+                tokenUsage: 0,
+                attempts: 1,
+                logs: [],
+            };
+        }
     },
 };
 //# sourceMappingURL=task-spawn.js.map

package/dist/core/sub-agent/tools/team.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { Phase } from '../../types/runtime.js';
+import { getOrCreateTeam } from '../team.js';
+const AgentTeamInputSchema = z.object({
+    action: z
+        .enum(['claim', 'release', 'list', 'is_claimed'])
+        .describe('Action: claim a task key, release a claim, list all claims, or check if claimed.'),
+    taskKey: z
+        .string()
+        .optional()
+        .describe('The task/file key to claim, release, or check. Required for claim/release/is_claimed.'),
+    teamId: z.string().min(1).describe('The team ID to operate on.'),
+});
+/**
+ * agent_team — Coordination tool for parallel sub-agents.
+ * Allows sub-agents to claim tasks/files and query the team board
+ * to avoid duplicate work.
+ */
+export const agentTeamSpec = {
+    name: 'agent_team',
+    source: 'builtin',
+    intent: 'AGENT',
+    description: 'Coordinate with parallel sub-agents. Use "claim" to declare you are working on a task/file, "list" to see current claims, "is_claimed" to check availability, "release" to free a claim.',
+    riskLevel: 'low',
+    defaultTimeoutMs: 5_000,
+    sideEffects: ['none'],
+    concurrency: 'parallel_ok',
+    allowedPhases: [Phase.PLAN, Phase.CONTEXT, Phase.AUTOPILOT],
+    inputSchema: AgentTeamInputSchema,
+    outputSchema: z.any(),
+    examples: [
+        {
+            description: 'Claim a file for editing',
+            input: { action: 'claim', taskKey: 'src/utils/parser.ts', teamId: 'team-alpha' },
+            output: { success: true, claimed: true },
+        },
+        {
+            description: 'Check if a file is already claimed',
+            input: { action: 'is_claimed', taskKey: 'src/utils/parser.ts', teamId: 'team-alpha' },
+            output: { claimed: true, claimedBy: 'smallfry-a1b2c3d4' },
+        },
+        {
+            description: 'List all current claims',
+            input: { action: 'list', teamId: 'team-alpha' },
+            output: {
+                claims: [
+                    {
+                        taskKey: 'src/utils/parser.ts',
+                        claimedBy: 'smallfry-a1b2c3d4',
+                        claimedAt: 1717800000000,
+                    },
+                ],
+            },
+        },
+    ],
+    executor: async (input, ctx) => {
+        const parsed = AgentTeamInputSchema.parse(input);
+        const agentId = ctx.agentId ?? 'unknown';
+        const team = getOrCreateTeam(parsed.teamId);
+        switch (parsed.action) {
+            case 'claim': {
+                if (!parsed.taskKey)
+                    return { success: false, error: 'taskKey required for claim' };
+                const claimed = team.claim(parsed.taskKey, agentId);
+                return { success: true, claimed };
+            }
+            case 'release': {
+                if (!parsed.taskKey)
+                    return { success: false, error: 'taskKey required for release' };
+                const released = team.release(parsed.taskKey, agentId);
+                return { success: true, released };
+            }
+            case 'is_claimed': {
+                if (!parsed.taskKey)
+                    return { success: false, error: 'taskKey required for is_claimed' };
+                const existing = team.listClaims().find((c) => c.taskKey === parsed.taskKey);
+                return {
+                    success: true,
+                    claimed: team.isClaimed(parsed.taskKey),
+                    claimedBy: existing?.claimedBy,
+                };
+            }
+            case 'list': {
+                const claims = team.listClaims();
+                return { success: true, claims };
+            }
+            default:
+                return { success: false, error: `Unknown action: ${parsed.action}` };
+        }
+    },
+};
+//# sourceMappingURL=team.js.map

package/dist/core/sub-agent/types.js

@@ -40,9 +40,9 @@ export const SubAgentRequestSchema = z.object({
         .describe('Optional repo-relative files the sub-agent should inspect first.'),
     recursionDepth: z.number().optional().default(0),
     session_target: z
-        .enum(['isolated', 'shared'])
+        .enum(['isolated', 'shared', 'fork'])
         .default('isolated')
-        .describe('Optional runtime strategy. Omit unless shared context is explicitly needed.'),
+        .describe('Optional runtime strategy. "fork" inherits parent conversation context with cache sharing. "shared" merges context snapshots. "isolated" (default) uses a clean environment.'),
     timeout_seconds: z
         .preprocess((value) => {
         if (typeof value !== 'string')
@@ -58,6 +58,15 @@ export const SubAgentRequestSchema = z.object({
         .enum(['diagnosis', 'patch', 'review'])
         .optional()
         .describe('Expected deliverable. Use patch for coder-style implementation proposals.'),
+    async: z
+        .boolean()
+        .default(false)
+        .optional()
+        .describe('If true, return a handle immediately and let the caller await the result.'),
+    teamId: z
+        .string()
+        .optional()
+        .describe('Join a coordination team. Sub-agents sharing a teamId can avoid duplicate work via claim/list.'),
     contextSnapshot: z
         .object({
         version: z.literal(SUB_AGENT_CONTEXT_SNAPSHOT_VERSION).optional().default(1),

package/dist/core/tools/budget.js

@@ -50,18 +50,14 @@ export class BudgetGuard {
         const currentRiskActive = this.activeCallsByRisk[params.riskLevel];
         const maxRiskAllowed = this.config.maxConcurrentByRisk[params.riskLevel];
         if (currentRiskActive >= maxRiskAllowed) {
-            throw {
-                code: 'BUDGET_CONCURRENCY',
-                message: `Too many concurrent ${params.riskLevel}-risk tool calls (limit: ${maxRiskAllowed})`,
-            };
+            throw Object.assign(new Error(`Too many concurrent ${params.riskLevel}-risk tool calls (limit: ${maxRiskAllowed})`), { code: 'BUDGET_CONCURRENCY' });
         }
         // 2. Rate Limit / Count Check per Phase
         const currentCount = this.callCounts.get(params.phase) || 0;
         if (currentCount >= this.config.maxCallsPerPhase) {
-            throw {
+            throw Object.assign(new Error(`Too many tool calls in phase ${params.phase}`), {
                 code: 'BUDGET_RATE_LIMIT',
-                message: `Too many tool calls in phase ${params.phase}`,
-            };
+            });
         }
         this.activeCallsByRisk[params.riskLevel]++;
         this.callCounts.set(params.phase, currentCount + 1);
@@ -71,10 +67,7 @@ export class BudgetGuard {
             // 4. Output Size Check (Preliminary)
             const size = this.estimateSize(result);
             if (size > params.maxOutputBytes) {
-                throw {
-                    code: 'OUTPUT_TOO_LARGE',
-                    message: `Output size ${size} bytes exceeds limit of ${params.maxOutputBytes}`,
-                };
+                throw Object.assign(new Error(`Output size ${size} bytes exceeds limit of ${params.maxOutputBytes}`), { code: 'OUTPUT_TOO_LARGE' });
             }
             return result;
         }

package/dist/core/tools/builtin/code-search/executor.js

@@ -1,6 +1,7 @@
 import { LIMITS } from '../../../config/limits.js';
 import { getLogger } from '../../../observability/logger.js';
 import { spawnCommand } from '../../../runtime/process-runner.js';
+import { isRecord } from '../../../utils/serialize.js';
 import { runWithFallback } from '../../capability/executor.js';
 import { psBackend } from './backends/powershell.js';
 import { rgBackend } from './backends/rg.js';
@@ -24,53 +25,55 @@ export async function codeSearchExecutor(input, ctx) {
         attemptId: ctx.attemptId,
         dryRun: ctx.dryRun,
         // Allow tests (and callers) to override platform; default to host platform.
-        platform: ctx.platform ?? process.platform,
-        runner: ctx.runner ?? {
-            execFile: async (file, args, opts) => {
-                const maxStdoutBytes = opts?.maxStdoutBytes ?? Number.POSITIVE_INFINITY;
-                let stdout = '';
-                let stderr = '';
-                let stdoutBytes = 0;
-                const result = await spawnCommand({
-                    command: file,
-                    args,
-                    cwd: opts?.cwd ?? ctx.repoRoot,
-                    timeoutMs: opts?.timeoutMs,
-                    signal: ctx.signal,
-                    env: { ...process.env, ...ctx.env, ...opts?.env },
-                    onStdoutChunk: (chunk) => {
-                        if (stdoutBytes >= maxStdoutBytes)
-                            return;
-                        const buffer = Buffer.from(chunk);
-                        const remaining = maxStdoutBytes - stdoutBytes;
-                        if (buffer.length <= remaining) {
-                            stdout += buffer.toString();
-                            stdoutBytes += buffer.length;
-                            return;
-                        }
-                        stdout += buffer.subarray(0, remaining).toString();
-                        stdoutBytes += remaining;
-                    },
-                    onStderrChunk: (chunk) => {
-                        stderr += Buffer.from(chunk).toString();
-                    },
-                });
-                if (result.error) {
+        platform: isRecord(ctx) && typeof ctx.platform === 'string' ? ctx.platform : process.platform,
+        runner: isRecord(ctx) && typeof ctx.runner === 'object' && ctx.runner !== null
+            ? ctx.runner
+            : {
+                execFile: async (file, args, opts) => {
+                    const maxStdoutBytes = opts?.maxStdoutBytes ?? Number.POSITIVE_INFINITY;
+                    let stdout = '';
+                    let stderr = '';
+                    let stdoutBytes = 0;
+                    const result = await spawnCommand({
+                        command: file,
+                        args,
+                        cwd: opts?.cwd ?? ctx.repoRoot,
+                        timeoutMs: opts?.timeoutMs,
+                        signal: ctx.signal,
+                        env: { ...process.env, ...ctx.env, ...opts?.env },
+                        onStdoutChunk: (chunk) => {
+                            if (stdoutBytes >= maxStdoutBytes)
+                                return;
+                            const buffer = Buffer.from(chunk);
+                            const remaining = maxStdoutBytes - stdoutBytes;
+                            if (buffer.length <= remaining) {
+                                stdout += buffer.toString();
+                                stdoutBytes += buffer.length;
+                                return;
+                            }
+                            stdout += buffer.subarray(0, remaining).toString();
+                            stdoutBytes += remaining;
+                        },
+                        onStderrChunk: (chunk) => {
+                            stderr += Buffer.from(chunk).toString();
+                        },
+                    });
+                    if (result.error) {
+                        return {
+                            stdout,
+                            stderr: stderr || result.error.message,
+                            exitCode: 1,
+                            timedOut: false,
+                        };
+                    }
                     return {
                         stdout,
-                        stderr: stderr || result.error.message,
-                        exitCode: 1,
-                        timedOut: false,
+                        stderr,
+                        exitCode: result.code ?? 1,
+                        timedOut: result.timedOut,
                     };
-                }
-                return {
-                    stdout,
-                    stderr,
-                    exitCode: result.code ?? 1,
-                    timedOut: result.timedOut,
-                };
+                },
             },
-        },
         limits: {
             timeoutMs: LIMITS.defaultToolTimeoutMs,
             maxOutputBytes: LIMITS.maxToolOutputBytes,

package/dist/core/tools/builtin/fs.js

@@ -7,6 +7,7 @@ import { AtomicFileWriter } from '../../adapters/fs/atomic-file-writer.js';
 import { mkdir, readFile, readdir, stat } from '../../adapters/fs/node-fs.js';
 import { Phase } from '../../types/runtime.js';
 import { normalizeRepoRelativePath } from '../../utils/path.js';
+import { isRecord } from '../../utils/serialize.js';
 import { pathPrefixResource } from '../parallel/resource-helpers.js';
 const FsListEntryType = z.enum(['file', 'dir', 'symlink', 'other']);
 const fsListInputSchema = z.preprocess((raw) => {
@@ -338,12 +339,13 @@ export const fsWriteFileSpec = {
         bytesWritten: z.number().int().nonnegative(),
     }),
     summarizeArgsForAuthorization: async (args) => {
-        const encoding = args?.encoding || 'utf-8';
-        const content = String(args?.content ?? '');
+        const a = isRecord(args) ? args : {};
+        const encoding = typeof a.encoding === 'string' ? a.encoding : 'utf-8';
+        const content = String(a.content ?? '');
         const bytes = Buffer.byteLength(content, 'utf8');
         const sha256 = createHash('sha256').update(content, 'utf8').digest('hex');
         return JSON.stringify({
-            file: args?.file,
+            file: typeof a.file === 'string' ? a.file : undefined,
             encoding,
             bytes,
             sha256,
@@ -390,7 +392,10 @@ export const fsCreateDirectorySpec = {
         ok: z.boolean(),
         path: z.string(),
     }),
-    summarizeArgsForAuthorization: async (args) => JSON.stringify({ path: args?.path, recursive: args?.recursive }),
+    summarizeArgsForAuthorization: async (args) => {
+        const a = isRecord(args) ? args : {};
+        return JSON.stringify({ path: a.path, recursive: a.recursive });
+    },
 };
 export async function executeFsCreateDirectory(input, ctx) {
     if (ctx.dryRun) {
@@ -427,7 +432,10 @@ export const fsDeleteFileSpec = {
         path: z.string(),
         deleted: z.boolean(),
     }),
-    summarizeArgsForAuthorization: async (args) => JSON.stringify({ file: args?.file, missingOk: args?.missingOk }),
+    summarizeArgsForAuthorization: async (args) => {
+        const a = isRecord(args) ? args : {};
+        return JSON.stringify({ file: a.file, missingOk: a.missingOk });
+    },
 };
 export async function executeFsDeleteFile(input, ctx) {
     if (ctx.dryRun) {
@@ -439,7 +447,7 @@ export async function executeFsDeleteFile(input, ctx) {
         await stat(absolutePath);
     }
     catch (e) {
-        const code = e && typeof e === 'object' && 'code' in e ? e.code : undefined;
+        const code = isRecord(e) && typeof e.code === 'string' ? e.code : undefined;
         if (code === 'ENOENT')
             exists = false;
         else