opencode-swarm 7.18.3 → 7.19.1

package/dist/commands/command-dispatch.d.ts

@@ -0,0 +1,33 @@
+import type { AgentDefinition } from '../agents/index.js';
+import { type CommandEntry, resolveCommand } from './registry.js';
+export type ResolvedSwarmCommand = NonNullable<ReturnType<typeof resolveCommand>>;
+export type SwarmCommandPolicyResult = {
+    allowed: true;
+} | {
+    allowed: false;
+    message: string;
+};
+export type SwarmCommandPolicy = (resolved: ResolvedSwarmCommand) => SwarmCommandPolicyResult;
+export type SwarmCommandExecutionResult = {
+    text: string;
+    resolved?: ResolvedSwarmCommand;
+    canonicalKey?: string;
+};
+export declare function normalizeSwarmCommandInput(command: string, argumentText: string): {
+    isSwarmCommand: boolean;
+    tokens: string[];
+};
+export declare function canonicalCommandKey(resolved: ResolvedSwarmCommand): string;
+export declare function formatCommandNotFound(tokens: string[]): string;
+export declare function maybeMarkFirstRun(directory: string): boolean;
+export declare function prependWelcome(text: string): string;
+export declare function executeSwarmCommand(args: {
+    directory: string;
+    agents: Record<string, AgentDefinition>;
+    sessionID: string;
+    tokens: string[];
+    includeWelcome?: boolean;
+    buildHelpText?: () => string;
+    policy?: SwarmCommandPolicy;
+}): Promise<SwarmCommandExecutionResult>;
+export type { CommandEntry };

package/dist/commands/council.d.ts

@@ -14,4 +14,4 @@
  * 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>;
+export declare function handleCouncilCommand(_directory: string, args: string[]): Promise<string>;

package/dist/commands/doctor.d.ts

@@ -1,20 +1,15 @@
-import { type ConfigDoctorResult, type ModelAvailability } from '../services/config-doctor';
+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;
-export declare function loadModelAvailability(directory: string, client: unknown, options?: {
-    timeoutMs?: number;
-}): Promise<ModelAvailability | undefined>;
 /**
  * Handle /swarm config doctor command.
  * Maps to: config doctor service (runConfigDoctor)
  */
-export declare function handleDoctorCommand(directory: string, args: string[], options?: {
-    client?: unknown;
-}): Promise<string>;
+export declare function handleDoctorCommand(directory: string, args: string[]): Promise<string>;
 /**
  * Handle /swarm doctor tools command.
  * Maps to: tool doctor service (runToolDoctor)

package/dist/commands/index.d.ts

@@ -8,6 +8,7 @@ export { handleBrainstormCommand } from './brainstorm';
 export { handleCheckpointCommand } from './checkpoint';
 export { handleClarifyCommand } from './clarify';
 export { handleCloseCommand } from './close';
+export { executeSwarmCommand, formatCommandNotFound, normalizeSwarmCommandInput, } from './command-dispatch.js';
 export type { CommandName } from './command-names.js';
 export { COMMAND_NAME_SET, COMMAND_NAMES } from './command-names.js';
 export { handleConfigCommand } from './config';
@@ -38,18 +39,26 @@ export { handleSimulateCommand } from './simulate';
 export { handleSpecifyCommand } from './specify';
 export { handleStatusCommand } from './status';
 export { handleSyncPlanCommand } from './sync-plan';
+export { classifySwarmCommandChatFallbackUse, classifySwarmCommandToolUse, SWARM_COMMAND_TOOL_ALLOWLIST, SWARM_COMMAND_TOOL_COMMANDS, } from './tool-policy.js';
 export { handleTurboCommand } from './turbo';
 export { handleWriteRetroCommand } from './write-retro';
-export declare const LLM_MEDIATION_WARNING: string;
 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>, client?: unknown): (input: {
+export declare function createSwarmCommandHandler(directory: string, agents: Record<string, AgentDefinition>, options?: {
+    getActiveAgentName?: (sessionID: string) => string | undefined;
+    registeredAgents?: Record<string, {
+        tools?: Record<string, boolean>;
+    }>;
+}): (input: {
     command: string;
     sessionID: string;
     arguments: string;
 }, output: {
     parts: unknown[];
 }) => Promise<void>;
+export declare function agentHasSwarmCommandTool(activeAgentName: string | undefined, agents: Record<string, AgentDefinition>, registeredAgents?: Record<string, {
+    tools?: Record<string, boolean>;
+}>): boolean;

package/dist/commands/registry.d.ts

@@ -8,7 +8,6 @@ export type CommandContext = {
     args: string[];
     sessionID: string;
     agents: Record<string, AgentDefinition>;
-    client?: unknown;
 };
 export type CommandResult = Promise<string>;
 export type CommandCategory = 'core' | 'agent' | 'config' | 'diagnostics' | 'utility';

package/dist/commands/tool-policy.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedSwarmCommand, SwarmCommandPolicyResult } from './command-dispatch.js';
+export declare const SWARM_COMMAND_TOOL_COMMANDS: readonly ["agents", "config", "config doctor", "config-doctor", "doctor", "doctor tools", "status", "show-plan", "plan", "help", "history", "evidence", "evidence summary", "evidence-summary", "retrieve", "diagnose", "preflight", "benchmark", "knowledge", "sync-plan", "export", "list-agents"];
+export type SwarmCommandToolInputCommand = (typeof SWARM_COMMAND_TOOL_COMMANDS)[number];
+export declare const SWARM_COMMAND_TOOL_ALLOWLIST: Set<string>;
+export declare function classifySwarmCommandToolUse(resolved: ResolvedSwarmCommand): SwarmCommandPolicyResult;
+export declare function classifySwarmCommandChatFallbackUse(resolved: ResolvedSwarmCommand): SwarmCommandPolicyResult;

package/dist/config/plan-schema.d.ts

@@ -172,10 +172,18 @@ export type Plan = z.infer<typeof PlanSchema>;
 /**
  * Runtime plan with spec staleness tracking.
  * Extends Plan with runtime-only fields that are not persisted.
+ *
+ * `_midLoadRemovals` is attached by loadPlan-recovery paths that auto-
+ * acknowledged task removals (issue #853) so the system-enhancer Layer A
+ * can disclose the count to the model without re-reading the ledger.
  */
 export type RuntimePlan = Plan & {
     _specStale?: boolean;
     _specStaleReason?: string;
+    _midLoadRemovals?: {
+        count: number;
+        source: string;
+    };
 };
 /**
  * Find the first phase that is in progress.

package/dist/evidence/lock.d.ts

@@ -1,5 +1,5 @@
 /**
- * Evidence write-lock helper for concurrent Stage B evidence writers.
+ * Evidence write-lock helper (PR 1 — dark foundation).
  *
  * Wraps every evidence read-modify-write path with a proper-lockfile-backed
  * exclusive lock so that concurrent writers cannot interleave their

package/dist/gate-evidence.d.ts

@@ -44,13 +44,13 @@ export declare function expandRequiredGates(existingGates: string[], newAgentTyp
  * If file exists: merges gate entry, expands required_gates via expandRequiredGates.
  * Atomic write: temp file + rename.
  */
-export declare function recordGateEvidence(directory: string, taskId: string, gate: string, sessionId: string, turbo?: boolean, evidenceLockTimeoutMs?: number): Promise<void>;
+export declare function recordGateEvidence(directory: string, taskId: string, gate: string, sessionId: string, turbo?: boolean): Promise<void>;
 /**
  * Sets or expands required_gates WITHOUT recording a gate pass.
  * Used when non-gate agents are dispatched (coder, explorer, sme, etc.).
  * Creates evidence file if it doesn't exist yet.
  */
-export declare function recordAgentDispatch(directory: string, taskId: string, agentType: string, turbo?: boolean, evidenceLockTimeoutMs?: number): Promise<void>;
+export declare function recordAgentDispatch(directory: string, taskId: string, agentType: string, turbo?: boolean): Promise<void>;
 /**
  * Returns the TaskEvidence for a task, or null if file missing or parse error.
  * Never throws.

package/dist/hooks/guardrails.d.ts

@@ -9,6 +9,27 @@
 import * as path from 'node:path';
 import { type AuthorityConfig, type GuardrailsConfig } from '../config/schema';
 import { type FileZone } from '../context/zone-classifier';
+/**
+ * Issue #853 Layer B: tools that are structurally blocked while
+ * `.swarm/spec-staleness.json` exists. Every blocked tool mutates plan
+ * state (save_plan, update_task_status, phase_complete) or proceeds with
+ * lean-turbo execution (lean_turbo_run_phase, lean_turbo_acquire_locks).
+ * The architect must run /swarm clarify or /swarm acknowledge-spec-drift
+ * before any of these will succeed.
+ *
+ * Read tools (get_approved_plan, lint_spec, set_qa_gates, convene_*,
+ * lean_turbo_plan_lanes, lean_turbo_runner_status, lean_turbo_review) are
+ * intentionally NOT blocked — drift surfacing should not block exploration.
+ */
+export declare const SPEC_DRIFT_BLOCKED_TOOLS: Set<string>;
+/**
+ * Throw SPEC_DRIFT_BLOCK if the tool is on the block-list and the
+ * spec-staleness marker file exists. Layer B is structural (not a
+ * retryable error) — deterministic disk read every call, no cache, so
+ * /swarm acknowledge-spec-drift (which removes the marker) is reflected
+ * immediately on the next tool call.
+ */
+export declare function enforceSpecDriftGate(directory: string | undefined, toolName: string): void;
 /**
  * Retrieves stored input args for a given callID.
  * Used by other hooks (e.g., delegation-gate) to access tool input args.

package/dist/hooks/system-enhancer.d.ts

@@ -6,6 +6,25 @@
  * Reads plan.md and injects phase context into the system prompt.
  */
 import type { PluginConfig } from '../config';
+/**
+ * Build the [spec-drift] advisory injected into the model's system prompt
+ * after every loadPlan whenever spec staleness is detected (issue #853
+ * Layer A). The text is appended to `output.system` and survives the
+ * single-system-message collapse at `experimental.chat.system.transform`.
+ *
+ * The "Do NOT proceed" line enumerates every tool in SPEC_DRIFT_BLOCKED_TOOLS
+ * so the architect knows exactly which calls will return SPEC_DRIFT_BLOCK
+ * from Layer B.
+ */
+export declare function buildSpecDriftAdvisory(args: {
+    reason: string;
+    currentHash: string | null;
+    storedHash: string;
+    midLoadRemovals?: {
+        count: number;
+        source: string;
+    };
+}): string;
 /**
  * Build a retrospective injection string for the architect system message.
  * Tier 1: direct phase-scoped lookup for same-plan previous phase.