opencode-swarm 6.64.0 → 6.66.0

package/dist/agents/architect.d.ts

@@ -8,4 +8,21 @@ export interface AdversarialTestingConfig {
     enabled: boolean;
     scope: 'all' | 'security-only';
 }
-export declare function createArchitectAgent(model: string, customPrompt?: string, customAppendPrompt?: string, adversarialTesting?: AdversarialTestingConfig): AgentDefinition;
+/**
+ * Subset of PluginConfig.council needed to gate the Work Complete Council
+ * workflow block in the architect prompt. Only `enabled` is consumed here —
+ * runtime behavior (maxRounds, timeout, veto priority) is enforced elsewhere
+ * via the council tools and config. Keeping this shape narrow avoids pulling
+ * the full PluginConfig type into the agent-prompt layer.
+ */
+export interface CouncilWorkflowConfig {
+    enabled?: boolean;
+}
+/**
+ * Build the Work Complete Council four-phase workflow block. Returns the full
+ * block text when council.enabled === true, otherwise the empty string. The
+ * empty-string return path guarantees byte-for-byte non-regression when the
+ * council feature is off or the config key is absent.
+ */
+export declare function buildCouncilWorkflow(council?: CouncilWorkflowConfig): string;
+export declare function createArchitectAgent(model: string, customPrompt?: string, customAppendPrompt?: string, adversarialTesting?: AdversarialTestingConfig, council?: CouncilWorkflowConfig): AgentDefinition;

package/dist/cli/index.js

@@ -14825,7 +14825,14 @@ async function savePlan(directory, plan, options) {
   const planId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
   const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
-    await initLedger(directory, planId, planHashForInit, validated);
+    try {
+      await initLedger(directory, planId, planHashForInit, validated);
+    } catch (initErr) {
+      const msg = initErr instanceof Error ? initErr.message : String(initErr);
+      if (!/already initialized/i.test(msg)) {
+        throw initErr;
+      }
+    }
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
@@ -18470,6 +18477,8 @@ var TOOL_NAMES = [
   "evidence_check",
   "check_gate_status",
   "completion_verify",
+  "convene_council",
+  "declare_council_criteria",
   "sbom_generate",
   "checkpoint",
   "pkg_audit",
@@ -18526,6 +18535,8 @@ var AGENT_TOOL_MAP = {
     "checkpoint",
     "check_gate_status",
     "completion_verify",
+    "convene_council",
+    "declare_council_criteria",
     "complexity_hotspots",
     "detect_domains",
     "evidence_check",
@@ -19182,6 +19193,14 @@ var AuthorityConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   rules: exports_external.record(exports_external.string(), AgentAuthorityRuleSchema).default({})
 });
+var CouncilConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  maxRounds: exports_external.number().int().min(1).max(10).default(3),
+  parallelTimeoutMs: exports_external.number().int().min(5000).max(120000).default(30000),
+  vetoPriority: exports_external.boolean().default(true),
+  requireAllMembers: exports_external.boolean().default(false).describe("When true, convene_council rejects if fewer than 5 member verdicts are provided."),
+  escalateOnMaxRounds: exports_external.string().optional().describe("Optional webhook URL or handler name invoked when maxRounds is reached without APPROVE. Declared for forward compatibility; no behavior is implemented yet.")
+}).strict();
 var PluginConfigSchema = exports_external.object({
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
@@ -19229,6 +19248,7 @@ var PluginConfigSchema = exports_external.object({
   }).optional(),
   incremental_verify: IncrementalVerifyConfigSchema.optional(),
   compaction_service: CompactionConfigSchema.optional(),
+  council: CouncilConfigSchema.optional(),
   turbo_mode: exports_external.boolean().default(false).optional(),
   full_auto: exports_external.object({
     enabled: exports_external.boolean().default(false),

package/dist/config/schema.d.ts

@@ -511,6 +511,15 @@ export declare const AuthorityConfigSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type AuthorityConfig = z.infer<typeof AuthorityConfigSchema>;
+export declare const CouncilConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxRounds: z.ZodDefault<z.ZodNumber>;
+    parallelTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    vetoPriority: z.ZodDefault<z.ZodBoolean>;
+    requireAllMembers: z.ZodDefault<z.ZodBoolean>;
+    escalateOnMaxRounds: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CouncilConfig = z.infer<typeof CouncilConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
@@ -854,6 +863,14 @@ export declare const PluginConfigSchema: z.ZodObject<{
         emergencyThreshold: z.ZodDefault<z.ZodNumber>;
         preserveLastNTurns: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    council: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxRounds: z.ZodDefault<z.ZodNumber>;
+        parallelTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        vetoPriority: z.ZodDefault<z.ZodBoolean>;
+        requireAllMembers: z.ZodDefault<z.ZodBoolean>;
+        escalateOnMaxRounds: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     turbo_mode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     full_auto: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/council/council-advisory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Work Complete Council — advisory routing helper.
+ *
+ * Purpose:
+ *   Routes a CouncilSynthesis (unifiedFeedbackMd + verdict metadata) into the
+ *   architect's non-blocking advisory queue (`session.pendingAdvisoryMessages`).
+ *   The guardrails `messagesTransform` hook drains that queue into an
+ *   [ADVISORIES] block prepended to the architect's first SYSTEM message on
+ *   the next turn.
+ *
+ * Runtime call site:
+ *   `src/tools/convene-council.ts` invokes this helper after writing evidence,
+ *   guarded by `ctx?.sessionID` and `getAgentSession`. Missing session, missing
+ *   sessionID, or any thrown error silently skip — the advisory is never
+ *   critical-path. The helper is also re-exported for direct use by any future
+ *   caller that wants to push synthesis output into an advisory queue.
+ *
+ * Scope and known limitation:
+ *   The advisory queue is READ by the architect session on its next turn (self
+ *   echo). It is NOT a programmatic architect→coder delivery channel — the
+ *   architect still has to render `unifiedFeedbackMd` into the coder's
+ *   delegation payload manually, per the prompt's four-phase workflow. A
+ *   dedicated architect→coder advisory primitive is future work.
+ *
+ * Dedup semantics:
+ *   Dedup key is `council:${taskId}:${roundNumber}`. If the queue already
+ *   contains a string whose content includes that key, the push is a no-op.
+ *   Different rounds or tasks push distinct entries.
+ *
+ * Blocking signal (metadata only):
+ *   - REJECT  → header declares `blocking=true`. Council vetoed the candidate.
+ *   - CONCERNS→ `blocking=false`. Architect should weigh fixes but is not vetoed.
+ *   - APPROVE → `blocking=false`. Helper skips push entirely when there are no
+ *               advisoryFindings (nothing useful to surface).
+ */
+import type { AgentSessionState } from '../state';
+import type { CouncilSynthesis } from './types';
+/**
+ * Push a CouncilSynthesis into the given session's advisory queue so the
+ * architect will see it as an [ADVISORIES] block on the next messagesTransform.
+ *
+ * Idempotent per (taskId, roundNumber): repeated calls with the same key
+ * leave the queue unchanged. Safe to call on APPROVE — it is a no-op when
+ * there are no advisoryFindings.
+ */
+export declare function pushCouncilAdvisory(session: Pick<AgentSessionState, 'pendingAdvisoryMessages'>, synthesis: CouncilSynthesis): void;

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

@@ -0,0 +1,18 @@
+/**
+ * Work Complete Council — evidence writer.
+ *
+ * Stamps the council synthesis result into `.swarm/evidence/{taskId}.json`
+ * under `gates.council`, matching the shape other gate writers use and the
+ * shape that `check_gate_status` and `update_task_status` consume (they read
+ * `evidence.gates[gateName]`). Council-specific fields (verdict, vetoedBy,
+ * roundNumber, allCriteriaMet) are stored alongside the standard GateInfo
+ * fields (sessionId, timestamp, agent); existing consumers only check
+ * `gates.council != null`, so the extras are compatible.
+ *
+ * Existing fields in the evidence file — top-level keys AND other `gates[*]`
+ * entries — are preserved across the write. The raw taskId is used as the
+ * filename; defense-in-depth regex validation rejects malformed IDs before
+ * any filesystem op.
+ */
+import type { CouncilSynthesis } from './types';
+export declare function writeCouncilEvidence(workingDir: string, synthesis: CouncilSynthesis): void;

package/dist/council/council-service.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Work Complete Council — pure synthesis service.
+ *
+ * Given the verdicts of council members (critic, reviewer, sme, test_engineer),
+ * compute the overall verdict, classify findings, detect conflicts, and build a
+ * single unified feedback document for the coder.
+ *
+ * No I/O — fully unit-testable with mock inputs. All file reads/writes happen in
+ * sibling modules (criteria-store, council-evidence-writer).
+ */
+import type { CouncilConfig, CouncilCriteria, CouncilMemberVerdict, CouncilSynthesis } from './types';
+export declare function synthesizeCouncilVerdicts(taskId: string, swarmId: string, verdicts: CouncilMemberVerdict[], criteria: CouncilCriteria | null, roundNumber: number, config?: Partial<CouncilConfig>): CouncilSynthesis;

package/dist/council/criteria-store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Work Complete Council — pre-declaration criteria writer/reader.
+ *
+ * Stores acceptance criteria under .swarm/council/{safeId}.json so they can be
+ * read back during council evaluation.
+ */
+import type { CouncilCriteria, CouncilCriteriaItem } from './types';
+export declare function writeCriteria(workingDir: string, taskId: string, criteria: CouncilCriteriaItem[]): void;
+export declare function readCriteria(workingDir: string, taskId: string): CouncilCriteria | null;

package/dist/council/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Work Complete Council — data contracts.
+ *
+ * Flat, stable schema — no nested generics. Designed for reliable LLM output.
+ * No business logic, no I/O. Only types, interfaces, and defaults.
+ */
+export type CouncilVerdict = 'APPROVE' | 'CONCERNS' | 'REJECT';
+export type CouncilFindingSeverity = 'HIGH' | 'MEDIUM' | 'LOW';
+export type CouncilFindingCategory = 'logic' | 'edge_case' | 'error_handling' | 'spec_compliance' | 'security' | 'maintainability' | 'naming' | 'domain' | 'test_gap' | 'test_quality' | 'mutation_gap' | 'adversarial_gap' | 'slop_pattern' | 'hallucinated_api' | 'lazy_abstraction' | 'cargo_cult' | 'spec_drift' | 'other';
+export type CouncilAgent = 'critic' | 'reviewer' | 'sme' | 'test_engineer' | 'explorer';
+export interface CouncilFinding {
+    severity: CouncilFindingSeverity;
+    category: CouncilFindingCategory;
+    /** e.g. "src/tools/convene-council.ts:42" */
+    location: string;
+    /** Human-readable explanation */
+    detail: string;
+    /** Concrete quote or line reference */
+    evidence: string;
+}
+export interface CouncilMemberVerdict {
+    agent: CouncilAgent;
+    verdict: CouncilVerdict;
+    /** Confidence 0.0–1.0 */
+    confidence: number;
+    findings: CouncilFinding[];
+    /** Criteria IDs from pre-declaration (e.g. ["C1","C3"]) */
+    criteriaAssessed: string[];
+    /** Criteria IDs that failed */
+    criteriaUnmet: string[];
+    durationMs: number;
+}
+export interface CouncilSynthesis {
+    taskId: string;
+    swarmId: string;
+    /** ISO 8601 */
+    timestamp: string;
+    overallVerdict: CouncilVerdict;
+    vetoedBy: CouncilAgent[] | null;
+    memberVerdicts: CouncilMemberVerdict[];
+    unresolvedConflicts: string[];
+    /** Severity HIGH + MEDIUM from veto members */
+    requiredFixes: CouncilFinding[];
+    /** Severity LOW or from non-veto members */
+    advisoryFindings: CouncilFinding[];
+    /** Single markdown document sent to coder */
+    unifiedFeedbackMd: string;
+    /** 1-indexed */
+    roundNumber: number;
+    allCriteriaMet: boolean;
+}
+export interface CouncilCriteriaItem {
+    id: string;
+    description: string;
+    mandatory: boolean;
+}
+export interface CouncilCriteria {
+    taskId: string;
+    criteria: CouncilCriteriaItem[];
+    /** ISO 8601 */
+    declaredAt: string;
+}
+/** Config shape — matched in schema.ts via CouncilConfigSchema. */
+export interface CouncilConfig {
+    enabled: boolean;
+    /** Default 3 */
+    maxRounds: number;
+    /** Default 30_000 */
+    parallelTimeoutMs: number;
+    /** Default true — any REJECT blocks */
+    vetoPriority: boolean;
+    /** Default false — when true, convene_council rejects unless all 5 member verdicts are provided */
+    requireAllMembers: boolean;
+    /** Optional webhook URL or handler name invoked when maxRounds is reached without APPROVE. Declared for forward compatibility; no behavior is implemented yet. */
+    escalateOnMaxRounds?: string;
+}
+export declare const COUNCIL_DEFAULTS: CouncilConfig;

package/dist/hooks/index.d.ts

@@ -13,6 +13,7 @@ export { consolidateSystemMessages } from './messages-transform';
 export { extractModelInfo, NATIVE_MODEL_LIMITS, PROVIDER_CAPS, resolveModelLimit, } from './model-limits';
 export { type CuratorDelegateFactory, createPhaseMonitorHook, } from './phase-monitor';
 export { createPipelineTrackerHook } from './pipeline-tracker';
+export { createRepoGraphBuilderHook, type RepoGraphBuilderHook, } from './repo-graph-builder';
 export { buildApprovedReceipt, buildReceiptContextForDrift, buildRejectedReceipt, persistReviewReceipt, readAllReceipts, readReceiptsByScopeHash, } from './review-receipt';
 export { createSystemEnhancerHook } from './system-enhancer';
 export { createToolSummarizerHook, resetSummaryIdCounter, } from './tool-summarizer';

package/dist/hooks/repo-graph-builder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Repo Graph Builder Hook
+ *
+ * Startup hook that builds or refreshes the repo dependency graph when a session starts.
+ * Write-trigger hook that incrementally updates the graph when write tools are called.
+ * Wrapped in try/catch — failures are logged but never block plugin initialization.
+ */
+export interface RepoGraphBuilderHook {
+    init(): Promise<void>;
+    toolAfter(input: {
+        tool: string;
+        sessionID: string;
+        args?: unknown;
+    }, output: {
+        output?: unknown;
+        args?: unknown;
+    }): Promise<void>;
+}
+export interface RepoGraphDeps {
+    buildWorkspaceGraph: (workspace: string, options?: any) => any;
+    saveGraph: (workspace: string, graph: any) => Promise<void>;
+    updateGraphForFiles: (workspace: string, files: string[], options?: any) => Promise<any>;
+}
+export declare function createRepoGraphBuilderHook(workspaceRoot: string, deps?: Partial<RepoGraphDeps>): RepoGraphBuilderHook;