opencode-swarm 7.31.0 → 7.32.1

package/dist/agents/agent-output-schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { ProposeMemoryInput } from '../memory/gateway';
+export declare const AgentOutputMemorySchema: z.ZodObject<{
+    memoryProposals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            ignore: "ignore";
+            add: "add";
+            delete: "delete";
+            update: "update";
+            merge: "merge";
+            supersede: "supersede";
+        }>;
+        kind: z.ZodOptional<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.ZodOptional<z.ZodString>;
+        targetMemoryId: z.ZodOptional<z.ZodString>;
+        relatedMemoryIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rationale: z.ZodString;
+        evidenceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$loose>;
+export interface ExtractedAgentMemoryProposals {
+    proposals: ProposeMemoryInput[];
+    error?: string;
+}
+export declare function extractMemoryProposalsFromAgentOutput(outputText: string): ExtractedAgentMemoryProposals;

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.31.0",
+    version: "7.32.1",
     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/config/schema.d.ts

@@ -287,8 +287,8 @@ export type ReviewPassesConfig = z.infer<typeof ReviewPassesConfigSchema>;
 export declare const AdversarialDetectionConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     policy: z.ZodDefault<z.ZodEnum<{
-        gate: "gate";
         ignore: "ignore";
+        gate: "gate";
         warn: "warn";
     }>>;
     pairs: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
@@ -1053,8 +1053,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
     adversarial_detection: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         policy: z.ZodDefault<z.ZodEnum<{
-            gate: "gate";
             ignore: "ignore";
+            gate: "gate";
             warn: "warn";
         }>>;
         pairs: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;

package/dist/council/council-evidence-writer.d.ts

@@ -14,5 +14,14 @@
  * filename; defense-in-depth regex validation rejects malformed IDs before
  * any filesystem op.
  */
+import { withTaskEvidenceLock } from '../evidence/task-file.js';
 import type { CouncilSynthesis } from './types';
-export declare function writeCouncilEvidence(workingDir: string, synthesis: CouncilSynthesis): void;
+/**
+ * Dependency-injection seam for testing. Tests can temporarily replace
+ * `withTaskEvidenceLock` to exercise error paths (e.g. EvidenceLockTimeoutError)
+ * without mock.module leakage. Restore the entry in afterEach.
+ */
+export declare const _internals: {
+    withTaskEvidenceLock: typeof withTaskEvidenceLock;
+};
+export declare function writeCouncilEvidence(workingDir: string, synthesis: CouncilSynthesis): Promise<void>;

package/dist/evidence/task-file.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared write primitives for the flat task-scoped evidence file
+ * `.swarm/evidence/{taskId}.json`.
+ *
+ * This file is the single source of truth for *where* the flat task evidence
+ * file lives and *how* it is written safely. Multiple writers target the same
+ * `{taskId}.json` (the delegation-gate hook via `gate-evidence.ts`, and the
+ * Work-Complete council via `council-evidence-writer.ts`). They MUST coordinate
+ * through the same lock key and use the same atomic temp-file+rename write, or
+ * one writer's read-modify-write can clobber the other's (lost update) or
+ * observe a torn file.
+ *
+ * The lock is keyed by the *relative* evidence path, so every writer has to
+ * pass the identical relative path to `withEvidenceLock`. Centralizing that
+ * derivation here (`taskEvidenceRelPath`) guarantees the keys match.
+ *
+ * This module deliberately holds no schema/validation logic — each caller keeps
+ * its own taskId validation and read/merge semantics.
+ */
+import { renameSync, unlinkSync } from 'node:fs';
+/**
+ * Relative path (under `.swarm/`) of the flat task evidence file.
+ * This is also the lock key — it MUST be identical across all writers to the
+ * same task file so their locks coordinate.
+ */
+export declare function taskEvidenceRelPath(taskId: string): string;
+/** Absolute path of the flat task evidence file under `<directory>/.swarm/`. */
+export declare function taskEvidencePath(directory: string, taskId: string): string;
+/**
+ * Dependency-injection seam for testing. Tests can temporarily replace these
+ * to exercise failure paths (e.g. EPERM on renameSync) without mock.module leakage.
+ * Restore each entry in afterEach via the saved original reference.
+ */
+export declare const _internals: {
+    renameSync: typeof renameSync;
+    unlinkSync: typeof unlinkSync;
+};
+/**
+ * Atomic write: write to a unique temp file, then rename over the target.
+ * The rename is atomic on POSIX and Windows, so readers never observe a torn
+ * file. The temp file is cleaned up in `finally` (no-op once renamed away).
+ */
+export declare function atomicWriteFile(targetPath: string, content: string): Promise<void>;
+/**
+ * Acquire the exclusive lock for a task's flat evidence file, run `fn`, release.
+ * Thin wrapper over `withEvidenceLock` that fixes the lock-key convention so all
+ * writers to `{taskId}.json` serialize against each other.
+ */
+export declare function withTaskEvidenceLock<T>(directory: string, taskId: string, agent: string, fn: () => Promise<T>): Promise<T>;