kc-beta 0.6.0 → 0.6.2

package/package.json

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

package/src/agent/engine.js

@@ -69,6 +69,19 @@ export const NEXT_PHASE = {
   [Phase.PRODUCTION_QC]: Phase.FINALIZATION, // E1: new 7th phase
 };
 
+// v0.6.2 J2: explicit linear order so `_advancePhase` can detect rollback
+// direction (target index < current index → rollback). Mirrors NEXT_PHASE
+// but ordered, plus FINALIZATION at the end as the terminal phase.
+export const PHASE_ORDER = [
+  Phase.BOOTSTRAP,
+  Phase.EXTRACTION,
+  Phase.SKILL_AUTHORING,
+  Phase.SKILL_TESTING,
+  Phase.DISTILLATION,
+  Phase.PRODUCTION_QC,
+  Phase.FINALIZATION,
+];
+
 /**
  * The KC Agent conversation engine.
  *
@@ -150,7 +163,7 @@ export class AgentEngine {
     });
 
     // Session state persistence
-    this.sessionState = new SessionState(this.workspace.cwd, { statePath });
+    this.sessionState = new SessionState(this.workspace.cwd, { statePath, workspace: this.workspace });
 
     // Task manager (ralph-loop) — sub-agents don't queue further sub-tasks,
     // so they don't get a TaskManager.
@@ -165,7 +178,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),
@@ -223,6 +236,11 @@ export class AgentEngine {
           historyLen: this.history?.messages?.length ?? 0,
           tasksPending: this.taskManager?.progress?.pending ?? 0,
           tasksInProgress: this.taskManager?.progress?.inProgress ?? 0,
+          // v0.6.2 K1: per-component breakdown so heap-analyze.js can
+          // attribute growth (history vs subagents vs event log vs cache).
+          // All values in MB. Failures inside _sampleComponents are caught
+          // and the row gets `componentsErr` instead.
+          components: this._sampleComponents(),
         };
         fs.mkdirSync(logDir, { recursive: true });
         fs.appendFileSync(logPath, JSON.stringify(row) + "\n", "utf-8");
@@ -240,6 +258,89 @@ export class AgentEngine {
     };
   }
 
+  /**
+   * v0.6.2 K1: per-component heap accounting. Each value is in MB,
+   * rounded. The whole function is wrapped in a single try/catch by the
+   * caller; failures are silently dropped to keep the sampler diagnostic
+   * (never load-bearing).
+   *
+   * Components measured (by source):
+   *  - history: in-memory `this.history.messages` content sizes (sum of
+   *    JSON-stringified content)
+   *  - eventLog: disk size of `logs/events.jsonl`
+   *  - toolResults: disk size of `logs/tool_results/` (offloaded tool
+   *    output, summed top-level files only — the dir is one level deep)
+   *  - subagents: disk size of `sub_agents/` (one level — each subagent
+   *    has its own directory tree but we just want the order of magnitude)
+   *  - bundleCache: disk size of `cache/bundles/`
+   */
+  _sampleComponents() {
+    const out = { historyMB: 0, eventLogMB: 0, toolResultsMB: 0, subagentsMB: 0, bundleCacheMB: 0 };
+    const cwd = this.workspace?.cwd;
+    if (!cwd) return out;
+    // history: walk messages, sum content string lengths (UTF-16 → bytes
+    // approx 2× length; we conservatively count length itself since most
+    // content is ASCII-heavy JSON tool output)
+    try {
+      const msgs = this.history?.messages || [];
+      let bytes = 0;
+      for (const m of msgs) {
+        const c = m?.content;
+        if (typeof c === "string") bytes += c.length;
+        else if (Array.isArray(c)) {
+          for (const part of c) {
+            if (typeof part === "string") bytes += part.length;
+            else if (part?.text) bytes += String(part.text).length;
+            else if (part?.content) bytes += String(part.content).length;
+            else if (part?.input) bytes += JSON.stringify(part.input).length;
+          }
+        } else if (c && typeof c === "object") {
+          bytes += JSON.stringify(c).length;
+        }
+      }
+      out.historyMB = Math.round(bytes / 1024 / 1024);
+    } catch { /* skip */ }
+    // events.jsonl — single file size
+    try {
+      const p = path.join(cwd, "logs", "events.jsonl");
+      out.eventLogMB = Math.round(fs.statSync(p).size / 1024 / 1024);
+    } catch { /* skip */ }
+    // logs/tool_results/ — sum file sizes one level deep (it's flat)
+    try {
+      const dir = path.join(cwd, "logs", "tool_results");
+      let total = 0;
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.isFile()) {
+          try { total += fs.statSync(path.join(dir, e.name)).size; } catch { /* skip */ }
+        }
+      }
+      out.toolResultsMB = Math.round(total / 1024 / 1024);
+    } catch { /* skip */ }
+    // sub_agents/ — sum top-level entries (each is a dir, statSync returns
+    // dir-block size, not contents — that's fine for an order-of-magnitude
+    // signal; recursive walk would be too expensive for the sampler)
+    try {
+      const dir = path.join(cwd, "sub_agents");
+      let total = 0;
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        try { total += fs.statSync(path.join(dir, e.name)).size; } catch { /* skip */ }
+      }
+      out.subagentsMB = Math.round(total / 1024 / 1024);
+    } catch { /* skip */ }
+    // cache/bundles/
+    try {
+      const dir = path.join(cwd, "cache", "bundles");
+      let total = 0;
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.isFile()) {
+          try { total += fs.statSync(path.join(dir, e.name)).size; } catch { /* skip */ }
+        }
+      }
+      out.bundleCacheMB = Math.round(total / 1024 / 1024);
+    } catch { /* skip */ }
+    return out;
+  }
+
   /** Stop background diagnostics. Call on graceful shutdown. */
   stop() {
     try { this._heapSamplerStop?.(); } catch { /* ignore */ }
@@ -280,6 +381,14 @@ export class AgentEngine {
         new PhaseAdvanceTool(
           (to, reason, opts) => this._advancePhase(to, reason, opts),
           () => this.currentPhase, // H1: tool reads phase BEFORE its own call
+          // v0.6.2 J1: surface running subagents so the tool can refuse
+          // advance until the agent explicitly acknowledges them.
+          () => {
+            try {
+              const agentTool = this._buildTools?.core?.find((t) => t?.name === "agent_tool");
+              return agentTool?.getRunningTaskIds?.() || [];
+            } catch { return []; }
+          },
         ),
         new DocumentParseTool(this.workspace, {
           mineruApiUrl: this.config.mineruApiUrl,
@@ -311,7 +420,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 +1170,33 @@ export class AgentEngine {
       return false;
     }
 
-    const phaseSummary = `[${this.currentPhase.toUpperCase()} → ${nextPhase.toUpperCase()}]: ${reason}${force && nextPhase !== expected ? " (forced)" : ""}`;
+    // v0.6.2 J2: detect rollback direction. PHASE_ORDER is a linear array
+    // of all phases; if target index < current index, this is a rollback
+    // (e.g., production_qc → skill_authoring after gates revealed gaps).
+    const fromIdx = PHASE_ORDER.indexOf(this.currentPhase);
+    const toIdx = PHASE_ORDER.indexOf(nextPhase);
+    const direction = (fromIdx >= 0 && toIdx >= 0 && toIdx < fromIdx)
+      ? "rollback" : "forward";
+
+    // 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 directionTag = direction === "rollback" ? " [ROLLBACK]" : "";
+    const phaseSummary =
+      `[${this.currentPhase.toUpperCase()} → ${nextPhase.toUpperCase()}]${directionTag}: ${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,
+      direction,
+      engineCounts: engineCounts || null,
+      possibleMismatch: !!mismatchPrefix,
       forced: force && nextPhase !== expected,
     });
     const fromPhase = this.currentPhase;
@@ -1070,6 +1204,17 @@ export class AgentEngine {
     this._registerToolsForPhase(this.currentPhase);
     this.workspace.setPhase(this.currentPhase);
     this._createTasksForPhase(this.currentPhase);
+
+    // v0.6.2 J2: on rollback, reset the rolled-FROM phase's lastReady
+    // edge-trigger so that if the agent revisits it and re-flips
+    // exit-criteria true, _maybeAutoAdvance will fire correctly. Without
+    // this, the auto-advance edge trigger stays latched true and the
+    // moment the agent returns to fromPhase the engine immediately
+    // bounces them back out — defeating the rollback.
+    if (direction === "rollback" && this._lastReady) {
+      this._lastReady[fromPhase] = false;
+    }
+
     this.saveState();
 
     // B8: Soft signal — surface any sub-agents left running from the prior
@@ -1093,6 +1238,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 {