kc-beta 0.6.1 → 0.7.0

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

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { Phase, PipelineEvent } from "./index.js";
 import { Pipeline } from "./base.js";
+import { SkillValidator } from "../skill-validator.js";
+import { deriveSkillAuthoringMilestones } from "./_milestone-derive.js";
 
 export class SkillAuthoringPipeline extends Pipeline {
   /**
@@ -16,6 +18,13 @@ export class SkillAuthoringPipeline extends Pipeline {
     super();
     this._workspace = workspace;
     this._taskManager = taskManager;
+    // v0.6.2 I2: skill validator catches malformed check_r###.py at the
+    // skill_authoring exit boundary instead of silently passing the
+    // phase and breaking in production_qc (E2E #4 unified_qc.py
+    // SyntaxError went undiagnosed for hours).
+    this._validator = new SkillValidator();
+    this._validationFailures = [];
+    this._validationSkipped = false;
     this.totalRules = [];
     this.skillsAuthored = [];
     this.skillsWithScripts = [];
@@ -41,83 +50,22 @@ export class SkillAuthoringPipeline extends Pipeline {
   }
 
   _scanSkills() {
-    this.skillsAuthored = [];
-    this.skillsWithScripts = [];
-    // D2: rule_ids that are covered by some authored skill — whether that
-    // skill is single-rule (rule_skills/R014/) or grouped
-    // (rule_skills/SK02/check_r002_r007.py). Populated by _walkForRuleIds
-    // below so the exit criterion counts DISTINCT rule coverage rather
-    // than skill-directory count, which over-counts when skills are
-    // grouped (session 6304673afaa0's rule_skills/ had 289 rules packed
-    // into 23 skill files).
-    this.ruleIdsCovered = new Set();
-    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);
-      }
-      this._walkForRuleIds(skillPath);
-    }
+    // v0.7.0 A1: route through filesystem-derived milestone helper. The
+    // helper centralizes the ruleId extraction patterns (R### dirs,
+    // check_r###.py, range dirs R078_R128, grouped check_r###_r###.py)
+    // and recognizes both root-level check_*.py AND scripts/check*.py
+    // (per A6 — XM E2E #5 used scripts/ subdir).
+    const m = deriveSkillAuthoringMilestones(this._workspace);
+    this.skillsAuthored = [...m.skillsAuthored];
+    this.skillsWithScripts = [...m.skillsWithScripts];
+    this.ruleIdsCovered = new Set(m.ruleIdsCovered);
   }
 
-  /**
-   * D2: Find rule_ids referenced by any file under the skill directory.
-   * Recognizes three naming patterns from actual sessions:
-   *   - Directory name matches a rule: rule_skills/R014/
-   *   - Single-rule script: check_r014.py
-   *   - Grouped script: check_r002_r007.py → covers R002 through R007
-   */
-  _walkForRuleIds(skillDir) {
-    const dirName = path.basename(skillDir);
-    const dirMatch = dirName.match(/^R0*(\d+)$/i);
-    if (dirMatch) this.ruleIdsCovered.add(`R${String(parseInt(dirMatch[1], 10)).padStart(3, "0")}`);
-
-    const walk = (d) => {
-      let entries;
-      try { entries = fs.readdirSync(d, { withFileTypes: true }); }
-      catch { return; }
-      for (const e of entries) {
-        if (e.name.startsWith(".")) continue;
-        const p = path.join(d, e.name);
-        if (e.isDirectory()) { walk(p); continue; }
-        // Per-rule: check_r014.py
-        const single = e.name.match(/check_r0*(\d+)\.py$/i);
-        if (single) {
-          this.ruleIdsCovered.add(`R${String(parseInt(single[1], 10)).padStart(3, "0")}`);
-          continue;
-        }
-        // Grouped: check_r002_r007.py, check_r002-r007.py, check_r59_r77.py
-        const grouped = e.name.match(/check_r0*(\d+)[_-]+r0*(\d+)\.py$/i);
-        if (grouped) {
-          const lo = parseInt(grouped[1], 10);
-          const hi = parseInt(grouped[2], 10);
-          for (let n = lo; n <= hi; n++) {
-            this.ruleIdsCovered.add(`R${String(n).padStart(3, "0")}`);
-          }
-          continue;
-        }
-        // Directory names that encode ranges: R078_R128/
-        // handled by caller passing skillDir
-      }
-    };
-    // Also handle dirs named like R078_R128/
-    const rangeDir = dirName.match(/^R0*(\d+)[_-]R0*(\d+)$/i);
-    if (rangeDir) {
-      const lo = parseInt(rangeDir[1], 10);
-      const hi = parseInt(rangeDir[2], 10);
-      for (let n = lo; n <= hi; n++) {
-        this.ruleIdsCovered.add(`R${String(n).padStart(3, "0")}`);
-      }
-    }
-    walk(skillDir);
-  }
+  // v0.7.0 A1: ruleId extraction moved to _milestone-derive.js
+  // (deriveSkillAuthoringMilestones). Pattern recognition is identical
+  // — single rule (R014, check_r014.py), grouped scripts
+  // (check_r002_r007.py), range dirs (R078_R128). Kept as a single
+  // canonical implementation rather than duplicating across pipelines.
 
   describeState() {
     this._scanWorkspace();
@@ -128,15 +76,37 @@ export class SkillAuthoringPipeline extends Pipeline {
       "## Phase: SKILL_AUTHORING\n" +
       "Write 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.\n\n" +
+      "workflows are insufficient. Follow the canonical skill-folder layout " +
+      "(below). This is BUILD mode.\n\n" +
+      // v0.7.0 D1: inline the canonical folder structure spec so the
+      // agent sees it in every system prompt of this phase. E2E #5
+      // showed three of four contestants ignored the meta-meta spec
+      // because it required navigating to read the SKILL.md file
+      // separately. Inlining costs ~250 tokens and dramatically improves
+      // first-attempt structural compliance.
+      "### Canonical skill folder layout\n" +
+      "```\n" +
+      "rule_skills/\n" +
+      "  R014/                                # one dir per rule (or grouped range)\n" +
+      "    SKILL.md                           # YAML frontmatter (name+description) + methodology\n" +
+      "    check_r014.py                      # entry point: def check_rule|verify|check|evaluate(...)\n" +
+      "    references/regulation.md           # verbatim regulation text (optional)\n" +
+      "    references/interpretation.md       # edge-case notes (optional)\n" +
+      "    assets/test_cases.json             # annotated samples + expected verdicts (optional)\n" +
+      "```\n" +
+      "Validator-accepted alternatives: `scripts/check_r###.py` (under scripts/) " +
+      "instead of root-level. SKILL.md filename is case-insensitive (skill.md " +
+      "is also accepted). The check.py just needs a top-level `def` at module " +
+      "level — entry-point name does not have to match a strict pattern.\n\n" +
       // D2: soft granularity nudge
       "**Granularity preference:** 1 rule = 1 skill directory. Group rules into " +
       "the same file ONLY when they share evidence and fail together (e.g. " +
       "siblings from the same required-fields table). When grouping, name the " +
       "file with the range: `check_r002_r007.py`. Downstream consumers " +
-      "(workflow-run, dashboards) count rule coverage by parsing these names, " +
-      "so the file-naming matters.\n\n" +
+      "(workflow-run, dashboards, release tool) count rule coverage by parsing " +
+      "these names, so the file-naming matters. (Read `meta-meta/work-decomposition` " +
+      "for the full grouping/ordering decision framework + PATTERNS.md memory " +
+      "discipline.)\n\n" +
       "**Do not write to rules/catalog.json via sandbox_exec.** Use the " +
       "`rule_catalog` tool for any catalog edits — sandbox_exec bypasses the " +
       "workspace file lock and races with parallel workers."
@@ -152,6 +122,18 @@ export class SkillAuthoringPipeline extends Pipeline {
           (failedT > 0 ? ` (+${failedT} failed)` : "");
       }
     }
+    // v0.6.2 I2: validation status (only meaningful after first
+    // exitCriteriaMet call populates _validationFailures)
+    let validationLine = "";
+    if (this._validationSkipped) {
+      validationLine = `\n- Skill validation: SKIPPED (python3 not on PATH — install to enable)`;
+    } else if (this._validationFailures.length > 0) {
+      const f = this._validationFailures.slice(0, 5).map(({ filePath, error }) =>
+        `\n  - ${path.relative(this._workspace.cwd, filePath)}: ${error.split("\n")[0]}`,
+      ).join("");
+      validationLine = `\n- Skills failing validation (${this._validationFailures.length}):${f}` +
+        (this._validationFailures.length > 5 ? `\n  - … and ${this._validationFailures.length - 5} more` : "");
+    }
     parts.push(
       `### Progress (rule-id coverage, D2)\n` +
       `- Total rules in catalog: ${total}\n` +
@@ -159,6 +141,7 @@ export class SkillAuthoringPipeline extends Pipeline {
       `- Skill directories authored: ${this.skillsAuthored.length}\n` +
       `- Skills with scripts/: ${this.skillsWithScripts.length}` +
       taskLine +
+      validationLine +
       (uncovered.length > 0
         ? `\n- Missing coverage (${uncovered.length}): ${uncovered.slice(0, 15).join(", ")}${uncovered.length > 15 ? "…" : ""}`
         : ""),
@@ -173,7 +156,38 @@ export class SkillAuthoringPipeline extends Pipeline {
   onToolResult(toolName, toolInput, result) {
     if (result.isError) return null;
     const wasReady = this.exitCriteriaMet();
-    if (toolName === "workspace_file" && (toolInput.path || "").includes("rule_skills/")) this._scanSkills();
+    const writeToSkill = toolName === "workspace_file" &&
+      toolInput?.operation === "write" &&
+      (toolInput.path || "").includes("rule_skills/");
+    if (writeToSkill) {
+      this._scanSkills();
+      // v0.7.0 A4: validate this specific file immediately if it looks
+      // like a check.py. Surfaces syntax/entry-point issues in the next
+      // describeState rather than waiting for the phase boundary —
+      // E2E #5 had skill_authoring force-bypassed before exitCriteriaMet
+      // ever fired, so the v0.6.2 boundary-only validator never ran in
+      // practice.
+      const p = toolInput.path || "";
+      if (/\/check[_a-zA-Z0-9-]*\.py$/i.test(p) && /^rule_skills\//.test(p)) {
+        const abs = path.join(this._workspace.cwd, p);
+        // Invalidate any stale mtime cache entry for this path then
+        // re-validate. Folds the result into _validationFailures so
+        // describeState picks it up.
+        this._validator.invalidate(abs);
+        const r = this._validator.validateFile(abs);
+        if (!r.ok) {
+          // Replace any prior failure record for this path
+          this._validationFailures = this._validationFailures.filter(
+            (f) => f.filePath !== abs,
+          );
+          this._validationFailures.push({ filePath: abs, error: r.error || "unknown" });
+        } else {
+          this._validationFailures = this._validationFailures.filter(
+            (f) => f.filePath !== abs,
+          );
+        }
+      }
+    }
     if (!wasReady && this.exitCriteriaMet()) {
       return new PipelineEvent({ type: "phase_ready", message: "Skill authoring complete. Ready for SKILL_TESTING.", nextPhase: Phase.SKILL_TESTING });
     }
@@ -204,9 +218,67 @@ export class SkillAuthoringPipeline extends Pipeline {
         if (completed + failed < total) return false;
       }
     }
+    // v0.6.2 I2: skill validator — every check_r###.py must parse and
+    // expose an entry point. Catches the unified_qc.py-style monolith
+    // and other malformed scripts before they break in production_qc.
+    // mtime cache keeps this O(1) in steady state. Failures preserved
+    // in this._validationFailures for describeState rendering.
+    const checkFiles = this._collectCheckScripts();
+    const v = this._validator.validateAll(checkFiles);
+    this._validationFailures = v.failures;
+    this._validationSkipped = v.skipped;
+    if (!v.ok) return false;
     return this.skillsWithScripts.length >= Math.max(1, this.skillsAuthored.length * 0.5);
   }
 
+  /**
+   * v0.6.2 I2: gather every check_r###.py path under rule_skills/. Used by
+   * the skill validator. Walks one level into each skill directory.
+   */
+  /**
+   * v0.6.3 (#74): SKILL_AUTHORING writes per-rule check scripts under
+   * rule_skills/. Workflow runs against production samples or distillation
+   * outputs are later-phase work.
+   */
+  phaseMisfitHint(toolName, toolInput, result) {
+    if (result?.isError) return null;
+    const exitText = this.exitCriteriaMet()
+      ? "Skill-authoring exit criteria are MET — call phase_advance(to=\"skill_testing\") to proceed."
+      : "Skill-authoring not yet complete (see describeState).";
+
+    if (toolName === "workspace_file" && toolInput?.operation === "write") {
+      const p = toolInput.path || "";
+      if (p.startsWith("workflows/")) {
+        return `Writing under workflows/ is DISTILLATION-phase work, but engine is in SKILL_AUTHORING. ${exitText}`;
+      }
+      if (p.startsWith("output/results/")) {
+        return `Writing under output/results/ is PRODUCTION_QC-phase work, but engine is in SKILL_AUTHORING. ${exitText}`;
+      }
+    }
+
+    return null;
+  }
+
+  _collectCheckScripts() {
+    const out = [];
+    const dir = path.join(this._workspace.cwd, "rule_skills");
+    if (!fs.existsSync(dir)) return out;
+    const walk = (d) => {
+      let entries;
+      try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+      for (const e of entries) {
+        if (e.name.startsWith(".") || e.name.startsWith("__")) continue;
+        const p = path.join(d, e.name);
+        if (e.isDirectory()) { walk(p); continue; }
+        if (e.isFile() && /^check_r[\d_-]+\.py$/i.test(e.name)) {
+          out.push(p);
+        }
+      }
+    };
+    walk(dir);
+    return out;
+  }
+
   exportState() {
     return {
       totalRules: this.totalRules,

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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { Phase, PipelineEvent } from "./index.js";
 import { Pipeline } from "./base.js";
+import { deriveSkillAuthoringMilestones, deriveSkillTestingMilestones } from "./_milestone-derive.js";
 
 export class SkillTestingPipeline extends Pipeline {
   constructor(workspace) {
@@ -33,35 +34,48 @@ export class SkillTestingPipeline extends Pipeline {
   }
 
   _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);
-        }
-      }
-    }
+    // v0.7.0 A1: route through filesystem-derived helper (skill_authoring's
+    // skillsAuthored is the canonical "what skills exist" view).
+    const m = deriveSkillAuthoringMilestones(this._workspace);
+    this.skillsToTest = [...m.skillsAuthored];
   }
 
   _loadTestResults() {
     this.skillsTested = {};
     this.skillsPassing = [];
+
+    // Layer 1 (canonical schema): output/<rule_id>.json with `accuracy` field.
+    // Carries the actual numeric threshold check.
     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 */ }
+    if (fs.existsSync(outDir)) {
+      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 */ }
+      }
+    }
+
+    // Layer 2 (helper-derived floor): per-skill test_results/, tests/, or
+    // assets/test_cases.json count as "tested" even without an accuracy
+    // reading. Without this floor, agents who tested via sandbox_exec
+    // (no accuracy JSON written) showed skillsTested={} despite real
+    // testing — exactly the E2E #5 GLM case.
+    const m = deriveSkillTestingMilestones(this._workspace);
+    for (const id of m.skillsTested) {
+      // Test artifact present but no numeric accuracy → record as tested
+      // at threshold value (just-passing). The agent can revise via
+      // canonical-schema JSON if needed.
+      if (!(id in this.skillsTested)) this.skillsTested[id] = this._accuracyThreshold;
     }
-    this.skillsPassing = Object.entries(this.skillsTested).filter(([, acc]) => acc >= this._accuracyThreshold).map(([id]) => id);
+
+    this.skillsPassing = Object.entries(this.skillsTested)
+      .filter(([, acc]) => acc >= this._accuracyThreshold)
+      .map(([id]) => id);
   }
 
   _loadEvolutionLog() {
@@ -104,7 +118,37 @@ export class SkillTestingPipeline extends Pipeline {
   exitCriteriaMet() {
     const total = this.skillsToTest.length;
     if (!total) return false;
-    return Object.keys(this.skillsTested).length >= total && this.skillsPassing.length >= total * this._accuracyThreshold;
+    // v0.7.0 H/C2 fix: previous gate `skillsPassing.length >= total * threshold`
+    // was multiplying *count* by accuracy threshold (default 0.9), so 9/10
+    // failing skills could still pass the gate. The intent is "every
+    // skill passes its per-skill threshold" — count parity, not weighted.
+    // (Fraction-of-skills fallbacks belong in optional config, not the
+    // default exit criterion.)
+    return Object.keys(this.skillsTested).length >= total &&
+      this.skillsPassing.length >= total;
+  }
+
+  /**
+   * v0.6.3 (#74): SKILL_TESTING runs check scripts against test samples and
+   * measures accuracy. Writing distillation outputs or production results
+   * here means phase boundaries got skipped.
+   */
+  phaseMisfitHint(toolName, toolInput, result) {
+    if (result?.isError) return null;
+    const exitText = this.exitCriteriaMet()
+      ? "Skill-testing exit criteria are MET — call phase_advance(to=\"distillation\")."
+      : "Skill-testing not yet complete.";
+
+    if (toolName === "workspace_file" && toolInput?.operation === "write") {
+      const p = toolInput.path || "";
+      if (p.startsWith("workflows/")) {
+        return `Writing under workflows/ is DISTILLATION-phase work, but engine is in SKILL_TESTING. ${exitText}`;
+      }
+      if (p.startsWith("output/results/")) {
+        return `Writing under output/results/ is PRODUCTION_QC-phase work, but engine is in SKILL_TESTING. ${exitText}`;
+      }
+    }
+    return null;
   }
 
   exportState() {

package/src/agent/retry.js

@@ -1,9 +1,17 @@
 /**
  * Retry wrapper with exponential backoff and jitter.
  * Designed for LLM API calls — retries transient errors, fails fast on auth/validation errors.
+ *
+ * v0.6.3.1: KC_MAX_RETRIES env override. Default 10 attempts ≈ 5 min of
+ * exponential backoff (1+2+4+8+16+32+60+60+60+60s). E2E #5 surfaced a
+ * Tencent outage that lasted longer than the default; setting
+ * KC_MAX_RETRIES=20 buys ~15 more min before the engine gives up.
  */
-
-const MAX_RETRIES = 10;
+const MAX_RETRIES = (() => {
+  const raw = parseInt(process.env.KC_MAX_RETRIES || "", 10);
+  if (Number.isFinite(raw) && raw >= 0 && raw <= 50) return raw;
+  return 10;
+})();
 const INITIAL_DELAY_MS = 1000;
 const MAX_DELAY_MS = 60000;
 const BACKOFF_MULTIPLIER = 2;

package/src/agent/scheduler.js

@@ -222,14 +222,26 @@ export class Scheduler {
   }
 
   /**
-   * Count of files directly under input/ (excluding subdirs like archived/).
+   * Count of files directly under input/ (excluding subdirs like archived/
+   * and v0.7.0 F3 agent-scratch marker .kc-scratch/).
+   *
+   * Background: E2E #5 DS surfaced "📥 4 new file(s) pending in input/"
+   * when the agent's sandbox_exec had dropped 4 test fixtures into
+   * input/ during smoke-testing. The user assumed external arrivals.
+   * The scheduler never had a way to disambiguate.
+   *
+   * v0.7.0 F3: agent-side scratch writes go under input/.kc-scratch/
+   * (a sidecar dir, hidden by the standard "starts with ." filter).
+   * The banner counts only top-level non-hidden files, which is what
+   * external arrivals actually look like (schedule_fetch drops files
+   * directly into input/ root).
    */
   pendingInputCount() {
     const dir = path.join(this._workspace.cwd, "input");
     if (!fs.existsSync(dir)) return 0;
     try {
       return fs.readdirSync(dir, { withFileTypes: true })
-        .filter((e) => e.isFile())
+        .filter((e) => e.isFile() && !e.name.startsWith("."))
         .length;
     } catch {
       return 0;

package/src/agent/session-state.js

@@ -12,9 +12,14 @@ export class SessionState {
    * @param {string} workspacePath - Session workspace directory
    * @param {object} [opts]
    * @param {string} [opts.statePath] - Override absolute path (used for sub-agent isolation, Bug 2)
+   * @param {Workspace} [opts.workspace] - v0.6.2 J3: optional workspace ref so
+   *   save() can acquire a sync file lock on session-state.json. Without it
+   *   (subagents, tests), save() falls back to lock-free writes — same
+   *   behavior as pre-v0.6.2.
    */
   constructor(workspacePath, opts = {}) {
     this._path = opts.statePath || path.join(workspacePath, "session-state.json");
+    this._workspace = opts.workspace || null;
   }
 
   /**
@@ -46,7 +51,18 @@ export class SessionState {
       pipelineMilestones: this._extractMilestones(engine.pipelines),
     };
 
-    fs.writeFileSync(this._path, JSON.stringify(state, null, 2), "utf-8");
+    // v0.6.2 J3: acquire sync file lock if workspace ref available.
+    // session-state.json is in SHARED_COORDINATION_PATHS — concurrent
+    // writers (parallel ralph-loop workers + main saveState ticks)
+    // could otherwise interleave and corrupt the JSON.
+    const write = () => {
+      fs.writeFileSync(this._path, JSON.stringify(state, null, 2), "utf-8");
+    };
+    if (this._workspace?.withSyncFileLock) {
+      this._workspace.withSyncFileLock("session-state.json", write);
+    } else {
+      write();
+    }
   }
 
   /**
@@ -54,7 +70,24 @@ export class SessionState {
    * @returns {object} The persisted state
    */
   load() {
-    return this._loadRaw() || {};
+    const raw = this._loadRaw() || {};
+    // v0.6.3: phase value renamed "extraction" → "rule_extraction" to
+    // disambiguate from data/entity extraction inside skills. Migrate old
+    // session-state on read so resumed workspaces don't end up in a phase
+    // the engine doesn't recognize. Idempotent — already-renamed values
+    // pass through unchanged.
+    if (raw.currentPhase === "extraction") raw.currentPhase = "rule_extraction";
+    if (raw.pipelineMilestones?.extraction && !raw.pipelineMilestones.rule_extraction) {
+      raw.pipelineMilestones.rule_extraction = raw.pipelineMilestones.extraction;
+      delete raw.pipelineMilestones.extraction;
+    }
+    if (Array.isArray(raw.phaseSummaries)) {
+      for (const s of raw.phaseSummaries) {
+        if (s?.fromPhase === "extraction") s.fromPhase = "rule_extraction";
+        if (s?.toPhase === "extraction") s.toPhase = "rule_extraction";
+      }
+    }
+    return raw;
   }
 
   /**

package/src/agent/skill-loader.js

@@ -17,22 +17,28 @@ const BUNDLED_SKILLS_DIR = path.resolve(__dirname, "../../template/skills");
 // to default to always-visible.
 const PHASE_RELEVANT_SKILLS = {
   "bootstrap-workspace": ["bootstrap"],
-  "rule-extraction":     ["bootstrap", "extraction"],
-  "rule-graph":          ["extraction", "skill_authoring"],
-  "task-decomposition":  ["extraction", "skill_authoring", "distillation"],
+  "rule-extraction":     ["bootstrap", "rule_extraction"],
+  "rule-graph":          ["rule_extraction", "skill_authoring"],
+  "task-decomposition":  ["rule_extraction", "skill_authoring", "distillation"],
+  // v0.7.0 B1: work-decomposition teaches the system-level decomposition
+  // discipline (ordering, grouping, difficulty triage, PATTERNS.md memory).
+  // Distinct from task-decomposition (per-rule sub-tasks). Loaded on
+  // rule_extraction → skill_authoring transition where the agent owns
+  // the TaskBoard.
+  "work-decomposition":  ["rule_extraction", "skill_authoring"],
   "skill-authoring":     ["skill_authoring", "skill_testing"],
   "skill-to-workflow":   ["distillation"],
   "evolution-loop":      ["skill_testing", "distillation", "production_qc"],
-  "version-control":     ["bootstrap", "extraction", "skill_authoring", "skill_testing", "distillation", "production_qc", "finalization"],
+  "version-control":     ["bootstrap", "rule_extraction", "skill_authoring", "skill_testing", "distillation", "production_qc", "finalization"],
   "quality-control":     ["production_qc", "finalization"],
   "confidence-system":   ["distillation", "production_qc"],
   "dashboard-reporting": ["production_qc", "finalization"],
   "cross-document-verification": ["production_qc"],
   "corner-case-management": ["skill_testing", "distillation", "production_qc"],
-  "data-sensibility":    ["extraction", "skill_authoring"],
+  "data-sensibility":    ["rule_extraction", "skill_authoring"],
   "entity-extraction":   ["skill_authoring", "distillation"],
-  "document-parsing":    ["bootstrap", "extraction", "skill_authoring"],
-  "document-chunking":   ["bootstrap", "extraction"],
+  "document-parsing":    ["bootstrap", "rule_extraction", "skill_authoring"],
+  "document-chunking":   ["bootstrap", "rule_extraction"],
   "tree-processing":     ["skill_authoring", "skill_testing"],
   "compliance-judgment": ["skill_authoring", "skill_testing", "production_qc"],
   "skill-creator":       ["skill_authoring"],