opencode-swarm 6.16.1 → 6.17.0

package/README.md

@@ -429,6 +429,23 @@ Config file location: `~/.config/opencode/opencode-swarm.json` (global) or `.ope
       "evidence_auto_summaries": true,
       "decision_drift_detection": true
     }
+  },
+  "knowledge": {
+    "enabled": true,
+    "swarm_max_entries": 100,
+    "hive_max_entries": 1000,
+    "auto_promote_days": 30,
+    "max_inject_count": 5,
+    "dedup_threshold": 0.6,
+    "scope_filter": ["global"],
+    "hive_enabled": true,
+    "rejected_max_entries": 200,
+    "validation_enabled": true,
+    "evergreen_confidence": 0.8,
+    "evergreen_utility": 0.5,
+    "low_utility_threshold": 0.2,
+    "min_retrievals_for_utility": 3,
+    "schema_version": "v6.17"
   }
 }
 ```

package/dist/commands/dark-matter.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles /swarm dark-matter command.
+ * Detects hidden couplings (files that co-change without explicit import relationships).
+ */
+export declare function handleDarkMatterCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/index.d.ts

@@ -5,11 +5,13 @@ export { handleArchiveCommand } from './archive';
 export { handleBenchmarkCommand } from './benchmark';
 export { handleClarifyCommand } from './clarify';
 export { handleConfigCommand } from './config';
+export { handleDarkMatterCommand } from './dark-matter';
 export { handleDiagnoseCommand } from './diagnose';
 export { handleDoctorCommand } from './doctor';
 export { handleEvidenceCommand } from './evidence';
 export { handleExportCommand } from './export';
 export { handleHistoryCommand } from './history';
+export { handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, } from './knowledge';
 export { handlePlanCommand } from './plan';
 export { handlePreflightCommand } from './preflight';
 export { handleResetCommand } from './reset';

package/dist/commands/knowledge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Handles /swarm knowledge quarantine <id> [reason] command.
+ * Moves a knowledge entry to quarantine with optional reason.
+ */
+export declare function handleKnowledgeQuarantineCommand(directory: string, args: string[]): Promise<string>;
+/**
+ * Handles /swarm knowledge restore <id> command.
+ * Restores a quarantined knowledge entry.
+ */
+export declare function handleKnowledgeRestoreCommand(directory: string, args: string[]): Promise<string>;

package/dist/config/evidence-schema.d.ts

@@ -202,8 +202,8 @@ export declare const RetrospectiveEvidenceSchema: z.ZodObject<{
         }>;
         scope: z.ZodEnum<{
             project: "project";
-            session: "session";
             global: "global";
+            session: "session";
         }>;
     }, z.core.$strip>>>;
     approaches_tried: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -570,8 +570,8 @@ export declare const EvidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         scope: z.ZodEnum<{
             project: "project";
-            session: "session";
             global: "global";
+            session: "session";
         }>;
     }, z.core.$strip>>>;
     approaches_tried: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -929,8 +929,8 @@ export declare const EvidenceBundleSchema: z.ZodObject<{
             }>;
             scope: z.ZodEnum<{
                 project: "project";
-                session: "session";
                 global: "global";
+                session: "session";
             }>;
         }, z.core.$strip>>>;
         approaches_tried: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/dist/config/schema.d.ts

@@ -381,6 +381,24 @@ declare const AutomationConfigSchemaBase: z.ZodObject<{
 }, z.core.$strip>;
 export type AutomationConfig = z.infer<typeof AutomationConfigSchemaBase>;
 export declare const AutomationConfigSchema: z.ZodType<AutomationConfig>;
+export declare const KnowledgeConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    swarm_max_entries: z.ZodDefault<z.ZodNumber>;
+    hive_max_entries: z.ZodDefault<z.ZodNumber>;
+    auto_promote_days: z.ZodDefault<z.ZodNumber>;
+    max_inject_count: z.ZodDefault<z.ZodNumber>;
+    dedup_threshold: z.ZodDefault<z.ZodNumber>;
+    scope_filter: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hive_enabled: z.ZodDefault<z.ZodBoolean>;
+    rejected_max_entries: z.ZodDefault<z.ZodNumber>;
+    validation_enabled: z.ZodDefault<z.ZodBoolean>;
+    evergreen_confidence: z.ZodDefault<z.ZodNumber>;
+    evergreen_utility: z.ZodDefault<z.ZodNumber>;
+    low_utility_threshold: z.ZodDefault<z.ZodNumber>;
+    min_retrievals_for_utility: z.ZodDefault<z.ZodNumber>;
+    schema_version: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type KnowledgeConfig = z.infer<typeof KnowledgeConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
@@ -608,6 +626,23 @@ export declare const PluginConfigSchema: z.ZodObject<{
             decision_drift_detection: boolean;
         };
     }, unknown>>>;
+    knowledge: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        swarm_max_entries: z.ZodDefault<z.ZodNumber>;
+        hive_max_entries: z.ZodDefault<z.ZodNumber>;
+        auto_promote_days: z.ZodDefault<z.ZodNumber>;
+        max_inject_count: z.ZodDefault<z.ZodNumber>;
+        dedup_threshold: z.ZodDefault<z.ZodNumber>;
+        scope_filter: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        hive_enabled: z.ZodDefault<z.ZodBoolean>;
+        rejected_max_entries: z.ZodDefault<z.ZodNumber>;
+        validation_enabled: z.ZodDefault<z.ZodBoolean>;
+        evergreen_confidence: z.ZodDefault<z.ZodNumber>;
+        evergreen_utility: z.ZodDefault<z.ZodNumber>;
+        low_utility_threshold: z.ZodDefault<z.ZodNumber>;
+        min_retrievals_for_utility: z.ZodDefault<z.ZodNumber>;
+        schema_version: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     tool_output: z.ZodOptional<z.ZodObject<{
         truncation_enabled: z.ZodDefault<z.ZodBoolean>;
         max_lines: z.ZodDefault<z.ZodNumber>;

package/dist/hooks/delegation-gate.d.ts

@@ -23,7 +23,14 @@ interface MessageWithParts {
  * Creates the experimental.chat.messages.transform hook for delegation gating.
  * Inspects coder delegations and warns when tasks are oversized or batched.
  */
-export declare function createDelegationGateHook(config: PluginConfig): (input: Record<string, never>, output: {
-    messages?: MessageWithParts[];
-}) => Promise<void>;
+export declare function createDelegationGateHook(config: PluginConfig): {
+    messagesTransform: (input: Record<string, never>, output: {
+        messages?: MessageWithParts[];
+    }) => Promise<void>;
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: unknown) => Promise<void>;
+};
 export {};

package/dist/hooks/hive-promoter.d.ts

@@ -0,0 +1,16 @@
+/** Hive promoter hook for opencode-swarm v6.17 two-tier knowledge system. */
+import type { KnowledgeConfig, SwarmKnowledgeEntry } from './knowledge-types.js';
+/**
+ * Main promotion logic: checks swarm entries and promotes eligible ones to hive.
+ * Also updates existing hive entries with new project confirmations.
+ *
+ * @note The 'hive-fast-track' tag is treated as privileged — it bypasses the
+ *   3-phase confirmation requirement. It should only be set by authorized tooling
+ *   (inferTags() never produces it automatically).
+ */
+export declare function checkHivePromotions(swarmEntries: SwarmKnowledgeEntry[], config: KnowledgeConfig): Promise<void>;
+/**
+ * Create a hook that promotes swarm entries to the hive.
+ * The hook fires unconditionally - the caller decides when to invoke it.
+ */
+export declare function createHivePromoterHook(directory: string, config: KnowledgeConfig): (input: unknown, output: unknown) => Promise<void>;

package/dist/hooks/knowledge-curator.d.ts

@@ -0,0 +1,17 @@
+/** Knowledge curator hook for opencode-swarm v6.17 two-tier knowledge system. */
+import type { KnowledgeConfig } from './knowledge-types.js';
+/**
+ * Curate and store swarm knowledge entries from lessons.
+ */
+export declare function curateAndStoreSwarm(lessons: string[], projectName: string, phaseInfo: {
+    phase_number: number;
+}, directory: string, config: KnowledgeConfig): Promise<void>;
+/**
+ * Auto-promote swarm entries based on phase confirmations and age.
+ */
+export declare function runAutoPromotion(directory: string, config: KnowledgeConfig): Promise<void>;
+/**
+ * Create the knowledge curator hook.
+ * Watches for writes to .swarm/plan.md and extracts lessons from the retrospective section.
+ */
+export declare function createKnowledgeCuratorHook(directory: string, config: KnowledgeConfig): (input: unknown, output: unknown) => Promise<void>;

package/dist/hooks/knowledge-injector.d.ts

@@ -0,0 +1,20 @@
+/** Phase-Start Knowledge Injection Hook for opencode-swarm v6.17.
+ *
+ * Injects relevant knowledge (from both swarm + hive tiers) into the architect's
+ * context at phase start. Caches the injection text for re-injection after
+ * compaction. Skips for non-architect agents. Appends rejected-pattern warnings
+ * to prevent re-learning loops.
+ */
+import type { KnowledgeConfig, MessageWithParts } from './knowledge-types.js';
+/**
+ * Creates a knowledge injection hook that injects relevant knowledge into the
+ * architect's message context at phase start. Supports caching for re-injection
+ * after compaction.
+ *
+ * @param directory - The project directory containing .swarm/
+ * @param config - Knowledge system configuration
+ * @returns A hook function that injects knowledge into messages
+ */
+export declare function createKnowledgeInjectorHook(directory: string, config: KnowledgeConfig): (input: Record<string, never>, output: {
+    messages?: MessageWithParts[];
+}) => Promise<void>;

package/dist/hooks/knowledge-migrator.d.ts

@@ -0,0 +1,10 @@
+/** One-time migration from .swarm/context.md → .swarm/knowledge.jsonl for existing projects. */
+import type { KnowledgeConfig } from './knowledge-types.js';
+export interface MigrationResult {
+    migrated: boolean;
+    entriesMigrated: number;
+    entriesDropped: number;
+    entriesTotal: number;
+    skippedReason?: 'sentinel-exists' | 'no-context-file' | 'empty-context';
+}
+export declare function migrateContextToKnowledge(directory: string, config: KnowledgeConfig): Promise<MigrationResult>;

package/dist/hooks/knowledge-reader.d.ts

@@ -0,0 +1,18 @@
+/** Read path for the opencode-swarm v6.17 two-tier knowledge system.
+ * Merges swarm + hive knowledge, deduplicates (hive wins), ranks by composite score,
+ * and provides utility tracking.
+ */
+import type { KnowledgeConfig, KnowledgeEntryBase } from './knowledge-types.js';
+export interface ProjectContext {
+    projectName: string;
+    currentPhase: string;
+    techStack?: string[];
+    recentErrors?: string[];
+}
+export interface RankedEntry extends KnowledgeEntryBase {
+    tier: 'swarm' | 'hive';
+    relevanceScore: number;
+    finalScore: number;
+}
+export declare function readMergedKnowledge(directory: string, config: KnowledgeConfig, context?: ProjectContext): Promise<RankedEntry[]>;
+export declare function updateRetrievalOutcome(directory: string, phaseInfo: string, phaseSucceeded: boolean): Promise<void>;

package/dist/hooks/knowledge-store.d.ts

@@ -0,0 +1,19 @@
+/** Core storage layer for the opencode-swarm v6.17 two-tier knowledge system. */
+import type { RejectedLesson } from './knowledge-types.js';
+export declare function resolveSwarmKnowledgePath(directory: string): string;
+export declare function resolveSwarmRejectedPath(directory: string): string;
+export declare function resolveHiveKnowledgePath(): string;
+export declare function resolveHiveRejectedPath(): string;
+export declare function readKnowledge<T>(filePath: string): Promise<T[]>;
+export declare function readRejectedLessons(directory: string): Promise<RejectedLesson[]>;
+export declare function appendKnowledge<T>(filePath: string, entry: T): Promise<void>;
+export declare function rewriteKnowledge<T>(filePath: string, entries: T[]): Promise<void>;
+export declare function appendRejectedLesson(directory: string, lesson: RejectedLesson): Promise<void>;
+export declare function normalize(text: string): string;
+export declare function wordBigrams(text: string): Set<string>;
+export declare function jaccardBigram(a: Set<string>, b: Set<string>): number;
+export declare function findNearDuplicate<T extends {
+    lesson: string;
+}>(candidate: string, entries: T[], threshold?: number): T | undefined;
+export declare function computeConfidence(confirmedByCount: number, autoGenerated: boolean): number;
+export declare function inferTags(lesson: string): string[];

package/dist/hooks/knowledge-types.d.ts

@@ -0,0 +1,101 @@
+/** Type definitions for the opencode-swarm v6.17 two-tier knowledge system. */
+export type KnowledgeCategory = 'process' | 'architecture' | 'tooling' | 'security' | 'testing' | 'debugging' | 'performance' | 'integration' | 'other';
+export interface PhaseConfirmationRecord {
+    phase_number: number;
+    confirmed_at: string;
+    project_name: string;
+}
+export interface ProjectConfirmationRecord {
+    project_name: string;
+    confirmed_at: string;
+    phase_number?: number;
+}
+export interface RetrievalOutcome {
+    applied_count: number;
+    succeeded_after_count: number;
+    failed_after_count: number;
+    last_applied_at?: string;
+}
+export interface KnowledgeEntryBase {
+    id: string;
+    tier: 'swarm' | 'hive';
+    lesson: string;
+    category: KnowledgeCategory;
+    tags: string[];
+    scope: string;
+    confidence: number;
+    status: 'candidate' | 'established' | 'promoted';
+    confirmed_by: PhaseConfirmationRecord[] | ProjectConfirmationRecord[];
+    retrieval_outcomes: RetrievalOutcome;
+    schema_version: number;
+    created_at: string;
+    updated_at: string;
+    hive_eligible?: boolean;
+    auto_generated?: boolean;
+}
+export interface SwarmKnowledgeEntry extends KnowledgeEntryBase {
+    tier: 'swarm';
+    confirmed_by: PhaseConfirmationRecord[];
+    project_name: string;
+}
+export interface HiveKnowledgeEntry extends KnowledgeEntryBase {
+    tier: 'hive';
+    confirmed_by: ProjectConfirmationRecord[];
+    source_project: string;
+}
+export interface RejectedLesson {
+    id: string;
+    lesson: string;
+    rejection_reason: string;
+    rejected_at: string;
+    rejection_layer: 1 | 2 | 3;
+}
+export interface KnowledgeConfig {
+    /** Enable or disable the entire knowledge system. Default: true */
+    enabled: boolean;
+    /** Maximum entries to keep in swarm knowledge.jsonl. Default: 100 */
+    swarm_max_entries: number;
+    /** Maximum entries to keep in hive shared-learnings.jsonl. Default: 200 */
+    hive_max_entries: number;
+    /** Days before auto-promotion to hive tier. Default: 90 */
+    auto_promote_days: number;
+    /** Maximum knowledge entries to inject per architect message. Default: 5 */
+    max_inject_count: number;
+    /** Jaccard bigram similarity threshold for deduplication. Default: 0.6 */
+    dedup_threshold: number;
+    /** Scope filters to apply when reading knowledge. Default: ['global'] */
+    scope_filter: string[];
+    /** Enable hive (cross-project) tier reads and writes. Default: true */
+    hive_enabled: boolean;
+    /** Maximum rejected lesson fingerprints to retain. Default: 20 */
+    rejected_max_entries: number;
+    /** Enable validation gate before storing lessons. Default: true */
+    validation_enabled: boolean;
+    /** Confidence threshold for marking an entry evergreen. Default: 0.9 */
+    evergreen_confidence: number;
+    /** Utility score threshold for marking an entry evergreen. Default: 0.8 */
+    evergreen_utility: number;
+    /** Utility score at or below which an entry is considered low-utility. Default: 0.3 */
+    low_utility_threshold: number;
+    /** Minimum retrieval count before utility scoring begins. Default: 3 */
+    min_retrievals_for_utility: number;
+    /** JSONL schema version. Default: 1 */
+    schema_version: number;
+}
+export interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
+}
+export interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}

package/dist/hooks/knowledge-validator.d.ts

@@ -0,0 +1,28 @@
+/** Three-layer validation gate for the opencode-swarm v6.17 knowledge system. */
+import type { KnowledgeCategory, KnowledgeEntryBase } from './knowledge-types.js';
+export interface ValidationResult {
+    valid: boolean;
+    layer: 1 | 2 | 3 | null;
+    reason: string | null;
+    severity: 'error' | 'warning' | null;
+}
+export declare const DANGEROUS_COMMAND_PATTERNS: RegExp[];
+export declare const SECURITY_DEGRADING_PATTERNS: RegExp[];
+export declare const INJECTION_PATTERNS: RegExp[];
+export declare function validateLesson(candidate: string, existingLessons: string[], meta: {
+    category: KnowledgeCategory;
+    scope: string;
+    confidence: number;
+}): ValidationResult;
+export interface QuarantinedEntry extends KnowledgeEntryBase {
+    quarantine_reason: string;
+    quarantined_at: string;
+    reported_by: 'architect' | 'user' | 'auto';
+}
+export interface EntryHealthResult {
+    healthy: boolean;
+    concern?: string;
+}
+export declare function auditEntryHealth(entry: KnowledgeEntryBase): EntryHealthResult;
+export declare function quarantineEntry(directory: string, entryId: string, reason: string, reportedBy: 'architect' | 'user' | 'auto'): Promise<void>;
+export declare function restoreEntry(directory: string, entryId: string): Promise<void>;