opencode-orchestrator 1.2.71 → 1.3.4

package/dist/core/agents/concurrency-config.d.ts

@@ -0,0 +1,4 @@
+import type { ConcurrencyConfig } from "./concurrency.js";
+export declare function extractConcurrencyConfig(source: unknown): ConcurrencyConfig;
+export declare function hasConcurrencyConfig(source: unknown): boolean;
+export declare function mergeConcurrencyConfig(base: ConcurrencyConfig, override: ConcurrencyConfig): ConcurrencyConfig;

package/dist/core/agents/concurrency.d.ts

@@ -34,6 +34,8 @@ export declare class ConcurrencyController {
     private readonly MAX_MEMORY_PERCENT;
     private workerPools;
     constructor(config?: ConcurrencyConfig);
+    configure(config: ConcurrencyConfig): void;
+    getConfig(): ConcurrencyConfig;
     setLimit(key: string, limit: number): void;
     getConcurrencyLimit(key: string): number;
     getLimit(key: string): number;

package/dist/core/agents/manager.d.ts

@@ -14,6 +14,7 @@ import { formatDuration } from "./format.js";
 import type { ParallelTask } from "./interfaces/index.js";
 import type { LaunchInput } from "./interfaces/launch-input.interface.js";
 import type { ResumeInput } from "./interfaces/resume-input.interface.js";
+import type { ConcurrencyConfig } from "./concurrency.js";
 export type { ParallelTask };
 export { formatDuration };
 type OpencodeClient = PluginInput["client"];
@@ -30,7 +31,7 @@ export declare class ParallelAgentManager {
     private cleaner;
     private eventHandler;
     private constructor();
-    static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
+    static getInstance(client?: OpencodeClient, directory?: string, concurrencyConfig?: ConcurrencyConfig): ParallelAgentManager;
     launch(inputs: LaunchInput | LaunchInput[]): Promise<ParallelTask | ParallelTask[]>;
     resume(input: ResumeInput): Promise<ParallelTask>;
     getTask(id: string): ParallelTask | undefined;
@@ -40,6 +41,7 @@ export declare class ParallelAgentManager {
     cancelTask(taskId: string): Promise<boolean>;
     getResult(taskId: string): Promise<string | null>;
     setConcurrencyLimit(agentType: string, limit: number): void;
+    configureConcurrency(config: ConcurrencyConfig): void;
     getPendingCount(parentSessionID: string): number;
     getConcurrency(): ConcurrencyController;
     cleanup(): void;

package/dist/core/config/plugin-options.d.ts

@@ -0,0 +1,9 @@
+import type { PluginOptions } from "@opencode-ai/plugin";
+import type { ConcurrencyConfig } from "../agents/concurrency.js";
+import { type MissionRuntimeOptions } from "../loop/mission-runtime-options.js";
+export type MissionLoopPluginOptions = MissionRuntimeOptions;
+export interface OrchestratorPluginOptions {
+    concurrency: ConcurrencyConfig;
+    missionLoop: MissionLoopPluginOptions;
+}
+export declare function parseOrchestratorPluginOptions(options?: PluginOptions): OrchestratorPluginOptions;

package/dist/core/knowledge/context-provider.d.ts

@@ -0,0 +1,8 @@
+export declare class KnowledgeContextProvider {
+    buildPrompt(directory: string, query: string): string | null;
+    private collectMarkdownFiles;
+    private walkDirectory;
+    private indexKnowledge;
+    private buildSnippet;
+    private formatPrompt;
+}

package/dist/core/knowledge/graph-parser.d.ts

@@ -0,0 +1,39 @@
+/**
+ * GraphParser - Bi-directional Obsidian Wiki-Link & Markdown Link Knowledge Graph Parser
+ */
+export declare class GraphParser {
+    /** Heading marker used for the auto-generated backlinks section */
+    static readonly BACKLINKS_HEADING = "## \uD83D\uDD17 Backlinks";
+    private forwardLinks;
+    private backlinks;
+    private noteToPath;
+    private pathToNote;
+    /**
+     * Resolve file path or relative link to a note name (basename without extension).
+     */
+    getNoteName(filePath: string): string;
+    /**
+     * Parse content and extract all unique referenced target note names.
+     */
+    parseLinks(content: string): string[];
+    /**
+     * Index file and register its bi-directional links.
+     */
+    indexFile(filePath: string, content: string): void;
+    /**
+     * Retrieve backlinks for a note name or file path.
+     */
+    getBacklinks(noteOrPath: string): string[];
+    /**
+     * Retrieve forward links for a note name or file path.
+     */
+    getForwardLinks(noteOrPath: string): string[];
+    /**
+     * Synchronize the ## 🔗 Backlinks section in a file's content.
+     */
+    syncBacklinksSection(content: string, backlinksList: string[]): string;
+    /**
+     * Clear all indexes for a note.
+     */
+    private clearIndexForNote;
+}

package/dist/core/knowledge/hybrid-search.d.ts

@@ -0,0 +1,65 @@
+/**
+ * HybridSearch - Combines lexical (BM25-inspired), tag, and graph search
+ * with Reciprocal Rank Fusion to surface the most relevant notes.
+ */
+import type { TagIndexer } from "./tag-indexer.js";
+import type { GraphParser } from "./graph-parser.js";
+/** Unified search result with provenance tracking. */
+export interface SearchResult {
+    noteName: string;
+    score: number;
+    matchType: "lexical" | "tag" | "graph";
+}
+export declare class HybridSearch {
+    private readonly tagIndexer;
+    private readonly graphParser;
+    /** Stores indexed note content keyed by note name. */
+    private contentMap;
+    constructor(tagIndexer: TagIndexer, graphParser: GraphParser);
+    /**
+     * Register note content for lexical search.
+     * Must be called after TagIndexer.indexFile / GraphParser.indexFile.
+     */
+    indexContent(noteName: string, content: string): void;
+    /**
+     * Fuse lexical, tag, and graph rankings via RRF to produce a single list.
+     */
+    search(query: string, maxResults?: number): SearchResult[];
+    /**
+     * BM25-inspired term-frequency scoring across all indexed documents.
+     * Approximates IDF via corpus size and document frequency.
+     */
+    private lexicalSearch;
+    /**
+     * Match query terms against the tag index to find tagged notes.
+     */
+    private tagSearch;
+    /**
+     * 2-hop graph traversal from tag-matched seed notes to discover related notes.
+     */
+    private graphSearch;
+    /**
+     * Depth-limited BFS from a seed note, scoring neighbors by proximity.
+     */
+    private traverseGraph;
+    /**
+     * Reciprocal Rank Fusion: combine three ranked lists into a single ranking.
+     * Formula: score(d) = Σ 1/(k + rank_i) for each list where d appears.
+     */
+    private fuseResults;
+    /**
+     * Accumulate RRF scores from a single ranked list into the fused map.
+     * The matchType is set to the source with the highest individual contribution.
+     */
+    private addRrfScores;
+    /** Split query into lowercase tokens for matching. */
+    private tokenize;
+    /** Count non-overlapping occurrences of a term in text. */
+    private countOccurrences;
+    /** Average document length across the corpus (character-based). */
+    private computeAverageLength;
+    /** Number of documents containing the given term. */
+    private documentFrequency;
+    /** Sort entries by descending score and return the keys in order. */
+    private sortByScore;
+}

package/dist/core/knowledge/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Knowledge Module - Barrel Export
+ *
+ * Re-exports all knowledge graph modules (Phase 1-7)
+ * for clean module boundary access from the rest of the framework.
+ */
+export { TagIndexer } from "./tag-indexer.js";
+export type { FrontmatterData } from "./tag-indexer.js";
+export { GraphParser } from "./graph-parser.js";
+export { HybridSearch } from "./hybrid-search.js";
+export type { SearchResult } from "./hybrid-search.js";
+export { Scratchpad } from "./scratchpad.js";
+export { getMissionCanvasPath, getMissionScratchpadPath, syncMissionMemory, } from "./mission-memory.js";
+export { SafetyGuards } from "./safety-guards.js";
+export type { WriteQueue } from "./safety-guards.js";
+export { MemoryConsolidation } from "./memory-consolidation.js";

package/dist/core/knowledge/memory-consolidation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * MemoryConsolidation - Pure analysis functions for knowledge-graph maintenance.
+ * All methods are side-effect-free: they read from indexes but never mutate state or files.
+ */
+import type { TagIndexer } from "./tag-indexer.js";
+import type { GraphParser } from "./graph-parser.js";
+export declare class MemoryConsolidation {
+    private readonly tagIndexer;
+    private readonly graphParser;
+    constructor(tagIndexer: TagIndexer, graphParser: GraphParser);
+    /**
+     * Find notes whose content exceeds the line-count ceiling.
+     * These are candidates for splitting to improve navigability.
+     */
+    identifyOversizedNotes(contentMap: Map<string, string>, maxLines?: number): string[];
+    /**
+     * Find notes that have zero forward links AND zero backlinks.
+     * Orphan notes are disconnected from the graph and may need linking or removal.
+     */
+    identifyOrphanNotes(allNotes: string[]): string[];
+    /**
+     * Find pairs of notes sharing enough tags to warrant merging.
+     * Uses TagIndexer.getAllTags() and getFilesWithTag() to build the full picture.
+     */
+    suggestMerges(threshold?: number): Array<[string, string]>;
+    /**
+     * Generate a Map of Content markdown listing all notes tagged with the given tag.
+     * MOCs serve as navigational hubs in the knowledge graph.
+     */
+    generateMOC(tag: string): string;
+    /**
+     * Build a lookup from note name to its set of tags by iterating
+     * all known tags in the index and collecting their associated files.
+     */
+    private buildNoteTagMap;
+    /** Count how many tags two sets share. */
+    private countSharedTags;
+}

package/dist/core/knowledge/mission-memory.d.ts

@@ -0,0 +1,4 @@
+import type { MissionLoopState } from "../../shared/loop/interfaces/mission-loop.js";
+export declare function syncMissionMemory(directory: string, state: MissionLoopState): boolean;
+export declare function getMissionScratchpadPath(directory: string): string;
+export declare function getMissionCanvasPath(directory: string): string;