@litfamily/litgrok 1.0.18 → 1.0.19

package/.grok/hooks/lit-status-line.mjs

@@ -6,6 +6,7 @@ import { dirname, isAbsolute, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { resolveAutoHandoff } from './auto-handoff.mjs';
 import { readHudRecordForCwd, writeContextRecord } from './litgrok-hud-state.mjs';
+import { STAGES, readWorkflowState } from './workflow-stage.mjs';
 
 const MAX_INPUT_BYTES = 64 * 1024;
 const GRADIENT_STOPS = [[255, 99, 55], [255, 45, 149], [0, 229, 255]];
@@ -18,6 +19,8 @@ const LEDGER_TAIL_BYTES = 128 * 1024;
 const COMPLETE_SHOWN_MS = 20 * 1000;
 const HANDOFF_NEAR_POINTS = 10;
 const CLOCK_SKEW_MS = 5 * 1000;
+// A turn the ledger has not heard from for this long is no longer shown as running.
+const LEDGER_TURN_QUIET_MS = 10 * 60 * 1000;
 const TOOL_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure']);
 // [background, foreground] of each pill.
 const PILLS = {
@@ -33,6 +36,16 @@ const GLYPHS = {
 };
 const ANSI_16 = [[0, 0, 0], [205, 0, 0], [0, 205, 0], [205, 205, 0], [0, 0, 238], [205, 0, 205], [0, 205, 205], [229, 229, 229],
   [127, 127, 127], [255, 0, 0], [0, 255, 0], [255, 255, 0], [92, 92, 255], [255, 0, 255], [0, 255, 255], [255, 255, 255]];
+// The workflow row's rail runs orange to pink to a softer cyan than the label.
+const RAIL_STOPS = [[255, 99, 55], [255, 45, 149], [95, 215, 255]];
+// The moving head is the label's cyan: a white cell would vanish on a light terminal.
+const RAIL = { ink: [11, 15, 20], faint: [72, 79, 88], head: [0, 229, 255], red: [255, 95, 95] };
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+// Grok's own tool names, shortened to the words people know them by. Any other name shows as sent.
+const TOOL_LABELS = {
+  run_terminal_command: 'Bash', read_file: 'Read', search_replace: 'Edit', write: 'Write', grep: 'Grep', list_dir: 'List',
+  todo_write: 'Todo', web_search: 'Search', web_fetch: 'Fetch', image_edit: 'Image', monitor: 'Monitor', ask_user_question: 'Ask',
+};
 
 async function readInput() {
   // Decode once: a multi-byte character can straddle two pipe chunks.
@@ -153,10 +166,10 @@ function sgr(rgb, depth, background = false) {
   return `\u001b[${background ? 48 : 38};2;${rgb.join(';')}m`;
 }
 
-function gradientColor(position) {
+function gradientColor(position, stops = GRADIENT_STOPS) {
   const stop = position <= 0.5 ? 0 : 1;
   const fraction = position <= 0.5 ? position * 2 : (position - 0.5) * 2;
-  return GRADIENT_STOPS[stop].map((value, index) => Math.round(value + (GRADIENT_STOPS[stop + 1][index] - value) * fraction));
+  return stops[stop].map((value, index) => Math.round(value + (stops[stop + 1][index] - value) * fraction));
 }
 
 // Bold is set once and each letter only changes the colour, so the longest label stays far below the cut.
@@ -247,6 +260,25 @@ function readLedgerTail(status) {
   return null;
 }
 
+// The hooks keep the session's workflow snapshot beside its ledger, in the same folders.
+function readWorkflow(status) {
+  const sessionId = status?.session_id;
+  if (typeof sessionId !== 'string' || sessionId === '' || sessionId.length > 512) return null;
+  const name = `${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}.workflow.json`;
+  for (const directory of statusDirs(status)) {
+    if (typeof directory !== 'string' || !isAbsolute(directory)) continue;
+    let root;
+    try {
+      root = realpathSync(directory);
+    } catch {
+      continue;
+    }
+    const state = readWorkflowState(join(root, '.grok', 'litgrok', 'session-ledger', name), sessionId);
+    if (state) return state;
+  }
+  return null;
+}
+
 // What the ledger says about the current turn: it starts at the prompt Grok names, or the latest one.
 // A turn whose start is not in the tail is unknown, so nothing is counted.
 function turnActivity(records, promptId) {
@@ -260,10 +292,20 @@ function turnActivity(records, promptId) {
   const held = (record) => record.signal === 'plan-gate-block' || record.signal === 'auto-handoff-directive'
     || (record.signal === 'auto-handoff-reload' && record.outcome === 'loaded');
   const last = turn.at(-1);
-  const ended = last?.event === 'Stop' && !held(last);
+  const failed = last?.event === 'StopFailure';
+  const ended = (last?.event === 'Stop' && !held(last)) || failed;
+  // A call is in flight while its PreToolUse is the turn's newest tool record. Parallel calls can hide
+  // one that is still running; that shows less, never a finished call as running.
+  const lastTool = turn.filter((record) => record.event === 'PreToolUse' || TOOL_EVENTS.has(record.event)).at(-1);
+  const liveStart = Date.parse(lastTool?.recordedAt);
   return {
+    live: !ended && lastTool?.event === 'PreToolUse' && typeof lastTool.tool?.name === 'string' && Number.isFinite(liveStart)
+      ? { name: lastTool.tool.name, startedAt: liveStart }
+      : null,
     startedAt: Date.parse(records[start].recordedAt),
+    lastAt: Date.parse((last ?? records[start]).recordedAt),
     endedAt: ended ? Date.parse(last.recordedAt) : null,
+    failed,
     tools: turn.filter((record) => TOOL_EVENTS.has(record.event)).length,
     agents: Math.max(0, count('SubagentStart') - count('SubagentStop')),
     planGate: !ended && turn.some((record) => record.signal === 'plan-gate-block'),
@@ -293,17 +335,30 @@ function warningText(status, activity) {
   return null;
 }
 
-function bandState(status, now) {
-  const started = status?.turn?.started_at_ms;
-  const running = typeof started === 'number' && Number.isFinite(started) && started > 0;
-  const activity = turnActivity(readLedgerTail(status), running ? status.prompt_id : undefined);
+// Whether a turn runs and since when. Grok's turn field decides when Grok sends one. Grok Build 1.0.13
+// sends none and, during a turn, re-runs the command with the payload of the last state change; then a
+// turn runs while the ledger's newest prompt has nothing that ended it and the ledger heard from it
+// recently. A cancel that records no stop shows as running until the ledger has been quiet that long.
+function turnState(status, activity, now) {
+  if (status !== null && typeof status === 'object' && Object.hasOwn(status, 'turn')) {
+    const started = status.turn?.started_at_ms;
+    const running = typeof started === 'number' && Number.isFinite(started) && started > 0;
+    return { running, startedAt: running && started <= now + CLOCK_SKEW_MS ? started : null };
+  }
+  const running = activity !== null && activity.endedAt === null && Number.isFinite(activity.startedAt)
+    && activity.startedAt <= now + CLOCK_SKEW_MS && now - activity.lastAt <= LEDGER_TURN_QUIET_MS;
+  return { running, startedAt: running ? activity.startedAt : null };
+}
+
+function bandState(status, now, activity, turn) {
+  const running = turn.running;
   const warning = warningText(status, activity);
   let timer = null;
   let state = null;
   if (running) {
     state = 'running';
-    if (started <= now + CLOCK_SKEW_MS) timer = duration(Math.max(0, now - started));
-  } else if (activity?.endedAt && now - activity.endedAt <= COMPLETE_SHOWN_MS && activity.endedAt <= now + CLOCK_SKEW_MS) {
+    if (turn.startedAt !== null) timer = duration(Math.max(0, now - turn.startedAt));
+  } else if (activity?.endedAt && !activity.failed && now - activity.endedAt <= COMPLETE_SHOWN_MS && activity.endedAt <= now + CLOCK_SKEW_MS) {
     state = 'complete';
     timer = duration(Math.max(0, activity.endedAt - activity.startedAt));
   }
@@ -360,6 +415,109 @@ function formatBand(discipline, band, depth, nerd, maxCells) {
   return renderBand(discipline, band, depth, nerd, { ...last, skillCells: Math.max(1, room) }).painted;
 }
 
+function clock(ms) {
+  const seconds = Math.floor(Math.max(0, ms) / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const rest = String(seconds % 60).padStart(2, '0');
+  return minutes < 60 ? `${minutes}:${rest}` : `${Math.floor(minutes / 60)}:${String(minutes % 60).padStart(2, '0')}:${rest}`;
+}
+
+// The current stage's pill: its name, the plan's checked tasks while working, and a tick once the
+// stage's turn has ended (for work, only once every task is checked).
+function stageLabel(workflow) {
+  if (workflow.stage === 'done') return 'DONE ✓';
+  const plan = workflow.plan;
+  const counter = workflow.stage === 'work' && plan?.total > 0 ? ` ${plan.done}/${plan.total}` : '';
+  const finished = workflow.ended && (workflow.stage !== 'work' || (plan?.total > 0 && plan.done === plan.total));
+  return `${workflow.stage.toUpperCase()}${counter}${finished ? ' ✓' : ''}`;
+}
+
+// The breadcrumb as { text, role, position, rail } pieces. Stage k of n sits at k/(n-1) along the
+// orange-pink-cyan gradient and each rail cell between two stages takes its own step in between.
+// Rails up to the current stage are lit. A stage before it shows a tick when the session went through
+// it; interview shows only when it happened.
+function breadcrumbPieces(workflow, { rail, compact }) {
+  const shown = STAGES.filter((stage) => stage !== 'interview' || workflow.visited.includes('interview') || workflow.stage === 'interview');
+  const current = shown.indexOf(workflow.stage);
+  const last = Math.max(1, shown.length - 1);
+  const pieces = [];
+  shown.forEach((stage, index) => {
+    if (index > 0) {
+      if (!compact) pieces.push({ text: ' ', role: 'space' });
+      for (let cell = 0; cell < rail; cell += 1) {
+        pieces.push({ text: index <= current ? '━' : '─', role: index <= current ? 'lit' : 'dim', position: (index - 1 + (cell + 1) / (rail + 1)) / last, rail: [index, cell] });
+      }
+      if (!compact) pieces.push({ text: ' ', role: 'space' });
+    }
+    const position = index / last;
+    if (index === current) pieces.push({ text: stageLabel(workflow), role: 'pill', position });
+    else if (index > current) pieces.push({ text: compact ? '·' : `${stage} ·`, role: 'future' });
+    else if (workflow.visited.includes(stage)) pieces.push({ text: compact ? '✓' : `${stage} ✓`, role: 'past', position });
+    else pieces.push({ text: compact ? '-' : stage, role: 'skipped' });
+  });
+  return { pieces, current };
+}
+
+// While a turn runs, one bright cell rides the rail into the current stage and moves on at each
+// redraw (Grok redraws about every 300 ms during a turn).
+function renderBreadcrumb(workflow, tier, depth, running, now) {
+  const { pieces, current } = breadcrumbPieces(workflow, tier);
+  const plain = pieces.map(({ text, role }) => (role === 'pill' ? `[${text}]` : text)).join('');
+  if (!depth) return { plain, painted: plain };
+  const head = running ? [current > 0 ? current : 1, Math.floor(now / 300) % tier.rail] : null;
+  const painted = pieces.map(({ text, role, position, rail }) => {
+    if (role === 'space') return text;
+    if (role === 'future' || role === 'skipped') return `${sgr(TEXT.dim, depth)}${text}`;
+    const rgb = gradientColor(position, RAIL_STOPS);
+    if (role === 'pill') return `${sgr(rgb, depth, true)}${sgr(RAIL.ink, depth)}\u001b[1m ${text} \u001b[0m`;
+    if (role === 'past') return `${sgr(rgb, depth)}${text}`;
+    if (head && rail[0] === head[0] && rail[1] === head[1]) return `${sgr(RAIL.head, depth)}${text}`;
+    return `${sgr(role === 'lit' ? rgb : RAIL.faint, depth)}${text}`;
+  }).join('');
+  return { plain, painted: `${painted}\u001b[0m` };
+}
+
+function toolLabel(name) {
+  return Object.hasOwn(TOOL_LABELS, name) ? TOOL_LABELS[name] : clipCells(plainText(name, 'tool'), 20);
+}
+
+function renderWorkflow(workflow, live, running, depth, now, tier) {
+  const paint = (text, rgb) => (depth ? `${sgr(rgb, depth)}${text}\u001b[0m` : text);
+  const parts = [];
+  if (workflow?.stage) parts.push(renderBreadcrumb(workflow, tier, depth, running, now));
+  if (live && tier.live) {
+    const spinner = SPINNER[Math.floor(now / 100) % SPINNER.length];
+    const text = tier.live === 'full' ? `${spinner} ${toolLabel(live.name)} · ${clock(now - live.startedAt)}` : `${spinner} ${clock(now - live.startedAt)}`;
+    parts.push({ plain: text, painted: paint(text, TEXT.amber) });
+  }
+  if (workflow?.test && tier.tests) {
+    const pass = workflow.test.verdict === 'pass';
+    const text = `tests ${pass ? '✓' : '✗'}${workflow.test.count === undefined ? '' : ` ${workflow.test.count}`}`;
+    parts.push({ plain: text, painted: paint(text, pass ? TEXT.green : RAIL.red) });
+  }
+  return { plain: parts.map((part) => part.plain).join('   '), painted: parts.map((part) => part.painted).join('   ') };
+}
+
+// Narrow rows shorten the rails, then drop the test badge, the tool's name, the tool and the stage
+// names, and last of all keep only the current stage.
+function formatWorkflow(workflow, live, running, depth, now, maxCells) {
+  const tiers = [
+    { rail: 4, live: 'full', tests: true },
+    { rail: 2, live: 'full', tests: true },
+    { rail: 2, live: 'full', tests: false },
+    { rail: 2, live: 'short', tests: false },
+    { rail: 1, live: false, tests: false },
+    { rail: 1, compact: true, live: false, tests: false },
+  ];
+  for (const tier of tiers) {
+    const row = renderWorkflow(workflow, live, running, depth, now, tier);
+    if (width(row.plain) <= maxCells && row.painted.length <= MAX_LINE_CHARACTERS) return row.painted || null;
+  }
+  if (!workflow?.stage) return null;
+  const label = clipCells(stageLabel(workflow), Math.max(1, maxCells - 2));
+  return depth ? `${sgr(RAIL_STOPS[1], depth, true)}${sgr(RAIL.ink, depth)}\u001b[1m ${label} \u001b[0m` : `[${label}]`;
+}
+
 const input = await readInput();
 try {
   recordContextForHandoff(input);
@@ -388,14 +546,35 @@ const row = formatRow({
   version: installedVersion(),
 }, depth, maxCells);
 // The ribbon is a second line, shown only while a skill is active and a turn runs, has just ended or
-// needs attention. LITGROK_HUD_LINES=1 keeps the compact row alone.
+// needs attention. The workflow row follows it once the session has a workflow stage, or while a skill
+// is active and there is a tool in flight or a test verdict to show. LITGROK_HUD_LINES=1 keeps the
+// compact row alone.
 let band = null;
-if (discipline && process.env.LITGROK_HUD_LINES !== '1') {
+let workflowLine = null;
+if (process.env.LITGROK_HUD_LINES !== '1') {
+  const now = Date.now();
+  let activity = null;
+  try {
+    activity = turnActivity(readLedgerTail(input), input?.prompt_id);
+  } catch {
+    activity = null;
+  }
+  const turn = turnState(input, activity, now);
+  const { running } = turn;
+  if (discipline) {
+    try {
+      const state = bandState(input, now, activity, turn);
+      if (state) band = formatBand(discipline, state, depth, process.env.LITGROK_HUD_GLYPHS === 'nerd', maxCells);
+    } catch {
+      band = null;
+    }
+  }
   try {
-    const state = bandState(input, Date.now());
-    if (state) band = formatBand(discipline, state, depth, process.env.LITGROK_HUD_GLYPHS === 'nerd', maxCells);
+    const workflow = readWorkflow(input);
+    const live = running ? activity?.live ?? null : null;
+    if (workflow?.stage || (discipline && (live || workflow?.test))) workflowLine = formatWorkflow(workflow, live, running, depth, now, maxCells);
   } catch {
-    band = null;
+    workflowLine = null;
   }
 }
-process.stdout.write(band ? `${row}\n${band}\n` : `${row}\n`);
+process.stdout.write(`${[row, band, workflowLine].filter(Boolean).join('\n')}\n`);

package/.grok/hooks/plan-progress.mjs

@@ -0,0 +1,36 @@
+// Checkbox progress of the newest plan. The prompt, tool and stop hooks note it in the workflow
+// snapshot for the status line, which never reads plan files itself.
+
+import { lstatSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { IMPLEMENTATION_ROW, planLinesOutsideFences } from '../skills/lit-plan/scripts/scaffold-plan.mjs';
+
+const MAX_PLAN_BYTES = 256 * 1024;
+const MAX_PLAN_ENTRIES = 500;
+
+/**
+ * Checkbox progress of the newest plan in `<workspace>/plans/` that has column-zero task rows:
+ * { done, total }, or null. Symlinks, oversized files and fenced rows are skipped.
+ */
+export function planProgress(workspaceRoot) {
+  const directory = join(workspaceRoot, 'plans');
+  try {
+    if (!lstatSync(directory).isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  const candidates = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true }).slice(0, MAX_PLAN_ENTRIES)) {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+    const status = lstatSync(join(directory, entry.name));
+    if (status.isFile() && status.size <= MAX_PLAN_BYTES) candidates.push({ path: join(directory, entry.name), mtimeMs: status.mtimeMs });
+  }
+  candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  for (const { path } of candidates) {
+    const rows = planLinesOutsideFences(readFileSync(path, 'utf8')).filter(({ line }) => IMPLEMENTATION_ROW.test(line));
+    if (rows.length === 0) continue;
+    return { done: rows.filter(({ line }) => /^- \[[xX]\]/u.test(line)).length, total: rows.length };
+  }
+  return null;
+}

package/.grok/hooks/post-tool-use-failure.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-// No failure-detail field is documented, so this records only the failing toolName and opaque toolInput digest.
+// No failure-detail field is documented, so this records only the failing toolName and opaque toolInput digest,
+// plus a fail verdict when the call was a test run.
 import { recordPassiveEvent } from './record-passive-event.mjs';
 
 await recordPassiveEvent('PostToolUseFailure');

package/.grok/hooks/post-tool-use.json

@@ -2,7 +2,6 @@
   "hooks": {
     "PostToolUse": [
       {
-        "matcher": "^(Edit|edit|Write|write)$",
         "hooks": [
           {
             "type": "command",

package/.grok/hooks/post-tool-use.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-// A documented edited-file path or tool-result field would make this ledger richer; neither is documented.
-// Record only toolName and a digest of the opaque documented toolInput, never its contents.
+// Every finished call is recorded for the status line: toolName and a digest of the opaque toolInput,
+// never its contents. A test run also keeps its verdict and one count, read from toolResult.
 import { recordPassiveEvent } from './record-passive-event.mjs';
 
 await recordPassiveEvent('PostToolUse');

package/.grok/hooks/pre-tool-use.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pre-tool-use.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/.grok/hooks/pre-tool-use.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// Records which tool started and when, for the status line's live step. The tool input is never
+// stored, not even as a digest. No stdout and exit 0 let the call proceed; a failure fails open.
+import { recordPassiveEvent } from './record-passive-event.mjs';
+
+await recordPassiveEvent('PreToolUse');

package/.grok/hooks/record-passive-event.mjs

@@ -19,6 +19,7 @@ import {
 } from 'node:fs';
 import { basename, dirname, isAbsolute, join } from 'node:path';
 import { writeHudRecords } from './litgrok-hud-state.mjs';
+import { stageFromPrompt, testVerdict, updateWorkflowState } from './workflow-stage.mjs';
 
 const MAX_EVENT_BYTES = 1024 * 1024;
 // A ledger past this size moves aside as a numbered segment and a fresh one starts.
@@ -29,6 +30,8 @@ const KEPT_SEGMENTS = 2;
 const ROTATION_LOCK_STALE_MS = 30 * 1000;
 const TOOL_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure']);
 const RECORD_SCHEMA = 'litgrok.hook-event/v1';
+// A finished call by one of these tools cannot have changed a plan file, so it skips the plan reread.
+const READ_ONLY_TOOLS = /^(?:read_file|grep|list_dir|glob|todo_write|web_search|web_fetch|read|ls)$/iu;
 const HUD_DISCIPLINE_PATTERN = /(?:^|[\s/])(lit-scientific-visualization|lit-handoff|autoconference|autoresearch|lit-plan|litwork|lit)(?=$|[^\w-])/iu;
 
 function maskCode(text) {
@@ -348,6 +351,8 @@ export function readLedgerRecords(ledgerFile, sessionId) {
 }
 
 function toolRecord(event, expectedEvent) {
+  // A call that is starting keeps only its tool name, for the status line's live step.
+  if (expectedEvent === 'PreToolUse') return { name: requireString(event.toolName, 'TOOL_NAME_MISSING') };
   if (!TOOL_EVENTS.has(expectedEvent)) return undefined;
   const name = requireString(event.toolName, 'TOOL_NAME_MISSING');
   if (!Object.hasOwn(event, 'toolInput')) throw new RecorderError('TOOL_INPUT_MISSING');
@@ -385,6 +390,24 @@ function appendRecord(path, record) {
   throw new RecorderError('LEDGER_FILE_UNSAFE');
 }
 
+// The workflow snapshot is display state for the status line: a failure leaves the ledger record in
+// place, says so on stderr and lets the hook succeed. The plan reader loads only here, because the
+// status line imports this module and must not depend on the lit-plan skill's files.
+async function noteWorkflow(ledgerFile, environment, expectedEvent, record) {
+  if (!['UserPromptSubmit', 'PostToolUse', 'PostToolUseFailure'].includes(expectedEvent)) return;
+  try {
+    const readsPlan = expectedEvent !== 'PostToolUseFailure' && !READ_ONLY_TOOLS.test(record.tool?.name ?? '');
+    const plan = readsPlan ? (await import('./plan-progress.mjs')).planProgress(environment.realWorkspaceRoot) : undefined;
+    updateWorkflowState(ledgerFile, environment.sessionId, {
+      stage: record.stage,
+      plan,
+      test: record.test,
+    });
+  } catch (error) {
+    process.stderr.write(`LitGrok workflow state: ${error?.message ?? 'WORKFLOW_STATE_FAILED'}\n`);
+  }
+}
+
 export function appendSessionRecord(ledgerFile, baseRecord, fields) {
   appendRecord(ledgerFile, { ...baseRecord, ...fields, recordedAt: new Date().toISOString() });
 }
@@ -410,9 +433,17 @@ export async function recordPassiveEvent(expectedEvent) {
       && /(?:^|[\s/])lit-plan(?:$|[^\w-])/iu.test(event.prompt) ? 'lit-plan' : null;
     const hudDiscipline = expectedEvent === 'UserPromptSubmit' ? hudDisciplineFromPrompt(event.prompt) : null;
     if (discipline !== null) record.discipline = discipline;
+    const stage = expectedEvent === 'UserPromptSubmit' && typeof event.prompt === 'string' ? stageFromPrompt(visiblePromptText(event.prompt)) : null;
+    if (stage !== null) record.stage = stage;
+    // Only the verdict and one count of a test run are kept, never the command or its output.
+    const test = TOOL_EVENTS.has(expectedEvent) ? testVerdict(event, expectedEvent === 'PostToolUseFailure') : null;
+    if (test !== null) record.test = test;
     if (expectedEvent === 'Stop') record.signal = 'turn-ended';
     const ledgerFile = environment.sessionId === null ? null : ledgerPath(environment.realWorkspaceRoot, environment.sessionId);
-    if (ledgerFile !== null) appendRecord(ledgerFile, record);
+    if (ledgerFile !== null) {
+      appendRecord(ledgerFile, record);
+      await noteWorkflow(ledgerFile, environment, expectedEvent, record);
+    }
     if (expectedEvent === 'UserPromptSubmit') {
       writeHudRecords({
         env: process.env,

package/.grok/hooks/stop.mjs

@@ -4,9 +4,12 @@
 import { appendSessionRecord, recordPassiveEvent } from './record-passive-event.mjs';
 import { PLAN_GATE_SIGNAL, evaluatePlanGate } from './plan-gate.mjs';
 import { evaluateAutoHandoff } from './auto-handoff-gate.mjs';
+import { planProgress } from './plan-progress.mjs';
+import { updateWorkflowState } from './workflow-stage.mjs';
 
 const observed = await recordPassiveEvent('Stop');
 if (observed) {
+  let held = false;
   // Plan gate: a planning turn must persist plans/<slug>.md; evaluated after the ledger record so a block is counted.
   let gate;
   try {
@@ -21,6 +24,7 @@ if (observed) {
     gate = { block: false };
   }
   if (gate.block) {
+    held = true;
     appendSessionRecord(observed.ledgerFile, observed.record, { signal: PLAN_GATE_SIGNAL, reason: gate.reason });
     process.stdout.write(`${JSON.stringify({ decision: 'block', reason: gate.reason })}\n`);
   } else {
@@ -35,9 +39,23 @@ if (observed) {
         ledgerFile: observed.ledgerFile,
       });
       if (handoff.record) appendSessionRecord(observed.ledgerFile, observed.record, handoff.record);
-      if (handoff.block) process.stdout.write(`${JSON.stringify({ decision: 'block', reason: handoff.reason })}\n`);
+      if (handoff.block) {
+        held = true;
+        process.stdout.write(`${JSON.stringify({ decision: 'block', reason: handoff.reason })}\n`);
+      }
     } catch (error) {
       process.stderr.write(`LitGrok auto-handoff: AUTO_HANDOFF_FAILED ${error instanceof Error ? error.message : String(error)}\n`);
     }
   }
+  // The workflow row: a stop that ends the turn closes the current stage, a held one keeps it open.
+  if (observed.ledgerFile) {
+    try {
+      updateWorkflowState(observed.ledgerFile, observed.environment.sessionId, {
+        ended: !held,
+        plan: planProgress(observed.environment.realWorkspaceRoot),
+      });
+    } catch (error) {
+      process.stderr.write(`LitGrok workflow state: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+  }
 }