opencode-swarm 6.6.1 → 6.8.1

package/dist/{config → src/config}/schema.d.ts

@@ -245,6 +245,205 @@ export declare const CheckpointConfigSchema: z.ZodObject<{
     auto_checkpoint_threshold: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type CheckpointConfig = z.infer<typeof CheckpointConfigSchema>;
+export declare const GitingestConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    endpoint: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type GitingestConfig = z.infer<typeof GitingestConfigSchema>;
+export declare const AutomationModeSchema: z.ZodEnum<{
+    auto: "auto";
+    manual: "manual";
+    hybrid: "hybrid";
+}>;
+export type AutomationMode = z.infer<typeof AutomationModeSchema>;
+export declare const AutomationCapabilitiesSchema: z.ZodObject<{
+    plan_sync: z.ZodDefault<z.ZodBoolean>;
+    phase_preflight: z.ZodDefault<z.ZodBoolean>;
+    config_doctor_on_startup: z.ZodDefault<z.ZodBoolean>;
+    config_doctor_autofix: z.ZodDefault<z.ZodBoolean>;
+    evidence_auto_summaries: z.ZodDefault<z.ZodBoolean>;
+    decision_drift_detection: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AutomationCapabilities = z.infer<typeof AutomationCapabilitiesSchema>;
+declare const AutomationConfigSchemaBase: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        manual: "manual";
+        hybrid: "hybrid";
+    }>>;
+    capabilities: z.ZodDefault<z.ZodObject<{
+        plan_sync: z.ZodDefault<z.ZodBoolean>;
+        phase_preflight: z.ZodDefault<z.ZodBoolean>;
+        config_doctor_on_startup: z.ZodDefault<z.ZodBoolean>;
+        config_doctor_autofix: z.ZodDefault<z.ZodBoolean>;
+        evidence_auto_summaries: z.ZodDefault<z.ZodBoolean>;
+        decision_drift_detection: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AutomationConfig = z.infer<typeof AutomationConfigSchemaBase>;
+export declare const AutomationConfigSchema: z.ZodType<AutomationConfig>;
+export declare const pluginConfigShape: {
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    swarms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    max_iterations: z.ZodDefault<z.ZodNumber>;
+    qa_retry_limit: z.ZodDefault<z.ZodNumber>;
+    inject_phase_reminders: z.ZodDefault<z.ZodBoolean>;
+    hooks: z.ZodOptional<z.ZodObject<{
+        system_enhancer: z.ZodDefault<z.ZodBoolean>;
+        compaction: z.ZodDefault<z.ZodBoolean>;
+        agent_activity: z.ZodDefault<z.ZodBoolean>;
+        delegation_tracker: z.ZodDefault<z.ZodBoolean>;
+        agent_awareness_max_chars: z.ZodDefault<z.ZodNumber>;
+        delegation_gate: z.ZodDefault<z.ZodBoolean>;
+        delegation_max_chars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    context_budget: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        warn_threshold: z.ZodDefault<z.ZodNumber>;
+        critical_threshold: z.ZodDefault<z.ZodNumber>;
+        model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+        scoring: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            max_candidates: z.ZodDefault<z.ZodNumber>;
+            weights: z.ZodOptional<z.ZodObject<{
+                phase: z.ZodDefault<z.ZodNumber>;
+                current_task: z.ZodDefault<z.ZodNumber>;
+                blocked_task: z.ZodDefault<z.ZodNumber>;
+                recent_failure: z.ZodDefault<z.ZodNumber>;
+                recent_success: z.ZodDefault<z.ZodNumber>;
+                evidence_presence: z.ZodDefault<z.ZodNumber>;
+                decision_recency: z.ZodDefault<z.ZodNumber>;
+                dependency_proximity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            decision_decay: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    linear: "linear";
+                    exponential: "exponential";
+                }>>;
+                half_life_hours: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            token_ratios: z.ZodOptional<z.ZodObject<{
+                prose: z.ZodDefault<z.ZodNumber>;
+                code: z.ZodDefault<z.ZodNumber>;
+                markdown: z.ZodDefault<z.ZodNumber>;
+                json: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    guardrails: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        max_tool_calls: z.ZodDefault<z.ZodNumber>;
+        max_duration_minutes: z.ZodDefault<z.ZodNumber>;
+        max_repetitions: z.ZodDefault<z.ZodNumber>;
+        max_consecutive_errors: z.ZodDefault<z.ZodNumber>;
+        warning_threshold: z.ZodDefault<z.ZodNumber>;
+        idle_timeout_minutes: z.ZodDefault<z.ZodNumber>;
+        profiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            max_tool_calls: z.ZodOptional<z.ZodNumber>;
+            max_duration_minutes: z.ZodOptional<z.ZodNumber>;
+            max_repetitions: z.ZodOptional<z.ZodNumber>;
+            max_consecutive_errors: z.ZodOptional<z.ZodNumber>;
+            warning_threshold: z.ZodOptional<z.ZodNumber>;
+            idle_timeout_minutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    evidence: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        max_age_days: z.ZodDefault<z.ZodNumber>;
+        max_bundles: z.ZodDefault<z.ZodNumber>;
+        auto_archive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    summaries: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        threshold_bytes: z.ZodDefault<z.ZodNumber>;
+        max_summary_chars: z.ZodDefault<z.ZodNumber>;
+        max_stored_bytes: z.ZodDefault<z.ZodNumber>;
+        retention_days: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    review_passes: z.ZodOptional<z.ZodObject<{
+        always_security_review: z.ZodDefault<z.ZodBoolean>;
+        security_globs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    integration_analysis: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    docs: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        doc_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    gitingest: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        endpoint: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    ui_review: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        trigger_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        trigger_keywords: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    compaction_advisory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        thresholds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        message: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    lint: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            check: "check";
+            fix: "fix";
+        }>>;
+        linter: z.ZodDefault<z.ZodEnum<{
+            biome: "biome";
+            eslint: "eslint";
+            auto: "auto";
+        }>>;
+        patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    secretscan: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        extensions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    checkpoint: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        auto_checkpoint_threshold: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    automation: z.ZodOptional<z.ZodType<{
+        mode: "auto" | "manual" | "hybrid";
+        capabilities: {
+            plan_sync: boolean;
+            phase_preflight: boolean;
+            config_doctor_on_startup: boolean;
+            config_doctor_autofix: boolean;
+            evidence_auto_summaries: boolean;
+            decision_drift_detection: boolean;
+        };
+    }, unknown, z.core.$ZodTypeInternals<{
+        mode: "auto" | "manual" | "hybrid";
+        capabilities: {
+            plan_sync: boolean;
+            phase_preflight: boolean;
+            config_doctor_on_startup: boolean;
+            config_doctor_autofix: boolean;
+            evidence_auto_summaries: boolean;
+            decision_drift_detection: boolean;
+        };
+    }, unknown>>>;
+};
+export declare const PLUGIN_CONFIG_ALLOWED_KEYS: Set<string>;
 export declare const PluginConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
@@ -346,6 +545,10 @@ export declare const PluginConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         doc_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    gitingest: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        endpoint: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
     ui_review: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         trigger_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -380,6 +583,27 @@ export declare const PluginConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         auto_checkpoint_threshold: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    automation: z.ZodOptional<z.ZodType<{
+        mode: "auto" | "manual" | "hybrid";
+        capabilities: {
+            plan_sync: boolean;
+            phase_preflight: boolean;
+            config_doctor_on_startup: boolean;
+            config_doctor_autofix: boolean;
+            evidence_auto_summaries: boolean;
+            decision_drift_detection: boolean;
+        };
+    }, unknown, z.core.$ZodTypeInternals<{
+        mode: "auto" | "manual" | "hybrid";
+        capabilities: {
+            plan_sync: boolean;
+            phase_preflight: boolean;
+            config_doctor_on_startup: boolean;
+            config_doctor_autofix: boolean;
+            evidence_auto_summaries: boolean;
+            decision_drift_detection: boolean;
+        };
+    }, unknown>>>;
 }, z.core.$strip>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export type { AgentName, PipelineAgentName, QAAgentName, } from './constants';

package/dist/{hooks → src/hooks}/index.d.ts

@@ -5,6 +5,7 @@ export { createDelegationGateHook } from './delegation-gate';
 export { createDelegationTrackerHook } from './delegation-tracker';
 export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';
 export { createGuardrailsHooks } from './guardrails';
+export { createPhaseMonitorHook } from './phase-monitor';
 export { createPipelineTrackerHook } from './pipeline-tracker';
 export { createSystemEnhancerHook } from './system-enhancer';
 export { createToolSummarizerHook, resetSummaryIdCounter, } from './tool-summarizer';

package/dist/src/hooks/phase-monitor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase Monitor Hook
+ *
+ * Detects phase transitions by reading plan state on each system prompt transform.
+ * When a phase change is detected, triggers preflight via PreflightTriggerManager.
+ * Wrapped in safeHook — errors must never propagate.
+ */
+import type { PreflightTriggerManager } from '../background/trigger';
+/**
+ * Creates a hook that monitors plan phase transitions and triggers preflight.
+ *
+ * @param directory - Project directory (where .swarm/ lives)
+ * @param preflightManager - The PreflightTriggerManager to call on phase change
+ * @returns A safeHook-wrapped system.transform handler
+ */
+export declare function createPhaseMonitorHook(directory: string, preflightManager: PreflightTriggerManager): (input: unknown, output: unknown) => Promise<void>;

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '@opencode-ai/plugin';
+declare const OpenCodeSwarm: Plugin;
+export default OpenCodeSwarm;
+export type { AgentDefinition } from './agents';
+export type { AgentName, AutomationCapabilities, AutomationConfig, AutomationMode, PipelineAgentName, PluginConfig, QAAgentName, } from './config';

package/dist/{plan → src/plan}/manager.d.ts

@@ -6,11 +6,17 @@ import { type Plan, type TaskStatus } from '../config/plan-schema';
  */
 export declare function loadPlanJsonOnly(directory: string): Promise<Plan | null>;
 /**
- * Load and validate plan from .swarm/plan.json with 4-step precedence:
- * 1. .swarm/plan.json exists AND validates → return parsed Plan
- * 2. .swarm/plan.json exists but FAILS validation → log warning, fall to step 3
- * 3. .swarm/plan.md exists → call migrateLegacyPlan(), save result, return it
- * 4. Neither exists → return null
+ * Load and validate plan from .swarm/plan.json with auto-heal sync.
+ *
+ * 4-step precedence with auto-heal:
+ * 1. .swarm/plan.json exists AND validates ->
+ *    a) If plan.md missing or stale -> regenerate plan.md from plan.json
+ *    b) Return parsed Plan
+ * 2. .swarm/plan.json exists but FAILS validation ->
+ *    a) If plan.md exists -> migrate from plan.md, save valid plan.json, then derive plan.md
+ *    b) Return migrated Plan
+ * 3. .swarm/plan.md exists only -> migrate from plan.md, save both files, return Plan
+ * 4. Neither exists -> return null
  */
 export declare function loadPlan(directory: string): Promise<Plan | null>;
 /**
@@ -24,7 +30,8 @@ export declare function savePlan(directory: string, plan: Plan): Promise<void>;
  */
 export declare function updateTaskStatus(directory: string, taskId: string, status: TaskStatus): Promise<Plan>;
 /**
- * Generate markdown view from plan object
+ * Generate deterministic markdown view from plan object.
+ * Ensures stable ordering: phases by ID (ascending), tasks by ID (natural numeric).
  */
 export declare function derivePlanMarkdown(plan: Plan): string;
 /**

package/dist/src/services/config-doctor.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Config Doctor Service
+ *
+ * Validates opencode-swarm config shape, detects stale/invalid settings,
+ * classifies findings by severity, and proposes safe auto-fixes.
+ */
+import type { PluginConfig } from '../config/schema';
+/** Severity levels for config findings */
+export type FindingSeverity = 'info' | 'warn' | 'error';
+/** A single config finding */
+export interface ConfigFinding {
+    /** Unique identifier for this finding type */
+    id: string;
+    /** Human-readable title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Severity level */
+    severity: FindingSeverity;
+    /** Path to the config key (dot notation) */
+    path: string;
+    /** Current invalid/stale value */
+    currentValue?: unknown;
+    /** Proposed safe fix (if available) */
+    proposedFix?: ConfigFix;
+    /** Whether this is auto-fixable (safe, non-destructive) */
+    autoFixable: boolean;
+}
+/** A proposed config fix */
+export interface ConfigFix {
+    /** Type of fix */
+    type: 'remove' | 'update' | 'add';
+    /** Path to the config key (dot notation) */
+    path: string;
+    /** Value to set (for update/add) */
+    value?: unknown;
+    /** Description of what the fix does */
+    description: string;
+    /** Risk level - only 'low' is auto-fixable */
+    risk: 'low' | 'medium' | 'high';
+}
+/** Result of running the config doctor */
+export interface ConfigDoctorResult {
+    /** All findings from the doctor run */
+    findings: ConfigFinding[];
+    /** Findings by severity */
+    summary: {
+        info: number;
+        warn: number;
+        error: number;
+    };
+    /** Whether any auto-fixable issues were found */
+    hasAutoFixableIssues: boolean;
+    /** Timestamp of the run */
+    timestamp: number;
+    /** The config that was analyzed */
+    configSource: string;
+}
+/** Backup artifact for rollback */
+export interface ConfigBackup {
+    /** When the backup was created */
+    createdAt: number;
+    /** The backed up config content */
+    configPath: string;
+    /** The raw config content */
+    content: string;
+    /** Hash of content for integrity verification */
+    contentHash: string;
+}
+/**
+ * Get config file paths
+ */
+export declare function getConfigPaths(directory: string): {
+    userConfigPath: string;
+    projectConfigPath: string;
+};
+/**
+ * Create a backup of the current config
+ */
+export declare function createConfigBackup(directory: string): ConfigBackup | null;
+/**
+ * Write a backup artifact to .swarm directory
+ * Persists full backup content to support rollback/restore
+ */
+export declare function writeBackupArtifact(directory: string, backup: ConfigBackup): string;
+/**
+ * Restore config from a backup artifact
+ * @param backupPath - Path to the backup artifact file
+ * @param directory - The working directory (for validating config paths)
+ * @returns the path to the restored config file, or null if restore failed
+ */
+export declare function restoreFromBackup(backupPath: string, directory: string): string | null;
+/**
+ * Run the config doctor on a loaded config
+ */
+export declare function runConfigDoctor(config: PluginConfig, directory: string): ConfigDoctorResult;
+/**
+ * Apply safe auto-fixes to config
+ * Only applies low-risk, non-destructive fixes
+ */
+export declare function applySafeAutoFixes(directory: string, result: ConfigDoctorResult): {
+    appliedFixes: ConfigFix[];
+    updatedConfigPath: string | null;
+};
+/**
+ * Write doctor result to .swarm directory for GUI consumption
+ */
+export declare function writeDoctorArtifact(directory: string, result: ConfigDoctorResult): string;
+/**
+ * Check if config doctor should run on startup
+ */
+export declare function shouldRunOnStartup(automationConfig: {
+    mode: string;
+    capabilities?: Record<string, boolean>;
+} | undefined): boolean;
+/**
+ * Full config doctor run with backup and fix application
+ */
+export declare function runConfigDoctorWithFixes(directory: string, config: PluginConfig, autoFix?: boolean): Promise<{
+    result: ConfigDoctorResult;
+    backupPath: string | null;
+    appliedFixes: ConfigFix[];
+    updatedConfigPath: string | null;
+    artifactPath: string | null;
+}>;

package/dist/src/services/config-doctor.security.test.d.ts

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

package/dist/src/services/config-doctor.test.d.ts

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

package/dist/src/services/decision-drift-analyzer.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Decision Drift Analyzer Service
+ *
+ * Analyzes decisions from context.md and current plan state to detect:
+ * 1. Stale decisions (age/phase mismatch or no recent confirmation)
+ * 2. Contradictions (new decisions conflicting with existing ones)
+ *
+ * Results are integrated into architect context injection.
+ */
+/**
+ * Drift signal severity levels
+ */
+export type DriftSeverity = 'warning' | 'error';
+/**
+ * A single decision extracted from context.md
+ */
+export interface Decision {
+    /** Raw decision text */
+    text: string;
+    /** Phase when decision was made (extracted or inferred) */
+    phase: number | null;
+    /** Whether decision has a confirmation marker */
+    confirmed: boolean;
+    /** Timestamp if available */
+    timestamp: string | null;
+    /** Line number in source file */
+    line: number;
+}
+/**
+ * A detected drift signal
+ */
+export interface DriftSignal {
+    /** Unique identifier for this drift */
+    id: string;
+    /** Severity level */
+    severity: DriftSeverity;
+    /** Type of drift */
+    type: 'stale' | 'contradiction';
+    /** Human-readable description */
+    message: string;
+    /** Source reference (file and line) */
+    source: {
+        file: string;
+        line: number;
+    };
+    /** Related decisions if applicable */
+    relatedDecisions?: string[];
+    /** Suggested resolution hint */
+    hint?: string;
+}
+/**
+ * Result of drift analysis
+ */
+export interface DriftAnalysisResult {
+    /** Whether drift was detected */
+    hasDrift: boolean;
+    /** List of drift signals */
+    signals: DriftSignal[];
+    /** Summary text for context injection */
+    summary: string;
+    /** Timestamp of analysis */
+    analyzedAt: string;
+}
+/**
+ * Configuration for drift analyzer
+ */
+export interface DriftAnalyzerConfig {
+    /** Maximum age in phases before a decision is considered stale */
+    staleThresholdPhases: number;
+    /** Whether to detect contradictions */
+    detectContradictions: boolean;
+    /** Maximum signals to return */
+    maxSignals: number;
+}
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_DRIFT_CONFIG: DriftAnalyzerConfig;
+/**
+ * Extract decisions from context.md content
+ */
+export declare function extractDecisionsFromContext(contextContent: string): Decision[];
+/**
+ * Simple keyword-based contradiction detection
+ * Looks for decisions that express opposite intentions
+ */
+export declare function findContradictions(decisions: Decision[]): DriftSignal[];
+/**
+ * Analyze decision drift
+ */
+export declare function analyzeDecisionDrift(directory: string, config?: Partial<DriftAnalyzerConfig>): Promise<DriftAnalysisResult>;
+/**
+ * Format drift signals as a structured section for context injection
+ * Returns bounded output suitable for LLM context
+ */
+export declare function formatDriftForContext(result: DriftAnalysisResult): string;

package/dist/src/services/diagnose-service.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A single health check result.
+ */
+export interface HealthCheck {
+    name: string;
+    status: '✅' | '❌';
+    detail: string;
+}
+/**
+ * Structured diagnose data returned by the diagnose service.
+ */
+export interface DiagnoseData {
+    checks: HealthCheck[];
+    passCount: number;
+    totalCount: number;
+    allPassed: boolean;
+}
+/**
+ * Get diagnose data from the swarm directory.
+ * Returns structured health checks for GUI, background flows, or commands.
+ */
+export declare function getDiagnoseData(directory: string): Promise<DiagnoseData>;
+/**
+ * Format diagnose data as markdown for command output.
+ */
+export declare function formatDiagnoseMarkdown(diagnose: DiagnoseData): string;
+/**
+ * Handle diagnose command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleDiagnoseCommand(directory: string, _args: string[]): Promise<string>;

package/dist/src/services/evidence-service.d.ts

@@ -0,0 +1,65 @@
+import type { Evidence } from '../config/evidence-schema';
+/**
+ * Structured evidence entry for a task.
+ */
+export interface EvidenceEntryData {
+    index: number;
+    entry: Evidence;
+    type: string;
+    verdict: string;
+    verdictIcon: string;
+    agent: string;
+    summary: string;
+    timestamp: string;
+    details: Record<string, string | number | undefined>;
+}
+/**
+ * Structured evidence data for a single task.
+ */
+export interface TaskEvidenceData {
+    hasEvidence: boolean;
+    taskId: string;
+    createdAt: string;
+    updatedAt: string;
+    entries: EvidenceEntryData[];
+}
+/**
+ * Structured evidence list data for all tasks.
+ */
+export interface EvidenceListData {
+    hasEvidence: boolean;
+    tasks: Array<{
+        taskId: string;
+        entryCount: number;
+        lastUpdated: string;
+    }>;
+}
+/**
+ * Get emoji for verdict type (exported for use in entry formatting).
+ */
+export declare function getVerdictEmoji(verdict: string): string;
+/**
+ * Get evidence data for a specific task.
+ */
+export declare function getTaskEvidenceData(directory: string, taskId: string): Promise<TaskEvidenceData>;
+/**
+ * Get list of all evidence bundles.
+ */
+export declare function getEvidenceListData(directory: string): Promise<EvidenceListData>;
+/**
+ * Format evidence list as markdown for command output.
+ */
+export declare function formatEvidenceListMarkdown(list: EvidenceListData): string;
+/**
+ * Format task evidence as markdown for command output.
+ */
+export declare function formatTaskEvidenceMarkdown(evidence: TaskEvidenceData): string;
+/**
+ * Handle evidence command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleEvidenceCommand(directory: string, args: string[]): Promise<string>;
+/**
+ * Handle evidence summary command - generates completion ratio and blockers report.
+ */
+export declare function handleEvidenceSummaryCommand(directory: string): Promise<string>;