@opengsd/gsd-core 1.7.0-rc.5 → 1.7.0

package/gsd-core/workflows/ui-phase.md

@@ -223,7 +223,7 @@ Agent(
 ## 8. Handle Checker Return
 
 **If `## UI-SPEC VERIFIED`:**
-Display dimension results. Proceed to step 10.
+Display dimension results. Proceed to step 9.5.
 
 **If `## ISSUES FOUND`:**
 Display blocking issues. Proceed to step 9.
@@ -264,6 +264,151 @@ Options:
 
 Use AskUserQuestion for the choice.
 
+**On "Force approve":** proceed to step 9.5 (the UI-consideration probe still runs on the accepted UI-SPEC, so state coverage is recorded even when quality FLAGs were accepted), then step 10. **On "Edit manually" / "Abandon":** exit without running the probe.
+
+## 9.5. UI-Consideration Probe (post-verification)
+
+Run AFTER the checker approves the UI-SPEC (VERIFIED, or force-approved at step 9) — never inline
+during authoring, so a revision-loop researcher rewrite (step 9) cannot clobber the section and the
+`## UI Considerations` block is committed with the FINAL UI-SPEC. This is the visual analog of
+spec-phase Step 5.5's edge probe, retargeted to the UI element/state axis. Reference:
+@~/.claude/gsd-core/references/ui-consideration-probe.md.
+
+**Skip conditions:** if `--auto` and the UI-SPEC already carries a resolved `## UI Considerations`
+section (re-run), the write-back is idempotent (it REPLACES that section, never appends). If the
+runtime is non-Claude and the probe engine cannot be resolved, the shim FAILS LOUD (below) — it
+never silently no-ops (a silent skip would drop the whole state-coverage axis).
+
+**Runtime coverage compute — resolve and invoke ui-consideration-probe.cjs:**
+
+```bash
+# Resolve the compiled ui-consideration-probe.cjs against the GSD install dir via RUNTIME_DIR
+# (#448) — NOT the consuming project's git root — falling back to git toplevel / $HOME/.claude.
+# Mirrors spec-phase.md Step 5.5's edge-probe resolution idiom verbatim (same candidate paths).
+_GSD_RT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+UI_PROBE_JS=$(for _c in \
+  "$_GSD_RT/gsd-core/bin/lib/ui-consideration-probe.cjs" \
+  "$_GSD_RT/bin/lib/ui-consideration-probe.cjs" \
+  "$_GSD_RT/.claude/bin/lib/ui-consideration-probe.cjs" \
+  "$HOME/.claude/gsd-core/bin/lib/ui-consideration-probe.cjs" \
+  "$HOME/.claude/bin/lib/ui-consideration-probe.cjs"; do
+  [ -f "$_c" ] && { echo "$_c"; break; }
+done)
+
+# Graceful degradation — never a silent skip. Build ONLY when $_GSD_RT is a verified GSD source
+# checkout (has tsconfig.build.json + src/ui-consideration-probe.cts), pinned with --prefix so we
+# never trigger the CONSUMING project's own build during a ui-phase. Real installs ship the
+# compiled .cjs via prepublishOnly, so this path only matters in a GSD dev checkout.
+if [ -z "$UI_PROBE_JS" ]; then
+  if [ -f "$_GSD_RT/tsconfig.build.json" ] && [ -f "$_GSD_RT/src/ui-consideration-probe.cts" ]; then
+    npm --prefix "$_GSD_RT" run build:lib 2>/dev/null || true
+    UI_PROBE_JS=$(for _c in \
+      "$_GSD_RT/gsd-core/bin/lib/ui-consideration-probe.cjs" \
+      "$_GSD_RT/bin/lib/ui-consideration-probe.cjs" \
+      "$_GSD_RT/.claude/bin/lib/ui-consideration-probe.cjs" \
+      "$HOME/.claude/gsd-core/bin/lib/ui-consideration-probe.cjs" \
+      "$HOME/.claude/bin/lib/ui-consideration-probe.cjs"; do
+      [ -f "$_c" ] && { echo "$_c"; break; }
+    done)
+  fi
+  if [ -z "$UI_PROBE_JS" ]; then
+    echo "ERROR: ui-consideration-probe.cjs not found — reinstall GSD or run \`npm run build:lib\` in your GSD checkout." >&2
+    exit 1
+  fi
+fi
+
+# Element extraction (MANUAL BY DESIGN — not an oversight): the agent reads the researcher-authored
+# UI-SPEC prose (the described surfaces — the Design System / Copywriting rows and any element the
+# researcher named) and writes ONE object per UI element/surface: {"id","text"} where text is the
+# prose describing it. This mirrors spec-phase Step 5.5's edge-probe REQS_JSON step VERBATIM — a
+# hand-populated heredoc guarded by the fail-loud <replace:> check below — the established, shipped
+# pattern for feeding a probe from a prose spec. It is NOT mechanized on purpose: a UI-SPEC has no
+# single machine-parseable "elements" column — surfaces are distributed across design-token tables
+# (Design System / Typography / Color), the Copywriting section, and prose the researcher names, so a
+# regex/table parse would fail-OPEN (miss a prose-named surface, or feed a design-token row as a bogus
+# element). The agent-authored heredoc + fail-loud guard is the conservative choice, identical to the
+# requirement-side edge-probe path (RR-04). If a future UI-SPEC gains a canonical element table,
+# revisit to parse it. Populate the heredoc from the UI-SPEC; the guard below fails loud on a
+# forgotten substitution (never a no-op).
+ELEMENTS_JSON=$(mktemp "${TMPDIR:-/tmp}/ui-probe-elements-XXXXXX") && mv "$ELEMENTS_JSON" "${ELEMENTS_JSON}.json" && ELEMENTS_JSON="${ELEMENTS_JSON}.json" || exit 1
+cat > "$ELEMENTS_JSON" <<'JSON'
+[
+  { "id": "E1", "text": "<replace: element/surface description from the UI-SPEC prose>" }
+]
+JSON
+if ! node -e 'const a=require(process.argv[1]);if(!Array.isArray(a)||a.length===0)process.exit(1);if(a.some(e=>typeof e.text!=="string"||!e.text.trim()||e.text.includes("<replace:")))process.exit(1)' "$ELEMENTS_JSON" 2>/dev/null; then
+  rm -f "$ELEMENTS_JSON"
+  echo "ERROR: ui-probe elements JSON is empty/invalid or still holds the <replace: …> placeholder — populate \$ELEMENTS_JSON from the UI-SPEC's described surfaces before this step runs." >&2
+  exit 1
+fi
+# Invoke the compiled engine and CAPTURE its report. FATAL-INVOKE GUARD: use `if ! COVERAGE=$(…)`,
+# NEVER a bare `COVERAGE=$(node …)` — a bare capture swallows the engine's exit 2 (invalid shape /
+# bad input) and falls through to prose re-derivation: fail-OPEN at the exact boundary the engine
+# validation protects.
+if ! COVERAGE=$(node "$UI_PROBE_JS" "$ELEMENTS_JSON"); then
+  rm -f "$ELEMENTS_JSON"
+  echo "ERROR: ui-consideration-probe engine failed (invalid shapes or bad input) — fix the element(s) and re-run; never proceed with empty coverage." >&2
+  exit 1
+fi
+rm -f "$ELEMENTS_JSON"
+# Malformed-report guard: exit 0 but garbage. The report must parse as { items[], coverage{} }.
+if ! printf '%s' "$COVERAGE" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{let r;try{r=JSON.parse(s)}catch{process.exit(1)}if(!r||!Array.isArray(r.items)||typeof r.coverage!=="object"||r.coverage===null)process.exit(1)})'; then
+  echo "ERROR: ui-consideration-probe produced an unparseable or malformed coverage report — refusing to proceed with the resolution loop." >&2
+  exit 1
+fi
+# Zero-applicable guard: a report where NO category applied across ANY element is far more likely a
+# classification miss (or malformed elements) than a genuinely state-free UI. Surface it loudly.
+APPLICABLE=$(printf '%s' "$COVERAGE" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{let n=0;try{n=JSON.parse(s).coverage.applicable}catch{n=0}process.stdout.write(String(n))})')
+if [ "$APPLICABLE" = "0" ]; then
+  echo "WARNING: ui-consideration-probe proposed ZERO applicable categories across all elements — likely a classification miss or malformed elements, not a genuinely state-free UI. Do NOT silently write an empty UI Considerations section." >&2
+fi
+```
+
+If `$APPLICABLE` is `0`, do NOT proceed silently: ask via AskUserQuestion ("The UI probe found no
+applicable state considerations — is this genuinely a state-free surface, or should we revisit the
+element descriptions?"). Only write an empty section after explicit confirmation.
+
+**Propose-then-confirm (the partial-cue mitigation — load-bearing).** For each element, the engine
+reports the DETECTED element kinds (`classifyElement` over the built `.cjs`). The prose classifier
+is heuristic and LOSSY: a surface that is genuinely both a form and a list, but whose prose trips
+only the form cue, under-covers — and because SOMETHING classified, no `unclassified` signal fires.
+So SURFACE the detected kinds to the user (AskUserQuestion) and ask whether any real element kind
+was missed. If the user ADDs a kind, re-run that element with an authored `elements` override
+(the union of detected + added) so the missed categories are raised. A single tripped cue is a
+SIGNAL, not proof the element is only that kind — the confirm step, not the heuristic, is what makes
+coverage sound.
+
+**Resolution loop** (mirror spec-phase 5.5): resolve each applicable consideration via
+AskUserQuestion — **Specify** (→ `covered`, write a concrete truth) / **Dismiss (reason required)** /
+**Backstop** (a held-out/visual UI-state test) / **Defer** (→ `unresolved`). An `unclassified` row is
+a manual-review nudge, not a hard block. Text mode (`workflow.text_mode` / `--text`) → numbered lists.
+
+**Kind-confirmation under `--auto`.** The propose-then-confirm step above is an AskUserQuestion, so
+under `--auto` it follows the spec-phase 5.5 convention (replace AskUserQuestion with Claude's
+recommended choice): Claude re-reads each element's prose and authors the `elements` override (the
+union of the detected kinds + any kind it identifies as missed) instead of prompting — so `--auto`
+recall rests on Claude's kind-identification, not the heuristic cue-match alone. This matters because
+`autoResolve` (below) is a RESOLUTION floor only: it resolves the *detected* categories and cannot
+recover a kind that was never surfaced, so recall is fixed HERE, at kind-confirmation, before
+resolution runs.
+
+**`--auto` mode (two layers).** The adapter's `autoResolve` is the CODE floor: every applicable
+consideration auto-`backstop`s (carrying the taxonomy question as its resolution) and an
+`unclassified` candidate stays `unresolved` — it NEVER auto-`dismiss`es and never auto-backstops an
+unclassified item (#1110). On top of that floor the workflow MAY upgrade an item to `covered` when a
+defensible acceptance criterion can be written (the same judgment spec-phase 5.5 applies in prose).
+An auto `--auto` run therefore leaves un-upgraded backstops as `backstop`: at verify time each one
+with no wired evidence routes to `insufficient_spec → human_needed` — never a silent pass (#1154).
+That surfacing is the intended honest-verifier behavior, not over-flagging.
+
+**Write-back.** Populate a `## UI Considerations` section in the UI-SPEC from the resolved
+considerations, in the format the shipped plan-phase `## UI Considerations` lift rule reads:
+`covered` → a truth string; `backstop` → a flat scalar `{ statement, verification: backstop }`;
+`unresolved` → an explicit `⚠ unresolved — planner must treat as assumption` row. Empty-state and
+error-state COPY stays in `## Copywriting Contract` — the considerations section covers shape-rooted
+STATE coverage and REFERENCES those rows rather than restating the copy (de-dup). IDEMPOTENT: if a
+`## UI Considerations` section already exists, REPLACE it — never append a duplicate.
+
 ## 10. Present Final Status
 
 Display:

package/gsd-core/workflows/validate-phase.md

@@ -122,11 +122,11 @@ Handle return:
 
 **State B (create):**
 1. Read template from `~/.claude/gsd-core/templates/VALIDATION.md`
-2. Fill: frontmatter, Test Infrastructure, Per-Task Map, Manual-Only, Sign-Off
+2. Fill: frontmatter (**set `status: validated`**), Test Infrastructure, Per-Task Map, Manual-Only, Sign-Off
 3. Write to `${PHASE_DIR}/${PADDED_PHASE}-VALIDATION.md`
 
 **State A (update):**
-1. Update Per-Task Map statuses, add escalated to Manual-Only, update frontmatter
+1. Update Per-Task Map statuses, add escalated to Manual-Only, update frontmatter (**set `status: validated`**)
 2. Append audit trail:
 
 ```markdown

package/hooks/dist/gsd-statusline.js

@@ -6,6 +6,9 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+// Namespace (not destructured) so tests can inject spawn failures by
+// monkeypatching childProcess.execFileSync.
+const childProcess = require('child_process');
 const { isSemverNewer } = require('../gsd-core/bin/lib/semver-compare.cjs');
 const { PACKAGE_NAME, updateCacheFileName } = require('../gsd-core/bin/lib/package-identity.cjs');
 
@@ -286,6 +289,129 @@ function formatGsdState(s) {
   return parts.join(' · ');
 }
 
+// --- Context token count (opt-in) ---------------------------------------------
+
+/**
+ * Format a token count compactly: 156342 → '156k', 1234567 → '1.2M'.
+ */
+function formatTokens(tokens) {
+  // Promote to the M branch when k-rounding would reach 1000 (999,500-999,999
+  // must render "1.0M", never "1000k").
+  if (tokens >= 1000000 || Math.round(tokens / 1000) >= 1000) {
+    return (tokens / 1000000).toFixed(1) + 'M';
+  }
+  if (tokens >= 1000) return Math.round(tokens / 1000) + 'k';
+  return String(tokens);
+}
+
+/**
+ * Pure function: build the token-count suffix for the context meter from the
+ * hook input's context_window.current_usage block. Sums input, cache-creation,
+ * cache-read, and output tokens (the same total Claude Code's /context shows).
+ * Returns ' (156k)' or '' when usage is absent/empty.
+ */
+function contextTokenSuffix(currentUsage) {
+  if (!currentUsage || typeof currentUsage !== 'object') return '';
+  const total = (Number(currentUsage.input_tokens) || 0) +
+    (Number(currentUsage.cache_creation_input_tokens) || 0) +
+    (Number(currentUsage.cache_read_input_tokens) || 0) +
+    (Number(currentUsage.output_tokens) || 0);
+  return total > 0 ? ` (${formatTokens(total)})` : '';
+}
+
+// --- Model name --------------------------------------------------------------
+
+/**
+ * Collapse the verbose " (… context)" model-name suffix Claude Code sends for
+ * long-context sessions (e.g. "Sonnet 4.5 (1M context)") to a compact badge
+ * (" (1M)"). The signal is preserved; the width isn't. Tolerant by design
+ * (issue #2160 approval condition): any trailing parenthesized token ending
+ * in "context" is collapsed — a future "(500K context)" becomes "(500K)"
+ * rather than silently no-opping. The token's own casing is preserved.
+ * Any other display name passes through unchanged.
+ */
+function compactModelName(name) {
+  if (typeof name !== 'string') return name;
+  return name.replace(/\s*\(([^)]+?)\s+(?:context|ctx)\)$/i, ' ($1)');
+}
+
+// --- Git segment (opt-in) ------------------------------------------------------
+//
+// Opt-in via `statusline.show_git: true` in .planning/config.json. Renders the
+// current branch plus compact work-state markers after the directory segment:
+//   " │ main+2~1?3↑1"  (staged / unstaged / untracked / ahead / behind)
+//   " │ main✓"         (clean, in sync)
+// One `git status --porcelain=v2 --branch` spawn per render — no shell, args
+// are a fixed array, and the workspace dir is passed via -C. Fails silently
+// (segment absent) outside a repo, without git, or on timeout.
+
+const GIT_STATUS_TIMEOUT_MS = 1500;
+
+/**
+ * Run `git status --porcelain=v2 --branch` in dir.
+ * Returns raw stdout, or null when git is missing, dir isn't a repo, or the
+ * call times out. Never throws.
+ */
+function readGitStatus(dir) {
+  try {
+    // 8 MiB maxBuffer (default 1 MiB) headroom for repos with very many changed
+    // or untracked files; overflow still degrades safely to segment-absent via
+    // the catch below.
+    return childProcess.execFileSync('git', ['-C', dir, 'status', '--porcelain=v2', '--branch'],
+      { encoding: 'utf8', timeout: GIT_STATUS_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Pure function: parse `git status --porcelain=v2 --branch` output.
+ *
+ * Returns { branch, ahead, behind, staged, unstaged, untracked } or null when
+ * the text carries no branch header (not a repo / unparseable). Detached HEAD
+ * reports branch "(detached)" — porcelain v2's literal spelling, shown as-is.
+ * Unmerged (conflict) entries count as unstaged: they're pending work either way.
+ */
+function parseGitStatus(text) {
+  if (typeof text !== 'string') return null;
+  const info = { branch: null, ahead: 0, behind: 0, staged: 0, unstaged: 0, untracked: 0 };
+  for (const line of text.split('\n')) {
+    if (line.startsWith('# branch.head ')) {
+      info.branch = line.slice('# branch.head '.length).trim() || null;
+    } else if (line.startsWith('# branch.ab ')) {
+      const m = line.match(/\+(\d+) -(\d+)/);
+      if (m) { info.ahead = parseInt(m[1], 10); info.behind = parseInt(m[2], 10); }
+    } else if (line.startsWith('1 ') || line.startsWith('2 ')) {
+      // Changed / renamed entries: XY pair at cols 2-3, '.' = unmodified side
+      const xy = line.slice(2, 4);
+      if (xy[0] !== '.') info.staged++;
+      if (xy[1] !== '.') info.unstaged++;
+    } else if (line.startsWith('u ')) {
+      info.unstaged++;
+    } else if (line.startsWith('? ')) {
+      info.untracked++;
+    }
+  }
+  return info.branch ? info : null;
+}
+
+/**
+ * Pure function: format parsed git info into the statusline segment, divider
+ * included (mirrors lastCmdSuffix). Branch is dimmed to match the directory
+ * segment; markers keep their own colors. Returns '' when info is absent.
+ */
+function buildGitSegment(info) {
+  if (!info || !info.branch) return '';
+  const markers = [];
+  if (info.staged) markers.push(`\x1b[32m+${info.staged}\x1b[0m`);
+  if (info.unstaged) markers.push(`\x1b[33m~${info.unstaged}\x1b[0m`);
+  if (info.untracked) markers.push(`\x1b[31m?${info.untracked}\x1b[0m`);
+  if (info.ahead) markers.push(`\x1b[32m↑${info.ahead}\x1b[0m`);
+  if (info.behind) markers.push(`\x1b[31m↓${info.behind}\x1b[0m`);
+  const state = markers.length ? markers.join('') : '\x1b[32m✓\x1b[0m';
+  return ` │ \x1b[2m${info.branch}\x1b[0m${state}`;
+}
+
 // --- stdin ------------------------------------------------------------------
 
 function runStatusline() {
@@ -299,11 +425,16 @@ function runStatusline() {
   clearTimeout(stdinTimeout);
   try {
     const data = JSON.parse(input);
-    const model = data.model?.display_name || 'Claude';
+    const model = compactModelName(data.model?.display_name || 'Claude');
     const dir = data.workspace?.current_dir || process.cwd();
     const session = data.session_id || '';
     const remaining = data.context_window?.remaining_percentage;
 
+    // Read .planning config once — used by the context meter (token suffix)
+    // and the last-command/position block below. Fail-soft to {}.
+    let cfg = {};
+    try { cfg = readGsdConfig(dir); } catch (e) {}
+
     // Context window display (shows USED percentage scaled to usable context)
     // Claude Code reserves a buffer for autocompact. By default this is ~16.5%
     // of the total window, but users can override it via CLAUDE_CODE_AUTO_COMPACT_WINDOW
@@ -349,15 +480,21 @@ function runStatusline() {
       const filled = Math.floor(used / 10);
       const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
 
+      // Opt-in absolute token count after the percentage (statusline.show_context_tokens)
+      let tokenSuffix = '';
+      if (getConfigValue(cfg, 'statusline.show_context_tokens') === true) {
+        tokenSuffix = contextTokenSuffix(data.context_window?.current_usage);
+      }
+
       // Color based on usable context thresholds
       if (used < 50) {
-        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+        ctx = ` \x1b[32m${bar} ${used}%${tokenSuffix}\x1b[0m`;
       } else if (used < 65) {
-        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+        ctx = ` \x1b[33m${bar} ${used}%${tokenSuffix}\x1b[0m`;
       } else if (used < 80) {
-        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+        ctx = ` \x1b[38;5;208m${bar} ${used}%${tokenSuffix}\x1b[0m`;
       } else {
-        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%${tokenSuffix}\x1b[0m`;
       }
     }
 
@@ -421,8 +558,8 @@ function runStatusline() {
     // Failure here must never break the statusline — wrap the entire lookup.
     let lastCmdSuffix = '';
     let position = 'end';
+    let gitSuffix = '';
     try {
-      const cfg = readGsdConfig(dir);
       if (getConfigValue(cfg, 'statusline.show_last_command') === true) {
         const transcriptPath = data.transcript_path;
         const lastCmd = readLastSlashCommand(transcriptPath);
@@ -432,8 +569,11 @@ function runStatusline() {
       }
       const cfgPos = getConfigValue(cfg, 'statusline.context_position');
       if (cfgPos != null) position = cfgPos;
+      if (getConfigValue(cfg, 'statusline.show_git') === true) {
+        gitSuffix = buildGitSegment(parseGitStatus(readGitStatus(dir)));
+      }
     } catch (e) {
-      // Never break the statusline on config/transcript errors
+      // Never break the statusline on config/transcript/git errors
     }
 
     // Output
@@ -444,7 +584,7 @@ function runStatusline() {
         ? `\x1b[2m${gsdStateStr}\x1b[0m`
         : null;
 
-    process.stdout.write(composeStatusline({ gsdUpdate, model, ctx, middle, dirname, lastCmdSuffix, position }));
+    process.stdout.write(composeStatusline({ gsdUpdate, model, ctx, middle, dirname, lastCmdSuffix, gitSuffix, position }));
   } catch (e) {
     // Silent fail - don't break statusline on parse errors
   }
@@ -463,6 +603,7 @@ function runStatusline() {
  * @param {string|null} [opts.middle=null]  - middle segment (todo task or GSD state), null = absent
  * @param {string} opts.dirname             - project directory basename (dim styling applied here)
  * @param {string} [opts.lastCmdSuffix='']  - last-command suffix, e.g. ' │ last: /foo'
+ * @param {string} [opts.gitSuffix='']      - git branch/status segment, e.g. ' │ main✓' (after dirname)
  * @param {'end'|'front'} [opts.position='end']
  *   - 'end'   (default): ctx appended after dirname — preserved byte-for-byte
  *   - 'front': ctx immediately after model name so the meter stays visible in narrow terminals
@@ -478,6 +619,7 @@ function composeStatusline({
   middle = null,
   dirname,
   lastCmdSuffix = '',
+  gitSuffix = '',
   position = 'end',
 } = {}) {
   const modelSeg = `\x1b[2m${model}\x1b[0m`;
@@ -486,12 +628,12 @@ function composeStatusline({
   const pos = position === 'front' ? 'front' : 'end';
 
   if (pos === 'front') {
-    if (middle) return `${gsdUpdate}${modelSeg}${ctx} │ ${middle} │ ${dirSeg}${lastCmdSuffix}`;
-    return `${gsdUpdate}${modelSeg}${ctx} │ ${dirSeg}${lastCmdSuffix}`;
+    if (middle) return `${gsdUpdate}${modelSeg}${ctx} │ ${middle} │ ${dirSeg}${gitSuffix}${lastCmdSuffix}`;
+    return `${gsdUpdate}${modelSeg}${ctx} │ ${dirSeg}${gitSuffix}${lastCmdSuffix}`;
   }
   // 'end' — preserved byte-for-byte relative to original inline templates
-  if (middle) return `${gsdUpdate}${modelSeg} │ ${middle} │ ${dirSeg}${ctx}${lastCmdSuffix}`;
-  return `${gsdUpdate}${modelSeg} │ ${dirSeg}${ctx}${lastCmdSuffix}`;
+  if (middle) return `${gsdUpdate}${modelSeg} │ ${middle} │ ${dirSeg}${gitSuffix}${ctx}${lastCmdSuffix}`;
+  return `${gsdUpdate}${modelSeg} │ ${dirSeg}${gitSuffix}${ctx}${lastCmdSuffix}`;
 }
 
 function isInstalledAheadOfLatest(installed, latest) {
@@ -531,6 +673,10 @@ module.exports = {
   composeStatusline,
   isInstalledAheadOfLatest,
   evaluateUpdateCache,
+  formatTokens,
+  contextTokenSuffix,
+  compactModelName,
+  readGitStatus, parseGitStatus, buildGitSegment,
 };
 
 /**
@@ -538,12 +684,13 @@ module.exports = {
  * testing without feeding stdin. Returns the rendered string.
  */
 function renderStatusline(data) {
-  const model = data.model?.display_name || 'Claude';
+  const model = compactModelName(data.model?.display_name || 'Claude');
   const dir = data.workspace?.current_dir || process.cwd();
   const dirname = path.basename(dir);
 
   let lastCmdSuffix = '';
   let position = 'end';
+  let gitSuffix = '';
   try {
     const cfg = readGsdConfig(dir);
     if (getConfigValue(cfg, 'statusline.show_last_command') === true) {
@@ -554,11 +701,14 @@ function renderStatusline(data) {
     }
     const cfgPos = getConfigValue(cfg, 'statusline.context_position');
     if (cfgPos != null) position = cfgPos;
+    if (getConfigValue(cfg, 'statusline.show_git') === true) {
+      gitSuffix = buildGitSegment(parseGitStatus(readGitStatus(dir)));
+    }
   } catch (e) { /* swallow */ }
 
   const gsdStateStr = formatGsdState(readGsdState(dir) || {});
   const middle = gsdStateStr ? `\x1b[2m${gsdStateStr}\x1b[0m` : null;
-  return composeStatusline({ model, ctx: '', middle, dirname, lastCmdSuffix, position });
+  return composeStatusline({ model, ctx: '', middle, dirname, lastCmdSuffix, gitSuffix, position });
 }
 
 module.exports.renderStatusline = renderStatusline;