opencode-swarm 7.0.0-beta.1 → 7.0.1

package/dist/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/services/diagnose-service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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;
+}
+/**
+ * Resolve the grammar WASM directory from an arbitrary module directory.
+ * Exported for unit testing — callers should not pass import.meta.url directly.
+ *
+ * Rules:
+ *   - Dev source  (ends with /src/services): go up one level → src/lang/grammars
+ *   - CLI bundle  (ends with /cli):           go up one level → dist/lang/grammars
+ *   - Main bundle (everything else):          stay put        → dist/lang/grammars
+ */
+export declare function resolveGrammarDir(thisDir: string): string;
+/**
+ * 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/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>;

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

@@ -0,0 +1,75 @@
+/**
+ * Evidence Summary Service
+ *
+ * Provides deterministic evidence aggregation per task and phase.
+ * Produces machine-readable and human-readable summary artifacts.
+ */
+import type { PhaseStatus, TaskStatus } from '../config/plan-schema';
+/** Evidence types required for task completion */
+export declare const REQUIRED_EVIDENCE_TYPES: readonly ["review", "test"];
+export type RequiredEvidenceType = (typeof REQUIRED_EVIDENCE_TYPES)[number];
+/** Summary artifact schema version */
+export declare const EVIDENCE_SUMMARY_VERSION = "1.0.0";
+/** Evidence summary for a single task */
+export interface TaskEvidenceSummary {
+    taskId: string;
+    phase: number;
+    taskStatus: TaskStatus;
+    evidenceCount: number;
+    hasReview: boolean;
+    hasTest: boolean;
+    hasApproval: boolean;
+    missingEvidence: string[];
+    isComplete: boolean;
+    blockers: string[];
+    lastEvidenceTimestamp: string | null;
+}
+/** Phase evidence summary */
+export interface PhaseEvidenceSummary {
+    phaseId: number;
+    phaseName: string;
+    phaseStatus: PhaseStatus;
+    totalTasks: number;
+    completedTasks: number;
+    tasksWithEvidence: number;
+    tasksWithCompleteEvidence: number;
+    completionRatio: number;
+    missingEvidenceByType: Record<string, string[]>;
+    blockers: PhaseBlocker[];
+    tasks: TaskEvidenceSummary[];
+}
+/** Blockers preventing phase closure */
+export interface PhaseBlocker {
+    type: 'missing_evidence' | 'incomplete_task' | 'blocked_task';
+    taskId: string;
+    reason: string;
+    severity: 'high' | 'medium' | 'low';
+}
+/** Full evidence summary artifact */
+export interface EvidenceSummaryArtifact {
+    schema_version: typeof EVIDENCE_SUMMARY_VERSION;
+    generated_at: string;
+    planTitle: string;
+    currentPhase: number;
+    phaseSummaries: PhaseEvidenceSummary[];
+    overallCompletionRatio: number;
+    overallBlockers: PhaseBlocker[];
+    summaryText: string;
+}
+/**
+ * Build complete evidence summary artifact
+ *
+ * Aggregates evidence per task and phase, producing deterministic
+ * summary artifacts including completion ratio, missing evidence,
+ * blockers, and per-task status.
+ */
+export declare function buildEvidenceSummary(directory: string, currentPhase?: number): Promise<EvidenceSummaryArtifact | null>;
+/**
+ * Check if auto-summaries are enabled via feature flags
+ */
+export declare function isAutoSummaryEnabled(automationConfig?: {
+    capabilities?: {
+        evidence_auto_summaries?: boolean;
+    };
+    mode?: string;
+}): boolean;

package/dist/services/export-service.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Structured export data.
+ */
+export interface ExportData {
+    version: string;
+    exported: string;
+    plan: unknown;
+    context: string | null;
+    /** The plan's execution_profile, if set. Consumers must honour locked profiles. */
+    execution_profile?: {
+        parallelization_enabled: boolean;
+        max_concurrent_tasks: number;
+        council_parallel: boolean;
+        locked: boolean;
+    } | null;
+}
+/**
+ * Get export data from the swarm directory.
+ * Returns structured data for GUI, background flows, or commands.
+ */
+export declare function getExportData(directory: string): Promise<ExportData>;
+/**
+ * Format export data as markdown with JSON code block for command output.
+ */
+export declare function formatExportMarkdown(exportData: ExportData): string;
+/**
+ * Handle export command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleExportCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/handoff-service.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Handoff Service
+ *
+ * Provides structured handoff data for agent transitions between swarm sessions.
+ * Reads from .swarm files to gather current state for context-efficient handoffs.
+ */
+/**
+ * Pending QA state from agent sessions
+ */
+export interface PendingQA {
+    taskId: string;
+    lastFailure: string | null;
+}
+/**
+ * Delegation chain entry
+ */
+export interface DelegationEntry {
+    from: string;
+    to: string;
+    taskId: string;
+    timestamp: number;
+}
+/**
+ * Delegation state from session snapshot
+ */
+export interface DelegationState {
+    activeChains: string[];
+    delegationDepth: number;
+    pendingHandoffs: string[];
+}
+/**
+ * Structured handoff data for agent transitions
+ */
+export interface HandoffData {
+    /** ISO timestamp when data was generated */
+    generated: string;
+    /** Current phase number or name */
+    currentPhase: string | null;
+    /** Current task ID being worked on */
+    currentTask: string | null;
+    /** List of incomplete task IDs */
+    incompleteTasks: string[];
+    /** Pending QA state */
+    pendingQA: PendingQA | null;
+    /** Active agent name */
+    activeAgent: string | null;
+    /** Recent decisions from context.md */
+    recentDecisions: string[];
+    /** Delegation state */
+    delegationState: DelegationState | null;
+    /** Locked execution_profile for this plan, if set. Resuming sessions must honour it. */
+    execution_profile?: {
+        parallelization_enabled: boolean;
+        max_concurrent_tasks: number;
+        council_parallel: boolean;
+        locked: boolean;
+    } | null;
+}
+/**
+ * Get handoff data from the swarm directory.
+ * Reads session state, plan, and context to build comprehensive handoff info.
+ */
+export declare function getHandoffData(directory: string): Promise<HandoffData>;
+/**
+ * Format handoff data as terse markdown for LLM consumption.
+ * Targets under 2K tokens for efficient context injection.
+ */
+export declare function formatHandoffMarkdown(data: HandoffData): string;
+/**
+ * Format handoff data as a continuation prompt for new agent sessions.
+ * Returns a terse markdown code block with essential context and explicit
+ * resumption instructions. Designed to be copy-pasted into a new session.
+ */
+export declare function formatContinuationPrompt(data: HandoffData): string;

package/dist/services/history-service.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Structured history data for a single phase.
+ */
+export interface PhaseHistoryData {
+    id: number;
+    name: string;
+    status: 'complete' | 'in_progress' | 'pending' | 'blocked' | 'closed';
+    statusText: string;
+    statusIcon: string;
+    completedTasks: number;
+    totalTasks: number;
+    tasksDisplay: string;
+}
+/**
+ * Structured history data returned by the history service.
+ */
+export interface HistoryData {
+    hasPlan: boolean;
+    phases: PhaseHistoryData[];
+    isLegacy: boolean;
+}
+/**
+ * Get history data from the swarm directory.
+ * Returns structured data for GUI, background flows, or commands.
+ */
+export declare function getHistoryData(directory: string): Promise<HistoryData>;
+/**
+ * Format history data as markdown for command output.
+ */
+export declare function formatHistoryMarkdown(history: HistoryData): string;
+/**
+ * Handle history command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleHistoryCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/index.d.ts

@@ -0,0 +1,13 @@
+export { analyzeDecisionDrift, DEFAULT_DRIFT_CONFIG, type Decision, type DriftAnalysisResult, type DriftAnalyzerConfig, type DriftSeverity, type DriftSignal, extractDecisionsFromContext, findContradictions, formatDriftForContext, } from './decision-drift-analyzer';
+export { applySafeAutoFixes, type ConfigBackup, type ConfigDoctorResult, type ConfigFinding, type ConfigFix, createConfigBackup, type FindingSeverity, getConfigPaths, runConfigDoctor, runConfigDoctorWithFixes, shouldRunOnStartup, writeBackupArtifact, writeDoctorArtifact, } from './config-doctor';
+export { type BudgetState, type ContextBudgetConfig, type ContextBudgetReport, DEFAULT_CONTEXT_BUDGET_CONFIG, estimateTokens, formatBudgetWarning, getContextBudgetReport, getDefaultConfig, } from './context-budget-service';
+export { type DiagnoseData, formatDiagnoseMarkdown, getDiagnoseData, type HealthCheck, handleDiagnoseCommand, } from './diagnose-service';
+export { type EvidenceEntryData, type EvidenceListData, formatEvidenceListMarkdown, formatTaskEvidenceMarkdown, getEvidenceListData, getTaskEvidenceData, getVerdictEmoji, handleEvidenceCommand, type TaskEvidenceData, } from './evidence-service';
+export { buildEvidenceSummary, EVIDENCE_SUMMARY_VERSION, type EvidenceSummaryArtifact, isAutoSummaryEnabled, type PhaseBlocker, type PhaseEvidenceSummary, REQUIRED_EVIDENCE_TYPES, type TaskEvidenceSummary, } from './evidence-summary-service';
+export { type ExportData, formatExportMarkdown, getExportData, handleExportCommand, } from './export-service';
+export { type DelegationState, formatHandoffMarkdown, getHandoffData, type HandoffData, type PendingQA, } from './handoff-service';
+export { formatHistoryMarkdown, getHistoryData, type HistoryData, handleHistoryCommand, type PhaseHistoryData, } from './history-service';
+export { formatPlanMarkdown, getPlanData, handlePlanCommand, type PlanData, } from './plan-service';
+export { createPreflightIntegration, type PreflightIntegrationConfig, runManualPreflight, } from './preflight-integration';
+export { formatPreflightMarkdown, handlePreflightCommand, type PreflightCheckResult, type PreflightCheckType, type PreflightConfig, type PreflightReport, runPreflight, } from './preflight-service';
+export { formatStatusMarkdown, getStatusData, handleStatusCommand, type StatusData, } from './status-service';

package/dist/services/plan-service.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured plan data for a specific phase or full plan.
+ */
+export interface PlanData {
+    hasPlan: boolean;
+    fullMarkdown: string;
+    requestedPhase: number | null;
+    phaseMarkdown: string | null;
+    errorMessage: string | null;
+    isLegacy: boolean;
+}
+/**
+ * Get plan data from the swarm directory.
+ * Returns structured data for GUI, background flows, or commands.
+ */
+export declare function getPlanData(directory: string, phaseArg?: string | number): Promise<PlanData>;
+/**
+ * Format plan data as markdown for command output.
+ */
+export declare function formatPlanMarkdown(planData: PlanData): string;
+/**
+ * Handle plan command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handlePlanCommand(directory: string, args: string[]): Promise<string>;

package/dist/services/preflight-integration.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Preflight Background Integration
+ *
+ * Wires the preflight service to background automation:
+ * - Subscribes to preflight.requested events
+ * - Runs preflight checks
+ * - Updates status artifact with results
+ */
+import { PreflightTriggerManager } from '../background/trigger';
+import type { AutomationConfig } from '../config/schema';
+import { type PreflightConfig, type PreflightReport } from '../services/preflight-service';
+/** Integration configuration */
+export interface PreflightIntegrationConfig {
+    /** Automation configuration (required for capability gating) */
+    automationConfig: AutomationConfig;
+    /** Directory to run preflight in */
+    directory: string;
+    /** Swarm directory for status artifact */
+    swarmDir: string;
+    /** Preflight check configuration */
+    preflightConfig?: PreflightConfig;
+    /** Whether to update status artifact (default true) */
+    updateStatusArtifact?: boolean;
+}
+/**
+ * Create preflight integration
+ *
+ * Sets up the handler that will be called when preflight is requested.
+ * Returns the trigger manager and cleanup function.
+ */
+export declare function createPreflightIntegration(config: PreflightIntegrationConfig): {
+    manager: PreflightTriggerManager;
+    cleanup: () => void;
+};
+/**
+ * Run preflight manually (for testing or CLI)
+ */
+export declare function runManualPreflight(directory: string, phase: number, config?: PreflightConfig): Promise<PreflightReport>;

package/dist/services/preflight-service.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Preflight Automation Service
+ *
+ * Runs automated preflight checks for release readiness:
+ * - lint check
+ * - tests check (sane verification scope)
+ * - secrets check
+ * - evidence completeness check
+ * - version consistency check
+ *
+ * Returns deterministic structured result with per-check status + overall verdict.
+ * Callable by background flow (from preflight.requested events).
+ */
+/** Preflight check types */
+export type PreflightCheckType = 'lint' | 'tests' | 'secrets' | 'evidence' | 'version' | 'req_coverage';
+/** Individual check status */
+export interface PreflightCheckResult {
+    type: PreflightCheckType;
+    status: 'pass' | 'fail' | 'skip' | 'error';
+    message: string;
+    details?: Record<string, unknown>;
+    durationMs?: number;
+}
+/** Preflight report structure */
+export interface PreflightReport {
+    id: string;
+    timestamp: number;
+    phase: number;
+    overall: 'pass' | 'fail' | 'skipped';
+    checks: PreflightCheckResult[];
+    totalDurationMs: number;
+    message: string;
+}
+/** Preflight configuration */
+export interface PreflightConfig {
+    /** Timeout per check in ms (default 60s, min 5s, max 300s) */
+    checkTimeoutMs?: number;
+    /** Skip tests check (default false) */
+    skipTests?: boolean;
+    /** Skip secrets check (default false) */
+    skipSecrets?: boolean;
+    /** Skip evidence check (default false) */
+    skipEvidence?: boolean;
+    /** Skip version check (default false) */
+    skipVersion?: boolean;
+    /** Test scope (default 'convention' for faster preflight) */
+    testScope?: 'all' | 'convention' | 'graph';
+    /** Linter to use (default 'biome') */
+    linter?: 'biome' | 'eslint';
+}
+/**
+ * Run all preflight checks
+ */
+export declare function runPreflight(dir: string, phase: number, config?: PreflightConfig): Promise<PreflightReport>;
+/**
+ * Format preflight report as markdown
+ */
+export declare function formatPreflightMarkdown(report: PreflightReport): string;
+/**
+ * Handle preflight command - thin adapter for CLI
+ */
+export declare function handlePreflightCommand(directory: string, _args: string[]): Promise<string>;

package/dist/services/run-memory.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Run Memory Service
+ *
+ * Provides append-only per-task outcome logging for tracking task execution
+ * results across swarm sessions. Used to avoid repeating known failure patterns.
+ */
+/**
+ * Represents a single task execution outcome entry
+ */
+export interface RunMemoryEntry {
+    /** ISO timestamp when the entry was recorded */
+    timestamp: string;
+    /** Plan.json task ID (e.g. "3.2") */
+    taskId: string;
+    /** SHA256 hash of taskId + sorted file targets, first 8 chars */
+    taskFingerprint: string;
+    /** Which agent executed the task (e.g. "coder") */
+    agent: string;
+    /** Outcome of the task execution */
+    outcome: 'pass' | 'fail' | 'retry' | 'skip';
+    /** 1-indexed attempt number */
+    attemptNumber: number;
+    /** One-line failure reason (only for fail/retry outcomes) */
+    failureReason?: string;
+    /** Files that were modified during this attempt */
+    filesModified?: string[];
+    /** Wall-clock time in milliseconds */
+    durationMs?: number;
+}
+/**
+ * Generate a task fingerprint from taskId and file targets
+ *
+ * @param taskId - The task identifier
+ * @param fileTargets - Array of file paths that were targeted
+ * @returns First 8 characters of SHA256 hash
+ */
+export declare function generateTaskFingerprint(taskId: string, fileTargets: string[]): string;
+/**
+ * Append a task outcome entry to the run memory log
+ *
+ * @param directory - The swarm workspace directory
+ * @param entry - The outcome entry to record
+ */
+export declare function recordOutcome(directory: string, entry: RunMemoryEntry): Promise<void>;
+/**
+ * Get all entries for a specific task ID
+ *
+ * @param directory - The swarm workspace directory
+ * @param taskId - The task identifier to filter by
+ * @returns Array of matching entries
+ */
+export declare function getTaskHistory(directory: string, taskId: string): Promise<RunMemoryEntry[]>;
+/**
+ * Get all failure and retry entries
+ *
+ * @param directory - The swarm workspace directory
+ * @returns Array of fail/retry entries
+ */
+export declare function getFailures(directory: string): Promise<RunMemoryEntry[]>;
+/**
+ * Generate a compact summary of task failures for context injection
+ *
+ * @param directory - The swarm workspace directory
+ * @returns Formatted summary string (≤500 tokens) or null if no failures
+ */
+export declare function getRunMemorySummary(directory: string): Promise<string | null>;

package/dist/services/status-service.d.ts

@@ -0,0 +1,35 @@
+import type { AgentDefinition } from '../agents';
+/**
+ * Structured status data returned by the status service.
+ * This can be used by GUI, background flows, or command adapters.
+ */
+export interface StatusData {
+    hasPlan: boolean;
+    currentPhase: string;
+    completedTasks: number;
+    totalTasks: number;
+    agentCount: number;
+    isLegacy: boolean;
+    turboMode: boolean;
+    /** Last known context budget percentage (0-100), or null if not yet measured */
+    contextBudgetPct: number | null;
+    /** Number of context compaction events triggered this session */
+    compactionCount: number;
+    /** ISO timestamp of last compaction snapshot, or null if none */
+    lastSnapshotAt: string | null;
+}
+/**
+ * Get status data from the swarm directory.
+ * Returns structured data that can be used by GUI, background flows, or commands.
+ */
+export declare function getStatusData(directory: string, agents: Record<string, AgentDefinition>): Promise<StatusData>;
+/**
+ * Format status data as markdown for command output.
+ * This is the thin adapter that delegates to the service.
+ */
+export declare function formatStatusMarkdown(status: StatusData): string;
+/**
+ * Handle status command - delegates to service and formats output.
+ * Kept for backward compatibility - thin adapter.
+ */
+export declare function handleStatusCommand(directory: string, agents: Record<string, AgentDefinition>): Promise<string>;

package/dist/services/status-service.turbo-indicator.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Task 3.18: Turbo Mode indicator in status output
+ * Verifies that the status-service surfaces the current bypass mode
+ */
+export {};