opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/graph/graph-builder.d.ts

@@ -0,0 +1,39 @@
+import { type FileNode, type RepoGraph } from './types';
+/**
+ * Build a full repository graph by walking the workspace, parsing source files
+ * for imports and exported symbols, and assembling them into a `RepoGraph`.
+ *
+ * Performance:
+ *   - File scanning skips well-known build/dep directories (node_modules, dist, .git, etc.)
+ *   - Per-file parsing runs with a concurrency limit to avoid overwhelming I/O.
+ *   - Files larger than `MAX_FILE_SIZE_BYTES` are skipped (would also fail downstream extractors).
+ *
+ * Targets ~5s for a 50k LOC repo (~500 files) on commodity hardware.
+ */
+export interface BuildOptions {
+    /** Optional cap on file count to bound runtime on huge repos. */
+    maxFiles?: number;
+    /** Concurrency for per-file parsing. Defaults to 16. */
+    concurrency?: number;
+    /** Additional directory names to skip (merged with defaults). */
+    skipDirs?: string[];
+}
+/**
+ * Hard upper bound on file count if the caller does not supply one. Protects
+ * against unbounded memory growth on extremely large monorepos. Callers can
+ * pass an explicit `maxFiles` (including a larger one) to override.
+ */
+export declare const DEFAULT_MAX_FILES = 10000;
+/**
+ * Walk the workspace and return absolute paths of all supported source files.
+ * Cross-platform: emits absolute paths using the host's path separator.
+ */
+export declare function findSourceFiles(workspaceRoot: string, skipDirs?: Set<string>): string[];
+/**
+ * Build the repo graph from scratch.
+ */
+export declare function buildRepoGraph(workspaceRoot: string, options?: BuildOptions): Promise<RepoGraph>;
+/**
+ * Process a single file into a FileNode. Returns null if the file cannot be processed.
+ */
+export declare function processFile(absoluteFilePath: string, workspaceRoot: string): Promise<FileNode | null>;

package/dist/graph/graph-query.d.ts

@@ -0,0 +1,42 @@
+import type { BlastRadiusResult, FileNode, FileReference, LocalizationBlock, RepoGraph, SymbolReference } from './types';
+/**
+ * Query API for the repo graph.
+ *
+ * All functions accept normalized RELATIVE forward-slash paths and return the
+ * same. Callers responsible for normalizing input paths (helper provided).
+ */
+export declare function normalizeGraphPath(p: string): string;
+/**
+ * Files that import the given file (direct dependents).
+ */
+export declare function getImporters(graph: RepoGraph, filePath: string): FileReference[];
+/**
+ * Files this file imports (direct dependencies, resolved targets only).
+ */
+export declare function getDependencies(graph: RepoGraph, filePath: string): FileReference[];
+/**
+ * Find all importers of a specific exported symbol from a file.
+ */
+export declare function getSymbolConsumers(graph: RepoGraph, filePath: string, symbolName: string): SymbolReference[];
+/**
+ * Compute the transitive blast radius of changing one or more files.
+ *
+ * Performs a BFS over the reverse-edge index up to `maxDepth` levels.
+ */
+export declare function getBlastRadius(graph: RepoGraph, filePaths: string[], maxDepth?: number): BlastRadiusResult;
+/**
+ * Top-N most-imported files (by in-degree) — useful for surfacing
+ * architectural pillars.
+ */
+export declare function getKeyFiles(graph: RepoGraph, topN?: number): FileNode[];
+/**
+ * Build a compact localization block for a single file. This is the primary
+ * payload injected into the coder agent's pre-edit context.
+ */
+export declare function getLocalizationContext(graph: RepoGraph, filePath: string, options?: {
+    maxImporters?: number;
+    maxDeps?: number;
+    maxDepth?: number;
+}): LocalizationBlock;
+/** Reset the cached reverse index. Call this when a graph is mutated in place. */
+export declare function resetQueryCache(): void;

package/dist/graph/graph-store.d.ts

@@ -0,0 +1,27 @@
+import { type RepoGraph } from './types';
+export declare function getGraphPath(workspaceRoot: string): string;
+export declare function loadGraph(workspaceRoot: string): RepoGraph | null;
+export declare function saveGraph(workspaceRoot: string, graph: RepoGraph): void;
+/**
+ * Build the graph from scratch and persist it.
+ */
+export declare function buildAndSaveGraph(workspaceRoot: string): Promise<RepoGraph>;
+/**
+ * Apply incremental updates for a list of changed (or potentially-changed) files.
+ *
+ * For each file:
+ *   - If the file no longer exists, its node is removed.
+ *   - Otherwise its node is re-parsed and replaced.
+ *
+ * Returns the updated graph (mutated in place AND returned for convenience).
+ * Caller must call `saveGraph` to persist if desired.
+ */
+export declare function updateGraphIncremental(workspaceRoot: string, changedRelativePaths: string[], graph: RepoGraph): Promise<RepoGraph>;
+/**
+ * Determine if a stored graph is fresh enough to reuse.
+ *
+ * Default freshness window: 5 minutes. Files added/removed outside this
+ * window are not detected without an explicit incremental update — callers
+ * that care about up-to-the-second accuracy should rebuild.
+ */
+export declare function isGraphFresh(graph: RepoGraph | null, maxAgeMs?: number): boolean;

package/dist/graph/import-extractor.d.ts

@@ -0,0 +1,44 @@
+import type { ImportEdge } from './types';
+/**
+ * Extract import edges from a source file.
+ *
+ * Uses regex-based parsing (the same proven approach as `src/tools/imports.ts`
+ * and `src/tools/co-change-analyzer.ts`). Tree-sitter is intentionally not used
+ * here because:
+ *   1. The existing regex patterns are battle-tested across the codebase.
+ *   2. Import statements have stable, simple syntax that regex handles reliably.
+ *   3. Avoiding the per-file Tree-sitter parse keeps full-graph builds fast
+ *      enough to be interactive (target: <5s for 50k LOC).
+ *
+ * Supported languages:
+ *   - TypeScript / JavaScript (.ts/.tsx/.js/.jsx/.mjs/.cjs) — ES modules + CJS require
+ *   - Python (.py) — `import x` and `from x import y`
+ *   - Go (.go) — `import "path"` and `import (...)` blocks
+ *   - Rust (.rs) — `use path::module`
+ *
+ * Only RELATIVE imports are tracked as graph edges. External package imports
+ * (e.g. 'react', 'fmt', 'std::fs') are skipped — they are not part of the
+ * intra-repo dependency graph.
+ */
+export interface ExtractImportsOptions {
+    /** Absolute path to the source file (used for relative resolution). */
+    absoluteFilePath: string;
+    /** Absolute workspace root (used for relative path computation). */
+    workspaceRoot: string;
+    /** Optional pre-read content; if omitted the file is read from disk. */
+    content?: string;
+}
+/** Source file extensions we know how to scan. */
+export declare const SOURCE_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
+export declare function getLanguageFromExtension(ext: string): string | null;
+/**
+ * Extract import edges for a single file. Returns an empty array when the
+ * language is unsupported or the file cannot be parsed.
+ *
+ * Resolution strategy for edge.target:
+ *   - TS/JS: probe extensions (.ts, .tsx, .js, .jsx, .mjs, .cjs, /index.*).
+ *   - Python: probe .py and /__init__.py for relative imports only.
+ *   - Go/Rust: target left empty (intra-repo resolution requires module/crate
+ *     metadata that is out of scope for Phase 1). The raw module is preserved.
+ */
+export declare function extractImports(opts: ExtractImportsOptions): ImportEdge[];

package/dist/graph/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Repo graph: structural codebase awareness for swarm agents.
+ *
+ * Public surface:
+ *   - Types (RepoGraph, FileNode, ImportEdge, ExportedSymbol, ...)
+ *   - Builders (buildRepoGraph, processFile, findSourceFiles)
+ *   - Store (loadGraph, saveGraph, buildAndSaveGraph, updateGraphIncremental, isGraphFresh, getGraphPath)
+ *   - Query (getImporters, getDependencies, getSymbolConsumers, getBlastRadius,
+ *            getKeyFiles, getLocalizationContext, normalizeGraphPath, resetQueryCache)
+ */
+export { type BuildOptions, buildRepoGraph, findSourceFiles, processFile, } from './graph-builder';
+export { getBlastRadius, getDependencies, getImporters, getKeyFiles, getLocalizationContext, getSymbolConsumers, normalizeGraphPath, resetQueryCache, } from './graph-query';
+export { buildAndSaveGraph, getGraphPath, isGraphFresh, loadGraph, saveGraph, updateGraphIncremental, } from './graph-store';
+export { extractImports, getLanguageFromExtension, SOURCE_EXTENSIONS, } from './import-extractor';
+export { extractExportedSymbols } from './symbol-extractor';
+export * from './types';

package/dist/graph/symbol-extractor.d.ts

@@ -0,0 +1,17 @@
+import type { ExportedSymbol } from './types';
+/**
+ * Extract exported symbols from a single file.
+ *
+ * Reuses the proven regex-based extractors from `src/tools/symbols.ts`
+ * (`extractTSSymbols` / `extractPythonSymbols`) and maps their internal
+ * SymbolInfo shape to our `ExportedSymbol` type.
+ *
+ * For Go and Rust, exported-symbol extraction is best-effort (out of scope
+ * for Phase 1) — empty arrays are returned. The graph still tracks file-level
+ * import edges for these languages.
+ */
+/**
+ * @param relativeFilePath - file path relative to workspace root (forward-slash)
+ * @param workspaceRoot - absolute workspace root
+ */
+export declare function extractExportedSymbols(relativeFilePath: string, workspaceRoot: string): ExportedSymbol[];

package/dist/graph/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Repo graph data structures.
+ *
+ * The graph captures structural relationships between source files
+ * (imports/exports) so agents can reason about blast radius before editing.
+ *
+ * All paths are RELATIVE to the workspace root and FORWARD-SLASH normalized
+ * for cross-platform comparison.
+ */
+export type ImportType = 'named' | 'default' | 'namespace' | 'sideeffect' | 'require';
+export interface ImportEdge {
+    /** Importing file (relative, forward-slash). */
+    source: string;
+    /** Resolved imported file (relative, forward-slash). May be empty for unresolved imports. */
+    target: string;
+    /** Raw module specifier as written in the source (e.g. '../utils/path-security'). */
+    rawModule: string;
+    /** Named imports brought in (empty for sideeffect/namespace/default). */
+    importedSymbols: string[];
+    /** What kind of import statement this is. */
+    importType: ImportType;
+    /** 1-indexed line number where the import appears. */
+    line: number;
+}
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'enum' | 'const' | 'variable' | 'method' | 'property';
+export interface ExportedSymbol {
+    name: string;
+    kind: SymbolKind;
+    signature?: string;
+    line: number;
+}
+export interface FileNode {
+    /** Relative, forward-slash path. */
+    path: string;
+    /** Detected language id (e.g. 'typescript', 'python', 'go', 'rust'). */
+    language: string;
+    /** Symbols this file exports (or top-level definitions for languages without explicit exports). */
+    exports: ExportedSymbol[];
+    /** Outgoing import edges from this file. */
+    imports: ImportEdge[];
+    /** mtime of the source file (ms epoch) for incremental updates. */
+    mtimeMs: number;
+}
+export interface RepoGraph {
+    /** Schema version for migration. */
+    version: number;
+    /** ISO timestamp when this graph was built. */
+    buildTimestamp: string;
+    /** Workspace root used at build time (absolute, for diagnostics only). */
+    rootDir: string;
+    /** Files keyed by their relative forward-slash path. */
+    files: Record<string, FileNode>;
+}
+export interface FileReference {
+    file: string;
+    line?: number;
+    importType?: ImportType;
+}
+export interface SymbolReference {
+    file: string;
+    line: number;
+    importedAs: string;
+}
+export interface BlastRadiusResult {
+    target: string[];
+    directDependents: string[];
+    transitiveDependents: string[];
+    depthReached: number;
+    totalDependents: number;
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+}
+export interface LocalizationBlock {
+    target: string;
+    importerCount: number;
+    importers: FileReference[];
+    dependencyCount: number;
+    dependencies: FileReference[];
+    exportedSymbolsUsedExternally: string[];
+    blastRadius: BlastRadiusResult;
+    /** Compact human/LLM-readable summary suitable for context injection. */
+    summary: string;
+}
+export declare const REPO_GRAPH_SCHEMA_VERSION = 1;
+export declare const REPO_GRAPH_FILENAME = "repo-graph.json";

package/dist/hooks/__tests__/semantic-diff-injection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/adversarial-detector.d.ts

@@ -0,0 +1,50 @@
+import type { PluginConfig } from '../config';
+/**
+ * Resolve the model for a given agent by checking config overrides,
+ * swarm configurations, and falling back to defaults.
+ */
+export declare function resolveAgentModel(agentName: string, config: PluginConfig): string;
+/**
+ * Detect if two agents share the same model (adversarial pair).
+ * Returns the shared model string if matched, null otherwise.
+ */
+export declare function detectAdversarialPair(agentA: string, agentB: string, config: PluginConfig): string | null;
+/**
+ * Format an adversarial warning message based on policy.
+ */
+export declare function formatAdversarialWarning(agentA: string, agentB: string, sharedModel: string, policy: string): string;
+/**
+ * Adversarial pattern detection for semantic analysis of agent outputs.
+ * Uses string/regex matching to detect sophisticated adversarial behaviors.
+ */
+export interface AdversarialPatternMatch {
+    pattern: 'PRECEDENT_MANIPULATION' | 'SELF_REVIEW' | 'CONTENT_EXEMPTION' | 'GATE_DELEGATION_BYPASS' | 'VELOCITY_RATIONALIZATION' | 'INTER_AGENT_MANIPULATION' | 'GATE_MISCLASSIFICATION' | 'REJECTION_SPIRAL';
+    severity: 'HIGHEST' | 'HIGH' | 'MEDIUM' | 'LOW';
+    matchedText: string;
+    confidence: 'HIGH' | 'MEDIUM' | 'LOW';
+}
+/**
+ * Detect adversarial patterns in agent output text.
+ * Returns array of matches or empty array if no patterns detected.
+ */
+export declare function detectAdversarialPatterns(text: string): AdversarialPatternMatch[];
+/**
+ * Format a precedent manipulation detection event for JSONL emission.
+ */
+export declare function formatPrecedentManipulationEvent(match: AdversarialPatternMatch, agentName: string, phase: number): string;
+export declare function formatDebuggingSpiralEvent(match: AdversarialPatternMatch, taskId: string): string;
+export declare function handleDebuggingSpiral(match: AdversarialPatternMatch, taskId: string, directory: string): Promise<{
+    eventLogged: boolean;
+    checkpointCreated: boolean;
+    message: string;
+}>;
+/**
+ * Record a tool call for debugging spiral detection.
+ * Call this from toolAfter to track repetitive patterns.
+ */
+export declare function recordToolCall(tool: string, args: unknown, sessionId: string): void;
+/**
+ * Detect debugging spiral: same tool called 5+ times in a row with similar args
+ * within a 5-minute window. Indicates the agent is stuck in a loop.
+ */
+export declare function detectDebuggingSpiral(_directory: string, sessionId: string): Promise<AdversarialPatternMatch | null>;

package/dist/hooks/agent-activity.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Agent Activity Tracking Hooks
+ *
+ * Tracks tool usage through tool.execute.before and tool.execute.after hooks.
+ * Records timing, success/failure, and periodically flushes aggregated stats.
+ */
+import type { PluginConfig } from '../config/schema';
+/**
+ * Creates agent activity tracking hooks
+ * @param config Plugin configuration
+ * @param directory Project directory path
+ * @returns Tool before and after hook handlers
+ */
+export declare function createAgentActivityHooks(config: PluginConfig, directory: string): {
+    toolBefore: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};
+/**
+ * Flushes activity data to context.md file
+ * Ensures only one flush operation runs at a time
+ * @param directory Project directory path
+ */
+declare function flushActivityToFile(directory: string): Promise<void>;
+export { flushActivityToFile as _flushForTesting };

package/dist/hooks/co-change-suggester.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Co-Change Suggester Hook
+ *
+ * Analyzes file modifications and suggests co-change partners based on
+ * historical co-change data from .swarm/co-change.json. This hook fires
+ * after file-write tools complete and logs suggestions when co-change
+ * partners are detected.
+ */
+/**
+ * Represents a single co-change entry from the JSON file
+ */
+export interface CoChangeJsonEntry {
+    /** First file in the co-change pair */
+    fileA: string;
+    /** Second file in the co-change pair */
+    fileB: string;
+    /** Number of times these files were changed together */
+    coChangeCount: number;
+    /** Normalized Pointwise Mutual Information score (0-1) */
+    npmi: number;
+}
+/**
+ * Root structure of the co-change JSON file
+ */
+export interface CoChangeJson {
+    /** File format version */
+    version: string;
+    /** ISO timestamp when the file was generated */
+    generated: string;
+    /** Array of co-change entries */
+    entries: CoChangeJsonEntry[];
+}
+/**
+ * Reads and parses the .swarm/co-change.json file
+ * @param directory - The project directory containing .swarm folder
+ * @returns Parsed CoChangeJson or null if not found/invalid
+ */
+export declare function readCoChangeJson(directory: string): Promise<CoChangeJson | null>;
+/**
+ * Finds co-change partners for a given file
+ * @param entries - Array of co-change entries to search
+ * @param filePath - The file path to find partners for
+ * @returns Array of entries where the file appears as fileA or fileB
+ */
+export declare function getCoChangePartnersForFile(entries: CoChangeJsonEntry[], filePath: string): CoChangeJsonEntry[];
+/**
+ * Creates the co-change suggester hook
+ * @param directory - The project directory containing .swarm folder
+ * @returns A hook function that analyzes file writes for co-change suggestions
+ */
+export declare function createCoChangeSuggesterHook(directory: string): (input: unknown, output: unknown) => Promise<void>;

package/dist/hooks/compaction-customizer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compaction Customizer Hook
+ *
+ * Enhances session compaction by injecting swarm context from plan.md and context.md.
+ * Adds current phase information and key decisions to the compaction context.
+ */
+import type { PluginConfig } from '../config';
+/**
+ * Creates the experimental.session.compacting hook for compaction customization.
+ */
+export declare function createCompactionCustomizerHook(config: PluginConfig, directory: string): Record<string, unknown>;

package/dist/hooks/conflict-resolution.d.ts

@@ -0,0 +1,12 @@
+import type { AgentConflictDetectedEvent } from '../types/events.js';
+export interface ResolveAgentConflictInput {
+    sessionID: string;
+    phase: number;
+    taskId?: string;
+    sourceAgent: AgentConflictDetectedEvent['sourceAgent'];
+    targetAgent: AgentConflictDetectedEvent['targetAgent'];
+    conflictType: AgentConflictDetectedEvent['conflictType'];
+    rejectionCount?: number;
+    summary: string;
+}
+export declare function resolveAgentConflict(input: ResolveAgentConflictInput): void;

package/dist/hooks/context-budget.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Context Budget Tracker Hook
+ *
+ * Estimates token usage across all messages and injects budget warnings
+ * when thresholds are exceeded. Uses experimental.chat.messages.transform
+ * to provide proactive context management guidance to the architect agent.
+ */
+import type { PluginConfig } from '../config';
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Creates the experimental.chat.messages.transform hook for context budget tracking.
+ * Injects warnings when context usage exceeds configured thresholds.
+ * Only operates on messages for the architect agent.
+ */
+export declare function createContextBudgetHandler(config: PluginConfig): (_input: Record<string, never>, _output: {
+    messages?: MessageWithParts[];
+}) => Promise<void>;
+export {};

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

@@ -0,0 +1,70 @@
+/**
+ * Context Scoring Utility
+ *
+ * Pure scoring/ranking helpers for context injection budget.
+ * Implements deterministic, reproducible candidate ranking based on configurable weights.
+ */
+export type ContentType = 'prose' | 'code' | 'markdown' | 'json';
+export type CandidateKind = 'phase' | 'task' | 'decision' | 'evidence' | 'agent_context';
+export interface ContextCandidate {
+    id: string;
+    kind: CandidateKind;
+    text: string;
+    tokens: number;
+    priority: number;
+    metadata: {
+        contentType: ContentType;
+        dependencyDepth?: number;
+        decisionAgeHours?: number;
+        isCurrentTask?: boolean;
+        isBlockedTask?: boolean;
+        hasFailure?: boolean;
+        hasSuccess?: boolean;
+        hasEvidence?: boolean;
+    };
+}
+export interface RankedCandidate extends ContextCandidate {
+    score: number;
+}
+export interface ScoringWeights {
+    phase: number;
+    current_task: number;
+    blocked_task: number;
+    recent_failure: number;
+    recent_success: number;
+    evidence_presence: number;
+    decision_recency: number;
+    dependency_proximity: number;
+}
+export interface DecisionDecayConfig {
+    mode: 'linear' | 'exponential';
+    half_life_hours: number;
+}
+export interface TokenRatios {
+    prose: number;
+    code: number;
+    markdown: number;
+    json: number;
+}
+export interface ScoringConfig {
+    enabled: boolean;
+    max_candidates: number;
+    weights: ScoringWeights;
+    decision_decay: DecisionDecayConfig;
+    token_ratios: TokenRatios;
+}
+/**
+ * Rank context candidates by importance score.
+ *
+ * Scoring formula:
+ * - base_score = sum of (weight * feature_flag)
+ * - For items with dependency depth: adjusted_score = base_score / (1 + depth)
+ * - For decisions with age: age_factor = 2^(-age_hours / half_life_hours), score = decision_recency * age_factor
+ *
+ * Tie-breaker: score desc → priority desc → id asc (stable sort)
+ *
+ * @param candidates - Array of context candidates
+ * @param config - Scoring configuration
+ * @returns Ranked candidates (truncated to max_candidates, original order if disabled)
+ */
+export declare function rankCandidates(candidates: ContextCandidate[], config: ScoringConfig): RankedCandidate[];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,30 @@
+import type { CriticDriftResult, CuratorConfig, CuratorPhaseResult, DriftReport } from './curator-types.js';
+/**
+ * Read all prior drift reports from .swarm/drift-report-phase-*.json files.
+ * Returns reports sorted ascending by phase number.
+ * Skips corrupt/unreadable files with a console.warn.
+ */
+export declare function readPriorDriftReports(directory: string): Promise<DriftReport[]>;
+/**
+ * Write a drift report to .swarm/drift-report-phase-{N}.json.
+ * Creates .swarm/ if it doesn't exist.
+ * Returns the absolute path of the written file.
+ */
+export declare function writeDriftReport(directory: string, report: DriftReport): Promise<string>;
+/**
+ * Deterministic drift check for the given phase.
+ * Builds a structured DriftReport from curator data, plan, spec, and prior reports.
+ * Writes the report to .swarm/drift-report-phase-N.json.
+ * Emits 'curator.drift.completed' event on success.
+ * On any error: emits 'curator.error' event and returns a safe default result.
+ * NEVER throws — drift failures must not block phase_complete.
+ */
+export declare function runDeterministicDriftCheck(directory: string, phase: number, curatorResult: CuratorPhaseResult, config: CuratorConfig, injectAdvisory?: (message: string) => void): Promise<CriticDriftResult>;
+/**
+ * Build a truncated summary suitable for architect context injection.
+ * Format: "<drift_report>Phase N: {alignment} ({drift_score}) — {key finding}. {correction if any}.</drift_report>"
+ * Truncate to maxChars (simple slice). Tags may be broken when truncation occurs mid-tag.
+ * If ALIGNED with drift_score < 0.1: minimal output "Phase N: ALIGNED, all requirements on track."
+ * If MINOR_DRIFT or worse: include first_deviation and top correction.
+ */
+export declare function buildDriftInjectionText(report: DriftReport, maxChars: number): string;

package/dist/hooks/curator-llm-factory.d.ts

@@ -0,0 +1,20 @@
+import type { CuratorLLMDelegate } from './curator.js';
+/**
+ * Create a CuratorLLMDelegate that uses the opencode SDK to call
+ * the registered curator agent in CURATOR_INIT or CURATOR_PHASE mode.
+ *
+ * Uses an ephemeral session (create → prompt → delete) to avoid
+ * re-entrancy with the current session's message flow.
+ *
+ * The `mode` parameter determines which registered named agent is used:
+ *   - 'init'  → curator_init  (e.g. 'curator_init' or 'swarm1_curator_init')
+ *   - 'phase' → curator_phase (e.g. 'curator_phase' or 'swarm1_curator_phase')
+ *
+ * The optional `sessionId` parameter enables deterministic swarm resolution:
+ * when provided, the factory uses the calling session's registered agent to
+ * identify the swarm prefix, rather than scanning all active sessions.
+ * Pass `ctx?.sessionID` from tool handlers that have it available.
+ *
+ * Returns undefined if swarmState.opencodeClient is not set (e.g. in unit tests).
+ */
+export declare function createCuratorLLMDelegate(directory: string, mode?: 'init' | 'phase', sessionId?: string): CuratorLLMDelegate | undefined;