opencode-swarm 7.0.0-beta.1 → 7.0.0

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

@@ -0,0 +1,103 @@
+/**
+ * Curator types — phase context consolidation and drift detection.
+ * No runtime logic. Types only.
+ */
+import type { KnowledgeCategory } from './knowledge-types.js';
+/** Curator summary — anchored iterative format. Persisted to .swarm/curator-summary.json */
+export interface CuratorSummary {
+    schema_version: 1;
+    session_id: string;
+    last_updated: string;
+    last_phase_covered: number;
+    /** Running digest — extended each phase, never regenerated */
+    digest: string;
+    /** Phase-level digests for lookup */
+    phase_digests: PhaseDigestEntry[];
+    /** Accumulated compliance observations */
+    compliance_observations: ComplianceObservation[];
+    /** Knowledge update recommendations from the last curator run */
+    knowledge_recommendations: KnowledgeRecommendation[];
+}
+export interface PhaseDigestEntry {
+    phase: number;
+    timestamp: string;
+    summary: string;
+    agents_used: string[];
+    tasks_completed: number;
+    tasks_total: number;
+    key_decisions: string[];
+    blockers_resolved: string[];
+}
+export interface ComplianceObservation {
+    phase: number;
+    timestamp: string;
+    type: 'missing_reviewer' | 'missing_retro' | 'missing_sme' | 'skipped_test' | 'workflow_deviation';
+    description: string;
+    severity: 'info' | 'warning';
+}
+export interface KnowledgeRecommendation {
+    action: 'promote' | 'archive' | 'flag_contradiction' | 'rewrite';
+    entry_id?: string;
+    lesson: string;
+    reason: string;
+    category?: KnowledgeCategory;
+    confidence?: number;
+}
+/** Drift report — produced by critic after curator phase run */
+export interface DriftReport {
+    schema_version: 1;
+    phase: number;
+    timestamp: string;
+    /** Overall alignment verdict */
+    alignment: 'ALIGNED' | 'MINOR_DRIFT' | 'MAJOR_DRIFT' | 'OFF_SPEC';
+    /** Severity score 0.0-1.0 (0 = perfectly aligned, 1 = completely off-spec) */
+    drift_score: number;
+    /** First deviation point if drift detected */
+    first_deviation: {
+        phase: number;
+        task: string;
+        description: string;
+    } | null;
+    /** Compounding effects across phases */
+    compounding_effects: string[];
+    /** Recommended course corrections */
+    corrections: string[];
+    /** Spec requirements checked */
+    requirements_checked: number;
+    /** Spec requirements satisfied */
+    requirements_satisfied: number;
+    /** Scope additions not in original plan */
+    scope_additions: string[];
+    /** Truncated summary for architect context injection */
+    injection_summary: string;
+}
+export interface CuratorConfig {
+    enabled: boolean;
+    init_enabled: boolean;
+    phase_enabled: boolean;
+    max_summary_tokens: number;
+    min_knowledge_confidence: number;
+    compliance_report: boolean;
+    suppress_warnings: boolean;
+    drift_inject_max_chars: number;
+    llm_timeout_ms?: number;
+}
+export interface CuratorInitResult {
+    briefing: string;
+    contradictions: string[];
+    knowledge_entries_reviewed: number;
+    prior_phases_covered: number;
+}
+export interface CuratorPhaseResult {
+    phase: number;
+    digest: PhaseDigestEntry;
+    compliance: ComplianceObservation[];
+    knowledge_recommendations: KnowledgeRecommendation[];
+    summary_updated: boolean;
+}
+export interface CriticDriftResult {
+    phase: number;
+    report: DriftReport;
+    report_path: string;
+    injection_text: string;
+}

package/dist/hooks/curator.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Curator core — file I/O for curator summary persistence.
+ * Extended incrementally: filterPhaseEvents, checkPhaseCompliance,
+ * runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates added in subsequent tasks.
+ *
+ * LLM delegation: runCuratorPhase and runCuratorInit accept an optional llmDelegate
+ * callback for LLM-based analysis. When provided, the prepared data context is sent
+ * to the explorer agent in CURATOR_PHASE/CURATOR_INIT mode for richer analysis.
+ * When the delegate is absent or fails, falls back to data-only behavior.
+ *
+ * ## Curator Agent Dispatch Modes
+ *
+ * Curator agents are dispatched in two ways:
+ *
+ * 1. **Factory dispatch** (standard): Created via `createCuratorAgent` from curator-agent.ts,
+ *    exposed through agents/index.ts. These appear in agent lists and are part of the
+ *    standard agent factory.
+ *
+ * 2. **Hook dispatch** (internal): curator.ts imports CURATOR_INIT_PROMPT and CURATOR_PHASE_PROMPT
+ *    from explorer.ts and dispatches curator analysis directly via hook callbacks. These
+ *    hook-dispatched curators do NOT go through the standard agent factory and are NOT
+ *    included in agent lists (e.g., AGENTS.md, agent discovery, the agent registry).
+ *
+ * This dual dispatch means agent lists are incomplete — they capture factory-dispatched
+ * curators but omit hook-dispatched ones. This is by design for hook-internal operations.
+ */
+import type { ComplianceObservation, CuratorConfig, CuratorInitResult, CuratorPhaseResult, CuratorSummary, KnowledgeRecommendation } from './curator-types.js';
+import type { KnowledgeConfig } from './knowledge-types.js';
+/**
+ * Optional LLM delegate callback type.
+ * Takes a system prompt and user input, returns the LLM output text.
+ * Used to delegate analysis to the explorer agent in CURATOR mode.
+ */
+export type CuratorLLMDelegate = (systemPrompt: string, userInput: string, signal?: AbortSignal) => Promise<string>;
+/**
+ * Parse OBSERVATIONS section from curator LLM output.
+ * Expected format per line: "- entry <uuid> (<observable>): [text]"
+ * Observable types: appears high-confidence, appears stale, could be tighter,
+ * contradicts project state, new candidate
+ * Action hints are extracted from parenthetical directives like "(suggests boost confidence, mark hive_eligible)"
+ */
+export declare function parseKnowledgeRecommendations(llmOutput: string): KnowledgeRecommendation[];
+/**
+ * Read curator summary from .swarm/curator-summary.json
+ * @param directory - The workspace directory
+ * @returns CuratorSummary if valid, null if missing or invalid
+ */
+export declare function readCuratorSummary(directory: string): Promise<CuratorSummary | null>;
+/**
+ * Write curator summary to .swarm/curator-summary.json
+ * @param directory - The workspace directory
+ * @param summary - The curator summary to write
+ */
+export declare function writeCuratorSummary(directory: string, summary: CuratorSummary): Promise<void>;
+/**
+ * Filter events from JSONL by phase or timestamp.
+ * @param eventsJsonl - Raw JSONL string of events
+ * @param phase - Phase number to filter by
+ * @param sinceTimestamp - Optional ISO 8601 timestamp to filter events after
+ * @returns Array of parsed event objects
+ */
+export declare function filterPhaseEvents(eventsJsonl: string, phase: number, sinceTimestamp?: string): object[];
+/**
+ * Check compliance for a phase based on events and dispatched agents.
+ * @param phaseEvents - Array of events for the phase
+ * @param agentsDispatched - List of agent names that were dispatched
+ * @param requiredAgents - List of required agent names for this phase
+ * @param phase - Phase number
+ * @returns Array of compliance observations
+ */
+export declare function checkPhaseCompliance(phaseEvents: object[], agentsDispatched: string[], requiredAgents: string[], phase: number): ComplianceObservation[];
+/**
+ * Prepare curator init data: reads prior summary, knowledge entries, and context.md.
+ * When an llmDelegate is provided, delegates to the explorer agent in CURATOR_INIT mode
+ * for LLM-based analysis that enhances the data-only briefing.
+ * @param directory - The workspace directory
+ * @param config - Curator configuration
+ * @param llmDelegate - Optional LLM delegate for enhanced analysis
+ * @returns CuratorInitResult with briefing text, contradictions, and stats
+ */
+export declare function runCuratorInit(directory: string, config: CuratorConfig, llmDelegate?: CuratorLLMDelegate): Promise<CuratorInitResult>;
+/**
+ * Run curator phase analysis: reads events, runs compliance, updates and writes summary.
+ * When an llmDelegate is provided, delegates to the explorer agent in CURATOR_PHASE mode
+ * for LLM-based architectural drift analysis and knowledge recommendations.
+ * @param directory - The workspace directory
+ * @param phase - The phase number that just completed
+ * @param agentsDispatched - List of agent names dispatched in this phase
+ * @param config - Curator configuration
+ * @param knowledgeConfig - Knowledge configuration (used for knowledge path resolution)
+ * @param llmDelegate - Optional LLM delegate for enhanced analysis
+ * @returns CuratorPhaseResult with digest, compliance, and recommendations
+ */
+export declare function runCuratorPhase(directory: string, phase: number, agentsDispatched: string[], config: CuratorConfig, _knowledgeConfig: {
+    directory?: string;
+}, llmDelegate?: CuratorLLMDelegate): Promise<CuratorPhaseResult>;
+/**
+ * Apply curator knowledge recommendations: promote, archive, or flag contradictions.
+ * Uses readKnowledge + rewriteKnowledge pattern for atomic updates.
+ * @param directory - The workspace directory
+ * @param recommendations - Array of knowledge recommendations to apply
+ * @param knowledgeConfig - Knowledge configuration (for path resolution)
+ * @returns Counts of applied and skipped recommendations
+ */
+export declare function applyCuratorKnowledgeUpdates(directory: string, recommendations: KnowledgeRecommendation[], knowledgeConfig: KnowledgeConfig): Promise<{
+    applied: number;
+    skipped: number;
+}>;

package/dist/hooks/dark-matter-detector.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Dark Matter Detector Hook
+ *
+ * This hook reads `.swarm/dark-matter.md` — a markdown file that lists
+ * unresolved coupling gaps. When unconsumed items exist in this file,
+ * the hook logs a reminder hint to the user.
+ */
+/**
+ * Parses dark matter gaps from markdown content
+ *
+ * @param content - The markdown content to parse
+ * @returns Object containing arrays of unresolved and resolved gap descriptions
+ */
+export declare function parseDarkMatterGaps(content: string): {
+    unresolved: string[];
+    resolved: string[];
+};
+/**
+ * Reads and parses the dark matter gaps file
+ *
+ * @param directory - The project directory containing .swarm folder
+ * @returns Object with unresolved and resolved gaps, or null if file not found/empty
+ */
+export declare function readDarkMatterMd(directory: string): Promise<{
+    unresolved: string[];
+    resolved: string[];
+} | null>;
+/**
+ * Creates the dark matter detector hook
+ *
+ * This hook fires on `toolAfter` and checks for unresolved coupling gaps
+ * in `.swarm/dark-matter.md`. It logs a reminder hint when gaps exist,
+ * with rate-limiting to avoid excessive file I/O.
+ *
+ * @param directory - The project directory containing .swarm folder
+ * @returns Hook function that checks for unresolved dark matter gaps
+ */
+export declare function createDarkMatterDetectorHook(directory: string): (input: unknown, output: unknown) => Promise<void>;

package/dist/hooks/delegation-gate.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Delegation Gate Hook
+ *
+ * Warns the architect when coder delegations are too large or batched.
+ * Uses experimental.chat.messages.transform to provide non-blocking guidance.
+ */
+import type { PluginConfig } from '../config';
+import type { DelegationEnvelope, EnvelopeValidationResult } from '../types/delegation.js';
+/**
+ * v6.33.1 CRIT-1: Fallback map for declared coder scope by taskId.
+ * When messagesTransform sets declaredCoderScope on the architect session,
+ * the coder session may not exist yet. This map allows scope-guard to look up
+ * the scope by taskId when the session's declaredCoderScope is null.
+ *
+ * v6.70.0 gap-closure: this map is module-scoped (not inside `swarmState`) and
+ * is cleared by `resetSwarmState` via `clearPendingCoderScope()` below. Without
+ * that cleanup, a `/swarm close` followed by a new session with a colliding
+ * taskId (e.g. "1.1") would inherit stale scope from the previous swarm.
+ */
+export declare const pendingCoderScopeByTaskId: Map<string, string[]>;
+/**
+ * v6.70.0 gap-closure: clears the pending coder-scope map. Exported as a
+ * helper (rather than importing the map directly from state.ts) to avoid the
+ * circular import `state.ts ↔ delegation-gate.ts`. Called by `resetSwarmState`.
+ */
+export declare function clearPendingCoderScope(): void;
+/**
+ * Parses a string to extract a DelegationEnvelope.
+ * Returns null if no valid envelope is found.
+ * Never throws - all errors are caught and result in null.
+ */
+export declare function parseDelegationEnvelope(content: string, directory?: string): DelegationEnvelope | null;
+interface ValidationContext {
+    planTasks: string[];
+    validAgents: string[];
+}
+/**
+ * Validates a DelegationEnvelope against the current plan and agent list.
+ * Returns { valid: true } on success, or { valid: false; reason: string } on failure.
+ */
+export declare function validateDelegationEnvelope(envelope: unknown, context: ValidationContext): EnvelopeValidationResult;
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Creates the experimental.chat.messages.transform hook for delegation gating.
+ * Inspects coder delegations and warns when tasks are oversized or batched.
+ */
+export declare function createDelegationGateHook(config: PluginConfig, directory: string): {
+    messagesTransform: (input: Record<string, never>, output: {
+        messages?: MessageWithParts[];
+    }) => Promise<void>;
+    toolBefore: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args?: Record<string, unknown>;
+    }, output: unknown) => Promise<void>;
+};
+export {};

package/dist/hooks/delegation-gate.evidence.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Integration tests for evidence recording in delegation-gate.ts toolAfter.
+ */
+export {};

package/dist/hooks/delegation-gate.getEvidenceTaskId.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * delegation-gate.getEvidenceTaskId.test.ts
+ *
+ * Verification tests for the async conversion of getEvidenceTaskId.
+ * Tests the function behavior by recreating its logic in isolation since
+ * the function is private (not exported) and depends on fs.promises.
+ *
+ * Covers:
+ * 1. Function returns a Promise (is async)
+ * 2. Function resolves to correct task ID when currentTaskId is set
+ * 3. Function resolves to correct task ID when lastCoderDelegationTaskId is set
+ * 4. Function falls back to taskWorkflowStates when above are null
+ * 5. Function returns null when plan.json doesn't exist (ENOENT)
+ * 6. Function returns null when plan.json has no in_progress tasks
+ * 7. Function returns null when session has direct task_id (early return path via currentTaskId)
+ * 8. Path traversal is blocked (security hardening)
+ * 9. Malformed JSON returns null
+ * 10. Empty/invalid directory returns null
+ */
+export {};

package/dist/hooks/delegation-gate.plan-fallback-security.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adversarial security tests for getEvidenceTaskId plan.json fallback.
+ *
+ * Tests security-hardened fallback mechanism that reads .swarm/plan.json only after
+ * exhausting live task state. Focuses on attack vectors:
+ * - Path traversal via plan.json path
+ * - Malformed durable state (JSON bombs, circular refs)
+ * - Invalid directory inputs
+ * - Oversized/hostile inputs
+ * - Boundary violations
+ * - Symlink attacks
+ */
+export {};

package/dist/hooks/delegation-gate.plan-fallback.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for getEvidenceTaskId plan.json fallback behavior.
+ * Verifies durable task ID recovery from .swarm/plan.json when in-memory state is empty.
+ */
+export {};

package/dist/hooks/delegation-gate.seed-state.test.d.ts

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

package/dist/hooks/delegation-gate.turbo-evidence.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for Task 3.16: Propagate turboMode through evidence recording
+ *
+ * This verifies that when a session has turboMode enabled, the turbo flag is
+ * recorded in the evidence JSON files for all agent delegations (reviewer,
+ * test_engineer, docs, designer, critic, explorer, sme, coder).
+ */
+export {};

package/dist/hooks/delegation-gate.verify.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Verification tests for callID→evidenceTaskId map in delegation-gate.ts
+ *
+ * Tests verify the map behavior indirectly through evidence recording outcomes:
+ * 1. Map stores callID→evidenceTaskId after determining the taskId
+ * 2. Map is checked first before getEvidenceTaskId fallback
+ * 3. Map entry is cleaned up after successful evidence recording
+ * 4. Map entry is cleaned up even when evidence recording errors
+ * 5. Fallback works when storedTaskId is not in map
+ */
+export {};

package/dist/hooks/delegation-ledger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * DELEGATION LEDGER (v6.31 Task 3.2)
+ *
+ * tool.execute.after hook that maintains a per-session in-memory ledger of tool calls
+ * made during a delegation. When the architect session receives a message (resume),
+ * injects a compact DELEGATION SUMMARY via pendingAdvisoryMessages.
+ *
+ * No file I/O — fully in-memory.
+ */
+export interface LedgerEntry {
+    agent: string;
+    tool: string;
+    file?: string;
+    duration_ms: number;
+    success: boolean;
+    timestamp: number;
+}
+export interface DelegationLedgerConfig {
+    enabled: boolean;
+}
+/**
+ * Creates the delegation ledger hook pair (toolAfter + summary injection).
+ */
+export declare function createDelegationLedgerHook(config: Partial<DelegationLedgerConfig>, _directory: string, // reserved for future use
+injectAdvisory: (sessionId: string, message: string) => void): {
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args?: Record<string, unknown>;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    onArchitectResume: (sessionId: string) => void;
+};

package/dist/hooks/delegation-ledger.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * delegation-ledger.test.ts
+ *
+ * Tests for delegation-ledger hook (Task 3.2):
+ * 1. toolAfter records entries in ledgerBySession
+ * 2. onArchitectResume generates DELEGATION SUMMARY when non-architect tool calls exist
+ * 3. onArchitectResume is no-op when no entries exist
+ * 4. Success is false when output starts with 'Error:'
+ * 5. Success is true for normal output
+ */
+export {};

package/dist/hooks/delegation-sanitizer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Delegation message sanitization - Layer 2 defense against inter-agent manipulation.
+ * Strips attempt metadata, urgency references, and consequence claims from gate agent messages.
+ */
+declare const SANITIZATION_PATTERNS: RegExp[];
+/**
+ * Sanitize a message by stripping manipulation patterns.
+ * Returns sanitized text and logs if any stripping occurred.
+ */
+export declare function sanitizeMessage(text: string, patterns?: RegExp[]): {
+    sanitized: string;
+    modified: boolean;
+    stripped: string[];
+};
+/**
+ * Check if message is to a gate agent (reviewer, test_engineer, critic).
+ */
+export declare function isGateAgentMessage(agentName: string): boolean;
+/**
+ * Create a hook that sanitizes delegation messages to gate agents.
+ * @param directory - The project directory containing the .swarm folder
+ */
+export declare function createDelegationSanitizerHook(directory: string): (input: unknown, output: unknown) => Promise<void>;
+export { SANITIZATION_PATTERNS };

package/dist/hooks/delegation-tracker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Delegation Tracker Hook
+ *
+ * Tracks agent delegation by monitoring chat.message events with agent fields.
+ * Updates the active agent map and optionally logs delegation chain entries.
+ */
+import type { PluginConfig } from '../config/schema';
+export type { DelegationReason } from '../state';
+/**
+ * Creates the chat.message hook for delegation tracking.
+ */
+export declare function createDelegationTrackerHook(config: PluginConfig, guardrailsEnabled?: boolean): (input: {
+    sessionID: string;
+    agent?: string;
+}, output: Record<string, unknown>) => Promise<void>;

package/dist/hooks/diff-scope.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Diff scope validator — compares files changed in git against the declared scope
+ * for a given task in plan.json. Returns a warning string if undeclared files
+ * were modified, or null if in-scope, no scope declared, or git unavailable.
+ * Never throws.
+ */
+/**
+ * Validate that git-changed files match the declared scope for a task.
+ * Returns a warning string if undeclared files were modified, null otherwise.
+ * Never throws.
+ */
+export declare function validateDiffScope(taskId: string, directory: string): Promise<string | null>;

package/dist/hooks/diff-scope.test.d.ts

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

package/dist/hooks/extractors.d.ts

@@ -0,0 +1,53 @@
+import type { Plan } from '../config/plan-schema';
+/**
+ * Swarm File Extractors
+ *
+ * Pure parsing functions for extracting structured data from .swarm/ files.
+ * Used by system-enhancer and compaction-customizer hooks.
+ */
+/**
+ * Extracts the current phase information from plan content.
+ */
+export declare function extractCurrentPhase(planContent: string): string | null;
+/**
+ * Extracts the first incomplete task from the current IN PROGRESS phase.
+ */
+export declare function extractCurrentTask(planContent: string): string | null;
+/**
+ * Extracts decisions section from context content.
+ */
+export declare function extractDecisions(contextContent: string, maxChars?: number): string | null;
+/**
+ * Extracts incomplete tasks from plan content under the current IN PROGRESS phase.
+ */
+export declare function extractIncompleteTasks(planContent: string, maxChars?: number): string | null;
+/**
+ * Extracts patterns section from context content.
+ */
+export declare function extractPatterns(contextContent: string, maxChars?: number): string | null;
+/**
+ * Extracts current phase info from a Plan object.
+ */
+export declare function extractCurrentPhaseFromPlan(plan: Plan): string | null;
+/**
+ * Extracts the first incomplete task from the current phase of a Plan object.
+ */
+export declare function extractCurrentTaskFromPlan(plan: Plan): string | null;
+/**
+ * Extracts incomplete tasks from the current phase of a Plan object.
+ */
+export declare function extractIncompleteTasksFromPlan(plan: Plan, maxChars?: number): string | null;
+/**
+ * Extracts plan cursor - a concise summary of current phase, current task,
+ * and lookahead tasks for context-aware agent communication.
+ *
+ * @param planContent - The raw plan markdown content
+ * @param options - Optional configuration
+ * @param options.maxTokens - Target max tokens (default 1500, ~6000 chars)
+ * @param options.lookaheadTasks - Number of lookahead tasks (default 2)
+ * @returns A [SWARM PLAN CURSOR] block with phase summaries and task details
+ */
+export declare function extractPlanCursor(planContent: string, options?: {
+    maxTokens?: number;
+    lookaheadTasks?: number;
+}): string;

package/dist/hooks/full-auto-intercept.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Full-Auto Intercept Hook
+ *
+ * Intercepts architect messages in full-auto mode and triggers autonomous oversight
+ * when the architect outputs escalation patterns (questions, phase completion prompts).
+ *
+ * This hook runs as a chat.message transform — it inspects the architect's output
+ * and injects the critic's autonomous oversight response when escalation is detected.
+ */
+import type { PluginConfig } from '../config';
+interface MessageWithParts {
+    info: {
+        role: string;
+        agent?: string;
+        sessionID?: string;
+        [key: string]: unknown;
+    };
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Result from critic dispatch — used to inject verdict into message stream.
+ */
+interface CriticDispatchResult {
+    verdict: string;
+    reasoning: string;
+    evidenceChecked: string[];
+    antiPatternsDetected: string[];
+    escalationNeeded: boolean;
+    rawResponse: string;
+}
+/**
+ * Parses the critic's structured text response into a CriticDispatchResult.
+ * The critic response format is:
+ *   VERDICT: APPROVED | NEEDS_REVISION | ...
+ *   REASONING: [text with possible multi-line content]
+ *   EVIDENCE_CHECKED: [list]
+ *   ANTI_PATTERNS_DETECTED: [list or "none"]
+ *   ESCALATION_NEEDED: YES | NO
+ */
+export declare function parseCriticResponse(rawResponse: string): CriticDispatchResult;
+/**
+ * Injects the critic's verdict as an assistant message after the architect's message.
+ * This makes the verdict visible in the chat without modifying the architect's output.
+ *
+ * Verdict handling:
+ * - ANSWER: injects critic's reasoning as the assistant's answer
+ * - ESCALATE_TO_HUMAN: triggers escalation (handled separately)
+ * - APPROVED / NEEDS_REVISION / REJECTED / BLOCKED / REPHRASE: injects verdict message
+ */
+export declare function injectVerdictIntoMessages(messages: MessageWithParts[], architectIndex: number, criticResult: CriticDispatchResult, escalationType: 'phase_completion' | 'question', oversightAgentName: string): void;
+/**
+ * Handles critic dispatch and writes the auto_oversight event after the critic responds.
+ *
+ * This function encapsulates the critic invocation and event writing flow.
+ * The critic response is awaited before writing the event to events.jsonl.
+ */
+export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string): Promise<CriticDispatchResult>;
+/**
+ * Creates the full-auto intercept hook factory.
+ *
+ * This hook intercepts architect messages in full-auto mode and triggers
+ * autonomous oversight when escalation patterns are detected.
+ *
+ * @param config - Plugin configuration containing full_auto settings
+ * @param directory - Working directory from plugin init context
+ * @returns Hook object with messagesTransform function
+ */
+export declare function createFullAutoInterceptHook(config: PluginConfig, directory: string): {
+    messagesTransform: (input: Record<string, never>, output: {
+        messages?: MessageWithParts[];
+    }) => Promise<void>;
+};
+export {};