opencode-swarm 7.177.1 → 7.178.0

package/dist/mcp/adapters/knowledge-add.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Explicitly-authorized MCP knowledge_add adapter (#2500).
+ *
+ * This adapter owns only the MCP idempotency boundary. Validation,
+ * actionability, deduplication, reinforcement, quarantine, and the atomic
+ * knowledge transaction remain in the registered production knowledge_add
+ * tool. The adapter passes a fixed server root and never accepts a
+ * working-directory override.
+ */
+import { type KnowledgeAddAdapterRuntime, knowledgeAddInput } from '../write-receipts.js';
+export interface McpKnowledgeAddWriteAdapter {
+    name: 'knowledge_add';
+    kind: 'write';
+    pathFields: string[];
+    inputSchema: typeof knowledgeAddInput;
+    execute(rawArgs: unknown, root: string, runtime?: KnowledgeAddAdapterRuntime): Promise<unknown>;
+}
+export declare function executeKnowledgeAdd(rawArgs: unknown, root: string, runtime?: KnowledgeAddAdapterRuntime): Promise<unknown>;
+export declare const knowledgeAddAdapter: McpKnowledgeAddWriteAdapter;

package/dist/mcp/adapters/receipt-status.d.ts

@@ -0,0 +1,3 @@
+/** Read-only MCP status probe for explicitly-authorized knowledge writes. */
+import type { McpReadTool } from '../registry.js';
+export declare const receiptStatusAdapter: McpReadTool;

package/dist/mcp/adapters/scope-validation.d.ts

@@ -0,0 +1,3 @@
+/** Read-only MCP adapter for the inline shell-write scope advisory (#2500). */
+import type { McpReadTool } from '../registry.js';
+export declare const scopeValidationAdapter: McpReadTool;

package/dist/mcp/registry.d.ts

@@ -1,5 +1,5 @@
 /**
- * Tool registry for the read-only MCP verification surface (#2499).
+ * Tool registry for the MCP verification surface (#2499, #2500).
  *
  * `buildMcpToolRegistry` composes the read-only tool set for ONE configured
  * project root. Descriptions are sourced from `TOOL_METADATA` — the same
@@ -7,21 +7,20 @@
  * registered tool names with exact description parity (frozen by
  * repro/check-mcp-registry-capability-coverage.sh, C2).
  *
- * The write boundary is fail-closed (frozen by
- * repro/check-mcp-readonly-default-no-writes.sh, C6): every tool name is
- * validated against a write-capable denylist and a match THROWS — with or
- * without `allowWrite`. Phase 1 ships zero write tools; `allowWrite` is the
- * documented forward-compat seam for the #2500 write surface and adds
- * nothing today.
+ * The write boundary is fail-closed: a write is present only when the caller
+ * supplies both the startup capability flag and an exact reviewed tool name.
+ * The positive allowlist below is checked again here (rather than trusting the
+ * CLI) so direct programmatic callers cannot widen the MCP surface.
  */
 import type { z } from 'zod';
+import type { KnowledgeAddAdapterRuntime } from './write-receipts.js';
 /** Write-capable tool-name shapes. Mirrors the frozen C6 denylist. */
 export declare const WRITE_TOOL_NAME_PATTERN: RegExp;
 export interface McpReadTool {
     /** Registered plugin tool name (a TOOL_METADATA key). */
     name: string;
     /** Exact TOOL_METADATA description (parity assigned at build time). */
-    description: string;
+    description?: string;
     kind: 'read';
     /** Argument field names carrying file-path values (containment-checked). */
     pathFields: string[];
@@ -29,19 +28,32 @@ export interface McpReadTool {
     inputSchema: z.ZodObject<z.ZodRawShape>;
     execute(args: Record<string, unknown>, root: string): Promise<unknown>;
 }
+export interface McpWriteTool {
+    /** Registered plugin tool name (a TOOL_METADATA key). */
+    name: string;
+    /** Exact TOOL_METADATA description (parity assigned at build time). */
+    description?: string;
+    kind: 'write';
+    /** Argument field names carrying file-path values (containment-checked). */
+    pathFields: string[];
+    /** MCP input schema (mirrors the reviewed tool's zod args). */
+    inputSchema: z.ZodObject<z.ZodRawShape>;
+    execute(args: Record<string, unknown>, root: string, runtime?: KnowledgeAddAdapterRuntime): Promise<unknown>;
+}
+export type McpTool = McpReadTool | McpWriteTool;
 export interface McpToolRegistry {
-    tools: McpReadTool[];
+    tools: McpTool[];
 }
 export interface BuildMcpToolRegistryOptions {
     /** The single configured project root (one server = one root). */
     root: string;
     /** Alias for `root` (accepted for harness compatibility). */
     directory?: string;
-    /**
-     * Forward-compat seam for the #2500 explicitly-authorized write surface.
-     * Phase 1 has no write tools, so this flag never adds anything; the
-     * write-name denylist stays fail-closed either way.
-     */
+    /** Startup capability gate. This flag alone never registers a write. */
     allowWrite?: boolean;
+    /** Exact reviewed write names authorized for this server instance. */
+    writeTools?: string[];
 }
+/** The only MCP write adapter reviewed and shipped by #2500. */
+export declare const REVIEWED_MCP_WRITE_TOOLS: readonly ["knowledge_add"];
 export declare function buildMcpToolRegistry(options: BuildMcpToolRegistryOptions): McpToolRegistry;

package/dist/mcp/server.d.ts

@@ -8,6 +8,7 @@
  * the response pipeline before it leaves the server.
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { KnowledgeAddAdapterRuntime } from './write-receipts.js';
 /** Containment rejection carried as a tool-level error result. */
 export declare class McpContainmentError extends Error {
     readonly field: string;
@@ -20,6 +21,10 @@ export declare function validatePathField(field: string, value: unknown, root: s
 export interface RunMcpServerOptions {
     root: string;
     allowWrite?: boolean;
+    /** Exact reviewed write names authorized for this server instance. */
+    writeTools?: string[];
+    /** Test-only receipt fault and clock hooks. */
+    writeHooks?: KnowledgeAddAdapterRuntime['hooks'];
     /** Test seam: inject transports instead of stdio (InMemoryTransport pair). */
     transport?: {
         connect(server: unknown): Promise<void>;

package/dist/mcp/write-receipts.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Durable settlement receipts for explicitly-authorized MCP writes (#2500).
+ *
+ * The receipt journal is deliberately a separate durability domain from the
+ * knowledge store. Its lock is held only while looking up or appending a
+ * receipt. A production mutation is always made after PREPARED is durable and
+ * outside that lock, so the journal cannot be nested with the knowledge-store
+ * transaction lock.
+ */
+import { z } from 'zod';
+export declare const MCP_WRITE_RECEIPTS_RELATIVE_PATH: string;
+/**
+ * Terminal receipt history is moved here when the active journal reaches its
+ * bounded record count. Unresolved records remain active; if an active rewrite
+ * fails after archive rotation, a best-effort recovery shadow is written so a
+ * newly prepared attempt cannot disappear before mutation.
+ */
+export declare const MCP_WRITE_RECEIPTS_ARCHIVE_RELATIVE_PATH: string;
+export declare const PREPARED_LEASE_MS = 30000;
+export declare const MAX_RECEIPT_RECORDS = 500;
+export declare const MAX_RECEIPT_ARCHIVE_RECORDS = 10000;
+export declare const MAX_RECEIPT_LINE_BYTES = 16384;
+export declare const MAX_RECEIPT_JOURNAL_BYTES: number;
+export declare const MAX_RECEIPT_ARCHIVE_BYTES: number;
+export declare const MAX_RECEIPT_RESPONSE_BYTES: number;
+/** Immutable receipt identity version for the reviewed knowledge_add policy. */
+export declare const KNOWLEDGE_ADD_POLICY_VERSION = "knowledge_add:v1";
+export declare const writeReceiptStatusInput: z.ZodObject<{
+    idempotency_key: z.ZodString;
+}, z.core.$strip>;
+export declare const WRITE_RECEIPT_STATES: readonly ["PREPARED", "COMMITTED", "FAILED_NO_EFFECT", "IN_DOUBT"];
+export type WriteReceiptState = (typeof WRITE_RECEIPT_STATES)[number];
+export interface WriteReceiptRecord {
+    version: 1;
+    receipt_id: string;
+    attempt_id: string;
+    tool: string;
+    root_hash: string;
+    idempotency_hash: string;
+    arguments_digest: string;
+    policy_digest: string;
+    state: WriteReceiptState;
+    prepared_at: number;
+    updated_at: number;
+    lease_expires_at: number;
+    response?: string;
+    error?: string;
+}
+export interface WriteReceiptHooks {
+    /**
+     * Test-only fault seam. It is invoked before each durable transition. The
+     * supplied record is already sanitized and contains no raw request fields.
+     */
+    persistReceipt?: (receipt: WriteReceiptRecord) => Promise<void>;
+    /**
+     * Test-only fault/order seam. It is invoked immediately before each
+     * physical archive or active-journal rewrite. The records are sanitized
+     * receipt records and the callback may throw to model an I/O failure.
+     */
+    persistStorage?: (kind: 'archive' | 'active', records: readonly WriteReceiptRecord[]) => Promise<void>;
+    /** Test-only interruption seam after PREPARED is durable. */
+    afterPrepare?: (receipt: WriteReceiptRecord) => Promise<void>;
+    /** Test-only interruption seam after the production call returns. */
+    afterMutation?: (receipt: WriteReceiptRecord) => Promise<void>;
+    /** Test-only clock seam. Production uses Date.now. */
+    now?: () => number;
+}
+export interface WriteReceiptRequest {
+    root: string;
+    tool: string;
+    idempotencyKey: string;
+    arguments: unknown;
+    policy?: string;
+}
+export type PrepareReceiptResult = {
+    kind: 'prepared';
+    receipt: WriteReceiptRecord;
+} | {
+    kind: 'replay';
+    receipt: WriteReceiptRecord;
+    response: unknown;
+} | {
+    kind: 'in_progress' | 'in_doubt';
+    receipt: WriteReceiptRecord;
+} | {
+    kind: 'conflict';
+    receipt: WriteReceiptRecord;
+    response: unknown;
+};
+export declare class WriteReceiptError extends Error {
+    readonly code: 'INVALID_REQUEST' | 'JOURNAL_UNAVAILABLE' | 'JOURNAL_CORRUPT' | 'JOURNAL_CAPACITY' | 'TRANSITION_REJECTED';
+    constructor(code: WriteReceiptError['code'], message: string);
+}
+export declare function getWriteReceiptPath(root: string): string;
+export declare function getWriteReceiptArchivePath(root: string): string;
+export declare function canonicalArguments(value: unknown): string;
+export declare function computeWriteReceiptIdentity(request: WriteReceiptRequest): Pick<WriteReceiptRecord, 'root_hash' | 'idempotency_hash' | 'arguments_digest' | 'policy_digest'>;
+export interface WriteReceiptStatus {
+    found: boolean;
+    status: WriteReceiptState | 'NOT_FOUND';
+    tool?: string;
+    receipt_id?: string;
+    attempt_id?: string;
+    updated_at?: number;
+    lease_expires_at?: number;
+    archived?: boolean;
+    /** A missing receipt is safe to submit; every recorded state is not. */
+    retryable: boolean;
+}
+export declare function sanitizeReceiptResponse(value: unknown, request?: Pick<WriteReceiptRequest, 'root' | 'idempotencyKey' | 'arguments'>): string;
+export declare function parseReceiptResponse(response: string): unknown;
+/**
+ * Read the latest status for one knowledge_add idempotency key without
+ * creating a lock or any other project state. Response/error payloads are
+ * intentionally omitted: this surface is only an uncertainty/replay probe.
+ */
+export declare function readWriteReceiptStatus(root: string, idempotencyKey: string): Promise<WriteReceiptStatus>;
+/**
+ * Add fixed receipt metadata to a bounded stored response. The production
+ * result remains intact, including success:false; no receipt IDs or request
+ * fields are exposed to the MCP client.
+ */
+export declare function addReplayMarker(value: unknown): unknown;
+/**
+ * Look up or durably prepare one write attempt. The returned PREPARED record
+ * owns the attempt. Callers MUST release the receipt transition lock before
+ * invoking production code, then call commitReceipt or markInDoubt.
+ */
+export declare function prepareReceipt(request: WriteReceiptRequest, hooks?: WriteReceiptHooks): Promise<PrepareReceiptResult>;
+export declare function commitReceipt(request: WriteReceiptRequest, attempt: WriteReceiptRecord, response: unknown, hooks?: WriteReceiptHooks): Promise<WriteReceiptRecord>;
+export declare function markInDoubt(request: WriteReceiptRequest, attempt: WriteReceiptRecord, error: string, hooks?: WriteReceiptHooks): Promise<WriteReceiptRecord>;
+/**
+ * Adapter-facing execution helper. It owns the prepare/call/settle sequence
+ * but accepts the production operation as a callback so the registry can
+ * provide knowledge_add without duplicating its logic.
+ */
+export declare function executeWithReceipt<T>(request: WriteReceiptRequest, operation: () => Promise<T>, hooks?: WriteReceiptHooks): Promise<unknown>;
+export declare const knowledgeAddInput: z.ZodObject<{
+    idempotency_key: z.ZodString;
+    lesson: z.ZodString;
+    category: z.ZodEnum<{
+        security: "security";
+        other: "other";
+        process: "process";
+        architecture: "architecture";
+        tooling: "tooling";
+        testing: "testing";
+        debugging: "debugging";
+        performance: "performance";
+        integration: "integration";
+        todo: "todo";
+    }>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodString>;
+    applies_to_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    applies_to_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    required_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    forbidden_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    verification_checks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export interface KnowledgeAddAdapterRuntime {
+    hooks?: WriteReceiptHooks;
+    policy?: string;
+}
+export declare function buildKnowledgeAddRequest(root: string, rawArgs: unknown, runtime?: KnowledgeAddAdapterRuntime): {
+    request: WriteReceiptRequest;
+    productionArgs: Record<string, unknown>;
+};

package/dist/summaries/index.d.ts

@@ -1,2 +1,2 @@
-export { cleanupSummaries, listSummaries, loadFullOutput, storeSummary, } from './manager';
+export { allocateSummaryId, cleanupSummaries, listSummaries, loadFullOutput, SummaryIdCollisionError, storeSummary, } from './manager';
 export { createSummary, detectContentType, HYSTERESIS_FACTOR, shouldSummarize, } from './summarizer';

package/dist/summaries/manager.d.ts

@@ -5,9 +5,20 @@
  * @throws Error with descriptive message on failure
  */
 export declare function sanitizeSummaryId(id: string): string;
+/**
+ * Typed collision signal for the no-overwrite store contract (issue #2576):
+ * the destination summary entry already exists and must never be replaced.
+ * Callers distinguish this from storage errors by `instanceof` (or `name`).
+ */
+export declare class SummaryIdCollisionError extends Error {
+    readonly summaryId: string;
+    constructor(summaryId: string);
+}
 /**
  * Store a summary entry to .swarm/summaries/{id}.json.
- * Performs atomic write via temp file + rename.
+ * Performs an atomic, no-overwrite install: temp file + exclusive
+ * hard-link install. Throws {@link SummaryIdCollisionError} if an entry
+ * with this ID already exists (it is never replaced — issue #2576).
  * @throws Error if summary ID is invalid or size limit would be exceeded
  */
 export declare function storeSummary(directory: string, id: string, fullOutput: string, summaryText: string, maxStoredBytes: number): Promise<void>;
@@ -26,6 +37,21 @@ export declare function loadFullOutput(directory: string, id: string): Promise<s
  * directory directly so stale files beyond the newest N are still pruned.
  */
 export declare const MAX_SUMMARIES_LISTED = 500;
+/**
+ * Durable summary ID allocation (issue #2576): returns the next free numeric
+ * ID (`S<max+1>`) derived from the entries that actually exist on disk, so a
+ * restarted process continues after persisted IDs instead of reusing `S1`.
+ *
+ * The scan uses the strict write-side grammar (`^S\d+`) via
+ * {@link enumerateSummaryIds} — large timestamp-suffixed IDs (e.g. Stage A's
+ * `S<ms><random>`) match and are included; filenames outside the grammar are
+ * ignored. The max is computed with BigInt so 16-digit IDs stay exact past
+ * 2^53 (a float max could alias two distinct large IDs and hand the retry
+ * loop an already-occupied slot); `max + 1n` always stringifies back to a
+ * valid `^S\d+$` ID, and leading-zero legacy entries (`S007`) normalize
+ * numerically so allocation never regresses.
+ */
+export declare function allocateSummaryId(directory: string): string;
 /**
  * List summary IDs that have summary entries, newest-first (mtime
  * descending, code-unit filename tie-break), capped at

package/dist/tools/index.d.ts

@@ -42,6 +42,7 @@ export { knowledge_archive } from './knowledge-archive';
 export { knowledge_query } from './knowledge-query';
 export { knowledge_recall } from './knowledge-recall';
 export { knowledge_receipt } from './knowledge-receipt';
+export { knowledge_receipt_status } from './knowledge-receipt-status';
 export { knowledge_remove } from './knowledge-remove';
 export { lint } from './lint';
 export { osv_scan } from './osv-scan';
@@ -68,6 +69,7 @@ export type { SavePlanArgs, SavePlanResult } from './save-plan';
 export { save_plan } from './save-plan';
 export { type SbomGenerateInput, type SbomGenerateResult, sbom_generate, } from './sbom-generate';
 export { schema_drift } from './schema-drift';
+export { evaluateScopeValidate, type ScopeValidateArgs, type ScopeValidateResult, ScopeValidationError, scope_validate, } from './scope-validate';
 export { search } from './search';
 export { type SecretFinding, type SecretscanResult, secretscan, } from './secretscan';
 export { set_qa_gates } from './set-qa-gates';

package/dist/tools/knowledge-receipt-status.d.ts

@@ -0,0 +1,8 @@
+/** Read-only status for an explicitly-authorized MCP knowledge write receipt. */
+import { createSwarmTool } from './create-tool.js';
+export declare const knowledge_receipt_status: ReturnType<typeof createSwarmTool>;
+export declare const _test_exports: {
+    writeReceiptStatusInput: import("zod").ZodObject<{
+        idempotency_key: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+};

package/dist/tools/manifest.d.ts

@@ -90,6 +90,7 @@ export declare const TOOL_MANIFEST: {
     write_hallucination_evidence: () => ToolDefinition;
     write_mutation_evidence: () => ToolDefinition;
     declare_scope: () => ToolDefinition;
+    scope_validate: () => ToolDefinition;
     knowledge_query: () => ToolDefinition;
     doc_scan: () => ToolDefinition;
     doc_extract: () => ToolDefinition;
@@ -127,6 +128,7 @@ export declare const TOOL_MANIFEST: {
     skill_improve: () => ToolDefinition;
     spec_write: () => ToolDefinition;
     knowledge_receipt: () => ToolDefinition;
+    knowledge_receipt_status: () => ToolDefinition;
     knowledge_archive: () => ToolDefinition;
     swarm_memory_recall: () => ToolDefinition;
     swarm_memory_propose: () => ToolDefinition;

package/dist/tools/scope-validate.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Read-only shell-write scope advisory for the MCP surface (#2500).
+ *
+ * This tool is deliberately an evaluator only. It never executes a command,
+ * publishes an OpenCode scope binding, or persists any state. The decision is
+ * composed from the same classifier, write detector, containment, and file
+ * authority helpers used by the live guardrails.
+ */
+import { z } from 'zod';
+import { createSwarmTool } from './create-tool';
+export declare const scopeValidateArgs: {
+    command: z.ZodString;
+    shell: z.ZodEnum<{
+        powershell: "powershell";
+        cmd: "cmd";
+        posix: "posix";
+    }>;
+    scope_files: z.ZodArray<z.ZodString>;
+};
+export declare const scopeValidateSchema: z.ZodObject<{
+    command: z.ZodString;
+    shell: z.ZodEnum<{
+        powershell: "powershell";
+        cmd: "cmd";
+        posix: "posix";
+    }>;
+    scope_files: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ScopeValidateArgs = {
+    command: string;
+    shell: 'posix' | 'powershell' | 'cmd';
+    scope_files: string[];
+};
+export interface ScopeValidateTarget {
+    category: string;
+    operator: string;
+    path: string;
+}
+export interface ScopeValidateResult {
+    allowed: true;
+    shell: ScopeValidateArgs['shell'];
+    command_digest: string;
+    targets: ScopeValidateTarget[];
+}
+export declare class ScopeValidationError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * Evaluate a shell command against an inline scope without executing it.
+ * Every filesystem path is checked against the supplied root and scope before
+ * a successful result is returned.
+ */
+export declare function evaluateScopeValidate(args: ScopeValidateArgs, directory: string): ScopeValidateResult;
+export declare const scope_validate: ReturnType<typeof createSwarmTool>;

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

@@ -373,6 +373,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    scope_validate: {
+        description: string;
+        agents: "architect"[];
+    };
     knowledge_query: {
         description: string;
         agents: ("architect" | "skill_improver" | "spec_writer")[];
@@ -541,6 +545,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_finding_validator" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "curator_init" | "curator_phase" | "skill_improver" | "spec_writer")[];
     };
+    knowledge_receipt_status: {
+        description: string;
+        agents: "architect"[];
+    };
     knowledge_archive: {
         description: string;
         agents: "architect"[];

package/dist/utils/path-security.d.ts

@@ -175,6 +175,27 @@ export declare function validateSymlinkBoundary(targetPath: string, rootPath: st
  * @returns true if the canonical target is within the canonical root
  */
 export declare function isCanonicalPathWithinRoot(targetPath: string, rootPath: string): boolean;
+/**
+ * Build a canonical containment checker for a single root.
+ *
+ * Scope validation may check thousands of entries against one workspace root.
+ * Calling `isCanonicalPathWithinRoot` for every entry re-resolves the same root
+ * and the same existing ancestors, which turns an otherwise linear validation
+ * into a synchronous filesystem bottleneck. This checker keeps the root and
+ * observed ancestors local to one evaluation, and only canonicalizes entries
+ * that are actually links. A regular entry beneath a non-link ancestor is
+ * already lexically inside the validated root; canonicalizing it adds no
+ * security signal. Missing entries still walk to the nearest existing
+ * ancestor, so a symlinked directory cannot be used to escape the root.
+ *
+ * The cache is deliberately per-checker (never module-global) and bounded.
+ */
+export declare function createCanonicalPathWithinRootChecker(rootPath: string): (targetPath: string) => boolean;
+/**
+ * Build a relative-target validator that reuses one canonical root and its
+ * observed ancestor cache across a batch of paths.
+ */
+export declare function createTargetWithinRootValidator(root: string): (filePath: string) => string | null;
 /**
  * Validate that a caller-supplied path stays within an allowed root directory.
  * Rejects empty paths, absolute paths (POSIX + Windows drive), traversal,

package/opencode-swarm.schema.json

@@ -5400,6 +5400,20 @@
         }
       },
       "additionalProperties": false
+    },
+    "dashboard": {
+      "description": "Opt-in local mission-control dashboard over durable swarm state (issue #2509). Disabled by default; set port > 0 to enable the loopback-only read-only view.",
+      "type": "object",
+      "properties": {
+        "port": {
+          "default": 0,
+          "description": "Loopback port for the opt-in local dashboard (issue #2509). 0 or absent = disabled (default).",
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 65535
+        }
+      },
+      "additionalProperties": false
     }
   },
   "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.177.1",
+	"version": "7.178.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",

package/dist/cli/curator-llm-factory-fywmb8jh.js

@@ -1,72 +0,0 @@
-// @bun
-import {
-  createCuratorLLMDelegate
-} from "./index-yepxmq4f.js";
-import"./index-hnvmj9wx.js";
-import"./index-vfp9hjgv.js";
-import"./index-fgv6qp10.js";
-import"./index-eefz8ghz.js";
-import"./index-1042jnb9.js";
-import"./index-4ygb35m1.js";
-import"./index-k6bjkqw8.js";
-import"./index-txdagbh7.js";
-import"./index-n1tcj1q7.js";
-import"./index-fpbcxykc.js";
-import"./index-qgf5xexz.js";
-import"./index-k330631a.js";
-import"./index-7c24bb1r.js";
-import"./index-fyfbpz4f.js";
-import"./index-eya03h5m.js";
-import"./index-549wxbe1.js";
-import"./index-zsrtt42s.js";
-import"./index-822hhbkc.js";
-import"./index-5d2avnj9.js";
-import"./index-7nsvszwn.js";
-import"./index-pt7h91zc.js";
-import"./index-q7sjgr1y.js";
-import"./index-fnq5ac3f.js";
-import"./index-j82xdrqp.js";
-import"./index-bqmxxbrw.js";
-import"./index-cv191ybt.js";
-import"./index-exhm2ztr.js";
-import"./index-2s7dvzff.js";
-import"./index-yrs4wwfq.js";
-import"./index-wemtrnch.js";
-import"./index-rtry5xyf.js";
-import"./index-67amf4my.js";
-import"./index-frcemc0b.js";
-import"./index-wrt875kh.js";
-import"./index-7ntcak58.js";
-import"./index-drgt81xf.js";
-import"./index-t2nf57mv.js";
-import"./index-v2he8xfj.js";
-import"./index-1bq6hkw5.js";
-import"./index-xnednxvm.js";
-import"./index-rdm3px0g.js";
-import"./index-ry16d01s.js";
-import"./index-tbswvz8s.js";
-import"./index-634pjhe4.js";
-import"./index-vzm6zre7.js";
-import"./index-ae75rja9.js";
-import"./index-en0p0hqp.js";
-import"./index-tj0sdxg9.js";
-import"./index-7g4c7s5r.js";
-import"./index-2jtmevrr.js";
-import"./index-yhaxn5r7.js";
-import"./index-1xnse449.js";
-import"./index-c1ggtmpm.js";
-import"./index-m0cdjvtv.js";
-import"./index-zz7gzw57.js";
-import"./index-4ddpvd5c.js";
-import"./index-e48h8m73.js";
-import"./index-n7nzwz0q.js";
-import"./index-bk5tah7q.js";
-import"./index-gknz3bv1.js";
-import"./index-zpsr8rpc.js";
-import"./index-76qm2c2y.js";
-import"./index-yzjaj53h.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  createCuratorLLMDelegate
-};