kc-beta 0.7.2 → 0.7.5

package/README.md

@@ -216,28 +216,41 @@ Quality Thresholds, Language.
 
 ## Status
 
-**v0.6.0 — first architectural beta.** This release lands:
+**v0.7.4 — phase-control fix + codex review re-attempt.** Architectural
+payload from v0.6.0+ is still in place:
 
 - Parallel ralph-loop (up to 8 concurrent workers) with a heap-safety
   conformance gate
 - Native chunker + RAG (onion-peeler + CJK bigram keyword index +
   one-shot LLM bundle classifier, ported from the AMC verification app)
-- Source-context auto-attach on skill_authoring tasks (rule NL + evidence
-  chunks + sibling rules injected into the prompt, no manual search needed)
+- Agent-owned task board: the agent reads the rule list from
+  `describeState`, decides decomposition (per-rule / grouped / range),
+  and calls `TaskCreate` / `TaskUpdate` / `TaskComplete` to drive the
+  Ralph loop **within the current phase only** (v0.7.4). Source-context
+  auto-attach pulls rule NL + evidence chunks + sibling rules into each
+  task's prompt.
+- Phase boundaries = user checkpoints: the Ralph loop exits at every
+  phase transition, returning control to the user. The engine doesn't
+  auto-advance; phase advance is explicit (agent's `phase_advance` tool
+  call or user re-prompt). Marathon-style end-to-end autonomy lives
+  outside the engine.
 - Workspace file locking for shared coordination files (`rules/catalog.json`,
-  `rules/manifest.json`, `tasks.json`, etc.)
+  `rules/manifest.json`, `refs/manifest.json`, `tasks.json`,
+  `session-state.json`) — every writer goes through `withFileLock`.
 - `agent_tool` gets `wait` / `poll` / `list` / `kill` operations +
   `stale_subagents` phase-advance signal
-- New FINALIZATION phase packages the session into a shippable deliverable
+- FINALIZATION phase packages the session into a shippable deliverable
   (canonical `rule_skills/` layout + README + coverage report + final
   dashboard)
+- Filesystem-derived phase milestones (v0.7.0+): the engine reads disk
+  artifacts for advance criteria, never trusts tool-call assertions
 - Input stays active during streaming (type-ahead queue), arrow keys +
   history recall, CTX smoothing + peak, per-provider context-limit caps,
   `/tools`, `/parallelism`, and more
 
-See [DEV_LOG.md](./DEV_LOG.md) for the full v0.6.0 change breakdown and
-[docs/update_design_v5.md](./docs/update_design_v5.md) for the plan that
-drove it.
+See [DEV_LOG.md](./DEV_LOG.md) for the per-release change breakdowns and
+[docs/update_design_v7.md](./docs/update_design_v7.md) for the v0.7.x
+plan and patch notes.
 
 Bug reports and PRs welcome at <https://github.com/kitchen-engineer42/kc-cli>.
 

package/bin/kc-beta.js

@@ -34,17 +34,31 @@ if (parallelismOverride !== null) {
 // their own output.
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-function printBanner() {
+function readPkgVersion() {
   try {
     const pkg = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));
-    const scriptPath = __filename;
-    process.stderr.write(`⏵⏵  KC Agent CLI  v${pkg.version}  ·  ${scriptPath}\n`);
-  } catch { /* package.json missing or unreadable — silent */ }
+    return pkg.version || "unknown";
+  } catch { return "unknown"; }
+}
+function printBanner() {
+  try {
+    const v = readPkgVersion();
+    process.stderr.write(`⏵⏵  KC Agent CLI  v${v}  ·  ${__filename}\n`);
+  } catch { /* silent */ }
 }
-const suppressBanner = args.includes("--version") || args.includes("-v") ||
-                       args.includes("--help") || args.includes("-h");
+const isVersion = args.includes("--version") || args.includes("-v");
+const isHelp = args.includes("--help") || args.includes("-h");
+const suppressBanner = isVersion || isHelp;
 if (!suppressBanner) printBanner();
 
+// v0.7.5 G-F1: `--version` prints version and exits. Previously the flag
+// suppressed the banner but fell through to TUI launch (audit confirmed
+// during v0.7.4 testing). Print + exit before the subcommand dispatch.
+if (isVersion) {
+  process.stdout.write(`${readPkgVersion()}\n`);
+  process.exit(0);
+}
+
 (async () => {
   if (subcommand === "onboard" || subcommand === "setup") {
     const { onboard } = await import("../src/cli/onboard.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kc-beta",
-  "version": "0.7.2",
+  "version": "0.7.5",
   "description": "KC Agent — LLM document verification agent (pure Node.js CLI). Dual-licensed: PolyForm Noncommercial 1.0.0 for personal/noncommercial use; commercial license required for enterprise production. See LICENSE and LICENSE-COMMERCIAL.md.",
   "type": "module",
   "bin": {

package/src/agent/engine.js

@@ -37,6 +37,8 @@ import { EvolutionCycleTool } from "./tools/evolution-cycle.js";
 import { TierDowngradeTool } from "./tools/tier-downgrade.js";
 import { AgentTool } from "./tools/agent-tool.js";
 import { WebSearchTool } from "./tools/web-search.js";
+import { TaskCreateTool, TaskUpdateTool, TaskCompleteTool } from "./tools/task-board.js";
+import { ConsultSkillTool } from "./tools/consult-skill.js";
 import { SkillLoader } from "./skill-loader.js";
 import { TaskManager } from "./task-manager.js";
 import { Scheduler } from "./scheduler.js";
@@ -233,6 +235,18 @@ export class AgentEngine {
     // Skill discovery (Claude Code pattern: index in context, full content on demand)
     this._skillLoader = new SkillLoader(config.language);
 
+    // v0.7.5 G-D1: populate <workspace>/skills/ with the initial phase's
+    // available skill set. Symlink with copy fallback. Re-populated on
+    // every phase advance/retreat (see _advancePhase).
+    try {
+      const res = this._skillLoader.populateWorkspaceSkills(this.workspace.cwd, this.currentPhase);
+      this.eventLog?.append?.("skills_populated", {
+        phase: res.phase,
+        populated: res.populated,
+        failures: res.failures,
+      });
+    } catch { /* best-effort; skills/ population is not a critical-path failure */ }
+
     // Register tools for initial phase
     this.toolRegistry = new ToolRegistry();
     this._registerToolsForPhase(this.currentPhase);
@@ -475,6 +489,27 @@ export class AgentEngine {
           () => this.currentPhase,
         ),
         new WebSearchTool(this.config.tavilyApiKey),
+        // v0.7.4 (re-applied from v0.7.3 G2b): TaskCreate /
+        // TaskUpdate / TaskComplete — agent populates the
+        // Ralph-loop queue for the CURRENT phase only. Phase
+        // boundaries exit the loop (v0.7.4 G0c). Skipped for
+        // subagents (taskManager null in subagent scope).
+        ...(this.taskManager ? [
+          new TaskCreateTool(this.workspace, this.taskManager),
+          new TaskUpdateTool(this.workspace, this.taskManager),
+          new TaskCompleteTool(this.workspace, this.taskManager),
+        ] : []),
+        // v0.7.5: consult_skill loads a meta-skill body into conversation
+        // history on demand. Always-loaded skills are already in the
+        // system prompt via SkillLoader.formatForContext; this tool covers
+        // the "available" set for the current phase. Both main + subagents
+        // register their own — each has its own skillLoader + phase.
+        new ConsultSkillTool(
+          this.workspace,
+          this._skillLoader,
+          () => this.currentPhase,
+          this.eventLog,
+        ),
       ],
       // Distillation+ only (DISTILL mode)
       distill: [
@@ -1185,11 +1220,11 @@ export class AgentEngine {
           }
           this._totalTurns = (this._totalTurns || 0) + 1;
 
-          // Bug 4 trigger (1): re-check phase criteria at end of every turn —
-          // KC may have advanced state via conversation alone, without any
-          // tool that the pipeline narrowly watches.
-          const advancedEv = this._maybeAutoAdvance();
-          if (advancedEv) yield advancedEv;
+          // v0.7.4 G0b: removed `_maybeAutoAdvance()` auto-fire here.
+          // Phase advance is now 100% explicit (agent's `phase_advance`
+          // tool, or user re-prompt). v0.7.3 phase-control regression
+          // was caused by this edge-triggered auto-advance firing mid-
+          // session and chaining into next phase without user check-in.
 
           this.eventLog.append("turn_complete", {});
           this.saveState();
@@ -1278,23 +1313,45 @@ export class AgentEngine {
 
           this.eventLog.append("tool_result", {
             name: tc.name,
+            input: inputData,
             output: result.content || "",
             isError: result.isError,
             traceId: offload?.traceId || null,
           });
 
-          // D3a: trace skill invocations. When the agent reads a SKILL.md via
-          // workspace_file (the canonical way KC "uses" a skill, since skills
-          // are progressively-disclosed markdown), emit a skill_invoked event.
-          // Makes "which skills did KC actually consult?" answerable in post-run
-          // analysis — before this, skills were opaque to the event log.
+          // v0.7.5 (G-F4): added `input` above so events.jsonl carries the
+          // tool inputs (v0.7.4 G1c only patched the AgentEvent yield path,
+          // missed the persistence path — audit confirmed 0/453 + 0/946
+          // tool_result events had `input` in v0.7.4 sessions).
+
+          // D3a: trace skill invocations. v0.7.5 (G-C6): only fire on
+          // READS of meta-skill paths. Writes to rule_skills/<id>/SKILL.md
+          // during skill_authoring are NOT skill invocations — they're the
+          // agent producing its own deliverable. The old "(unknown)" spam
+          // (100% of events in v0.7.1 + v0.7.4 sessions) is gone.
+          //
+          // Note: meta-skill body reads now happen via consult_skill, which
+          // emits skill_invoked itself (with the real skill name). This
+          // path-matching emission stays only as a fallback for any agent
+          // that reads a SKILL.md path directly (out of pattern).
           try {
+            const isRead =
+              (tc.name === "workspace_file" && inputData?.operation === "read") ||
+              (tc.name === "sandbox_exec" && /\b(cat|head|tail|less|grep|view|read)\b/.test(
+                String(inputData?.command || "")
+              ));
             if (
               !result.isError &&
+              isRead &&
               (tc.name === "workspace_file" || tc.name === "sandbox_exec")
             ) {
               const p = String(inputData?.path || inputData?.command || "");
-              const skillMatch = p.match(/(?:template\/)?skills\/[a-z-]+\/(?:meta-meta|meta|skill-creator)\/([a-zA-Z0-9_-]+)(?:\/SKILL\.md|\/)?|\bSKILL\.md\b/);
+              // v0.7.5 flat layout: skills/<name>/SKILL.md (workspace scope)
+              // OR template/skills/<lang>/<name>/SKILL.md (template scope, rare)
+              // Deep layout backward-compat preserved for any stragglers.
+              const skillMatch = p.match(
+                /(?:template\/)?skills\/(?:[a-z]+\/)?(?:(?:meta-meta|meta|skill-creator)\/)?([a-zA-Z0-9_-]+)\/SKILL\.md\b/
+              ) || p.match(/\bSKILL\.md\b/);
               if (skillMatch) {
                 const skillName = skillMatch[1] || "(unknown)";
                 this.eventLog.append("skill_invoked", {
@@ -1308,6 +1365,7 @@ export class AgentEngine {
           yield new AgentEvent({
             type: "tool_result",
             name: tc.name,
+            input: inputData,
             output: historyContent,
             isError: result.isError,
           });
@@ -1374,12 +1432,9 @@ export class AgentEngine {
           }
         }
 
-        // Bug 4 fix: re-check exit criteria after every tool-result loop, not
-        // just from pipeline.onToolResult. The pipeline's describeState() (called
-        // on every turn) already re-scans, so exitCriteriaMet() is accurate; we
-        // just need to act on it eagerly.
-        const ev = this._maybeAutoAdvance();
-        if (ev) yield ev;
+        // v0.7.4 G0b: removed post-tool `_maybeAutoAdvance()` call.
+        // Phase advance is now 100% explicit. See `_runTaskLoopSerial`
+        // phase-change-exit guard for the loop-level checkpoint.
 
       } catch (err) {
         // A8: If the LLM client tagged the stream termination reason, pass
@@ -1529,6 +1584,20 @@ export class AgentEngine {
     this.workspace.setPhase(this.currentPhase);
     this._createTasksForPhase(this.currentPhase);
 
+    // v0.7.5 G-D2: re-populate <workspace>/skills/ with the new phase's
+    // available set. Symlinks are wiped + recreated. Agent's `ls skills/`
+    // and any read-by-path reflects the current phase's allowlist.
+    try {
+      const res = this._skillLoader?.populateWorkspaceSkills(this.workspace.cwd, this.currentPhase);
+      if (res) {
+        this.eventLog.append("skills_populated", {
+          phase: res.phase,
+          populated: res.populated,
+          failures: res.failures,
+        });
+      }
+    } catch { /* best-effort */ }
+
     // v0.7.0 N (#94): give the entered pipeline a chance to do
     // phase-entry setup. Used by finalization to copy the release
     // template into output/releases/v1/. Other pipelines are no-ops.
@@ -2097,7 +2166,26 @@ export class AgentEngine {
     // Run the initial turn (user's request)
     yield* this.runTurn(userMessage);
 
-    // Auto-continue through pending tasks
+    // v0.7.5 G-F5 — TEMPORARILY DISABLED 2026-05-13 for overnight
+    // marathon test. The strict capture-BEFORE form lets every user
+    // prompt advance only one phase, which blocks unattended overnight
+    // sessions. v0.7.4-style capture-AFTER (below) allows the agent
+    // to chain multiple phase_advance calls within the initial runTurn,
+    // then exits the while loop on subsequent phase changes.
+    //
+    // TODO: after the overnight E2E results come in (2026-05-14), decide:
+    //   (a) re-enable F5 strict and build marathon as a separate mode
+    //       (external driver pattern, e.g., /loop-kc command) — locked
+    //       earlier decision per harness-research § 7
+    //   (b) keep capture-AFTER permanently and accept multi-phase prompts
+    //
+    // To re-enable F5: move `const startingPhase = this.currentPhase;`
+    // to BEFORE the `yield* this.runTurn(userMessage);` above, and add
+    // the matching `if (this.currentPhase !== startingPhase) { return; }`
+    // block between runTurn and the while loop.
+    const startingPhase = this.currentPhase;
+
+    // Auto-continue through pending tasks (within current phase only)
     while (this.taskManager.getNextPending()) {
       // v0.7.0 #93: budget-aware compact threshold. The old
       // `messages.length > 15` was message-count-based and frozen
@@ -2158,26 +2246,20 @@ export class AgentEngine {
         },
       });
 
-      // Bug 4 trigger (2): auto-advance when all phase tasks are done AND
-      // the pipeline's exit criteria are also met (Bug 5 fix — task state
-      // alone is a ralph-loop convenience, not authoritative phase signal;
-      // tasks could be marked skipped manually or by an editor).
-      if (this._allCurrentPhaseTasksComplete()) {
-        const pipeline = this.pipelines[this.currentPhase];
-        let exitMet = false;
-        try { exitMet = !!pipeline?.exitCriteriaMet?.(); } catch { exitMet = false; }
-        if (exitMet) {
-          const next = NEXT_PHASE[this.currentPhase];
-          if (next) {
-            const advanced = this._advancePhase(next, "all current-phase tasks completed + exit criteria met");
-            if (advanced) {
-              yield new AgentEvent({
-                type: "pipeline_event",
-                data: { type: "phase_ready", nextPhase: next, message: "all phase tasks done; exit criteria met" },
-              });
-            }
-          }
-        }
+      // v0.7.4 G0c: phase boundary = user checkpoint. Exit the
+      // loop if the agent advanced phase during this task —
+      // even if pre-created tasks for the new phase are queued.
+      // User sees current state and explicitly re-prompts to
+      // begin the next phase. Marathon-style end-to-end
+      // autonomy belongs to an external driver (Claude Code
+      // /loop pattern), not the engine.
+      if (this.currentPhase !== startingPhase) {
+        this.eventLog.append("ralph_loop_exit", {
+          reason: "phase_changed",
+          from: startingPhase,
+          to: this.currentPhase,
+        });
+        break;
       }
     }
   }
@@ -2203,6 +2285,12 @@ export class AgentEngine {
     // Initial turn: main agent reads user request, creates tasks.
     yield* this.runTurn(userMessage);
 
+    // v0.7.5 G-F5 — TEMPORARILY DISABLED 2026-05-13 for overnight
+    // marathon test. See _runTaskLoopSerial above for full rationale.
+    // To re-enable F5: move `startingPhase` capture BEFORE the
+    // initial runTurn, add post-runTurn exit check matching serial.
+    const startingPhase = this.currentPhase;
+
     const agentTool = this._buildTools.core.find((t) => t?.name === "agent_tool");
     if (!agentTool) {
       // Shouldn't happen (agent_tool is core), but fall back safely.
@@ -2227,6 +2315,9 @@ export class AgentEngine {
     const inFlight = new Map();
 
     const dispatch = async () => {
+      // v0.7.4 G0c: stop dispatching if phase changed since loop start.
+      // In-flight workers complete naturally; queue stays untouched.
+      if (this.currentPhase !== startingPhase) return;
       while (inFlight.size < parallelism) {
         const task = this.taskManager.claimNextPending(`pool${inFlight.size}`);
         if (!task) return;
@@ -2362,23 +2453,15 @@ export class AgentEngine {
 
     this.saveState();
 
-    // After all workers done, check for phase auto-advance (same as serial path).
-    if (this._allCurrentPhaseTasksComplete()) {
-      const pipeline = this.pipelines[this.currentPhase];
-      let exitMet = false;
-      try { exitMet = !!pipeline?.exitCriteriaMet?.(); } catch { exitMet = false; }
-      if (exitMet) {
-        const next = NEXT_PHASE[this.currentPhase];
-        if (next) {
-          const advanced = this._advancePhase(next, "all parallel tasks completed + exit criteria met");
-          if (advanced) {
-            yield new AgentEvent({
-              type: "pipeline_event",
-              data: { type: "phase_ready", nextPhase: next, message: "all phase tasks done; exit criteria met" },
-            });
-          }
-        }
-      }
+    // v0.7.4 G0c: if phase changed during the parallel run, log the
+    // checkpoint event for the audit trail. No auto-advance — that
+    // belongs to the agent (phase_advance tool) or user re-prompt.
+    if (this.currentPhase !== startingPhase) {
+      this.eventLog.append("ralph_loop_exit", {
+        reason: "phase_changed",
+        from: startingPhase,
+        to: this.currentPhase,
+      });
     }
   }
 

package/src/agent/pipelines/_milestone-derive.js

@@ -80,6 +80,59 @@ function readJsonSafe(p) {
   try { return JSON.parse(fs.readFileSync(p, "utf-8")); } catch { return null; }
 }
 
+function readFileSafe(p) {
+  try { return fs.readFileSync(p, "utf-8"); } catch { return ""; }
+}
+
+/**
+ * v0.7.5 G-H1: extract `source_rules: [...]` from YAML frontmatter.
+ *
+ * Supports both inline and block list forms:
+ *   source_rules: [R001, R005, R007]
+ *   source_rules:
+ *     - R001
+ *     - R005
+ *
+ * Used by milestone derivation to credit grouped/thematic skill folders
+ * + master workflows where the agent declares which rules are covered.
+ * Returns an array of canonical rule IDs (e.g., ["R001", "R005"]).
+ */
+function parseSourceRulesFromFrontmatter(content) {
+  if (!content || typeof content !== "string") return [];
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return [];
+  const fm = fmMatch[1];
+
+  // Inline form: source_rules: [R001, R005, "R007"]
+  const inlineMatch = fm.match(/^source_rules\s*:\s*\[([^\]]*)\]\s*$/m);
+  if (inlineMatch) {
+    return inlineMatch[1]
+      .split(",")
+      .map(s => s.trim().replace(/^["']|["']$/g, ""))
+      .filter(Boolean)
+      .map(s => canonicalRuleId(s) || s)
+      .filter(rid => /^R\d+$/i.test(rid))
+      .map(rid => rid.toUpperCase().replace(/^R0*(\d+)$/, (_, n) => `R${String(parseInt(n,10)).padStart(3,"0")}`));
+  }
+
+  // Block form: source_rules:\n  - R001\n  - R005
+  const blockMatch = fm.match(/^source_rules\s*:\s*\n((?:[ \t]+-\s+\S+\s*\n?)+)/m);
+  if (blockMatch) {
+    return blockMatch[1]
+      .split("\n")
+      .map(line => {
+        const m = line.match(/^[ \t]+-\s+["']?([^"'\s]+)["']?\s*$/);
+        return m ? m[1] : null;
+      })
+      .filter(Boolean)
+      .map(s => canonicalRuleId(s) || s)
+      .filter(rid => /^R\d+$/i.test(rid))
+      .map(rid => rid.toUpperCase().replace(/^R0*(\d+)$/, (_, n) => `R${String(parseInt(n,10)).padStart(3,"0")}`));
+  }
+
+  return [];
+}
+
 function sha256OfFile(p) {
   try {
     const buf = fs.readFileSync(p);
@@ -239,6 +292,26 @@ export function deriveSkillAuthoringMilestones(workspace) {
         }
       }
     }
+
+    // v0.7.5 G-H1: also credit rule_ids declared in SKILL.md frontmatter
+    // `source_rules:` field. Agents using grouped/thematic skill folders
+    // (e.g., S01_compliance/, custodian_checks/) declare which rules
+    // their grouped check covers via frontmatter; engine derivation
+    // credits each declared rule_id. Audit found 资管 v0.7.4 session
+    // forced through skill_authoring → skill_testing because its 10 S*
+    // grouped folders weren't credited (rulesCovered=0/94).
+    if (hasSkillMd) {
+      try {
+        const skillMdFile = listChildFiles(skillPath).find(
+          (f) => f.name.toLowerCase() === "skill.md",
+        );
+        if (skillMdFile) {
+          const content = readFileSafe(path.join(skillPath, skillMdFile.name));
+          const sourceRules = parseSourceRulesFromFrontmatter(content);
+          for (const rid of sourceRules) ruleIdsCovered.add(rid);
+        }
+      } catch { /* best-effort */ }
+    }
   }
 
   return {
@@ -362,6 +435,37 @@ export function deriveDistillationMilestones(workspace) {
   const cwd = cwdOf(workspace);
   const wfRoot = path.join(cwd, "workflows");
   const workflowsCreated = [];
+  // v0.7.5 G-H1: also track rule IDs covered by workflows. Grouped/master
+  // workflows (e.g., 贷款 v0.7.4's master + R001 template) cover multiple
+  // rules; declare them via SKILL.md frontmatter `source_rules: [...]`.
+  // Engine credits each declared rule_id so workflowsCovered milestone
+  // matches catalog reality.
+  const ruleIdsCovered = new Set();
+
+  const creditWorkflowSourceRules = (workflowDir) => {
+    // Check for a SKILL.md (or workflow.md) declaring source_rules
+    const candidates = listChildFiles(workflowDir).filter(
+      (f) => /^(skill|workflow)\.md$/i.test(f.name),
+    );
+    for (const c of candidates) {
+      const content = readFileSafe(path.join(workflowDir, c.name));
+      for (const rid of parseSourceRulesFromFrontmatter(content)) {
+        ruleIdsCovered.add(rid);
+      }
+    }
+    // Also: per-workflow config.json may declare rule coverage
+    const configPath = path.join(workflowDir, "config.json");
+    if (fileExists(configPath)) {
+      const data = readJsonSafe(configPath);
+      const rules = Array.isArray(data?.source_rules) ? data.source_rules :
+                    Array.isArray(data?.rules) ? data.rules :
+                    Array.isArray(data?.rule_ids) ? data.rule_ids : [];
+      for (const r of rules) {
+        const canon = canonicalRuleId(String(r));
+        if (canon) ruleIdsCovered.add(canon);
+      }
+    }
+  };
 
   if (dirExists(wfRoot)) {
     // Two layouts seen in E2E #5:
@@ -375,16 +479,39 @@ export function deriveDistillationMilestones(workspace) {
         const sub = path.join(wfRoot, e.name);
         const hasPy = listChildFiles(sub).some((f) =>
           /workflow.*\.py$/i.test(f.name) || /^check.*\.py$/i.test(f.name));
-        if (hasPy) workflowsCreated.push(e.name);
+        if (hasPy) {
+          workflowsCreated.push(e.name);
+          // Dir name might itself be a rule_id
+          const canon = canonicalRuleId(e.name);
+          if (canon) ruleIdsCovered.add(canon);
+          // Plus any frontmatter / config-declared source_rules
+          creditWorkflowSourceRules(sub);
+        }
         continue;
       }
       if (e.isFile()) {
         const m1 = e.name.match(/^(.+)_workflow\.py$/i);
-        if (m1) { workflowsCreated.push(m1[1]); continue; }
+        if (m1) {
+          workflowsCreated.push(m1[1]);
+          const canon = canonicalRuleId(m1[1]);
+          if (canon) ruleIdsCovered.add(canon);
+          continue;
+        }
         const m2 = e.name.match(/^(.+)\.json$/i);
         if (m2) {
           const data = readJsonSafe(path.join(wfRoot, e.name));
-          if (data && (data.rule_id || data.entry || data.type)) workflowsCreated.push(m2[1]);
+          if (data && (data.rule_id || data.entry || data.type)) {
+            workflowsCreated.push(m2[1]);
+            const canon = canonicalRuleId(data.rule_id || m2[1]);
+            if (canon) ruleIdsCovered.add(canon);
+            // Manifest-declared source_rules
+            const rules = Array.isArray(data.source_rules) ? data.source_rules :
+                          Array.isArray(data.rules) ? data.rules : [];
+            for (const r of rules) {
+              const c2 = canonicalRuleId(String(r));
+              if (c2) ruleIdsCovered.add(c2);
+            }
+          }
           continue;
         }
       }
@@ -408,7 +535,16 @@ export function deriveDistillationMilestones(workspace) {
     }
   }
 
-  return { workflowsCreated, workflowsTested };
+  return {
+    workflowsCreated,
+    workflowsTested,
+    // v0.7.5 G-H1: rule_ids the engine credits as having workflow coverage
+    // (either via dir name being a canonical rule_id, or via SKILL.md /
+    // workflow.md / config.json frontmatter declaring source_rules: [...]).
+    // Pipelines that check workflow coverage against the catalog should
+    // prefer ruleIdsCovered over workflowsCreated for grouped patterns.
+    ruleIdsCovered: [...ruleIdsCovered],
+  };
 }
 
 // ───────────────────────────────────────────────────────────────────

package/src/agent/pipelines/initializer.js

@@ -9,7 +9,10 @@ import { deriveBootstrapMilestones } from "./_milestone-derive.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_MD_TEMPLATE = path.resolve(__dirname, "../../../template/AGENT.md");
 
-const REQUIRED_DIRS = ["rules", "samples", "input", "output", "logs", "workflows", "rule_skills"];
+// v0.7.5: `skills` added to required dirs. Populated by SkillLoader
+// .populateWorkspaceSkills() at bootstrap + on every phase transition
+// with the phase's `available` skill set (per phase_skills.yaml).
+const REQUIRED_DIRS = ["rules", "samples", "input", "output", "logs", "workflows", "rule_skills", "skills"];
 
 const DEFAULT_ENV = `# === KC Agent Project Configuration ===