opencode-swarm 7.73.3 → 7.74.1

package/dist/config/schema.d.ts

@@ -575,6 +575,13 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
         synonym_min_cooccurrence: z.ZodDefault<z.ZodNumber>;
         synonym_map_max_pairs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    enrichment: z.ZodDefault<z.ZodObject<{
+        max_calls_per_day: z.ZodDefault<z.ZodNumber>;
+        quota_window: z.ZodDefault<z.ZodEnum<{
+            utc: "utc";
+            local: "local";
+        }>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type KnowledgeConfig = z.infer<typeof KnowledgeConfigSchema>;
 export declare const MemoryConfigSchema: z.ZodObject<{
@@ -1561,6 +1568,13 @@ export declare const PluginConfigSchema: z.ZodObject<{
             synonym_min_cooccurrence: z.ZodDefault<z.ZodNumber>;
             synonym_map_max_pairs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
+        enrichment: z.ZodDefault<z.ZodObject<{
+            max_calls_per_day: z.ZodDefault<z.ZodNumber>;
+            quota_window: z.ZodDefault<z.ZodEnum<{
+                utc: "utc";
+                local: "local";
+            }>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     memory: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

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

@@ -7,6 +7,7 @@
  */
 import type { KnowledgeApplicationResult } from './knowledge-types.js';
 export declare function resolveApplicationLogPath(directory: string): string;
+export declare const MAX_LEGACY_APPLICATION_LOG_ENTRIES = 5000;
 /**
  * Parse explicit knowledge-acknowledgment markers from architect/delegate text.
  * Recognised forms (case-insensitive, line-anchored or inline):

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

@@ -41,7 +41,8 @@ export interface EnrichmentQuotaOptions {
 /**
  * Enrich one prose lesson with v3 actionability fields via the curator LLM.
  * One retry on schema failure (with a RETRY message naming the missing
- * fields). Quota-gated per call via skill-improver-quota. Returns null when
+ * fields). Quota-gated per call via the dedicated knowledge-enrichment quota.
+ * Returns null when
  * enrichment is unavailable (quota exhausted) or fails twice — the caller
  * quarantines the entry. Never throws.
  */
@@ -94,7 +95,11 @@ export declare function runAutoPromotion(directory: string, config: KnowledgeCon
  * 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>;
+export interface KnowledgeCuratorHookOptions {
+    llmDelegateFactory?: (sessionID: string) => CuratorLLMDelegate | undefined;
+    enrichmentQuota?: EnrichmentQuotaOptions;
+}
+export declare function createKnowledgeCuratorHook(directory: string, config: KnowledgeConfig, options?: KnowledgeCuratorHookOptions): (input: unknown, output: unknown) => Promise<void>;
 export declare const _internals: {
     isWriteToEvidenceFile: typeof isWriteToEvidenceFile;
     curateAndStoreSwarm: typeof curateAndStoreSwarm;

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

@@ -1,16 +1,16 @@
 /**
  * Event-sourced knowledge lifecycle for opencode-swarm.
  *
- * `.swarm/knowledge-events.jsonl` is an append-only, immutable log of every
- * meaningful knowledge interaction (retrieval, receipt, outcome, archival).
- * It is the authoritative history: per-entry counters
- * (`retrieval_outcomes.*`) become *derived rollups* recomputed deterministically
- * from this log via {@link recomputeCounters}.
+ * `.swarm/knowledge-events.jsonl` records meaningful knowledge interactions
+ * (retrieval, receipt, outcome, archival). Recent lines stay in the event log;
+ * old lines are folded into `.swarm/knowledge-counter-baseline.json` when the
+ * log exceeds the cap. The event log plus baseline are the authoritative
+ * history for derived per-entry counters (`retrieval_outcomes.*`).
  *
  * Design contracts:
- * - Append-only. We never rewrite or delete lines. OS-level atomic append is
- *   used (same pattern as `appendKnowledge` in knowledge-store.ts) — no lock is
- *   needed for append-only writes.
+ * - Append-first, bounded retention. New events use OS-level atomic append; trim
+ *   rewrites only after folding evicted counters into the baseline so aggregate
+ *   counters survive log rotation.
  * - Fail-open. Event recording is telemetry; it must never break tool or hook
  *   execution. Use {@link recordKnowledgeEvent} (swallows + warns) on hot paths;
  *   {@link appendKnowledgeEvent} throws and is intended for tests / callers that
@@ -113,6 +113,7 @@ export interface ArchivedEvent {
     event_id: string;
     timestamp: string;
     entry_id: string;
+    tier?: 'swarm' | 'hive';
     actor: string;
     reason: string;
     mode: 'archive' | 'quarantine' | 'purge';
@@ -147,6 +148,8 @@ export type KnowledgeEventInput = KnowledgeEvent extends infer T ? T extends Kno
 export declare const RECEIPT_EVENT_TYPES: ReadonlySet<string>;
 /** Returns `.swarm/knowledge-events.jsonl` for the given project directory. */
 export declare function resolveKnowledgeEventsPath(directory: string): string;
+/** Returns `.swarm/knowledge-counter-baseline.json` for folded event counters. */
+export declare function resolveKnowledgeCounterBaselinePath(directory: string): string;
 /** Returns `.swarm/knowledge-application.jsonl` for legacy v2 audit records. */
 export declare function resolveLegacyApplicationLogPath(directory: string): string;
 /** Generate a fresh trace id. One per retrieval; receipts reference it. */
@@ -211,6 +214,7 @@ export interface CounterRollup {
 }
 /** Cap on retained per-entry violation timestamps. */
 export declare const MAX_VIOLATION_TIMESTAMPS = 10;
+declare function readCounterBaseline(directory: string): Promise<Map<string, CounterRollup>>;
 /**
  * Recompute per-entry counters deterministically from the immutable event log,
  * optionally folding in legacy `knowledge-application.jsonl` records.
@@ -234,7 +238,7 @@ export declare const MAX_VIOLATION_TIMESTAMPS = 10;
  * @param events Events from {@link readKnowledgeEvents}.
  * @param legacyRecords Optional legacy application records (any order).
  */
-export declare function recomputeCounters(events: KnowledgeEvent[], legacyRecords?: KnowledgeApplicationRecord[]): Map<string, CounterRollup>;
+export declare function recomputeCounters(events: KnowledgeEvent[], legacyRecords?: KnowledgeApplicationRecord[], baseline?: Map<string, CounterRollup>): Map<string, CounterRollup>;
 /**
  * Count how many of the given violation timestamps fall within `windowDays` of
  * `now` (inclusive). Pure helper — deterministic given its inputs. Malformed
@@ -276,9 +280,11 @@ export declare function applyKnowledgeVerdictFeedback(directory: string, options
 }>;
 export declare const _internals: {
     resolveKnowledgeEventsPath: typeof resolveKnowledgeEventsPath;
+    resolveKnowledgeCounterBaselinePath: typeof resolveKnowledgeCounterBaselinePath;
     appendKnowledgeEvent: typeof appendKnowledgeEvent;
     recordKnowledgeEvent: typeof recordKnowledgeEvent;
     readKnowledgeEvents: typeof readKnowledgeEvents;
+    readCounterBaseline: typeof readCounterBaseline;
     readLegacyApplicationRecords: typeof readLegacyApplicationRecords;
     readKnowledgeCounterRollups: typeof readKnowledgeCounterRollups;
     effectiveRetrievalOutcomes: typeof effectiveRetrievalOutcomes;
@@ -287,3 +293,4 @@ export declare const _internals: {
     newTraceId: typeof newTraceId;
     newEventId: typeof newEventId;
 };
+export {};

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

@@ -87,7 +87,7 @@ export declare function matchesDelegateScope(entry: Pick<RankedEntry, 'applies_t
  * @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: {
+export declare function createKnowledgeInjectorHook(directory: string, config: KnowledgeConfig, modelLimitOverrides?: Record<string, number>): (input: Record<string, never>, output: {
     messages?: MessageWithParts[];
 }) => Promise<void>;
 export declare const _internals: {

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

@@ -17,6 +17,7 @@ export interface RankedEntry extends KnowledgeEntryBase {
         keywords: number;
     };
     finalScore: number;
+    coldStartBoost?: number;
 }
 declare function transactShownFile(shownFile: string, mutate: (data: Record<string, string[]>) => Record<string, string[]> | null): Promise<boolean>;
 export declare function readMergedKnowledge(directory: string, config: KnowledgeConfig, context?: ProjectContext, opts?: {

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

@@ -26,6 +26,7 @@ export declare function transactFile<T>(filePath: string, read: (filePath: strin
 export declare function transactKnowledge<T>(filePath: string, mutate: (entries: T[]) => T[] | null): Promise<boolean>;
 export declare function appendKnowledgeWithCapEnforcement<T>(filePath: string, entry: T, maxEntries: number): Promise<boolean>;
 export declare function enforceKnowledgeCap<T>(filePath: string, maxEntries: number): Promise<void>;
+declare function selectKnowledgeCapSurvivors<T>(entries: T[], maxEntries: number): T[];
 export interface SweepResult {
     scanned: number;
     aged: number;
@@ -87,6 +88,8 @@ export declare const _internals: {
     findNearDuplicate: typeof findNearDuplicate;
     computeConfidence: typeof computeConfidence;
     computeOutcomeSignal: typeof computeOutcomeSignal;
+    selectKnowledgeCapSurvivors: typeof selectKnowledgeCapSurvivors;
     inferTags: typeof inferTags;
     bumpKnowledgeConfidenceBatch: typeof bumpKnowledgeConfidenceBatch;
 };
+export {};

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

@@ -212,6 +212,11 @@ export interface KnowledgeConfig {
         synonym_min_cooccurrence?: number;
         synonym_map_max_pairs?: number;
     };
+    /** Dedicated quota for LLM enrichment of plain-prose lessons into v3 directives. */
+    enrichment: {
+        max_calls_per_day: number;
+        quota_window: 'utc' | 'local';
+    };
 }
 export interface MessageInfo {
     role: string;

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

@@ -6,6 +6,8 @@ export interface ValidationResult {
     reason: string | null;
     severity: 'error' | 'warning' | null;
 }
+export declare const DANGEROUS_COMMAND_ERROR_PATTERNS: RegExp[];
+export declare const DANGEROUS_COMMAND_WARNING_PATTERNS: RegExp[];
 export declare const DANGEROUS_COMMAND_PATTERNS: RegExp[];
 export declare const SECURITY_DEGRADING_PATTERNS: RegExp[];
 export declare const INVISIBLE_FORMAT_CHARS: RegExp;
@@ -65,12 +67,9 @@ export interface UnactionableRecord extends KnowledgeEntryBase {
  * queue (held out of the active store, pending hardening by the skill-improver).
  * FIFO-capped at 200. Best-effort: throws only on lock failure for tests.
  *
- * Flooding tradeoff (Phase 4 review): duplicate prose lessons are NOT deduped
- * at queue time, so a looping producer can fill the queue with duplicates and
- * FIFO-evict older legitimate records. Accepted because (a) the cap bounds the
- * damage at 200 records of plain text, (b) the hardening loop's promotion path
- * dedups at commit time against the active store, and (c) queue producers are
- * themselves quota- or phase-bounded. Revisit if telemetry shows real evictions.
+ * Duplicate or near-duplicate prose lessons are deduped under the same lock used
+ * for the append/trim transaction. This keeps hook-first/phase_complete replay
+ * from filling the bounded queue with equivalent quarantines.
  */
 export declare function appendUnactionable(directory: string, entry: KnowledgeEntryBase, reason: string): Promise<void>;
 export interface QuarantinedEntry extends KnowledgeEntryBase {

package/dist/hooks/micro-reflector.d.ts

@@ -13,7 +13,8 @@
  *
  * Budget: the prompt is capped well under ~2k input chars and the model is
  * asked for ≤512 output. Exactly one LLM call per qualifying return, gated by
- * the shared skill-improver quota. Fail-open: never throws, never blocks.
+ * the dedicated knowledge-enrichment quota. Fail-open: never throws, never
+ * blocks.
  */
 import type { CuratorLLMDelegate } from './curator.js';
 import type { EnrichmentQuotaOptions } from './knowledge-curator.js';

package/dist/hooks/skill-scoring.d.ts

@@ -88,7 +88,7 @@ declare function computeRecencyScore(lastUsedTimestamp: string): number;
  * @param skillPath       - Repo-relative path to the skill file.
  * @returns Context match score in [0, 1].
  */
-declare function computeContextMatchScore(taskDescription: string, skillPath: string): number;
+declare function computeContextMatchScore(taskDescription: string, skillPath: string, metadata?: SkillMetadata): number;
 /**
  * Compute a composite relevance score for a skill based on its usage history
  * and keyword overlap with the task description.

package/dist/hooks/skill-usage-log.d.ts

@@ -85,7 +85,12 @@ export declare const _internals: {
     applySkillUsageFeedback: typeof applySkillUsageFeedback;
     parseGeneratedFromKnowledge: typeof parseGeneratedFromKnowledge;
     computeComplianceByVersion: typeof computeComplianceByVersion;
+    normalizeComplianceVerdict: typeof normalizeComplianceVerdict;
+    readFeedbackAppliedEntryIds: typeof readFeedbackAppliedEntryIds;
+    appendFeedbackAppliedMarker: typeof appendFeedbackAppliedMarker;
 };
+declare function readFeedbackAppliedEntryIds(directory: string): Set<string>;
+declare function appendFeedbackAppliedMarker(directory: string, processedEntryIds: string[]): void;
 /**
  * Validate and append a single skill-usage entry to the JSONL log.
  *
@@ -162,9 +167,9 @@ declare function parseGeneratedFromKnowledge(content: string): string[];
  * Read skill-usage entries, resolve source knowledge IDs for each skill,
  * and apply confidence bumps/decays to the originating knowledge entries.
  *
- * For each unique skillPath with at least one compliance or violation entry:
+ * For each unique skillPath with at least one compliance or violated entry:
  * 1. Resolve source knowledge UUIDs from the skill's SKILL.md frontmatter.
- * 2. Count compliant and violation events for that skill.
+ * 2. Count compliant and violated events for that skill.
  * 3. Compute net delta: if compliant count > violation count → +0.05; else → -0.1.
  * 4. Call `bumpKnowledgeConfidenceBatch` with the aggregated deltas.
  *