kc-beta 0.6.2 → 0.7.0

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

@@ -3,6 +3,7 @@ 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 {
   /**
@@ -49,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();
@@ -136,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."
@@ -194,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 });
     }
@@ -242,6 +235,30 @@ export class SkillAuthoringPipeline extends Pipeline {
    * 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");

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

@@ -70,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"],

package/src/agent/skill-validator.js

@@ -16,12 +16,15 @@
  *    still bypasses. The validator's job is to refuse the auto-advance,
  *    not to trap the agent.
  *
- * Validation rules per `check_r###.py`:
+ * Validation rules per `check_*.py`:
  *  1. File ≥ 100 bytes (smoke test for empty stubs).
  *  2. Passes `python3 -c "import ast; ast.parse(open(F).read())"` (no
  *     syntax errors).
- *  3. Defines a function reachable by name `check_rule` or `verify`
- *     (regex match on file content).
+ *  3. Defines a function reachable by one of the names: `check_rule`,
+ *     `verify`, OR `check_r<digits>` (e.g. `check_r014`, `check_r013_r017`).
+ *     v0.7.0 A6 broadened the third pattern after E2E #5 audit found
+ *     three sessions independently chose `def check_r###` over the
+ *     canonical names — the validator was too strict.
  *
  * Disable mechanism: if `python3` is not on PATH, validator silently
  * passes everything and emits a one-time warning — we don't want the
@@ -32,7 +35,18 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
-const ENTRY_POINT_REGEX = /^\s*(?:async\s+)?def\s+(check_rule|verify)\b/m;
+// v0.7.0 A6: entry-point check is a sanity probe, not a style enforcer.
+// The validator's real signal comes from `≥ 100 bytes` + `ast.parse
+// passes`. Restricting to specific verb names rejected 27/28 GLM
+// scripts in E2E #5 — the cost outweighed the catch (every contestant
+// converged on a different naming convention).
+//
+// New rule: any top-level `def \w+(...)` counts. Rejects pure-imports
+// or comment-only stubs (which is what we actually wanted to catch),
+// accepts anything with real logic. The check_*.py *filename* (matched
+// by the path regex in `findCheckScripts`) carries the rule-id signal;
+// the function name doesn't need to.
+const ENTRY_POINT_REGEX = /^(?:async\s+)?def\s+\w+\s*\(/m;
 const MIN_BYTES = 100;
 
 export class SkillValidator {
@@ -141,7 +155,7 @@ export class SkillValidator {
     try { content = fs.readFileSync(filePath, "utf-8"); }
     catch { return { ok: false, error: "read failed after parse OK" }; }
     if (!ENTRY_POINT_REGEX.test(content)) {
-      return { ok: false, error: "no entry point: expected `def check_rule(...)` or `def verify(...)`" };
+      return { ok: false, error: "no callable defined: file has imports/comments only, no top-level `def`" };
     }
 
     return { ok: true };

package/src/agent/task-manager.js

@@ -139,12 +139,23 @@ export class TaskManager {
   // --- Bulk creation from rule catalog ---
 
   /**
-   * Phases where one-task-per-rule is the natural unit of work.
-   * For BOOTSTRAP / EXTRACTION the unit is a regulation (one PDF → many rules);
-   * ralph-loop shouldn't drive per-rule there because the rules don't exist yet
-   * (or are the *output*, not the input) — see E2E #3 coverage check.
+   * Phases where the engine auto-creates one-task-per-rule on phase entry.
+   *
+   * v0.7.0 B2: empty by default. Agent owns TaskBoard decisions per the
+   * work-decomposition meta-meta skill — engine no longer assumes per-rule
+   * granularity is right. The agent reads the rule list from describeState
+   * and calls TaskCreate with whatever shape (single, grouped, range,
+   * non-rule) makes sense for the corpus.
+   *
+   * Override `KC_AGENT_OWNS_TASKBOARD=0` to restore v0.6.x behavior
+   * (engine auto-populates per-rule for skill_authoring + skill_testing).
+   * The override is a staged-rollout safety valve, not a long-lived
+   * config — slated for removal in v0.8.0 after E2E #6 validates the
+   * agent-owned default.
    */
-  static PER_RULE_PHASES = new Set(["skill_authoring", "skill_testing"]);
+  static PER_RULE_PHASES = (process.env.KC_AGENT_OWNS_TASKBOARD === "0")
+    ? new Set(["skill_authoring", "skill_testing"])
+    : new Set();
 
   /**
    * Create one task per rule for a given phase — but only if the phase's unit
@@ -197,6 +208,51 @@ export class TaskManager {
     ).length;
   }
 
+  /**
+   * v0.7.0 A5: Reconcile per-rule tasks against disk artifacts.
+   *
+   * Background: E2E #5 DS audit found tasks.json showing 70/70 completed
+   * while only ~56 dirs / 36 with check_*.py existed on disk. The agent
+   * called markDone() optimistically but the artifacts didn't materialize
+   * (or were deleted later). The engine's phase gate trusted the count.
+   *
+   * Reconcile walks every "completed" task in PER_RULE_PHASES and checks
+   * whether the expected disk artifacts exist via a caller-supplied
+   * `expectsFn(task) -> boolean` predicate. Tasks whose artifacts are
+   * missing are flipped back to `pending` with a `reconcile_failed`
+   * note so the agent can re-do the work, and the gate can refuse
+   * advance if the per-rule artifact set is incomplete.
+   *
+   * Called from engine `_advancePhase` before `exitCriteriaMet()`.
+   *
+   * @param {(task: object) => boolean} expectsFn
+   * @returns {{ reconciled: number, flippedBack: string[] }}
+   *   Number of tasks inspected, plus the IDs of tasks flipped back to
+   *   pending. Caller logs to events.jsonl.
+   */
+  reconcileAgainstDisk(expectsFn) {
+    let reconciled = 0;
+    const flippedBack = [];
+    if (typeof expectsFn !== "function") return { reconciled, flippedBack };
+    for (const task of this._tasks) {
+      if (task.status !== "completed") continue;
+      if (!TaskManager.PER_RULE_PHASES.has(task.phase)) continue;
+      reconciled++;
+      let ok = false;
+      try { ok = !!expectsFn(task); }
+      catch { ok = false; }
+      if (!ok) {
+        task.status = "pending";
+        task.reconcile_failed = true;
+        task.summary = (task.summary ? task.summary + " | " : "") +
+          "v0.7.0 A5: artifacts missing on disk → flipped back to pending";
+        flippedBack.push(task.id);
+      }
+    }
+    if (flippedBack.length > 0) this.save();
+    return { reconciled, flippedBack };
+  }
+
   /**
    * Format task list for injection into system prompt context.
    * Compact checklist — not conversation history.

package/src/agent/tools/document-chunk.js

@@ -194,20 +194,32 @@ export class DocumentChunkTool extends BaseTool {
       };
     }
 
-    // For other formats (.docx, .xlsx, etc): read as UTF-8 best-effort.
-    // Upstream agent should call document_parse first and then document_chunk
-    // on the parsed output directly — current MVP keeps the tool surface small.
+    // v0.7.0 G (#91): route .docx / .doc / others through native parser
+    // dispatcher (mammoth / word-extractor / LibreOffice fallback).
+    // Replaces the prior "read as UTF-8" stub which produced binary
+    // garbage on .docx and forced agents to call document_parse + chunk
+    // separately. extractText() returns clean text or a structured
+    // failure that downstream can surface to the agent.
     try {
-      const txt = fs.readFileSync(absPath, "utf-8");
+      const { extractText } = await import("../document-parser.js");
+      const result = await extractText(absPath);
+      if (result.ok && result.text) {
+        return {
+          source_file: baseName,
+          total_pages: 1,
+          blocks: [{ page: 1, markdown: result.text }],
+          parse_via: result.via,
+        };
+      }
       return {
-        source_file: baseName,
-        total_pages: 1,
-        blocks: [{ page: 1, markdown: txt }],
+        source_file: baseName, total_pages: 0, blocks: [],
+        parse_error: result.error ||
+          `Unsupported format '${suffix}'. Install mammoth / word-extractor or rely on LibreOffice fallback.`,
       };
-    } catch {
+    } catch (e) {
       return {
         source_file: baseName, total_pages: 0, blocks: [],
-        parse_error: `Unsupported format '${suffix}'. Run document_parse first and use its output, or stick to .pdf / .md / .txt.`,
+        parse_error: `parse exception: ${e?.message || String(e)}`,
       };
     }
   }