opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/commands/acknowledge-spec-drift.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handle /swarm acknowledge-spec-drift command
+ * Acknowledges and clears a previously detected spec drift staleness warning
+ */
+export declare function handleAcknowledgeSpecDriftCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/brainstorm.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Handle /swarm brainstorm command.
+ *
+ * Returns a trigger prompt instructing the architect to enter
+ * MODE: BRAINSTORM — the seven-phase planning workflow defined in the
+ * architect prompt: CONTEXT SCAN → DIALOGUE → APPROACHES → DESIGN SECTIONS
+ * → SPEC WRITE + SELF-REVIEW → QA GATE SELECTION → TRANSITION.
+ *
+ * Any arguments become the initial topic/problem statement for the
+ * architect to reason about. The topic is sanitized to prevent prompt
+ * injection of rival MODE: headers or newline-based control sequences.
+ */
+export declare function handleBrainstormCommand(_directory: string, args: string[]): Promise<string>;

package/dist/commands/brainstorm.test.d.ts

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

package/dist/commands/checkpoint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handle /swarm checkpoint command
+ * Creates, lists, restores, or deletes checkpoints with optional label
+ */
+export declare function handleCheckpointCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/close.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Handles /swarm close command - performs full terminal session finalization:
+ * 0. Guarantee: mark all incomplete phases/tasks as closed
+ * 1. Finalize: write retrospectives, produce terminal summary
+ * 2. Archive: create timestamped bundle of swarm artifacts
+ * 3. Clean: clear active-state files that confuse future swarms
+ * 4. Align: safe git alignment to main
+ *
+ * Must be idempotent - safe to run multiple times.
+ */
+export declare function handleCloseCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/command-adapters.security.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adversarial Security Tests for Command Adapters (Task 5.10)
+ *
+ * ATTACK VECTORS COVERED:
+ * 1. Path Traversal - attempts to escape .swarm directory via command args
+ * 2. Null Byte Injection - injecting null bytes to truncate paths/strings
+ * 3. Control Character Injection - injecting control chars (0x00-0x1F)
+ * 4. Command Injection - shell metacharacters in args
+ * 5. Argument Pollution - malformed, oversized, special character args
+ * 6. Flag Injection - malicious flag values and combinations
+ * 7. Unicode Attacks - unicode normalization/replacement attacks
+ * 8. Edge Cases - empty, extremely long, boundary values
+ */
+export {};

package/dist/commands/commands.test.d.ts

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

package/dist/commands/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles the /swarm config command.
+ * Loads and displays the current resolved plugin configuration.
+ */
+export declare function handleConfigCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/council.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Handle /swarm council command.
+ *
+ * Triggers the architect to enter MODE: COUNCIL — the General Council Mode
+ * deliberation workflow (Pre-flight → Round 1 parallel search → Synthesis +
+ * Deliberation → Moderator Pass → Output).
+ *
+ * Flag parsing:
+ *   --preset <name>   → emits "[MODE: COUNCIL preset=<name>] <question>"
+ *   --spec-review     → emits "[MODE: COUNCIL spec_review] <question>"
+ *   default           → emits "[MODE: COUNCIL] <question>"
+ *   no args           → returns usage string (no throw)
+ *
+ * Sanitizes the question to prevent prompt injection of rival MODE: headers
+ * or control sequences (mirrors brainstorm.ts).
+ */
+export declare function handleCouncilCommand(_directory: string, args: string[]): Promise<string>;

package/dist/commands/council.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for /swarm council command handler.
+ */
+export {};

package/dist/commands/curate.test.d.ts

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

package/dist/commands/doctor.d.ts

@@ -0,0 +1,17 @@
+import { type ConfigDoctorResult } from '../services/config-doctor';
+/**
+ * Format tool doctor result as markdown for command output.
+ *
+ * Exported for unit testing of the BLOCKING footer enforcement path.
+ */
+export declare function formatToolDoctorMarkdown(result: ConfigDoctorResult): string;
+/**
+ * Handle /swarm config doctor command.
+ * Maps to: config doctor service (runConfigDoctor)
+ */
+export declare function handleDoctorCommand(directory: string, args: string[]): Promise<string>;
+/**
+ * Handle /swarm doctor tools command.
+ * Maps to: tool doctor service (runToolDoctor)
+ */
+export declare function handleDoctorToolsCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/full-auto-config-guard.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for the config-guard behavior in handleFullAutoCommand.
+ *
+ * When swarmState.fullAutoEnabledInConfig is false, activation must be blocked.
+ * When it is true, activation must succeed. Disabling always works regardless.
+ */
+export {};

package/dist/commands/full-auto-discoverability.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for Full-Auto command discoverability fixes.
+ *
+ * Verifies that TUI shortcuts, error messages, and registry entries
+ * all use the dashed form (/swarm-full-auto) while maintaining backward
+ * compatibility with the spaced form (/swarm full-auto).
+ */
+export {};

package/dist/commands/full-auto-registration.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Full-Auto Mode command registration in src/commands/index.ts.
+ * Verifies import, export, help text, and registry routing for /swarm full-auto.
+ */
+export {};

package/dist/commands/full-auto-sessionid.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for empty sessionID handling in handleFullAutoCommand.
+ * Tests the CLI wiring fix where empty sessionID returns proper error message.
+ */
+export {};

package/dist/commands/full-auto.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Handles the /swarm full-auto command.
+ * Toggles Full-Auto Mode on or off for the active session.
+ *
+ * @param directory - Project directory (unused but kept for consistency with other commands)
+ * @param args - Optional argument: "on" | "off" | undefined (toggle behavior)
+ * @param sessionID - Session ID for accessing active session state
+ * @returns Feedback message about Full-Auto Mode state
+ */
+export declare function handleFullAutoCommand(_directory: string, args: string[], sessionID: string): Promise<string>;

package/dist/commands/full-auto.regression.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Regression Tests for Full-Auto Mode Integration.
+ *
+ * Covers the integration surfaces unique to full-auto mode:
+ * 1. /swarm full-auto command toggle, on, off
+ * 2. hasActiveFullAuto() - session-scoped and global-fallback behavior
+ * 3. System-enhancer hook injects FULL-AUTO MODE ACTIVE banner (Path A and global)
+ * 4. Counter reset side-effects are visible after disable
+ */
+export {};

package/dist/commands/full-auto.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for handleFullAutoCommand function.
+ * Tests the /swarm full-auto command toggle functionality,
+ * including the unique counter-reset behavior on disable.
+ */
+export {};

package/dist/commands/index.d.ts

@@ -0,0 +1,50 @@
+import type { AgentDefinition } from '../agents/index.js';
+export { handleAcknowledgeSpecDriftCommand } from './acknowledge-spec-drift';
+export { handleAgentsCommand } from './agents';
+export { handleAnalyzeCommand } from './analyze';
+export { handleArchiveCommand } from './archive';
+export { handleBenchmarkCommand } from './benchmark';
+export { handleBrainstormCommand } from './brainstorm';
+export { handleCheckpointCommand } from './checkpoint';
+export { handleClarifyCommand } from './clarify';
+export { handleCloseCommand } from './close';
+export { handleConfigCommand } from './config';
+export { handleCouncilCommand } from './council';
+export { handleCurateCommand } from './curate';
+export { handleDarkMatterCommand } from './dark-matter';
+export { handleDiagnoseCommand } from './diagnose';
+export { handleDoctorCommand } from './doctor';
+export { handleEvidenceCommand, handleEvidenceSummaryCommand, } from './evidence';
+export { handleExportCommand } from './export';
+export { handleFullAutoCommand } from './full-auto';
+export { handleHandoffCommand } from './handoff';
+export { handleHistoryCommand } from './history';
+export { handleKnowledgeListCommand, handleKnowledgeMigrateCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, } from './knowledge';
+export { handlePlanCommand } from './plan';
+export { handlePreflightCommand } from './preflight';
+export { handlePromoteCommand } from './promote';
+export { handleQaGatesCommand } from './qa-gates';
+export type { CommandContext, CommandEntry, RegisteredCommand, } from './registry.js';
+export { COMMAND_REGISTRY, resolveCommand, VALID_COMMANDS, } from './registry.js';
+export { handleResetCommand } from './reset';
+export { handleResetSessionCommand } from './reset-session';
+export { handleRetrieveCommand } from './retrieve';
+export { handleRollbackCommand } from './rollback';
+export { handleSimulateCommand } from './simulate';
+export { handleSpecifyCommand } from './specify';
+export { handleStatusCommand } from './status';
+export { handleSyncPlanCommand } from './sync-plan';
+export { handleTurboCommand } from './turbo';
+export { handleWriteRetroCommand } from './write-retro';
+export declare function buildHelpText(): string;
+/**
+ * Creates a command.execute.before handler for /swarm commands.
+ * Uses factory pattern to close over directory and agents.
+ */
+export declare function createSwarmCommandHandler(directory: string, agents: Record<string, AgentDefinition>): (input: {
+    command: string;
+    sessionID: string;
+    arguments: string;
+}, output: {
+    parts: unknown[];
+}) => Promise<void>;

package/dist/commands/index.help-text.test.d.ts

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

package/dist/commands/issue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Handle /swarm issue command.
+ *
+ * Triggers the architect to enter MODE: ISSUE_INGEST — the swarm issue ingest workflow.
+ * Accepts issue URL in multiple formats and sanitizes inputs against injection.
+ *
+ * Flag parsing:
+ *   --plan        → appends plan=true to emitted signal
+ *   --trace       → appends trace=true to emitted signal (implies --plan)
+ *   --no-repro    → appends noRepro=true to emitted signal
+ *   no args       → returns usage string (no throw)
+ */
+export declare function handleIssueCommand(_directory: string, args: string[]): string;

package/dist/{knowledge.d.ts → commands/knowledge.d.ts}

@@ -1,11 +1,13 @@
 /**
  * Handles /swarm knowledge quarantine <id> [reason] command.
  * Moves a knowledge entry to quarantine with optional reason.
+ * Accepts a full ID or a unique prefix.
  */
 export declare function handleKnowledgeQuarantineCommand(directory: string, args: string[]): Promise<string>;
 /**
  * Handles /swarm knowledge restore <id> command.
  * Restores a quarantined knowledge entry.
+ * Accepts a full ID or a unique prefix.
  */
 export declare function handleKnowledgeRestoreCommand(directory: string, args: string[]): Promise<string>;
 /**

package/dist/commands/pr-review.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Handle /swarm pr-review command.
+ *
+ * Triggers the architect to enter MODE: PR_REVIEW — the swarm PR review workflow.
+ * Accepts PR URL in multiple formats and sanitizes inputs against injection.
+ *
+ * Flag parsing:
+ *   --council       → appends council=true to emitted signal
+ *   no args         → returns usage string (no throw)
+ */
+export declare function handlePrReviewCommand(_directory: string, args: string[]): string;

package/dist/commands/qa-gates.d.ts

@@ -0,0 +1,15 @@
+/**
+ * /swarm qa-gates command.
+ *
+ * View, enable, or add session overrides for QA gates tied to the current
+ * plan's QA gate profile. Read-only display when called without arguments;
+ * ratchet-tighter enable/override when called with `enable <gate>...` or
+ * `override <gate>...`.
+ *
+ *   /swarm qa-gates                     -> show profile + effective gates
+ *   /swarm qa-gates enable <gate>...    -> persist into profile (architect)
+ *   /swarm qa-gates override <gate>...  -> session-only override
+ *
+ * Refuses to persist into a locked profile.
+ */
+export declare function handleQaGatesCommand(directory: string, args: string[], sessionID: string): Promise<string>;

package/dist/commands/qa-gates.test.d.ts

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

package/dist/commands/registry-documentation.test.d.ts

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

package/dist/commands/registry-type.test.d.ts

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

package/dist/commands/registry.d.ts

@@ -0,0 +1,282 @@
+import type { AgentDefinition } from '../agents/index.js';
+export type CommandContext = {
+    directory: string;
+    args: string[];
+    sessionID: string;
+    agents: Record<string, AgentDefinition>;
+};
+export type CommandResult = Promise<string>;
+export type CommandEntry = {
+    handler: (ctx: CommandContext) => CommandResult;
+    /** Human-readable description shown in /swarm help and CLI --help */
+    description: string;
+    /** If true, this command is only accessible as a sub-key of a parent command */
+    subcommandOf?: string;
+    /**
+     * 2-3 line behavioral summary: what the command does step-by-step,
+     * side effects, and safety guarantees.
+     */
+    details?: string;
+    /**
+     * Documents flags and positional arguments. Format: flags comma-separated with
+     * double-dash prefix, positional args in angle brackets.
+     * Example: args: '--dry-run, --confirm, <phase-number>'
+     */
+    args?: string;
+};
+export declare const COMMAND_REGISTRY: {
+    readonly 'acknowledge-spec-drift': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Acknowledge that the spec has drifted from the plan and suppress further warnings";
+        readonly args: "";
+    };
+    readonly status: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show current swarm state";
+    };
+    readonly plan: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show plan (optionally filter by phase number)";
+    };
+    readonly agents: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "List registered agents";
+    };
+    readonly history: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show completed phases summary";
+    };
+    readonly config: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show current resolved configuration";
+    };
+    readonly 'config doctor': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run config doctor checks";
+        readonly subcommandOf: "config";
+    };
+    readonly 'config-doctor': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run config doctor checks";
+        readonly subcommandOf: "config";
+    };
+    readonly 'doctor tools': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run tool registration coherence check";
+    };
+    readonly diagnose: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run health check on swarm state";
+    };
+    readonly diagnosis: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run health check on swarm state";
+    };
+    readonly preflight: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run preflight automation checks";
+    };
+    readonly 'sync-plan': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Ensure plan.json and plan.md are synced";
+        readonly args: "";
+    };
+    readonly benchmark: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show performance metrics [--cumulative] [--ci-gate]";
+        readonly args: "--cumulative, --ci-gate";
+    };
+    readonly export: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Export plan and context as JSON";
+        readonly args: "";
+        readonly details: "Exports the current plan and context as JSON to stdout. Useful for piping to external tools or debugging swarm state.";
+    };
+    readonly evidence: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show evidence bundles [taskId]";
+        readonly args: "<taskId>";
+        readonly details: "Displays review results, test verdicts, and other evidence bundles for the given task ID (e.g., \"2.1\").";
+    };
+    readonly 'evidence summary': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Generate evidence summary with completion ratio and blockers";
+        readonly subcommandOf: "evidence";
+        readonly args: "";
+        readonly details: "Generates a summary showing completion ratio across all tasks, lists blockers, and identifies missing evidence.";
+    };
+    readonly 'evidence-summary': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Generate evidence summary with completion ratio and blockers";
+        readonly subcommandOf: "evidence";
+        readonly args: "";
+        readonly details: "Generates a summary showing completion ratio across all tasks, lists blockers, and identifies missing evidence.";
+    };
+    readonly archive: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Archive old evidence bundles [--dry-run]";
+        readonly details: "Archives evidence bundles older than max_age_days (config, default 90) or beyond max_bundles cap (config, default 1000). --dry-run previews which bundles would be archived without deleting them. Applies two-tier retention: age-based first, then count-based on oldest remaining.";
+        readonly args: "--dry-run";
+    };
+    readonly curate: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run knowledge curation and hive promotion review";
+        readonly args: "";
+    };
+    readonly 'dark-matter': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Detect hidden file couplings via co-change NPMI analysis";
+        readonly args: "--threshold <number>, --min-commits <number>";
+    };
+    readonly close: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Use /swarm close to close the swarm project and archive evidence";
+        readonly details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs safe git ff-only to main. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation.";
+        readonly args: "--prune-branches";
+    };
+    readonly simulate: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Dry-run hidden coupling analysis with configurable thresholds";
+        readonly args: "--threshold <number>, --min-commits <number>";
+    };
+    readonly analyze: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Analyze spec.md vs plan.md for requirement coverage gaps";
+        readonly args: "";
+    };
+    readonly clarify: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Clarify and refine an existing feature specification";
+        readonly args: "[description-text]";
+    };
+    readonly specify: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Generate or import a feature specification [description]";
+        readonly args: "[description-text]";
+    };
+    readonly brainstorm: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Enter architect MODE: BRAINSTORM — structured seven-phase planning workflow [topic]";
+        readonly args: "[topic-text]";
+        readonly details: "Triggers the architect to run the brainstorm workflow: CONTEXT SCAN, single-question DIALOGUE, APPROACHES, DESIGN SECTIONS, SPEC WRITE + SELF-REVIEW, QA GATE SELECTION, TRANSITION. Use for new plans where requirements need to be drawn out before writing spec.md / plan.md.";
+    };
+    readonly council: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Enter architect MODE: COUNCIL — multi-model deliberation [question] [--preset <name>] [--spec-review]";
+        readonly args: "<question> [--preset <name>] [--spec-review]";
+        readonly details: "Triggers the architect to convene a configurable General Council: each member independently web-searches, answers, and engages in one structured deliberation round on disagreements; an optional moderator pass synthesizes the final answer. --preset <name> selects a member group from council.general.presets. --spec-review switches to single-pass advisory mode for spec review. Requires council.general.enabled: true and a search API key in opencode-swarm.json.";
+    };
+    readonly 'pr-review': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Launch deep PR review with multi-lane analysis [url] [--council]";
+        readonly args: "<pr-url|owner/repo#N|N> [--council]";
+        readonly details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).";
+    };
+    readonly issue: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Ingest a GitHub issue into the swarm workflow [url] [--plan] [--trace] [--no-repro]";
+        readonly args: "<issue-url|owner/repo#N|N> [--plan] [--trace] [--no-repro]";
+        readonly details: "Triggers the architect to enter MODE: ISSUE_INGEST — ingests a GitHub issue, restructures it into a normalized intake note, localizes root cause through hypothesis-driven tracing, and outputs a resolution spec. --plan transitions to plan creation after spec generation. --trace runs the full fix-and-PR workflow (implies --plan). --no-repro skips the reproduction step. Supports full GitHub URL, owner/repo#N shorthand, or bare issue number (resolves against origin remote).";
+    };
+    readonly 'qa-gates': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "View or modify QA gate profile for the current plan [enable|override <gate>...]";
+        readonly args: "[show|enable|override] <gate>...";
+        readonly details: "show: display spec-level, session-override, and effective QA gates for the current plan. enable: persist gate(s) into the locked-once profile (architect; rejected after critic approval lock). override: session-only ratchet-tighter enable. Valid gates: reviewer, test_engineer, council_mode, sme_enabled, critic_pre_plan, hallucination_guard, sast_enabled, mutation_test, council_general_review, drift_check.";
+    };
+    readonly promote: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Manually promote lesson to hive knowledge";
+        readonly details: "Promotes a lesson directly to hive knowledge (--category flag sets category) or references an existing swarm lesson by ID (--from-swarm). Validates lesson text before promotion. Either direct text or --from-swarm ID is required.";
+        readonly args: "--category <category>, --from-swarm <lesson-id>, <lesson-text>";
+    };
+    readonly reset: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Clear swarm state files [--confirm]";
+        readonly details: "DELETES plan.md, context.md, and summaries/ directory from .swarm/. Stops background automation and clears in-memory queues. SAFETY: requires --confirm flag — without it, displays a warning and tips to export first.";
+        readonly args: "--confirm (required)";
+    };
+    readonly 'reset-session': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Clear session state while preserving plan, evidence, and knowledge";
+        readonly details: "Deletes only .swarm/session/state.json and any other session files. Clears in-memory agent sessions and delegation chains. Preserves plan, evidence, and knowledge for cross-session continuity.";
+        readonly args: "";
+    };
+    readonly rollback: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Restore swarm state to a checkpoint <phase>";
+        readonly details: "Restores .swarm/ state by directly overwriting files from a checkpoint directory (checkpoints/phase-<N>). Writes rollback event to events.jsonl. Without phase argument, lists available checkpoints. Partial failures are reported but processing continues.";
+        readonly args: "<phase-number>";
+    };
+    readonly retrieve: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Retrieve full output from a summary <id>";
+        readonly args: "<summary-id>";
+        readonly details: "Loads the full tool output that was previously summarized (referenced by IDs like S1, S2). Use when you need the complete output instead of the truncated summary.";
+    };
+    readonly handoff: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Prepare state for clean model switch (new session)";
+        readonly args: "";
+        readonly details: "Generates handoff.md with full session state snapshot, including plan progress, recent decisions, and agent delegation history. Prepended to the next session prompt for seamless model switches.";
+    };
+    readonly turbo: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Toggle Turbo Mode for the active session [on|off]";
+        readonly args: "on, off";
+        readonly details: "Toggles Turbo Mode which skips non-critical QA gates for faster iteration. When enabled, the architect can proceed without waiting for all automated checks. Session-scoped — resets on new session. Use \"on\" or \"off\" to set explicitly, or toggle with no argument.";
+    };
+    readonly 'full-auto': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Toggle Full-Auto Mode for the active session [on|off]";
+        readonly args: "on, off";
+        readonly details: "Toggles Full-Auto Mode which enables autonomous execution without confirmation prompts. When enabled, the architect proceeds through implementation steps automatically. Session-scoped — resets on new session. Use \"on\" or \"off\" to set explicitly, or toggle with no argument.";
+    };
+    readonly 'write-retro': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Write a retrospective evidence bundle for a completed phase <json>";
+        readonly details: "Writes retrospective evidence bundle to .swarm/evidence/retro-{phase}/evidence.json. Required JSON: phase, summary, task_count, task_complexity, total_tool_calls, coder_revisions, reviewer_rejections, test_failures, security_findings, integration_issues. Optional: lessons_learned (max 5), top_rejection_reasons, task_id, metadata.";
+        readonly args: "<json: {phase, summary, task_count, task_complexity, ...}>";
+    };
+    readonly 'knowledge migrate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Migrate knowledge entries to the current format";
+        readonly subcommandOf: "knowledge";
+        readonly details: "One-time migration from .swarm/context.md SME cache to .swarm/knowledge.jsonl. Skips if sentinel file .swarm/.knowledge-migrated exists, if context.md is absent, or if context.md is empty. Reports entries migrated, dropped (validation/dedup), and total processed.";
+        readonly args: "<directory>";
+    };
+    readonly 'knowledge quarantine': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Move a knowledge entry to quarantine <id> [reason]";
+        readonly subcommandOf: "knowledge";
+        readonly details: "Moves a knowledge entry to quarantine with optional reason string (defaults to \"Quarantined via /swarm knowledge quarantine command\"). Validates entry ID format (1-64 alphanumeric/hyphen/underscore). Quarantined entries are excluded from knowledge queries.";
+        readonly args: "<entry-id> [reason]";
+    };
+    readonly 'knowledge restore': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Restore a quarantined knowledge entry <id>";
+        readonly subcommandOf: "knowledge";
+        readonly details: "Restores a quarantined knowledge entry back to the active knowledge store by ID. Validates entry ID format (1-64 alphanumeric/hyphen/underscore). Entry must currently be in quarantine state.";
+        readonly args: "<entry-id>";
+    };
+    readonly knowledge: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "List knowledge entries";
+    };
+    readonly checkpoint: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Manage project checkpoints [save|restore|delete|list] <label>";
+        readonly details: "save: creates named snapshot of current .swarm/ state. restore: soft-resets to checkpoint by overwriting current .swarm/ files. delete: removes named checkpoint. list: shows all checkpoints with timestamps. All subcommands require a label except list.";
+        readonly args: "<save|restore|delete|list> <label>";
+    };
+};
+export type RegisteredCommand = keyof typeof COMMAND_REGISTRY;
+export declare const VALID_COMMANDS: RegisteredCommand[];
+/**
+ * Resolves compound commands like "evidence summary" and "config doctor".
+ * Tries a two-token compound key first, then falls back to a single-token key.
+ */
+export declare function resolveCommand(tokens: string[]): {
+    entry: CommandEntry;
+    remainingArgs: string[];
+} | null;

package/dist/commands/reset-session.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Handles the /swarm reset-session command.
+ * Deletes only the session state file (.swarm/session/state.json)
+ * and clears in-memory agent sessions. Preserves plan, evidence,
+ * and knowledge for continuity across sessions.
+ */
+export declare function handleResetSessionCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/shortcut-routing.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Regression tests for swarm-* shortcut command routing.
+ *
+ * When a user selects a shortcut command from the OpenCode command picker
+ * (e.g. swarm-config, swarm-status, swarm-turbo), OpenCode sets
+ * input.command to the registered key name ('swarm-config') rather than
+ * the generic 'swarm' key. Previously the handler returned early for any
+ * command that wasn't exactly 'swarm', so these shortcuts fell through to
+ * the LLM as plain text. This file verifies they are correctly routed.
+ */
+export {};

package/dist/{sync-plan.d.ts → commands/sync-plan.d.ts}

@@ -3,6 +3,8 @@
  * Maps to: plan service (loadPlan which triggers auto-heal/sync)
  *
  * This command ensures plan.json and plan.md are in sync.
- * The loadPlan function automatically regenerates plan.md from plan.json if needed.
+ * loadPlan() is safe here: the migration-aware ledger guard in loadPlan()
+ * now prevents false reverts caused by swarm identity changes, so the
+ * full auto-heal path (including legacy plan.md migration) is correct.
  */
 export declare function handleSyncPlanCommand(directory: string, _args: string[]): Promise<string>;

package/dist/commands/turbo-registration.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Task 3.12: Turbo Mode command registration in src/commands/index.ts
+ * Verifies import, export, help text, and switch case routing for /swarm turbo
+ */
+export {};

package/dist/commands/turbo-sessionid.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Task 3.13: Empty sessionID handling in handleTurboCommand
+ * Tests the CLI wiring fix where empty sessionID returns proper error message
+ */
+export {};