opencode-swarm 7.5.1 → 7.5.3

package/dist/commands/registry.d.ts

@@ -1,4 +1,7 @@
 import type { AgentDefinition } from '../agents/index.js';
+declare function levenshteinDistance(a: string, b: string): number;
+declare function findSimilarCommands(query: string): string[];
+declare function buildDetailedHelp(commandName: string, entry: CommandEntry): string;
 export declare function handleHelpCommand(ctx: CommandContext): Promise<string>;
 export type CommandContext = {
     directory: string;
@@ -403,6 +406,18 @@ export declare function validateAliases(): {
     errors: string[];
     warnings: string[];
 };
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    handleHelpCommand: typeof handleHelpCommand;
+    validateAliases: typeof validateAliases;
+    resolveCommand: typeof resolveCommand;
+    levenshteinDistance: typeof levenshteinDistance;
+    findSimilarCommands: typeof findSimilarCommands;
+    buildDetailedHelp: typeof buildDetailedHelp;
+};
 /**
  * Resolves compound commands like "evidence summary" and "config doctor".
  * Tries a two-token compound key first, then falls back to a single-token key.
@@ -414,3 +429,4 @@ export declare function resolveCommand(tokens: string[]): {
     key: string;
     warning?: string;
 } | null;
+export {};

package/dist/config/index.d.ts

@@ -3,6 +3,19 @@ export { ALL_AGENT_NAMES, ALL_SUBAGENT_NAMES, DEFAULT_MODELS, isQAAgent, isSubag
 export type { ApprovalEvidence, BaseEvidence, DiffEvidence, Evidence, EvidenceBundle, EvidenceType, EvidenceVerdict, NoteEvidence, ReviewEvidence, TestEvidence, } from './evidence-schema';
 export { ApprovalEvidenceSchema, BaseEvidenceSchema, DiffEvidenceSchema, EVIDENCE_MAX_JSON_BYTES, EVIDENCE_MAX_PATCH_BYTES, EVIDENCE_MAX_TASK_BYTES, EvidenceBundleSchema, EvidenceSchema, EvidenceTypeSchema, EvidenceVerdictSchema, NoteEvidenceSchema, ReviewEvidenceSchema, TestEvidenceSchema, } from './evidence-schema';
 export { loadAgentPrompt, loadPluginConfig, loadPluginConfigWithMeta, loadPluginConfigWithMetaAsync, } from './loader';
+import { loadPluginConfigWithMeta } from './loader';
+/**
+ * Test-only dependency-injection seam — see `gitignore-warning.ts:_internals`
+ * for the rationale (`mock.module` from `bun:test` leaks across files in
+ * Bun's shared test-runner process). Mutating this local object is
+ * file-scoped and trivially restorable via `afterEach`.
+ *
+ * Note: functions are re-exported from ./loader so tests mocking index.js
+ * can substitute at this level without touching the loader module directly.
+ */
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+};
 export type { MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskStatus, } from './plan-schema';
 export { MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
 export type { AgentOverrideConfig, AutomationCapabilities, AutomationConfig, AutomationMode, PhaseCompleteConfig, PipelineConfig, PluginConfig, SwarmConfig, } from './schema';

package/dist/config/schema.d.ts

@@ -1,4 +1,14 @@
 import { z } from 'zod';
+/**
+ * Test-only dependency-injection seam — see `gitignore-warning.ts:_internals`
+ * for the rationale (`mock.module` from `bun:test` leaks across files in
+ * Bun's shared test-runner process). Mutating this local object is
+ * file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    stripKnownSwarmPrefix: typeof stripKnownSwarmPrefix;
+    resolveGuardrailsConfig: typeof resolveGuardrailsConfig;
+};
 /**
  * Strips known Swarm prefixes from agent names to get the canonical agent name.
  *

package/dist/db/qa-gate-profile.d.ts

@@ -6,6 +6,19 @@
  * locked, row updates are rejected by a SQLite trigger and by this service.
  * Sessions can only ratchet gates tighter (enable more), never disable them.
  */
+/**
+ * Test-only dependency-injection seam — see `gitignore-warning.ts:_internals`
+ * for the rationale (`mock.module` from `bun:test` leaks across files in
+ * Bun's shared test-runner process). Mutating this local object is
+ * file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    getProfile: typeof getProfile;
+    getOrCreateProfile: typeof getOrCreateProfile;
+    setGates: typeof setGates;
+    getEffectiveGates: typeof getEffectiveGates;
+    computeProfileHash: typeof computeProfileHash;
+};
 /**
  * QA gate flags. All ten gates are tracked explicitly.
  */

package/dist/evidence/manager.d.ts

@@ -45,6 +45,10 @@ export declare const sanitizeTaskId: typeof _sanitizeTaskId;
  * @throws Error if task ID is invalid or size limit would be exceeded
  */
 export declare function saveEvidence(directory: string, taskId: string, evidence: Evidence): Promise<EvidenceBundle>;
+/**
+ * Transform a flat retrospective object into a valid EvidenceBundle.
+ */
+declare function wrapFlatRetrospective(flatEntry: Record<string, unknown>, taskId: string): EvidenceBundle;
 /**
  * Load evidence bundle for a task.
  * Returns a LoadEvidenceResult discriminated union.
@@ -76,3 +80,13 @@ export declare function checkRequirementCoverage(phase: number, directory: strin
  * Returns array of archived (deleted) task IDs.
  */
 export declare function archiveEvidence(directory: string, maxAgeDays: number, maxBundles?: number): Promise<string[]>;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    wrapFlatRetrospective: typeof wrapFlatRetrospective;
+    loadEvidence: typeof loadEvidence;
+    listEvidenceTaskIds: typeof listEvidenceTaskIds;
+};
+export {};

package/dist/git/branch.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Execute git command safely
+ */
+declare function gitExec(args: string[], cwd: string): string;
 /**
  * Check if we're in a git repository
  */
@@ -57,6 +61,10 @@ export interface ResetToRemoteBranchResult {
     prunedBranches: string[];
     warnings: string[];
 }
+/**
+ * Detect the default remote branch using multiple fallback methods
+ */
+declare function detectDefaultRemoteBranch(cwd: string): string | null;
 /**
  * Reset local branch to align with its remote counterpart.
  * Safely handles uncommitted changes, unpushed commits, and detached HEAD states.
@@ -68,3 +76,14 @@ export interface ResetToRemoteBranchResult {
 export declare function resetToRemoteBranch(cwd: string, options?: {
     pruneBranches?: boolean;
 }): ResetToRemoteBranchResult;
+/**
+ * DI seam for testability. Contains all test-mocked exports.
+ * Internal calls should use _internals.fn() instead of fn() directly.
+ */
+export declare const _internals: {
+    gitExec: typeof gitExec;
+    detectDefaultRemoteBranch: typeof detectDefaultRemoteBranch;
+    getDefaultBaseBranch: typeof getDefaultBaseBranch;
+    resetToRemoteBranch: typeof resetToRemoteBranch;
+};
+export {};

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

@@ -11,6 +11,12 @@ export declare function readPriorDriftReports(directory: string): Promise<DriftR
  * Returns the absolute path of the written file.
  */
 export declare function writeDriftReport(directory: string, report: DriftReport): Promise<string>;
+export declare const _internals: {
+    readPriorDriftReports: typeof readPriorDriftReports;
+    writeDriftReport: typeof writeDriftReport;
+    runDeterministicDriftCheck: typeof runDeterministicDriftCheck;
+    buildDriftInjectionText: typeof buildDriftInjectionText;
+};
 /**
  * Deterministic drift check for the given phase.
  * Builds a structured DriftReport from curator data, plan, spec, and prior reports.

package/dist/hooks/curator.d.ts

@@ -32,6 +32,14 @@ import type { KnowledgeConfig } from './knowledge-types.js';
  * Used to delegate analysis to the explorer agent in CURATOR mode.
  */
 export type CuratorLLMDelegate = (systemPrompt: string, userInput: string, signal?: AbortSignal) => Promise<string>;
+export declare const _internals: {
+    parseKnowledgeRecommendations: typeof parseKnowledgeRecommendations;
+    readCuratorSummary: typeof readCuratorSummary;
+    writeCuratorSummary: typeof writeCuratorSummary;
+    filterPhaseEvents: typeof filterPhaseEvents;
+    checkPhaseCompliance: typeof checkPhaseCompliance;
+    normalizeAgentName: typeof normalizeAgentName;
+};
 /**
  * Parse OBSERVATIONS section from curator LLM output.
  * Expected format per line: "- entry <uuid> (<observable>): [text]"
@@ -52,6 +60,10 @@ export declare function readCuratorSummary(directory: string): Promise<CuratorSu
  * @param summary - The curator summary to write
  */
 export declare function writeCuratorSummary(directory: string, summary: CuratorSummary): Promise<void>;
+/**
+ * Normalize agent name by stripping common swarm prefixes.
+ */
+declare function normalizeAgentName(name: string): string;
 /**
  * Filter events from JSONL by phase or timestamp.
  * @param eventsJsonl - Raw JSONL string of events
@@ -106,3 +118,4 @@ export declare function applyCuratorKnowledgeUpdates(directory: string, recommen
     applied: number;
     skipped: number;
 }>;
+export {};

package/dist/hooks/extractors.d.ts

@@ -51,3 +51,14 @@ export declare function extractPlanCursor(planContent: string, options?: {
     maxTokens?: number;
     lookaheadTasks?: number;
 }): string;
+export declare const _internals: {
+    extractCurrentPhase: typeof extractCurrentPhase;
+    extractCurrentTask: typeof extractCurrentTask;
+    extractDecisions: typeof extractDecisions;
+    extractIncompleteTasks: typeof extractIncompleteTasks;
+    extractPatterns: typeof extractPatterns;
+    extractCurrentPhaseFromPlan: typeof extractCurrentPhaseFromPlan;
+    extractCurrentTaskFromPlan: typeof extractCurrentTaskFromPlan;
+    extractIncompleteTasksFromPlan: typeof extractIncompleteTasksFromPlan;
+    extractPlanCursor: typeof extractPlanCursor;
+};

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

@@ -25,3 +25,9 @@ export declare function runAutoPromotion(directory: string, config: KnowledgeCon
  * 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 declare const _internals: {
+    isWriteToEvidenceFile: typeof isWriteToEvidenceFile;
+    curateAndStoreSwarm: typeof curateAndStoreSwarm;
+    runAutoPromotion: typeof runAutoPromotion;
+    createKnowledgeCuratorHook: typeof createKnowledgeCuratorHook;
+};

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

@@ -1,5 +1,5 @@
 /** One-time migration from .swarm/context.md → .swarm/knowledge.jsonl for existing projects. */
-import type { KnowledgeConfig } from './knowledge-types.js';
+import type { KnowledgeCategory, KnowledgeConfig } from './knowledge-types.js';
 export interface MigrationResult {
     migrated: boolean;
     entriesMigrated: number;
@@ -8,4 +8,55 @@ export interface MigrationResult {
     skippedReason?: 'sentinel-exists' | 'no-context-file' | 'empty-context' | 'external-sentinel-exists';
 }
 export declare function migrateKnowledgeToExternal(_directory: string, _config: KnowledgeConfig): Promise<MigrationResult>;
+interface RawMigrationEntry {
+    text: string;
+    sourceSection: 'lessons-learned' | 'patterns' | 'sme-cache' | 'decisions';
+    categoryHint: KnowledgeCategory | null;
+}
+interface Section {
+    heading: string;
+    body: string;
+}
+export declare const _internals: {
+    migrateContextToKnowledge: typeof migrateContextToKnowledge;
+    migrateKnowledgeToExternal: typeof migrateKnowledgeToExternal;
+    parseContextMd: typeof parseContextMd;
+    splitIntoSections: typeof splitIntoSections;
+    extractBullets: typeof extractBullets;
+    inferCategoryFromText: typeof inferCategoryFromText;
+    truncateLesson: typeof truncateLesson;
+    inferProjectName: typeof inferProjectName;
+    writeSentinel: typeof writeSentinel;
+};
 export declare function migrateContextToKnowledge(directory: string, config: KnowledgeConfig): Promise<MigrationResult>;
+/**
+ * Parse context.md content into raw migration entries.
+ * Extracts bullets from sections matching: lessons-learned, patterns, sme-cache, decisions.
+ */
+declare function parseContextMd(content: string): RawMigrationEntry[];
+/**
+ * Split markdown content into sections based on headings (h1-h3).
+ */
+declare function splitIntoSections(content: string): Section[];
+/**
+ * Extract bullet points from markdown body text.
+ * Matches lines starting with - or * followed by content.
+ */
+declare function extractBullets(body: string): string[];
+/**
+ * Infer knowledge category from text using keyword matching.
+ */
+declare function inferCategoryFromText(text: string): KnowledgeCategory;
+/**
+ * Truncate lesson text to maximum 280 characters.
+ */
+declare function truncateLesson(text: string): string;
+/**
+ * Infer project name from package.json or directory basename.
+ */
+declare function inferProjectName(directory: string): string;
+/**
+ * Write sentinel file to track migration status.
+ */
+declare function writeSentinel(sentinelPath: string, migrated: number, dropped: number): Promise<void>;
+export {};

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

@@ -20,3 +20,7 @@ export interface RankedEntry extends KnowledgeEntryBase {
 }
 export declare function readMergedKnowledge(directory: string, config: KnowledgeConfig, context?: ProjectContext): Promise<RankedEntry[]>;
 export declare function updateRetrievalOutcome(directory: string, phaseInfo: string, phaseSucceeded: boolean): Promise<void>;
+export declare const _internals: {
+    readMergedKnowledge: typeof readMergedKnowledge;
+    updateRetrievalOutcome: typeof updateRetrievalOutcome;
+};

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

@@ -28,3 +28,24 @@ export declare function findNearDuplicate<T extends {
 }>(candidate: string, entries: T[], threshold?: number): T | undefined;
 export declare function computeConfidence(confirmedByCount: number, autoGenerated: boolean): number;
 export declare function inferTags(lesson: string): string[];
+export declare const _internals: {
+    getPlatformConfigDir: typeof getPlatformConfigDir;
+    resolveSwarmKnowledgePath: typeof resolveSwarmKnowledgePath;
+    resolveSwarmRejectedPath: typeof resolveSwarmRejectedPath;
+    resolveHiveKnowledgePath: typeof resolveHiveKnowledgePath;
+    resolveHiveRejectedPath: typeof resolveHiveRejectedPath;
+    readKnowledge: typeof readKnowledge;
+    readRejectedLessons: typeof readRejectedLessons;
+    appendKnowledge: typeof appendKnowledge;
+    rewriteKnowledge: typeof rewriteKnowledge;
+    enforceKnowledgeCap: typeof enforceKnowledgeCap;
+    sweepAgedEntries: typeof sweepAgedEntries;
+    sweepStaleTodos: typeof sweepStaleTodos;
+    appendRejectedLesson: typeof appendRejectedLesson;
+    normalize: typeof normalize;
+    wordBigrams: typeof wordBigrams;
+    jaccardBigram: typeof jaccardBigram;
+    findNearDuplicate: typeof findNearDuplicate;
+    computeConfidence: typeof computeConfidence;
+    inferTags: typeof inferTags;
+};

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

@@ -27,3 +27,9 @@ export interface EntryHealthResult {
 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>;
+export declare const _internals: {
+    validateLesson: typeof validateLesson;
+    auditEntryHealth: typeof auditEntryHealth;
+    quarantineEntry: typeof quarantineEntry;
+    restoreEntry: typeof restoreEntry;
+};

package/dist/hooks/utils.d.ts

@@ -5,6 +5,20 @@
  * including error handling, handler composition, file I/O, and
  * token estimation for swarm-related operations.
  */
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.<fn>(...)` so tests can replace the function on this object
+ * without touching the real module — `mock.module` from `bun:test` leaks
+ * across files in Bun's shared test-runner process, which would corrupt
+ * unrelated suites. Mutating this local object is file-scoped and
+ * trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    safeHook: typeof safeHook;
+    composeHandlers: typeof composeHandlers;
+    validateSwarmPath: typeof validateSwarmPath;
+    readSwarmFileAsync: typeof readSwarmFileAsync;
+};
 export declare function safeHook<I, O>(fn: (input: I, output: O) => Promise<void>): (input: I, output: O) => Promise<void>;
 export declare function composeHandlers<I, O>(...fns: Array<(input: I, output: O) => Promise<void>>): (input: I, output: O) => Promise<void>;
 /**