opencode-swarm 6.57.0 → 6.59.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/index.d.ts

@@ -1,4 +1,5 @@
 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';

package/dist/commands/registry.d.ts

@@ -14,6 +14,10 @@ export type CommandEntry = {
     subcommandOf?: 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 status: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Show current swarm state";

package/dist/config/index.d.ts

@@ -7,3 +7,5 @@ export type { MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskSta
 export { MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
 export type { AgentOverrideConfig, AutomationCapabilities, AutomationConfig, AutomationMode, PhaseCompleteConfig, PipelineConfig, PluginConfig, SwarmConfig, } from './schema';
 export { AgentOverrideConfigSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, AutomationModeSchema, PhaseCompleteConfigSchema, PipelineConfigSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';
+export type { DeltaSpec, Obligation, SpecDelta, SpecRequirement, SpecScenario, SpecSection, SwarmSpec, } from './spec-schema';
+export { DeltaSpecSchema, ObligationSchema, SpecDeltaSchema, SpecRequirementSchema, SpecScenarioSchema, SpecSectionSchema, SwarmSpecSchema, validateSpecContent, } from './spec-schema';

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

@@ -144,8 +144,18 @@ export declare const PlanSchema: z.ZodObject<{
         migrated: "migrated";
         migration_failed: "migration_failed";
     }>>;
+    specMtime: z.ZodOptional<z.ZodString>;
+    specHash: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type Plan = z.infer<typeof PlanSchema>;
+/**
+ * Runtime plan with spec staleness tracking.
+ * Extends Plan with runtime-only fields that are not persisted.
+ */
+export type RuntimePlan = Plan & {
+    _specStale?: boolean;
+    _specStaleReason?: string;
+};
 /**
  * Find the first phase that is in progress.
  * @param phases - Array of phases

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

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+export declare const ObligationSchema: z.ZodEnum<{
+    MUST: "MUST";
+    SHALL: "SHALL";
+    SHOULD: "SHOULD";
+    MAY: "MAY";
+}>;
+export type Obligation = z.infer<typeof ObligationSchema>;
+export declare const SpecRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    obligation: z.ZodEnum<{
+        MUST: "MUST";
+        SHALL: "SHALL";
+        SHOULD: "SHOULD";
+        MAY: "MAY";
+    }>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type SpecRequirement = z.infer<typeof SpecRequirementSchema>;
+export declare const SpecScenarioSchema: z.ZodObject<{
+    name: z.ZodString;
+    given: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    when: z.ZodArray<z.ZodString>;
+    thenClauses: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SpecScenario = z.infer<typeof SpecScenarioSchema>;
+export declare const SpecSectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    requirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SpecSection = z.infer<typeof SpecSectionSchema>;
+export declare const SwarmSpecSchema: z.ZodObject<{
+    title: z.ZodString;
+    purpose: z.ZodString;
+    sections: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        requirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            obligation: z.ZodEnum<{
+                MUST: "MUST";
+                SHALL: "SHALL";
+                SHOULD: "SHOULD";
+                MAY: "MAY";
+            }>;
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SwarmSpec = z.infer<typeof SwarmSpecSchema>;
+export declare const SpecDeltaSchema: z.ZodObject<{
+    added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    modified: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        obligation: z.ZodEnum<{
+            MUST: "MUST";
+            SHALL: "SHALL";
+            SHOULD: "SHOULD";
+            MAY: "MAY";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SpecDelta = z.infer<typeof SpecDeltaSchema>;
+export declare const DeltaSpecSchema: z.ZodType<SwarmSpec | SpecDelta>;
+export type DeltaSpec = z.infer<typeof DeltaSpecSchema>;
+interface ValidationIssue {
+    line: number;
+    message: string;
+}
+interface SpecContentValidationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+}
+/**
+ * Validate raw markdown spec content using regex patterns.
+ * Checks for:
+ * - FR-### requirement IDs
+ * - Obligation keywords (MUST, SHALL, SHOULD, MAY)
+ * - Section headers (## Section Name)
+ *
+ * @param content - Raw markdown string to validate
+ * @returns Validation result with issues array
+ */
+export declare function validateSpecContent(content: string): SpecContentValidationResult;
+export {};

package/dist/evidence/manager.d.ts

@@ -71,6 +71,14 @@ export declare function listEvidenceTaskIds(directory: string): Promise<string[]
  * Returns true if deleted, false if didn't exist or deletion failed.
  */
 export declare function deleteEvidence(directory: string, taskId: string): Promise<boolean>;
+/**
+ * Check if a requirement coverage file exists for a given phase.
+ * Looks for .swarm/evidence/req-coverage-phase-{N}.json
+ */
+export declare function checkRequirementCoverage(phase: number, directory: string): Promise<{
+    exists: boolean;
+    path: string;
+}>;
 /**
  * Archive old evidence bundles based on retention policy.
  * Removes evidence older than maxAgeDays.

package/dist/hooks/curator.d.ts

@@ -7,6 +7,22 @@
  * callback for LLM-based analysis. When provided, the prepared data context is sent
  * to the explorer agent in CURATOR_PHASE/CURATOR_INIT mode for richer analysis.
  * When the delegate is absent or fails, falls back to data-only behavior.
+ *
+ * ## Curator Agent Dispatch Modes
+ *
+ * Curator agents are dispatched in two ways:
+ *
+ * 1. **Factory dispatch** (standard): Created via `createCuratorAgent` from curator-agent.ts,
+ *    exposed through agents/index.ts. These appear in agent lists and are part of the
+ *    standard agent factory.
+ *
+ * 2. **Hook dispatch** (internal): curator.ts imports CURATOR_INIT_PROMPT and CURATOR_PHASE_PROMPT
+ *    from explorer.ts and dispatches curator analysis directly via hook callbacks. These
+ *    hook-dispatched curators do NOT go through the standard agent factory and are NOT
+ *    included in agent lists (e.g., AGENTS.md, agent discovery, the agent registry).
+ *
+ * This dual dispatch means agent lists are incomplete — they capture factory-dispatched
+ * curators but omit hook-dispatched ones. This is by design for hook-internal operations.
  */
 import type { ComplianceObservation, CuratorConfig, CuratorInitResult, CuratorPhaseResult, CuratorSummary, KnowledgeRecommendation } from './curator-types.js';
 import type { KnowledgeConfig } from './knowledge-types.js';
@@ -17,8 +33,11 @@ import type { KnowledgeConfig } from './knowledge-types.js';
  */
 export type CuratorLLMDelegate = (systemPrompt: string, userInput: string, signal?: AbortSignal) => Promise<string>;
 /**
- * Parse KNOWLEDGE_UPDATES section from curator LLM output.
- * Expected format per line: "- [action] [entry_id or "new"]: [reason]"
+ * Parse OBSERVATIONS section from curator LLM output.
+ * Expected format per line: "- entry <uuid> (<observable>): [text]"
+ * Observable types: appears high-confidence, appears stale, could be tighter,
+ * contradicts project state, new candidate
+ * Action hints are extracted from parenthetical directives like "(suggests boost confidence, mark hive_eligible)"
  */
 export declare function parseKnowledgeRecommendations(llmOutput: string): KnowledgeRecommendation[];
 /**