opencode-swarm 6.27.0 → 7.0.0-beta.1

package/dist/telemetry/src/events.d.ts

@@ -0,0 +1,308 @@
+import { z } from 'zod';
+export declare const SwarmEventBaseSchema: z.ZodObject<{
+    type: z.ZodString;
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type SwarmEventBase = z.infer<typeof SwarmEventBaseSchema>;
+export declare const SessionMetadataEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"session_metadata">;
+    swarmDir: z.ZodString;
+    pid: z.ZodNumber;
+    platform: z.ZodString;
+    nodeVersion: z.ZodString;
+}, z.core.$strip>;
+export type SessionMetadataEvent = z.infer<typeof SessionMetadataEventSchema>;
+export declare const DelegationStartEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"delegation_start">;
+    taskId: z.ZodNullable<z.ZodString>;
+    targetAgent: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DelegationStartEvent = z.infer<typeof DelegationStartEventSchema>;
+export declare const DelegationEndEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"delegation_end">;
+    taskId: z.ZodNullable<z.ZodString>;
+    targetAgent: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    verdict: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DelegationEndEvent = z.infer<typeof DelegationEndEventSchema>;
+export declare const AgentStatusEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"agent_status">;
+    agentName: z.ZodString;
+    status: z.ZodEnum<{
+        complete: "complete";
+        idle: "idle";
+        active: "active";
+    }>;
+    worktreeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentStatusEvent = z.infer<typeof AgentStatusEventSchema>;
+export declare const TokenUsageEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"token_usage">;
+    agentName: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TokenUsageEvent = z.infer<typeof TokenUsageEventSchema>;
+export declare const ToolInvocationEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"tool_invocation">;
+    toolName: z.ZodString;
+    taskId: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    success: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ToolInvocationEvent = z.infer<typeof ToolInvocationEventSchema>;
+export declare const GateEvaluationEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"gate_evaluation">;
+    taskId: z.ZodString;
+    gate: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        skip: "skip";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GateEvaluationEvent = z.infer<typeof GateEvaluationEventSchema>;
+export declare const FileReservationEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"file_reservation">;
+    taskId: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    action: z.ZodEnum<{
+        reserve: "reserve";
+        release: "release";
+    }>;
+    worktreeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FileReservationEvent = z.infer<typeof FileReservationEventSchema>;
+export declare const PhaseTransitionEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"phase_transition">;
+    phase: z.ZodNumber;
+    transition: z.ZodEnum<{
+        complete: "complete";
+        start: "start";
+    }>;
+    taskCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PhaseTransitionEvent = z.infer<typeof PhaseTransitionEventSchema>;
+export declare const FileTouchEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"file_touch">;
+    taskId: z.ZodNullable<z.ZodString>;
+    filePath: z.ZodString;
+    operation: z.ZodEnum<{
+        rename: "rename";
+        write: "write";
+        delete: "delete";
+    }>;
+}, z.core.$strip>;
+export type FileTouchEvent = z.infer<typeof FileTouchEventSchema>;
+export declare const StateFileUpdateEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"state_file_update">;
+    filePath: z.ZodString;
+    fileType: z.ZodEnum<{
+        evidence: "evidence";
+        other: "other";
+        plan_json: "plan_json";
+        plan_md: "plan_md";
+        context_md: "context_md";
+    }>;
+}, z.core.$strip>;
+export type StateFileUpdateEvent = z.infer<typeof StateFileUpdateEventSchema>;
+export declare const ParallelWaveStartEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"parallel_wave_start">;
+    waveIndex: z.ZodNumber;
+    totalWaves: z.ZodNumber;
+    taskIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ParallelWaveStartEvent = z.infer<typeof ParallelWaveStartEventSchema>;
+export declare const ParallelWaveEndEventSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"parallel_wave_end">;
+    waveIndex: z.ZodNumber;
+    outcomes: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        success: z.ZodBoolean;
+    }, z.core.$strip>>;
+    mergeConflicts: z.ZodNumber;
+}, z.core.$strip>;
+export type ParallelWaveEndEvent = z.infer<typeof ParallelWaveEndEventSchema>;
+export declare const SwarmEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"session_metadata">;
+    swarmDir: z.ZodString;
+    pid: z.ZodNumber;
+    platform: z.ZodString;
+    nodeVersion: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"delegation_start">;
+    taskId: z.ZodNullable<z.ZodString>;
+    targetAgent: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"delegation_end">;
+    taskId: z.ZodNullable<z.ZodString>;
+    targetAgent: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    verdict: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"agent_status">;
+    agentName: z.ZodString;
+    status: z.ZodEnum<{
+        complete: "complete";
+        idle: "idle";
+        active: "active";
+    }>;
+    worktreeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"token_usage">;
+    agentName: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"tool_invocation">;
+    toolName: z.ZodString;
+    taskId: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    success: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"gate_evaluation">;
+    taskId: z.ZodString;
+    gate: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        skip: "skip";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"file_reservation">;
+    taskId: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    action: z.ZodEnum<{
+        reserve: "reserve";
+        release: "release";
+    }>;
+    worktreeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"phase_transition">;
+    phase: z.ZodNumber;
+    transition: z.ZodEnum<{
+        complete: "complete";
+        start: "start";
+    }>;
+    taskCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"file_touch">;
+    taskId: z.ZodNullable<z.ZodString>;
+    filePath: z.ZodString;
+    operation: z.ZodEnum<{
+        rename: "rename";
+        write: "write";
+        delete: "delete";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"state_file_update">;
+    filePath: z.ZodString;
+    fileType: z.ZodEnum<{
+        evidence: "evidence";
+        other: "other";
+        plan_json: "plan_json";
+        plan_md: "plan_md";
+        context_md: "context_md";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"parallel_wave_start">;
+    waveIndex: z.ZodNumber;
+    totalWaves: z.ZodNumber;
+    taskIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    type: z.ZodLiteral<"parallel_wave_end">;
+    waveIndex: z.ZodNumber;
+    outcomes: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        success: z.ZodBoolean;
+    }, z.core.$strip>>;
+    mergeConflicts: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export type SwarmEvent = z.infer<typeof SwarmEventSchema>;

package/dist/telemetry/src/guards.d.ts

@@ -0,0 +1,14 @@
+import type { AgentStatusEvent, DelegationEndEvent, DelegationStartEvent, FileReservationEvent, FileTouchEvent, GateEvaluationEvent, ParallelWaveEndEvent, ParallelWaveStartEvent, PhaseTransitionEvent, SessionMetadataEvent, StateFileUpdateEvent, SwarmEvent, TokenUsageEvent, ToolInvocationEvent } from './events';
+export declare function isSessionMetadata(e: SwarmEvent): e is SessionMetadataEvent;
+export declare function isDelegationStart(e: SwarmEvent): e is DelegationStartEvent;
+export declare function isDelegationEnd(e: SwarmEvent): e is DelegationEndEvent;
+export declare function isAgentStatus(e: SwarmEvent): e is AgentStatusEvent;
+export declare function isTokenUsage(e: SwarmEvent): e is TokenUsageEvent;
+export declare function isToolInvocation(e: SwarmEvent): e is ToolInvocationEvent;
+export declare function isGateEvaluation(e: SwarmEvent): e is GateEvaluationEvent;
+export declare function isFileReservation(e: SwarmEvent): e is FileReservationEvent;
+export declare function isPhaseTransition(e: SwarmEvent): e is PhaseTransitionEvent;
+export declare function isFileTouch(e: SwarmEvent): e is FileTouchEvent;
+export declare function isStateFileUpdate(e: SwarmEvent): e is StateFileUpdateEvent;
+export declare function isParallelWaveStart(e: SwarmEvent): e is ParallelWaveStartEvent;
+export declare function isParallelWaveEnd(e: SwarmEvent): e is ParallelWaveEndEvent;

package/dist/telemetry/src/index.d.ts

@@ -0,0 +1,4 @@
+export type { AgentStatusEvent, DelegationEndEvent, DelegationStartEvent, FileReservationEvent, FileTouchEvent, GateEvaluationEvent, ParallelWaveEndEvent, ParallelWaveStartEvent, PhaseTransitionEvent, SessionMetadataEvent, StateFileUpdateEvent, SwarmEvent, SwarmEventBase, TokenUsageEvent, ToolInvocationEvent, } from './events';
+export { AgentStatusEventSchema, DelegationEndEventSchema, DelegationStartEventSchema, FileReservationEventSchema, FileTouchEventSchema, GateEvaluationEventSchema, ParallelWaveEndEventSchema, ParallelWaveStartEventSchema, PhaseTransitionEventSchema, SessionMetadataEventSchema, StateFileUpdateEventSchema, SwarmEventBaseSchema, SwarmEventSchema, TokenUsageEventSchema, ToolInvocationEventSchema, } from './events';
+export { isAgentStatus, isDelegationEnd, isDelegationStart, isFileReservation, isFileTouch, isGateEvaluation, isParallelWaveEnd, isParallelWaveStart, isPhaseTransition, isSessionMetadata, isStateFileUpdate, isTokenUsage, isToolInvocation, } from './guards';
+export { TELEMETRY_SCHEMA_VERSION } from './version';

package/dist/telemetry/src/version.d.ts

@@ -0,0 +1 @@
+export declare const TELEMETRY_SCHEMA_VERSION = "1.0.0";

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export { composeHandlers, estimateTokens, readSwarmFileAsync, safeHook, validateSwarmPath, } from '@opencode-swarm/core';

package/dist/write-retro.d.ts

@@ -0,0 +1 @@
+export { executeWriteRetro, type WriteRetroArgs, } from '@opencode-swarm/core';

package/package.json

@@ -1,13 +1,20 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.27.0",
+	"version": "7.0.0-beta.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
+	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"source": "./src/index.ts",
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
 	"bin": {
 		"opencode-swarm": "./dist/cli/index.js"
 	},
-	"type": "module",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -34,29 +41,21 @@
 		"LICENSE"
 	],
 	"scripts": {
+		"build": "bun run clean && bun run ../../scripts/copy-grammars.ts && bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && bun run ../../scripts/copy-grammars.ts --to-dist && tsc --emitDeclarationOnly && bun run move-declarations",
+		"move-declarations": "node -e \"const fs=require('fs');const path=require('path');function m(d){if(!fs.existsSync(d))return;fs.readdirSync(d).forEach(f=>{const src=path.join(d,f),dst=path.join('dist',f);if(fs.statSync(src).isDirectory()){fs.mkdirSync(dst,{recursive:true});m(src)}else{fs.copyFileSync(src,dst)}})};m('dist/opencode/src');fs.rmSync('dist/opencode',{recursive:true});fs.rmSync('dist/core',{recursive:true})\"",
 		"clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
-		"build": "bun run clean && bun run scripts/copy-grammars.ts && bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && bun run scripts/copy-grammars.ts --to-dist && tsc --emitDeclarationOnly",
 		"typecheck": "tsc --noEmit",
 		"test": "bun test",
-		"lint": "biome lint .",
-		"format": "biome format . --write",
-		"check": "biome check --write .",
-		"dev": "bun run build && opencode",
 		"prepublishOnly": "bun run build"
 	},
 	"dependencies": {
+		"@opencode-swarm/core": "workspace:*",
 		"@opencode-ai/plugin": "^1.1.53",
 		"@opencode-ai/sdk": "^1.1.53",
-		"@vscode/tree-sitter-wasm": "^0.3.0",
-		"p-limit": "^7.3.0",
-		"proper-lockfile": "^4.1.2",
-		"web-tree-sitter": "^0.25.0",
 		"zod": "^4.1.8"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.3.14",
 		"bun-types": "latest",
-		"js-yaml": "^4.1.1",
 		"typescript": "^5.7.3"
 	}
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/__tests__/security-adversarial.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/agents/architect-permission.adversarial.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Adversarial Tests for Architect Task-Permission Hotfix (Task 1.21)
- * Focus: Agent naming edge cases, prefix misclassification, permission leakage
- */
-export {};

package/dist/agents/architect.turbo-banner.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/agents/coder.d.ts

@@ -1,2 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createCoderAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/critic.d.ts

@@ -1,3 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createCriticAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;
-export declare function createCriticDriftAgent(model: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/designer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createDesignerAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/docs.d.ts

@@ -1,2 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createDocsAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/explorer.d.ts

@@ -1,3 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createExplorerAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;
-export declare function createExplorerCuratorAgent(model: string, mode: 'CURATOR_INIT' | 'CURATOR_PHASE', customAppendPrompt?: string): AgentDefinition;

package/dist/agents/index.d.ts

@@ -1,27 +0,0 @@
-import type { AgentConfig as SDKAgentConfig } from '@opencode-ai/sdk';
-import { type PluginConfig } from '../config';
-import { type AgentDefinition } from './architect';
-export type { AgentDefinition } from './architect';
-/**
- * Strip the swarm prefix from an agent name to get the base name.
- * e.g., "local_coder" with prefix "local" → "coder"
- * Returns the name unchanged if no prefix matches.
- */
-export declare function stripSwarmPrefix(agentName: string, swarmPrefix?: string): string;
-/**
- * Create all agent definitions with configuration applied
- */
-export declare function createAgents(config?: PluginConfig): AgentDefinition[];
-/**
- * Get agent configurations formatted for the OpenCode SDK.
- */
-export declare function getAgentConfigs(config?: PluginConfig): Record<string, SDKAgentConfig>;
-export { createArchitectAgent } from './architect';
-export { createCoderAgent } from './coder';
-export { createCriticAgent } from './critic';
-export { createDesignerAgent } from './designer';
-export { createDocsAgent } from './docs';
-export { createExplorerAgent } from './explorer';
-export { createReviewerAgent, SECURITY_CATEGORIES, type SecurityCategory, } from './reviewer';
-export { createSMEAgent } from './sme';
-export { createTestEngineerAgent } from './test-engineer';

package/dist/agents/reviewer.d.ts

@@ -1,5 +0,0 @@
-import type { AgentDefinition } from './architect';
-/** OWASP Top 10 2021 categories for security-focused review passes */
-export declare const SECURITY_CATEGORIES: readonly ["broken-access-control", "cryptographic-failures", "injection", "insecure-design", "security-misconfiguration", "vulnerable-components", "auth-failures", "data-integrity-failures", "logging-monitoring-failures", "ssrf"];
-export type SecurityCategory = (typeof SECURITY_CATEGORIES)[number];
-export declare function createReviewerAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/sme.d.ts

@@ -1,2 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createSMEAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/test-engineer.adversarial.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Adversarial Security Tests for Test Engineer Agent (Task 7.1)
- * Focus: Prompt injection, unsafe execution bypass, secret leakage
- */
-export {};

package/dist/agents/test-engineer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createTestEngineerAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/test-engineer.security.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/background/circuit-breaker.d.ts

@@ -1,149 +0,0 @@
-/**
- * Circuit Breaker + Loop Protection Primitives
- *
- * Provides fault tolerance and infinite loop prevention for background automation.
- */
-/** Circuit breaker states */
-export type CircuitBreakerState = 'closed' | 'open' | 'half-open';
-/** Circuit breaker configuration */
-export interface CircuitBreakerConfig {
-    /** Number of failures before opening circuit */
-    failureThreshold: number;
-    /** Time in ms to wait before attempting reset */
-    resetTimeoutMs: number;
-    /** Number of success calls needed to close from half-open */
-    successThreshold: number;
-    /** Timeout for individual calls (0 = no timeout) */
-    callTimeoutMs: number;
-}
-/** Circuit breaker events */
-export interface CircuitBreakerEvents {
-    opened: {
-        timestamp: number;
-        failureCount: number;
-    };
-    closed: {
-        timestamp: number;
-        successCount: number;
-    };
-    'half-open': {
-        timestamp: number;
-    };
-    callSuccess: {
-        duration: number;
-    };
-    callFailure: {
-        error: unknown;
-        duration: number;
-    };
-}
-export type CircuitBreakerEventType = keyof CircuitBreakerEvents;
-/**
- * Circuit Breaker Implementation
- *
- * Prevents cascading failures by stopping requests when the circuit is open.
- * States:
- * - closed: Normal operation, requests pass through
- * - open: Circuit is open, requests fail fast
- * - half-open: Testing if service recovered
- */
-export declare class CircuitBreaker {
-    private state;
-    private failureCount;
-    private successCount;
-    private lastFailureTime?;
-    private readonly config;
-    private readonly name;
-    private readonly onStateChange?;
-    constructor(name: string, config?: Partial<CircuitBreakerConfig>, onStateChange?: (eventType: string, event: unknown) => void);
-    /**
-     * Get current circuit state
-     */
-    getState(): CircuitBreakerState;
-    /**
-     * Execute a function with circuit breaker protection
-     */
-    execute<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Execute with timeout
-     */
-    private executeWithTimeout;
-    /**
-     * Record a successful call
-     */
-    private recordSuccess;
-    /**
-     * Record a failed call
-     */
-    private recordFailure;
-    /**
-     * Transition to a new state
-     */
-    private transitionTo;
-    /**
-     * Manually reset the circuit breaker
-     */
-    reset(): void;
-    /**
-     * Get circuit breaker statistics
-     */
-    getStats(): {
-        state: CircuitBreakerState;
-        failureCount: number;
-        successCount: number;
-        lastFailureTime?: number;
-    };
-}
-/**
- * Loop Protection for preventing infinite automation loops
- *
- * Tracks operation history and detects potential infinite loops.
- */
-export interface LoopProtectionConfig {
-    /** Maximum times an operation can be attempted */
-    maxIterations: number;
-    /** Time window in ms to track iterations */
-    timeWindowMs: number;
-    /** Unique key for the operation being protected */
-    operationKey: string;
-}
-/**
- * Loop Protection Implementation
- *
- * Prevents infinite loops by tracking operation frequency.
- */
-export declare class LoopProtection {
-    private records;
-    private readonly config;
-    private readonly onLoopDetected?;
-    constructor(config: LoopProtectionConfig, onLoopDetected?: (key: string, count: number) => void);
-    /**
-     * Record an iteration attempt
-     * Returns false if max iterations exceeded
-     */
-    recordAttempt(key?: string): boolean;
-    /**
-     * Check if operation is allowed without recording
-     */
-    canProceed(key?: string): boolean;
-    /**
-     * Get remaining iterations allowed
-     */
-    getRemainingIterations(key?: string): number;
-    /**
-     * Reset tracking for an operation
-     */
-    reset(key?: string): void;
-    /**
-     * Reset all tracking
-     */
-    resetAll(): void;
-    /**
-     * Get current iteration count
-     */
-    getIterationCount(key?: string): number;
-    /**
-     * Get all operation keys being tracked
-     */
-    getTrackedOperations(): string[];
-}