kc-beta 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kc-beta",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "KC Agent — LLM document verification agent (pure Node.js CLI)",
   "type": "module",
   "bin": {

package/src/agent/engine.js

@@ -165,7 +165,7 @@ export class AgentEngine {
     this.pipelines = {
       [Phase.BOOTSTRAP]: new ProjectInitializer(this.workspace),
       [Phase.EXTRACTION]: new RuleExtractionPipeline(this.workspace),
-      [Phase.SKILL_AUTHORING]: new SkillAuthoringPipeline(this.workspace),
+      [Phase.SKILL_AUTHORING]: new SkillAuthoringPipeline(this.workspace, this.taskManager),
       [Phase.SKILL_TESTING]: new SkillTestingPipeline(this.workspace),
       [Phase.DISTILLATION]: new DistillationPipeline(this.workspace),
       [Phase.PRODUCTION_QC]: new ProductionQCPipeline(this.workspace),
@@ -311,7 +311,11 @@ export class AgentEngine {
       // Distillation+ only (DISTILL mode)
       distill: [
         workerLlm,
-        new WorkflowRunTool(this.workspace, this.versionManager, this.confidence),
+        new WorkflowRunTool(this.workspace, this.versionManager, this.confidence, {
+          // v0.6.1 A6: hook engine-emitted milestones so phase gates see workflow runs
+          recordMilestone: (phase, key, value) => this._recordMilestone(phase, key, value),
+          getCurrentPhase: () => this.currentPhase,
+        }),
         new TierDowngradeTool(this.workspace, workerLlm),
         new QCSampleTool(this.workspace),
       ],
@@ -1057,12 +1061,23 @@ export class AgentEngine {
       return false;
     }
 
-    const phaseSummary = `[${this.currentPhase.toUpperCase()} → ${nextPhase.toUpperCase()}]: ${reason}${force && nextPhase !== expected ? " (forced)" : ""}`;
+    // v0.6.1 B1: build engine-appended hard-counts block + heuristic mismatch
+    // detection so the LLM-narrated reason can be cross-checked against
+    // ground-truth telemetry. Phase summaries become diagnostic, not just
+    // narrative.
+    const engineCounts = this._buildEngineCountsBlock(this.currentPhase);
+    const mismatchPrefix = this._detectSummaryMismatch(reason, this.currentPhase) ? "⚠️ POSSIBLE MISMATCH: " : "";
+    const phaseSummary =
+      `[${this.currentPhase.toUpperCase()} → ${nextPhase.toUpperCase()}]: ${mismatchPrefix}${reason}` +
+      (force && nextPhase !== expected ? " (forced)" : "") +
+      (engineCounts ? `\n  (engine) ${engineCounts}` : "");
     this._phaseSummaries.push(phaseSummary);
     this.eventLog.append("phase_transition", {
       from: this.currentPhase,
       to: nextPhase,
       reason,
+      engineCounts: engineCounts || null,
+      possibleMismatch: !!mismatchPrefix,
       forced: force && nextPhase !== expected,
     });
     const fromPhase = this.currentPhase;
@@ -1093,6 +1108,172 @@ export class AgentEngine {
     return true;
   }
 
+  /**
+   * v0.6.1 A6: Single chokepoint for engine-emitted milestone updates.
+   * Tools call this on successful execution to bump pipeline counters that
+   * the phase-gate hardening (A2-A5) depends on. Without engine emission,
+   * gates fall back to filesystem scans which can miss work that didn't
+   * follow canonical output paths (E2E #4: `unified_qc.py` wrote to
+   * `output/results/`, production-qc only scanned `output/qc/`).
+   *
+   * The mutation routes through the pipeline's existing internal state, so
+   * exportState/importState round-trips work unchanged and the gate sees a
+   * unified view of (filesystem-scanned + engine-emitted) signals.
+   *
+   * Three modes inferred from value shape:
+   *  - increment counter: pipeline[key] is number, value is number → add
+   *  - set in dict-by-id:  pipeline[key] is object, value is { id, value? } → assign
+   *  - dedupe-add to array: pipeline[key] is array, value is string → push if absent
+   *
+   * @param {string} phase - Pipeline name (e.g., "distillation")
+   * @param {string} key - Field on the pipeline (e.g., "workflowsTested")
+   * @param {*} value - Shape varies by target type (see modes above)
+   * @returns {boolean} true if a write happened
+   */
+  _recordMilestone(phase, key, value) {
+    const pipeline = this.pipelines?.[phase];
+    if (!pipeline) return false;
+    const target = pipeline[key];
+    // increment counter
+    if (typeof target === "number" && typeof value === "number") {
+      pipeline[key] = target + value;
+      return true;
+    }
+    // set on dict-by-id
+    if (target && typeof target === "object" && !Array.isArray(target)
+        && value && typeof value === "object" && "id" in value) {
+      target[value.id] = "value" in value ? value.value : true;
+      return true;
+    }
+    // dedupe-add to array
+    if (Array.isArray(target) && typeof value === "string") {
+      if (!target.includes(value)) target.push(value);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * v0.6.1 B1: build a one-line "engine counts" block summarizing the
+   * pipeline's ground-truth telemetry at the moment of phase advance.
+   * Different phases surface different metrics; we keep this short so the
+   * appended summary line stays readable.
+   *
+   * @param {string} fromPhase - The phase being LEFT (we summarize its work)
+   * @returns {string} block text, or "" if pipeline has nothing to report
+   */
+  _buildEngineCountsBlock(fromPhase) {
+    const pipeline = this.pipelines?.[fromPhase];
+    if (!pipeline) return "";
+    const parts = [];
+    try {
+      switch (fromPhase) {
+        case "extraction": {
+          const total = pipeline._catalogRuleCount?.() ?? pipeline.rulesExtracted?.length ?? 0;
+          parts.push(`rulesExtracted: ${pipeline.rulesExtracted?.length ?? 0}`);
+          parts.push(`rulesWithChunkRefs: ${pipeline.rulesWithChunkRefs?.length ?? 0}/${total}`);
+          parts.push(`rulesWithTests: ${pipeline.rulesWithTests?.length ?? 0}`);
+          parts.push(`coverageAudited: ${pipeline.coverageAudited ? "yes" : "no"}`);
+          break;
+        }
+        case "skill_authoring": {
+          const totalRules = pipeline.totalRules?.length ?? 0;
+          const covered = pipeline.ruleIdsCovered?.size ?? 0;
+          parts.push(`rulesCovered: ${covered}/${totalRules}`);
+          parts.push(`skillDirsAuthored: ${pipeline.skillsAuthored?.length ?? 0}`);
+          if (this.taskManager) {
+            const t = this.taskManager.countByPhase("skill_authoring");
+            const d = this.taskManager.countByPhase("skill_authoring", "completed");
+            const f = this.taskManager.countByPhase("skill_authoring", "failed");
+            parts.push(`tasksCompleted: ${d}/${t}${f > 0 ? ` (+${f} failed)` : ""}`);
+          }
+          break;
+        }
+        case "skill_testing": {
+          const total = pipeline.skillsToTest?.length ?? 0;
+          const tested = Object.keys(pipeline.skillsTested || {}).length;
+          const passing = pipeline.skillsPassing?.length ?? 0;
+          parts.push(`skillsTested: ${tested}/${total}`);
+          parts.push(`skillsPassing: ${passing}`);
+          parts.push(`iterations: ${pipeline.iterationCount ?? 0}`);
+          break;
+        }
+        case "distillation": {
+          const total = pipeline.skillsToDistill?.length ?? 0;
+          const created = Object.keys(pipeline.workflowsCreated || {}).length;
+          const tested = Object.keys(pipeline.workflowsTested || {}).length;
+          const passing = pipeline.workflowsPassing?.length ?? 0;
+          parts.push(`workflowsCreated: ${created}/${total}`);
+          parts.push(`workflowsTested: ${tested}/${total}`);
+          parts.push(`workflowsPassing: ${passing}/${total}`);
+          break;
+        }
+        case "production_qc": {
+          parts.push(`batchesProcessed: ${pipeline.batchesProcessed ?? 0}`);
+          parts.push(`documentsReviewed: ${pipeline.documentsReviewed ?? 0}`);
+          parts.push(`monitoring: ${pipeline.monitoringPhase ?? "?"}`);
+          break;
+        }
+        // bootstrap / finalization: no specific counters, fall through
+      }
+    } catch { /* never let summary build break phase advance */ }
+    return parts.join(", ");
+  }
+
+  /**
+   * v0.6.1 B1: heuristic mismatch detection. Conservative regex over the
+   * LLM's free-form reason for percentages and counts, compared against
+   * engine truth. INFORMATIONAL only — never blocks the transition. False
+   * positives are acceptable (the warning is a hint to the human reviewer,
+   * not a hard signal). False negatives are also acceptable (this catches
+   * the loud, numerical claims; subtle ones still slip through).
+   *
+   * Returns true if the agent's reason mentions a count or percentage that
+   * doesn't match engine state.
+   */
+  _detectSummaryMismatch(reason, fromPhase) {
+    if (!reason || typeof reason !== "string") return false;
+    const pipeline = this.pipelines?.[fromPhase];
+    if (!pipeline) return false;
+    try {
+      // Match "N/M" fractions and standalone counts
+      const fractionMatches = [...reason.matchAll(/(\d+)\s*\/\s*(\d+)/g)];
+      // Match "N rules / skills / workflows / tasks"
+      const countMatches = [...reason.matchAll(/(\d+)\s*(rules?|skills?|workflows?|tasks?|条规则|个技能)/gi)];
+      // Match accuracy claims like "95%", "0.95"
+      const pctMatches = [...reason.matchAll(/(\d+(?:\.\d+)?)\s*%/g)];
+
+      // Phase-specific cross-checks (cheap conservative comparisons)
+      if (fromPhase === "skill_authoring" && this.taskManager) {
+        const completed = this.taskManager.countByPhase("skill_authoring", "completed");
+        const total = this.taskManager.countByPhase("skill_authoring");
+        for (const m of fractionMatches) {
+          const claimedDone = parseInt(m[1], 10);
+          const claimedTotal = parseInt(m[2], 10);
+          if (claimedTotal === total && claimedDone > completed + 5) return true;
+        }
+      }
+      if (fromPhase === "skill_testing") {
+        const tested = Object.keys(pipeline.skillsTested || {}).length;
+        const passing = pipeline.skillsPassing?.length ?? 0;
+        for (const m of pctMatches) {
+          const claimed = parseFloat(m[1]);
+          // If claimed > 50% but engine sees 0 tested, that's suspicious
+          if (claimed >= 50 && tested === 0 && passing === 0) return true;
+        }
+      }
+      if (fromPhase === "production_qc") {
+        const batches = pipeline.batchesProcessed ?? 0;
+        // Any "complete" or large-count claim while batches==0 is suspicious
+        if (batches === 0) {
+          if (countMatches.some((m) => parseInt(m[1], 10) > 10)) return true;
+          if (pctMatches.some((m) => parseFloat(m[1]) > 50)) return true;
+        }
+      }
+    } catch { /* informational only — never block */ }
+    return false;
+  }
+
   /**
    * Bug 4 trigger (1) auto-detect, edge-triggered (Bug 5): only fires on a
    * fresh false → true flip in `exitCriteriaMet()`. Sessions resumed in an

package/src/agent/pipelines/distillation.js

@@ -40,6 +40,13 @@ export class DistillationEngine extends Pipeline {
   }
 
   _scanWorkflows() {
+    // v0.6.1 A6: preserve engine-emitted entries across filesystem rescans.
+    // workflow_run hook bumps workflowsTested[ruleId] and adds to
+    // workflowsPassing on success — without this preservation, those entries
+    // get clobbered on the next describeState() / onToolResult() rescan.
+    const engineWfTested = { ...this.workflowsTested };
+    const engineWfPassing = [...this.workflowsPassing];
+
     this.workflowsCreated = {};
     this.workflowsTested = {};
     this.workflowsPassing = [];
@@ -68,6 +75,14 @@ export class DistillationEngine extends Pipeline {
         this.workflowsCreated[path.parse(e.name).name] = 1;
       }
     }
+
+    // Re-merge engine-emitted entries on top of filesystem-derived state
+    for (const [k, v] of Object.entries(engineWfTested)) {
+      if (!(k in this.workflowsTested)) this.workflowsTested[k] = v;
+    }
+    for (const id of engineWfPassing) {
+      if (!this.workflowsPassing.includes(id)) this.workflowsPassing.push(id);
+    }
   }
 
   describeState() {

package/src/agent/pipelines/extraction.js

@@ -11,6 +11,11 @@ export class RuleExtractionPipeline extends Pipeline {
     this.rulesExtracted = [];
     this.rulesWithTests = [];
     this.coverageAudited = false;
+    // v0.6.1 A1: track which rules in catalog.json have non-empty
+    // source_chunk_ids — D1 grounded skill_authoring prompts on these but
+    // exit didn't require them, so a sloppy extraction could leave rules
+    // unmoored.
+    this.rulesWithChunkRefs = [];
     this._scanWorkspace();
   }
 
@@ -28,11 +33,21 @@ export class RuleExtractionPipeline extends Pipeline {
 
   _scanRules() {
     this.rulesExtracted = [];
+    this.rulesWithChunkRefs = [];
     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}`);
+        if (Array.isArray(data)) {
+          this.rulesExtracted = data.map((r, i) => r.id || `rule_${i}`);
+          // A1: collect ids whose entry has non-empty source_chunk_ids
+          for (const r of data) {
+            const ids = r?.source_chunk_ids;
+            if (Array.isArray(ids) && ids.length > 0 && r?.id) {
+              this.rulesWithChunkRefs.push(r.id);
+            }
+          }
+        }
       } catch { /* skip */ }
     }
     const skillsDir = path.join(this._workspace.cwd, "rule_skills");
@@ -67,10 +82,43 @@ export class RuleExtractionPipeline extends Pipeline {
       parts.push("### Exit\nExtraction complete. Proceed to SKILL_AUTHORING.");
     }
 
-    parts.push(`### Exit criteria\n- [${this.regulationsScanned ? "x" : " "}] All regulations read\n- [${this.rulesExtracted.length > 0 ? "x" : " "}] Rules decomposed into atomic units\n- [${this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) ? "x" : " "}] >=80% of rules have test stubs\n- [${this.coverageAudited ? "x" : " "}] Coverage audit completed`);
+    const chunkRefsOk = this._chunkRefsCriterionMet();
+    parts.push(
+      `### Exit criteria\n` +
+      `- [${this.regulationsScanned ? "x" : " "}] All regulations read\n` +
+      `- [${this.rulesExtracted.length > 0 ? "x" : " "}] Rules decomposed into atomic units\n` +
+      `- [${this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) ? "x" : " "}] >=80% of rules have test stubs\n` +
+      `- [${this.coverageAudited ? "x" : " "}] Coverage audit completed\n` +
+      `- [${chunkRefsOk ? "x" : " "}] Every rule has source_chunk_ids in catalog.json (${this.rulesWithChunkRefs.length}/${this._catalogRuleCount()})`,
+    );
     return parts.join("\n\n");
   }
 
+  /**
+   * v0.6.1 A1: number of rules currently in catalog.json (not the union with
+   * rule_skills/ dirs that rulesExtracted carries). Used by the chunk-refs
+   * gate so we compare apples to apples.
+   */
+  _catalogRuleCount() {
+    const catalogPath = path.join(this._workspace.cwd, "rules", "catalog.json");
+    if (!fs.existsSync(catalogPath)) return 0;
+    try {
+      const data = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+      return Array.isArray(data) ? data.length : 0;
+    } catch { return 0; }
+  }
+
+  /**
+   * v0.6.1 A1: pass when every rule in catalog.json has a non-empty
+   * source_chunk_ids array. Empty catalog (legacy / pre-D1 sessions) passes
+   * trivially so resume of v0.6.0 sessions doesn't get trapped.
+   */
+  _chunkRefsCriterionMet() {
+    const total = this._catalogRuleCount();
+    if (total === 0) return true; // backwards-compat for sessions pre-D1
+    return this.rulesWithChunkRefs.length >= total;
+  }
+
   onToolResult(toolName, toolInput, result) {
     if (result.isError) return null;
     const wasReady = this.exitCriteriaMet();
@@ -85,7 +133,12 @@ export class RuleExtractionPipeline extends Pipeline {
 
   exitCriteriaMet() {
     return this.regulationsScanned && this.rulesExtracted.length > 0 &&
-      this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) && this.coverageAudited;
+      this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) &&
+      this.coverageAudited &&
+      // v0.6.1 A1: hard tracking — D1 source-context auto-attach requires
+      // catalog.json entries to carry source_chunk_ids. Without them the
+      // skill_authoring prompts are blind.
+      this._chunkRefsCriterionMet();
   }
 
   exportState() {
@@ -93,6 +146,7 @@ export class RuleExtractionPipeline extends Pipeline {
       regulationsScanned: this.regulationsScanned,
       rulesExtracted: this.rulesExtracted,
       rulesWithTests: this.rulesWithTests,
+      rulesWithChunkRefs: this.rulesWithChunkRefs,
       coverageAudited: this.coverageAudited,
     };
   }
@@ -107,5 +161,8 @@ export class RuleExtractionPipeline extends Pipeline {
     if (Array.isArray(data.rulesWithTests) && data.rulesWithTests.length > this.rulesWithTests.length) {
       this.rulesWithTests = data.rulesWithTests;
     }
+    if (Array.isArray(data.rulesWithChunkRefs) && data.rulesWithChunkRefs.length > this.rulesWithChunkRefs.length) {
+      this.rulesWithChunkRefs = data.rulesWithChunkRefs;
+    }
   }
 }

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

@@ -36,6 +36,11 @@ 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.
+    const engineDocsReviewed = this.documentsReviewed;
     this.batchesProcessed = 0;
     this.totalDocuments = 0;
     this.documentsReviewed = 0;
@@ -43,23 +48,57 @@ export class ProductionQCPipeline extends Pipeline {
     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)) return;
+    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;
+          }
+          if (Array.isArray(data.issues)) this.issuesFound.push(...data.issues);
+        } catch { /* skip */ }
+      }
+    }
 
-    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"));
+    // 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++;
-        this.totalDocuments += typeof data.documents === "number" ? data.documents : (data.total || 0);
-        this.documentsReviewed += data.reviewed || 0;
-        if (data.accuracy_by_rule) Object.assign(this.accuracyByRule, data.accuracy_by_rule);
-        if (data.confidence) {
-          for (const band of ["low", "medium", "high"]) this.confidenceDistribution[band] += data.confidence[band] || 0;
-        }
-        if (Array.isArray(data.issues)) this.issuesFound.push(...data.issues);
-      } catch { /* skip */ }
+        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
+    if (engineDocsReviewed > this.documentsReviewed) this.documentsReviewed = engineDocsReviewed;
+
     // Determine monitoring phase
     if (this.batchesProcessed < 3) this.monitoringPhase = "initial";
     else if (this.issuesFound.length > 0) this.monitoringPhase = "active";
@@ -93,7 +132,18 @@ export class ProductionQCPipeline extends Pipeline {
     return null;
   }
 
-  exitCriteriaMet() { return this.monitoringPhase === "stable"; }
+  /**
+   * v0.6.1 A5: gate requires at least one batch processed (real telemetry)
+   * AND the legacy stable-monitoring criterion. Without the batch floor, the
+   * agent could declare PRODUCTION_QC done from a clean session-state file
+   * (E2E #4: phase advanced into PRODUCTION_QC, agent ran 6,930 checks via
+   * sandbox_exec to non-canonical paths, batchesProcessed stayed 0, exit
+   * fired anyway because monitoringPhase defaults can flip to "stable" with
+   * empty accuracyByRule + zero issues).
+   */
+  exitCriteriaMet() {
+    return this.batchesProcessed > 0 && this.monitoringPhase === "stable";
+  }
 
   exportState() {
     return {

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

@@ -4,9 +4,18 @@ import { Phase, PipelineEvent } from "./index.js";
 import { Pipeline } from "./base.js";
 
 export class SkillAuthoringPipeline extends Pipeline {
-  constructor(workspace) {
+  /**
+   * @param {Workspace} workspace
+   * @param {TaskManager|null} [taskManager] - v0.6.1 A2: pass the engine's
+   *   TaskManager so exitCriteriaMet can require task-completion parity in
+   *   addition to D2 filename coverage. Subagents pass null (no taskManager
+   *   in subagent scope), in which case the gate falls back to D2-only
+   *   behaviour.
+   */
+  constructor(workspace, taskManager = null) {
     super();
     this._workspace = workspace;
+    this._taskManager = taskManager;
     this.totalRules = [];
     this.skillsAuthored = [];
     this.skillsWithScripts = [];
@@ -132,12 +141,24 @@ export class SkillAuthoringPipeline extends Pipeline {
       "`rule_catalog` tool for any catalog edits — sandbox_exec bypasses the " +
       "workspace file lock and races with parallel workers."
     ];
+    // v0.6.1 A2: surface task-completion parity so the agent sees the gate
+    let taskLine = "";
+    if (this._taskManager) {
+      const totalT = this._taskManager.countByPhase("skill_authoring");
+      const doneT = this._taskManager.countByPhase("skill_authoring", "completed");
+      const failedT = this._taskManager.countByPhase("skill_authoring", "failed");
+      if (totalT > 0) {
+        taskLine = `\n- Per-rule tasks completed: ${doneT}/${totalT}` +
+          (failedT > 0 ? ` (+${failedT} failed)` : "");
+      }
+    }
     parts.push(
       `### Progress (rule-id coverage, D2)\n` +
       `- Total rules in catalog: ${total}\n` +
       `- Rule ids covered by some skill: ${covered}\n` +
       `- Skill directories authored: ${this.skillsAuthored.length}\n` +
       `- Skills with scripts/: ${this.skillsWithScripts.length}` +
+      taskLine +
       (uncovered.length > 0
         ? `\n- Missing coverage (${uncovered.length}): ${uncovered.slice(0, 15).join(", ")}${uncovered.length > 15 ? "…" : ""}`
         : ""),
@@ -169,6 +190,20 @@ export class SkillAuthoringPipeline extends Pipeline {
     // preserved as a secondary gate on skill depth.
     const allCovered = this.totalRules.every((r) => this.ruleIdsCovered.has(r));
     if (!allCovered) return false;
+    // v0.6.1 A2: tasks-parity gate. The 17-minute skill_authoring transition
+    // in E2E #4 happened because D2 fired on 20 skeleton SK01-SK20 dirs
+    // covering all 110 rule_ids by filename, while only ~5 of 110 per-rule
+    // skill_authoring tasks had actually been worked on. Now require every
+    // per-rule task in TaskManager to be in a terminal state (completed or
+    // failed). Subagents (no taskManager) skip this gate.
+    if (this._taskManager) {
+      const total = this._taskManager.countByPhase("skill_authoring");
+      if (total > 0) {
+        const completed = this._taskManager.countByPhase("skill_authoring", "completed");
+        const failed = this._taskManager.countByPhase("skill_authoring", "failed");
+        if (completed + failed < total) return false;
+      }
+    }
     return this.skillsWithScripts.length >= Math.max(1, this.skillsAuthored.length * 0.5);
   }
 

package/src/agent/task-manager.js

@@ -182,6 +182,21 @@ export class TaskManager {
     return { total, completed, inProgress, pending, failed };
   }
 
+  /**
+   * v0.6.1 A2: Phase-scoped task count. Used by SkillAuthoringPipeline's
+   * exitCriteriaMet to gate phase advance on TaskManager parity, not just
+   * filename-regex coverage. Pass a status to filter; omit for total.
+   *
+   * @param {string} phase - Phase name (e.g., "skill_authoring")
+   * @param {string|null} [status] - Optional status filter ("completed", "pending", etc.)
+   * @returns {number}
+   */
+  countByPhase(phase, status = null) {
+    return this._tasks.filter(
+      (t) => t.phase === phase && (status == null || t.status === status),
+    ).length;
+  }
+
   /**
    * Format task list for injection into system prompt context.
    * Compact checklist — not conversation history.

package/src/agent/tools/workflow-run.js

@@ -9,12 +9,33 @@ import { BaseTool, ToolResult } from "./base.js";
  * result and trace ID automatically. Saves structured result to output/results/.
  */
 export class WorkflowRunTool extends BaseTool {
-  constructor(workspace, versionManager, confidenceScorer, { timeout = 120 } = {}) {
+  /**
+   * @param {Workspace} workspace
+   * @param {VersionManager} versionManager
+   * @param {ConfidenceScorer} confidenceScorer
+   * @param {object} [opts]
+   * @param {number} [opts.timeout=120]
+   * @param {(phase: string, key: string, value: any) => boolean} [opts.recordMilestone]
+   *   v0.6.1 A6: callback for engine-emitted milestone updates. Called on
+   *   successful workflow execution so the distillation/production_qc gates
+   *   see real telemetry, not just filesystem scans of canonical paths.
+   * @param {() => string} [opts.getCurrentPhase]
+   *   v0.6.1 A6: returns the engine's current phase. Used to gate
+   *   production_qc-specific milestone bumps (documentsReviewed) so
+   *   distillation-phase calls don't accidentally credit QC.
+   */
+  constructor(workspace, versionManager, confidenceScorer, {
+    timeout = 120,
+    recordMilestone = null,
+    getCurrentPhase = null,
+  } = {}) {
     super();
     this._workspace = workspace;
     this._versionMgr = versionManager;
     this._confidence = confidenceScorer;
     this._timeout = timeout;
+    this._recordMilestone = recordMilestone;
+    this._getCurrentPhase = getCurrentPhase;
   }
 
   get name() { return "workflow_run"; }
@@ -97,6 +118,18 @@ export class WorkflowRunTool extends BaseTool {
     const resultFile = path.join(resultsDir, `${ruleId}_${path.parse(docResolved).name}.json`);
     fs.writeFileSync(resultFile, JSON.stringify(resultData, null, 2), "utf-8");
 
+    // v0.6.1 A6: emit milestone signals so phase gates see this run.
+    // Wrapped in try/catch so milestone emission can never break a workflow.
+    try {
+      this._recordMilestone?.("distillation", "workflowsTested",
+        { id: ruleId, value: { confidence, traceId: resultData.trace_id } });
+      this._recordMilestone?.("distillation", "workflowsPassing", ruleId);
+      const phase = this._getCurrentPhase?.();
+      if (phase === "production_qc") {
+        this._recordMilestone?.("production_qc", "documentsReviewed", 1);
+      }
+    } catch { /* never let milestone emission break workflow execution */ }
+
     return new ToolResult(JSON.stringify(resultData, null, 2));
   }