salmon-loop 0.3.1 → 0.4.1

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

@@ -3,11 +3,13 @@ import { text } from '../../../locales/index.js';
 import { createFileSystemAdapter } from '../../adapters/fs/index.js';
 import * as fs from '../../adapters/fs/node-fs.js';
 import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { createTaskEventBus } from '../../interaction/events/bus.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { getLogger } from '../../observability/logger.js';
 import { FileStateResolver } from '../../strata/layers/file-state-resolver.js';
 import { RuntimeEnvironment } from '../../strata/runtime/environment.js';
 import { ErrorType } from '../../types/index.js';
+import { errorMessage } from '../../utils/error.js';
 import { ArtifactStore } from '../artifacts/store.js';
 import { cloneSubAgentContextSnapshot } from '../context-snapshot.js';
 import { isReadOnlySubAgentContext, resolveSubAgentDryRun } from '../dispatch-policy.js';
@@ -31,45 +33,162 @@ export class SubAgentManager {
             createRuntimeEnvironment: deps?.createRuntimeEnvironment ??
                 ((options, emit) => new RuntimeEnvironment(options, emit)),
             artifactStore: deps?.artifactStore ?? ArtifactStore,
+            eventBus: deps?.eventBus ?? createTaskEventBus(),
+            llmFactory: deps?.llmFactory,
+            onSubAgentComplete: deps?.onSubAgentComplete,
         };
     }
     /**
-     * Spawns a new sub-agent and monitors its execution.
+     * Spawns a new sub-agent. When request.async is true, returns a handle immediately;
+     * otherwise blocks until the sub-agent completes.
      */
     async execute(request) {
-        const normalizedRequest = request.session_target === 'shared'
-            ? (() => {
-                const consistency = validateSharedPrefixConsistency({
-                    requestSnapshot: request.contextSnapshot,
-                    runtimeSnapshot: this.ctx.contextSnapshot,
-                });
-                if (consistency.compatible)
-                    return request;
-                recordAuditEvent('sub_agent.shared.prefix_consistency_failed', {
-                    metric: 'shared_fallback_rate',
-                    fallbackMode: 'isolated',
-                    reason: consistency.reason,
-                    expected: consistency.expected,
-                    actual: consistency.actual,
-                }, {
-                    source: 'smallfry',
-                    severity: 'medium',
-                    scope: 'session',
-                    phase: this.ctx.phase,
-                });
-                return {
-                    ...request,
-                    session_target: 'isolated',
-                    contextSnapshot: undefined,
-                };
-            })()
-            : request;
+        const normalizedRequest = this.normalizeRequest(request);
         const profile = this.deps.registry.get(normalizedRequest.agent_ref);
         if (!profile) {
             return this.fail(normalizedRequest.agent_ref, text.smallfry.errors.profileNotFound(normalizedRequest.agent_ref), 'LOOP_FAILED');
         }
         const agentId = `smallfry-${randomBytes(4).toString('hex')}`;
-        const currentDepth = normalizedRequest.recursionDepth || 0;
+        if (normalizedRequest.async) {
+            return this.executeAsync(normalizedRequest, profile, agentId);
+        }
+        return this.executeSync(normalizedRequest, profile, agentId);
+    }
+    /**
+     * Waits for an async sub-agent to complete and returns its result.
+     * @param handle - The sub-agent handle returned by executeAsync
+     * @param timeoutMs - Maximum time to wait in milliseconds. Defaults to 300_000 (5 minutes).
+     */
+    async awaitResult(handle, timeoutMs) {
+        // Check if already completed
+        const entry = this.activeAgents.get(handle.agentId);
+        if (entry?.result) {
+            return entry.result;
+        }
+        // Check historical events
+        const historical = this.deps.eventBus.list(handle.taskId, { limit: 10 });
+        const terminalEvent = historical.find((e) => e.type === 'subagent.completed' || e.type === 'subagent.failed');
+        if (terminalEvent) {
+            return terminalEvent.state === 'completed'
+                ? terminalEvent.result
+                : this.fail(handle.agentId, terminalEvent.reason ?? 'Sub-agent failed', 'LOOP_FAILED');
+        }
+        const effectiveTimeout = timeoutMs ?? 300_000;
+        // Subscribe and wait for terminal event
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                unsub();
+                // Request stop on the sub-agent so it can clean up
+                this.controller.requestStop(handle.agentId);
+                reject(new Error(`Timed out waiting for sub-agent ${handle.agentId} after ${effectiveTimeout}ms`));
+            }, effectiveTimeout);
+            const unsub = this.deps.eventBus.subscribe((event) => {
+                if (event.taskId !== handle.taskId)
+                    return;
+                if (event.type === 'subagent.completed' || event.type === 'subagent.failed') {
+                    clearTimeout(timeout);
+                    unsub();
+                    if (event.type === 'subagent.completed') {
+                        resolve(event.result);
+                    }
+                    else {
+                        resolve(this.fail(handle.agentId, event.reason ?? 'Sub-agent failed', 'LOOP_FAILED'));
+                    }
+                }
+            });
+        });
+    }
+    normalizeRequest(request) {
+        // Fork mode: no prefix consistency validation needed (it's a clone, not a shared session)
+        if (request.session_target === 'fork')
+            return request;
+        if (request.session_target !== 'shared')
+            return request;
+        const consistency = validateSharedPrefixConsistency({
+            requestSnapshot: request.contextSnapshot,
+            runtimeSnapshot: this.ctx.contextSnapshot,
+        });
+        if (consistency.compatible)
+            return request;
+        recordAuditEvent('sub_agent.shared.prefix_consistency_failed', {
+            metric: 'shared_fallback_rate',
+            fallbackMode: 'isolated',
+            reason: consistency.reason,
+            expected: consistency.expected,
+            actual: consistency.actual,
+        }, {
+            source: 'smallfry',
+            severity: 'medium',
+            scope: 'session',
+            phase: this.ctx.phase,
+        });
+        return {
+            ...request,
+            session_target: 'isolated',
+            contextSnapshot: undefined,
+        };
+    }
+    /**
+     * Async dispatch: fire-and-forget, publish events, return handle.
+     */
+    executeAsync(request, profile, agentId) {
+        const taskId = agentId;
+        this.activeAgents.set(agentId, { profile, status: 'hiring' });
+        this.controller.registerAgent(agentId, profile, 'hiring');
+        this.deps.eventBus.publish({
+            type: 'subagent.accepted',
+            taskId,
+            state: 'accepted',
+        });
+        // Fire-and-forget: executeCore runs in the background
+        this.executeCore(request, profile, agentId)
+            .then((result) => {
+            const entry = this.activeAgents.get(agentId);
+            if (entry)
+                entry.result = result;
+            this.controller.setResult(agentId, result);
+            this.controller.updateStatus(agentId, 'terminated', result.summary);
+            this.deps.eventBus.publish({
+                type: result.success ? 'subagent.completed' : 'subagent.failed',
+                taskId,
+                state: result.success ? 'completed' : 'failed',
+            });
+            // Notify completion listener (for background auto-notify)
+            this.deps.onSubAgentComplete?.(agentId, result);
+        })
+            .catch((error) => {
+            const failResult = this.fail(profile.id, errorMessage(error), 'LOOP_CRASH');
+            const entry = this.activeAgents.get(agentId);
+            if (entry)
+                entry.result = failResult;
+            this.controller.setResult(agentId, failResult);
+            this.controller.updateStatus(agentId, 'terminated', failResult.summary);
+            this.deps.eventBus.publish({
+                type: 'subagent.failed',
+                taskId,
+                state: 'failed',
+            });
+        })
+            .finally(() => {
+            const entry = this.activeAgents.get(agentId);
+            if (!entry?.result) {
+                this.activeAgents.delete(agentId);
+            }
+        });
+        return { agentId, status: 'working', taskId };
+    }
+    /**
+     * Synchronous dispatch: blocks until the sub-agent completes.
+     */
+    async executeSync(request, profile, agentId) {
+        return this.executeCore(request, profile, agentId);
+    }
+    /**
+     * Core execution logic shared by async and sync paths.
+     * Retries up to profile.maxAttempts on LOOP_FAILED (not LOOP_CRASH).
+     */
+    async executeCore(request, profile, agentId) {
+        const currentDepth = request.recursionDepth || 0;
         const MAX_RECURSION_DEPTH = 2;
         if (currentDepth >= MAX_RECURSION_DEPTH) {
             const msg = text.smallfry.errors.recursionLimitExceeded(currentDepth, MAX_RECURSION_DEPTH);
@@ -79,97 +198,128 @@ export class SubAgentManager {
         this.activeAgents.set(agentId, { profile, status: 'hiring' });
         this.controller.registerAgent(agentId, profile, 'hiring');
         getLogger().debug(`[SubAgentManager] ${text.smallfry.status.spawning} (ID: ${agentId}, Role: ${profile.role})`);
-        const llm = this.ctx.llm;
-        if (!llm) {
+        // Resolve LLM: per-profile model override or inherit parent
+        const parentLlm = this.ctx.llm;
+        if (!parentLlm) {
             const msg = text.smallfry.errors.dispatchMissingRuntimeLlm;
             getLogger().error(`[SubAgentManager] ${msg}`);
             return this.fail(profile.id, msg, 'LOOP_CRASH');
         }
-        try {
-            this.updateStatus(agentId, 'working');
-            if (this.controller.isStopRequested(agentId)) {
-                throw new Error('Stop requested before launching Smallfry');
-            }
-            const effectiveDryRun = resolveSubAgentDryRun({
-                parentDryRun: this.ctx.dryRun,
-                flowMode: this.ctx.flowMode,
-                phase: this.ctx.phase,
-            });
-            const runtimeEnv = await this.setupIsolatedEnvironment(normalizedRequest, llm, agentId, effectiveDryRun);
+        const llm = this.resolveLlm(profile, parentLlm);
+        if (!llm) {
+            const msg = `Failed to resolve LLM for model "${profile.model}"`;
+            getLogger().error(`[SubAgentManager] ${msg}`);
+            return this.fail(profile.id, msg, 'LOOP_CRASH');
+        }
+        const maxAttempts = profile.maxAttempts ?? 1;
+        let lastResult;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             try {
-                const workspace = runtimeEnv.workspace;
-                const activePath = workspace.workPath;
-                const git = new GitAdapter(activePath);
-                const resolver = new FileStateResolver(git, activePath);
-                const flowMode = 'patch';
-                const fsAdapter = createFileSystemAdapter(flowMode);
-                // 2. Construct InitCtx for the smallfry
-                const initCtx = this.applyContextSnapshot(normalizedRequest.contextSnapshot, {
-                    workspace: {
-                        workPath: activePath,
-                        baseRepoPath: workspace.baseRepoPath,
-                        strategy: workspace.strategy,
-                    },
-                    options: {
-                        instruction: normalizedRequest.task,
-                        repoPath: activePath,
-                        dryRun: effectiveDryRun,
-                        contextFiles: normalizedRequest.contextFiles || [],
-                        llm,
-                        recursionDepth: currentDepth + 1, // Increment depth for child
-                        allowedToolNames: this.filterAllowedTools(profile.allowedTools, this.ctx.phase),
-                        timeoutMs: normalizedRequest.timeout_seconds
-                            ? normalizedRequest.timeout_seconds * 1000
-                            : profile.timeoutMs,
-                    },
-                    mode: flowMode,
-                    fs: fsAdapter,
-                    emit: (event) => {
-                        // Bridge status to parent/UI
-                        if (event.type === 'phase.start') {
-                            this.updateStatus(agentId, 'working');
-                        }
-                        if (event.type === 'log') {
-                            getLogger().debug(`[Smallfry:${agentId}] ${event.level}: ${event.message}`);
-                        }
-                        else {
-                            getLogger().debug(`[Smallfry:${agentId}] ${event.type}`);
-                        }
-                    },
-                    fileStateResolver: resolver,
-                    shadowInitialRef: runtimeEnv?.initialSnapshotHash || 'HEAD',
+                this.updateStatus(agentId, 'working');
+                if (this.controller.isStopRequested(agentId)) {
+                    throw new Error('Stop requested before launching Smallfry');
+                }
+                const effectiveDryRun = resolveSubAgentDryRun({
+                    parentDryRun: this.ctx.dryRun,
+                    flowMode: this.ctx.flowMode,
+                    phase: this.ctx.phase,
                 });
-                // 3. Launch the "Little Fry"
-                const subLoop = new SmallfryLoop(profile);
-                const result = await subLoop.execute(initCtx);
-                return await this.persistArtifacts(agentId, result);
+                const runtimeEnv = await this.setupIsolatedEnvironment(request, llm, agentId, effectiveDryRun);
+                try {
+                    const workspace = runtimeEnv.workspace;
+                    if (!workspace) {
+                        throw new Error('Runtime environment setup succeeded but workspace was not initialized');
+                    }
+                    const activePath = workspace.workPath;
+                    const git = new GitAdapter(activePath);
+                    const resolver = new FileStateResolver(git, activePath);
+                    const flowMode = 'patch';
+                    const fsAdapter = createFileSystemAdapter(flowMode);
+                    const initCtx = this.applyContextSnapshot(request.contextSnapshot, {
+                        workspace: {
+                            workPath: activePath,
+                            baseRepoPath: workspace.baseRepoPath,
+                            strategy: workspace.strategy,
+                        },
+                        options: {
+                            instruction: request.task,
+                            repoPath: activePath,
+                            dryRun: effectiveDryRun,
+                            contextFiles: request.contextFiles || [],
+                            llm,
+                            recursionDepth: currentDepth + 1,
+                            allowedToolNames: this.resolveAllowedTools(profile, request.teamId),
+                            timeoutMs: request.timeout_seconds
+                                ? request.timeout_seconds * 1000
+                                : profile.timeoutMs,
+                            subAgentSystemPrompt: profile.systemPrompt,
+                            agentId,
+                        },
+                        lastError,
+                        mode: flowMode,
+                        fs: fsAdapter,
+                        emit: (event) => {
+                            if (event.type === 'phase.start') {
+                                this.updateStatus(agentId, 'working');
+                            }
+                            if (event.type === 'log') {
+                                getLogger().debug(`[Smallfry:${agentId}] ${event.level}: ${event.message}`);
+                            }
+                            else {
+                                getLogger().debug(`[Smallfry:${agentId}] ${event.type}`);
+                            }
+                        },
+                        fileStateResolver: resolver,
+                        shadowInitialRef: runtimeEnv?.initialSnapshotHash || 'HEAD',
+                    });
+                    const subLoop = new SmallfryLoop(profile);
+                    const result = await subLoop.execute(initCtx);
+                    lastResult = result;
+                    // Success or non-retryable failure — return immediately
+                    if (result.success || result.reasonCode === 'LOOP_CRASH' || attempt >= maxAttempts) {
+                        return await this.persistArtifacts(agentId, {
+                            ...result,
+                            attempts: attempt,
+                        });
+                    }
+                    // Retryable failure — log and continue
+                    lastError = result.reason || result.summary;
+                    getLogger().warn(`[SubAgentManager] Smallfry ${agentId} attempt ${attempt}/${maxAttempts} failed (${result.reasonCode}), retrying...`);
+                }
+                finally {
+                    await runtimeEnv.teardown();
+                }
             }
-            finally {
-                await runtimeEnv.teardown();
+            catch (error) {
+                this.controller.appendLog(agentId, `Execution failed: ${errorMessage(error)}`);
+                getLogger().error(`[SubAgentManager] Smallfry ${agentId} crashed: ${errorMessage(error)}`);
+                // Crashes are not retryable
+                return {
+                    agent_ref: profile.id,
+                    success: false,
+                    summary: text.smallfry.errors.missionFailedWithReason(errorMessage(error)),
+                    tokenUsage: 0,
+                    reason: errorMessage(error),
+                    reasonCode: 'LOOP_CRASH',
+                    attempts: attempt,
+                    logs: [],
+                    errorType: ErrorType.UNKNOWN,
+                };
             }
         }
-        catch (error) {
-            this.controller.appendLog(agentId, `Execution failed: ${(error instanceof Error ? error.message : undefined) ?? error}`);
-            getLogger().error(`[SubAgentManager] Smallfry ${agentId} crashed: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                agent_ref: profile.id,
-                success: false,
-                summary: text.smallfry.errors.missionFailedWithReason(error instanceof Error ? error.message : String(error)),
-                tokenUsage: 0,
-                reason: error instanceof Error ? error.message : String(error),
-                reasonCode: 'LOOP_CRASH',
-                attempts: 1,
-                logs: [],
-                errorType: ErrorType.UNKNOWN,
-            };
-        }
-        finally {
-            this.activeAgents.delete(agentId);
-        }
+        // Should not reach here, but safety fallback
+        return lastResult ?? this.fail(profile.id, text.smallfry.errors.missionFailed, 'LOOP_FAILED');
     }
-    // Backward compatibility for internal calls
+    // Backward compatibility for internal calls (always synchronous)
     async spawn(request) {
-        return this.execute(request);
+        const normalizedRequest = this.normalizeRequest(request);
+        const profile = this.deps.registry.get(normalizedRequest.agent_ref);
+        if (!profile) {
+            return this.fail(normalizedRequest.agent_ref, text.smallfry.errors.profileNotFound(normalizedRequest.agent_ref), 'LOOP_FAILED');
+        }
+        const agentId = `smallfry-${randomBytes(4).toString('hex')}`;
+        return this.executeSync(normalizedRequest, profile, agentId);
     }
     applyContextSnapshot(snapshot, initCtx) {
         const normalized = cloneSubAgentContextSnapshot(snapshot);
@@ -209,6 +359,54 @@ export class SubAgentManager {
             errorType: ErrorType.UNKNOWN,
         };
     }
+    resolveAllowedTools(profile, teamId) {
+        const base = this.filterAllowedTools(profile.allowedTools, this.ctx.phase, profile.toolInheritance);
+        // Apply disallowedTools (denylist) — subtract from resolved tools
+        let resolved = base;
+        if (resolved !== undefined && profile.disallowedTools && profile.disallowedTools.length > 0) {
+            const denied = new Set(profile.disallowedTools);
+            resolved = resolved.filter((name) => !denied.has(name));
+        }
+        if (!teamId)
+            return resolved;
+        // When a teamId is present, add agent_team to the allowed tools
+        if (resolved === undefined)
+            return undefined; // Inherited all tools — agent_team already available
+        return [...new Set([...resolved, 'agent_team'])];
+    }
+    /**
+     * Resolve the LLM for a sub-agent based on profile.model.
+     * 'inherit' or undefined → use parent LLM.
+     * Other values → use llmFactory to create a model-specific LLM.
+     */
+    resolveLlm(profile, parentLlm) {
+        const model = profile.model;
+        // Try llmFactory first for all models (including 'inherit').
+        // This allows test harnesses to provide isolated LLMs for sub-agents.
+        // In production, factories typically return undefined for 'inherit',
+        // so the fallback to parentLlm is preserved.
+        if (this.deps.llmFactory) {
+            const modelLlm = this.deps.llmFactory(model ?? 'inherit');
+            if (modelLlm) {
+                getLogger().debug(`[SubAgentManager] Using llmFactory LLM for profile "${profile.id}" (model="${model ?? 'inherit'}")`);
+                return modelLlm;
+            }
+        }
+        if (!model || model === 'inherit') {
+            return parentLlm;
+        }
+        if (!this.deps.llmFactory) {
+            getLogger().warn(`[SubAgentManager] Profile "${profile.id}" requests model "${model}" but no llmFactory configured. Falling back to parent LLM.`);
+            return parentLlm;
+        }
+        const modelLlm = this.deps.llmFactory(model);
+        if (!modelLlm) {
+            getLogger().warn(`[SubAgentManager] llmFactory returned no LLM for model "${model}". Falling back to parent LLM.`);
+            return parentLlm;
+        }
+        getLogger().debug(`[SubAgentManager] Using model "${model}" for profile "${profile.id}"`);
+        return modelLlm;
+    }
     async setupIsolatedEnvironment(request, llm, agentId, effectiveDryRun) {
         if (isReadOnlySubAgentContext({
             flowMode: this.ctx.flowMode,
@@ -251,7 +449,7 @@ export class SubAgentManager {
                 await env.teardown();
             }
             catch (teardownError) {
-                getLogger().warn(`[SubAgentManager] Failed to teardown isolated environment after setup error: ${teardownError instanceof Error ? teardownError.message : String(teardownError)}`);
+                getLogger().warn(`[SubAgentManager] Failed to teardown isolated environment after setup error: ${errorMessage(teardownError)}`);
             }
             throw error;
         }
@@ -275,11 +473,20 @@ export class SubAgentManager {
         return {
             ...rest,
             auditPath: auditArtifact?.handle ?? rest.auditPath,
-            auditArtifact: auditArtifact ?? undefined,
+            auditArtifact: auditArtifact,
             patchArtifact: saved,
         };
     }
-    filterAllowedTools(allowed, phase) {
+    filterAllowedTools(allowed, phase, toolInheritance) {
+        const readOnlyPhase = isReadOnlySubAgentContext({
+            flowMode: this.ctx.flowMode,
+            phase,
+        });
+        // When toolInheritance is 'safe' or 'all' in non-read-only phase,
+        // return undefined to skip allowlist filtering (inherits parent toolstack)
+        if (!readOnlyPhase && toolInheritance && toolInheritance !== 'none') {
+            return undefined;
+        }
         const safeReadOnlyTools = new Set([
             'agent_dispatch',
             'code.search',
@@ -290,10 +497,6 @@ export class SubAgentManager {
             'artifact.read',
         ]);
         const readOnlyPlanTools = new Set(['plan.init', 'plan.read', 'plan.update']);
-        const readOnlyPhase = isReadOnlySubAgentContext({
-            flowMode: this.ctx.flowMode,
-            phase,
-        });
         if (!readOnlyPhase) {
             return allowed;
         }

package/dist/core/sub-agent/registry-defaults.js

@@ -7,9 +7,12 @@ const DEFAULT_SUB_AGENT_PROFILES = [
         allowedTools: ['code.search', 'fs.read', 'git.status', 'git.cat', 'code.ast'],
         readOnly: true,
         stratagem: 'investigator',
+        toolInheritance: 'safe',
         maxTokens: 50000,
         maxAttempts: 3,
         timeoutMs: 60_000,
+        maxTurns: 20,
+        model: 'haiku',
     },
     {
         id: 'surgeon',
@@ -19,9 +22,12 @@ const DEFAULT_SUB_AGENT_PROFILES = [
         allowedTools: ['code.search', 'fs.read', 'test.run', 'code.ast'],
         readOnly: false,
         stratagem: 'surgeon',
+        toolInheritance: 'none',
         maxTokens: 100000,
         maxAttempts: 5,
         timeoutMs: 180_000,
+        maxTurns: 50,
+        model: 'inherit',
     },
     {
         id: 'reviewer',
@@ -31,9 +37,12 @@ const DEFAULT_SUB_AGENT_PROFILES = [
         allowedTools: ['code.search', 'fs.read', 'code.ast'],
         readOnly: true,
         stratagem: 'investigator',
+        toolInheritance: 'safe',
         maxTokens: 30000,
         maxAttempts: 2,
         timeoutMs: 60_000,
+        maxTurns: 15,
+        model: 'haiku',
     },
     {
         id: 'cleaner',
@@ -43,9 +52,12 @@ const DEFAULT_SUB_AGENT_PROFILES = [
         allowedTools: ['fs.read', 'test.run', 'code.search'],
         readOnly: false,
         stratagem: 'surgeon',
+        toolInheritance: 'none',
         maxTokens: 50000,
         maxAttempts: 3,
         timeoutMs: 120_000,
+        maxTurns: 30,
+        model: 'inherit',
     },
 ];
 export function registerDefaultSubAgentProfiles(registry) {

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

@@ -3,12 +3,20 @@ export class SubAgentRegistry {
     register(profile) {
         this.profiles.set(profile.id, profile);
     }
+    registerMany(profiles) {
+        for (const profile of profiles) {
+            this.profiles.set(profile.id, profile);
+        }
+    }
     get(id) {
         return this.profiles.get(id);
     }
     getAll() {
         return Array.from(this.profiles.values());
     }
+    has(id) {
+        return this.profiles.has(id);
+    }
     clear() {
         this.profiles.clear();
     }

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

@@ -0,0 +1,98 @@
+/**
+ * SubAgentTeam — lightweight task board for parallel sub-agent coordination.
+ *
+ * Multiple sub-agents can claim tasks/files to avoid duplicate work.
+ * Claims are advisory (not enforced) — the team board is a shared
+ * declaration board, not a mutex.
+ */
+export class SubAgentTeam {
+    board = new Map();
+    /**
+     * Attempt to claim a task key. Returns true if the claim succeeded
+     * (key was unclaimed), false if already claimed by another agent.
+     * Re-claiming by the same agent is idempotent (returns true).
+     */
+    claim(taskKey, agentId) {
+        const existing = this.board.get(taskKey);
+        if (existing && existing.claimedBy !== agentId) {
+            return false;
+        }
+        this.board.set(taskKey, { claimedBy: agentId, claimedAt: Date.now() });
+        return true;
+    }
+    /**
+     * Release a claim (e.g., on completion or failure).
+     */
+    release(taskKey, agentId) {
+        const existing = this.board.get(taskKey);
+        if (!existing || existing.claimedBy !== agentId) {
+            return false;
+        }
+        this.board.delete(taskKey);
+        return true;
+    }
+    /**
+     * Check if a task key is already claimed by someone else.
+     */
+    isClaimed(taskKey, excludeAgent) {
+        const existing = this.board.get(taskKey);
+        if (!existing)
+            return false;
+        return existing.claimedBy !== excludeAgent;
+    }
+    /**
+     * List all current claims.
+     */
+    listClaims() {
+        return Array.from(this.board.entries()).map(([taskKey, entry]) => ({
+            taskKey,
+            claimedBy: entry.claimedBy,
+            claimedAt: entry.claimedAt,
+        }));
+    }
+    /**
+     * Get all claims for a specific agent.
+     */
+    getAgentClaims(agentId) {
+        const claims = [];
+        for (const [taskKey, entry] of this.board) {
+            if (entry.claimedBy === agentId) {
+                claims.push({ taskKey, claimedBy: entry.claimedBy, claimedAt: entry.claimedAt });
+            }
+        }
+        return claims;
+    }
+    /**
+     * Clear all claims for a specific agent (e.g., on termination).
+     */
+    releaseAll(agentId) {
+        let released = 0;
+        for (const [key, entry] of this.board) {
+            if (entry.claimedBy === agentId) {
+                this.board.delete(key);
+                released++;
+            }
+        }
+        return released;
+    }
+}
+// Global team registry — teams live for the duration of the parent session
+const teams = new Map();
+/** Get an existing team or create a new one. Teams are keyed by teamId. */
+export function getOrCreateTeam(teamId) {
+    let team = teams.get(teamId);
+    if (!team) {
+        team = new SubAgentTeam();
+        teams.set(teamId, team);
+    }
+    return team;
+}
+/** Remove a team from the global registry. Returns false if not found. */
+export function removeTeam(teamId) {
+    return teams.delete(teamId);
+}
+/** Remove all teams from the global registry. */
+export function clearAllTeams() {
+    teams.clear();
+}
+//# sourceMappingURL=team.js.map