opencode-swarm 7.29.4 → 7.30.0

package/dist/memory/config.d.ts

@@ -0,0 +1,22 @@
+import type { MemoryKind } from './types';
+export interface MemoryConfig {
+    enabled: boolean;
+    provider: 'local-jsonl';
+    storageDir: string;
+    recall: {
+        defaultMaxItems: number;
+        defaultTokenBudget: number;
+        minScore: number;
+    };
+    writes: {
+        mode: 'propose';
+    };
+    redaction: {
+        rejectDurableSecrets: boolean;
+    };
+    hardDelete: boolean;
+}
+export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
+export declare const DURABLE_MEMORY_KINDS: ReadonlySet<MemoryKind>;
+export declare const EVIDENCE_REQUIRED_KINDS: ReadonlySet<MemoryKind>;
+export declare function resolveMemoryConfig(input: Partial<MemoryConfig> | undefined): MemoryConfig;

package/dist/memory/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class MemoryValidationError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+export declare class MemoryDisabledError extends Error {
+    constructor(message?: string);
+}

package/dist/memory/gateway.d.ts

@@ -0,0 +1,51 @@
+import { type MemoryConfig } from './config';
+import type { MemoryProposalStore, MemoryProvider } from './provider';
+import type { MemoryContext, MemoryKind, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle } from './types';
+export interface MemoryGatewayOptions {
+    config?: Partial<MemoryConfig>;
+    provider?: MemoryProvider & Partial<MemoryProposalStore>;
+    now?: () => Date;
+}
+export interface ProposeMemoryInput {
+    operation: MemoryProposal['operation'];
+    kind?: MemoryKind;
+    text?: string;
+    targetMemoryId?: string;
+    relatedMemoryIds?: string[];
+    rationale: string;
+    evidenceRefs?: string[];
+}
+export interface RecallMemoryInput {
+    query: string;
+    task?: string;
+    kinds?: MemoryKind[];
+    maxItems?: number;
+    tokenBudget?: number;
+    minScore?: number;
+    includeExpired?: boolean;
+}
+export declare class MemoryGateway {
+    private readonly context;
+    private readonly config;
+    private readonly provider;
+    private readonly now;
+    constructor(context: MemoryContext, options?: MemoryGatewayOptions);
+    isEnabled(): boolean;
+    deriveAllowedScopes(): MemoryScopeRef[];
+    recall(input: RecallMemoryInput): Promise<RecallBundle>;
+    propose(input: ProposeMemoryInput): Promise<MemoryProposal>;
+    upsertCurated(record: MemoryRecord): Promise<MemoryRecord>;
+    createRecord(input: {
+        kind: MemoryKind;
+        text: string;
+        evidenceRefs?: string[];
+        source?: MemorySource;
+        scope?: MemoryScopeRef;
+        confidence?: number;
+        stability?: MemoryRecord['stability'];
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    }): MemoryRecord;
+    private assertEnabled;
+}
+export declare function createMemoryGateway(context: MemoryContext, options?: MemoryGatewayOptions): MemoryGateway;

package/dist/memory/index.d.ts

@@ -0,0 +1,11 @@
+export type { MemoryConfig } from './config';
+export { DEFAULT_MEMORY_CONFIG, resolveMemoryConfig } from './config';
+export { MemoryDisabledError, MemoryValidationError } from './errors';
+export type { MemoryGatewayOptions, ProposeMemoryInput, RecallMemoryInput, } from './gateway';
+export { createMemoryGateway, MemoryGateway } from './gateway';
+export { LocalJsonlMemoryProvider } from './local-jsonl-provider';
+export { buildRecallPromptBlock } from './prompt-block';
+export type { MemoryProposalStore, MemoryProvider } from './provider';
+export { findSecrets, redactSecrets } from './redaction';
+export { computeMemoryContentHash, createBundleId, createMemoryId, createProposalId, isExpired, normalizeMemoryText, validateMemoryProposal, validateMemoryRecordRules, } from './schema';
+export type { MemoryContext, MemoryKind, MemoryListFilter, MemoryProposal, MemoryRecord, MemoryScopeRef, MemoryScopeType, RecallBundle, RecallRequest, RecallResultItem, } from './types';

package/dist/memory/local-jsonl-provider.d.ts

@@ -0,0 +1,26 @@
+import { type MemoryConfig } from './config';
+import type { MemoryProposalStore, MemoryProvider } from './provider';
+import type { MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem } from './types';
+export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryProposalStore {
+    readonly name = "local-jsonl";
+    private readonly rootDirectory;
+    private readonly config;
+    private initialized;
+    private memories;
+    private proposals;
+    constructor(rootDirectory: string, config?: Partial<MemoryConfig>);
+    private pathFor;
+    initialize(): Promise<void>;
+    upsert(record: MemoryRecord): Promise<MemoryRecord>;
+    get(id: string): Promise<MemoryRecord | null>;
+    delete(id: string, reason?: string): Promise<void>;
+    recall(request: RecallRequest): Promise<RecallResultItem[]>;
+    list(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
+    createProposal(proposal: MemoryProposal): Promise<MemoryProposal>;
+    listProposals(filter?: {
+        status?: MemoryProposal['status'];
+        limit?: number;
+    }): Promise<MemoryProposal[]>;
+    compact(): Promise<void>;
+    private audit;
+}

package/dist/memory/prompt-block.d.ts

@@ -0,0 +1,13 @@
+import type { RecallBundle, RecallResultItem } from './types';
+export declare function buildRecallPromptBlock(items: RecallResultItem[], tokenBudget: number): {
+    promptBlock: string;
+    tokenEstimate: number;
+    items: RecallResultItem[];
+};
+export declare function toRecallBundle(input: {
+    id: string;
+    query: string;
+    generatedAt: string;
+    items: RecallResultItem[];
+    tokenBudget: number;
+}): RecallBundle;

package/dist/memory/provider.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem } from './types';
+export interface MemoryProvider {
+    readonly name: string;
+    initialize?(): Promise<void>;
+    upsert(record: MemoryRecord): Promise<MemoryRecord>;
+    get(id: string): Promise<MemoryRecord | null>;
+    delete(id: string, reason?: string): Promise<void>;
+    recall(request: RecallRequest): Promise<RecallResultItem[]>;
+    list(filter: MemoryListFilter): Promise<MemoryRecord[]>;
+}
+export interface MemoryProposalStore {
+    createProposal(proposal: MemoryProposal): Promise<MemoryProposal>;
+    listProposals(filter?: {
+        status?: MemoryProposal['status'];
+        limit?: number;
+    }): Promise<MemoryProposal[]>;
+}

package/dist/memory/redaction.d.ts

@@ -0,0 +1,7 @@
+export interface SecretFinding {
+    type: string;
+    match: string;
+}
+export declare function findSecrets(text: string): SecretFinding[];
+export declare function containsSecret(text: string): boolean;
+export declare function redactSecrets(text: string): string;

package/dist/memory/schema.d.ts

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+import type { MemoryKind, MemoryProposal, MemoryRecord, MemoryScopeRef } from './types';
+export declare const MemoryScopeTypeSchema: z.ZodEnum<{
+    agent: "agent";
+    project: "project";
+    run: "run";
+    global_user: "global_user";
+    workspace: "workspace";
+    repository: "repository";
+}>;
+export declare const MemoryScopeRefSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        agent: "agent";
+        project: "project";
+        run: "run";
+        global_user: "global_user";
+        workspace: "workspace";
+        repository: "repository";
+    }>;
+    userId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    repoId: z.ZodOptional<z.ZodString>;
+    repoRoot: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MemoryKindSchema: z.ZodEnum<{
+    evidence: "evidence";
+    todo: "todo";
+    user_preference: "user_preference";
+    project_fact: "project_fact";
+    architecture_decision: "architecture_decision";
+    repo_convention: "repo_convention";
+    api_finding: "api_finding";
+    code_pattern: "code_pattern";
+    test_pattern: "test_pattern";
+    failure_pattern: "failure_pattern";
+    security_note: "security_note";
+    scratch: "scratch";
+}>;
+export declare const MemorySourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        agent: "agent";
+        file: "file";
+        manual: "manual";
+        test: "test";
+        tool: "tool";
+        user: "user";
+        commit: "commit";
+        repo: "repo";
+        web: "web";
+    }>;
+    ref: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    commitSha: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MemoryRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        type: z.ZodEnum<{
+            agent: "agent";
+            project: "project";
+            run: "run";
+            global_user: "global_user";
+            workspace: "workspace";
+            repository: "repository";
+        }>;
+        userId: z.ZodOptional<z.ZodString>;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        repoId: z.ZodOptional<z.ZodString>;
+        repoRoot: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    kind: z.ZodEnum<{
+        evidence: "evidence";
+        todo: "todo";
+        user_preference: "user_preference";
+        project_fact: "project_fact";
+        architecture_decision: "architecture_decision";
+        repo_convention: "repo_convention";
+        api_finding: "api_finding";
+        code_pattern: "code_pattern";
+        test_pattern: "test_pattern";
+        failure_pattern: "failure_pattern";
+        security_note: "security_note";
+        scratch: "scratch";
+    }>;
+    text: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    confidence: z.ZodNumber;
+    stability: z.ZodEnum<{
+        session: "session";
+        ephemeral: "ephemeral";
+        durable: "durable";
+    }>;
+    source: z.ZodObject<{
+        type: z.ZodEnum<{
+            agent: "agent";
+            file: "file";
+            manual: "manual";
+            test: "test";
+            tool: "tool";
+            user: "user";
+            commit: "commit";
+            repo: "repo";
+            web: "web";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        filePath: z.ZodOptional<z.ZodString>;
+        commitSha: z.ZodOptional<z.ZodString>;
+        createdBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastAccessedAt: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    supersededBy: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const MemoryProposalSchema: z.ZodObject<{
+    id: z.ZodString;
+    operation: z.ZodEnum<{
+        ignore: "ignore";
+        add: "add";
+        delete: "delete";
+        update: "update";
+        merge: "merge";
+        supersede: "supersede";
+    }>;
+    proposedRecord: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        scope: z.ZodObject<{
+            type: z.ZodEnum<{
+                agent: "agent";
+                project: "project";
+                run: "run";
+                global_user: "global_user";
+                workspace: "workspace";
+                repository: "repository";
+            }>;
+            userId: z.ZodOptional<z.ZodString>;
+            workspaceId: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            repoId: z.ZodOptional<z.ZodString>;
+            repoRoot: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        kind: z.ZodEnum<{
+            evidence: "evidence";
+            todo: "todo";
+            user_preference: "user_preference";
+            project_fact: "project_fact";
+            architecture_decision: "architecture_decision";
+            repo_convention: "repo_convention";
+            api_finding: "api_finding";
+            code_pattern: "code_pattern";
+            test_pattern: "test_pattern";
+            failure_pattern: "failure_pattern";
+            security_note: "security_note";
+            scratch: "scratch";
+        }>;
+        text: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        confidence: z.ZodNumber;
+        stability: z.ZodEnum<{
+            session: "session";
+            ephemeral: "ephemeral";
+            durable: "durable";
+        }>;
+        source: z.ZodObject<{
+            type: z.ZodEnum<{
+                agent: "agent";
+                file: "file";
+                manual: "manual";
+                test: "test";
+                tool: "tool";
+                user: "user";
+                commit: "commit";
+                repo: "repo";
+                web: "web";
+            }>;
+            ref: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            filePath: z.ZodOptional<z.ZodString>;
+            commitSha: z.ZodOptional<z.ZodString>;
+            createdBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        lastAccessedAt: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+        contentHash: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>;
+    targetMemoryId: z.ZodOptional<z.ZodString>;
+    relatedMemoryIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    proposedBy: z.ZodObject<{
+        agentRole: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    rationale: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        pending: "pending";
+        applied: "applied";
+        superseded: "superseded";
+    }>;
+    reviewer: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        controller: "controller";
+        curator_agent: "curator_agent";
+        auto_policy: "auto_policy";
+    }>>;
+    reviewedAt: z.ZodOptional<z.ZodString>;
+    rejectionReason: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export declare function normalizeMemoryText(text: string): string;
+export declare function stableScopeKey(scope: MemoryScopeRef): string;
+export declare function computeMemoryContentHash(recordLike: {
+    scope: MemoryScopeRef;
+    kind: MemoryKind;
+    text: string;
+}): string;
+export declare function createMemoryId(recordLike: {
+    scope: MemoryScopeRef;
+    kind: MemoryKind;
+    text: string;
+}): string;
+export declare function createProposalId(input: {
+    createdAt: string;
+    proposer: string;
+    text: string;
+}): string;
+export declare function createBundleId(query: string, generatedAt: string): string;
+export declare function isExpired(record: MemoryRecord, now?: Date): boolean;
+export declare function hasEvidenceSource(record: MemoryRecord): boolean;
+export declare function validateMemoryRecordRules(record: MemoryRecord, options: {
+    rejectDurableSecrets: boolean;
+}): MemoryRecord;
+export declare function validateMemoryProposal(proposal: MemoryProposal): MemoryProposal;

package/dist/memory/scoring.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryRecord, MemoryScopeRef, RecallRequest, RecallResultItem } from './types';
+export declare function sameScope(a: MemoryScopeRef, b: MemoryScopeRef): boolean;
+export declare function scopeAllowed(recordScope: MemoryScopeRef, allowedScopes: MemoryScopeRef[]): boolean;
+export declare function scoreMemoryRecord(record: MemoryRecord, request: RecallRequest): RecallResultItem | null;
+export declare function scoreMemoryRecords(records: MemoryRecord[], request: RecallRequest): RecallResultItem[];

package/dist/memory/types.d.ts

@@ -0,0 +1,96 @@
+export type MemoryScopeType = 'global_user' | 'workspace' | 'project' | 'repository' | 'run' | 'agent';
+export interface MemoryScopeRef {
+    type: MemoryScopeType;
+    userId?: string;
+    workspaceId?: string;
+    projectId?: string;
+    repoId?: string;
+    repoRoot?: string;
+    runId?: string;
+    agentId?: string;
+}
+export type MemoryKind = 'user_preference' | 'project_fact' | 'architecture_decision' | 'repo_convention' | 'api_finding' | 'code_pattern' | 'test_pattern' | 'failure_pattern' | 'security_note' | 'evidence' | 'todo' | 'scratch';
+export interface MemorySource {
+    type: 'user' | 'agent' | 'tool' | 'file' | 'repo' | 'commit' | 'test' | 'web' | 'manual';
+    ref?: string;
+    url?: string;
+    filePath?: string;
+    commitSha?: string;
+    createdBy?: string;
+}
+export interface MemoryRecord {
+    id: string;
+    scope: MemoryScopeRef;
+    kind: MemoryKind;
+    text: string;
+    tags: string[];
+    confidence: number;
+    stability: 'ephemeral' | 'session' | 'durable';
+    source: MemorySource;
+    createdAt: string;
+    updatedAt: string;
+    lastAccessedAt?: string;
+    expiresAt?: string;
+    supersedes?: string[];
+    supersededBy?: string;
+    contentHash: string;
+    metadata: Record<string, unknown>;
+}
+export interface MemoryProposal {
+    id: string;
+    operation: 'add' | 'update' | 'delete' | 'ignore' | 'merge' | 'supersede';
+    proposedRecord?: MemoryRecord;
+    targetMemoryId?: string;
+    relatedMemoryIds?: string[];
+    proposedBy: {
+        agentRole?: string;
+        agentId?: string;
+        runId?: string;
+    };
+    rationale: string;
+    evidenceRefs: string[];
+    status: 'pending' | 'approved' | 'rejected' | 'superseded' | 'applied';
+    reviewer?: 'user' | 'controller' | 'curator_agent' | 'auto_policy';
+    reviewedAt?: string;
+    rejectionReason?: string;
+    createdAt: string;
+    metadata: Record<string, unknown>;
+}
+export interface RecallRequest {
+    query: string;
+    task?: string;
+    agentRole?: string;
+    scopes: MemoryScopeRef[];
+    kinds?: MemoryKind[];
+    maxItems: number;
+    tokenBudget: number;
+    minScore?: number;
+    includeExpired?: boolean;
+    includePendingProposals?: boolean;
+}
+export interface RecallResultItem {
+    record: MemoryRecord;
+    score: number;
+    reason: string;
+}
+export interface RecallBundle {
+    id: string;
+    query: string;
+    generatedAt: string;
+    items: RecallResultItem[];
+    tokenEstimate: number;
+    promptBlock: string;
+}
+export interface MemoryContext {
+    directory: string;
+    sessionID?: string;
+    agentRole?: string;
+    agentId?: string;
+    runId?: string;
+}
+export interface MemoryListFilter {
+    scopes?: MemoryScopeRef[];
+    kinds?: MemoryKind[];
+    includeExpired?: boolean;
+    limit?: number;
+}

package/dist/tools/index.d.ts

@@ -50,7 +50,9 @@ export { skill_inspect } from './skill-inspect';
 export { skill_list } from './skill-list';
 export { spec_write } from './spec-write';
 export { submit_phase_council_verdicts } from './submit-phase-council-verdicts';
-export { createSwarmCommandTool } from './swarm-command';
+export { createSwarmCommandTool, swarm_command } from './swarm-command';
+export { swarm_memory_propose } from './swarm-memory-propose';
+export { swarm_memory_recall } from './swarm-memory-recall';
 import { suggestPatch } from './suggest-patch';
 export { suggestPatch };
 export type { SuggestPatchArgs } from './suggest-patch';

package/dist/tools/swarm-command.d.ts

@@ -1,3 +1,4 @@
 import type { AgentDefinition } from '../agents/index.js';
 import { createSwarmTool } from './create-tool.js';
 export declare function createSwarmCommandTool(agents: Record<string, AgentDefinition>): ReturnType<typeof createSwarmTool>;
+export declare const swarm_command: ReturnType<typeof createSwarmTool>;

package/dist/tools/swarm-memory-propose.d.ts

@@ -0,0 +1,8 @@
+import { loadPluginConfigWithMeta } from '../config';
+import { createMemoryGateway } from '../memory';
+import { createSwarmTool } from './create-tool';
+export declare const swarm_memory_propose: ReturnType<typeof createSwarmTool>;
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+    createMemoryGateway: typeof createMemoryGateway;
+};

package/dist/tools/swarm-memory-recall.d.ts

@@ -0,0 +1,8 @@
+import { loadPluginConfigWithMeta } from '../config';
+import { createMemoryGateway } from '../memory';
+import { createSwarmTool } from './create-tool';
+export declare const swarm_memory_recall: ReturnType<typeof createSwarmTool>;
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+    createMemoryGateway: typeof createMemoryGateway;
+};

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

@@ -3,7 +3,7 @@
  * 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' | 'submit_phase_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' | 'write_final_council_evidence' | 'skill_generate' | 'skill_list' | 'skill_apply' | 'skill_inspect' | 'skill_improve' | 'spec_write' | 'knowledge_ack' | 'swarm_command' | 'lean_turbo_plan_lanes' | 'lean_turbo_acquire_locks' | 'lean_turbo_runner_status' | 'lean_turbo_review' | 'lean_turbo_run_phase' | 'lean_turbo_status';
+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' | 'submit_phase_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' | 'write_final_council_evidence' | 'skill_generate' | 'skill_list' | 'skill_apply' | 'skill_inspect' | 'skill_improve' | 'spec_write' | 'knowledge_ack' | 'swarm_memory_recall' | 'swarm_memory_propose' | 'swarm_command' | 'lean_turbo_plan_lanes' | 'lean_turbo_acquire_locks' | 'lean_turbo_runner_status' | 'lean_turbo_review' | 'lean_turbo_run_phase' | 'lean_turbo_status';
 /** Readonly array of all tool names */
 export declare const TOOL_NAMES: readonly ToolName[];
 /** Set for O(1) tool name validation */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.29.4",
+	"version": "7.30.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",