moflo 4.12.9 → 4.12.10

package/.claude/guidance/shipped/moflo-yaml-reference.md

@@ -103,6 +103,7 @@ status_line:
   show_model: true                # Current model name
   show_session: true              # Session duration
   show_intelligence: true         # Intelligence % indicator
+  show_context: true              # Context-window % used; hides until Claude Code reports it
   show_swarm: true                # Active swarm agents count
   show_hooks: true                # Enabled hooks count
   show_mcp: true                  # MCP server count

package/.claude/helpers/gate.cjs

@@ -240,10 +240,11 @@ function isEphemeralPath(fp) {
 }
 // #1171 — DANGEROUS gained PowerShell additions to match the matcher widening
 // that now routes the dedicated `PowerShell` tool through check-dangerous-command.
-// POSIX entries still apply because PS will execute them when invoked. Substring
-// match (case-insensitive) inside the gate.
+// POSIX entries still apply because PS will execute them when invoked. Matched
+// case-insensitively by `matchesDangerous` below — substring for most entries,
+// root-anchored for the ones that end at a filesystem root.
 var DANGEROUS = [
-  'rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:', 'mkfs.', '> /dev/sda',
+  'rm -rf /', 'rm -rf ~', 'format c:', 'del /s /q c:\\', ':(){:|:&};:', 'mkfs.', '> /dev/sda',
   // PowerShell destructive patterns. Won't catch every adversarial spelling
   // (PS aliases let `ri -r -force C:\` mean the same thing) but covers the
   // common-typo destruction class — symmetric to the POSIX list's intent.
@@ -254,6 +255,74 @@ var DANGEROUS = [
   'clear-disk',
 ];
 
+// #1449 — the entries above that END at a filesystem root are also a PREFIX of
+// every absolute path beneath it, so plain substring matching blocked routine
+// cleanup: `rm -rf /tmp/scratch` reported as `rm -rf /`. Those entries must
+// match ON the root rather than at the head of a longer path.
+//
+// WHICH entries those are is derived, not listed: a pattern is root-shaped iff
+// it ends at a root — a separator or `~`. That selects `rm -rf /`, `rm -rf ~`,
+// `del /s /q c:\` and the three `remove-item` forms, and leaves `format c:`,
+// `mkfs.`, `> /dev/sda`, `format-volume` and `clear-disk` on plain substring
+// matching, where trailing text is still the same dangerous command. Deriving
+// it rather than keeping a parallel list means a future root-shaped addition to
+// DANGEROUS is anchored automatically instead of silently falling back to the
+// prefix bug this fixes.
+//
+// `rm -rf ~` joins DANGEROUS with this change: it was never listed, so wiping a
+// home directory was allowed outright while cleaning a subdirectory of one was
+// blocked. Anchoring is what makes the entry safe to add.
+function endsAtRoot(pat) {
+  var last = pat.charAt(pat.length - 1);
+  return last === '/' || last === '\\' || last === '~';
+}
+// What may legally follow a root target: nothing, whitespace, a glob (`rm -rf /*`
+// still blocks), a shell operator, or a closing quote/paren. A path character —
+// letter, digit, `-`, `_` — means another segment follows, i.e. routine cleanup
+// of something below root. Rule #1: pure string logic, no platform branch; both
+// separators are handled for every OS's spelling.
+var ROOT_BOUNDARY_RE = /[\s;&|)"'`*<>]/;
+function isRootBoundary(cmd, i) {
+  if (i >= cmd.length) return true;
+  var c = cmd.charAt(i);
+  return c === '/' || c === '\\' || ROOT_BOUNDARY_RE.test(c);
+}
+
+/**
+ * Advance past text that does not move OFF the root: repeated separators, and
+ * `.` / `..` segments, which resolve back to where they started. `rm -rf //`,
+ * `rm -rf /.` and `rm -rf /..` all still mean `rm -rf /` and must block, while
+ * `rm -rf //tmp/x` and `rm -rf /.config` are real paths below root and must not.
+ * Without the dot handling the anchoring would OPEN a hole the substring match
+ * did not have — `.` is not a boundary character, so `rm -rf /.` would read as
+ * "a longer path follows" and pass.
+ */
+function skipToRootEnd(cmd, i) {
+  for (;;) {
+    var start = i;
+    while (i < cmd.length && (cmd.charAt(i) === '/' || cmd.charAt(i) === '\\')) i++;
+    var dots = 0;
+    while (cmd.charAt(i + dots) === '.') dots++;
+    // Only a BARE `.` or `..` segment is a no-op; `.config` and `..foo` are names.
+    if ((dots === 1 || dots === 2) && isRootBoundary(cmd, i + dots)) i += dots;
+    if (i === start) return i;
+  }
+}
+
+/**
+ * True when `pat` occurs in `cmd` as a real dangerous command. Root-shaped
+ * patterns must land on the root; every occurrence is examined, so a safe
+ * leading match (`rm -rf /tmp/a && rm -rf /`) never masks a later real one.
+ */
+function matchesDangerous(cmd, pat) {
+  if (!endsAtRoot(pat)) return cmd.indexOf(pat) >= 0;
+  for (var at = cmd.indexOf(pat); at >= 0; at = cmd.indexOf(pat, at + 1)) {
+    var end = skipToRootEnd(cmd, at + pat.length);
+    if (end >= cmd.length || ROOT_BOUNDARY_RE.test(cmd.charAt(end))) return true;
+  }
+  return false;
+}
+
 // #1132 — Bash memory-first gate.
 //
 // CREDIT: marks the gate satisfied when Claude invokes a memory-search CLI
@@ -1191,11 +1260,32 @@ function isPrCreateCommand(cmd) {
 // Fail-safe: any error (no classifier, no git, no merge-base) returns null,
 // which forces /simplify to run as today.
 function classifyForGateSkip(state) {
-  var classify;
+  var mod;
   try {
-    classify = require('./simplify-classify.cjs').classifyDiff;
+    mod = require('./simplify-classify.cjs');
   } catch (e) { return null; }
-  if (typeof classify !== 'function') return null;
+  var classify = mod && mod.classifyDiff;
+  var readUntracked = mod && mod.readUntrackedDiff;
+  // EXEC_MAX_BUFFER is checked alongside the functions because falling back to
+  // Node's 1 MiB default would silently reinstate the very cliff #1451 removed.
+  if (typeof classify !== 'function' || typeof readUntracked !== 'function'
+      || typeof mod.EXEC_MAX_BUFFER !== 'number') return null;
+
+  // Untracked files show up in no `git diff` output, so without them the gate
+  // could auto-pass a branch of brand-new unstaged files as TRIVIAL (#1451).
+  // Reading every one of them is real work, so it is deferred until a path is
+  // actually about to classify. Returns null if the read failed — the caller
+  // must then fall through and force /simplify rather than classify a partial
+  // diff.
+  var untrackedText = null;
+  function untrackedSuffix() {
+    if (untrackedText !== null) return untrackedText;
+    var u;
+    try { u = readUntracked(PROJECT_DIR); } catch (e) { return null; }
+    if (!u || u.unreadable) return null;
+    untrackedText = u.text ? '\n' + u.text : '';
+    return untrackedText;
+  }
 
   function tryClassify(diffText, label, allowSmallReviewFix) {
     try {
@@ -1219,11 +1309,16 @@ function classifyForGateSkip(state) {
     return null;
   }
 
+  // maxBuffer comes FROM the classifier (#1451) rather than being a matching
+  // literal here, so the gate and the skill cannot drift on which diffs are
+  // readable at all. Past it execFileSync throws ENOBUFS and gitDiff returns
+  // null — which every caller below must treat as "unknown", never "empty".
+  var maxBuffer = mod.EXEC_MAX_BUFFER;
   function gitDiff(args) {
     try {
       return cp.execFileSync('git', args, {
         cwd: PROJECT_DIR, encoding: 'utf-8', timeout: 5000, windowsHide: true,
-        stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 8 * 1024 * 1024
+        stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: maxBuffer
       });
     } catch (e) { return null; }
   }
@@ -1231,9 +1326,14 @@ function classifyForGateSkip(state) {
   // Snapshot path: classify everything since /simplify last ran.
   if (state.simplifySnapshotSha) {
     var snapDiff = gitDiff(['diff', state.simplifySnapshotSha + '...HEAD']);
-    var workTreeA = gitDiff(['diff', 'HEAD']) || '';
-    if (snapDiff !== null) {
-      var combined = snapDiff + (workTreeA ? '\n' + workTreeA : '');
+    var workTreeA = gitDiff(['diff', 'HEAD']);
+    // BOTH reads must succeed. Coalescing a failed working-tree read to '' is
+    // how an over-buffer working tree used to read as "no working-tree changes"
+    // and let the gate skip review (#1451).
+    if (snapDiff !== null && workTreeA !== null) {
+      var suffixA = untrackedSuffix();
+      if (suffixA === null) return null;
+      var combined = snapDiff + (workTreeA ? '\n' + workTreeA : '') + suffixA;
       // Snapshot path: allow SMALL review-fix shape because the original /simplify
       // already covered the surface and only tiny no-decl-touching tweaks followed.
       var hit = tryClassify(combined, 'delta since last /simplify', true);
@@ -1253,9 +1353,11 @@ function classifyForGateSkip(state) {
     } catch (e) { continue; }
     if (!base) continue;
     var branchDiff = gitDiff(['diff', base + '...HEAD']);
-    var workTreeB = gitDiff(['diff', 'HEAD']) || '';
-    if (branchDiff !== null) {
-      return tryClassify(branchDiff + (workTreeB ? '\n' + workTreeB : ''), 'branch diff');
+    var workTreeB = gitDiff(['diff', 'HEAD']);
+    if (branchDiff !== null && workTreeB !== null) {
+      var suffixB = untrackedSuffix();
+      if (suffixB === null) return null;
+      return tryClassify(branchDiff + (workTreeB ? '\n' + workTreeB : '') + suffixB, 'branch diff');
     }
     break;
   }
@@ -2110,7 +2212,7 @@ switch (command) {
     var raw = process.env.TOOL_INPUT_command || '';
     var cmd = stripQuotedAndHeredocs(raw).toLowerCase();
     for (var i = 0; i < DANGEROUS.length; i++) {
-      if (cmd.indexOf(DANGEROUS[i]) >= 0) {
+      if (matchesDangerous(cmd, DANGEROUS[i])) {
         console.log('[BLOCKED] Dangerous command: ' + DANGEROUS[i]);
         process.exit(2);
       }

package/.claude/helpers/simplify-classify.cjs

@@ -31,6 +31,14 @@
  *     "stats": { added, deleted, fileCount, declAdded, declRemoved, tsjsLOC, tsjsNetDecls, otherNetAdded, ... }
  *   }
  *
+ * The diff it measures spans committed-since-base, working-tree, AND untracked
+ * non-ignored files — an untracked file is a change the branch will carry, and
+ * omitting it undercounts the diff exactly as a swallowed read error does.
+ * When a read it needed did not happen, `stats.diffUnavailable` is set and the
+ * decision routes to a review tier: the classifier cannot distinguish "no
+ * changes" from "I could not read the changes", and only the first is safe to
+ * call TRIVIAL (#1451).
+ *
  * Usage:
  *   node bin/simplify-classify.cjs                  # auto-detects default branch
  *   node bin/simplify-classify.cjs --base develop   # explicit override
@@ -42,6 +50,27 @@
 'use strict';
 
 const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// execSync defaults to a 1 MiB stdout buffer and a real branch diff clears that
+// routinely (#1451 measured 2,113,712 bytes). Overflow throws ENOBUFS, which
+// used to be swallowed into an empty diff — "TRIVIAL, nothing to review" on a
+// branch with plenty to review. 64 MiB puts the cliff well past any diff a
+// human opens a PR for; past it, the classifier now says so instead of
+// reporting zero.
+const EXEC_MAX_BUFFER = 64 * 1024 * 1024;
+
+// Cap on how much of an untracked file is slurped to synthesize its new-file
+// diff. Well past any hand-written source file; anything larger is treated like
+// a binary (counted as a new file with no added lines) rather than read.
+const UNTRACKED_MAX_BYTES = 8 * 1024 * 1024;
+
+// Total budget for synthesized untracked-file content. A repo with a huge
+// un-ignored directory must not be slurped into memory wholesale — past this
+// the remaining files are recorded as new files and the result is flagged
+// unmeasurable, which forces review rather than quietly undercounting.
+const UNTRACKED_TOTAL_BUDGET = 32 * 1024 * 1024;
 
 // Paths where new logic warrants the 3-agent fan-out.
 // Mechanical edits inside these paths are still SMALL; only adding/removing
@@ -98,14 +127,43 @@ function noEscalate() {
   return { suggested: false, target: null, reason: null };
 }
 
+/**
+ * Run a git command, returning its stdout — or `null` if the command failed.
+ *
+ * `null` rather than `''` is load-bearing: a caller that cannot tell "git said
+ * nothing" from "git never answered" will report an unreadable diff as an empty
+ * one, and an empty diff is the one thing it is safe to call TRIVIAL (#1451).
+ */
 function safeExec(cmd, opts) {
   try {
     return execSync(cmd, {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
+      maxBuffer: EXEC_MAX_BUFFER,
       ...(opts && opts.cwd ? { cwd: opts.cwd } : {}),
     });
-  } catch { return ''; }
+  } catch { return null; }
+}
+
+/**
+ * Is there a repo with at least one commit here? A git failure only means
+ * "there was something we could not measure" when there is history to read —
+ * outside a repo, or in a fresh `git init` before the first commit, there is
+ * genuinely no diff to miss, and forcing a review fan-out over nothing would be
+ * its own defect.
+ */
+function hasGitHistory(cwd) {
+  return safeExec('git rev-parse --verify HEAD', cwd ? { cwd } : undefined) !== null;
+}
+
+/**
+ * One `git rev-parse` per classification, shared by both diff readers. They
+ * consult it only on their failure paths — and a directory that is not a repo
+ * makes every read fail, so without sharing, the cheapest case pays twice.
+ */
+function makeHistoryProbe(cwd) {
+  let answer;
+  return () => (answer === undefined ? (answer = hasGitHistory(cwd)) : answer);
 }
 
 // Detect the consumer's default branch. Hardcoding 'main' silently miscalibrates
@@ -119,7 +177,7 @@ function detectDefaultBranch(cwd) {
   const opts = cwd ? { cwd } : undefined;
 
   // Preferred: origin/HEAD points to whatever the remote considers default.
-  const symbolic = safeExec('git symbolic-ref --short refs/remotes/origin/HEAD', opts).trim();
+  const symbolic = (safeExec('git symbolic-ref --short refs/remotes/origin/HEAD', opts) || '').trim();
   if (symbolic.startsWith('origin/')) {
     const v = symbolic.slice('origin/'.length);
     if (cwd === undefined) _cachedDefaultBranch = v;
@@ -127,7 +185,7 @@ function detectDefaultBranch(cwd) {
   }
 
   // Fallback: local init.defaultBranch (set by `git init -b <name>` or config).
-  const configured = safeExec('git config --get init.defaultBranch', opts).trim();
+  const configured = (safeExec('git config --get init.defaultBranch', opts) || '').trim();
   if (configured) {
     if (cwd === undefined) _cachedDefaultBranch = configured;
     return configured;
@@ -142,12 +200,95 @@ function _resetCacheForTest() {
   _cachedDefaultBranch = null;
 }
 
-function readDiffFromGit(base, cwd) {
+/**
+ * Read the tracked half of the diff: committed-since-base + working-tree.
+ * Returns `{ text, unreadable, reason }` — `unreadable` means a read we needed
+ * did not happen, so `text` is an undercount and must not be trusted as zero.
+ */
+function readDiffFromGit(base, cwd, historyProbe) {
   const opts = cwd ? { cwd } : undefined;
-  // Combined diff: committed-since-base + working-tree
   const committed = safeExec(`git diff ${base}...HEAD`, opts);
   const working = safeExec('git diff HEAD', opts);
-  return committed + (working ? '\n' + working : '');
+  const text = (committed || '') + (working ? '\n' + working : '');
+
+  if (committed !== null && working !== null) return { text, unreadable: false };
+  if (!(historyProbe ? historyProbe() : hasGitHistory(cwd))) return { text, unreadable: false };
+
+  const failed = [];
+  if (committed === null) failed.push(`git diff ${base}...HEAD`);
+  if (working === null) failed.push('git diff HEAD');
+  return { text, unreadable: true, reason: `${failed.join(' and ')} failed` };
+}
+
+/**
+ * Read the untracked half of the diff.
+ *
+ * Untracked files appear in no `git diff` output at all, so a branch of
+ * brand-new files reads as a far smaller change than it is — 12 new CRUD files
+ * classified SMALL until someone staged them (#1451). Synthesize a new-file
+ * entry per untracked, non-ignored file so `parseDiff` counts it exactly as it
+ * would once staged.
+ *
+ * Built from Node file reads rather than `git diff --no-index` against a null
+ * device, which would need `/dev/null` vs `NUL` branching (Rule #1). The index
+ * is never touched.
+ */
+function readUntrackedDiff(cwd, historyProbe) {
+  const root = cwd || process.cwd();
+  const out = safeExec('git ls-files --others --exclude-standard -z', cwd ? { cwd } : undefined);
+  if (out === null) {
+    return (historyProbe ? historyProbe() : hasGitHistory(cwd))
+      ? { text: '', unreadable: true, reason: 'git ls-files --others failed' }
+      : { text: '', unreadable: false };
+  }
+
+  const parts = [];
+  let budgetSpent = 0;
+  let overBudget = false;
+  // -z keeps paths raw (no shell quoting of unusual characters). git emits them
+  // POSIX-separated on every platform, so they need no separator translation —
+  // only path.resolve to reach the file on disk.
+  for (const rel of out.split('\0')) {
+    if (!rel) continue;
+    const header = `diff --git a/${rel} b/${rel}\nnew file mode 100644\n`;
+
+    let body = null;
+    try {
+      const abs = path.resolve(root, rel);
+      // lstat, not stat: following an untracked symlink would read and count
+      // the TARGET's content — mismeasuring the diff, and pulling bytes from
+      // wherever the link points, which may be outside the working tree.
+      const stat = fs.lstatSync(abs);
+      if (stat.isFile() && stat.size <= UNTRACKED_MAX_BYTES && budgetSpent + stat.size <= UNTRACKED_TOTAL_BUDGET) {
+        const buf = fs.readFileSync(abs);
+        budgetSpent += stat.size;
+        if (!buf.includes(0)) body = buf.toString('utf-8');
+      } else if (stat.isFile()) {
+        overBudget = overBudget || budgetSpent + stat.size > UNTRACKED_TOTAL_BUDGET;
+      }
+    } catch { /* vanished or unreadable — header only */ }
+
+    if (body === null) {
+      // Binary, symlink, oversized, or unreadable. git emits no `+` lines for
+      // these either, so the file still counts toward fileCount/newFiles with
+      // zero added lines — the honest measurement, not a swallowed one.
+      parts.push(`${header}Binary files /dev/null and b/${rel} differ\n`);
+      continue;
+    }
+
+    // Split on \n and drop the trailing empty element from a final newline;
+    // CRLF files keep their \r on each line, which parseDiff trims before
+    // testing for declarations.
+    const lines = body.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+    parts.push(`${header}--- /dev/null\n+++ b/${rel}\n@@ -0,0 +1,${lines.length} @@\n`);
+    for (const ln of lines) parts.push(`+${ln}\n`);
+  }
+
+  const text = parts.join('');
+  return overBudget
+    ? { text, unreadable: true, reason: 'untracked files exceeded the diff-synthesis budget' }
+    : { text, unreadable: false };
 }
 
 /**
@@ -240,14 +381,19 @@ function parseDiff(diff) {
 }
 
 /**
- * Pure decision function. Takes parsed stats, returns dispatch decision.
- * No I/O. Easy to unit-test with synthetic stats.
+ * Route a diff we actually managed to measure. Pure — no I/O. Callers reach
+ * this through `decide`, which first handles the case where the measurement
+ * itself failed.
  */
-function decide(stats) {
+function decideMeasured(stats) {
   const reasoning = [];
   const totalChange = stats.added + stats.deleted;
 
-  if (totalChange === 0) {
+  // Only a diff with no files at all is genuinely empty. A diff carrying files
+  // but no +/- lines — binary assets, pure renames, mode changes, an untracked
+  // binary — is a real change git simply does not express as lines, and calling
+  // it "nothing to review" is the same undercount as swallowing a read error.
+  if (totalChange === 0 && stats.fileCount === 0) {
     return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, escalate: noEscalate(), reasoning: ['empty diff — nothing to review'], stats };
   }
 
@@ -345,13 +491,46 @@ function decide(stats) {
   return { tier: 'SMALL', model: 'sonnet', agentCount: 1, escalate: noEscalate(), reasoning, stats };
 }
 
+/**
+ * Pure decision function. Takes parsed stats, returns dispatch decision.
+ * No I/O. Easy to unit-test with synthetic stats.
+ *
+ * `stats.diffUnavailable` marks a diff the reader could not fully measure. The
+ * classifier cannot tell "no changes" from "I could not read the changes", and
+ * only the first is safe to call TRIVIAL — so an unmeasurable diff routes to a
+ * review tier and says why, rather than stamping the gate clean (#1451).
+ */
+function decide(stats) {
+  if (!stats.diffUnavailable) return decideMeasured(stats);
+
+  const note = `diff could not be fully read (${stats.diffUnavailableReason || 'git read failed'})`
+    + ' — a diff the classifier cannot measure is never TRIVIAL';
+  // Whatever DID parse may already warrant more than the forced NORMAL floor;
+  // an architectural diff whose working-tree half went missing stays DEEP.
+  const measured = decideMeasured(stats);
+  if (measured.agentCount >= 3) {
+    return { ...measured, reasoning: [note].concat(measured.reasoning) };
+  }
+  return { tier: 'NORMAL', model: 'sonnet', agentCount: 3, escalate: noEscalate(), reasoning: [note], stats };
+}
+
 function classifyDiff(diffText) {
   return decide(parseDiff(diffText));
 }
 
 function classifyFromGit(base, cwd) {
   const resolved = base || detectDefaultBranch(cwd);
-  return classifyDiff(readDiffFromGit(resolved, cwd));
+  const historyProbe = makeHistoryProbe(cwd);
+  const tracked = readDiffFromGit(resolved, cwd, historyProbe);
+  const untracked = readUntrackedDiff(cwd, historyProbe);
+  const stats = parseDiff(tracked.text + (untracked.text ? '\n' + untracked.text : ''));
+  if (tracked.unreadable || untracked.unreadable) {
+    stats.diffUnavailable = true;
+    // Both halves can fail independently; surface every reason, not just the
+    // first, so the printed decision explains the whole gap.
+    stats.diffUnavailableReason = [tracked.reason, untracked.reason].filter(Boolean).join('; ');
+  }
+  return decide(stats);
 }
 
 if (require.main === module) {
@@ -375,4 +554,7 @@ if (require.main === module) {
   }
 }
 
-module.exports = { parseDiff, decide, classifyDiff, classifyFromGit, detectDefaultBranch, _resetCacheForTest };
+module.exports = {
+  parseDiff, decide, classifyDiff, classifyFromGit,
+  readUntrackedDiff, detectDefaultBranch, EXEC_MAX_BUFFER, _resetCacheForTest,
+};

package/.claude/helpers/statusline.cjs

@@ -45,6 +45,7 @@ function loadStatusLineConfig() {
     show_model: true,
     show_session: true,
     show_intelligence: true,
+    show_context: true,
     show_swarm: true,
     show_hooks: true,
     show_mcp: true,
@@ -153,6 +154,23 @@ function readJSON(filePath) {
   return null;
 }
 
+// Normalize Claude Code's `context_window.used_percentage` into a 0-100 integer.
+// Returns null (never a stand-in number) for anything that isn't a finite number,
+// so every renderer can self-hide rather than publish a value it can't stand
+// behind (#1453).
+function normalizeContextPct(raw) {
+  if (typeof raw !== 'number' || !Number.isFinite(raw)) return null;
+  return Math.max(0, Math.min(100, Math.round(raw)));
+}
+
+// Colour for a context gauge; lower is better. Matches the thresholds already
+// used by the TypeScript statusline generator (src/cli/hooks/statusline/index.ts).
+function contextColor(pct) {
+  if (pct >= 75) return c.brightRed;
+  if (pct >= 50) return c.brightYellow;
+  return c.brightGreen;
+}
+
 // Safe file stat (returns null on failure)
 function safeStat(filePath) {
   try {
@@ -386,7 +404,6 @@ function getSystemMetrics() {
   // Intelligence from learning.json
   const learningData = readJSON(path.join(CWD, '.moflo', 'metrics', 'learning.json'));
   let intelligencePct = 0;
-  let contextPct = 0;
 
   if (learningData?.intelligence?.score !== undefined) {
     intelligencePct = Math.min(100, Math.floor(learningData.intelligence.score));
@@ -409,11 +426,20 @@ function getSystemMetrics() {
     intelligencePct = Math.min(100, score);
   }
 
-  if (learningData?.sessions?.total !== undefined) {
-    contextPct = Math.min(100, learningData.sessions.total * 5);
-  } else {
-    contextPct = Math.min(100, Math.floor(learning.sessions * 5));
-  }
+  // Context %: the real value, piped in by Claude Code on stdin (#1453).
+  //
+  // `context_window.used_percentage` is pre-calculated by Claude Code from INPUT
+  // tokens only (input_tokens + cache_creation_input_tokens + cache_read_input_tokens);
+  // it deliberately excludes output_tokens. It already accounts for
+  // `context_window_size`, so it stays correct on a 1M-context model. Do NOT
+  // "correct" this to `exceeds_200k_tokens`, which is a fixed 200k threshold and
+  // is meaningless on anything larger.
+  //
+  // It is null early in a session (before the first API response). Report null,
+  // never a substitute: this field used to be derived from the stored session
+  // count (`sessions * 5`), which pinned at 100% after 20 sessions and had nothing
+  // to do with the window. A blank beats a wrong number.
+  const contextPct = normalizeContextPct(STDIN_PAYLOAD?.context_window?.used_percentage);
 
   // Sub-agents from file metrics (no ps aux)
   let subAgents = 0;
@@ -797,6 +823,12 @@ function generateStatusline() {
     parts.push(`${c.cyan}\u23F1 ${session.duration}${c.reset}`);
   }
 
+  // Context % (#1453). Self-hides when Claude Code hasn't reported a window yet,
+  // rather than rendering a placeholder that reads as a real measurement.
+  if (SL_CONFIG.show_context && system.contextPct !== null) {
+    parts.push(`${contextColor(system.contextPct)}\uD83D\uDCC2 ${system.contextPct}%${c.reset}`);
+  }
+
   // Intelligence %
   if (SL_CONFIG.show_intelligence) {
     const intellColor = system.intelligencePct >= 80 ? c.brightGreen : system.intelligencePct >= 40 ? c.brightYellow : c.dim;
@@ -875,6 +907,14 @@ function generateDashboard() {
     );
   }
 
+  // Context % (#1453). Self-hides when the value is unknown.
+  if (SL_CONFIG.show_context && system.contextPct !== null) {
+    lines.push(
+      `${c.brightCyan}\uD83D\uDCC2 Context${c.reset}  ${contextColor(system.contextPct)}${system.contextPct}%${c.reset} ` +
+      `${c.dim}used${c.reset}`
+    );
+  }
+
   // Embeddings line \u2014 vector store stats from .moflo/vector-stats.json.
   // Reuses `system.embeddings` (already computed by getSystemMetrics()) instead
   // of re-probing the cache file on every render.
@@ -952,8 +992,17 @@ function generateCompactDashboard() {
   pushUpgradeNoticeSegment(lines);
   lines.push(header);
 
-  // Combined swarm + embeddings + mcp line
+  // Combined context + swarm + embeddings + mcp line
   const segments = [];
+  // Context % (#1453). Read straight off the stdin payload rather than via
+  // getSystemMetrics() — compact mode deliberately avoids that call so it stays
+  // probe-free, and this value costs nothing to derive.
+  {
+    const pct = normalizeContextPct(STDIN_PAYLOAD?.context_window?.used_percentage);
+    if (SL_CONFIG.show_context && pct !== null) {
+      segments.push(`${contextColor(pct)}\uD83D\uDCC2 ${pct}%${c.reset}`);
+    }
+  }
   if (SL_CONFIG.show_swarm) {
     const swarm = getSwarmStatus();
     const swarmInd = swarm.coordinationActive ? `${c.brightGreen}\u25C9${c.reset}` : `${c.dim}\u25CB${c.reset}`;