kc-beta 0.6.2 → 0.7.1

package/src/agent/skill-validator.js

@@ -16,12 +16,15 @@
  *    still bypasses. The validator's job is to refuse the auto-advance,
  *    not to trap the agent.
  *
- * Validation rules per `check_r###.py`:
+ * Validation rules per `check_*.py`:
  *  1. File ≥ 100 bytes (smoke test for empty stubs).
  *  2. Passes `python3 -c "import ast; ast.parse(open(F).read())"` (no
  *     syntax errors).
- *  3. Defines a function reachable by name `check_rule` or `verify`
- *     (regex match on file content).
+ *  3. Defines a function reachable by one of the names: `check_rule`,
+ *     `verify`, OR `check_r<digits>` (e.g. `check_r014`, `check_r013_r017`).
+ *     v0.7.0 A6 broadened the third pattern after E2E #5 audit found
+ *     three sessions independently chose `def check_r###` over the
+ *     canonical names — the validator was too strict.
  *
  * Disable mechanism: if `python3` is not on PATH, validator silently
  * passes everything and emits a one-time warning — we don't want the
@@ -32,7 +35,18 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
-const ENTRY_POINT_REGEX = /^\s*(?:async\s+)?def\s+(check_rule|verify)\b/m;
+// v0.7.0 A6: entry-point check is a sanity probe, not a style enforcer.
+// The validator's real signal comes from `≥ 100 bytes` + `ast.parse
+// passes`. Restricting to specific verb names rejected 27/28 GLM
+// scripts in E2E #5 — the cost outweighed the catch (every contestant
+// converged on a different naming convention).
+//
+// New rule: any top-level `def \w+(...)` counts. Rejects pure-imports
+// or comment-only stubs (which is what we actually wanted to catch),
+// accepts anything with real logic. The check_*.py *filename* (matched
+// by the path regex in `findCheckScripts`) carries the rule-id signal;
+// the function name doesn't need to.
+const ENTRY_POINT_REGEX = /^(?:async\s+)?def\s+\w+\s*\(/m;
 const MIN_BYTES = 100;
 
 export class SkillValidator {
@@ -141,7 +155,7 @@ export class SkillValidator {
     try { content = fs.readFileSync(filePath, "utf-8"); }
     catch { return { ok: false, error: "read failed after parse OK" }; }
     if (!ENTRY_POINT_REGEX.test(content)) {
-      return { ok: false, error: "no entry point: expected `def check_rule(...)` or `def verify(...)`" };
+      return { ok: false, error: "no callable defined: file has imports/comments only, no top-level `def`" };
     }
 
     return { ok: true };

package/src/agent/task-manager.js

@@ -139,12 +139,23 @@ export class TaskManager {
   // --- Bulk creation from rule catalog ---
 
   /**
-   * Phases where one-task-per-rule is the natural unit of work.
-   * For BOOTSTRAP / EXTRACTION the unit is a regulation (one PDF → many rules);
-   * ralph-loop shouldn't drive per-rule there because the rules don't exist yet
-   * (or are the *output*, not the input) — see E2E #3 coverage check.
+   * Phases where the engine auto-creates one-task-per-rule on phase entry.
+   *
+   * v0.7.0 B2: empty by default. Agent owns TaskBoard decisions per the
+   * work-decomposition meta-meta skill — engine no longer assumes per-rule
+   * granularity is right. The agent reads the rule list from describeState
+   * and calls TaskCreate with whatever shape (single, grouped, range,
+   * non-rule) makes sense for the corpus.
+   *
+   * Override `KC_AGENT_OWNS_TASKBOARD=0` to restore v0.6.x behavior
+   * (engine auto-populates per-rule for skill_authoring + skill_testing).
+   * The override is a staged-rollout safety valve, not a long-lived
+   * config — slated for removal in v0.8.0 after E2E #6 validates the
+   * agent-owned default.
    */
-  static PER_RULE_PHASES = new Set(["skill_authoring", "skill_testing"]);
+  static PER_RULE_PHASES = (process.env.KC_AGENT_OWNS_TASKBOARD === "0")
+    ? new Set(["skill_authoring", "skill_testing"])
+    : new Set();
 
   /**
    * Create one task per rule for a given phase — but only if the phase's unit
@@ -197,6 +208,51 @@ export class TaskManager {
     ).length;
   }
 
+  /**
+   * v0.7.0 A5: Reconcile per-rule tasks against disk artifacts.
+   *
+   * Background: E2E #5 DS audit found tasks.json showing 70/70 completed
+   * while only ~56 dirs / 36 with check_*.py existed on disk. The agent
+   * called markDone() optimistically but the artifacts didn't materialize
+   * (or were deleted later). The engine's phase gate trusted the count.
+   *
+   * Reconcile walks every "completed" task in PER_RULE_PHASES and checks
+   * whether the expected disk artifacts exist via a caller-supplied
+   * `expectsFn(task) -> boolean` predicate. Tasks whose artifacts are
+   * missing are flipped back to `pending` with a `reconcile_failed`
+   * note so the agent can re-do the work, and the gate can refuse
+   * advance if the per-rule artifact set is incomplete.
+   *
+   * Called from engine `_advancePhase` before `exitCriteriaMet()`.
+   *
+   * @param {(task: object) => boolean} expectsFn
+   * @returns {{ reconciled: number, flippedBack: string[] }}
+   *   Number of tasks inspected, plus the IDs of tasks flipped back to
+   *   pending. Caller logs to events.jsonl.
+   */
+  reconcileAgainstDisk(expectsFn) {
+    let reconciled = 0;
+    const flippedBack = [];
+    if (typeof expectsFn !== "function") return { reconciled, flippedBack };
+    for (const task of this._tasks) {
+      if (task.status !== "completed") continue;
+      if (!TaskManager.PER_RULE_PHASES.has(task.phase)) continue;
+      reconciled++;
+      let ok = false;
+      try { ok = !!expectsFn(task); }
+      catch { ok = false; }
+      if (!ok) {
+        task.status = "pending";
+        task.reconcile_failed = true;
+        task.summary = (task.summary ? task.summary + " | " : "") +
+          "v0.7.0 A5: artifacts missing on disk → flipped back to pending";
+        flippedBack.push(task.id);
+      }
+    }
+    if (flippedBack.length > 0) this.save();
+    return { reconciled, flippedBack };
+  }
+
   /**
    * Format task list for injection into system prompt context.
    * Compact checklist — not conversation history.

package/src/agent/tools/document-chunk.js

@@ -194,20 +194,32 @@ export class DocumentChunkTool extends BaseTool {
       };
     }
 
-    // For other formats (.docx, .xlsx, etc): read as UTF-8 best-effort.
-    // Upstream agent should call document_parse first and then document_chunk
-    // on the parsed output directly — current MVP keeps the tool surface small.
+    // v0.7.0 G (#91): route .docx / .doc / others through native parser
+    // dispatcher (mammoth / word-extractor / LibreOffice fallback).
+    // Replaces the prior "read as UTF-8" stub which produced binary
+    // garbage on .docx and forced agents to call document_parse + chunk
+    // separately. extractText() returns clean text or a structured
+    // failure that downstream can surface to the agent.
     try {
-      const txt = fs.readFileSync(absPath, "utf-8");
+      const { extractText } = await import("../document-parser.js");
+      const result = await extractText(absPath);
+      if (result.ok && result.text) {
+        return {
+          source_file: baseName,
+          total_pages: 1,
+          blocks: [{ page: 1, markdown: result.text }],
+          parse_via: result.via,
+        };
+      }
       return {
-        source_file: baseName,
-        total_pages: 1,
-        blocks: [{ page: 1, markdown: txt }],
+        source_file: baseName, total_pages: 0, blocks: [],
+        parse_error: result.error ||
+          `Unsupported format '${suffix}'. Install mammoth / word-extractor or rely on LibreOffice fallback.`,
       };
-    } catch {
+    } catch (e) {
       return {
         source_file: baseName, total_pages: 0, blocks: [],
-        parse_error: `Unsupported format '${suffix}'. Run document_parse first and use its output, or stick to .pdf / .md / .txt.`,
+        parse_error: `parse exception: ${e?.message || String(e)}`,
       };
     }
   }

package/src/agent/tools/phase-advance.js

@@ -15,7 +15,11 @@ const VALID_PHASES = new Set(Object.values(Phase));
  */
 export class PhaseAdvanceTool extends BaseTool {
   /**
-   * @param {(to: string, reason: string, opts: {force?: boolean}) => boolean} advanceFn
+   * @param {(to: string, reason: string, opts: {force?: boolean}) => {advanced: boolean, engineCounts?: string}} advanceFn
+   *   v0.7.1 2c: returns the rich object so the tool can surface engine
+   *   telemetry in the refusal text. Internal engine callers of
+   *   `_advancePhase` still get the bool; only this LLM-facing tool
+   *   uses the wrapped form.
    * @param {() => string} getCurrentPhaseFn - H1: lets the tool read the
    *   engine's phase BEFORE the call, so it can distinguish "already there"
    *   (silent no-op, informational) from "non-adjacent refusal" (actionable).
@@ -91,7 +95,11 @@ export class PhaseAdvanceTool extends BaseTool {
       );
     }
 
-    const advanced = this._advance(to, input.reason || "agent request", { force: !!input.force });
+    // v0.7.1 2c: advanceFn returns {advanced, engineCounts?} so we can
+    // surface telemetry in the refusal text below. Internal callers of
+    // _advancePhase still get bool; only this LLM-facing tool unwraps.
+    const advanceResult = this._advance(to, input.reason || "agent request", { force: !!input.force });
+    const advanced = !!advanceResult?.advanced;
     if (advanced) {
       // Log the ack so post-mortems can find phase advances that proceeded
       // with live subagents
@@ -104,10 +112,34 @@ export class PhaseAdvanceTool extends BaseTool {
       return new ToolResult(`Advanced${beforePhase ? ` from ${beforePhase}` : ""} to ${to}${input.force ? " (forced)" : ""}`);
     }
 
-    // Truly refused — non-adjacent transition without force, or terminal-phase
-    // forward attempt. Give the actionable hint.
+    // Truly refused — possible reasons: non-adjacent transition,
+    // terminal-phase forward attempt, or hard-tracking gate (source phase's
+    // exit criteria not met by engine telemetry).
+    //
+    // v0.7.0 A3: refusal text no longer advertises `force:true`. E2E #5
+    // showed every conductor reading the old refusal hint and force-bypassing
+    // immediately (12/12 transitions). The escape valve remains in the input
+    // schema (discoverable) but isn't hand-fed to the LLM here. Instead,
+    // direct the agent at the missing milestones it can satisfy.
+    //
+    // v0.7.1 2c: include engineCounts when available so the agent sees
+    // exactly which milestones the gate is reading and can satisfy them.
+    // E2E #6 v070 showed the generic "check /status" hint wasn't concrete
+    // enough — agents forced through. Naming the gap inline reduces that.
+    const engineCountsLine = advanceResult?.engineCounts
+      ? `\nEngine telemetry: ${advanceResult.engineCounts}`
+      : "";
+
     return new ToolResult(
-      `Did not advance to ${to}. Transition is non-adjacent${beforePhase ? ` (currently in ${beforePhase})` : ""} — set force:true to override, or advance to the immediate-next phase first.`,
+      `Did not advance to ${to} (currently in ${beforePhase || "?"}). ` +
+      `Likely cause: source-phase exit criteria not met.${engineCountsLine}\n\n` +
+      `Run /status (or read the phase describeState block in this turn's system reminder) ` +
+      `to see which milestones are missing, then produce the disk artifacts that satisfy them — ` +
+      `the engine derives milestones from filesystem facts (rule_skills/<id>/SKILL.md, check.py, ` +
+      `workflows/<id>/*.py, output/results/*.json, etc.). ` +
+      `If the transition is non-adjacent or this phase truly is done despite the gate, ` +
+      `re-call with the documented schema flag. The engine logged the precise reason in ` +
+      `events.jsonl as 'phase_advance_refused'.`,
       false,
     );
   }

package/src/agent/tools/release.js

@@ -151,8 +151,23 @@ export class ReleaseTool extends BaseTool {
     }
 
     if (ruleEntries.length === 0) {
+      // v0.7.0 #98: actionable error. The previous "no workflows found
+      // for any selected rule" message left agents confused (E2E #5 GLM
+      // dismissed it with "不影响系统功能" and shipped anyway, with a
+      // broken bundle). Spell out the canonical layout, the accepted
+      // alternatives, and where the agent's actual files are.
       return new ToolResult(
-        `no workflows found for any selected rule. Missing: ${missingWorkflows.join(", ")}`,
+        `Release tool found no workflows for the selected rules.\n\n` +
+        `Missing: ${missingWorkflows.slice(0, 10).join(", ")}` +
+        (missingWorkflows.length > 10 ? ` (+ ${missingWorkflows.length - 10} more)` : "") + "\n\n" +
+        `Accepted layouts (release tool checks all three):\n` +
+        `  workflows/<ruleId>/workflow_v1.py    (canonical)\n` +
+        `  workflows/<ruleId>_workflow.py       (flat)\n` +
+        `  workflows/<ruleId>.json              (regex_skill manifest with .entry path)\n\n` +
+        `If your workflow files exist under a different layout, either ` +
+        `relocate them or write a workflows/<ruleId>.json manifest pointing ` +
+        `at the actual file. Do NOT ship the release without workflows — ` +
+        `the run.py harness needs them at runtime.`,
         true,
       );
     }
@@ -251,15 +266,42 @@ export class ReleaseTool extends BaseTool {
   }
 
   _findLatestWorkflow(ruleId) {
+    // Canonical: workflows/<ruleId>/workflow_v#.py (subdirectory layout)
     const wfDir = path.join(this._workspace.cwd, "workflows", ruleId);
-    if (!fs.existsSync(wfDir) || !fs.statSync(wfDir).isDirectory()) return null;
-    const entries = fs.readdirSync(wfDir).sort();
-    const versioned = entries.filter((f) => /^workflow_v\d+\.py$/.test(f));
-    if (versioned.length > 0) return path.join(wfDir, versioned[versioned.length - 1]);
-    const any = entries.find((f) => f.endsWith(".py") && f.toLowerCase().includes("workflow"));
-    if (any) return path.join(wfDir, any);
-    const py = entries.find((f) => f.endsWith(".py"));
-    return py ? path.join(wfDir, py) : null;
+    if (fs.existsSync(wfDir) && fs.statSync(wfDir).isDirectory()) {
+      const entries = fs.readdirSync(wfDir).sort();
+      const versioned = entries.filter((f) => /^workflow_v\d+\.py$/.test(f));
+      if (versioned.length > 0) return path.join(wfDir, versioned[versioned.length - 1]);
+      const any = entries.find((f) => f.endsWith(".py") && f.toLowerCase().includes("workflow"));
+      if (any) return path.join(wfDir, any);
+      const py = entries.find((f) => f.endsWith(".py"));
+      if (py) return path.join(wfDir, py);
+    }
+
+    // v0.7.0 #98: fall back to flat layouts seen in E2E #5 — both DS
+    // and GLM produced workflows that release.js's strict per-dir check
+    // missed. Accept these so the release tool actually packages the
+    // agent's work instead of returning "no workflows found".
+    const flatRoot = path.join(this._workspace.cwd, "workflows");
+    if (fs.existsSync(flatRoot)) {
+      // GLM-style flat: workflows/R001_workflow.py
+      const flat = path.join(flatRoot, `${ruleId}_workflow.py`);
+      if (fs.existsSync(flat) && fs.statSync(flat).isFile()) return flat;
+      // DS-style manifest: workflows/R001.json (regex_skill pointer)
+      const manifest = path.join(flatRoot, `${ruleId}.json`);
+      if (fs.existsSync(manifest) && fs.statSync(manifest).isFile()) {
+        try {
+          const data = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+          if (data?.entry) {
+            const entryPath = path.isAbsolute(data.entry)
+              ? data.entry
+              : path.join(this._workspace.cwd, data.entry);
+            if (fs.existsSync(entryPath)) return entryPath;
+          }
+        } catch { /* manifest unreadable; skip */ }
+      }
+    }
+    return null;
   }
 
   _resolveFixture(rel) {

package/src/agent/tools/rule-catalog.js

@@ -56,7 +56,17 @@ export class RuleCatalogTool extends BaseTool {
   constructor(workspace) {
     super();
     this._workspace = workspace;
-    this._catalogPath = path.join(workspace.cwd, "rules", "catalog.json");
+    // v0.6.3: do NOT cache the absolute path here. engine.renameSession()
+    // moves the workspace dir via fs.renameSync and updates this._workspace.cwd
+    // via Workspace.rename(), but tool instances live in the registry and
+    // never see the cascade — a cached _catalogPath would keep writing to the
+    // pre-rename absolute path, mkdir-recreating the orphaned directory and
+    // stranding all rule_catalog state. Resolve on every call instead.
+  }
+
+  /** Always read workspace.cwd at call time so /rename is followed. */
+  get _catalogPath() {
+    return path.join(this._workspace.cwd, "rules", "catalog.json");
   }
 
   get name() { return "rule_catalog"; }

package/src/agent/tools/workspace-file.js

@@ -113,6 +113,37 @@ export class WorkspaceFileTool extends BaseTool {
     }
     const resolved = this._resolveForScope(filePath, scope);
     fs.mkdirSync(path.dirname(resolved), { recursive: true });
+
+    // v0.7.0 Group M (#84 remainder): on case-insensitive filesystems
+    // (macOS/Windows defaults), warn when the target's basename collides
+    // with an existing sibling differing only in case. Write proceeds
+    // — agents may legitimately overwrite — but the agent gets visible
+    // signal so it doesn't end up confused like E2E #5 GLM ("SKILL.md
+    // disappeared" when the inode was shared with skill.md). Workspace-
+    // scope only; project-dir scope is the user's territory.
+    let collisionNote = "";
+    if (
+      scope === "workspace" &&
+      this._workspace.fsCaseSensitive === false
+    ) {
+      try {
+        const parent = path.dirname(resolved);
+        const targetBase = path.basename(resolved);
+        const targetLower = targetBase.toLowerCase();
+        const siblings = fs.readdirSync(parent);
+        const collision = siblings.find(
+          (s) => s !== targetBase && s.toLowerCase() === targetLower,
+        );
+        if (collision) {
+          collisionNote =
+            ` ⚠ case-collision: case-insensitive filesystem already has '${collision}'` +
+            ` at this path; both names resolve to the same inode. Pick one canonical case` +
+            ` (lowercase preferred for skill files) and use it consistently — otherwise` +
+            ` archive_file / Read on either name affects the other.`;
+        }
+      } catch { /* readdirSync may fail on a fresh dir; that's fine, no collision possible */ }
+    }
+
     fs.writeFileSync(resolved, content, "utf-8");
 
     // Auto-commit to git for workspace writes (silently no-ops if gitignored or git unavailable)
@@ -124,6 +155,7 @@ export class WorkspaceFileTool extends BaseTool {
     const label = scope === "project" ? `[project] ${filePath}` : filePath;
     let msg = `Wrote ${content.length} chars to ${label}`;
     if (traceId) msg += ` [trace: ${traceId}]`;
+    if (collisionNote) msg += collisionNote;
     return new ToolResult(msg);
   }
 

package/src/agent/workspace.js

@@ -62,6 +62,38 @@ export class Workspace {
     this._gitAutoCommitEnabled = opts.gitAutoCommit !== false;
     this._gitAvailable = this._gitAutoCommitEnabled && Workspace.isGitInstalled();
     if (this._gitAvailable) this._initGitRepo();
+
+    // v0.7.0 F1: detect filesystem case-sensitivity once at construction.
+    // macOS HFS+/APFS default + Windows NTFS default are case-insensitive
+    // — `SKILL.md` and `skill.md` resolve to the same inode. E2E #5 GLM
+    // hit this exactly: wrote skill.md, then SKILL.md (overwrote it),
+    // then archive_file moved skill.md (moved both since same inode),
+    // then agent saw "SKILL.md disappeared". Surfacing the FS property
+    // here lets tools warn on case-collision attempts.
+    this.fsCaseSensitive = Workspace._probeCaseSensitivity(this.path);
+  }
+
+  /**
+   * v0.7.0 F1: cheap probe — write a known-case marker, stat its
+   * lowercased twin. If the stat succeeds, the FS folded the case →
+   * case-insensitive. Probe runs once per session at construction.
+   * Marker is deleted regardless. Returns true on case-sensitive (Linux
+   * default), false on case-insensitive (macOS/Windows defaults).
+   */
+  static _probeCaseSensitivity(dir) {
+    const probe = path.join(dir, ".kc-case-probe-MIXED");
+    const twin = path.join(dir, ".kc-case-probe-mixed");
+    try {
+      fs.writeFileSync(probe, "");
+      const sensitive = !fs.existsSync(twin);
+      try { fs.unlinkSync(probe); } catch { /* ignore */ }
+      return sensitive;
+    } catch {
+      // Couldn't probe (permission?); assume sensitive (Linux default)
+      // since false-positive on macOS doesn't break correctness, just
+      // misses the warning opportunity.
+      return true;
+    }
   }
 
   /** @returns {string} Current workspace directory */
@@ -249,7 +281,13 @@ export class Workspace {
    * `withFileLock` (async) for all paths that allow it.
    */
   withSyncFileLock(relPath, fn, { timeoutMs = 5_000, staleMs = 30_000 } = {}) {
-    const lockPath = path.join(this.path, `${relPath}.lock`);
+    // v0.7.0 H3: route through resolvePath() so a caller passing
+    // "../../shared.json" can't write a lockfile outside the workspace
+    // root (the async sibling withFileLock already does this — sync
+    // version was the asymmetric weak spot). Cross-session lock-file
+    // contamination shut down.
+    const resolved = this.resolvePath(relPath);
+    const lockPath = `${resolved}.lock`;
     return this._withSyncLockAtPath(lockPath, fn, { timeoutMs, staleMs });
   }
 

package/src/cli/components.js

@@ -52,19 +52,64 @@ const LENAT_QUOTE = "Intelligence is ten million rules.";
 // display jumpy. Peak stays at the highest seen this session.
 const CTX_SAMPLE_WINDOW = 30;
 
+// Visual width of a string with CJK chars counted as 2 cells each.
+// Used to truncate session IDs etc. so the status bar fits in a single
+// terminal row regardless of terminal width.
+function visualWidth(s) {
+  let w = 0;
+  for (const ch of s || "") {
+    const cp = ch.codePointAt(0);
+    // CJK + fullwidth + emoji rough heuristic — wide if codepoint ≥ 0x1100.
+    w += cp >= 0x1100 ? 2 : 1;
+  }
+  return w;
+}
+
+function truncateVisual(s, maxCells) {
+  if (!s) return s;
+  if (visualWidth(s) <= maxCells) return s;
+  // Middle-truncate so renamed sessions keep both ends visible
+  // (e.g. "资管新规测试062-GLM" → "资管新规…2-GLM" — model suffix preserved).
+  const headBudget = Math.floor((maxCells - 1) / 2);
+  const tailBudget = maxCells - 1 - headBudget;
+  const chars = [...s];
+  let w = 0; let head = "";
+  for (const ch of chars) {
+    const cw = ch.codePointAt(0) >= 0x1100 ? 2 : 1;
+    if (w + cw > headBudget) break;
+    w += cw; head += ch;
+  }
+  let tw = 0; let tail = "";
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const ch = chars[i];
+    const cw = ch.codePointAt(0) >= 0x1100 ? 2 : 1;
+    if (tw + cw > tailBudget) break;
+    tw += cw; tail = ch + tail;
+  }
+  return head + "…" + tail;
+}
+
 export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
   const samplesRef = useRef([]);
   const peakRef = useRef(0);
 
-  // Push current sample + cap the ring
+  // v0.7.0 C3: ref mutations live inside useEffect, not in the render
+  // body. React may invoke renders multiple times (StrictMode, concurrent
+  // rendering, suspense replay); mutating refs inline duplicated the
+  // pushed sample on every replay and let peak drift higher than the
+  // real history. Effect runs once per commit.
+  useEffect(() => {
+    const samples = samplesRef.current;
+    samples.push(contextTokens || 0);
+    if (samples.length > CTX_SAMPLE_WINDOW) samples.shift();
+    if ((contextTokens || 0) > peakRef.current) peakRef.current = contextTokens || 0;
+  }, [contextTokens]);
+
   const samples = samplesRef.current;
-  samples.push(contextTokens || 0);
-  if (samples.length > CTX_SAMPLE_WINDOW) samples.shift();
   const smoothed = samples.length > 0
     ? Math.round(samples.reduce((a, b) => a + b, 0) / samples.length)
-    : 0;
-  if ((contextTokens || 0) > peakRef.current) peakRef.current = contextTokens || 0;
-  const peak = peakRef.current;
+    : (contextTokens || 0);
+  const peak = Math.max(peakRef.current, contextTokens || 0);
 
   const pct = contextLimit ? Math.round((smoothed / contextLimit) * 100) : 0;
   const ctxColor = pct > 80 ? "red" : pct > 60 ? "yellow" : "green";
@@ -83,15 +128,19 @@ export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
                      : pct >= 60 ? "  · 💾 建议 /compact"
                      : "";
 
+  // Truncate session ID to keep the bar single-row even with CJK names.
+  // 14 visual cells covers most short UUIDs and ~6-7 CJK chars.
+  const displaySessionId = sessionId ? truncateVisual(sessionId, 14) : "";
+
   return h(Box, { marginTop: 0 },
-    h(Text, { dimColor: true }, "  ⏵⏵  KC Agent CLI "),
-    h(Text, { dimColor: true }, sessionId ? `[${sessionId}]` : ""),
-    phase ? h(Text, { color: "cyan" }, ` ${phase.toUpperCase()}`) : null,
-    h(Text, { color: "green" }, "  ●  "),
-    h(Text, { color: ctxColor }, `CTX: ${ctxLabel}/${limitLabel} (${pct}%)`),
-    showPeak ? h(Text, { dimColor: true }, ` · peak ${fmt(peak)}`) : null,
-    compactHint ? h(Text, { color: ctxColor }, compactHint) : null,
-    h(Text, { dimColor: true }, `  · ${LENAT_QUOTE}`),
+    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,
+    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,
+    compactHint ? h(Text, { color: ctxColor, wrap: "truncate-end" }, compactHint) : null,
+    h(Text, { dimColor: true, wrap: "truncate-end" }, `  · ${LENAT_QUOTE}`),
   );
 }
 
@@ -161,6 +210,7 @@ export function WelcomeBanner({ projectDir, pendingInputCount = 0 } = {}) {
       "   rules/02 as core; rules/03-10 are supporting context only.\""),
     h(Text, null, ""),
     h(Text, { dimColor: true }, "Product of Memium / kitchen-engineer42"),
+    h(Text, { dimColor: true }, "PolyForm Noncommercial 1.0.0 — commercial use requires a separate license. See LICENSE-COMMERCIAL.md."),
   );
 }