kc-beta 0.1.0

package/src/agent/history.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Manages the message list for the OpenAI-compatible API.
+ * Persists to workspace/logs/conversation/ on every write.
+ * Loads existing history when workspacePath is provided.
+ */
+export class ConversationHistory {
+  /**
+   * @param {string} [workspacePath] - Workspace directory for persistence
+   */
+  constructor(workspacePath) {
+    /** @type {Array<object>} API messages */
+    this._messages = [];
+    /** @type {Array<object>} Flat display log for replay */
+    this._displayLog = [];
+    this._workspacePath = workspacePath || null;
+
+    if (this._workspacePath) this._load();
+  }
+
+  get messages() { return this._messages; }
+  get displayLog() { return this._displayLog; }
+
+  addUser(text) {
+    this._messages.push({ role: "user", content: text });
+    this._displayLog.push({ role: "user", content: text });
+    this._save();
+  }
+
+  /**
+   * Add a pre-built message dict (assistant with tool_calls, tool results, etc.)
+   * @param {object} message
+   */
+  addRaw(message) {
+    this._messages.push(message);
+
+    const role = message.role || "";
+    if (role === "assistant") {
+      const content = message.content || "";
+      if (content) {
+        this._displayLog.push({ role: "agent", content });
+      }
+      for (const tc of message.tool_calls || []) {
+        const fn = tc.function || {};
+        let toolInput = {};
+        try { toolInput = JSON.parse(fn.arguments || "{}"); } catch { /* ignore */ }
+        this._displayLog.push({
+          role: "tool",
+          toolName: fn.name || "",
+          toolInput,
+        });
+      }
+    } else if (role === "tool") {
+      const content = message.content || "";
+      // Update the last tool entry with output
+      for (let i = this._displayLog.length - 1; i >= 0; i--) {
+        if (this._displayLog[i].role === "tool" && !("toolOutput" in this._displayLog[i])) {
+          this._displayLog[i].toolOutput = content;
+          break;
+        }
+      }
+    }
+
+    this._save();
+  }
+
+  _save() {
+    if (!this._workspacePath) return;
+    const convDir = path.join(this._workspacePath, "logs", "conversation");
+    fs.mkdirSync(convDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(convDir, "messages.json"),
+      JSON.stringify(this._messages, null, 2),
+      "utf-8",
+    );
+    fs.writeFileSync(
+      path.join(convDir, "display.json"),
+      JSON.stringify(this._displayLog, null, 2),
+      "utf-8",
+    );
+  }
+
+  _load() {
+    if (!this._workspacePath) return;
+    const convDir = path.join(this._workspacePath, "logs", "conversation");
+
+    const msgPath = path.join(convDir, "messages.json");
+    if (fs.existsSync(msgPath)) {
+      try { this._messages = JSON.parse(fs.readFileSync(msgPath, "utf-8")); }
+      catch { this._messages = []; }
+    }
+
+    const displayPath = path.join(convDir, "display.json");
+    if (fs.existsSync(displayPath)) {
+      try { this._displayLog = JSON.parse(fs.readFileSync(displayPath, "utf-8")); }
+      catch { this._displayLog = []; }
+    }
+  }
+}

package/src/agent/llm-client.js

@@ -0,0 +1,131 @@
+/**
+ * Thin LLM client using native fetch + SSE parsing.
+ * Replaces the Python openai.AsyncOpenAI client.
+ * Supports OpenAI-compatible APIs (SiliconFlow, Aliyun, OpenAI, etc.)
+ */
+export class LLMClient {
+  /**
+   * @param {object} opts
+   * @param {string} opts.apiKey
+   * @param {string} opts.baseUrl - e.g. "https://api.siliconflow.cn/v1"
+   */
+  constructor({ apiKey, baseUrl }) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+
+  /**
+   * Streaming chat completion. Yields parsed SSE chunk objects.
+   * @param {object} opts
+   * @param {string} opts.model
+   * @param {Array} opts.messages
+   * @param {Array} [opts.tools]
+   * @param {number} [opts.maxTokens]
+   * @yields {object} Parsed chunk from the SSE stream
+   */
+  async *streamChat({ model, messages, tools, maxTokens }) {
+    const body = {
+      model,
+      messages,
+      stream: true,
+    };
+    if (maxTokens) body.max_tokens = maxTokens;
+    if (tools && tools.length > 0) body.tools = tools;
+
+    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`LLM API error ${resp.status}: ${text}`);
+    }
+
+    for await (const data of this._parseSSE(resp.body)) {
+      yield data;
+    }
+  }
+
+  /**
+   * Non-streaming chat completion. Returns the full response.
+   * @param {object} opts
+   * @param {string} opts.model
+   * @param {Array} opts.messages
+   * @param {number} [opts.maxTokens]
+   * @returns {object} The response object
+   */
+  async chat({ model, messages, maxTokens }) {
+    const body = {
+      model,
+      messages,
+    };
+    if (maxTokens) body.max_tokens = maxTokens;
+
+    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`LLM API error ${resp.status}: ${text}`);
+    }
+
+    return resp.json();
+  }
+
+  /**
+   * Parse SSE stream from a ReadableStream.
+   * Handles the `data: {...}` format used by OpenAI-compatible APIs.
+   * @param {ReadableStream} body
+   * @yields {object} Parsed JSON from each data line
+   */
+  async *_parseSSE(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    for await (const chunk of body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop(); // keep incomplete line
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(":")) continue;
+        if (trimmed.startsWith("data: ")) {
+          const data = trimmed.slice(6).trim();
+          if (data === "[DONE]") return;
+          try {
+            yield JSON.parse(data);
+          } catch {
+            // Skip malformed JSON lines
+          }
+        }
+      }
+    }
+
+    // Process any remaining buffer
+    if (buffer.trim()) {
+      const trimmed = buffer.trim();
+      if (trimmed.startsWith("data: ")) {
+        const data = trimmed.slice(6).trim();
+        if (data !== "[DONE]") {
+          try {
+            yield JSON.parse(data);
+          } catch {
+            // Skip
+          }
+        }
+      }
+    }
+  }
+}

package/src/agent/pipelines/base.js

@@ -0,0 +1,14 @@
+/**
+ * Base class for all pipeline components.
+ * Each pipeline hard-codes one meta-meta skill's methodology as structural code.
+ */
+export class Pipeline {
+  /** Return context injected into the system prompt before each LLM call. */
+  describeState() { throw new Error("Not implemented"); }
+
+  /** Called after each tool execution. Returns PipelineEvent or null. */
+  onToolResult(toolName, toolInput, result) { throw new Error("Not implemented"); }
+
+  /** Whether all requirements for leaving this phase are satisfied. */
+  exitCriteriaMet() { throw new Error("Not implemented"); }
+}

package/src/agent/pipelines/distillation.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+export class DistillationEngine extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.skillsToDistill = [];
+    this.workflowsCreated = {};
+    this.workflowsTested = {};
+    this.workflowsPassing = [];
+    this.tierAssignments = {};
+    this._workflowAccuracy = 0.9;
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    this._loadConfig();
+    this._loadSkills();
+    this._scanWorkflows();
+  }
+
+  _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("WORKFLOW_ACCURACY=")) try { this._workflowAccuracy = parseFloat(line.split("=")[1]); } catch { /* skip */ }
+    }
+  }
+
+  _loadSkills() {
+    this.skillsToDistill = [];
+    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("__")) this.skillsToDistill.push(e.name);
+    }
+  }
+
+  _scanWorkflows() {
+    this.workflowsCreated = {};
+    this.workflowsTested = {};
+    this.workflowsPassing = [];
+    this.tierAssignments = {};
+    const wfDir = path.join(this._workspace.cwd, "workflows");
+    if (!fs.existsSync(wfDir)) return;
+
+    for (const e of fs.readdirSync(wfDir, { withFileTypes: true })) {
+      if (e.isDirectory()) {
+        const ruleDir = path.join(wfDir, e.name);
+        const pyFiles = fs.readdirSync(ruleDir).filter((f) => f.endsWith(".py"));
+        if (pyFiles.length > 0) this.workflowsCreated[e.name] = pyFiles.length;
+        const cfgPath = path.join(ruleDir, "config.json");
+        if (fs.existsSync(cfgPath)) {
+          try {
+            const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+            if (cfg.tier) this.tierAssignments[e.name] = cfg.tier;
+            if (cfg.accuracy != null) {
+              const acc = parseFloat(cfg.accuracy);
+              this.workflowsTested[e.name] = acc;
+              if (acc >= this._workflowAccuracy) this.workflowsPassing.push(e.name);
+            }
+          } catch { /* skip */ }
+        }
+      } else if (e.isFile() && e.name.endsWith(".py")) {
+        this.workflowsCreated[path.parse(e.name).name] = 1;
+      }
+    }
+  }
+
+  describeState() {
+    this._scanWorkspace();
+    const total = this.skillsToDistill.length;
+    const created = Object.keys(this.workflowsCreated).length;
+    const passing = this.workflowsPassing.length;
+    const parts = ["## Current Phase: DISTILLATION"];
+    parts.push(`### Progress\n- Skills to distill: ${total}\n- Workflows created: ${created}\n- Workflows passing (>=${this._workflowAccuracy}): ${passing}`);
+
+    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);
+    }
+    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("workflows/") || (toolInput.path || "").includes("output/"))) {
+      this._scanWorkflows();
+    }
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Distillation complete. Ready for PRODUCTION_QC.", nextPhase: Phase.PRODUCTION_QC });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    const total = this.skillsToDistill.length;
+    if (!total) return false;
+    return Object.keys(this.workflowsCreated).length >= total && this.workflowsPassing.length >= total;
+  }
+}

package/src/agent/pipelines/extraction.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+export class RuleExtractionPipeline extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.regulationsScanned = false;
+    this.rulesExtracted = [];
+    this.rulesWithTests = [];
+    this.coverageAudited = false;
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    const rulesDir = path.join(this._workspace.cwd, "rules");
+    if (fs.existsSync(rulesDir)) {
+      const regFiles = fs.readdirSync(rulesDir).filter((f) => !f.endsWith(".json") && fs.statSync(path.join(rulesDir, f)).isFile());
+      this.regulationsScanned = regFiles.length > 0;
+    }
+    this._scanRules();
+    this._scanTests();
+    this.coverageAudited = fs.existsSync(path.join(this._workspace.cwd, "rules", "coverage_audit.md")) ||
+                           fs.existsSync(path.join(this._workspace.cwd, "rules", "coverage_audit.json"));
+  }
+
+  _scanRules() {
+    this.rulesExtracted = [];
+    const catalogPath = path.join(this._workspace.cwd, "rules", "catalog.json");
+    if (fs.existsSync(catalogPath)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+        if (Array.isArray(data)) this.rulesExtracted = data.map((r, i) => r.id || `rule_${i}`);
+      } catch { /* skip */ }
+    }
+    const skillsDir = path.join(this._workspace.cwd, "rule_skills");
+    if (fs.existsSync(skillsDir)) {
+      for (const e of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (e.isDirectory() && !e.name.startsWith("__") && !this.rulesExtracted.includes(e.name)) {
+          this.rulesExtracted.push(e.name);
+        }
+      }
+    }
+  }
+
+  _scanTests() {
+    this.rulesWithTests = [];
+    const skillsDir = path.join(this._workspace.cwd, "rule_skills");
+    if (!fs.existsSync(skillsDir)) return;
+    for (const e of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (!e.isDirectory()) continue;
+      const testDir = path.join(skillsDir, e.name, "test_cases");
+      if (fs.existsSync(testDir) && fs.readdirSync(testDir).length > 0) {
+        this.rulesWithTests.push(e.name);
+      }
+    }
+  }
+
+  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"}`);
+
+    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");
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasReady = this.exitCriteriaMet();
+    if (toolName === "workspace_file" || toolName === "rule_catalog") {
+      this._scanWorkspace();
+    }
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Extraction complete. Ready for SKILL_AUTHORING.", nextPhase: Phase.SKILL_AUTHORING });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    return this.regulationsScanned && this.rulesExtracted.length > 0 &&
+      this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) && this.coverageAudited;
+  }
+}

package/src/agent/pipelines/index.js

@@ -0,0 +1,23 @@
+/**
+ * Pipeline phases — sequential workflow of the KC Agent methodology.
+ */
+export const Phase = Object.freeze({
+  BOOTSTRAP: "bootstrap",
+  EXTRACTION: "extraction",
+  SKILL_AUTHORING: "skill_authoring",
+  SKILL_TESTING: "skill_testing",
+  DISTILLATION: "distillation",
+  PRODUCTION_QC: "production_qc",
+});
+
+/**
+ * Emitted by pipelines when a milestone or phase transition occurs.
+ */
+export class PipelineEvent {
+  constructor({ type, message = "", nextPhase = null, data = {} }) {
+    this.type = type;       // "milestone", "phase_ready", "error"
+    this.message = message;
+    this.nextPhase = nextPhase;
+    this.data = data;
+  }
+}

package/src/agent/pipelines/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;
+  }
+}