@helmiq/crew 0.1.0

package/dist/engine/engine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=engine.test.d.ts.map

package/dist/engine/engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.test.d.ts","sourceRoot":"","sources":["../../src/engine/engine.test.ts"],"names":[],"mappings":""}

package/dist/engine/engine.test.js

@@ -0,0 +1,334 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { filterTools } from './tool-filter.js';
+const mockModel = {
+    alias: 'claude-sonnet',
+    provider: 'anthropic',
+    concreteModel: 'claude-sonnet-4-20250514',
+    apiKeyEnv: 'ANTHROPIC_API_KEY',
+};
+const emptyContext = {
+    blocks: [],
+    totalTokens: 0,
+    budgetLimit: 100_000,
+    gaps: [],
+};
+function makePersona(overrides) {
+    return {
+        persona: {
+            name: 'test-persona',
+            identity: { role: 'Test Engineer' },
+            skills: ['feature-implementation'],
+            perception: { per_task: {} },
+            tasks: {},
+            tools: overrides?.tools ?? {
+                permitted: ['read-artifact', 'write-code', 'shell'],
+                denied: ['write-strategy-artifacts'],
+            },
+            cadence: {},
+            evaluation: { rubric: 'test.rubric.yaml' },
+        },
+    };
+}
+const pathDef = {
+    description: 'Tool for testing',
+    parameters: {
+        type: 'object',
+        properties: { path: { type: 'string' } },
+        required: ['path'],
+    },
+};
+const sampleTools = {
+    'read-artifact': pathDef,
+    'write-code': pathDef,
+    'write-strategy-artifacts': pathDef,
+    shell: pathDef,
+    'send-notifications': pathDef,
+};
+function toCrewToolSet(tools) {
+    const result = {};
+    for (const [name, def] of Object.entries(tools)) {
+        result[name] = { ...def, name, execute: vi.fn().mockResolvedValue({}) };
+    }
+    return result;
+}
+const sampleCrewTools = toCrewToolSet(sampleTools);
+function mockProvider(overrides) {
+    return {
+        generateText: vi.fn().mockResolvedValue({
+            text: 'Generated artifact content',
+            toolCalls: [],
+            tokensIn: 100,
+            tokensOut: 50,
+            ...overrides,
+        }),
+    };
+}
+describe('T-01-003b: tool permission enforcement', () => {
+    it('includes only permitted tools', () => {
+        const permissions = {
+            permitted: ['read-artifact', 'write-code', 'shell'],
+            denied: ['write-strategy-artifacts'],
+        };
+        const filtered = filterTools(sampleTools, permissions);
+        expect(Object.keys(filtered).sort()).toEqual(['read-artifact', 'shell', 'write-code'].sort());
+    });
+    it('excludes denied tools even if in permitted list', () => {
+        const permissions = {
+            permitted: ['read-artifact', 'write-code', 'write-strategy-artifacts', 'shell'],
+            denied: ['write-strategy-artifacts'],
+        };
+        const filtered = filterTools(sampleTools, permissions);
+        expect(Object.keys(filtered)).not.toContain('write-strategy-artifacts');
+    });
+    it('excludes tools not in the permitted list', () => {
+        const permissions = {
+            permitted: ['read-artifact'],
+            denied: [],
+        };
+        const filtered = filterTools(sampleTools, permissions);
+        expect(Object.keys(filtered)).toEqual(['read-artifact']);
+    });
+    it('applies sub-agent tool restriction as additional subset', () => {
+        const permissions = {
+            permitted: ['read-artifact', 'write-code', 'shell'],
+            denied: ['write-strategy-artifacts'],
+        };
+        const filtered = filterTools(sampleTools, permissions, ['write-code']);
+        expect(Object.keys(filtered)).toEqual(['write-code']);
+    });
+    it('returns empty set when no tools are permitted', () => {
+        const permissions = {
+            permitted: [],
+            denied: [],
+        };
+        const filtered = filterTools(sampleTools, permissions);
+        expect(Object.keys(filtered)).toHaveLength(0);
+    });
+    it('returns empty set when sub-agent restricts to empty', () => {
+        const permissions = {
+            permitted: ['read-artifact', 'write-code'],
+            denied: [],
+        };
+        const filtered = filterTools(sampleTools, permissions, ['nonexistent-tool']);
+        expect(Object.keys(filtered)).toHaveLength(0);
+    });
+});
+describe('T-01-003a: simple task execution', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('constructs prompt from persona identity and task context and calls provider', async () => {
+        const { executeSimpleTask } = await import('./simple.js');
+        const llmClient = await import('./llm-client.js');
+        const provider = mockProvider();
+        const callLlmSpy = vi.spyOn(llmClient, 'callLlm').mockResolvedValue({
+            text: 'Generated artifact content',
+            toolCalls: [],
+            tokensIn: 100,
+            tokensOut: 50,
+            durationMs: 1500,
+            model: 'claude-sonnet-4-20250514',
+        });
+        const persona = makePersona();
+        const task = {
+            mode: 'simple',
+            trigger: ['manual'],
+            skill: 'feature-implementation',
+            produces: 'review-report',
+        };
+        const skills = { 'feature-implementation': 'Write a review report' };
+        const context = {
+            blocks: [
+                {
+                    source: { type: 'requirements', path: 'work/CREW-01/requirements.md' },
+                    content: 'Requirement content here',
+                    tokens: 10,
+                    priority: 'required',
+                },
+            ],
+            totalTokens: 10,
+            budgetLimit: 100_000,
+            gaps: [],
+        };
+        const result = await executeSimpleTask(persona, task, context, mockModel, provider, sampleCrewTools, skills);
+        expect(result.content).toBe('Generated artifact content');
+        expect(result.tokensIn).toBe(100);
+        expect(result.tokensOut).toBe(50);
+        expect(result.model).toBe('claude-sonnet-4-20250514');
+        expect(callLlmSpy).toHaveBeenCalledOnce();
+        const callArgs = callLlmSpy.mock.calls[0][0];
+        expect(callArgs.system).toContain('Test Engineer');
+        expect(callArgs.messages[0].content).toContain('review-report');
+        expect(callArgs.messages[0].content).toContain('Requirement content here');
+        expect(callArgs.messages[0].content).toContain('Write a review report');
+    });
+    it('filters tools before passing to provider', async () => {
+        const { executeSimpleTask } = await import('./simple.js');
+        const llmClient = await import('./llm-client.js');
+        const provider = mockProvider();
+        const callLlmSpy = vi.spyOn(llmClient, 'callLlm').mockResolvedValue({
+            text: 'result',
+            toolCalls: [],
+            tokensIn: 10,
+            tokensOut: 10,
+            durationMs: 100,
+            model: 'claude-sonnet-4-20250514',
+        });
+        const persona = makePersona({
+            tools: {
+                permitted: ['read-artifact'],
+                denied: ['write-strategy-artifacts'],
+            },
+        });
+        const task = {
+            mode: 'simple',
+            trigger: ['manual'],
+            skill: 'feature-implementation',
+            produces: 'output',
+        };
+        await executeSimpleTask(persona, task, emptyContext, mockModel, provider, sampleCrewTools);
+        const toolsArg = callLlmSpy.mock.calls[0][0].tools;
+        expect(Object.keys(toolsArg)).toEqual(['read-artifact']);
+        expect(toolsArg['write-strategy-artifacts']).toBeUndefined();
+        expect(toolsArg['write-code']).toBeUndefined();
+    });
+    it('includes context gaps in the user prompt', async () => {
+        const { executeSimpleTask } = await import('./simple.js');
+        const llmClient = await import('./llm-client.js');
+        const provider = mockProvider();
+        const callLlmSpy = vi.spyOn(llmClient, 'callLlm').mockResolvedValue({
+            text: 'result',
+            toolCalls: [],
+            tokensIn: 10,
+            tokensOut: 10,
+            durationMs: 100,
+            model: 'claude-sonnet-4-20250514',
+        });
+        const contextWithGaps = {
+            blocks: [],
+            totalTokens: 0,
+            budgetLimit: 100_000,
+            gaps: ['design (scope: {"epic":"CREW-01"})'],
+        };
+        const persona = makePersona();
+        const task = {
+            mode: 'simple',
+            trigger: ['manual'],
+            skill: 'feature-implementation',
+            produces: 'output',
+        };
+        await executeSimpleTask(persona, task, contextWithGaps, mockModel, provider, {});
+        const userContent = callLlmSpy.mock.calls[0][0].messages[0].content;
+        expect(userContent).toContain('not found');
+        expect(userContent).toContain('design');
+        expect(userContent).toContain('Do not invent');
+    });
+    it('produces content after tool dispatch completes', async () => {
+        const { executeSimpleTask } = await import('./simple.js');
+        const llmClient = await import('./llm-client.js');
+        let callIdx = 0;
+        vi.spyOn(llmClient, 'callLlm').mockImplementation(async () => {
+            callIdx++;
+            if (callIdx === 1) {
+                return {
+                    text: '',
+                    toolCalls: [
+                        { toolCallId: 'tc-1', toolName: 'read-file', input: { path: 'src/index.ts' } },
+                    ],
+                    tokensIn: 50,
+                    tokensOut: 30,
+                    durationMs: 400,
+                    model: 'claude-sonnet-4-20250514',
+                };
+            }
+            return {
+                text: 'Done after tool use',
+                toolCalls: [],
+                tokensIn: 40,
+                tokensOut: 20,
+                durationMs: 400,
+                model: 'claude-sonnet-4-20250514',
+            };
+        });
+        const persona = makePersona();
+        const task = {
+            mode: 'simple',
+            trigger: ['manual'],
+            skill: 'feature-implementation',
+            produces: 'code-changes',
+        };
+        const provider = mockProvider();
+        const result = await executeSimpleTask(persona, task, emptyContext, mockModel, provider, sampleCrewTools);
+        expect(result.content).toBe('Done after tool use');
+        expect(callIdx).toBe(2);
+    });
+});
+describe('T-01-003c: error handling', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('wraps provider errors as LlmCallError', async () => {
+        const { callLlm } = await import('./llm-client.js');
+        const failingProvider = {
+            generateText: vi.fn().mockRejectedValue(new Error('API rate limited')),
+        };
+        await expect(callLlm({
+            provider: failingProvider,
+            model: mockModel,
+            system: 'test',
+            messages: [{ role: 'user', content: 'test' }],
+        })).rejects.toMatchObject({ code: 'LLM_CALL' });
+    });
+    it('LlmCallError includes model name in message', async () => {
+        const { callLlm } = await import('./llm-client.js');
+        const failingProvider = {
+            generateText: vi.fn().mockRejectedValue(new Error('timeout')),
+        };
+        try {
+            await callLlm({
+                provider: failingProvider,
+                model: mockModel,
+                system: 'test',
+                messages: [{ role: 'user', content: 'test' }],
+            });
+            expect.fail('Expected callLlm to throw');
+        }
+        catch (err) {
+            const error = err;
+            expect(error.code).toBe('LLM_CALL');
+            expect(error.message).toContain('claude-sonnet-4-20250514');
+            expect(error.message).toContain('timeout');
+        }
+    });
+    it('measures duration on failure', async () => {
+        const { callLlm } = await import('./llm-client.js');
+        const failingProvider = {
+            generateText: vi.fn().mockRejectedValue(new Error('fail')),
+        };
+        try {
+            await callLlm({
+                provider: failingProvider,
+                model: mockModel,
+                system: 'test',
+                messages: [{ role: 'user', content: 'test' }],
+            });
+            expect.fail('Expected callLlm to throw');
+        }
+        catch (err) {
+            const error = err;
+            expect(error.message).toMatch(/failed after \d+ms/);
+        }
+    });
+    it('passes maxRetries through to provider', async () => {
+        const { callLlm } = await import('./llm-client.js');
+        const provider = mockProvider();
+        await callLlm({
+            provider,
+            model: mockModel,
+            system: 'test',
+            messages: [{ role: 'user', content: 'test' }],
+            maxRetries: 7,
+        });
+        expect(provider.generateText).toHaveBeenCalledWith(expect.objectContaining({ maxRetries: 7 }));
+    });
+});

package/dist/engine/index.d.ts

@@ -0,0 +1,10 @@
+export { executeSimpleTask } from './simple.js';
+export type { EngineResult } from './simple.js';
+export { executeCompositeTask } from './composite.js';
+export type { CompositeResult, CheckpointRecord, SubAgentRecord } from './composite.js';
+export { callLlm } from './llm-client.js';
+export type { LlmCallOptions, LlmCallResult } from './llm-client.js';
+export { filterTools } from './tool-filter.js';
+export { executeWithToolDispatch, toSchemaOnlyToolSet, filterCrewTools } from './tool-dispatch.js';
+export type { ToolDispatchOptions, ToolDispatchResult } from './tool-dispatch.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACxF,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACnG,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/engine/index.js

@@ -0,0 +1,5 @@
+export { executeSimpleTask } from './simple.js';
+export { executeCompositeTask } from './composite.js';
+export { callLlm } from './llm-client.js';
+export { filterTools } from './tool-filter.js';
+export { executeWithToolDispatch, toSchemaOnlyToolSet, filterCrewTools } from './tool-dispatch.js';

package/dist/engine/llm-client.d.ts

@@ -0,0 +1,27 @@
+import type { LlmProvider, LlmMessage, ToolCallRecord, ToolSet } from '../types/index.js';
+import type { ResolvedModel } from '../config/model-resolver.js';
+export interface LlmCallOptions {
+    provider: LlmProvider;
+    model: ResolvedModel;
+    system: string;
+    messages: LlmMessage[];
+    tools?: ToolSet;
+    maxRetries?: number;
+}
+export interface LlmCallResult {
+    text: string;
+    toolCalls: ToolCallRecord[];
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    model: string;
+}
+/**
+ * Execute an LLM call through a Crew-defined LlmProvider.
+ *
+ * The provider is created by a provider package (e.g., @helmiq/anthropic-sdk)
+ * and injected by the caller. The runtime never imports SDK packages
+ * directly. See ADR-0009.
+ */
+export declare function callLlm(options: LlmCallOptions): Promise<LlmCallResult>;
+//# sourceMappingURL=llm-client.d.ts.map

package/dist/engine/llm-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-client.d.ts","sourceRoot":"","sources":["../../src/engine/llm-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGjE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAaD;;;;;;GAMG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAkC7E"}

package/dist/engine/llm-client.js

@@ -0,0 +1,46 @@
+import { LlmCallError } from '../common/errors.js';
+const DEFAULT_MAX_RETRIES = 3;
+function getMaxRetries() {
+    const env = process.env['CREW_LLM_MAX_RETRIES'];
+    if (env) {
+        const parsed = parseInt(env, 10);
+        if (!Number.isNaN(parsed) && parsed >= 0)
+            return parsed;
+    }
+    return DEFAULT_MAX_RETRIES;
+}
+/**
+ * Execute an LLM call through a Crew-defined LlmProvider.
+ *
+ * The provider is created by a provider package (e.g., @helmiq/anthropic-sdk)
+ * and injected by the caller. The runtime never imports SDK packages
+ * directly. See ADR-0009.
+ */
+export async function callLlm(options) {
+    const { provider, model, system, messages, tools } = options;
+    const maxRetries = options.maxRetries ?? getMaxRetries();
+    const startMs = Date.now();
+    try {
+        const result = await provider.generateText({
+            model: model.concreteModel,
+            system,
+            messages,
+            tools,
+            maxRetries,
+        });
+        const durationMs = Date.now() - startMs;
+        return {
+            text: result.text,
+            toolCalls: result.toolCalls,
+            tokensIn: result.tokensIn,
+            tokensOut: result.tokensOut,
+            durationMs,
+            model: model.concreteModel,
+        };
+    }
+    catch (err) {
+        const durationMs = Date.now() - startMs;
+        const message = err instanceof Error ? err.message : 'Unknown LLM call error';
+        throw new LlmCallError(`LLM call failed after ${durationMs}ms (model: ${model.concreteModel}): ${message}`, { cause: err });
+    }
+}

package/dist/engine/simple.d.ts

@@ -0,0 +1,21 @@
+import type { PersonaSpec, SimpleTask, LlmProvider, ToolCallRecord } from '../types/index.js';
+import type { CrewToolSet, ToolExecutionContext } from '../types/tool-runtime.js';
+import type { ResolvedModel } from '../config/model-resolver.js';
+import type { AssembledContext } from '../context/assembler.js';
+import type { ResolvedSkills } from '../config/resolver.js';
+export interface EngineResult {
+    content: string;
+    toolCalls: ToolCallRecord[];
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    model: string;
+}
+/**
+ * Execute a simple (single LLM call with tool dispatch) persona task.
+ *
+ * Per ADR-0014, uses executeWithToolDispatch for consistency with
+ * composite tasks. Sub-agents with no tools get an empty CrewToolSet.
+ */
+export declare function executeSimpleTask(persona: PersonaSpec, task: SimpleTask, context: AssembledContext, model: ResolvedModel, provider: LlmProvider, availableTools: CrewToolSet, skills?: ResolvedSkills, toolContext?: ToolExecutionContext): Promise<EngineResult>;
+//# sourceMappingURL=simple.d.ts.map

package/dist/engine/simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../src/engine/simple.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9F,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAElF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAuCD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,WAAW,EACrB,cAAc,EAAE,WAAW,EAC3B,MAAM,GAAE,cAAmB,EAC3B,WAAW,CAAC,EAAE,oBAAoB,GACjC,OAAO,CAAC,YAAY,CAAC,CA4BvB"}

package/dist/engine/simple.js

@@ -0,0 +1,59 @@
+import { createNullToolContext } from '../types/tool-runtime.js';
+import { filterCrewTools } from './tool-dispatch.js';
+import { executeWithToolDispatch } from './tool-dispatch.js';
+function buildSystemPrompt(persona) {
+    const { identity } = persona.persona;
+    return `You are a ${identity.role}.\n\nFollow your prompt instructions precisely. Produce the requested artifact.`;
+}
+function buildUserPrompt(task, context, skills) {
+    const parts = [];
+    parts.push(`Task: ${task.produces}`);
+    const skillContent = skills[task.skill];
+    if (skillContent) {
+        parts.push(`\nInstructions:\n${skillContent}`);
+    }
+    if (context.blocks.length > 0) {
+        parts.push('\n--- Context ---');
+        for (const block of context.blocks) {
+            const label = block.source.type + (block.source.path ? ` (${block.source.path})` : '');
+            parts.push(`\n[${label}]\n${block.content}`);
+        }
+        parts.push('\n--- End Context ---');
+    }
+    if (context.gaps.length > 0) {
+        parts.push(`\nNote: The following context artifacts were not found: ${context.gaps.join(', ')}. Do not invent their content.`);
+    }
+    return parts.join('\n');
+}
+/**
+ * Execute a simple (single LLM call with tool dispatch) persona task.
+ *
+ * Per ADR-0014, uses executeWithToolDispatch for consistency with
+ * composite tasks. Sub-agents with no tools get an empty CrewToolSet.
+ */
+export async function executeSimpleTask(persona, task, context, model, provider, availableTools, skills = {}, toolContext) {
+    const permittedSet = new Set(persona.persona.tools.permitted);
+    const deniedSet = new Set(persona.persona.tools.denied);
+    const filteredTools = filterCrewTools(availableTools, permittedSet, deniedSet, task.tools);
+    const system = buildSystemPrompt(persona);
+    const userPrompt = buildUserPrompt(task, context, skills);
+    const dispatchResult = await executeWithToolDispatch({
+        callOptions: {
+            provider,
+            model,
+            system,
+            messages: [{ role: 'user', content: userPrompt }],
+        },
+        tools: filteredTools,
+        context: toolContext ?? createNullToolContext(persona.persona.name, task.produces),
+        maxRounds: 8,
+    });
+    return {
+        content: dispatchResult.text,
+        toolCalls: [],
+        tokensIn: dispatchResult.totalTokensIn,
+        tokensOut: dispatchResult.totalTokensOut,
+        durationMs: dispatchResult.totalDurationMs,
+        model: dispatchResult.model,
+    };
+}

package/dist/engine/tool-dispatch.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Runtime-managed tool-call dispatch loop per ADR-0010.
+ *
+ * Calls the provider with schema-only tools, intercepts ToolCallRecord
+ * results, dispatches each to the corresponding CrewTool execute function,
+ * appends tool-result messages, and repeats until the LLM produces a
+ * final text response or the max round limit is reached.
+ */
+import type { ToolSet } from '../types/index.js';
+import type { CrewToolSet, ToolExecutionContext, ToolExecutionRecord } from '../types/tool-runtime.js';
+import type { LlmCallOptions } from './llm-client.js';
+export interface ToolDispatchOptions {
+    callOptions: Omit<LlmCallOptions, 'tools'>;
+    tools: CrewToolSet;
+    context: ToolExecutionContext;
+    maxRounds?: number;
+}
+export interface ToolDispatchResult {
+    text: string;
+    toolExecutions: ToolExecutionRecord[];
+    totalTokensIn: number;
+    totalTokensOut: number;
+    totalDurationMs: number;
+    rounds: number;
+    model: string;
+}
+export declare function toSchemaOnlyToolSet(tools: CrewToolSet): ToolSet;
+/**
+ * Filter available CrewTools by persona permissions and sub-agent restrictions.
+ *
+ * Supports tool group expansion: persona specs may use category names
+ * (e.g. "write-code", "git") which are expanded to individual tool names
+ * before matching against the registry.
+ */
+export declare function filterCrewTools(available: CrewToolSet, permitted: Set<string>, denied: Set<string>, subAgentTools?: string[]): CrewToolSet;
+export declare function executeWithToolDispatch(options: ToolDispatchOptions): Promise<ToolDispatchResult>;
+//# sourceMappingURL=tool-dispatch.d.ts.map

package/dist/engine/tool-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-dispatch.d.ts","sourceRoot":"","sources":["../../src/engine/tool-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAA8B,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;IAC3C,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,mBAAmB,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAID,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAS/D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EACnB,aAAa,CAAC,EAAE,MAAM,EAAE,GACvB,WAAW,CAab;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CA+D7B"}