kc-beta 0.8.1 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kc-beta",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "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/context.js

@@ -152,10 +152,26 @@ export class ContextAssembler {
    * @param {string} [opts.projectMemory] - v0.7.0 B3: rules/PATTERNS.md
    *   content. Capped at ~5 KB by the caller. Surfaced for phases the
    *   work-decomposition skill operates in (skill_authoring + skill_testing).
+   * @param {string} [opts.marathonGoal] - v0.8.2 P12-A: the active marathon
+   *   goal text. Pinned at the system-prompt layer (never windowed) for the
+   *   duration of the marathon session. Surfaced only when marathon mode is
+   *   active; absent otherwise. Fixes the v0.8.1 regression where the goal
+   *   user_message got evicted by context_windowed before distillation, so
+   *   agents reverted to default behavior mid-run.
    * @returns {string}
    */
-  build({ agentMd, pipelineState, workspaceState, skillIndex, projectMemory } = {}) {
+  build({ agentMd, pipelineState, workspaceState, skillIndex, projectMemory, marathonGoal } = {}) {
     const parts = [AGENT_IDENTITY];
+    if (marathonGoal) {
+      parts.push(
+        "## Marathon goal (pinned for the duration of this session)\n\n" +
+        marathonGoal.trim() + "\n\n" +
+        "You are running in marathon mode — no manual user check-ins between " +
+        "phases. This goal is your north star; keep returning to it as you " +
+        "advance through the pipeline. If a continuation prompt focuses on " +
+        "phase mechanics, the goal above tells you *why*.",
+      );
+    }
     if (agentMd) parts.push(agentMd);
     if (skillIndex) parts.push(skillIndex);
     if (projectMemory) {

package/src/agent/engine.js

@@ -229,6 +229,17 @@ export class AgentEngine {
     // marker, no inbox.jsonl. Driver instance set by enterMarathonMode(),
     // cleared by exitMarathonMode(). Query via this.marathonDriver.
     this.marathonDriver = null;
+    // v0.8.2 P12-A: marathon goal text. Pinned at system-prompt level via
+    // ContextAssembler so it survives context_windowed eviction (the v0.8.1
+    // regression). Stored alongside marathonDriver lifecycle.
+    this.marathonGoal = null;
+    // v0.8.2 P12-B: shared user-input queue between TUI and engine. The TUI
+    // queues mid-run typed messages here; the marathon decision loop drains
+    // this queue BEFORE asking the driver for a continuation, so user
+    // interrupts always win over driver autonomy. Fixes the v0.8.1 silent
+    // queue-starvation where /marathon mode kept the user message in a
+    // TUI-local queue that never reached the engine.
+    this.inputQueue = [];
 
     // Context windowing
     this.contextWindow = new ContextWindow({
@@ -461,12 +472,16 @@ export class AgentEngine {
       } catch { /* never fatal */ }
     };
 
-    // v0.8 P1-C: self-rescheduling setTimeout instead of setInterval. The
-    // 资管 v0.7.5 session shows only 2 heap.jsonl entries (12:39:40 start
-    // + 12:40:40 first tick) across an 18-hour run — the unref'd
-    // setInterval was somehow dropped between event-loop idle phases.
-    // setTimeout reschedules from inside the sample callback, so the
-    // timer is re-registered every tick. unref'd so we don't block exit.
+    // v0.8 P1-C: self-rescheduling setTimeout instead of setInterval.
+    // v0.8.3 P21-B4: removed .unref() — both 资管 + 贷款 v0.8.2 sessions
+    // showed only 1 line in heap.jsonl across 7+ hour runs even with
+    // self-rescheduling setTimeout. The .unref'd timer was apparently
+    // being dropped by Node's event-loop housekeeping despite the
+    // process being kept alive by stdin / React render loop / other
+    // refs. The cost of dropping .unref() is that on a graceful exit
+    // path that doesn't call engine.stop(), the timer can delay exit
+    // by up to 60s. We accept this — engine.stop() is the canonical
+    // shutdown path and it clears the timer via clearTimeout.
     let timeoutHandle = null;
     const scheduleNext = () => {
       if (stopped) return;
@@ -474,7 +489,6 @@ export class AgentEngine {
         sample();
         scheduleNext();
       }, 60_000);
-      timeoutHandle.unref?.();
     };
 
     // Record one sample at startup so we have a baseline even on short runs.
@@ -798,6 +812,7 @@ export class AgentEngine {
       pipelineState: this.pipelines[this.currentPhase]?.describeState?.() || null,
       workspaceState: this._buildWorkspaceState(),
       projectMemory: this._readProjectMemory(),
+      marathonGoal: this.marathonGoal,
     });
     const systemTokens = estimateTokens(systemPrompt);
     const messageTokens = estimateMessagesTokens(this.history.messages);
@@ -1239,6 +1254,7 @@ export class AgentEngine {
       pipelineState,
       workspaceState: this._buildWorkspaceState(),
       projectMemory: this._readProjectMemory(),
+      marathonGoal: this.marathonGoal,
     });
     const tools = this.toolRegistry.schemasOpenai();
 
@@ -2468,6 +2484,18 @@ export class AgentEngine {
     // v0.8.0; the I/O wrapper just shifted from filesystem-watcher to
     // direct method calls.
     while (this.marathonDriver) {
+      // v0.8.2 P12-B: user-input queue priority. Drain queued user messages
+      // FIRST so mid-run nudges always win over driver autonomy. Fixes the
+      // v0.8.1 silent queue-starvation: the TUI used to queue messages in a
+      // local ref that only drained after runTurn() returned, but the
+      // marathon loop never returns while the driver is active. Now the
+      // engine owns the queue; TUI hands off via queueUserInput().
+      const queuedUserInput = this._drainNextQueuedUserInput();
+      if (queuedUserInput) {
+        yield* this.runTurn(queuedUserInput);
+        continue;
+      }
+
       const turnsSnapshot = this.marathonDriver.turnsThisPhase;
       const phaseChanged = this.currentPhase !== this.marathonDriver.currentPhase;
       const milestones = this._buildEngineCountsBlock(this.currentPhase) || {};
@@ -2485,6 +2513,7 @@ export class AgentEngine {
           decisions: this.marathonDriver.decisionCount,
         });
         this.marathonDriver = null;
+        this.marathonGoal = null;
         break;
       }
       this.eventLog.append("marathon_decision", {
@@ -2493,7 +2522,8 @@ export class AgentEngine {
         phase: this.currentPhase,
       });
       yield* this.runTurn(decision.prompt);
-      // Loop back: another turn just completed; driver gets another decideNext call.
+      // Loop back: another turn just completed; engine queue + driver both
+      // get another chance via the next iteration's drain-then-decide.
     }
   }
 
@@ -2511,6 +2541,7 @@ export class AgentEngine {
     if (this.marathonDriver) {
       throw new Error("Marathon already active — use /marathon off to disengage first");
     }
+    this.marathonGoal = goal;
     this.marathonDriver = new MarathonDriver({
       goal,
       language: this.config.language || "en",
@@ -2534,6 +2565,7 @@ export class AgentEngine {
       decisions: this.marathonDriver.decisionCount,
     });
     this.marathonDriver = null;
+    this.marathonGoal = null;
     return status;
   }
 
@@ -2542,6 +2574,51 @@ export class AgentEngine {
     return !!this.marathonDriver && !this.marathonDriver.stopped;
   }
 
+  /**
+   * v0.8.2 P12-B: queue a user-typed message for the engine to pick up at
+   * the next turn boundary. Called by the TUI when the user types during an
+   * in-flight marathon turn. The marathon decision loop drains this queue
+   * BEFORE asking the driver for a continuation, so user interrupts always
+   * win over driver autonomy.
+   *
+   * @param {string} text — user-typed message
+   */
+  queueUserInput(text) {
+    if (!text || typeof text !== "string") return;
+    this.inputQueue.push(text);
+    this.eventLog.append("user_input_queued", {
+      preview: text.slice(0, 100),
+      queueDepth: this.inputQueue.length,
+      marathonActive: this.isMarathonActive(),
+    });
+  }
+
+  /**
+   * v0.8.2 P12-B: drain the next queued user input, or null if empty.
+   * Internal helper for the marathon decision loop.
+   *
+   * @returns {string|null}
+   */
+  _drainNextQueuedUserInput() {
+    if (this.inputQueue.length === 0) return null;
+    const text = this.inputQueue.shift();
+    this.eventLog.append("user_input_drained", {
+      preview: text.slice(0, 100),
+      queueDepth: this.inputQueue.length,
+    });
+    return text;
+  }
+
+  /**
+   * v0.8.2 P12-B: query the queue depth without draining.
+   * Used by TUI to display "Queued (N waiting)" indicator.
+   *
+   * @returns {number}
+   */
+  getQueueDepth() {
+    return this.inputQueue.length;
+  }
+
   /**
    * B1: Parallel ralph-loop — N concurrent subagents each executing one
    * task at a time, claimed atomically from TaskManager.

package/src/agent/llm-client.js

@@ -32,6 +32,16 @@ export class LLMClient {
     this.baseUrl = baseUrl.replace(/\/+$/, "");
     this.authType = authType;
     this.apiFormat = apiFormat;
+    // v0.8.2 P14-A: request-level timeout for fetch. SiliconFlow GLM-5.1
+    // streams hung 8h+ overnight in E2E #12 with no HTTP-level cutoff.
+    // 10 min ceiling (configurable via KC_LLM_REQUEST_TIMEOUT_MS) lets the
+    // marathon driver's `error: terminated` → recovery path kick in within
+    // minutes instead of hours when the upstream stalls a request without
+    // closing the TCP connection.
+    const envTimeout = parseInt(process.env.KC_LLM_REQUEST_TIMEOUT_MS || "0", 10);
+    this.requestTimeoutMs = Number.isFinite(envTimeout) && envTimeout > 0
+      ? envTimeout
+      : 10 * 60 * 1000;
   }
 
   /**
@@ -196,10 +206,15 @@ export class LLMClient {
     let resp;
     try {
       resp = await withRetry(async () => {
+        // v0.8.2 P14-A: AbortSignal.timeout for stream connect + per-chunk
+        // forward progress. Hung streams (SiliconFlow GLM-5.1 overnight,
+        // E2E #12) abort within requestTimeoutMs and surface as an error
+        // event the marathon driver can recover from.
         const r = await fetch(this._getEndpoint(), {
           method: "POST",
           headers: this._buildHeaders(),
           body: JSON.stringify(body),
+          signal: AbortSignal.timeout(this.requestTimeoutMs),
         });
         if (!r.ok) {
           const text = await r.text();
@@ -215,7 +230,13 @@ export class LLMClient {
       // A8: Any pre-stream failure (network, auth, 4xx/5xx after retry) is
       // tagged and re-thrown. Engine's outer catch sees exactly one tagged
       // error event.
-      if (!err.streamTermination) err.streamTermination = "connect_error";
+      // v0.8.2 P14-A: AbortError from AbortSignal.timeout marks request_timeout
+      // distinctly so audits can count these vs. generic connect errors.
+      if (err.name === "TimeoutError" || err.name === "AbortError") {
+        err.streamTermination = "request_timeout";
+      } else if (!err.streamTermination) {
+        err.streamTermination = "connect_error";
+      }
       throw err;
     }
 
@@ -256,10 +277,12 @@ export class LLMClient {
     const body = this._buildNonStreamBody({ model, messages, maxTokens });
 
     const resp = await withRetry(async () => {
+      // v0.8.2 P14-A: same request-level timeout as streamChat for symmetry.
       const r = await fetch(this._getEndpoint(), {
         method: "POST",
         headers: this._buildHeaders(),
         body: JSON.stringify(body),
+        signal: AbortSignal.timeout(this.requestTimeoutMs),
       });
       if (!r.ok) {
         const text = await r.text();

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

@@ -156,13 +156,33 @@ function sha256OfFile(p) {
   } catch { return null; }
 }
 
-// Normalize a rule id like "R14" / "r014" / "R0014" to canonical "R014".
+// Normalize a rule id to a canonical form for dedup + comparison.
+// Accepts two shapes:
+//   Bare-numeric: "R14" / "r014" / "R0014" → "R014"
+//   Compound:    "R01-01" / "R01_01" / "R001-005" → "R001-005"
+//                (zero-pads the major part to 3 digits; preserves the
+//                 minor part numerically; uses dash separator canonically)
 // Returns null for non-matching strings (e.g., thematic skill names like
-// "account_identity" — those stay as-is via the second branch).
-function canonicalRuleId(s) {
+// "account_identity" — those stay as-is and don't get credited via this
+// path; their credit comes from frontmatter `source_rules:` instead).
+//
+// v0.8.3 P20-B2: compound form added. E2E #13 资管 used `R01-01`..`R07-01`
+// naturally following the regulation's subsection numbering; v0.8.2's
+// bare-only regex returned null for all 15 dirs → `rulesCovered: 0/15`
+// → engine refused natural skill_testing advance.
+export function canonicalRuleId(s) {
   if (typeof s !== "string") return null;
-  const m = s.match(/^R0*(\d+)$/i);
-  if (m) return `R${String(parseInt(m[1], 10)).padStart(3, "0")}`;
+  const trimmed = s.trim();
+  // Compound form: R01-01, R01_01, R001-005, etc.
+  const compound = trimmed.match(/^R0*(\d+)[-_](\d+)$/i);
+  if (compound) {
+    const major = String(parseInt(compound[1], 10)).padStart(3, "0");
+    const minor = String(parseInt(compound[2], 10)).padStart(2, "0");
+    return `R${major}-${minor}`;
+  }
+  // Bare-numeric form
+  const bare = trimmed.match(/^R0*(\d+)$/i);
+  if (bare) return `R${String(parseInt(bare[1], 10)).padStart(3, "0")}`;
   return null;
 }
 
@@ -193,9 +213,16 @@ export function deriveRuleExtractionMilestones(workspace) {
 
   // rulesExtracted: every rule object across every JSON file in rules/
   // that has a non-empty `id` field. catalog.json is canonical but agents
-  // sometimes fan out to per-rule files (E2E #5 DS).
+  // sometimes fan out to per-rule files (E2E #5 DS) — or write SIBLING
+  // files with the same IDs plus additional metadata (E2E #13 资管's
+  // `rules/difficulty.json` added judgment-type classifications and
+  // doubled the count from 15 → 30 because the engine pushed IDs without
+  // dedup). v0.8.3 P20-B1: dedup by ID across all rules/*.json files.
+  // First-seen wins for chunk-ref counting (catalog.json is read first
+  // by alphabetical / fs order in most cases).
   const rulesExtracted = [];
   const rulesWithChunkRefs = [];
+  const seenIds = new Set();
   if (dirExists(rulesDir)) {
     for (const e of listChildFiles(rulesDir)) {
       if (!e.name.endsWith(".json")) continue;
@@ -204,8 +231,21 @@ export function deriveRuleExtractionMilestones(workspace) {
       const items = Array.isArray(data) ? data : (data.rules || []);
       for (const r of items) {
         if (r && typeof r.id === "string" && r.id.length) {
+          if (seenIds.has(r.id)) continue; // v0.8.3 P20-B1 dedup
+          seenIds.add(r.id);
           rulesExtracted.push(r.id);
-          if (Array.isArray(r.source_chunk_ids) && r.source_chunk_ids.length > 0) {
+          // v0.8.2 P13-C: accept any of three field names for chunk
+          // references. Engine historically looked only for
+          // `source_chunk_ids`, but 贷款 v0.8.1 + 资管 v0.8.1 catalogs
+          // wrote `chunk_ids` (the shorter form agents naturally pick
+          // from the rule-extraction skill examples). `chunk_refs` is
+          // a legacy alias from older audit docs. Any non-empty match
+          // counts.
+          const chunks = (Array.isArray(r.source_chunk_ids) && r.source_chunk_ids)
+            || (Array.isArray(r.chunk_ids) && r.chunk_ids)
+            || (Array.isArray(r.chunk_refs) && r.chunk_refs)
+            || null;
+          if (chunks && chunks.length > 0) {
             rulesWithChunkRefs.push(r.id);
           }
         }
@@ -331,6 +371,37 @@ export function deriveSkillAuthoringMilestones(workspace) {
         }
       } catch { /* best-effort */ }
     }
+
+    // v0.8.2 P13-D: also credit rule_ids declared in rule_mapping.json.
+    // 资管 v0.8.1 wrote 6 thematic-overlay dirs (R01_periodic_report,
+    // R02_custodian_core, etc.) each containing a rule_mapping.json that
+    // maps rule_ids to engine-level check function names. The dirs have
+    // no own check.py because the actual implementation lives in
+    // workspace-root verify_v*.py. Without recognizing rule_mapping.json,
+    // the engine treats them as orphan dirs.
+    //
+    // Rule-id formats in the wild include both bare-numeric (R01, R027)
+    // and compound (R01-05, R02-08). canonicalRuleId() only handles the
+    // bare form, so we accept either canonicalized form OR a raw key
+    // that looks like a rule id (matches R\d+ optionally followed by
+    // `-` or `_` and more digits).
+    try {
+      const mappingPath = path.join(skillPath, "rule_mapping.json");
+      if (fileExists(mappingPath)) {
+        const mapping = readJsonSafe(mappingPath);
+        if (mapping && typeof mapping === "object" && !Array.isArray(mapping)) {
+          for (const key of Object.keys(mapping)) {
+            const canon = canonicalRuleId(key);
+            if (canon) {
+              ruleIdsCovered.add(canon);
+            } else if (/^R0*\d+[-_]?\d*$/i.test(key.trim())) {
+              // Compound form like "R01-05" — preserve as-is
+              ruleIdsCovered.add(key.trim());
+            }
+          }
+        }
+      }
+    } catch { /* best-effort */ }
   }
 
   // v0.8 P2-F (item 22): count stub-shaped check.py files. Pairs with

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

@@ -3,7 +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";
+import { deriveSkillAuthoringMilestones, canonicalRuleId } from "./_milestone-derive.js";
 
 export class SkillAuthoringPipeline extends Pipeline {
   /**
@@ -37,14 +37,31 @@ export class SkillAuthoringPipeline extends Pipeline {
   }
 
   _loadRules() {
+    // v0.8.3 P20-B1+B2: dedup rule IDs across all rules/*.json files AND
+    // canonicalize them so the rulesCovered comparison against
+    // ruleIdsCovered (which now goes through canonicalRuleId) works for
+    // BOTH bare-numeric (R14) AND compound (R01-01, R02-03) forms.
+    // E2E #13 资管 used compound IDs + wrote a sibling difficulty.json;
+    // the raw-string + no-dedup pre-v0.8.3 path produced rulesCovered:
+    // 0/30 (compound IDs unmatched + double-counted).
     this.totalRules = [];
+    const seen = new Set();
     const rulesDir = path.join(this._workspace.cwd, "rules");
     if (!fs.existsSync(rulesDir)) return;
     for (const f of fs.readdirSync(rulesDir).filter((f) => f.endsWith(".json"))) {
       try {
         const data = JSON.parse(fs.readFileSync(path.join(rulesDir, f), "utf-8"));
         const rules = Array.isArray(data) ? data : (data.rules || []);
-        for (const r of rules) { if (r.id) this.totalRules.push(r.id); }
+        for (const r of rules) {
+          if (!r || !r.id) continue;
+          // Canonicalize to match ruleIdsCovered which is built from
+          // canonicalRuleId() output. If canonicalRuleId returns null
+          // (non-rule-shaped string), preserve the raw trimmed string.
+          const canon = canonicalRuleId(r.id) || String(r.id).trim();
+          if (seen.has(canon)) continue;
+          seen.add(canon);
+          this.totalRules.push(canon);
+        }
       } catch { /* skip */ }
     }
   }

package/src/agent/tools/release.js

@@ -763,7 +763,100 @@ export class ReleaseTool extends BaseTool {
       }
     }
 
-    // 5) Fallback (belt-and-suspenders per v0.8 plan Risk #7):
+    // 5) v0.8.2 P13-A: doc-keyed → rules-keyed nested shape.
+    // 贷款 v0.8.1 wrote skill_test_v*_results.json + v2_hybrid_results.json
+    // + run_all_checks.json all with this shape:
+    //   {
+    //     "<doc_filename>": {
+    //       "channel": "...", "expected": "PASS"|"FAIL",
+    //       "rules": {
+    //         "R01": {"rule_id": "R01", "verdict": "PASS", "confidence": 0.95, "method": "regex"},
+    //         "R02": {...}
+    //       }
+    //     },
+    //     ...
+    //   }
+    // The optional outer "results" wrapper from v2_full_regression.json
+    // (which nests this further) is unwrapped via d.results || d.
+    if (tally.size === 0) {
+      for (const f of files) {
+        if (!/qc|verdict|result|test/i.test(f.name)) continue;
+        try {
+          const d = JSON.parse(fs.readFileSync(f.path, "utf-8"));
+          const root = d?.results || d;
+          if (!root || typeof root !== "object" || Array.isArray(root)) continue;
+          let matched = false;
+          for (const docKey of Object.keys(root)) {
+            const docEntry = root[docKey];
+            if (!docEntry || typeof docEntry !== "object") continue;
+            const rulesMap = docEntry.rules;
+            if (!rulesMap || typeof rulesMap !== "object" || Array.isArray(rulesMap)) continue;
+            for (const rid of Object.keys(rulesMap)) {
+              if (!isRuleId(rid)) continue;
+              const r = rulesMap[rid];
+              if (!r || typeof r !== "object") continue;
+              const verdict = (r.verdict || r.result_type || r.status || "").toString().toUpperCase();
+              if (verdict === "PASS") { bump(rid, "pass"); matched = true; }
+              else if (verdict === "FAIL") { bump(rid, "fail"); matched = true; }
+              else if (verdict === "NOT_APPLICABLE" || verdict === "NA") { bump(rid, "na"); matched = true; }
+            }
+          }
+          if (matched) {
+            sourceFiles.push(path.relative(this._workspace.cwd, f.path));
+            break;
+          }
+        } catch { /* skip non-JSON */ }
+      }
+    }
+
+    // 6) v0.8.3 P22-B6: top-level array of {doc_id, results: [{rule_id, status}]}.
+    // 资管 v0.8.2 wrote `output/skill_test_v*.json` + `workflow_v*_results.json`
+    // + `evolution_round*.json` all with this shape:
+    //   [
+    //     {
+    //       "doc_id": "<doc-filename>",
+    //       "results": [
+    //         {"rule_id": "R01-01", "status": "WARNING", "found_fields": {...}},
+    //         {"rule_id": "R01-02", "status": "PASS", ...},
+    //         ...
+    //       ]
+    //     },
+    //     ...
+    //   ]
+    // Distinct from Shape 5: top-level is an ARRAY (not object), and the
+    // per-rule data lives in `results: [...]` (an array of rule outcomes)
+    // rather than `rules: {<rule>: ...}` (object keyed by rule).
+    if (tally.size === 0) {
+      for (const f of files) {
+        if (!/qc|verdict|result|test|evolution|workflow/i.test(f.name)) continue;
+        try {
+          const d = JSON.parse(fs.readFileSync(f.path, "utf-8"));
+          if (!Array.isArray(d)) continue;
+          let matched = false;
+          for (const docEntry of d) {
+            if (!docEntry || typeof docEntry !== "object") continue;
+            const results = docEntry.results;
+            if (!Array.isArray(results)) continue;
+            for (const r of results) {
+              if (!r || typeof r !== "object") continue;
+              const rid = r.rule_id || r.ruleId || r.id;
+              if (!isRuleId(rid)) continue;
+              const verdict = (r.status || r.verdict || r.result_type || "").toString().toUpperCase();
+              if (verdict === "PASS") { bump(rid, "pass"); matched = true; }
+              else if (verdict === "FAIL") { bump(rid, "fail"); matched = true; }
+              else if (verdict === "WARNING") { bump(rid, "pass"); matched = true; } // WARNING counts as pass (per existing shape conventions)
+              else if (verdict === "NOT_APPLICABLE" || verdict === "NA") { bump(rid, "na"); matched = true; }
+            }
+          }
+          if (matched) {
+            sourceFiles.push(path.relative(this._workspace.cwd, f.path));
+            break;
+          }
+        } catch { /* skip non-JSON */ }
+      }
+    }
+
+    // 7) Fallback (belt-and-suspenders per v0.8 plan Risk #7):
     // walk any output/*.json with a top-level rule_id-keyed shape that has
     // verdict-like leaf objects. Catches future schema drift before the
     // next audit cycle.

package/src/cli/index.js

@@ -716,12 +716,27 @@ function App({ engine, config }) {
     }
 
     if (streamingRef.current) {
-      queueRef.current.push(trimmed);
-      setQueueSize(queueRef.current.length); // F2
-      addMessage({
-        role: "system",
-        content: `⏳ Queued (${queueRef.current.length} waiting). Will be sent to KC on next turn boundary.`,
-      });
+      // v0.8.2 P12-B: in marathon mode, hand off to engine's input queue
+      // instead of the TUI-local queueRef. The engine's marathon decision
+      // loop drains it FIRST at each turn boundary, so the user's nudge
+      // wins over the driver's continuation. Outside marathon, keep the
+      // existing TUI-local queue (drained after runTurn returns).
+      const marathonActive = engineRef.current?.isMarathonActive?.() ?? false;
+      if (marathonActive && engineRef.current?.queueUserInput) {
+        engineRef.current.queueUserInput(trimmed);
+        const depth = engineRef.current.getQueueDepth?.() ?? 1;
+        addMessage({
+          role: "system",
+          content: `⏳ Queued for marathon (${depth} waiting). Will be sent before the next driver continuation.`,
+        });
+      } else {
+        queueRef.current.push(trimmed);
+        setQueueSize(queueRef.current.length); // F2
+        addMessage({
+          role: "system",
+          content: `⏳ Queued (${queueRef.current.length} waiting). Will be sent to KC on next turn boundary.`,
+        });
+      }
     } else {
       runTurn(trimmed);
     }
@@ -850,9 +865,15 @@ export async function main({ languageOverride } = {}) {
   // Capture user's project directory (CWD at launch)
   config.projectDir = process.cwd();
 
-  // Session-only language override (does NOT persist to config)
+  // Session-only language override (does NOT persist to config).
+  // v0.8.3 P20-B3 (Task #218): also set process.env.LANGUAGE so the
+  // engine's _overlayWorkspaceEnv() penvWon check honors the CLI flag.
+  // Pre-v0.8.3, workspace .env LANGUAGE=en would overwrite a CLI --zh
+  // override during engine construction because the overlay only
+  // checked process.env, not in-memory config.language.
   if (languageOverride) {
     config.language = languageOverride;
+    process.env.LANGUAGE = languageOverride;
   }
 
   if (!config.llmApiKey) {

package/template/.env.template

@@ -1,4 +1,4 @@
-# === KC Reborn Configuration ===
+# === KC Configuration ===
 
 # Language: en | zh
 LANGUAGE=en

package/template/AGENT.md

@@ -15,7 +15,7 @@ update as you learn about this specific business scenario.
 
 ---
 
-# KC Reborn — Document Verification Workspace
+# KC — Document Verification Workspace
 
 ## What This Workspace Is
 
@@ -93,7 +93,7 @@ The skill body is the methodology. Skills convey philosophy and decision framewo
 
 ---
 
-# KC Reborn — 文档核查工作区
+# KC — 文档核查工作区
 
 > **技能优先级**: meta-meta 技能是架构层面 —— 当指导冲突时，
 > meta-meta 凌驾于 meta (技法层面) 之上。架构师的框架约束技法。