kc-beta 0.1.0 → 0.1.2

package/src/agent/pipelines/_archive_v1/initializer.js

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+const REQUIRED_DIRS = ["rules", "samples", "input", "output", "logs", "workflows", "rule_skills"];
+
+const DEFAULT_ENV = `# === KC Agent Project Configuration ===
+
+# Language: en | zh
+LANGUAGE=en
+
+# === Worker LLM API (SiliconFlow) ===
+SILICONFLOW_API_KEY=
+SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1
+
+# === Worker LLM Tiers (highest capability to lowest) ===
+TIER1=Pro/zai-org/GLM-5, Pro/moonshotai/Kimi-K2.5
+TIER2=Pro/deepseek-ai/DeepSeek-V3.2, Pro/MiniMaxAI/MiniMax-M2.5, Qwen/Qwen3.5-397B-A17B
+TIER3=Qwen/Qwen3.5-122B-A10B
+TIER4=Qwen/Qwen3.5-35B-A3B
+
+# === OCR Model Tiers ===
+OCR_MODEL_TIER1=zai-org/GLM-4.6V
+
+# === Quality Thresholds ===
+SKILL_ACCURACY=0.9
+WORKFLOW_ACCURACY=0.9
+MONITOR_FREQUENCY=mid
+
+# === Evolution Control ===
+MAX_ITERATIONS=20
+`;
+
+export class ProjectInitializer extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.workspaceCreated = false;
+    this.configReady = false;
+    this.hasRegulations = false;
+    this.hasSamples = false;
+    this._setupWorkspace();
+  }
+
+  _setupWorkspace() {
+    for (const d of REQUIRED_DIRS) {
+      fs.mkdirSync(path.join(this._workspace.cwd, d), { recursive: true });
+    }
+
+    const envPath = path.join(this._workspace.cwd, ".env");
+    if (!fs.existsSync(envPath)) {
+      let envContent = DEFAULT_ENV;
+      const gc = this._loadGlobalConfig();
+      if (gc.api_key) envContent = envContent.replace("SILICONFLOW_API_KEY=", `SILICONFLOW_API_KEY=${gc.api_key}`);
+      if (gc.base_url) envContent = envContent.replace("SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1", `SILICONFLOW_BASE_URL=${gc.base_url}`);
+      if (gc.accuracy_threshold) {
+        envContent = envContent.replace("SKILL_ACCURACY=0.9", `SKILL_ACCURACY=${gc.accuracy_threshold}`);
+        envContent = envContent.replace("WORKFLOW_ACCURACY=0.9", `WORKFLOW_ACCURACY=${gc.accuracy_threshold}`);
+      }
+      const tiers = gc.tiers || {};
+      for (const tk of ["tier1", "tier2", "tier3", "tier4"]) {
+        if (tiers[tk]) {
+          const tag = tk.toUpperCase();
+          envContent = envContent.split("\n").map((l) => l.startsWith(`${tag}=`) ? `${tag}=${tiers[tk]}` : l).join("\n");
+        }
+      }
+      fs.writeFileSync(envPath, envContent, "utf-8");
+    }
+
+    const manifestPath = path.join(this._workspace.cwd, "versions.json");
+    if (!fs.existsSync(manifestPath)) {
+      fs.writeFileSync(manifestPath, JSON.stringify({ version: "0.1.0", entries: [] }, null, 2), "utf-8");
+    }
+
+    this.workspaceCreated = true;
+    this._checkRegulations();
+    this._checkSamples();
+    this._checkConfig();
+  }
+
+  _checkRegulations() {
+    const dir = path.join(this._workspace.cwd, "rules");
+    if (!fs.existsSync(dir)) { this.hasRegulations = false; return; }
+    this.hasRegulations = fs.readdirSync(dir, { withFileTypes: true }).some((e) => e.isFile());
+  }
+
+  _checkSamples() {
+    const dir = path.join(this._workspace.cwd, "samples");
+    if (!fs.existsSync(dir)) { this.hasSamples = false; return; }
+    this.hasSamples = fs.readdirSync(dir, { withFileTypes: true }).some((e) => e.isFile());
+  }
+
+  _checkConfig() {
+    const envPath = path.join(this._workspace.cwd, ".env");
+    if (fs.existsSync(envPath)) {
+      for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+        if (line.startsWith("SILICONFLOW_API_KEY=") && line.split("=")[1].trim()) {
+          this.configReady = true; return;
+        }
+      }
+    }
+    const gc = this._loadGlobalConfig();
+    this.configReady = !!gc.api_key;
+  }
+
+  _loadGlobalConfig() {
+    const p = path.join(os.homedir(), ".kc_agent", "config.json");
+    if (fs.existsSync(p)) { try { return JSON.parse(fs.readFileSync(p, "utf-8")); } catch { /* skip */ } }
+    return {};
+  }
+
+  describeState() {
+    const completed = [], pending = [];
+    if (this.workspaceCreated) completed.push("Workspace structure created"); else pending.push("Create workspace structure");
+    if (this.configReady) completed.push("Configuration ready (API keys set)"); else pending.push("Configure .env (API key needed)");
+    if (this.hasRegulations) completed.push("Regulation documents available in rules/"); else pending.push("Regulation documents needed in rules/");
+    if (this.hasSamples) completed.push("Sample documents available in samples/"); else pending.push("Sample documents needed in samples/");
+
+    const parts = ["## Current Phase: BOOTSTRAP"];
+    if (completed.length) parts.push("### Completed\n" + completed.map((c) => `- [x] ${c}`).join("\n"));
+    if (pending.length) parts.push("### Pending\n" + pending.map((p) => `- [ ] ${p}`).join("\n"));
+
+    if (this.exitCriteriaMet()) {
+      parts.push("### Ready\nAll bootstrap requirements met. Proceed to EXTRACTION phase.");
+    } else {
+      parts.push(
+        "### What to do now\nTalk to the developer user about their verification scenario:\n" +
+        "- What documents do they verify?\n- What regulations apply?\n" +
+        "- Ask them to provide regulation documents (save to rules/) and sample documents (save to samples/)."
+      );
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasReady = this.exitCriteriaMet();
+
+    if (toolName === "workspace_file") {
+      const op = toolInput.operation || "";
+      const p = toolInput.path || "";
+      if (op === "write") {
+        if (p.startsWith("rules/")) this.hasRegulations = true;
+        else if (p.startsWith("samples/")) this.hasSamples = true;
+        else if (p === ".env") this._checkConfig();
+      } else if (op === "list") {
+        this._checkRegulations();
+        this._checkSamples();
+      }
+    }
+
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Bootstrap complete. Ready for EXTRACTION.", nextPhase: Phase.EXTRACTION });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    return this.workspaceCreated && this.configReady && this.hasRegulations && this.hasSamples;
+  }
+}

package/src/agent/pipelines/_archive_v1/production-qc.js

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+const FREQUENCY_MAP = { high: 1.0, mid: 0.5, low: 0.2 };
+
+export class ProductionQCPipeline extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.batchesProcessed = 0;
+    this.totalDocuments = 0;
+    this.documentsReviewed = 0;
+    this.accuracyByRule = {};
+    this.confidenceDistribution = { low: 0, medium: 0, high: 0 };
+    this.issuesFound = [];
+    this.monitoringPhase = "initial";
+    this._samplingRate = 0.5;
+    this._accuracyThreshold = 0.9;
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    this._loadConfig();
+    this._scanQcResults();
+  }
+
+  _loadConfig() {
+    const envPath = path.join(this._workspace.cwd, ".env");
+    if (!fs.existsSync(envPath)) return;
+    for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+      if (line.startsWith("MONITOR_FREQUENCY=")) this._samplingRate = FREQUENCY_MAP[line.split("=")[1].trim().toLowerCase()] ?? 0.5;
+      if (line.startsWith("WORKFLOW_ACCURACY=")) try { this._accuracyThreshold = parseFloat(line.split("=")[1]); } catch { /* skip */ }
+    }
+  }
+
+  _scanQcResults() {
+    this.batchesProcessed = 0;
+    this.totalDocuments = 0;
+    this.documentsReviewed = 0;
+    this.accuracyByRule = {};
+    this.confidenceDistribution = { low: 0, medium: 0, high: 0 };
+    this.issuesFound = [];
+
+    const qcDir = path.join(this._workspace.cwd, "output", "qc");
+    if (!fs.existsSync(qcDir)) return;
+
+    for (const f of fs.readdirSync(qcDir).filter((f) => f.endsWith(".json")).sort()) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(qcDir, f), "utf-8"));
+        this.batchesProcessed++;
+        this.totalDocuments += typeof data.documents === "number" ? data.documents : (data.total || 0);
+        this.documentsReviewed += data.reviewed || 0;
+        if (data.accuracy_by_rule) Object.assign(this.accuracyByRule, data.accuracy_by_rule);
+        if (data.confidence) {
+          for (const band of ["low", "medium", "high"]) this.confidenceDistribution[band] += data.confidence[band] || 0;
+        }
+        if (Array.isArray(data.issues)) this.issuesFound.push(...data.issues);
+      } catch { /* skip */ }
+    }
+
+    // Determine monitoring phase
+    if (this.batchesProcessed < 3) this.monitoringPhase = "initial";
+    else if (this.issuesFound.length > 0) this.monitoringPhase = "active";
+    else if (Object.values(this.accuracyByRule).every((a) => a >= this._accuracyThreshold)) this.monitoringPhase = "stable";
+    else this.monitoringPhase = "active";
+  }
+
+  describeState() {
+    this._scanWorkspace();
+    const parts = ["## Current Phase: PRODUCTION_QC"];
+    parts.push(`### Progress\n- Batches: ${this.batchesProcessed}\n- Documents: ${this.totalDocuments}\n- Reviewed: ${this.documentsReviewed}\n- Monitoring: ${this.monitoringPhase}\n- Sampling rate: ${(this._samplingRate * 100).toFixed(0)}%`);
+
+    if (Object.keys(this.accuracyByRule).length) {
+      const lines = Object.entries(this.accuracyByRule).map(([r, a]) => `- ${r}: ${a}`);
+      parts.push("### Accuracy by rule\n" + lines.join("\n"));
+    }
+
+    if (this.monitoringPhase === "initial") {
+      parts.push("### What to do now\nRun workflows on input/ documents. Save results to output/. Review and save QC to output/qc/.");
+    } else if (this.monitoringPhase === "stable") {
+      parts.push("### Status: Stable\nWorkflows running reliably. Spot-check only.");
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasStable = this.monitoringPhase === "stable";
+    if (toolName === "workspace_file" && (toolInput.path || "").includes("output/")) this._scanQcResults();
+    if (!wasStable && this.monitoringPhase === "stable") {
+      return new PipelineEvent({ type: "milestone", message: "Production QC reached stable monitoring phase." });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() { return this.monitoringPhase === "stable"; }
+}

package/src/agent/pipelines/_archive_v1/skill-authoring.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+export class SkillAuthoringPipeline extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.totalRules = [];
+    this.skillsAuthored = [];
+    this.skillsWithScripts = [];
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    this._loadRules();
+    this._scanSkills();
+  }
+
+  _loadRules() {
+    this.totalRules = [];
+    const rulesDir = path.join(this._workspace.cwd, "rules");
+    if (!fs.existsSync(rulesDir)) return;
+    for (const f of fs.readdirSync(rulesDir).filter((f) => f.endsWith(".json"))) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(rulesDir, f), "utf-8"));
+        const rules = Array.isArray(data) ? data : (data.rules || []);
+        for (const r of rules) { if (r.id) this.totalRules.push(r.id); }
+      } catch { /* skip */ }
+    }
+  }
+
+  _scanSkills() {
+    this.skillsAuthored = [];
+    this.skillsWithScripts = [];
+    const dir = path.join(this._workspace.cwd, "rule_skills");
+    if (!fs.existsSync(dir)) return;
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!e.isDirectory() || e.name.startsWith("__")) continue;
+      const skillPath = path.join(dir, e.name);
+      if (fs.existsSync(path.join(skillPath, "SKILL.md")) || fs.readdirSync(skillPath).some((f) => f.endsWith(".py"))) {
+        this.skillsAuthored.push(e.name);
+      }
+      const scriptsDir = path.join(skillPath, "scripts");
+      if (fs.existsSync(scriptsDir) && fs.readdirSync(scriptsDir).length > 0) {
+        this.skillsWithScripts.push(e.name);
+      }
+    }
+  }
+
+  describeState() {
+    this._scanWorkspace();
+    const total = this.totalRules.length;
+    const parts = ["## Current Phase: SKILL_AUTHORING"];
+    parts.push(`### Progress\n- Rules from extraction: ${total}\n- Skills authored: ${this.skillsAuthored.length}\n- Skills with scripts/: ${this.skillsWithScripts.length}`);
+
+    if (this.exitCriteriaMet()) {
+      parts.push("### Ready\nAll rules have skills. Proceed to SKILL_TESTING.");
+    } else if (this.skillsAuthored.length === 0) {
+      parts.push("### What to do now\nWrite a SKILL.md for each rule in rule_skills/{rule_id}/.\nDescribe: what to check, where to look, what to extract, how to judge.");
+    } else {
+      const remaining = this.totalRules.filter((r) => !this.skillsAuthored.includes(r));
+      parts.push(`### What to do now\n${total - this.skillsAuthored.length} rules still need skills. Remaining: ${remaining.slice(0, 10).join(", ")}`);
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasReady = this.exitCriteriaMet();
+    if (toolName === "workspace_file" && (toolInput.path || "").includes("rule_skills/")) this._scanSkills();
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Skill authoring complete. Ready for SKILL_TESTING.", nextPhase: Phase.SKILL_TESTING });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    if (!this.totalRules.length) return false;
+    return this.skillsAuthored.length >= this.totalRules.length && this.skillsWithScripts.length >= this.skillsAuthored.length * 0.5;
+  }
+}

package/src/agent/pipelines/_archive_v1/skill-testing.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+export class SkillTestingPipeline extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.skillsToTest = [];
+    this.skillsTested = {};
+    this.skillsPassing = [];
+    this.iterationCount = 0;
+    this._accuracyThreshold = 0.9;
+    this._maxIterations = 20;
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    this._loadConfig();
+    this._loadSkills();
+    this._loadTestResults();
+    this._loadEvolutionLog();
+  }
+
+  _loadConfig() {
+    const envPath = path.join(this._workspace.cwd, ".env");
+    if (!fs.existsSync(envPath)) return;
+    for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+      if (line.startsWith("SKILL_ACCURACY=")) try { this._accuracyThreshold = parseFloat(line.split("=")[1]); } catch { /* skip */ }
+      if (line.startsWith("MAX_ITERATIONS=")) try { this._maxIterations = parseInt(line.split("=")[1]); } catch { /* skip */ }
+    }
+  }
+
+  _loadSkills() {
+    this.skillsToTest = [];
+    const dir = path.join(this._workspace.cwd, "rule_skills");
+    if (!fs.existsSync(dir)) return;
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory() && !e.name.startsWith("__")) {
+        const p = path.join(dir, e.name);
+        if (fs.existsSync(path.join(p, "SKILL.md")) || fs.readdirSync(p).some((f) => f.endsWith(".py"))) {
+          this.skillsToTest.push(e.name);
+        }
+      }
+    }
+  }
+
+  _loadTestResults() {
+    this.skillsTested = {};
+    this.skillsPassing = [];
+    const outDir = path.join(this._workspace.cwd, "output");
+    if (!fs.existsSync(outDir)) return;
+    for (const f of fs.readdirSync(outDir).filter((f) => f.endsWith(".json"))) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(outDir, f), "utf-8"));
+        if (data.accuracy != null) {
+          const ruleId = data.rule_id || path.parse(f).name;
+          const acc = parseFloat(data.accuracy);
+          this.skillsTested[ruleId] = Math.max(this.skillsTested[ruleId] || 0, acc);
+        }
+      } catch { /* skip */ }
+    }
+    this.skillsPassing = Object.entries(this.skillsTested).filter(([, acc]) => acc >= this._accuracyThreshold).map(([id]) => id);
+  }
+
+  _loadEvolutionLog() {
+    const logDir = path.join(this._workspace.cwd, "logs", "evolution");
+    if (!fs.existsSync(logDir)) { this.iterationCount = 0; return; }
+    this.iterationCount = fs.readdirSync(logDir).filter((f) => f.endsWith(".json")).length;
+  }
+
+  describeState() {
+    this._scanWorkspace();
+    const total = this.skillsToTest.length;
+    const tested = Object.keys(this.skillsTested).length;
+    const passing = this.skillsPassing.length;
+    const failing = Object.entries(this.skillsTested).filter(([, acc]) => acc < this._accuracyThreshold);
+    const untested = this.skillsToTest.filter((s) => !(s in this.skillsTested));
+
+    const parts = ["## Current Phase: SKILL_TESTING"];
+    parts.push(`### Progress\n- Skills to test: ${total}\n- Tested: ${tested}\n- Passing (>=${this._accuracyThreshold}): ${passing}\n- Evolution iterations: ${this.iterationCount}/${this._maxIterations}`);
+
+    if (this.exitCriteriaMet()) {
+      parts.push("### Ready\nAll skills passing. Proceed to DISTILLATION.");
+    } else if (untested.length) {
+      parts.push(`### What to do now\nTest these skills: ${untested.slice(0, 10).join(", ")}`);
+    } else if (failing.length) {
+      parts.push("### What to do now — Evolution Cycle\nFailing skills:\n" +
+        failing.map(([id, acc]) => `- ${id}: ${acc.toFixed(2)}`).join("\n") +
+        "\n\nFollow: diagnose -> classify -> fix -> retest -> log");
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasReady = this.exitCriteriaMet();
+    if (toolName === "workspace_file" || toolName === "evolution_cycle") this._scanWorkspace();
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Skill testing complete. Ready for DISTILLATION.", nextPhase: Phase.DISTILLATION });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    const total = this.skillsToTest.length;
+    if (!total) return false;
+    return Object.keys(this.skillsTested).length >= total && this.skillsPassing.length >= total * this._accuracyThreshold;
+  }
+}

package/src/agent/pipelines/distillation.js

@@ -75,20 +75,16 @@ export class DistillationEngine extends Pipeline {
     const total = this.skillsToDistill.length;
     const created = Object.keys(this.workflowsCreated).length;
     const passing = this.workflowsPassing.length;
-    const parts = ["## Current Phase: DISTILLATION"];
+    const notCreated = this.skillsToDistill.filter((s) => !(s in this.workflowsCreated));
+    const notPassing = Object.keys(this.workflowsCreated).filter((s) => !this.workflowsPassing.includes(s));
+
+    const parts = ["## Phase: DISTILLATION\nConvert proven skills into worker LLM workflows that run cheaply at scale. Skill results from the testing phase are the accuracy baseline — workflow results must match them. Worker LLM tools (worker_llm_call, tier_downgrade, workflow_run) are now available."];
     parts.push(`### Progress\n- Skills to distill: ${total}\n- Workflows created: ${created}\n- Workflows passing (>=${this._workflowAccuracy}): ${passing}`);
+    if (notCreated.length) parts.push(`- Need workflows: ${notCreated.slice(0, 10).join(", ")}`);
+    if (notPassing.length) parts.push(`- Below threshold: ${notPassing.slice(0, 10).join(", ")}`);
 
     if (this.exitCriteriaMet()) {
-      parts.push("### Ready\nAll workflows passing. Proceed to PRODUCTION_QC.");
-    } else if (created === 0) {
-      parts.push("### What to do now\nConvert proven skills into worker LLM workflows.\nFor each skill: write workflow script, write prompts, test vs ground truth, tier-downgrade test.");
-    } else {
-      const notCreated = this.skillsToDistill.filter((s) => !(s in this.workflowsCreated));
-      const notPassing = Object.keys(this.workflowsCreated).filter((s) => !this.workflowsPassing.includes(s));
-      let guidance = "### What to do now\n";
-      if (notCreated.length) guidance += `Create workflows for: ${notCreated.slice(0, 10).join(", ")}\n`;
-      if (notPassing.length) guidance += `Improve accuracy for: ${notPassing.slice(0, 10).join(", ")}\n`;
-      parts.push(guidance);
+      parts.push("### Exit\nAll workflows passing. Proceed to PRODUCTION_QC.");
     }
     return parts.join("\n\n");
   }

package/src/agent/pipelines/extraction.js

@@ -60,16 +60,14 @@ export class RuleExtractionPipeline extends Pipeline {
 
   describeState() {
     this._scanWorkspace();
-    const parts = ["## Current Phase: EXTRACTION"];
-    parts.push(`### Progress\n- Regulations scanned: ${this.regulationsScanned ? "yes" : "no"}\n- Rules extracted: ${this.rulesExtracted.length}\n- Rules with tests: ${this.rulesWithTests.length}\n- Coverage audit: ${this.coverageAudited ? "done" : "not yet"}`);
+    const parts = ["## Phase: EXTRACTION\nRead and decompose regulation documents into atomic, testable verification rules. This is BUILD mode — do the analysis directly."];
+    parts.push(`### Progress\n- Regulations scanned: ${this.regulationsScanned ? "yes" : "no"}\n- Rules extracted: ${this.rulesExtracted.length}\n- Rules with test stubs: ${this.rulesWithTests.length}\n- Coverage audit: ${this.coverageAudited ? "done" : "pending"}`);
 
     if (this.exitCriteriaMet()) {
-      parts.push("### Ready\nExtraction complete. Proceed to SKILL_AUTHORING phase.");
-    } else if (this.rulesExtracted.length === 0) {
-      parts.push("### What to do now\nDecompose regulations into atomic, testable rules.\n- One rule = one pass/fail outcome\n- Work top-down: major areas → chapters → sections → atomic rules\n- Save rules to rules/catalog.json via rule_catalog tool");
-    } else if (!this.coverageAudited) {
-      parts.push("### What to do now\nRun a coverage audit: which regulation sections are NOT covered? Save to rules/coverage_audit.md");
+      parts.push("### Exit\nExtraction complete. Proceed to SKILL_AUTHORING.");
     }
+
+    parts.push(`### Exit criteria\n- [${this.regulationsScanned ? "x" : " "}] All regulations read\n- [${this.rulesExtracted.length > 0 ? "x" : " "}] Rules decomposed into atomic units\n- [${this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) ? "x" : " "}] >=80% of rules have test stubs\n- [${this.coverageAudited ? "x" : " "}] Coverage audit completed`);
     return parts.join("\n\n");
   }
 

package/src/agent/pipelines/initializer.js

@@ -113,23 +113,17 @@ export class ProjectInitializer extends Pipeline {
 
   describeState() {
     const completed = [], pending = [];
-    if (this.workspaceCreated) completed.push("Workspace structure created"); else pending.push("Create workspace structure");
-    if (this.configReady) completed.push("Configuration ready (API keys set)"); else pending.push("Configure .env (API key needed)");
-    if (this.hasRegulations) completed.push("Regulation documents available in rules/"); else pending.push("Regulation documents needed in rules/");
-    if (this.hasSamples) completed.push("Sample documents available in samples/"); else pending.push("Sample documents needed in samples/");
+    if (this.workspaceCreated) completed.push("Workspace structure created"); else pending.push("Workspace structure");
+    if (this.configReady) completed.push("API keys configured"); else pending.push("API keys (check .env)");
+    if (this.hasRegulations) completed.push("Regulation documents in rules/"); else pending.push("Regulation documents in rules/");
+    if (this.hasSamples) completed.push("Sample documents in samples/"); else pending.push("Sample documents in samples/");
 
-    const parts = ["## Current Phase: BOOTSTRAP"];
-    if (completed.length) parts.push("### Completed\n" + completed.map((c) => `- [x] ${c}`).join("\n"));
-    if (pending.length) parts.push("### Pending\n" + pending.map((p) => `- [ ] ${p}`).join("\n"));
+    const parts = ["## Phase: BOOTSTRAP\nSet up the workspace and understand the developer user's verification scenario. Bundled methodology skills are available in the workspace skills/ directory."];
+    if (completed.length) parts.push("### Done\n" + completed.map((c) => `- [x] ${c}`).join("\n"));
+    if (pending.length) parts.push("### Needed\n" + pending.map((p) => `- [ ] ${p}`).join("\n"));
 
     if (this.exitCriteriaMet()) {
-      parts.push("### Ready\nAll bootstrap requirements met. Proceed to EXTRACTION phase.");
-    } else {
-      parts.push(
-        "### What to do now\nTalk to the developer user about their verification scenario:\n" +
-        "- What documents do they verify?\n- What regulations apply?\n" +
-        "- Ask them to provide regulation documents (save to rules/) and sample documents (save to samples/)."
-      );
+      parts.push("### Exit\nBootstrap requirements met. Proceed to EXTRACTION.");
     }
     return parts.join("\n\n");
   }

package/src/agent/pipelines/production-qc.js

@@ -69,7 +69,7 @@ export class ProductionQCPipeline extends Pipeline {
 
   describeState() {
     this._scanWorkspace();
-    const parts = ["## Current Phase: PRODUCTION_QC"];
+    const parts = ["## Phase: PRODUCTION_QC\nRun workflows on production documents from input/, monitor quality via confidence-based sampling. This phase transitions from active review to stable spot-checking as accuracy stabilizes."];
     parts.push(`### Progress\n- Batches: ${this.batchesProcessed}\n- Documents: ${this.totalDocuments}\n- Reviewed: ${this.documentsReviewed}\n- Monitoring: ${this.monitoringPhase}\n- Sampling rate: ${(this._samplingRate * 100).toFixed(0)}%`);
 
     if (Object.keys(this.accuracyByRule).length) {
@@ -77,10 +77,8 @@ export class ProductionQCPipeline extends Pipeline {
       parts.push("### Accuracy by rule\n" + lines.join("\n"));
     }
 
-    if (this.monitoringPhase === "initial") {
-      parts.push("### What to do now\nRun workflows on input/ documents. Save results to output/. Review and save QC to output/qc/.");
-    } else if (this.monitoringPhase === "stable") {
-      parts.push("### Status: Stable\nWorkflows running reliably. Spot-check only.");
+    if (this.monitoringPhase === "stable") {
+      parts.push("### Status: Stable monitoring. Spot-check only.");
     }
     return parts.join("\n\n");
   }

package/src/agent/pipelines/skill-authoring.js

@@ -52,16 +52,13 @@ export class SkillAuthoringPipeline extends Pipeline {
   describeState() {
     this._scanWorkspace();
     const total = this.totalRules.length;
-    const parts = ["## Current Phase: SKILL_AUTHORING"];
-    parts.push(`### Progress\n- Rules from extraction: ${total}\n- Skills authored: ${this.skillsAuthored.length}\n- Skills with scripts/: ${this.skillsWithScripts.length}`);
+    const authored = this.skillsAuthored.length;
+    const remaining = this.totalRules.filter((r) => !this.skillsAuthored.includes(r));
+    const parts = ["## Phase: SKILL_AUTHORING\nWrite verification skills for each extracted rule. Skills are first-class deliverables — they may serve as the production solution when worker LLM workflows are insufficient. Follow Anthropic skill-creator format. This is BUILD mode."];
+    parts.push(`### Progress\n- Rules: ${total}\n- Skills authored: ${authored}\n- Skills with scripts/: ${this.skillsWithScripts.length}${remaining.length > 0 ? `\n- Remaining: ${remaining.slice(0, 10).join(", ")}` : ""}`);
 
     if (this.exitCriteriaMet()) {
-      parts.push("### Ready\nAll rules have skills. Proceed to SKILL_TESTING.");
-    } else if (this.skillsAuthored.length === 0) {
-      parts.push("### What to do now\nWrite a SKILL.md for each rule in rule_skills/{rule_id}/.\nDescribe: what to check, where to look, what to extract, how to judge.");
-    } else {
-      const remaining = this.totalRules.filter((r) => !this.skillsAuthored.includes(r));
-      parts.push(`### What to do now\n${total - this.skillsAuthored.length} rules still need skills. Remaining: ${remaining.slice(0, 10).join(", ")}`);
+      parts.push("### Exit\nAll rules have skills. Proceed to SKILL_TESTING.");
     }
     return parts.join("\n\n");
   }

package/src/agent/pipelines/skill-testing.js

@@ -78,17 +78,15 @@ export class SkillTestingPipeline extends Pipeline {
     const failing = Object.entries(this.skillsTested).filter(([, acc]) => acc < this._accuracyThreshold);
     const untested = this.skillsToTest.filter((s) => !(s in this.skillsTested));
 
-    const parts = ["## Current Phase: SKILL_TESTING"];
+    const parts = ["## Phase: SKILL_TESTING\nTest skills against sample documents, iterate via evolution loop until accuracy threshold is met. This is BUILD mode — the results established here become the accuracy baseline for distillation."];
     parts.push(`### Progress\n- Skills to test: ${total}\n- Tested: ${tested}\n- Passing (>=${this._accuracyThreshold}): ${passing}\n- Evolution iterations: ${this.iterationCount}/${this._maxIterations}`);
+    if (untested.length) parts.push(`- Untested: ${untested.slice(0, 10).join(", ")}`);
+    if (failing.length) parts.push(`- Below threshold:\n${failing.map(([id, acc]) => `  - ${id}: ${acc.toFixed(2)}`).join("\n")}`);
 
     if (this.exitCriteriaMet()) {
-      parts.push("### Ready\nAll skills passing. Proceed to DISTILLATION.");
-    } else if (untested.length) {
-      parts.push(`### What to do now\nTest these skills: ${untested.slice(0, 10).join(", ")}`);
-    } else if (failing.length) {
-      parts.push("### What to do now — Evolution Cycle\nFailing skills:\n" +
-        failing.map(([id, acc]) => `- ${id}: ${acc.toFixed(2)}`).join("\n") +
-        "\n\nFollow: diagnose -> classify -> fix -> retest -> log");
+      parts.push("### Exit\nAll skills passing. Proceed to DISTILLATION.");
+    } else if (this.iterationCount >= this._maxIterations) {
+      parts.push(`### Max iterations (${this._maxIterations}) reached. Discuss remaining failures with the developer user.`);
     }
     return parts.join("\n\n");
   }