@planu/cli 3.9.9 → 3.9.11

package/dist/engine/agent-generator/builders.js

@@ -0,0 +1,141 @@
+// Planu — Agent Generator: Prompt Builders and Inference Helpers
+// Generates system prompts and infers agent configuration from role/capabilities.
+export function buildSystemPrompt(agentName, role, capabilities, knowledge) {
+    const lines = [];
+    lines.push(`You are ${agentName}, a specialized ${role} agent.`);
+    lines.push('');
+    lines.push('## Your Capabilities');
+    for (const cap of capabilities) {
+        lines.push(`- ${cap}`);
+    }
+    lines.push('');
+    lines.push('## Project Context');
+    lines.push(`- Language: ${knowledge.language}`);
+    if (knowledge.framework) {
+        lines.push(`- Framework: ${knowledge.framework}`);
+    }
+    lines.push(`- Architecture: ${knowledge.architecture.primary}`);
+    lines.push(`- Database: ${knowledge.database}`);
+    lines.push('');
+    lines.push('## Rules');
+    lines.push('- Follow the project architecture patterns.');
+    lines.push('- Write clean, well-tested code.');
+    lines.push('- Handle errors explicitly.');
+    lines.push('- Report progress and blockers clearly.');
+    if (knowledge.qualityProfile.principles.length > 0) {
+        lines.push('');
+        lines.push('## Quality Principles');
+        for (const principle of knowledge.qualityProfile.principles) {
+            lines.push(`- ${principle}`);
+        }
+    }
+    // SPEC-022: Scope restrictions — sub-agents must NOT handle commit/push/tracking
+    lines.push('');
+    lines.push('## Scope Restrictions');
+    lines.push('- NEVER git commit or git push changes — that is handled by the parent skill');
+    lines.push('- NEVER update PROGRESS.md or spec tracking files — delegate to parent skill');
+    lines.push('- NEVER run the full CI/CD pipeline — parent skill manages pipeline execution');
+    lines.push('- Focus exclusively on your assigned subtask and report results clearly');
+    return lines.join('\n');
+}
+export function buildCoordinatorPrompt(knowledge) {
+    return [
+        'You are the coordinator agent for the SDD workflow.',
+        '',
+        '## Your Role',
+        'You orchestrate the development workflow:',
+        '1. Receive feature requests and break them into specs.',
+        '2. Assign analysis tasks to the analyst agent.',
+        '3. Route implementation tasks to the implementor agent.',
+        '4. Request reviews from the reviewer agent.',
+        '5. Track progress and resolve conflicts.',
+        '',
+        '## Project Context',
+        `- Language: ${knowledge.language}`,
+        `- Framework: ${knowledge.framework ?? 'none'}`,
+        `- Architecture: ${knowledge.architecture.primary}`,
+        `- Spec location: ${knowledge.specLocation}`,
+        '',
+        '## Workflow',
+        '1. Analyze -> 2. Spec -> 3. Filter -> 4. Implement -> 5. Validate -> 6. Complete',
+        '',
+        '## Rules',
+        '- Always create a spec before implementation.',
+        '- Validate implementation against spec criteria.',
+        '- Record actuals when completing specs.',
+        '- Resolve agent conflicts before proceeding.',
+    ].join('\n');
+}
+export function inferModel(role, capabilities) {
+    // Use Opus for complex reasoning tasks, Sonnet for simpler ones
+    const complexRoles = ['orchestrator', 'architect', 'code-analyst', 'security-auditor'];
+    const complexCapabilities = ['architecture-review', 'security-audit', 'complex-refactoring'];
+    if (complexRoles.includes(role)) {
+        return 'claude-sonnet-4-20250514';
+    }
+    if (capabilities.some((c) => complexCapabilities.includes(c))) {
+        return 'claude-sonnet-4-20250514';
+    }
+    return 'claude-sonnet-4-20250514';
+}
+export function inferTools(role, _capabilities, knowledge) {
+    const tools = [];
+    // Base tools for all agents
+    tools.push('read_file', 'write_file', 'list_directory');
+    // Role-specific tools
+    const roleTools = {
+        orchestrator: ['sdd_init_project', 'sdd_create_spec', 'sdd_update_status', 'sdd_orchestrate'],
+        'code-analyst': [
+            'sdd_audit_code',
+            'sdd_detect_drift',
+            'sdd_reverse_engineer',
+            'sdd_generate_checklist',
+        ],
+        'code-implementor': ['sdd_validate_spec', 'sdd_check_versions', 'bash'],
+        'code-reviewer': ['sdd_audit_code', 'sdd_generate_checklist', 'sdd_detect_drift'],
+        documentation: ['sdd_generate_docs', 'sdd_summarize_spec'],
+        testing: ['sdd_generate_test_plan', 'sdd_validate_spec', 'bash'],
+    };
+    if (roleTools[role]) {
+        tools.push(...(roleTools[role] ?? []));
+    }
+    // MCP tools if available
+    for (const mcp of knowledge.availableMcps) {
+        tools.push(...mcp.tools);
+    }
+    return [...new Set(tools)];
+}
+export function inferMaxTurns(role) {
+    const turnsByRole = {
+        orchestrator: 20,
+        'code-analyst': 10,
+        'code-implementor': 30,
+        'code-reviewer': 15,
+        documentation: 10,
+        testing: 15,
+    };
+    return turnsByRole[role] ?? 10;
+}
+export function inferHandoffConditions(role) {
+    const conditions = {
+        orchestrator: [
+            'Handoff to analyst when code analysis is needed.',
+            'Handoff to implementor when spec is approved and ready for coding.',
+            'Handoff to reviewer when implementation is complete.',
+        ],
+        'code-analyst': [
+            'Handoff back to coordinator with analysis results.',
+            'Handoff to reviewer if critical issues found.',
+        ],
+        'code-implementor': [
+            'Handoff to reviewer when implementation is complete.',
+            'Handoff to coordinator if blocked by dependencies.',
+        ],
+        'code-reviewer': [
+            'Handoff back to implementor if changes needed.',
+            'Handoff to coordinator when review is approved.',
+        ],
+    };
+    return conditions[role] ?? [];
+}
+//# sourceMappingURL=builders.js.map

package/dist/engine/agent-generator/framework-files-helpers.d.ts

@@ -0,0 +1,10 @@
+import type { SubAgentFramework, FrameworkConfig, SkillFile } from '../../types/index.js';
+/** Convert a string to camelCase. */
+export declare function camelCase(str: string): string;
+/** Convert a string to PascalCase. */
+export declare function pascalCase(str: string): string;
+/** Escape backticks and template literal expressions for embedding in template literals. */
+export declare function escapeTemplateLiteral(str: string): string;
+/** Build human-readable install instructions for a framework agent. */
+export declare function buildInstallInstructions(framework: SubAgentFramework, config: FrameworkConfig, files: SkillFile[]): string;
+//# sourceMappingURL=framework-files-helpers.d.ts.map

package/dist/engine/agent-generator/framework-files-helpers.js

@@ -0,0 +1,54 @@
+// Planu — Agent Generator: Framework File Helpers
+// Shared utility functions and install instruction builder.
+/** Convert a string to camelCase. */
+export function camelCase(str) {
+    return str
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^(.)/, (_, c) => c.toLowerCase());
+}
+/** Convert a string to PascalCase. */
+export function pascalCase(str) {
+    return str
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+/** Escape backticks and template literal expressions for embedding in template literals. */
+export function escapeTemplateLiteral(str) {
+    return str.replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+/** Build human-readable install instructions for a framework agent. */
+export function buildInstallInstructions(framework, config, files) {
+    const lines = [];
+    lines.push(`## ${config.name} Agent Setup`);
+    lines.push('');
+    lines.push(`Documentation: ${config.docsUrl}`);
+    lines.push(`Supported languages: ${config.languages.join(', ')}`);
+    lines.push('');
+    // Install commands
+    const installCommands = {
+        'claude-agent-sdk': 'npm install @anthropic-ai/sdk',
+        crewai: 'pip install crewai',
+        langgraph: 'pip install langgraph langchain-anthropic',
+        autogen: 'pip install autogen-agentchat',
+        mastra: 'npm install @mastra/core',
+        'vercel-ai-sdk': 'npm install ai @ai-sdk/anthropic',
+    };
+    if (installCommands[framework]) {
+        lines.push(`Install: \`${installCommands[framework]}\``);
+        lines.push('');
+    }
+    lines.push('Generated files:');
+    for (const file of files) {
+        lines.push(`- ${file.path}`);
+    }
+    if (config.supportsHandoffs) {
+        lines.push('');
+        lines.push('This framework supports agent handoffs. Configure handoff conditions as needed.');
+    }
+    if (config.supportsMcp) {
+        lines.push('');
+        lines.push('This framework supports MCP tools. Connect SDD MCP server for full workflow integration.');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=framework-files-helpers.js.map

package/dist/engine/agent-generator/framework-files.d.ts

@@ -0,0 +1,5 @@
+import type { SubAgentFramework, SubAgentDefinition, SkillFile, FrameworkConfig, ProjectKnowledge } from '../../types/index.js';
+import { buildInstallInstructions } from './framework-files-helpers.js';
+export { buildInstallInstructions };
+export declare function generateFrameworkFiles(framework: SubAgentFramework, agent: SubAgentDefinition, knowledge: ProjectKnowledge, _config: FrameworkConfig): SkillFile[];
+//# sourceMappingURL=framework-files.d.ts.map

package/dist/engine/agent-generator/framework-files.js

@@ -0,0 +1,259 @@
+// Planu — Agent Generator: Framework-Specific File Generators
+// Generates code files for each supported multi-agent framework.
+import { camelCase, pascalCase, escapeTemplateLiteral, buildInstallInstructions, } from './framework-files-helpers.js';
+export { buildInstallInstructions };
+// === Framework File Generators ===
+function generateClaudeAgentSdkFiles(agent, _knowledge) {
+    const slug = agent.name.toLowerCase().replace(/\s+/g, '-');
+    const content = `// ${agent.name} — Generated by Planu SDD MCP Server
+// Framework: Anthropic Agent SDK
+// Docs: https://docs.anthropic.com/en/docs/agents
+
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic();
+
+export const ${camelCase(agent.name)}Agent = {
+  name: "${agent.name}",
+  role: "${agent.role}",
+  model: "${agent.model}",
+  maxTurns: ${agent.maxTurns ?? 10},
+
+  systemPrompt: \`${escapeTemplateLiteral(agent.systemPrompt)}\`,
+
+  tools: ${JSON.stringify(agent.tools, null, 4)},
+
+  ${agent.handoffConditions ? `handoffConditions: ${JSON.stringify(agent.handoffConditions, null, 4)},` : ''}
+
+  async run(input: string) {
+    const response = await client.messages.create({
+      model: this.model,
+      max_tokens: 4096,
+      system: this.systemPrompt,
+      messages: [{ role: "user", content: input }],
+    });
+    return response;
+  },
+};
+`;
+    return [
+        {
+            path: `agents/${slug}.ts`,
+            content,
+            format: 'markdown', // TypeScript content, markdown format for SkillFile
+        },
+    ];
+}
+function generateCrewAiFiles(agent, knowledge) {
+    const slug = agent.name.toLowerCase().replace(/\s+/g, '_');
+    const content = `# ${agent.name} — Generated by Planu SDD MCP Server
+# Framework: CrewAI
+# Docs: https://docs.crewai.com
+
+from crewai import Agent, Task
+
+${slug}_agent = Agent(
+    role="${agent.role}",
+    goal="${agent.role} for ${knowledge.language}/${knowledge.framework ?? 'native'} project",
+    backstory="""${agent.systemPrompt.replace(/"/g, '\\"').substring(0, 500)}""",
+    verbose=True,
+    allow_delegation=${agent.handoffConditions ? 'True' : 'False'},
+    tools=[${agent.tools.map((t) => `"${t}"`).join(', ')}],
+    max_iter=${agent.maxTurns ?? 10},
+)
+
+# Example task
+${slug}_task = Task(
+    description="Execute the assigned ${agent.role} task.",
+    expected_output="Structured result of the ${agent.role} analysis.",
+    agent=${slug}_agent,
+)
+`;
+    return [
+        {
+            path: `agents/${slug}_agent.py`,
+            content,
+            format: 'markdown',
+        },
+    ];
+}
+function generateLangGraphFiles(agent, _knowledge) {
+    const slug = agent.name.toLowerCase().replace(/\s+/g, '_');
+    const content = `# ${agent.name} — Generated by Planu SDD MCP Server
+# Framework: LangGraph
+# Docs: https://langchain-ai.github.io/langgraph
+
+from langgraph.graph import StateGraph, END
+from langchain_anthropic import ChatAnthropic
+from typing import TypedDict, Annotated
+
+class ${pascalCase(agent.name)}State(TypedDict):
+    messages: list
+    context: dict
+    result: str | None
+
+llm = ChatAnthropic(model="${agent.model}")
+
+def ${slug}_node(state: ${pascalCase(agent.name)}State) -> ${pascalCase(agent.name)}State:
+    """${agent.role} node."""
+    system_prompt = """${agent.systemPrompt.replace(/"/g, '\\"').substring(0, 500)}"""
+
+    response = llm.invoke([
+        {"role": "system", "content": system_prompt},
+        *state["messages"],
+    ])
+
+    return {
+        **state,
+        "result": response.content,
+        "messages": [*state["messages"], {"role": "assistant", "content": response.content}],
+    }
+
+# Build the graph
+graph = StateGraph(${pascalCase(agent.name)}State)
+graph.add_node("${slug}", ${slug}_node)
+graph.set_entry_point("${slug}")
+graph.add_edge("${slug}", END)
+
+${slug}_graph = graph.compile()
+`;
+    return [
+        {
+            path: `agents/${slug}_graph.py`,
+            content,
+            format: 'markdown',
+        },
+    ];
+}
+function generateAutoGenFiles(agent, _knowledge) {
+    const slug = agent.name.toLowerCase().replace(/\s+/g, '_');
+    const content = `# ${agent.name} — Generated by Planu SDD MCP Server
+# Framework: AutoGen (Microsoft)
+# Docs: https://microsoft.github.io/autogen
+
+from autogen import AssistantAgent, UserProxyAgent
+
+${slug}_agent = AssistantAgent(
+    name="${agent.name}",
+    system_message="""${agent.systemPrompt.replace(/"/g, '\\"').substring(0, 500)}""",
+    llm_config={
+        "model": "${agent.model}",
+        "temperature": 0,
+    },
+    max_consecutive_auto_reply=${agent.maxTurns ?? 10},
+)
+
+# User proxy for human-in-the-loop
+user_proxy = UserProxyAgent(
+    name="user",
+    human_input_mode="TERMINATE",
+    max_consecutive_auto_reply=0,
+)
+
+# Example usage:
+# user_proxy.initiate_chat(${slug}_agent, message="Analyze the codebase")
+`;
+    return [
+        {
+            path: `agents/${slug}_autogen.py`,
+            content,
+            format: 'markdown',
+        },
+    ];
+}
+function generateMastraFiles(agent, _knowledge) {
+    const slug = agent.name.toLowerCase().replace(/\s+/g, '-');
+    const content = `// ${agent.name} — Generated by Planu SDD MCP Server
+// Framework: Mastra
+// Docs: https://mastra.ai/docs
+
+import { Agent } from "@mastra/core";
+
+export const ${camelCase(agent.name)}Agent = new Agent({
+  name: "${agent.name}",
+  instructions: \`${escapeTemplateLiteral(agent.systemPrompt)}\`,
+  model: {
+    provider: "ANTHROPIC",
+    name: "${agent.model}",
+  },
+  tools: {
+    ${agent.tools.map((t) => `// ${t}: imported from your tools registry`).join('\n    ')}
+  },
+});
+`;
+    return [
+        {
+            path: `agents/${slug}.ts`,
+            content,
+            format: 'markdown',
+        },
+    ];
+}
+function generateVercelAiSdkFiles(agent, _knowledge) {
+    const slug = agent.name.toLowerCase().replace(/\s+/g, '-');
+    const content = `// ${agent.name} — Generated by Planu SDD MCP Server
+// Framework: Vercel AI SDK
+// Docs: https://sdk.vercel.ai/docs
+
+import { generateText } from "ai";
+import { anthropic } from "@ai-sdk/anthropic";
+
+export async function run${pascalCase(agent.name)}(input: string) {
+  const result = await generateText({
+    model: anthropic("${agent.model}"),
+    system: \`${escapeTemplateLiteral(agent.systemPrompt)}\`,
+    prompt: input,
+    maxSteps: ${agent.maxTurns ?? 10},
+  });
+
+  return result.text;
+}
+`;
+    return [
+        {
+            path: `agents/${slug}.ts`,
+            content,
+            format: 'markdown',
+        },
+    ];
+}
+function generateGenericFiles(agent, _knowledge) {
+    const content = JSON.stringify({
+        name: agent.name,
+        role: agent.role,
+        model: agent.model,
+        systemPrompt: agent.systemPrompt,
+        tools: agent.tools,
+        maxTurns: agent.maxTurns,
+        handoffConditions: agent.handoffConditions,
+    }, null, 2);
+    return [
+        {
+            path: `agents/${agent.name.toLowerCase().replace(/\s+/g, '-')}.json`,
+            content,
+            format: 'json',
+        },
+    ];
+}
+// === Public Entry Point ===
+export function generateFrameworkFiles(framework, agent, knowledge, _config) {
+    switch (framework) {
+        case 'claude-agent-sdk':
+            return generateClaudeAgentSdkFiles(agent, knowledge);
+        case 'crewai':
+            return generateCrewAiFiles(agent, knowledge);
+        case 'langgraph':
+            return generateLangGraphFiles(agent, knowledge);
+        case 'autogen':
+            return generateAutoGenFiles(agent, knowledge);
+        case 'mastra':
+            return generateMastraFiles(agent, knowledge);
+        case 'vercel-ai-sdk':
+            return generateVercelAiSdkFiles(agent, knowledge);
+        case 'custom':
+            return generateGenericFiles(agent, knowledge);
+        default:
+            return generateGenericFiles(agent, knowledge);
+    }
+}
+//# sourceMappingURL=framework-files.js.map

package/dist/engine/agent-generator.d.ts

@@ -0,0 +1,18 @@
+import type { SubAgentFramework, GenerateSubAgentResult, ProjectKnowledge, FrameworkConfig } from '../types/index.js';
+import { buildSystemPrompt, buildCoordinatorPrompt, inferModel, inferTools, inferMaxTurns, inferHandoffConditions } from './agent-generator/builders.js';
+import { generateFrameworkFiles, buildInstallInstructions } from './agent-generator/framework-files.js';
+export { buildSystemPrompt, buildCoordinatorPrompt, inferModel, inferTools, inferMaxTurns, inferHandoffConditions, generateFrameworkFiles, buildInstallInstructions, };
+/**
+ * Generate a sub-agent definition for a given multi-agent framework.
+ */
+export declare function generateSubAgent(framework: SubAgentFramework, agentName: string, role: string, capabilities: string[], knowledge: ProjectKnowledge, tools?: string[], systemPrompt?: string): Promise<GenerateSubAgentResult>;
+/**
+ * Generate a complete multi-agent system definition for a project.
+ * Creates a coordinator agent plus specialized sub-agents.
+ */
+export declare function generateAgentSystem(framework: SubAgentFramework, knowledge: ProjectKnowledge): Promise<GenerateSubAgentResult[]>;
+/**
+ * Get framework configuration details.
+ */
+export declare function getFrameworkConfig(framework: SubAgentFramework): Promise<FrameworkConfig>;
+//# sourceMappingURL=agent-generator.d.ts.map

package/dist/engine/agent-generator.js

@@ -0,0 +1,82 @@
+// @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
+// Planu — Agent Generator Engine
+// Generates sub-agent definitions for various multi-agent frameworks.
+// Orchestrator: delegates to agent-generator/ sub-modules.
+import { readFile } from 'node:fs/promises';
+import { buildSystemPrompt, buildCoordinatorPrompt, inferModel, inferTools, inferMaxTurns, inferHandoffConditions, } from './agent-generator/builders.js';
+import { generateFrameworkFiles, buildInstallInstructions, } from './agent-generator/framework-files.js';
+// Re-export sub-module functions so existing callers via this module still work.
+export { buildSystemPrompt, buildCoordinatorPrompt, inferModel, inferTools, inferMaxTurns, inferHandoffConditions, generateFrameworkFiles, buildInstallInstructions, };
+// === Framework Config ===
+let frameworksCache = null;
+async function loadFrameworks() {
+    if (frameworksCache) {
+        return frameworksCache;
+    }
+    try {
+        const configPath = new URL('../config/agent-platforms.json', import.meta.url);
+        const content = await readFile(configPath, 'utf-8');
+        frameworksCache = JSON.parse(content);
+        return frameworksCache;
+    }
+    catch {
+        /* v8 ignore next -- defensive catch for missing config file */
+        return { subAgentFrameworks: {} };
+    }
+}
+// === Public API ===
+/**
+ * Generate a sub-agent definition for a given multi-agent framework.
+ */
+export async function generateSubAgent(framework, agentName, role, capabilities, knowledge, tools = [], systemPrompt) {
+    const config = await getFrameworkConfig(framework);
+    const resolvedPrompt = systemPrompt ?? buildSystemPrompt(agentName, role, capabilities, knowledge);
+    const resolvedTools = tools.length > 0 ? tools : inferTools(role, capabilities, knowledge);
+    const agentDefinition = {
+        name: agentName,
+        role,
+        model: inferModel(role, capabilities),
+        systemPrompt: resolvedPrompt,
+        tools: resolvedTools,
+        maxTurns: inferMaxTurns(role),
+        // SPEC-022: Only generate handoff conditions for frameworks that support them natively
+        handoffConditions: config.supportsHandoffs ? inferHandoffConditions(role) : undefined,
+    };
+    const files = generateFrameworkFiles(framework, agentDefinition, knowledge, config);
+    return {
+        framework,
+        files,
+        agentDefinition,
+        installInstructions: buildInstallInstructions(framework, config, files),
+    };
+}
+/**
+ * Generate a complete multi-agent system definition for a project.
+ * Creates a coordinator agent plus specialized sub-agents.
+ */
+export async function generateAgentSystem(framework, knowledge) {
+    const agents = [];
+    // Coordinator agent
+    agents.push(await generateSubAgent(framework, 'coordinator', 'orchestrator', ['task-routing', 'spec-management', 'workflow-control'], knowledge, ['sdd_init_project', 'sdd_create_spec', 'sdd_update_status', 'sdd_orchestrate'], buildCoordinatorPrompt(knowledge)));
+    // Analyst agent
+    agents.push(await generateSubAgent(framework, 'analyst', 'code-analyst', ['code-analysis', 'architecture-review', 'dependency-scanning'], knowledge, ['sdd_audit_code', 'sdd_detect_drift', 'sdd_reverse_engineer']));
+    // Implementor agent
+    agents.push(await generateSubAgent(framework, 'implementor', 'code-implementor', ['code-generation', 'file-editing', 'refactoring'], knowledge, ['sdd_validate_spec', 'sdd_check_versions']));
+    // Reviewer agent
+    agents.push(await generateSubAgent(framework, 'reviewer', 'code-reviewer', ['code-review', 'quality-check', 'security-audit'], knowledge, ['sdd_audit_code', 'sdd_generate_checklist', 'sdd_detect_drift']));
+    return agents;
+}
+/**
+ * Get framework configuration details.
+ */
+export async function getFrameworkConfig(framework) {
+    const platforms = await loadFrameworks();
+    return (platforms.subAgentFrameworks[framework] ?? {
+        name: framework,
+        languages: ['typescript'],
+        docsUrl: '',
+        supportsHandoffs: false,
+        supportsMcp: false,
+    });
+}
+//# sourceMappingURL=agent-generator.js.map

package/dist/engine/agent-handoff-store.d.ts

@@ -0,0 +1,34 @@
+import type { AgentHandoffEntry, AgentTeamHandoff, AgentHandoffStatus } from '../types/index.js';
+export type { AgentHandoffEntry, AgentTeamHandoff, AgentHandoffStatus };
+/**
+ * SPEC-639: Initialize handoff.json for a spec team.
+ * Creates the directory and empty handoff file if it does not exist.
+ */
+export declare function initTeamHandoff(projectPath: string, specId: string, agentIds: string[]): Promise<AgentTeamHandoff>;
+/**
+ * SPEC-639: Read the current handoff.json for a spec team.
+ * Returns null if not initialized.
+ */
+export declare function readTeamHandoff(projectPath: string, specId: string): Promise<AgentTeamHandoff | null>;
+/**
+ * SPEC-639: Write an agent's completion entry to handoff.json.
+ * Called by a worker when it finishes (or fails).
+ */
+export declare function writeAgentHandoffEntry(projectPath: string, specId: string, entry: Omit<AgentHandoffEntry, 'updatedAt'>): Promise<AgentTeamHandoff>;
+/**
+ * SPEC-639: Return the list of agents that have failed and need re-queuing.
+ */
+export declare function getFailedAgents(handoff: AgentTeamHandoff): AgentHandoffEntry[];
+/**
+ * SPEC-639: Return true when all agents are done (none pending or failed).
+ * QA may start when this returns true.
+ */
+export declare function allWorkersDone(handoff: AgentTeamHandoff): boolean;
+/**
+ * SPEC-639: Collect all files touched by workers for QA consumption.
+ */
+export declare function collectAllWorkerFiles(handoff: AgentTeamHandoff): {
+    filesCreated: string[];
+    filesModified: string[];
+};
+//# sourceMappingURL=agent-handoff-store.d.ts.map