kc-beta 0.6.2 → 0.7.1

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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { PipelineEvent } from "./index.js";
 import { Pipeline } from "./base.js";
+import { deriveProductionQcMilestones } from "./_milestone-derive.js";
 
 const FREQUENCY_MAP = { high: 1.0, mid: 0.5, low: 0.2 };
 
@@ -36,27 +37,31 @@ export class ProductionQCPipeline extends Pipeline {
   }
 
   _scanQcResults() {
-    // v0.6.1 A5/A6: don't reset documentsReviewed if engine emission has
-    // bumped it since last scan — workflow_run hooks call _recordMilestone
-    // and the increment lives in this same field. Other counters (batches,
-    // accuracy, issues) come solely from filesystem scan and reset cleanly.
+    // v0.7.0 A1: route through filesystem-derived helper. The helper
+    // recognizes both DS-style results (object with `results` keyed by
+    // rule_id, doc-paths in nested keys) AND GLM-style array-of-verdicts
+    // (one entry per doc with .verdict/.file/.path) — neither matched
+    // the v0.6.1 A5 heuristic alone, so E2E #5 saw batchesProcessed=0
+    // even with 1,951 verdicts on disk.
     const engineDocsReviewed = this.documentsReviewed;
-    this.batchesProcessed = 0;
+    const m = deriveProductionQcMilestones(this._workspace);
+    this.batchesProcessed = m.batchesProcessed;
+    this.documentsReviewed = m.documentsReviewed;
+
+    // Layered: still extract accuracyByRule / confidence / issues from
+    // canonical output/qc/*.json batches when present. The helper
+    // doesn't try to reconstruct accuracy semantics (too schema-specific),
+    // but if the agent followed canonical schema, we surface it.
     this.totalDocuments = 0;
-    this.documentsReviewed = 0;
     this.accuracyByRule = {};
     this.confidenceDistribution = { low: 0, medium: 0, high: 0 };
     this.issuesFound = [];
-
-    // Existing canonical path: output/qc/*.json (formal QC batch reports)
     const qcDir = path.join(this._workspace.cwd, "output", "qc");
     if (fs.existsSync(qcDir)) {
       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;
@@ -66,44 +71,26 @@ export class ProductionQCPipeline extends Pipeline {
       }
     }
 
-    // v0.6.1 A5: also pick up batch-style results in output/results/. E2E #4
-    // showed agents writing batch QC outputs to output/results/qc_*.json
-    // (e.g. unified_qc.py) instead of output/qc/, so the formal scanner
-    // missed them. Heuristic match: filename starts with "qc_" or contains
-    // "_batch_". Each match counts as one batch; total_checks → totalDocuments.
-    const resultsDir = path.join(this._workspace.cwd, "output", "results");
-    if (fs.existsSync(resultsDir)) {
-      const seen = new Set();
-      for (const f of fs.readdirSync(resultsDir).filter((f) => f.endsWith(".json"))) {
-        const lower = f.toLowerCase();
-        if (!(lower.startsWith("qc_") || lower.includes("_batch_"))) continue;
-        // Dedupe near-duplicate filenames that differ only by timestamp
-        // suffix (qc_full_batch_20260424_141642.json vs _141921.json
-        // — both are real batches, keep both. But qc_pt_x.json and
-        // qc_pt_x_<ts>.json are usually the same batch saved twice; key
-        // on the prefix before any 8-digit date.)
-        const key = f.replace(/_\d{8}_\d{6}/g, "").replace(/\.json$/, "");
-        if (seen.has(key)) continue;
-        seen.add(key);
-        this.batchesProcessed++;
-        try {
-          const data = JSON.parse(fs.readFileSync(path.join(resultsDir, f), "utf-8"));
-          // Best-effort metric extraction; tolerate missing keys
-          this.totalDocuments += typeof data.sample_count === "number" ? data.sample_count
-            : typeof data.documents === "number" ? data.documents
-            : typeof data.total === "number" ? data.total : 0;
-        } catch { /* skip */ }
-      }
-    }
-
-    // Restore engine-emitted documentsReviewed if filesystem reported less
+    // Restore engine-emitted documentsReviewed if disk-derived is lower
+    // (engine increment may know about reviews not yet flushed to disk)
     if (engineDocsReviewed > this.documentsReviewed) this.documentsReviewed = engineDocsReviewed;
 
-    // Determine monitoring phase
+    // Determine monitoring phase. v0.7.0 H5 fix: empty accuracyByRule
+    // no longer flips to "stable" via vacuous truth — require at least
+    // one rule with an accuracy reading before claiming stability.
     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";
+    else {
+      const accuracies = Object.values(this.accuracyByRule);
+      if (accuracies.length > 0 && accuracies.every((a) => a >= this._accuracyThreshold)) {
+        this.monitoringPhase = "stable";
+      } else {
+        // Helper-derived batches with no accuracy data: agent ran QC but
+        // didn't surface accuracy schema. Treat as `active` (work
+        // happened, but engine can't auto-bless stability).
+        this.monitoringPhase = "active";
+      }
+    }
   }
 
   describeState() {

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) {
@@ -13,6 +14,11 @@ export class SkillTestingPipeline extends Pipeline {
     this.iterationCount = 0;
     this._accuracyThreshold = 0.9;
     this._maxIterations = 20;
+    // v0.7.1 1b: rate-limit phaseMisfitHint firing for ephemeral
+    // sandbox tests. Caps at ~3 nudges per phase entry so the agent
+    // sees the path expectation but doesn't get spammed during a
+    // batch run.
+    this._misfit_nudge_count = 0;
     this._scanWorkspace();
   }
 
@@ -33,35 +39,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 */ }
+      }
     }
-    this.skillsPassing = Object.entries(this.skillsTested).filter(([, acc]) => acc >= this._accuracyThreshold).map(([id]) => id);
+
+    // 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);
   }
 
   _loadEvolutionLog() {
@@ -104,7 +123,71 @@ 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.
+   *
+   * v0.7.1 1b: also nudges agents who run check scripts via sandbox_exec
+   * but don't persist verdicts. E2E #6 v070 surfaced this — both
+   * conductors batched tests in one sandbox_exec call, read pass/fail
+   * from stdout, then declared "testing done" while engine saw
+   * skillsTested=0 because nothing landed in a recognized path.
+   */
+  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}`;
+      }
+    }
+
+    // v0.7.1 1b: sandbox_exec test-command nudge
+    if (toolName === "sandbox_exec") {
+      const cmd = String(toolInput?.command || "");
+      const looksLikeTest =
+        /python.*check.*\.py.*\.(txt|pdf|md|docx)/i.test(cmd) ||
+        /pytest|unittest|run_tests/i.test(cmd) ||
+        /python.*workflow.*\.py.*samples/i.test(cmd);
+      if (!looksLikeTest) return null;
+
+      const tested = Object.keys(this.skillsTested).length;
+      const total = this.skillsToTest.length;
+      // Already satisfied? Don't nudge.
+      if (total === 0 || tested >= total) return null;
+
+      // Rate-limit: ~3 per phase. Counter resets on phase entry
+      // (constructor) and on importState if available.
+      this._misfit_nudge_count = (this._misfit_nudge_count || 0) + 1;
+      if (this._misfit_nudge_count > 3) return null;
+
+      return (
+        `Engine derives skillsTested from rule_skills/<id>/test_results.json, ` +
+        `rule_skills/<id>/tests/, OR output/*.json with rule_id field. ` +
+        `Sandbox runs are ephemeral — record per-rule verdicts to one of ` +
+        `those paths before phase_advance. Currently engine sees ` +
+        `${tested}/${total} skills tested.`
+      );
+    }
+    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"],