opencode-swarm 7.10.0 → 7.11.1

package/dist/agents/architect.d.ts

@@ -1,4 +1,5 @@
 import type { AgentConfig } from '@opencode-ai/sdk';
+export type { AgentConfig };
 export interface AgentDefinition {
     name: string;
     description?: string;

package/dist/agents/skill-improver.d.ts

@@ -0,0 +1,12 @@
+/**
+ * skill_improver agent — low-frequency, expensive-model improvement loop
+ * (issue #629).
+ *
+ * Default behaviour:
+ *   - read-only access to knowledge / skills / spec / docs
+ *   - quota-bounded LLM usage (skill_improve tool enforces .swarm/skill-improver-quota.json)
+ *   - never mutates source code; default write_mode is "proposal"
+ *   - architect must ask user before invoking, when require_user_approval=true
+ */
+import type { AgentDefinition } from './architect.js';
+export declare function createSkillImproverAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/spec-writer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * spec_writer agent — independent author/reviewer for `.swarm/spec.md`.
+ *
+ * Allows architect to remain on a cheap model while spec authoring runs on a
+ * higher-capability model. Architect delegates spec work explicitly.
+ */
+import type { AgentDefinition } from './architect.js';
+export declare function createSpecWriterAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.10.0",
+    version: "7.11.1",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -16054,7 +16054,14 @@ var init_tool_names = __esm(() => {
     "set_qa_gates",
     "web_search",
     "convene_general_council",
-    "write_final_council_evidence"
+    "write_final_council_evidence",
+    "skill_generate",
+    "skill_list",
+    "skill_apply",
+    "skill_inspect",
+    "skill_improve",
+    "spec_write",
+    "knowledge_ack"
   ];
   TOOL_NAME_SET = new Set(TOOL_NAMES);
 });
@@ -16110,6 +16117,8 @@ var init_constants = __esm(() => {
     "council_generalist",
     "council_skeptic",
     "council_domain_expert",
+    "skill_improver",
+    "spec_writer",
     ...QA_AGENTS,
     ...PIPELINE_AGENTS
   ];
@@ -16292,7 +16301,13 @@ var init_constants = __esm(() => {
       "set_qa_gates",
       "convene_general_council",
       "web_search",
-      "write_final_council_evidence"
+      "write_final_council_evidence",
+      "skill_generate",
+      "skill_list",
+      "skill_apply",
+      "skill_inspect",
+      "skill_improve",
+      "knowledge_ack"
     ],
     explorer: [
       "complexity_hotspots",
@@ -16462,7 +16477,32 @@ var init_constants = __esm(() => {
     curator_phase: ["knowledge_recall"],
     council_generalist: [],
     council_skeptic: [],
-    council_domain_expert: []
+    council_domain_expert: [],
+    skill_improver: [
+      "knowledge_recall",
+      "knowledge_query",
+      "skill_list",
+      "skill_inspect",
+      "skill_generate",
+      "skill_improve",
+      "search",
+      "doc_scan",
+      "doc_extract",
+      "web_search"
+    ],
+    spec_writer: [
+      "search",
+      "knowledge_recall",
+      "knowledge_query",
+      "doc_scan",
+      "doc_extract",
+      "req_coverage",
+      "lint_spec",
+      "retrieve_summary",
+      "symbols",
+      "extract_code_blocks",
+      "spec_write"
+    ]
   };
   for (const [agentName, tools] of Object.entries(AGENT_TOOL_MAP)) {
     const invalidTools = tools.filter((tool) => !TOOL_NAME_SET.has(tool));
@@ -16526,6 +16566,14 @@ var init_constants = __esm(() => {
     curator_phase: {
       model: "opencode/gpt-5-nano",
       fallback_models: ["opencode/big-pickle"]
+    },
+    skill_improver: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/gpt-5-nano"]
+    },
+    spec_writer: {
+      model: "opencode/big-pickle",
+      fallback_models: ["opencode/gpt-5-nano"]
     }
   };
 });
@@ -16559,7 +16607,7 @@ function getCanonicalAgentRole(agentName, generatedAgentNames) {
 function stripKnownSwarmPrefix(agentName) {
   return getCanonicalAgentRole(agentName);
 }
-var SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, CuratorConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, PluginConfigSchema;
+var SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, CuratorConfigSchema, KnowledgeApplicationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_constants();
@@ -17000,6 +17048,7 @@ var init_schema = __esm(() => {
     low_utility_threshold: exports_external.number().min(0).max(1).default(0.3),
     min_retrievals_for_utility: exports_external.number().min(1).max(100).default(3),
     schema_version: exports_external.number().int().min(1).default(1),
+    directive_min_confidence: exports_external.number().min(0).max(1).default(0.75),
     same_project_weight: exports_external.number().min(0).max(5).default(1),
     cross_project_weight: exports_external.number().min(0).max(5).default(0.5),
     min_encounter_score: exports_external.number().min(0).max(1).default(0.1),
@@ -17019,7 +17068,36 @@ var init_schema = __esm(() => {
     compliance_report: exports_external.boolean().default(true),
     suppress_warnings: exports_external.boolean().default(true),
     drift_inject_max_chars: exports_external.number().min(100).max(2000).default(500),
-    llm_timeout_ms: exports_external.number().int().min(5000).max(600000).default(300000)
+    llm_timeout_ms: exports_external.number().int().min(5000).max(600000).default(300000),
+    skill_generation_enabled: exports_external.boolean().default(true),
+    skill_generation_mode: exports_external.enum(["draft", "active"]).default("draft"),
+    min_skill_confidence: exports_external.number().min(0).max(1).default(0.85),
+    min_skill_confirmations: exports_external.number().int().min(1).max(50).default(2)
+  });
+  KnowledgeApplicationConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    mode: exports_external.enum(["warn", "enforce"]).default("warn"),
+    min_confidence: exports_external.number().min(0).max(1).default(0.85),
+    critical_requires_ack: exports_external.boolean().default(true),
+    require_skill_refs: exports_external.boolean().default(true)
+  });
+  SkillImproverConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    model: exports_external.string().nullable().default(null),
+    fallback_models: exports_external.array(exports_external.string()).default([]),
+    max_calls_per_day: exports_external.number().int().min(1).max(1000).default(10),
+    trigger: exports_external.enum(["manual", "scheduled"]).default("manual"),
+    targets: exports_external.array(exports_external.enum(["skills", "spec", "architect_prompt", "knowledge"])).default(["skills", "spec", "architect_prompt", "knowledge"]),
+    write_mode: exports_external.enum(["proposal", "draft_skills"]).default("proposal"),
+    require_user_approval: exports_external.boolean().default(true),
+    quota_window: exports_external.enum(["utc", "local"]).default("utc"),
+    allow_deterministic_fallback: exports_external.boolean().default(true)
+  });
+  SpecWriterConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    model: exports_external.string().nullable().default(null),
+    fallback_models: exports_external.array(exports_external.string()).default([]),
+    allow_spec_write: exports_external.boolean().default(true)
   });
   SlopDetectorConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -17155,6 +17233,9 @@ var init_schema = __esm(() => {
     automation: AutomationConfigSchema.optional(),
     knowledge: KnowledgeConfigSchema.optional(),
     curator: CuratorConfigSchema.optional(),
+    knowledge_application: KnowledgeApplicationConfigSchema.optional(),
+    skill_improver: SkillImproverConfigSchema.optional(),
+    spec_writer: SpecWriterConfigSchema.optional(),
     tool_output: exports_external.object({
       truncation_enabled: exports_external.boolean().default(true),
       max_lines: exports_external.number().min(10).max(500).default(150),
@@ -20705,6 +20786,10 @@ function resetSwarmState() {
   swarmState.opencodeClient = null;
   swarmState.curatorInitAgentNames = [];
   swarmState.curatorPhaseAgentNames = [];
+  swarmState.skillImproverAgentNames = [];
+  swarmState.specWriterAgentNames = [];
+  swarmState.currentCriticalShownIds.clear();
+  swarmState.knowledgeAckDedup.clear();
   swarmState.generatedAgentNames = [];
   _rehydrationCache = null;
   swarmState.fullAutoEnabledInConfig = false;
@@ -20750,6 +20835,10 @@ var init_state = __esm(() => {
     opencodeClient: null,
     curatorInitAgentNames: [],
     curatorPhaseAgentNames: [],
+    skillImproverAgentNames: [],
+    specWriterAgentNames: [],
+    currentCriticalShownIds: new Map,
+    knowledgeAckDedup: new Set,
     generatedAgentNames: [],
     lastBudgetPct: 0,
     agentSessions: defaultRunContext.agentSessions,
@@ -34810,13 +34899,59 @@ async function readKnowledge(filePath) {
     if (!trimmed)
       continue;
     try {
-      results.push(JSON.parse(trimmed));
+      const raw = JSON.parse(trimmed);
+      results.push(normalizeEntry(raw));
     } catch {
       console.warn(`[knowledge-store] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
     }
   }
   return results;
 }
+function normalizeEntry(raw) {
+  if (!raw || typeof raw !== "object")
+    return raw;
+  const obj = raw;
+  if (!("retrieval_outcomes" in obj))
+    return raw;
+  const ro = obj.retrieval_outcomes;
+  if (ro && typeof ro === "object") {
+    if (typeof ro.shown_count !== "number") {
+      ro.shown_count = typeof ro.applied_count === "number" ? ro.applied_count : 0;
+    }
+    if (typeof ro.acknowledged_count !== "number")
+      ro.acknowledged_count = 0;
+    if (typeof ro.applied_explicit_count !== "number") {
+      ro.applied_explicit_count = 0;
+    }
+    if (typeof ro.ignored_count !== "number")
+      ro.ignored_count = 0;
+    if (typeof ro.violated_count !== "number")
+      ro.violated_count = 0;
+    if (typeof ro.succeeded_after_shown_count !== "number") {
+      ro.succeeded_after_shown_count = typeof ro.succeeded_after_count === "number" ? ro.succeeded_after_count : 0;
+    }
+    if (typeof ro.failed_after_shown_count !== "number") {
+      ro.failed_after_shown_count = typeof ro.failed_after_count === "number" ? ro.failed_after_count : 0;
+    }
+  }
+  const arrayFields = [
+    "triggers",
+    "required_actions",
+    "forbidden_actions",
+    "applies_to_agents",
+    "applies_to_tools",
+    "verification_checks",
+    "source_refs",
+    "source_knowledge_ids"
+  ];
+  for (const f of arrayFields) {
+    const v = obj[f];
+    if (v !== undefined && !Array.isArray(v)) {
+      delete obj[f];
+    }
+  }
+  return raw;
+}
 async function readRejectedLessons(directory) {
   return readKnowledge(resolveSwarmRejectedPath(directory));
 }
@@ -35189,7 +35324,7 @@ async function restoreEntry(directory, entryId) {
     }
   }
 }
-var import_proper_lockfile4, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS;
+var import_proper_lockfile4, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, VALID_DIRECTIVE_PRIORITIES;
 var init_knowledge_validator = __esm(() => {
   init_logger();
   init_knowledge_store();
@@ -35295,12 +35430,20 @@ var init_knowledge_validator = __esm(() => {
     ["use", "don't use"],
     ["recommended", "not recommended"]
   ];
+  VALID_DIRECTIVE_PRIORITIES = new Set([
+    "low",
+    "medium",
+    "high",
+    "critical"
+  ]);
 });
 
 // src/hooks/curator.ts
 var init_curator = __esm(() => {
   init_event_bus();
+  init_schema();
   init_manager();
+  init_state();
   init_bun_compat();
   init_logger();
   init_knowledge_store();
@@ -35565,11 +35708,11 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
     const foundInSwarm = new Set;
     for (const entry of entries) {
       if (shownIds.includes(entry.id)) {
-        entry.retrieval_outcomes.applied_count++;
+        const ro = entry.retrieval_outcomes;
         if (phaseSucceeded) {
-          entry.retrieval_outcomes.succeeded_after_count++;
+          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
         } else {
-          entry.retrieval_outcomes.failed_after_count++;
+          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
         }
         updated = true;
         foundInSwarm.add(entry.id);
@@ -35589,11 +35732,11 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
     let hiveUpdated = false;
     for (const entry of hiveEntries) {
       if (remainingIds.includes(entry.id)) {
-        entry.retrieval_outcomes.applied_count++;
+        const ro = entry.retrieval_outcomes;
         if (phaseSucceeded) {
-          entry.retrieval_outcomes.succeeded_after_count++;
+          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
         } else {
-          entry.retrieval_outcomes.failed_after_count++;
+          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
         }
         hiveUpdated = true;
       }

package/dist/config/constants.d.ts

@@ -2,8 +2,8 @@ import type { ToolName } from '../tools/tool-names';
 export declare const QA_AGENTS: readonly ["reviewer", "critic", "critic_oversight"];
 export declare const PIPELINE_AGENTS: readonly ["explorer", "coder", "test_engineer"];
 export declare const ORCHESTRATOR_NAME: "architect";
-export declare const ALL_SUBAGENT_NAMES: readonly ["sme", "docs", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "curator_init", "curator_phase", "council_generalist", "council_skeptic", "council_domain_expert", "reviewer", "critic", "critic_oversight", "explorer", "coder", "test_engineer"];
-export declare const ALL_AGENT_NAMES: readonly ["architect", "sme", "docs", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "curator_init", "curator_phase", "council_generalist", "council_skeptic", "council_domain_expert", "reviewer", "critic", "critic_oversight", "explorer", "coder", "test_engineer"];
+export declare const ALL_SUBAGENT_NAMES: readonly ["sme", "docs", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "curator_init", "curator_phase", "council_generalist", "council_skeptic", "council_domain_expert", "skill_improver", "spec_writer", "reviewer", "critic", "critic_oversight", "explorer", "coder", "test_engineer"];
+export declare const ALL_AGENT_NAMES: readonly ["architect", "sme", "docs", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "curator_init", "curator_phase", "council_generalist", "council_skeptic", "council_domain_expert", "skill_improver", "spec_writer", "reviewer", "critic", "critic_oversight", "explorer", "coder", "test_engineer"];
 export declare const OPENCODE_NATIVE_AGENTS: Set<"compaction" | "title" | "build" | "general" | "plan" | "explore" | "summary">;
 export declare const CLAUDE_CODE_NATIVE_COMMANDS: ReadonlySet<string>;
 export type QAAgentName = (typeof QA_AGENTS)[number];

package/dist/config/schema.d.ts

@@ -490,6 +490,7 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
     low_utility_threshold: z.ZodDefault<z.ZodNumber>;
     min_retrievals_for_utility: z.ZodDefault<z.ZodNumber>;
     schema_version: z.ZodDefault<z.ZodNumber>;
+    directive_min_confidence: z.ZodDefault<z.ZodNumber>;
     same_project_weight: z.ZodDefault<z.ZodNumber>;
     cross_project_weight: z.ZodDefault<z.ZodNumber>;
     min_encounter_score: z.ZodDefault<z.ZodNumber>;
@@ -511,8 +512,60 @@ export declare const CuratorConfigSchema: z.ZodObject<{
     suppress_warnings: z.ZodDefault<z.ZodBoolean>;
     drift_inject_max_chars: z.ZodDefault<z.ZodNumber>;
     llm_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    skill_generation_enabled: z.ZodDefault<z.ZodBoolean>;
+    skill_generation_mode: z.ZodDefault<z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+    }>>;
+    min_skill_confidence: z.ZodDefault<z.ZodNumber>;
+    min_skill_confirmations: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type CuratorConfig = z.infer<typeof CuratorConfigSchema>;
+export declare const KnowledgeApplicationConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        enforce: "enforce";
+        warn: "warn";
+    }>>;
+    min_confidence: z.ZodDefault<z.ZodNumber>;
+    critical_requires_ack: z.ZodDefault<z.ZodBoolean>;
+    require_skill_refs: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type KnowledgeApplicationConfig = z.infer<typeof KnowledgeApplicationConfigSchema>;
+export declare const SkillImproverConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fallback_models: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    max_calls_per_day: z.ZodDefault<z.ZodNumber>;
+    trigger: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        scheduled: "scheduled";
+    }>>;
+    targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        skills: "skills";
+        spec: "spec";
+        architect_prompt: "architect_prompt";
+        knowledge: "knowledge";
+    }>>>;
+    write_mode: z.ZodDefault<z.ZodEnum<{
+        proposal: "proposal";
+        draft_skills: "draft_skills";
+    }>>;
+    require_user_approval: z.ZodDefault<z.ZodBoolean>;
+    quota_window: z.ZodDefault<z.ZodEnum<{
+        utc: "utc";
+        local: "local";
+    }>>;
+    allow_deterministic_fallback: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SkillImproverConfig = z.infer<typeof SkillImproverConfigSchema>;
+export declare const SpecWriterConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fallback_models: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allow_spec_write: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SpecWriterConfig = z.infer<typeof SpecWriterConfigSchema>;
 export declare const SlopDetectorConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     classThreshold: z.ZodDefault<z.ZodNumber>;
@@ -985,6 +1038,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         low_utility_threshold: z.ZodDefault<z.ZodNumber>;
         min_retrievals_for_utility: z.ZodDefault<z.ZodNumber>;
         schema_version: z.ZodDefault<z.ZodNumber>;
+        directive_min_confidence: z.ZodDefault<z.ZodNumber>;
         same_project_weight: z.ZodDefault<z.ZodNumber>;
         cross_project_weight: z.ZodDefault<z.ZodNumber>;
         min_encounter_score: z.ZodDefault<z.ZodNumber>;
@@ -1005,6 +1059,55 @@ export declare const PluginConfigSchema: z.ZodObject<{
         suppress_warnings: z.ZodDefault<z.ZodBoolean>;
         drift_inject_max_chars: z.ZodDefault<z.ZodNumber>;
         llm_timeout_ms: z.ZodDefault<z.ZodNumber>;
+        skill_generation_enabled: z.ZodDefault<z.ZodBoolean>;
+        skill_generation_mode: z.ZodDefault<z.ZodEnum<{
+            draft: "draft";
+            active: "active";
+        }>>;
+        min_skill_confidence: z.ZodDefault<z.ZodNumber>;
+        min_skill_confirmations: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    knowledge_application: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            enforce: "enforce";
+            warn: "warn";
+        }>>;
+        min_confidence: z.ZodDefault<z.ZodNumber>;
+        critical_requires_ack: z.ZodDefault<z.ZodBoolean>;
+        require_skill_refs: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    skill_improver: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        fallback_models: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        max_calls_per_day: z.ZodDefault<z.ZodNumber>;
+        trigger: z.ZodDefault<z.ZodEnum<{
+            manual: "manual";
+            scheduled: "scheduled";
+        }>>;
+        targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            skills: "skills";
+            spec: "spec";
+            architect_prompt: "architect_prompt";
+            knowledge: "knowledge";
+        }>>>;
+        write_mode: z.ZodDefault<z.ZodEnum<{
+            proposal: "proposal";
+            draft_skills: "draft_skills";
+        }>>;
+        require_user_approval: z.ZodDefault<z.ZodBoolean>;
+        quota_window: z.ZodDefault<z.ZodEnum<{
+            utc: "utc";
+            local: "local";
+        }>>;
+        allow_deterministic_fallback: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    spec_writer: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        fallback_models: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        allow_spec_write: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     tool_output: z.ZodOptional<z.ZodObject<{
         truncation_enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/hooks/curator-types.d.ts

@@ -94,6 +94,31 @@ export interface CuratorPhaseResult {
     compliance: ComplianceObservation[];
     knowledge_recommendations: KnowledgeRecommendation[];
     summary_updated: boolean;
+    /** v2: per-knowledge-entry application audit (applied/ignored/violated/n/a). */
+    knowledge_application_findings?: KnowledgeApplicationFinding[];
+    /** v2: candidate clusters the curator suggests compiling into SKILL.md. */
+    skill_candidates?: SkillCandidate[];
+}
+/** v2: machine-typed audit produced by the curator after each phase. */
+export interface KnowledgeApplicationFinding {
+    knowledge_id: string;
+    expected_behavior: string;
+    observed_behavior: string;
+    verdict: 'applied' | 'ignored' | 'violated' | 'not_applicable';
+    evidence_refs: string[];
+}
+/** v2: skill cluster proposal emitted by the curator. */
+export interface SkillCandidate {
+    slug: string;
+    title: string;
+    source_knowledge_ids: string[];
+    trigger: string;
+    required_procedure: string[];
+    forbidden_shortcuts: string[];
+    target_agents: string[];
+    reviewer_checks: string[];
+    confidence: number;
+    reason: string;
 }
 export interface CriticDriftResult {
     phase: number;

package/dist/hooks/curator.d.ts

@@ -48,6 +48,26 @@ export declare const _internals: {
  * Action hints are extracted from parenthetical directives like "(suggests boost confidence, mark hive_eligible)"
  */
 export declare function parseKnowledgeRecommendations(llmOutput: string): KnowledgeRecommendation[];
+/**
+ * v2: Strict-JSON parser for the new curator output blocks.
+ *
+ * Curator prompts may now emit JSON-fenced blocks like:
+ *
+ * ```json knowledge_application_findings
+ * [{ "knowledge_id": "...", "expected_behavior": "...", ... }]
+ * ```
+ *
+ * ```json skill_candidates
+ * [{ "slug": "...", "title": "...", ... }]
+ * ```
+ *
+ * Malformed JSON or unexpected types are silently dropped: no knowledge or
+ * skill writes happen when curator output is malformed.
+ */
+export declare function parseStructuredCuratorBlocks(llmOutput: string): {
+    findings: import('./curator-types.js').KnowledgeApplicationFinding[];
+    candidates: import('./curator-types.js').SkillCandidate[];
+};
 /**
  * Read curator summary from .swarm/curator-summary.json
  * @param directory - The workspace directory
@@ -61,7 +81,19 @@ export declare function readCuratorSummary(directory: string): Promise<CuratorSu
  */
 export declare function writeCuratorSummary(directory: string, summary: CuratorSummary): Promise<void>;
 /**
- * Normalize agent name by stripping common swarm prefixes.
+ * Normalize an agent name to its canonical role.
+ *
+ * v2 (Phase F′ remediation): use the repository's canonical resolver
+ * `getCanonicalAgentRole`, registry-aware. When the generated-agent registry
+ * is populated (post plugin-init), an arbitrary swarm id like
+ * `banana_coder` resolves to `coder` IFF it appears in the registry.
+ * Pre-init (registry empty), the resolver falls back to a permissive
+ * suffix-match against ALL_AGENT_NAMES — preserving today's behaviour for
+ * arbitrary user prefixes without the hard-coded
+ * `(mega|paid|local|lowtier|modelrelay)_` whitelist.
+ *
+ * Lower-casing is preserved for backwards compatibility with the prior
+ * comparator code paths in this file.
  */
 declare function normalizeAgentName(name: string): string;
 /**

package/dist/hooks/knowledge-application-gate.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Runtime wiring for the knowledge application contract.
+ *
+ * Two integration points:
+ *
+ *   1. `experimental.chat.messages.transform` — scans the latest
+ *      architect-authored message for `KNOWLEDGE_APPLIED|IGNORED|VIOLATED`
+ *      markers and records them via `recordAcknowledgmentDeduped`. This
+ *      runs BEFORE the architect's next tool call so the toolBefore gate
+ *      sees the ack.
+ *
+ *   2. `tool.execute.before` (FAIL-CLOSED chain at src/index.ts) — when a
+ *      high-risk tool fires and the calling agent is the architect,
+ *      consults `swarmState.currentCriticalShownIds` and the audit log to
+ *      assemble the set of critical directives that have been shown but
+ *      not acknowledged. In `mode: 'enforce'` it THROWS to block the
+ *      action (per the FAIL-CLOSED contract — `output.error` is NOT a
+ *      write API at toolBefore time). In `mode: 'warn'` it appends to
+ *      `events.jsonl` and lets the action proceed.
+ *
+ * Tools considered high-risk:
+ *   - save_plan
+ *   - update_task_status
+ *   - phase_complete
+ *   - Task (delegations to coder/reviewer/test_engineer/sme/docs/designer)
+ *
+ * Non-architect agents are never gated.
+ */
+import { type KnowledgeApplicationConfig } from './knowledge-application.js';
+import type { MessageWithParts } from './knowledge-types.js';
+/** Tools that require knowledge-directive acknowledgment before execution. */
+export declare const HIGH_RISK_TOOLS: Set<string>;
+export interface GateInput {
+    tool: unknown;
+    agent?: unknown;
+    sessionID?: unknown;
+}
+/**
+ * Pre-tool gate. Throws when the architect attempts a high-risk action with
+ * an unacknowledged critical directive in `enforce` mode. Always returns in
+ * `warn` mode (with a side-effect events.jsonl write).
+ */
+export declare function knowledgeApplicationGateBefore(directory: string, input: GateInput, config: KnowledgeApplicationConfig): Promise<void>;
+declare function writeWarnEvent(directory: string, record: Record<string, unknown>): Promise<void>;
+/**
+ * Compose into `experimental.chat.messages.transform`. Scans the most recent
+ * `role: 'user'`-shaped architect message for ack markers (per
+ * `full-auto-intercept.ts` pattern: architect outputs appear as user role)
+ * and records each via `recordAcknowledgmentDeduped`. Best-effort: never
+ * throws; never mutates the messages array.
+ */
+export declare function knowledgeApplicationTransformScan(directory: string, output: {
+    messages?: MessageWithParts[];
+}, sessionID?: string): Promise<void>;
+export declare const _internals: {
+    knowledgeApplicationGateBefore: typeof knowledgeApplicationGateBefore;
+    knowledgeApplicationTransformScan: typeof knowledgeApplicationTransformScan;
+    HIGH_RISK_TOOLS: Set<string>;
+    writeWarnEvent: typeof writeWarnEvent;
+};
+export {};