opencode-swarm 7.130.1 → 7.131.0

package/dist/tools/consensus-mine.d.ts

@@ -0,0 +1,172 @@
+/**
+ * `consensus_mine` — run the consensus miner and persist its report.
+ *
+ * The tool is a thin, fully-wired shell around `src/consensus/`: it resolves the
+ * effective consensus config, assembles a `ConsensusMineRequest` from the
+ * caller's overrides, optionally supplies an LLM dispatcher, delegates to
+ * `mineAndStoreConsensusV1`, applies report retention, and renders a bounded
+ * summary.
+ *
+ * It is NOT write-minimal, and the description the model reads says so. The
+ * complete list of effects, none of which touches a project file:
+ *
+ * 1. **Its own report** under `.swarm/evolution/consensus/<reportId>.json`.
+ * 2. **Deletions of its own prior reports.** `pruneConsensusReports` runs
+ *    unconditionally after every mine and `consensus.report_retention` defaults
+ *    to 50, so the steady state of a long-lived project is that each run
+ *    `unlink`s the oldest report. Only `report_retention: 0` disables it.
+ * 3. **The shared dedup ledger** (issue #1821 AC21). It gains one entry per
+ *    emitted proposal EXCEPT where it already carries that recommendation's
+ *    cross key — those are counted as `duplicate_recommendation_count` instead.
+ *    The append is a whole-file rewrite with FIFO eviction at
+ *    `MAX_RECOMMENDATION_LEDGER_ENTRIES`, and eviction is by position, not by
+ *    producer: a miner append can evict the CURATOR's or the IMPROVER's oldest
+ *    entries. The ledger normally lives at
+ *    `.swarm/learning/recommendation-ledger.jsonl`, but its root is
+ *    `resolveKnowledgeStoreDir`, so under a knowledge-link pointer it lands in
+ *    the shared cohort root rather than this project's `.swarm/`.
+ * 4. **Lock sentinels.** The report goes through `withEvidenceLock`, whose
+ *    sentinel is an empty `<sha256>.lock` file under this project's
+ *    `.swarm/locks/`; `proper-lockfile` removes its own lock directory but
+ *    NOTHING removes that sentinel, so each distinct report id leaves one behind
+ *    permanently. The ledger goes through `transactFile`, which locks the
+ *    ledger's own containing directory and therefore produces
+ *    `<resolveKnowledgeStoreDir(directory)>/learning.lock` — outside this
+ *    project's `.swarm/` entirely whenever a knowledge link is active.
+ * 5. **A pending memory proposal per emitted proposal**, but only when
+ *    `memory.enabled` is `true` (it defaults to `false`,
+ *    `src/config/schema.ts`). This is issue #1821 AC22 — "use existing
+ *    proposal/MemoryRecord paths, not another inbox" — so the mirror goes
+ *    through the same `MemoryGateway.propose` path `swarm_memory_propose` uses,
+ *    which creates a *pending proposal* requiring curator review and never a
+ *    durable memory record.
+ * 6. **Up to `MAX_LLM_SUMMARIES` (20) `session.create` + `session.prompt`
+ *    calls** whenever `consensus.llm_summarization_enabled` (default `true`)
+ *    finds a wired OpenCode client.
+ *
+ * Effects 2-6 were absent from the tool description for four review rounds
+ * while it claimed "its only writes are its own immutable report and one entry
+ * in the shared recommendation dedup ledger". That string is read by a model as
+ * fact and was the premise of the Full-Auto auto-allow in
+ * `src/full-auto/policy.ts`; both now state the list above.
+ *
+ * What the tool does NOT do is mutate any of the evidence it reads. That is a
+ * chosen property, not a free one:
+ * `loadEvidence` upgrades a legacy flat retrospective in place by default, so
+ * `src/consensus/corpus.ts` binds it with `{ migrate: false }`. Without that, a
+ * mining run would rewrite evidence bundles — and remap their legacy
+ * `task_complexity` values — while advertising itself as read-only.
+ *
+ * It activates no skill, writes no knowledge entry, admits no durable memory
+ * record, and touches no project file — which is why it is classified as a
+ * **pathless write-like** tool in `src/full-auto/policy.ts` alongside
+ * `write_retro` and `knowledge_add`, and why it is absent from
+ * `WRITE_TOOL_NAMES` (`src/config/constants.ts`), whose members are the tools
+ * that write PROJECT FILE CONTENTS and are therefore subject to the scope guard.
+ * The knowledge-link redirection in effects 3 and 5 does not change that
+ * classification: `knowledge_add` and `knowledge_remove` are in the same
+ * auto-allow set and have the same redirection, and it comes from operator
+ * configuration rather than from anything the caller passed.
+ *
+ * `ctx.directory` is injected by `createSwarmTool`; there is no `process.cwd()`
+ * anywhere in this file (AGENTS.md invariant 4).
+ */
+import type { MemoryConfig } from '../config/schema';
+import type { ConsensusAttributeV1, ConsensusReportV1 } from '../consensus/contracts';
+import { createMemoryGateway } from '../memory';
+import { type RecommendationCandidate } from '../services/recommendation-ledger';
+import { createSwarmTool } from './create-tool';
+/**
+ * Reconcile the summary counters with what the inline echo actually shows.
+ *
+ * These are two different orderings and they do not line up. Restatements are
+ * spent on the top `MAX_LLM_SUMMARIES` attributes by CONFIDENCE
+ * (`src/consensus/miner.ts`), while the echo below is the first
+ * `MAX_INLINE_ATTRIBUTES` in canonical SIGNAL order. With confidence inverted
+ * relative to signal order, a report can print `summarized_count: 20` while zero
+ * `llm_summary` values are visible — which is exactly what "the count always
+ * agrees with the values echoed alongside it" used to claim was impossible.
+ * `hidden` is what makes the discrepancy legible instead of mysterious.
+ */
+declare function countSummaries(attributes: readonly ConsensusAttributeV1[], inlineLimit: number): {
+    total: number;
+    hidden: number;
+};
+/**
+ * Describe the miner's emissions to the cross-producer dedup ledger
+ * (issue #1821 AC21).
+ *
+ * The statement is the proposal's `intent` — the sentence the miner actually
+ * emits — not the internal attribute statement its own `lrec_` fingerprint is
+ * built from: only the intent survives onto the persisted report, and it is the
+ * text a human reads as "the recommendation". `scopeKeys` stays empty for the
+ * same reason the curator's new-knowledge recommendations carry none: content
+ * alone is the identity of a freshly-minted lesson, and that is exactly where
+ * another producer can legitimately be proposing the same thing.
+ */
+declare function buildMinerRecommendationCandidates(report: Pick<ConsensusReportV1, 'proposals' | 'generatedAt'>, sessionId?: string): RecommendationCandidate[];
+/**
+ * What the AC22 memory mirror actually did, reported rather than assumed.
+ *
+ * `attempted` is 0 whenever `enabled` is false, so a reader can tell "memory is
+ * off" from "memory is on and nothing was proposed". `failed` and `error` exist
+ * because the mirror is deliberately fail-open — the report is already durably
+ * written by the time it runs, and losing the whole mine to a memory-store
+ * problem would be worse than losing the mirror — but a fail-open path that
+ * reports nothing is exactly the defect `recommendation_ledger.degraded` was
+ * added to close.
+ */
+type MemoryMirrorResult = {
+    enabled: boolean;
+    attempted: number;
+    proposed: number;
+    rejected: number;
+    failed: number;
+    error?: string;
+};
+/**
+ * Issue #1821 AC22: mirror each emitted proposal into the EXISTING memory
+ * proposal path rather than leaving the consensus report as a write-only inbox.
+ *
+ * `MemoryGateway.propose` is the same entry point `swarm_memory_propose` uses
+ * (`src/tools/swarm-memory-propose.ts`), including its `dispose()` in a
+ * `finally`. It creates a PENDING proposal — curator review is still required,
+ * nothing durable is admitted — which is why the tool's proposals-only guarantee
+ * survives the mirror.
+ *
+ * Fail-open by design and per-proposal: one rejected or throwing proposal must
+ * not discard the ones that succeeded, and none of it can unwrite the report.
+ * Every outcome is counted and returned, so the tool's response says what
+ * happened instead of implying success.
+ */
+declare function mirrorProposalsToMemory(options: {
+    directory: string;
+    memoryConfig: MemoryConfig | undefined;
+    report: Pick<ConsensusReportV1, 'proposals' | 'reportId'>;
+    sessionId?: string;
+}): Promise<MemoryMirrorResult>;
+/**
+ * DI seam (AGENTS.md invariant 7). Lets a test drive the AC22 mirror's
+ * failure and rejection branches without a real provider and without
+ * `mock.module`. Restore each entry in `afterEach`.
+ */
+export declare const _internals: {
+    createMemoryGateway: typeof createMemoryGateway;
+};
+/**
+ * Pure-function seam for tests (writing-tests SKILL.md, Tier 0). Exported so a
+ * cross-producer dedup test can build the miner's ledger candidates through the
+ * same code the tool runs instead of restating the mapping, and so the
+ * summary-counter reconciliation can be asserted at the ordering that produces
+ * it — 20 summarized attributes with none visible — rather than only at the
+ * degenerate all-zero case a dispatcher-less run reaches.
+ */
+export declare const _test_exports: {
+    buildMinerRecommendationCandidates: typeof buildMinerRecommendationCandidates;
+    countSummaries: typeof countSummaries;
+    mirrorProposalsToMemory: typeof mirrorProposalsToMemory;
+    MAX_INLINE_ATTRIBUTES: number;
+    MIRRORED_PROPOSAL_KIND: "todo";
+};
+export declare const consensus_mine: ReturnType<typeof createSwarmTool>;
+export {};

package/dist/tools/index.d.ts

@@ -10,6 +10,7 @@ export { checkpoint } from './checkpoint';
 export { co_change_analyzer } from './co-change-analyzer';
 export { completion_verify } from './completion-verify';
 export { complexity_hotspots } from './complexity-hotspots';
+export { consensus_mine } from './consensus-mine';
 export { context_status } from './context-status';
 export { submit_council_verdicts } from './convene-council';
 export { convene_general_council } from './convene-general-council';

package/dist/tools/knowledge-add.d.ts

@@ -1,2 +1,36 @@
 import { createSwarmTool } from './create-tool.js';
+/**
+ * Merge caller-supplied tags with the tags inferred from the lesson.
+ *
+ * Caller tags come FIRST so that when the combined list exceeds the cap,
+ * truncation drops inferred tags before it drops user intent. `dedupeCapped`
+ * is case-insensitive (first casing wins), so an inferred tag the caller
+ * already supplied collapses into the caller's casing instead of duplicating.
+ *
+ * Hoisted to module scope and exposed via `_test_exports` so this call site is
+ * observable on its own: the store write boundary normalizes the same fields,
+ * which would otherwise mask a regression here (issue #1821 Lane 0b).
+ */
+declare function mergeLessonTags(tagsInput: unknown, lesson: string): string[];
+/**
+ * Normalize one optional v3 actionability array from untrusted tool input.
+ *
+ * The `undefined` return is load-bearing: `validateActionableFields` and
+ * `validateActionability` distinguish an ABSENT field from an empty one, and
+ * JSON.stringify drops an `undefined` value so the persisted record keeps that
+ * distinction. Only the inner filter+cap is `dedupeCapped` (#1821 Lane 0b).
+ */
+declare function strArray(v: unknown): string[] | undefined;
 export declare const knowledge_add: ReturnType<typeof createSwarmTool>;
+/**
+ * Tier-0 test seam (issue #1821 Lane 0b). These are pure functions with no I/O.
+ * They are exported so the call-site normalization can be asserted directly:
+ * the store write boundary normalizes the same fields with the same semantics,
+ * so an assertion made against a PERSISTED entry cannot distinguish "call site
+ * fixed" from "call site reverted".
+ */
+export declare const _test_exports: {
+    mergeLessonTags: typeof mergeLessonTags;
+    strArray: typeof strArray;
+};
+export {};

package/dist/tools/manifest.d.ts

@@ -79,6 +79,7 @@ export declare const TOOL_MANIFEST: {
     doc_scan: () => ToolDefinition;
     doc_extract: () => ToolDefinition;
     curator_analyze: () => ToolDefinition;
+    consensus_mine: () => ToolDefinition;
     knowledge_add: () => ToolDefinition;
     knowledge_recall: () => ToolDefinition;
     knowledge_remove: () => ToolDefinition;

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

@@ -320,6 +320,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    consensus_mine: {
+        description: string;
+        agents: ("architect" | "curator_phase" | "curator_postmortem")[];
+    };
     knowledge_add: {
         description: string;
         agents: ("coder" | "architect")[];

package/package.json

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