kc-beta 0.7.5 → 0.8.1

package/src/agent/tools/release.js

@@ -85,13 +85,19 @@ export class ReleaseTool extends BaseTool {
       return new ToolResult(`release template missing at ${TEMPLATE_DIR}`, true);
     }
 
-    // 1. Snapshot first — locks in commit + tag, regardless of whether bundle build succeeds
-    const snapResult = await this._snapshot.execute({
-      label: `release-${slug}`,
-      notes: `Release ${label} bundle source`,
-    });
-    if (snapResult.isError) return new ToolResult(`snapshot failed: ${snapResult.content}`, true);
-    const { tag: snapshotTag, commit: snapshotCommit } = this._readSnapshotMeta(`release-${slug}`);
+    // v0.8.1 P9-C: defer the snapshot (git tag) until AFTER the bundle
+    // is written + verified. v0.8.0 ordered snapshot-first to "lock in
+    // commit + tag regardless of bundle outcome," but E2E #11 资管 v0.8
+    // audit found `release-v1` tags with no corresponding bundle dir —
+    // tag without bundle confuses downstream consumers. New order:
+    //   1. Build bundle (catalog read, copy template, write fixtures, manifest, README)
+    //   2. Verify bundle (manifest.json + README.md exist + non-empty)
+    //   3. ONLY THEN snapshot (creates the git tag) + back-fill manifest
+    //      with snapshot tag/commit
+    // If verification fails, a `.failed_release` marker is written into
+    // the bundle dir and NO tag is created.
+    let snapshotTag = null;
+    let snapshotCommit = null;
 
     // 2. Read catalog and filter
     const catalogPath = path.join(this._workspace.cwd, "rules", "catalog.json");
@@ -294,6 +300,77 @@ export class ReleaseTool extends BaseTool {
       }
     }
 
+    // v0.8.1 P9-C: bundle verification + transactional snapshot.
+    // The manifest + README were written above. Verify they exist with
+    // substance (≥200 bytes README, valid JSON manifest with `slug` field).
+    // If verification fails, write `.failed_release` marker and skip
+    // the git-tag step — no tag-without-bundle.
+    const manifestPath = path.join(bundleAbs, "manifest.json");
+    const readmePath = path.join(bundleAbs, "README.md");
+    let verifyError = null;
+    try {
+      const mStat = fs.statSync(manifestPath);
+      const rStat = fs.statSync(readmePath);
+      if (!mStat.isFile() || mStat.size < 50) verifyError = "manifest.json missing or too small";
+      else if (!rStat.isFile() || rStat.size < 200) verifyError = "README.md missing or too small";
+      else {
+        const m = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        if (m.slug !== slug) verifyError = `manifest.slug=${m.slug} doesn't match expected ${slug}`;
+      }
+    } catch (e) {
+      verifyError = `bundle verification threw: ${e.message}`;
+    }
+
+    if (verifyError) {
+      try {
+        fs.writeFileSync(
+          path.join(bundleAbs, ".failed_release"),
+          JSON.stringify({
+            failed_at: new Date().toISOString(),
+            reason: verifyError,
+            label,
+            slug,
+          }, null, 2),
+        );
+      } catch { /* best-effort */ }
+      return new ToolResult(
+        `Release bundle verification failed (${verifyError}). NO git tag created. ` +
+        `See .failed_release marker in ${bundleRel}/ for details. Fix the bundle issue and re-run.`,
+        true,
+      );
+    }
+
+    // Bundle verified. NOW snapshot — creates the durable git tag.
+    const snapResult = await this._snapshot.execute({
+      label: `release-${slug}`,
+      notes: `Release ${label} bundle source`,
+    });
+    if (snapResult.isError) {
+      // Bundle exists but tagging failed. Surface but don't roll back —
+      // the bundle is still usable; the user can manually tag later.
+      return new ToolResult(
+        `Release '${label}' bundled at ${bundleRel} but snapshot tag FAILED: ${snapResult.content}. ` +
+        `Bundle is valid; create the snapshot tag manually if needed.`,
+      );
+    }
+    const meta = this._readSnapshotMeta(`release-${slug}`);
+    snapshotTag = meta.tag;
+    snapshotCommit = meta.commit;
+
+    // Back-fill the manifest with the now-known snapshot tag/commit.
+    try {
+      const m = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      m.snapshot_tag = snapshotTag;
+      m.snapshot_commit = snapshotCommit;
+      fs.writeFileSync(manifestPath, JSON.stringify(m, null, 2) + "\n");
+      // Also back-fill the README's snapshot placeholders if still placeholder.
+      const readme = fs.readFileSync(readmePath, "utf-8");
+      const updated = readme
+        .replace(/\(no tag — git unavailable\)/g, snapshotTag || "")
+        .replace(/\(unknown\)/g, snapshotCommit || "(unknown)");
+      if (updated !== readme) fs.writeFileSync(readmePath, updated);
+    } catch { /* best-effort back-fill */ }
+
     // Bundle dir is in output/ (gitignored). Snapshot manifest in snapshots/ IS tracked.
     const lines = [
       `Release '${label}' bundled at ${bundleRel}`,
@@ -576,10 +653,175 @@ export class ReleaseTool extends BaseTool {
       }
     }
 
+    // 3) v0.8 P0-C: production_qc_results.json + qc_results_v*.json shapes
+    // (资管 + 贷款 v0.7.5 audits both shipped empty historical_accuracy
+    // because the v0.7.2 aggregator only recognized rule_stats / full_test_results).
+    if (tally.size === 0) {
+      const qcFiles = files
+        .filter((f) =>
+          /^production_qc(?:_results)?(?:_v\d+)?\.json$/i.test(f.name) ||
+          /^qc_results(?:_v\d+)?\.json$/i.test(f.name)
+        )
+        .sort((a, b) => a.name.localeCompare(b.name));
+      for (const f of qcFiles.slice(0, 5)) {
+        try {
+          const d = JSON.parse(fs.readFileSync(f.path, "utf-8"));
+          const results = d.results;
+          if (!results) continue;
+
+          // Shape 3a (资管): nested rule-keyed map
+          //   {results: {<rid>: {<doc_id>: {verdict, ...}}}}
+          if (typeof results === "object" && !Array.isArray(results)) {
+            for (const [rid, docs] of Object.entries(results)) {
+              if (!isRuleId(rid) || !docs || typeof docs !== "object") continue;
+              for (const r of Object.values(docs)) {
+                if (!r || typeof r !== "object") continue;
+                const verdict = (r.verdict || "").toString().toUpperCase();
+                if (verdict === "PASS") bump(rid, "pass");
+                else if (verdict === "FAIL") bump(rid, "fail");
+                else if (verdict === "NOT_APPLICABLE" || verdict === "NA" || verdict === "WARNING") bump(rid, "na");
+              }
+            }
+            if (tally.size > 0) sourceFiles.push(path.relative(this._workspace.cwd, f.path));
+          }
+          // Shape 3b (贷款): per-doc rollup list with failed_rules
+          //   {results: [{filename, actual, correct, failed_rules: [...]}], total_tested: N}
+          // For each rule: failures counted from failed_rules union; passes
+          // inferred as (total_tested - failures) for rules that appear in the catalog.
+          else if (Array.isArray(results)) {
+            const catalogPath = path.join(this._workspace.cwd, "rules", "catalog.json");
+            let catalogRules = [];
+            try {
+              const cat = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+              const list = Array.isArray(cat) ? cat : Array.isArray(cat?.rules) ? cat.rules : [];
+              catalogRules = list.map((r) => r?.id || r?.rule_id).filter((x) => isRuleId(x));
+            } catch { /* catalog optional */ }
+
+            const failCountByRule = new Map();
+            let docCount = 0;
+            for (const row of results) {
+              if (!row || typeof row !== "object") continue;
+              docCount += 1;
+              const failed = Array.isArray(row.failed_rules) ? row.failed_rules : [];
+              for (const rid of failed) {
+                if (!isRuleId(rid)) continue;
+                failCountByRule.set(rid, (failCountByRule.get(rid) || 0) + 1);
+              }
+            }
+            if (docCount > 0) {
+              const ruleSet = new Set([...catalogRules, ...failCountByRule.keys()]);
+              for (const rid of ruleSet) {
+                const fails = failCountByRule.get(rid) || 0;
+                const passes = Math.max(0, docCount - fails);
+                const t = tally.get(rid) || { pass: 0, fail: 0, na: 0, n: 0 };
+                t.pass += passes; t.fail += fails; t.n += docCount;
+                tally.set(rid, t);
+              }
+              if (tally.size > 0) sourceFiles.push(path.relative(this._workspace.cwd, f.path));
+            }
+          }
+        } catch { /* try next file */ }
+        if (tally.size > 0) break;
+      }
+    }
+
+    // 4) v0.8.1 P9-A: top-level fail_by_rule + pass_by_rule maps (贷款
+    // v0.8 production_qc_report.json shape). Direct per-rule counts —
+    // no per-doc rollup, no verdict literals to scan.
+    //   {accuracy, total_checks, fail_by_rule: {<rid>: N}, pass_by_rule: {<rid>: N}}
+    if (tally.size === 0) {
+      for (const f of files) {
+        if (!/qc|prod|report|result/i.test(f.name)) continue;
+        try {
+          const d = JSON.parse(fs.readFileSync(f.path, "utf-8"));
+          const failMap = d?.fail_by_rule;
+          const passMap = d?.pass_by_rule;
+          if (
+            failMap && typeof failMap === "object" && !Array.isArray(failMap) &&
+            passMap && typeof passMap === "object" && !Array.isArray(passMap)
+          ) {
+            const allRules = new Set([...Object.keys(failMap), ...Object.keys(passMap)]);
+            let matched = false;
+            for (const rid of allRules) {
+              if (!isRuleId(rid)) continue;
+              const fails = Number(failMap[rid]) || 0;
+              const passes = Number(passMap[rid]) || 0;
+              if (fails + passes === 0) continue;
+              const t = tally.get(rid) || { pass: 0, fail: 0, na: 0, n: 0 };
+              t.pass += passes;
+              t.fail += fails;
+              t.n += passes + fails;
+              tally.set(rid, t);
+              matched = true;
+            }
+            if (matched) {
+              sourceFiles.push(path.relative(this._workspace.cwd, f.path));
+              break;
+            }
+          }
+        } catch { /* skip non-JSON */ }
+      }
+    }
+
+    // 5) 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.
+    if (tally.size === 0) {
+      for (const f of files) {
+        if (!/qc|verdict|result/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 [rid, val] of Object.entries(root)) {
+            if (!isRuleId(rid) || !val || typeof val !== "object") continue;
+            // val might be {verdict, ...} OR {<doc>: {verdict, ...}}
+            const probe = val.verdict ? [val] : Object.values(val);
+            for (const r of probe) {
+              if (!r || typeof r !== "object") continue;
+              const verdict = (r.verdict || "").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) + " (fallback shape)");
+            break;
+          }
+        } catch { /* skip non-JSON */ }
+      }
+    }
+
     if (tally.size === 0) return null;
 
+    // v0.8.1 P9-D: filter tally to rule_ids in the current catalog.
+    // E2E #11 资管 v0.8 audit: confidence_calibration aggregated from
+    // an abandoned 39-rule pipeline included only 2 of 4 final samples.
+    // Filtering to catalog.json keeps the calibration scoped to the
+    // rules that actually ship in the release.
+    let catalogRuleIds = null;
+    try {
+      const catalogPath = path.join(this._workspace.cwd, "rules", "catalog.json");
+      if (fs.existsSync(catalogPath)) {
+        const cat = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+        const list = Array.isArray(cat) ? cat : Array.isArray(cat?.rules) ? cat.rules : [];
+        catalogRuleIds = new Set(
+          list.map((r) => r?.id || r?.rule_id).filter((x) => isRuleId(x))
+        );
+        if (catalogRuleIds.size === 0) catalogRuleIds = null;
+      }
+    } catch { /* skip filter if catalog missing/malformed */ }
+
     const historical_accuracy = {};
+    const droppedRules = [];
     for (const [rid, t] of tally.entries()) {
+      if (catalogRuleIds && !catalogRuleIds.has(rid)) {
+        droppedRules.push(rid);
+        continue;
+      }
       const fired = t.pass + t.fail;
       historical_accuracy[rid] = {
         pass_rate: fired > 0 ? +(t.pass / fired).toFixed(4) : null,
@@ -593,6 +835,7 @@ export class ReleaseTool extends BaseTool {
       historical_accuracy,
       computed_at: new Date().toISOString(),
       source_files: sourceFiles,
+      ...(droppedRules.length > 0 ? { dropped_off_catalog: droppedRules } : {}),
     };
   }
 

package/src/agent/tools/sandbox-exec.js

@@ -25,16 +25,38 @@ function detectSharedFileWrites(command) {
  * Execute shell commands in the workspace directory.
  * Uses child_process.spawn so pipes, redirects, && all work.
  * Output (stdout + stderr combined) is capped at 10K chars.
+ *
+ * v0.8 P1-F timeout model:
+ *   - Default: KC_EXEC_DEFAULT_TIMEOUT_MS (env) or 120000ms (2 min)
+ *   - Hard cap: KC_EXEC_MAX_TIMEOUT_MS (env) or 600000ms (10 min)
+ *   - Per-call `timeout_ms` overrides default, clamped to [1000, max]
+ *   - Legacy `KC_EXEC_TIMEOUT` (seconds) still accepted as a deprecation
+ *     alias for the default; emits a warning to stderr on first read.
  */
 export class SandboxExecTool extends BaseTool {
   /**
    * @param {import('../workspace.js').Workspace} workspace
-   * @param {number} [timeout=30]
+   * @param {object|number} [opts] — either a config object (new) OR
+   *   a number meaning the legacy timeout-in-seconds (old). The number
+   *   form is preserved for callers that haven't been updated yet.
+   * @param {number} [opts.defaultTimeoutMs] — default 120000
+   * @param {number} [opts.maxTimeoutMs] — default 600000
    */
-  constructor(workspace, timeout = 30) {
+  constructor(workspace, opts = {}) {
     super();
     this._workspace = workspace;
-    this._timeout = timeout;
+
+    // Legacy: opts is a bare number = seconds. Convert to ms.
+    if (typeof opts === "number") {
+      this._defaultTimeoutMs = opts * 1000;
+      this._maxTimeoutMs = Math.max(this._defaultTimeoutMs, 600_000);
+    } else {
+      this._defaultTimeoutMs = opts.defaultTimeoutMs ?? 120_000;
+      this._maxTimeoutMs = opts.maxTimeoutMs ?? 600_000;
+    }
+    // Floor: keep at least 1s. Cap: max can't be below default.
+    this._defaultTimeoutMs = Math.max(1000, this._defaultTimeoutMs);
+    this._maxTimeoutMs = Math.max(this._defaultTimeoutMs, this._maxTimeoutMs);
   }
 
   get name() { return "sandbox_exec"; }
@@ -47,7 +69,10 @@ export class SandboxExecTool extends BaseTool {
       "Pipes, redirects, and chained commands (&&) are supported. " +
       "stdout + stderr combined are capped at 10,000 chars; longer output is truncated. " +
       "For reading individual files larger than ~10 KB (e.g. regulation documents), " +
-      "prefer workspace_file (operation=read) which has a larger 50 KB cap."
+      "prefer workspace_file (operation=read) which has a larger 50 KB cap. " +
+      `Default timeout ${Math.round(this._defaultTimeoutMs / 1000)}s; pass timeout_ms ` +
+      `to extend up to ${Math.round(this._maxTimeoutMs / 1000)}s for known-slow commands ` +
+      `(LLM batch processing, document parsing, large regression runs).`
     );
   }
 
@@ -64,6 +89,10 @@ export class SandboxExecTool extends BaseTool {
           enum: ["workspace", "project"],
           description: "Working directory. 'workspace' (default) = KC's workspace. 'project' = user's project directory.",
         },
+        timeout_ms: {
+          type: "integer",
+          description: `Optional per-call timeout in milliseconds. Default ${this._defaultTimeoutMs}ms; clamped to [1000, ${this._maxTimeoutMs}]. Pass for commands you expect to take longer than the default (LLM batches, parsing, regressions).`,
+        },
       },
       required: ["command"],
     };
@@ -76,6 +105,22 @@ export class SandboxExecTool extends BaseTool {
       return new ToolResult("No command provided", true);
     }
 
+    // v0.8 P1-F: per-call timeout clamping
+    let effectiveTimeoutMs = this._defaultTimeoutMs;
+    let clampedMessage = null;
+    if (Number.isFinite(input.timeout_ms) && input.timeout_ms > 0) {
+      const requested = Math.floor(input.timeout_ms);
+      if (requested < 1000) {
+        effectiveTimeoutMs = 1000;
+        clampedMessage = `timeout_ms=${requested} below 1000ms floor; using 1000ms.`;
+      } else if (requested > this._maxTimeoutMs) {
+        effectiveTimeoutMs = this._maxTimeoutMs;
+        clampedMessage = `timeout_ms=${requested} above ${this._maxTimeoutMs}ms ceiling; clamped to ${this._maxTimeoutMs}ms.`;
+      } else {
+        effectiveTimeoutMs = requested;
+      }
+    }
+
     const effectiveCwd = (cwdScope === "project" && this._workspace.projectDir)
       ? this._workspace.projectDir
       : this._workspace.cwd;
@@ -86,7 +131,7 @@ export class SandboxExecTool extends BaseTool {
     const sharedHits = detectSharedFileWrites(command);
 
     try {
-      const { output, code } = await this._run(command, effectiveCwd);
+      const { output, code } = await this._run(command, effectiveCwd, effectiveTimeoutMs);
       let result = output;
       if (result.length > MAX_OUTPUT) {
         result = result.slice(0, MAX_OUTPUT) + "\n[truncated]";
@@ -101,10 +146,20 @@ export class SandboxExecTool extends BaseTool {
           `   Under concurrent subagents this races — use workspace_file or rule_catalog instead.\n\n`;
         result = prefix + result;
       }
+      if (clampedMessage) {
+        result = `[note] ${clampedMessage}\n\n` + result;
+      }
       return new ToolResult(result, code !== 0);
     } catch (err) {
       if (err.message === "timeout") {
-        return new ToolResult(`Command timed out after ${this._timeout}s`, true);
+        const seconds = Math.round(effectiveTimeoutMs / 1000);
+        const hint = effectiveTimeoutMs < this._maxTimeoutMs
+          ? ` Pass timeout_ms (up to ${this._maxTimeoutMs}) for known-slow commands.`
+          : ` Already at max timeout (${this._maxTimeoutMs}ms); consider splitting the command into smaller batches or running it via a subagent.`;
+        return new ToolResult(
+          `Command timed out after ${seconds}s (${effectiveTimeoutMs}ms).${hint}`,
+          true,
+        );
       }
       return new ToolResult(`Execution error: ${err.message}`, true);
     }
@@ -112,9 +167,11 @@ export class SandboxExecTool extends BaseTool {
 
   /**
    * @param {string} command
+   * @param {string} cwd
+   * @param {number} timeoutMs
    * @returns {Promise<{output: string, code: number}>}
    */
-  _run(command, cwd) {
+  _run(command, cwd, timeoutMs) {
     return new Promise((resolve, reject) => {
       const controller = new AbortController();
       const proc = spawn("sh", ["-c", command], {
@@ -130,7 +187,7 @@ export class SandboxExecTool extends BaseTool {
       const timer = setTimeout(() => {
         controller.abort();
         reject(new Error("timeout"));
-      }, this._timeout * 1000);
+      }, timeoutMs);
 
       proc.on("close", (code) => {
         clearTimeout(timer);

package/src/agent/tools/worker-llm-call.js

@@ -49,7 +49,10 @@ export class WorkerLLMCallTool extends BaseTool {
     return (
       "Call a worker LLM at a specified tier (tier1-tier4) for extraction, " +
       "judgment, or other verification tasks. Tier1 is most capable/expensive, " +
-      "tier4 is cheapest. Returns response with model used and token counts."
+      "tier4 is cheapest. Pass `prompt` for a single call OR `prompts: [...]` " +
+      "for batch (parallel up to concurrency=5). Returns response(s) with " +
+      "model used and token counts. v0.8 P2-B: batch mode keeps the engine " +
+      "visible to LLM usage instead of agents bypassing via direct HTTP."
     );
   }
 
@@ -58,29 +61,105 @@ export class WorkerLLMCallTool extends BaseTool {
       type: "object",
       properties: {
         tier: { type: "string", enum: ["tier1", "tier2", "tier3", "tier4"], description: "Worker LLM tier to use" },
-        prompt: { type: "string", description: "The user/task prompt to send" },
-        system_prompt: { type: "string", description: "Optional system prompt for context" },
-        max_tokens: { type: "integer", description: "Maximum tokens in response (default 4096)" },
+        prompt: { type: "string", description: "The user/task prompt to send (single-call mode)" },
+        prompts: {
+          type: "array",
+          items: { type: "string" },
+          description: "Batch mode: array of prompts processed in parallel (up to concurrency=5). All share the same tier + system_prompt. Mutually exclusive with `prompt`.",
+        },
+        system_prompt: { type: "string", description: "Optional system prompt for context (shared across all prompts in batch mode)" },
+        max_tokens: { type: "integer", description: "Maximum tokens per response (default 4096)" },
+        concurrency: { type: "integer", description: "Batch mode only: max parallel requests (default 5, max 10)" },
       },
-      required: ["tier", "prompt"],
+      required: ["tier"],
     };
   }
 
   async execute(input) {
     const tier = input.tier || "tier2";
-    const prompt = input.prompt || "";
     const systemPrompt = input.system_prompt;
     const maxTokens = input.max_tokens || 4096;
 
-    if (!prompt) return new ToolResult("No prompt provided", true);
     if (!this._apiKey) return new ToolResult("Worker LLM API key not configured", true);
 
+    // v0.8 P2-B: batch mode dispatch
+    if (Array.isArray(input.prompts)) {
+      return this._executeBatch(input.prompts, { tier, systemPrompt, maxTokens, concurrency: input.concurrency });
+    }
+
+    const prompt = input.prompt || "";
+    if (!prompt) return new ToolResult("No prompt provided (pass `prompt` for single-call or `prompts: [...]` for batch)", true);
+
+    const result = await this._executeOne({ prompt, tier, systemPrompt, maxTokens });
+    if (result.error) return new ToolResult(result.error, true);
+    return new ToolResult(JSON.stringify(result.payload, null, 2));
+  }
+
+  /**
+   * v0.8 P2-B: process N prompts in parallel with concurrency control.
+   * Returns aggregated results as a JSON array under "results" with
+   * summary stats (total_in, total_out, n_failed). Partial failures don't
+   * fail the whole call — individual results carry their own error flag.
+   */
+  async _executeBatch(prompts, { tier, systemPrompt, maxTokens, concurrency }) {
+    if (prompts.length === 0) return new ToolResult("Empty prompts array", true);
     this._loadTiers();
     const models = this._tierModels[tier] || [];
     if (models.length === 0) {
       return new ToolResult(`No models configured for ${tier}. Check .env TIER1-TIER4 settings.`, true);
     }
 
+    const limit = Math.max(1, Math.min(10, Number.isFinite(concurrency) ? concurrency : 5));
+    const results = new Array(prompts.length);
+    let cursor = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let nFailed = 0;
+
+    const worker = async () => {
+      while (true) {
+        const idx = cursor++;
+        if (idx >= prompts.length) break;
+        const r = await this._executeOne({ prompt: prompts[idx], tier, systemPrompt, maxTokens });
+        if (r.error) {
+          results[idx] = { index: idx, error: r.error };
+          nFailed++;
+        } else {
+          results[idx] = { index: idx, ...r.payload };
+          tokensIn += r.payload.tokens_in || 0;
+          tokensOut += r.payload.tokens_out || 0;
+        }
+      }
+    };
+
+    await Promise.all(Array.from({ length: limit }, () => worker()));
+
+    const summary = {
+      n_total: prompts.length,
+      n_succeeded: prompts.length - nFailed,
+      n_failed: nFailed,
+      total_tokens_in: tokensIn,
+      total_tokens_out: tokensOut,
+      tier,
+      concurrency: limit,
+      results,
+    };
+    return new ToolResult(JSON.stringify(summary, null, 2), nFailed > 0 && nFailed === prompts.length);
+  }
+
+  /**
+   * Single-prompt path. Returns {error?: string, payload?: {...}}.
+   * Used by both single-call and batch modes; batch dedups the tier
+   * lookup and shares concurrency with multiple in-flight invocations.
+   */
+  async _executeOne({ prompt, tier, systemPrompt, maxTokens }) {
+    if (!prompt) return { error: "Empty prompt" };
+    this._loadTiers();
+    const models = this._tierModels[tier] || [];
+    if (models.length === 0) {
+      return { error: `No models configured for ${tier}. Check .env TIER1-TIER4 settings.` };
+    }
+
     const messages = [];
     if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
     messages.push({ role: "user", content: prompt });
@@ -98,14 +177,15 @@ export class WorkerLLMCallTool extends BaseTool {
         if (resp.ok) {
           const data = await resp.json();
           const usage = data.usage || {};
-          const result = {
-            response: data.choices[0].message.content,
-            model_used: model,
-            tier,
-            tokens_in: usage.prompt_tokens || 0,
-            tokens_out: usage.completion_tokens || 0,
+          return {
+            payload: {
+              response: data.choices[0].message.content,
+              model_used: model,
+              tier,
+              tokens_in: usage.prompt_tokens || 0,
+              tokens_out: usage.completion_tokens || 0,
+            },
           };
-          return new ToolResult(JSON.stringify(result, null, 2));
         }
         lastError = `${model}: HTTP ${resp.status}`;
       } catch (e) {
@@ -113,6 +193,6 @@ export class WorkerLLMCallTool extends BaseTool {
       }
     }
 
-    return new ToolResult(`All models for ${tier} failed. Last error: ${lastError}`, true);
+    return { error: `All models for ${tier} failed. Last error: ${lastError}` };
   }
 }

package/src/agent/workspace.js

@@ -170,11 +170,12 @@ export class Workspace {
    * @param {{timeoutMs?: number, retryMs?: number, staleMs?: number}} [opts]
    * @returns {Promise<T>}
    */
-  async withFileLock(relPath, fn, { timeoutMs = 10_000, retryMs = 50, staleMs = 60_000 } = {}) {
+  async withFileLock(relPath, fn, { timeoutMs = 10_000, retryMs = 50, staleMs = 60_000, eventLog = null, blockedWarnMs = 5_000 } = {}) {
     const target = this.resolvePath(relPath);
     fs.mkdirSync(path.dirname(target), { recursive: true });
     const lockPath = target + ".lock";
     const start = Date.now();
+    let blockedWarned = false;
 
     while (true) {
       let fd;
@@ -193,7 +194,24 @@ export class Workspace {
           // Lockfile vanished between EEXIST and stat — retry to acquire.
           continue;
         }
-        if (Date.now() - start > timeoutMs) {
+        // v0.8 P4-C: emit lock_blocked event once when wait crosses
+        // blockedWarnMs (default 5s). Lets parent see subagent contention
+        // before the call fails. 贷款 v0.7.5 audit: subagent burned 5 min
+        // on silent lock contention; parent only saw it as a long-running
+        // subagent. Now there's a visible signal.
+        const waited = Date.now() - start;
+        if (!blockedWarned && waited > blockedWarnMs && eventLog?.append) {
+          try {
+            eventLog.append("lock_blocked", {
+              path: relPath,
+              waited_ms: waited,
+              session_id: this.sessionId,
+              pid: process.pid,
+            });
+          } catch { /* best-effort */ }
+          blockedWarned = true;
+        }
+        if (waited > timeoutMs) {
           throw new Error(`Timeout acquiring lock on ${relPath} after ${timeoutMs}ms (held by another engine)`);
         }
         await new Promise((r) => setTimeout(r, retryMs));
@@ -221,8 +239,11 @@ export class Workspace {
    * Lets callsites uniformly wrap their writes without knowing which
    * paths are shared.
    */
-  async withSharedLockIfApplicable(relPath, fn) {
-    if (isSharedCoordinationPath(relPath)) return this.withFileLock(relPath, fn);
+  async withSharedLockIfApplicable(relPath, fn, opts = {}) {
+    // v0.8 P4-C: forward optional {eventLog, ...} through to withFileLock
+    // so lock_blocked events can fire from any call site (workspace_file,
+    // rule_catalog, etc.) once they pass their engine's eventLog.
+    if (isSharedCoordinationPath(relPath)) return this.withFileLock(relPath, fn, opts);
     return fn();
   }
 

package/src/cli/components.js

@@ -89,7 +89,7 @@ function truncateVisual(s, maxCells) {
   return head + "…" + tail;
 }
 
-export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
+export function StatusBar({ sessionId, phase, contextTokens, contextLimit, marathonActive }) {
   const samplesRef = useRef([]);
   const peakRef = useRef(0);
 
@@ -136,6 +136,9 @@ export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
     h(Text, { dimColor: true, wrap: "truncate-end" }, "  ⏵⏵  KC "),
     h(Text, { dimColor: true, wrap: "truncate-end" }, displaySessionId ? `[${displaySessionId}]` : ""),
     phase ? h(Text, { color: "cyan", wrap: "truncate-end" }, ` ${phase.toUpperCase()}`) : null,
+    // v0.8.1 P8-A: marathon-mode indicator. Only renders when active —
+    // normal interactive mode shows no indicator (avoid clutter).
+    marathonActive ? h(Text, { color: "magenta", bold: true, wrap: "truncate-end" }, "  🏃 MARATHON") : null,
     h(Text, { color: "green", wrap: "truncate-end" }, "  ●  "),
     h(Text, { color: ctxColor, wrap: "truncate-end" }, `CTX: ${ctxLabel}/${limitLabel} (${pct}%)`),
     showPeak ? h(Text, { dimColor: true, wrap: "truncate-end" }, ` · peak ${fmt(peak)}`) : null,