opencode-swarm 7.0.0-beta.1 → 7.0.1

package/dist/tools/search.d.ts

@@ -0,0 +1,29 @@
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+export interface SearchMatch {
+    file: string;
+    lineNumber: number;
+    lineText: string;
+    context?: string[];
+}
+export interface SearchResult {
+    matches: SearchMatch[];
+    truncated: boolean;
+    total: number;
+    query: string;
+    mode: 'literal' | 'regex';
+    maxResults: number;
+}
+export interface SearchError {
+    error: true;
+    type: 'rg-not-found' | 'regex-timeout' | 'path-escape' | 'invalid-query' | 'unknown';
+    message: string;
+}
+export interface SearchArgs {
+    query: string;
+    mode?: 'literal' | 'regex';
+    include?: string;
+    exclude?: string;
+    max_results?: number;
+    max_lines?: number;
+}
+export declare const search: ToolDefinition;

package/dist/tools/search.test.d.ts

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

package/dist/tools/secretscan.d.ts

@@ -0,0 +1,35 @@
+import { createSwarmTool } from './create-tool';
+type SecretType = 'api_key' | 'aws_access_key' | 'aws_secret_key' | 'private_key' | 'password' | 'secret_token' | 'bearer_token' | 'basic_auth' | 'database_url' | 'jwt' | 'github_token' | 'slack_token' | 'stripe_key' | 'sendgrid_key' | 'twilio_key' | 'generic_token' | 'high_entropy';
+type Confidence = 'high' | 'medium' | 'low';
+type Severity = 'critical' | 'high' | 'medium' | 'low';
+export interface SecretFinding {
+    path: string;
+    line: number;
+    type: SecretType;
+    confidence: Confidence;
+    severity: Severity;
+    redacted: string;
+    context: string;
+}
+export interface SecretscanResult {
+    scan_dir: string;
+    findings: SecretFinding[];
+    count: number;
+    files_scanned: number;
+    skipped_files: number;
+    message?: string;
+}
+export interface SecretscanErrorResult {
+    error: string;
+    scan_dir: string;
+    findings: [];
+    count: 0;
+    files_scanned: 0;
+    skipped_files: 0;
+}
+export declare const secretscan: ReturnType<typeof createSwarmTool>;
+/**
+ * Run secretscan programmatically
+ */
+export declare function runSecretscan(directory: string): Promise<SecretscanResult | SecretscanErrorResult>;
+export {};

package/dist/tools/set-qa-gates.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Tool to configure the QA gate profile for the current plan.
+ *
+ * Architect-only: invoked during the QA GATE SELECTION phase of brainstorm
+ * mode (or equivalent). Ratchet-tighter only — cannot disable gates that are
+ * already enabled. Rejects all writes once the profile is locked.
+ *
+ * Creates the profile with defaults if missing, then applies the requested
+ * partial update.
+ */
+import type { tool } from '@opencode-ai/plugin';
+export interface SetQaGatesArgs {
+    reviewer?: boolean;
+    test_engineer?: boolean;
+    council_mode?: boolean;
+    sme_enabled?: boolean;
+    critic_pre_plan?: boolean;
+    hallucination_guard?: boolean;
+    sast_enabled?: boolean;
+    mutation_test?: boolean;
+    council_general_review?: boolean;
+    drift_check?: boolean;
+    project_type?: string;
+}
+interface SetQaGatesResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    plan_id?: string;
+    profile?: {
+        plan_id: string;
+        gates: Record<string, boolean>;
+        locked_at: string | null;
+        locked_by_snapshot_seq: number | null;
+        profile_hash: string;
+    };
+}
+export declare function executeSetQaGates(args: SetQaGatesArgs, directory: string): Promise<SetQaGatesResult>;
+export declare const set_qa_gates: ReturnType<typeof tool>;
+export {};

package/dist/tools/suggest-patch.adversarial.test.d.ts

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

package/dist/tools/suggest-patch.d.ts

@@ -0,0 +1,37 @@
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+export interface PatchHunk {
+    file: string;
+    originalContext: string[];
+    newContent: string;
+    hunkIndex: number;
+}
+export interface PatchSuggestion {
+    success: true;
+    patches: PatchHunk[];
+    filesModified: string[];
+    errors?: PatchError[];
+}
+export interface PatchError {
+    success: false;
+    error: true;
+    type: 'context-mismatch' | 'file-not-found' | 'parse-error' | 'unknown';
+    message: string;
+    details?: {
+        expected?: string;
+        actual?: string;
+        location?: string;
+    };
+    errors?: PatchError[];
+}
+export interface ChangeDescription {
+    file: string;
+    contextBefore?: string[];
+    contextAfter?: string[];
+    oldContent?: string;
+    newContent: string;
+}
+export interface SuggestPatchArgs {
+    targetFiles: string[];
+    changes: ChangeDescription[];
+}
+export declare const suggestPatch: ToolDefinition;

package/dist/tools/suggest-patch.test.d.ts

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

package/dist/tools/symbols.d.ts

@@ -0,0 +1,21 @@
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+interface SymbolInfo {
+    name: string;
+    kind: 'function' | 'class' | 'interface' | 'type' | 'enum' | 'const' | 'variable' | 'method' | 'property';
+    exported: boolean;
+    signature: string;
+    line: number;
+    jsdoc?: string;
+}
+/**
+ * Extract symbols from a TypeScript/JavaScript file using regex-based parsing.
+ * Handles: export function, export const, export class, export interface,
+ * export type, export enum, export default, and class members.
+ */
+export declare function extractTSSymbols(filePath: string, cwd: string): SymbolInfo[];
+/**
+ * Extract symbols from a Python file.
+ */
+export declare function extractPythonSymbols(filePath: string, cwd: string): SymbolInfo[];
+export declare const symbols: ToolDefinition;
+export {};

package/dist/tools/syntax-check.d.ts

@@ -0,0 +1,37 @@
+import type { tool } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+import type { EvidenceVerdict } from '../config/evidence-schema';
+export interface SyntaxCheckInput {
+    /** Files to check (from diff gate) */
+    changed_files: Array<{
+        path: string;
+        additions: number;
+    }>;
+    /** Check mode: 'changed' = only changed files, 'all' = all files in repo */
+    mode?: 'changed' | 'all';
+    /** Optional: restrict to specific languages */
+    languages?: string[];
+}
+export interface SyntaxCheckFileResult {
+    path: string;
+    language: string;
+    ok: boolean;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+    skipped_reason?: string;
+}
+export interface SyntaxCheckResult {
+    verdict: EvidenceVerdict;
+    files: SyntaxCheckFileResult[];
+    summary: string;
+}
+/**
+ * Run syntax check on changed files
+ *
+ * Respects config.gates.syntax_check.enabled - returns skipped if disabled
+ */
+export declare function syntaxCheck(input: SyntaxCheckInput, directory: string, config?: PluginConfig): Promise<SyntaxCheckResult>;
+export declare const syntax_check: ReturnType<typeof tool>;

package/dist/tools/test-impact.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool';
+export declare const test_impact: ReturnType<typeof createSwarmTool>;

package/dist/tools/test-runner.d.ts

@@ -0,0 +1,86 @@
+import type { tool } from '@opencode-ai/plugin';
+export declare const MAX_OUTPUT_BYTES = 512000;
+export declare const MAX_COMMAND_LENGTH = 500;
+export declare const DEFAULT_TIMEOUT_MS = 60000;
+export declare const MAX_TIMEOUT_MS = 300000;
+export declare const MAX_SAFE_TEST_FILES = 50;
+export declare const SUPPORTED_FRAMEWORKS: readonly ["bun", "vitest", "jest", "mocha", "pytest", "cargo", "pester", "go-test", "maven", "gradle", "dotnet-test", "ctest", "swift-test", "dart-test", "rspec", "minitest"];
+export type TestFramework = (typeof SUPPORTED_FRAMEWORKS)[number] | 'none';
+export interface TestRunnerArgs {
+    scope?: 'all' | 'convention' | 'graph' | 'impact';
+    files?: string[];
+    coverage?: boolean;
+    timeout_ms?: number;
+    allow_full_suite?: boolean;
+}
+export type RegressionOutcome = 'pass' | 'skip' | 'regression' | 'scope_exceeded' | 'error';
+export interface TestTotals {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+}
+export interface TestSuccessResult {
+    success: true;
+    framework: TestFramework;
+    scope: 'all' | 'convention' | 'graph' | 'impact';
+    command: string[];
+    timeout_ms: number;
+    duration_ms: number;
+    totals: TestTotals;
+    coveragePercent?: number;
+    rawOutput?: string;
+    message?: string;
+    outcome?: RegressionOutcome;
+}
+export interface TestErrorResult {
+    success: false;
+    framework: TestFramework;
+    scope: 'all' | 'convention' | 'graph' | 'impact';
+    command?: string[];
+    timeout_ms?: number;
+    duration_ms?: number;
+    totals?: TestTotals;
+    coveragePercent?: number;
+    error: string;
+    rawOutput?: string;
+    message?: string;
+    outcome?: RegressionOutcome;
+    attempted_scope?: 'graph';
+}
+export type TestResult = TestSuccessResult | TestErrorResult;
+export declare function detectTestFramework(cwd: string): Promise<TestFramework>;
+/**
+ * Returns true when `basename` matches a language-specific test file naming
+ * convention that is NOT captured by the compound-extension or dot-separated
+ * `.test.`/`.spec.` checks above.
+ *
+ * Covered patterns (all lower-cased for comparison):
+ *   Go   : <name>_test.go          (per `go test` convention)
+ *   Python: test_<name>.py          (pytest discovery default)
+ *           <name>_test.py          (pytest alternative)
+ *   Ruby : <name>_spec.rb           (RSpec convention)
+ *   Java : Test<Name>.java          (JUnit 4/5 prefix)
+ *          <Name>Test.java          (JUnit 4/5 suffix)
+ *          <Name>Tests.java         (JUnit 4/5 plural suffix)
+ *          <Name>IT.java            (Maven Failsafe integration-test suffix)
+ *   C#   : <Name>Test.cs            (xUnit/NUnit/MSTest suffix)
+ *          <Name>Tests.cs           (xUnit/NUnit/MSTest plural suffix)
+ *   Rust : test files are recognized by test-directory placement
+ *           (for example, tests/<anything>.rs via /tests/ path detection)
+ *   Kotlin: <Name>Test.kt / <Name>Tests.kt / Test<Name>.kt
+ *
+ * Exported for unit tests; production code uses it only through
+ * getTestFilesFromConvention.
+ */
+export declare function isLanguageSpecificTestFile(basename: string): boolean;
+/**
+ * Map source files (or already-test files) to the test files that should be
+ * run for them. Handles any language whose test files follow a naming convention
+ * — TS/JS, Go, Python, Ruby, Java, C#, Kotlin, PowerShell.
+ *
+ * Exported for unit tests.
+ */
+export declare function getTestFilesFromConvention(sourceFiles: string[], workingDir?: string): string[];
+export declare function runTests(framework: TestFramework, scope: 'all' | 'convention' | 'graph' | 'impact', files: string[], coverage: boolean, timeout_ms: number, cwd: string): Promise<TestResult>;
+export declare const test_runner: ReturnType<typeof tool>;

package/dist/tools/test-runner.security-adversarial.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ADVERSARIAL SECURITY TESTS FOR test-runner.ts
+ * Testing ONLY attack vectors - identifies which inputs are REJECTED vs ACCEPTED
+ */
+export {};

package/dist/tools/todo-extract.d.ts

@@ -0,0 +1,2 @@
+import type { tool } from '@opencode-ai/plugin';
+export declare const todo_extract: ReturnType<typeof tool>;

package/dist/tools/tool-names.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Central registry of all tool names used by the swarm.
+ * Used for constants and agent setup references.
+ */
+/** Union type of all valid tool names */
+export type ToolName = 'diff' | 'diff_summary' | 'syntax_check' | 'placeholder_scan' | 'imports' | 'lint' | 'secretscan' | 'sast_scan' | 'build_check' | 'pre_check_batch' | 'quality_budget' | 'symbols' | 'complexity_hotspots' | 'schema_drift' | 'todo_extract' | 'evidence_check' | 'check_gate_status' | 'completion_verify' | 'submit_council_verdicts' | 'declare_council_criteria' | 'sbom_generate' | 'checkpoint' | 'pkg_audit' | 'test_runner' | 'test_impact' | 'mutation_test' | 'generate_mutants' | 'detect_domains' | 'gitingest' | 'retrieve_summary' | 'extract_code_blocks' | 'phase_complete' | 'save_plan' | 'update_task_status' | 'lint_spec' | 'write_retro' | 'write_drift_evidence' | 'write_hallucination_evidence' | 'write_mutation_evidence' | 'declare_scope' | 'knowledge_query' | 'doc_scan' | 'doc_extract' | 'curator_analyze' | 'knowledge_add' | 'knowledge_recall' | 'knowledge_remove' | 'co_change_analyzer' | 'search' | 'batch_symbols' | 'suggest_patch' | 'req_coverage' | 'get_approved_plan' | 'repo_map' | 'get_qa_gate_profile' | 'set_qa_gates' | 'web_search' | 'convene_general_council';
+/** Readonly array of all tool names */
+export declare const TOOL_NAMES: readonly ToolName[];
+/** Set for O(1) tool name validation */
+export declare const TOOL_NAME_SET: ReadonlySet<ToolName>;

package/dist/tools/update-task-status.adversarial.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ADVERSARIAL SECURITY TESTS for src/tools/update-task-status.ts
+ *
+ * Tests attack vectors against the fallbackDir parameter which bypasses
+ * the working_directory validation guards.
+ *
+ * Attack vectors tested:
+ * 1. Null byte injection in fallbackDir
+ * 2. Path traversal sequences (../../etc) in fallbackDir
+ * 3. Empty string fallbackDir (falsy check edge case)
+ * 4. Command injection via path.join with malicious fallbackDir
+ */
+export {};

package/dist/tools/update-task-status.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Update task status tool for changing the status of individual tasks in a plan.
+ * Allows agents to mark tasks as pending, in_progress, completed, or blocked.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the update_task_status tool
+ */
+export interface UpdateTaskStatusArgs {
+    task_id: string;
+    status: string;
+    working_directory?: string;
+}
+/**
+ * Result from executing update_task_status
+ */
+export interface UpdateTaskStatusResult {
+    success: boolean;
+    message: string;
+    task_id?: string;
+    new_status?: string;
+    current_phase?: number;
+    errors?: string[];
+    /** Present when the call failed due to lock contention. Instructs the caller to retry. */
+    recovery_guidance?: string;
+}
+/**
+ * Validate that the status is one of the allowed values.
+ * @param status - The status to validate
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateStatus(status: string): string | undefined;
+/**
+ * Validate that task_id matches the required format (N.M or N.M.P).
+ * @param taskId - The task ID to validate
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateTaskId(taskId: string): string | undefined;
+/**
+ * Result from checking reviewer gate presence
+ */
+export interface ReviewerGateResult {
+    blocked: boolean;
+    reason: string;
+}
+/**
+ * Check if a task has passed required QA gates using the state machine.
+ * Requires the task to be in 'tests_run' or 'complete' state, which means
+ * both reviewer delegation and test_engineer runs have been recorded.
+ * @param taskId - The task ID to check gate state for
+ * @param workingDirectory - Optional working directory for plan.json fallback
+ * @param stageBParallelEnabled - When true, also accept both-markers-present as passing (PR 2 barrier)
+ * @returns ReviewerGateResult indicating whether the gate is blocked
+ */
+export declare function checkReviewerGate(taskId: string, workingDirectory?: string, stageBParallelEnabled?: boolean): ReviewerGateResult;
+/**
+ * Wrapper around checkReviewerGate that appends a diff-scope advisory warning.
+ * Keeps checkReviewerGate synchronous for backward compatibility.
+ * Also resolves the PR 2 stageB.parallel.enabled flag from config.
+ * @param taskId - The task ID to check gate state for
+ * @param workingDirectory - Optional working directory for plan.json fallback
+ * @returns ReviewerGateResult with optional scope warning appended to reason
+ */
+export declare function checkReviewerGateWithScope(taskId: string, workingDirectory?: string): Promise<ReviewerGateResult>;
+/**
+ * Recovery mechanism: reconcile task state with delegation history.
+ * When reviewer/test_engineer delegations occurred but the state machine
+ * was not advanced (e.g., toolAfter didn't fire, subagent_type missing,
+ * cross-session gaps, or pure verification tasks without coder delegation),
+ * this function walks all delegation chains and advances the task state
+ * so that checkReviewerGate can make an accurate decision.
+ *
+ * @param taskId - The task ID to recover state for
+ */
+export declare function recoverTaskStateFromDelegations(taskId: string): void;
+/**
+ * Result of the council-gate check used when transitioning to 'completed'.
+ *
+ * - When council.enabled is false, {blocked:false} is always returned (no regression).
+ * - When council.enabled is true, requires evidence.gates.council to exist and
+ *   its verdict to be APPROVE or CONCERNS. A missing gate or REJECT verdict blocks.
+ */
+export interface CouncilGateResult {
+    blocked: boolean;
+    reason: string;
+}
+/**
+ * Check the council gate for a completion transition. Pure — reads config and
+ * evidence only, no state mutation. Exported for focused unit testing.
+ *
+ * AND semantics (mirrors isCouncilGateActive in state.ts): the gate only
+ * activates when BOTH pluginConfig.council.enabled === true AND the QA gate
+ * profile for this plan has council_mode === true.  When council.enabled is
+ * true but council_mode is false (or the profile is absent), the gate is
+ * treated as inactive — the operator has disabled it at the profile level.
+ *
+ * @param workingDirectory - Validated project root (contains .swarm/evidence/)
+ * @param taskId - Task ID in N.M or N.M.P format
+ */
+export declare function checkCouncilGate(workingDirectory: string, taskId: string): CouncilGateResult;
+/**
+ * Execute the update_task_status tool.
+ * Validates the task_id and status, then updates the task status in the plan.
+ * Uses file locking on plan.json to prevent concurrent writes from corrupting the plan.
+ * Only one concurrent call wins the lock; others return success: false with recovery_guidance: "retry".
+ * @param args - The update task status arguments
+ * @param fallbackDir - Fallback working directory if args.working_directory is not provided
+ * @returns UpdateTaskStatusResult with success status and details
+ */
+export declare function executeUpdateTaskStatus(args: UpdateTaskStatusArgs, fallbackDir?: string): Promise<UpdateTaskStatusResult>;
+/**
+ * Tool definition for update_task_status
+ */
+export declare const update_task_status: ToolDefinition;

package/dist/tools/update-task-status.gates.test.d.ts

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

package/dist/tools/update-task-status.test.d.ts

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

package/dist/tools/update-task-status.turbo-bypass.test.d.ts

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

package/dist/tools/verify-six-tools-registration.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Verification tests for the 6 registered tools
+ *
+ * Verifies:
+ * 1. All 6 tools can be imported from './tools/index.ts'
+ * 2. The tool: {} block in src/index.ts includes all 6 tools
+ * 3. The plugin can load without errors
+ */
+export {};

package/dist/tools/web-search.d.ts

@@ -0,0 +1,13 @@
+/**
+ * web_search tool — restricted to council_member agents.
+ *
+ * Thin wrapper around `src/council/web-search-provider.ts`. Returns structured
+ * results on success and structured errors on failure (never throws). Config-
+ * gated on `council.general.enabled`. The provider itself surfaces missing-key
+ * configuration via WebSearchConfigError, which this tool maps to a structured
+ * `success: false` response.
+ *
+ * Hard cap on max_results = 10 (clamped silently). Default sourced from council.general.maxSourcesPerMember.
+ */
+import type { tool } from '@opencode-ai/plugin';
+export declare const web_search: ReturnType<typeof tool>;

package/dist/tools/write-drift-evidence.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Write drift evidence tool for persisting drift verification results.
+ * Accepts phase, verdict, and summary from the Architect and writes
+ * a gate-contract formatted evidence file.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the write_drift_evidence tool
+ */
+export interface WriteDriftEvidenceArgs {
+    /** The phase number for the drift verification */
+    phase: number;
+    /** Verdict of the drift verification: 'APPROVED' or 'NEEDS_REVISION' */
+    verdict: 'APPROVED' | 'NEEDS_REVISION';
+    /** Human-readable summary of the drift verification */
+    summary: string;
+    /** Requirement coverage report from req_coverage tool */
+    requirementCoverage?: string;
+}
+/**
+ * Execute the write_drift_evidence tool.
+ * Validates input, builds a gate-contract entry, and writes to disk.
+ * @param args - The write drift evidence arguments
+ * @param directory - Working directory
+ * @returns JSON string with success status and details
+ */
+export declare function executeWriteDriftEvidence(args: WriteDriftEvidenceArgs, directory: string): Promise<string>;
+/**
+ * Tool definition for write_drift_evidence
+ */
+export declare const write_drift_evidence: ToolDefinition;

package/dist/tools/write-hallucination-evidence.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Write hallucination evidence tool for persisting hallucination verification results.
+ * Accepts phase, verdict, and summary from the Architect and writes
+ * a gate-contract formatted evidence file.
+ *
+ * Unlike write_drift_evidence, this tool does NOT lock the QA gate profile or
+ * write a plan snapshot — those side-effects belong to drift verification only.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the write_hallucination_evidence tool
+ */
+export interface WriteHallucinationEvidenceArgs {
+    /** The phase number for the hallucination verification */
+    phase: number;
+    /** Verdict of the hallucination verification: 'APPROVED' or 'NEEDS_REVISION' */
+    verdict: 'APPROVED' | 'NEEDS_REVISION';
+    /** Human-readable summary of the hallucination verification */
+    summary: string;
+    /** Optional bullet list of FABRICATED/DRIFTED/UNSUPPORTED/BROKEN findings */
+    findings?: string;
+}
+/**
+ * Execute the write_hallucination_evidence tool.
+ */
+export declare function executeWriteHallucinationEvidence(args: WriteHallucinationEvidenceArgs, directory: string): Promise<string>;
+/**
+ * Tool definition for write_hallucination_evidence
+ */
+export declare const write_hallucination_evidence: ToolDefinition;

package/dist/tools/write-mutation-evidence.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Write mutation evidence tool for persisting mutation testing gate results.
+ * Accepts phase, verdict, killRate, adjustedKillRate, and summary from the Architect
+ * and writes a gate-contract formatted evidence file.
+ *
+ * Unlike write_drift_evidence, this tool does NOT lock the QA gate profile or
+ * write a plan snapshot — those side-effects belong to drift verification only.
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the write_mutation_evidence tool
+ */
+export interface WriteMutationEvidenceArgs {
+    /** The phase number for the mutation gate */
+    phase: number;
+    /** Verdict of the mutation gate: 'PASS', 'WARN', 'FAIL', or 'SKIP' */
+    verdict: 'PASS' | 'WARN' | 'FAIL' | 'SKIP';
+    /** The raw kill rate (e.g., 0.85) */
+    killRate?: number;
+    /** The adjusted kill rate accounting for timeout survived mutants (e.g., 0.87) */
+    adjustedKillRate?: number;
+    /** Human-readable summary of the mutation gate result */
+    summary: string;
+    /** Optional JSON-serialized list of survived mutants */
+    survivedMutants?: string;
+}
+/**
+ * Execute the write_mutation_evidence tool.
+ */
+export declare function executeWriteMutationEvidence(args: WriteMutationEvidenceArgs, directory: string): Promise<string>;
+/**
+ * Tool definition for write_mutation_evidence
+ */
+export declare const write_mutation_evidence: ToolDefinition;

package/dist/tools/write-mutation-evidence.test.d.ts

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

package/dist/tools/write-retro.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Write retro tool for persisting retrospective evidence bundles.
+ * Accepts flat retro fields from the Architect and wraps them correctly
+ * in a RetrospectiveEvidence entry before calling saveEvidence().
+ * This fixes the bug where Architect was writing flat JSON that failed EvidenceBundleSchema.parse().
+ */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the write_retro tool
+ * User-supplied fields (the Architect provides these)
+ */
+export interface WriteRetroArgs {
+    /** The phase number being completed (maps to phase_number in schema) */
+    phase: number;
+    /** Human-readable phase summary (maps to summary in BaseEvidenceSchema) */
+    summary: string;
+    /** Count of tasks completed */
+    task_count: number;
+    /** Task complexity level */
+    task_complexity: 'trivial' | 'simple' | 'moderate' | 'complex';
+    /** Total number of tool calls in the phase */
+    total_tool_calls: number;
+    /** Number of coder revisions made */
+    coder_revisions: number;
+    /** Number of reviewer rejections received */
+    reviewer_rejections: number;
+    loop_detections?: number;
+    circuit_breaker_trips?: number;
+    /** Number of test failures encountered */
+    test_failures: number;
+    /** Number of security findings */
+    security_findings: number;
+    /** Number of integration issues */
+    integration_issues: number;
+    /** Optional lessons learned (max 5) */
+    lessons_learned?: string[];
+    /** Optional top rejection reasons */
+    top_rejection_reasons?: string[];
+    /** Optional task ID (defaults to retro-{phase}) */
+    task_id?: string;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Execute the write_retro tool.
+ * Validates input, builds a RetrospectiveEvidence entry, and saves to disk.
+ * @param args - The write retro arguments
+ * @param directory - Working directory
+ * @returns JSON string with success status and details
+ */
+export declare function executeWriteRetro(args: WriteRetroArgs, directory: string): Promise<string>;
+/**
+ * Tool definition for write_retro
+ */
+export declare const write_retro: ToolDefinition;

package/dist/transient-retry.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Regression tests for Issue #691 — transient LLM error continuation (v6.34)
+ *
+ * Covers:
+ * 1. TRANSIENT_MODEL_ERROR_PATTERN regex (529 addition and pre-existing terms)
+ * 2. GuardrailsConfigSchema and GuardrailsProfileSchema max_transient_retries field
+ * 3. InvocationWindow.transientRetryCount initialization via beginInvocation
+ * 4. transientRetryCount resets at the start of each new invocation window
+ */
+export {};