opencode-orchestrator 1.2.71 → 1.3.4

package/dist/core/knowledge/safety-guards.d.ts

@@ -0,0 +1,39 @@
+/**
+ * SafetyGuards - Graph integrity checks and concurrency primitives.
+ * Protects knowledge-graph mutations from cycles, races, and accidental deletes.
+ */
+import type { GraphParser } from "./graph-parser.js";
+import type { FrontmatterData } from "./tag-indexer.js";
+/**
+ * FIFO async write queue that serializes concurrent write operations
+ * to prevent data corruption from overlapping file mutations.
+ */
+export interface WriteQueue {
+    /** Enqueue a write operation; resolves when the operation completes. */
+    enqueue(fn: () => Promise<void>): Promise<void>;
+    /** Wait for all queued operations to finish. */
+    drain(): Promise<void>;
+}
+export declare class SafetyGuards {
+    /**
+     * Detect circular links from a starting note via depth-limited DFS.
+     * Returns true if the start note is reachable from itself within maxDepth hops.
+     */
+    static checkCircularLinks(graph: GraphParser, startNote: string, maxDepth?: number): boolean;
+    /**
+     * Create a FIFO write queue that ensures only one write runs at a time.
+     * Each enqueued function waits for all prior functions to complete first.
+     */
+    static createWriteQueue(): WriteQueue;
+    /**
+     * Check whether a note's frontmatter marks it as pinned (keep: true).
+     * Pinned notes should be excluded from pruning and consolidation.
+     */
+    static isPinned(metadata: FrontmatterData): boolean;
+    /**
+     * Recursive DFS that returns true when the start note is revisited.
+     * Bounded by maxDepth to prevent runaway traversal in dense graphs.
+     * Always checks direct neighbors for the start note before applying depth limit.
+     */
+    private static dfsDetectCycle;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Scratchpad - Volatile key-value register cache for agent working memory.
+ * Implements LRU eviction and markdown-based serialization for persistence.
+ */
+export declare class Scratchpad {
+    /**
+     * Ordered map where the most-recently-accessed key moves to the end.
+     * Eviction removes from the beginning (least recently used).
+     */
+    private registers;
+    /**
+     * Store a value, evicting the least-recently-used entry if at capacity.
+     * Values exceeding 4 KB are truncated to enforce size constraints.
+     */
+    set(key: string, value: string): void;
+    /**
+     * Retrieve a register value, refreshing its LRU position on access.
+     */
+    get(key: string): string | undefined;
+    /** Return a snapshot copy of all registers. */
+    getAll(): Map<string, string>;
+    /** Remove a specific register entry. */
+    delete(key: string): boolean;
+    /** Wipe all register entries. */
+    clear(): void;
+    /**
+     * Export all registers as a markdown document for persistence.
+     * Each register becomes a level-2 heading with its value as content.
+     */
+    serialize(): string;
+    /**
+     * Import registers from a previously serialized markdown document.
+     * Clears existing state before importing to ensure idempotent loads.
+     */
+    deserialize(content: string): void;
+    /** Evict the least-recently-used entry (first key in insertion order). */
+    private evictLru;
+}

package/dist/core/knowledge/tag-indexer.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Interface representing standard Obsidian-style Frontmatter metadata.
+ */
+export interface FrontmatterData {
+    tags?: string[];
+    title?: string;
+    keep?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Metadata extractor with regular expression fallback when standard parser crashes.
+ */
+export declare class TagIndexer {
+    private tagMap;
+    private fileCache;
+    /**
+     * Parse frontmatter using regular expressions as a primary safe parser.
+     * This avoids library dependencies and provides deterministic error recovery.
+     */
+    parseFrontmatter(content: string): {
+        data: FrontmatterData;
+        body: string;
+    };
+    /**
+     * Parse a single YAML line and update data object in-place.
+     * Returns the currently active key for block list continuation.
+     */
+    private parseYamlLine;
+    /**
+     * Index a single markdown file content dynamically.
+     */
+    indexFile(filePath: string, fileContent: string): void;
+    /**
+     * Index a file directly from the filesystem.
+     */
+    indexFileFromDisk(filePath: string): void;
+    /**
+     * Get all files associated with a specific tag O(1).
+     */
+    getFilesWithTag(tag: string): Set<string>;
+    /**
+     * Get intersection of files containing all specified tags.
+     */
+    getFilesWithAllTags(tags: string[]): Set<string>;
+    /**
+     * Get union of files containing any of the specified tags.
+     */
+    getFilesWithAnyTags(tags: string[]): Set<string>;
+    /**
+     * Get the cached frontmatter metadata of a file.
+     */
+    getMetadata(filePath: string): FrontmatterData | undefined;
+    /**
+     * Return all file paths that have been indexed.
+     */
+    getIndexedFiles(): string[];
+    /**
+     * Return all distinct tags currently present across all indexed files.
+     */
+    getAllTags(): string[];
+    /**
+     * Remove file references cleanly from tag mappings and metadata cache.
+     */
+    private clearIndexForFile;
+    /**
+     * Helper to insert tags atomically.
+     */
+    private addTagEntry;
+    /**
+     * Basic scalar value parser for YAML frontmatter fields.
+     */
+    private parseScalar;
+}

package/dist/core/loop/mission-ledger.d.ts

@@ -0,0 +1,17 @@
+export type MissionLedgerEventType = "mission_started" | "verification_failed" | "continuation_scheduled" | "prompt_injected" | "mission_completed" | "mission_cancelled" | "circuit_open";
+export interface MissionLedgerEvent {
+    id: string;
+    type: MissionLedgerEventType;
+    timestamp: string;
+    sessionID: string;
+    iteration?: number;
+    objective?: string;
+    summary?: string;
+    reason?: string;
+}
+export type MissionLedgerInput = Omit<MissionLedgerEvent, "id" | "timestamp"> & {
+    timestamp?: string;
+};
+export declare function getMissionLedgerPath(directory: string): string;
+export declare function appendMissionLedgerEvent(directory: string, input: MissionLedgerInput): MissionLedgerEvent | null;
+export declare function readMissionLedger(directory: string, limit?: number): MissionLedgerEvent[];

package/dist/core/loop/mission-loop.d.ts

@@ -6,6 +6,11 @@
  * strictly on file-based state verification.
  */
 import type { MissionLoopState, MissionLoopOptions } from "../../shared/loop/interfaces/mission-loop.js";
+type MissionContinuationContext = {
+    verificationSummary?: string;
+    continuationReason?: string;
+};
+type MissionContinuationInput = string | MissionContinuationContext;
 /**
  * Read loop state from disk
  */
@@ -37,8 +42,9 @@ export declare function isLoopActive(directory: string, sessionID: string): bool
 /**
  * Generate continuation prompt for mission loop
  */
-export declare function generateMissionContinuationPrompt(state: MissionLoopState, verificationSummary?: string): string;
+export declare function generateMissionContinuationPrompt(state: MissionLoopState, input?: MissionContinuationInput): string;
 /**
  * Generate completion notification
  */
 export declare function generateCompletionNotification(state: MissionLoopState): string;
+export {};

package/dist/core/loop/mission-runtime-options.d.ts

@@ -0,0 +1,8 @@
+export interface MissionRuntimeOptions {
+    ledger: boolean;
+    markdownMemory: boolean;
+    maxEvidenceEvents: number;
+}
+export declare const DEFAULT_MISSION_RUNTIME_OPTIONS: MissionRuntimeOptions;
+export declare function configureMissionRuntimeOptions(options: MissionRuntimeOptions): void;
+export declare function getMissionRuntimeOptions(): MissionRuntimeOptions;