great-cto 3.47.0 → 3.48.0

package/README.md

@@ -20,6 +20,34 @@ That's it. The CLI detects your stack, picks the right archetype, clones the plu
 
 After install, restart Claude Code and run `/inbox` or `/audit`.
 
+## Everyday use (source version)
+
+```bash
+great-cto run "build, fix or investigate something"
+great-cto status
+great-cto resume
+```
+
+Run launches interactive Claude Code through `/start`; resume targets its exact
+pre-bound session through `/resume`. The plugin must be loaded. Status reads
+private task metadata without launching a model. `/start` handles existing projects without resetting
+their configuration. For the controlled Codex runtime use `--host codex` and,
+when starting, an explicit scope such as `--allow src,tests,docs`.
+`status --json` works for both hosts. `--task UUID` selects persisted task identity;
+Codex status also includes its sanitized run listing. Optional repeated `--accept`
+criteria are stored and passed to execution and verification. `--operation UUID`
+provides idempotent launch receipts, and `resume --revision N` rejects stale intent.
+See [the shared task contract](../../docs/WORK-TASK-CONTRACT.md) for ownership and recovery.
+`resume --host codex` selects only one unfinished run in the target project;
+ambiguity requires a UUID. Pending gates, runtime locks and verifier checks remain
+in force. `--dir PATH` targets another project; `--dry-run` previews without agents.
+Advanced policies, recovery and approvals stay under `codex-host`.
+Research uses explicit `run --intent research`; controlled research writes reports
+only and preserves its bounded stage retry budget. Advanced host approvals, outcome
+attestations and cohort reports are under `task work`, documented in the shared
+contract. Resume progress is measured from bound stage evidence, not exit zero.
+Published npm versions may not include these source additions yet.
+
 ## What the plugin gives you
 
 The CLI installs it; these are what it installs.

package/board/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "great-cto",
   "description": "You already have the agent. This is everything around it. great_cto runs Claude Code as a pipeline of 71 specialist agents \u2014 an independent model checks each stage before the next builds on it, spending caps refuse rather than warn, and three decisions stay yours: what gets built, how, and whether it ships.",
-  "version": "3.47.0",
+  "version": "3.48.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"
@@ -81,6 +81,11 @@
             "command": "_gd=\"$PWD\"; while [ -n \"$_gd\" ] && [ ! -f \"$_gd/.great_cto/PROJECT.md\" ]; do _gd=\"${_gd%/*}\"; done; [ -n \"$_gd\" ] && cd \"$_gd\"; PLUGIN_DIR=${CLAUDE_PLUGIN_ROOT:-$(ls -d ~/.claude/plugins/cache/*/great_cto/*/ 2>/dev/null | awk -F'/plugins/cache/' '{split($NF,p,\"/\"); print p[3], $0}' | sort -V | tail -1 | cut -d' ' -f2- | sed \"s|/$||\")}; [ -n \"$PLUGIN_DIR\" ] && node \"${PLUGIN_DIR}/scripts/hooks/register-project.mjs\" </dev/null 2>/dev/null || true",
             "timeout": 10,
             "statusMessage": "Registering project on the board..."
+          },
+          {
+            "type": "command",
+            "command": "_gd=\"$PWD\"; while [ -n \"$_gd\" ] && [ ! -f \"$_gd/.great_cto/PROJECT.md\" ]; do _gd=\"${_gd%/*}\"; done; [ -n \"$_gd\" ] && cd \"$_gd\"; PLUGIN_DIR=${CLAUDE_PLUGIN_ROOT:-$(ls -d ~/.claude/plugins/cache/*/great_cto/*/ 2>/dev/null | awk -F'/plugins/cache/' '{split($NF,p,\"/\"); print p[3], $0}' | sort -V | tail -1 | cut -d' ' -f2- | sed \"s|/$||\")}; [ -n \"$PLUGIN_DIR\" ] && node \"${PLUGIN_DIR}/scripts/hooks/learner-report.mjs\" </dev/null 2>/dev/null || true",
+            "timeout": 10
           }
         ]
       }

package/board/packages/board/lib/routes.mjs

@@ -40,6 +40,7 @@ import { readVerdicts } from './verdicts.mjs';
 import { parseAgentBudgets, upsertAgentBudget, removeAgentBudget } from '../../../scripts/lib/agent-budget.mjs';
 import { resolveSecondOpinion, SECOND_OPINION_PROVIDERS } from '../../../scripts/lib/second-opinion.mjs';
 import { detectCodex } from '../../../scripts/lib/codex-exec.mjs';
+import { getWork } from './work.mjs';
 import { listCodexRuns } from '../../../scripts/lib/codex-host-state.mjs';
 import { upsertCapability, capabilitiesFromProjectMd } from '../../../scripts/lib/stack-capabilities.mjs';
 // Moved to scripts/lib so the cross-review Stop hook can ask the same question
@@ -99,6 +100,24 @@ async function dispatch(req, res, url, cwd) {
     }
   }
 
+  // New read model refuses project fallback rather than relabeling another project.
+  if (pathname === '/api/work') {
+    if (requestedProject && resolveProjectInfo(requestedProject).resolved === 'fallback') {
+      res.writeHead(404, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ error: 'Unknown project; work projection was not read' }));
+      return true;
+    }
+    if (req.method !== 'GET') {
+      res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'GET' });
+      res.end(JSON.stringify({ error: 'Work execution is not connected; use the host CLI' }));
+      return true;
+    }
+    const snapshot = getWork(cwd);
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(snapshot));
+    return true;
+  }
+
   // SSE
   if (pathname === '/api/sse') {
     res.writeHead(200, {

package/board/packages/board/lib/work.mjs

@@ -0,0 +1,136 @@
+/** Project-scoped read model. Never invent task/run links or dispatch from a GET. */
+import { createHash } from 'node:crypto';
+import { readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { getTasks, getReadDegradation } from './beads.mjs';
+import { listCodexRuns } from '../../../scripts/lib/codex-host-state.mjs';
+import { listWorkTasks, publicWorkTask } from '../../../scripts/lib/work-tasks.mjs';
+import { decisionCapabilities } from '../../../scripts/lib/work-decisions.mjs';
+import { measureWork, compareWork } from '../../../scripts/lib/work-metrics.mjs';
+import { readSessionStatus } from '../../../scripts/lib/session-status.mjs';
+
+const text = v => typeof v === 'string' ? v : null;
+const date = v => typeof v === 'string' && Number.isFinite(Date.parse(v)) ? v : null;
+const RUN_PHASE = { ready: 'accepted', 'awaiting-gate': 'needs_decision',
+  'awaiting-release': 'needs_decision', blocked: 'blocked', 'manual-action': 'blocked' };
+
+export function projectWork({ projectId, issues = [], codex = { state: 'absent', runs: [] },
+  tasks = [], sessions = [], sources = [], observedAt = new Date().toISOString() }) {
+  const entries = [];
+  for (const r of codex.runs || []) {
+    // Completion of a controller run is not proof of the user's acceptance criteria.
+    const terminal = ['done', 'cancelled'].includes(r.status);
+    const active = !!r.active || r.wave?.status === 'running';
+    const phase = active ? 'working' : RUN_PHASE[r.status] || null;
+    const pending = !!r.pending || ['awaiting-gate', 'awaiting-release'].includes(r.status);
+    const canCopyResume = !terminal && !pending && !active && r.status === 'ready';
+    const updatedAt = (r.attempts || []).flatMap(a => [date(a.startedAt), date(a.finishedAt)])
+      .filter(Boolean).sort((a, b) => Date.parse(b) - Date.parse(a))[0] || date(r.pending?.createdAt);
+    entries.push({ key: `run:${r.id}`, kind: 'run', taskId: null, runId: r.id, issueIds: [],
+      title: `Controlled run ${r.id}`, goal: null, acceptance: [], host: 'codex',
+      phase, nativeState: text(r.status), terminal, updatedAt: updatedAt || null,
+      outcome: r.status === 'done' ? 'Run finished; task acceptance is not recorded'
+        : r.status === 'cancelled' ? 'Run cancelled' : null,
+      reason: text(r.reason), decisions: pending ? [{ id: `run:${r.id}:pending`, engine: 'codex',
+        label: r.status === 'awaiting-release' ? 'Release approval in host controller' : 'Approval in host controller' }] : [],
+      capabilities: [{ action: 'copy_resume', enabled: canCopyResume,
+        reason: canCopyResume ? null : pending ? 'Resolve the host decision first' : active ? 'A worker owns this run'
+          : terminal ? 'This run is terminal' : 'This state does not permit ordinary resume' }],
+      command: canCopyResume ? `great-cto resume ${r.id} --host codex` : null,
+      evidence: (r.rolesCompleted || []).map(role => ({ kind: 'recorded_role', label: role })),
+      release: r.release ? { status: text(r.release.status), url: text(r.release.url), verifiedAt: date(r.release.verifiedAt) } : null,
+    });
+  }
+  for (const t of issues) {
+    const terminal = ['closed', 'done'].includes(t.raw_status || t.status);
+    const pending = !!t.is_gate && !terminal && t.raw_status !== 'blocked' && t.status !== 'blocked';
+    entries.push({ key: `issue:${t.id}`, kind: 'issue', taskId: null, runId: null, issueIds: [t.id],
+      title: text(t.title) || t.id, goal: null, acceptance: text(t.acceptance) ? [t.acceptance] : [],
+      host: null, phase: null, nativeState: text(t.raw_status || t.status), terminal,
+      updatedAt: date(t.updated_at), outcome: terminal ? 'Issue closed; task acceptance is not recorded' : null,
+      reason: 'Legacy work item; no execution run is linked',
+      decisions: pending ? [{ id: t.id, engine: 'beads', label: 'Review decision' }] : [],
+      capabilities: [{ action: pending ? 'review_decision' : 'view_issue', enabled: true, reason: null }],
+      command: null, evidence: [], release: null,
+    });
+  }
+  for (const t of tasks) {
+    const linkedRuns = entries.filter(e => e.kind === 'run' && t.links.runs.includes(e.runId));
+    const linkedIssues = entries.filter(e => e.kind === 'issue' && e.issueIds.some(id => t.links.issues.includes(id)));
+    for (const linked of [...linkedRuns, ...linkedIssues]) {
+      linked.taskId = t.taskId; linked.goal = t.goal; linked.acceptance = t.acceptance;
+      if (!linked.terminal) entries.splice(entries.indexOf(linked), 1);
+    }
+    const owner = t.operations.some(o => o.state === 'running');
+    const run = linkedRuns.length === 1 ? linkedRuns[0] : null;
+    const approval = decisionCapabilities(t).find(d => d.capability.enabled);
+    const approveCommand = approval ? `great-cto task work approve --task ${t.taskId} --decision ${approval.decisionId} --revision ${t.revision}` : null;
+    const enabled = !['cancelled', 'verified', 'completed'].includes(t.phase) && !owner && (t.host === 'codex'
+      ? !!run?.capabilities.some(c => c.action === 'copy_resume' && c.enabled)
+      : t.managed !== false && t.links.sessions.length === 1 && !['needs_decision', 'working'].includes(t.phase));
+    entries.push({ key: `task:${t.taskId}`, kind: 'task', taskId: t.taskId, runId: run?.runId || null,
+      issueIds: t.links.issues, title: t.goal, goal: t.goal, acceptance: t.acceptance,
+      host: t.host, phase: t.phase, nativeState: run?.nativeState || t.phase,
+      terminal: ['cancelled', 'completed'].includes(t.phase), updatedAt: t.updatedAt, outcome: t.outcome?.state === 'completed' ? `${t.intent || 'delivery'} outcome explicitly completed` : null, reason: t.reason,
+      intent: t.intent || 'delivery', stage: t.stage || null, taskOutcome: t.outcome || null,
+      decisions: decisionCapabilities(t).map(d => ({ ...d, id: d.decisionId, label: d.label || 'Host decision' })), evidence: (t.evidence || []).map(e => ({ kind: 'verdict', label: `${e.role}: ${e.verdict || 'not recorded'}` })),
+      release: run?.release || null, revision: t.revision, metrics: t.metrics,
+      capabilities: [...(approval ? [{ action: 'copy_approve', enabled: true, reason: null }] : []), { action: 'copy_resume', enabled, reason: enabled ? null : owner ? 'Host operation is active; duplicate resume is refused'
+        : t.managed === false ? 'Continue this observed session inside its native host'
+        : t.phase === 'needs_decision' ? 'Resolve the native host decision first' : 'Execution link or resumable host state is unavailable' }],
+      command: approveCommand || (enabled ? `great-cto resume --task ${t.taskId} --host ${t.host} --revision ${t.revision}` : null),
+    });
+  }
+  entries.sort((a, b) => (a.terminal - b.terminal) || (b.decisions.length - a.decisions.length)
+    || (Date.parse(b.updatedAt || '') || 0) - (Date.parse(a.updatedAt || '') || 0) || a.key.localeCompare(b.key));
+  const health = sources.some(s => ['degraded', 'unavailable'].includes(s.health)) ? 'degraded' : 'current';
+  const measurement = measureWork(tasks);
+  const payload = { schemaVersion: 1, projectId, observedAt, health, sources, tasks, entries, measurement, simplification: compareWork(measurement, null),
+    sessions: sessions.map(s => ({ session: s.session, state: s.state, since: date(s.since), reason: text(s.reason) })),
+    decisions: entries.flatMap(e => e.decisions.map(d => ({ ...d, entryKey: e.key }))),
+    execution: { enabled: false, reason: 'This board prepares commands; host execution is not connected' } };
+  // A timestamp is not a revision. Stable revision changes only with projected content.
+  const { observedAt: ignored, sources: sourceRows, ...content } = payload;
+  payload.revision = createHash('sha256').update(JSON.stringify({ ...content,
+    sources: sourceRows.map(({ observedAt: ignoredSourceTime, ...s }) => s) })).digest('hex');
+  return payload;
+}
+
+export function getWork(cwd) {
+  const observedAt = new Date().toISOString();
+  const sources = []; let issues = [], codex = { state: 'absent', runs: [] }, sessions = [], tasks = [];
+  const source = (id, health, reason = null) => sources.push({ id, health, reason, observedAt });
+  try {
+    const listing = listWorkTasks(cwd); tasks = listing.tasks.map(publicWorkTask);
+    source('tasks', listing.state === 'degraded' ? 'degraded' : 'current', listing.unreadable ? `${listing.unreadable} task state file(s) could not be read` : null);
+  } catch { source('tasks', 'unavailable', 'Cannot read shared task metadata'); }
+  try {
+    issues = getTasks(cwd);
+    const reason = getReadDegradation(cwd);
+    source('issues', reason ? 'degraded' : 'current', reason);
+  } catch { source('issues', 'unavailable', 'Cannot read project work items'); }
+  try {
+    codex = listCodexRuns({ root: cwd });
+    source('codex', codex.state === 'degraded' ? 'degraded' : 'current', codex.unreadable
+      ? `${codex.unreadable} run state file(s) could not be read; project membership is unknown` : null);
+  } catch { source('codex', 'unavailable', 'Cannot read the host run store'); }
+  try {
+    // Native reader drops malformed files. Check separately so absence stays honest.
+    let files = [];
+    try { files = readdirSync(join(cwd, '.great_cto', 'status')).filter(f => f.endsWith('.json')); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    let unreadable = 0;
+    for (const f of files) {
+      try {
+        const s = JSON.parse(readFileSync(join(cwd, '.great_cto', 'status', f), 'utf8'));
+        if (!text(s.session) || !date(s.since) || !['blocked', 'waiting', 'working'].includes(s.state)) unreadable++;
+      } catch { unreadable++; }
+    }
+    sessions = readSessionStatus(cwd);
+    source('claude_sessions', unreadable ? 'degraded' : 'current', unreadable ? `${unreadable} session state file(s) could not be read` : null);
+  } catch { source('claude_sessions', 'unavailable', 'Cannot read Claude session status'); }
+  let canonical = cwd;
+  try { canonical = realpathSync(cwd); } catch { /* source health already reports inaccessible data */ }
+  const projectId = 'project:' + createHash('sha256').update(canonical).digest('hex');
+  return { ...projectWork({ projectId, issues, codex, tasks, sessions, sources, observedAt }), projectName: basename(cwd) };
+}

package/board/packages/board/public/assets/work-view.js

@@ -0,0 +1,97 @@
+/* Read-side work UI; injected callbacks retain existing board authority. */
+(function () {
+  const esc = value => String(value ?? '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+  const quote = value => "'" + String(value).replace(/'/g, "'\\''") + "'";
+  function commandFor(goal, host, allow) {
+    if (!goal.trim()) throw Error('Describe the result first.');
+    if (!['claude-code', 'codex'].includes(host)) throw Error('Choose a supported host.');
+    if (host === 'codex' && (!allow.trim() || allow.split(',').some(p => !p.trim()))) throw Error('Codex requires an explicit comma-separated write scope.');
+    return `great-cto run --host ${host}` + (host === 'codex' ? ` --allow ${quote(allow.trim())}` : '') + ` -- ${quote(goal.trim())}`;
+  }
+  const phaseLabel = e => e.outcome || ({ waiting: 'Waiting; acceptance is not confirmed', unknown: 'Execution state is unknown', verified: 'Verified outcome; explicit completion pending', completed: 'Requested outcome explicitly completed', publishing: 'Host publication in progress', cancelled: 'Cancelled', working: 'Host activity recorded; liveness is not measured', accepted: 'Ready for host execution', needs_decision: 'Needs a decision', blocked: 'Blocked' }[e.phase])
+    || (e.kind === 'issue' ? `Issue: ${e.nativeState || 'unknown'}` : `Run: ${e.nativeState || 'unknown'}`);
+  function render(snapshot, history = false, filter = '') {
+    const warnings = snapshot.sources.filter(s => ['degraded', 'unavailable'].includes(s.health));
+    const rows = snapshot.entries.filter(e => e.terminal === history && (!filter || `${e.title} ${e.key}`.toLowerCase().includes(filter.toLowerCase())));
+    return `<p class="work-meta">Observed ${esc(snapshot.observedAt)} · ${snapshot.health === 'current' ? 'Sources read' : 'Sources incomplete'}</p>`
+      + warnings.map(s => `<p class="work-warning">${esc(s.id)}: ${esc(s.reason || s.health)}</p>`).join('')
+      + (rows.length ? rows.map(e => {
+        const cap = e.capabilities.find(c => c.enabled);
+        const action = cap ? `<button type="button" class="gate-btn" data-work-key="${esc(e.key)}" data-work-action="${esc(cap.action)}">${cap.action === 'copy_approve' ? 'Copy approval command' : cap.action === 'copy_resume' ? 'Copy resume command' : cap.action === 'review_decision' ? 'Review decision' : 'Open issue'}</button>` : '';
+        return `<article class="work-card" data-entry-key="${esc(e.key)}"><h2>${esc(e.title)}</h2><p>${esc(phaseLabel(e))}</p>`
+          + `<p class="work-meta">${esc(e.host || 'Host not linked')} · ${e.updatedAt ? esc(e.updatedAt) : 'Update time not recorded'}</p>`
+          + (e.acceptance.length ? `<p>Acceptance: ${esc(e.acceptance.join('; '))}</p>` : '')
+          + `<p>${esc(e.reason || 'Execution observation is recorded; acceptance is not inferred.')}</p>`
+          + e.decisions.map(d => `<p>${esc(d.label)}${d.engine === 'codex' ? ' · resolve in the host controller' : ''}</p>`).join('')
+          + action + (e.command ? `<pre>${esc(e.command)}</pre>` : '')
+          + (!cap && e.capabilities[0]?.reason ? `<p>${esc(e.capabilities[0].reason)}</p>` : '')
+          + `<details><summary>Technical details</summary><p>${esc(e.key)} · ${esc(e.nativeState || 'unknown')}</p>`
+          + `<p>Task linkage: ${esc(e.taskId || 'not recorded')}</p>${e.revision ? `<p>Task revision: ${esc(e.revision)}</p>` : ''}`
+          + (e.taskOutcome ? `<p>Outcome evidence: ${esc(e.taskOutcome.source || 'operator-attestation')} · ${esc(e.taskOutcome.state)}</p>` : '')
+          + `<p>Recorded roles: ${esc(e.evidence.map(v => v.label).join(', ') || 'none recorded; verification is not inferred')}</p>`
+          + (e.release ? `<p>Release: ${esc(e.release.status || 'unknown')} · verified ${esc(e.release.verifiedAt || 'not recorded')}</p>` + (typeof e.release.url === 'string' && /^https?:\/\//i.test(e.release.url) ? `<p><a href="${esc(e.release.url)}" target="_blank" rel="noopener noreferrer">Open release result</a></p>` : '') : '')
+          + `</details></article>`;
+      }).join('') : `<p>${warnings.length ? 'No readable entries match this view; sources are incomplete.' : filter ? 'No entries match the search.' : history ? 'No closed work records or terminal runs recorded.' : 'No active work records or runs recorded. Describe a result to prepare a host command.'}</p>`)
+      + (!history && snapshot.sessions.length ? `<details><summary>Claude sessions (${snapshot.sessions.length}) · task linkage not recorded</summary>`
+        + snapshot.sessions.map(s => `<p>${esc(s.session)} · ${esc(s.state)} · ${esc(s.reason || '')}</p>`).join('') + '</details>' : '');
+  }
+  let config, snapshot, generation = 0, filter = '';
+  const status = message => { document.getElementById('work-feedback').textContent = message; };
+  async function refresh() {
+    const seq = ++generation, project = config.project();
+    try {
+      const data = await config.read(`/api/work${project ? '?project=' + encodeURIComponent(project) : ''}`);
+      if (seq !== generation || project !== config.project()) return;
+      if (!data || data.error || data.schemaVersion !== 1) throw Error(data?.error || 'Cannot read work state. Check the board connection and refresh.');
+      if (snapshot?.revision === data.revision) return;
+      snapshot = data; paint();
+    } catch (error) {
+      if (seq !== generation || project !== config.project()) return;
+      snapshot = null;
+      for (const id of ['work-list', 'history-list']) document.getElementById(id).textContent = error.message;
+    }
+  }
+  function paint() {
+    if (!snapshot) return;
+    const expanded = [...document.querySelectorAll('.work-card details[open]')].map(d => d.closest('[data-entry-key]').dataset.entryKey);
+    const focused = document.activeElement;
+    const focusKey = focused?.dataset?.workKey, focusAction = focused?.dataset?.workAction;
+    document.getElementById('work-list').innerHTML = render(snapshot, false, filter);
+    document.getElementById('history-list').innerHTML = render(snapshot, true, filter);
+    for (const card of document.querySelectorAll('[data-entry-key]')) if (expanded.includes(card.dataset.entryKey)) card.querySelector('details').open = true;
+    if (focusKey) [...document.querySelectorAll('[data-work-key]')].find(b => b.dataset.workKey === focusKey && b.dataset.workAction === focusAction)?.focus();
+  }
+  function reset() {
+    generation++; snapshot = null; status('');
+    for (const id of ['work-list', 'history-list']) document.getElementById(id).textContent = 'Loading project work…';
+    refresh();
+  }
+  async function copy(command) {
+    try { await navigator.clipboard.writeText(command); status('Command copied. Run it in a terminal in the selected project; execution has not started here.'); }
+    catch { status('Clipboard unavailable. Select and copy the displayed command.'); }
+  }
+  function bind(options) {
+    config = options;
+    document.getElementById('work-compose').addEventListener('submit', event => {
+      event.preventDefault();
+      try {
+        const cmd = commandFor(document.getElementById('work-goal').value, document.getElementById('work-host').value, document.getElementById('work-allow').value);
+        document.getElementById('work-command').textContent = cmd; copy(cmd);
+      } catch (error) { document.getElementById('work-command').textContent = ''; status(error.message); }
+    });
+    document.getElementById('work-host').addEventListener('change', event => {
+      document.getElementById('work-allow-row').hidden = event.target.value !== 'codex';
+      document.getElementById('work-command').textContent = ''; status('');
+    });
+    for (const id of ['work-list', 'history-list']) document.getElementById(id).addEventListener('click', event => {
+      const button = event.target.closest('[data-work-action]'); if (!button || !snapshot) return;
+      const entry = snapshot.entries.find(e => e.key === button.dataset.workKey);
+      const action = entry?.capabilities.find(c => c.action === button.dataset.workAction && c.enabled);
+      if (!action) return;
+      if (action.action === 'copy_resume' || action.action === 'copy_approve') copy(entry.command);
+      else options.openIssue(entry.issueIds[0], action.action === 'review_decision');
+    });
+    setInterval(() => { if (!document.hidden && options.visible()) refresh(); }, 10000);
+  }
+  window.GctoWork = { bind, refresh, reset, render, commandFor, search(value) { filter = value; paint(); } };
+})();

package/board/packages/board/public/index.html

@@ -378,7 +378,7 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 
 /* The budgets panel. A cap with no consumption beside it cannot answer the only
    question worth asking of it, so every row carries the state and the spend. */
-.ab-title { font-weight: 600; margin-bottom: 8px; }
+.ab-title { font-weight: 500; margin-bottom: 8px; }
 .ab-row {
   display: flex; align-items: center; gap: 10px;
   padding: 4px 0; border-top: 1px solid var(--border);
@@ -886,6 +886,10 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
   color: var(--text3);
   text-align: center;
 }
+/* A <small> hint inside an empty state rendered at the browser's "smaller"
+   (13px × 5/6 = 10.83px), off the type scale; the layout gate caught it whenever
+   a fresh board had no logs. Pin it to the caption size. */
+.empty small { font-size: var(--fs-caption); }
 
 /* A read failed. Deliberately louder than .empty — the whole point is that this
    must not be mistaken for "there is nothing here". */
@@ -2565,7 +2569,7 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 /* ── Agents installed list (legacy — kept for fallback) ───────────────── */
 .agents-installed { display: grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 10px; margin-top: 4px; }
 /* Agent budget bars (Paperclip cascading budget pattern) */
-.ab-title { font-weight: 600; color: var(--text2); margin-bottom: 6px; }
+.ab-title { font-weight: 500; color: var(--text2); margin-bottom: 6px; }
 .ab-row { display: flex; justify-content: space-between; padding: 2px 0; }
 .ab-name { font-family: var(--mono, monospace); color: var(--accent-text); }
 .ab-cap { color: var(--text3); }
@@ -3261,9 +3265,27 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 ::-webkit-scrollbar { width: 10px; height: 10px; }
 ::-webkit-scrollbar-thumb { background: rgba(15, 17, 21, 0.12); border-radius: 999px; border: 2px solid transparent; background-clip: content-box; }
 ::-webkit-scrollbar-thumb:hover { background: rgba(15, 17, 21, 0.22); border: 2px solid transparent; background-clip: content-box; }
+/* Task read-side: reuse the board's measured typography and colour tokens. */
+.nav-views[hidden], #nav-views-label[hidden], #work-allow-row[hidden] { display: none; }
+.work-page { padding: 24px; max-width: 1000px; }
+.work-card, #work-compose { padding: 16px; border: 1px solid var(--border); border-radius: 8px; margin: 12px 0; background: var(--bg-card); }
+.work-page h1 { font-size: var(--fs-title-l); font-weight: 500; }
+.work-page .gate-btn { padding: 8px 12px; min-height: 36px; border: 1px solid var(--border-strong); border-radius: 4px; background: var(--bg-solid); color: var(--on-solid); cursor: pointer; }
+.work-page .gate-btn:hover { background: var(--bg-solid-hover); }
+.work-card a { color: var(--text); text-decoration: underline; }
+.work-card h2 { font-size: var(--fs-title-s); }
+.work-card p, #work-compose p { margin: 8px 0; font-size: var(--fs-body); }
+.work-meta { color: var(--text2); font-size: var(--fs-caption); }
+.work-warning { color: var(--absent-warn-fg); background: var(--bg-card); border: 1px solid var(--absent-warn-fg); padding: 12px; }
+.work-page pre { font-weight: 400; white-space: pre-wrap; overflow-wrap: anywhere; margin: 12px 0; }
+#work-compose textarea, #work-compose input, #work-compose select { display: block; width: 100%; margin: 8px 0 12px; padding: 8px; background: var(--bg-muted); color: var(--text); border: 1px solid var(--border-strong); border-radius: 4px; }
+#tools-nav summary { padding: 12px 16px; cursor: pointer; }
+@media (min-width: 768px) and (max-width: 1199px) { .nav-item[data-tab="work"] > span, .nav-item[data-tab="history"] > span { display: inline; font-size: var(--fs-caption); } #tools-nav summary { padding: 12px 4px; } }
+@media (max-width: 767px) { .work-page { padding: 12px; } .work-page button, #work-compose select { min-height: 44px; } }
 </style>
 </head>
 <body>
+<script src="/assets/work-view.js"></script>
 <div class="board">
   <!-- Subtle emerald glow background -->
   <div class="board-bg" aria-hidden="true"></div>
@@ -3299,21 +3321,17 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
         <div id="proj-menu-list"></div>
       </div>
     </div>
-    <!-- Nav shell cutover (great_cto-ki1x.5): eight tabs (+ a topbar share
-         button and bell) become four destinations. Tasks/kanban, Metrics/
-         dashboard, Docs, Activity/logs, Notifications and Share lose their
-         entry point here — their panels and functions are untouched, so nothing
-         that already linked to `#dashboard`/`switchTab('budgets', …)`/etc. goes
-         dead; a bookmark just stops appearing in the menu. Settings — the
-         future home for the Share/Notifications rows this detaches — is
-         reachable from the topbar gear, not a fifth item here (kept under the
-         ≤5 ceiling `ui-ux-pro-max` sets for the same nav to also serve mobile). -->
     <nav class="nav" id="nav-tablist" role="tablist" aria-orientation="vertical">
-      <div class="nav-item active" data-tab="decisions" role="tab" tabindex="0" aria-label="Decisions" title="Decisions" onkeydown="navTabKeydown(event, this)" onclick="switchTab('decisions', this)">
+      <div class="nav-item active" data-tab="work" role="tab" tabindex="0" aria-label="Work" title="Work" onkeydown="navTabKeydown(event, this)" onclick="switchTab('work', this)"><span>Work</span></div>
+      <div class="nav-item" data-tab="decisions" role="tab" tabindex="0" aria-label="Decisions" title="Decisions" onkeydown="navTabKeydown(event, this)" onclick="switchTab('decisions', this)">
         <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M22 12h-6l-2 3h-4l-2-3H2 M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"/></svg>
         <span>Decisions</span>
         <span class="count" id="nav-inbox-count">0</span>
       </div>
+      <div class="nav-item" data-tab="history" role="tab" tabindex="0" aria-label="History" title="History" onkeydown="navTabKeydown(event, this)" onclick="switchTab('history', this)"><span>History</span></div>
+    </nav>
+    <details id="tools-nav"><summary>Tools</summary>
+    <nav class="nav" role="tablist" aria-label="Technical tools" aria-orientation="vertical">
       <div class="nav-item" data-tab="ledger" role="tab" tabindex="0" aria-label="Ledger" title="Ledger" onkeydown="navTabKeydown(event, this)" onclick="switchTab('ledger', this)">
         <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M12 1v22 M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"/></svg>
         <span>Ledger</span>
@@ -3336,14 +3354,15 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
         <span class="count" id="nav-harness-count"></span>
       </div>
     </nav>
+    </details>
     <div class="nav-divider"></div>
-    <div class="nav-views-label" id="nav-views-label">Views</div>
+    <div class="nav-views-label" id="nav-views-label" hidden>Views</div>
     <!-- Saved views over Fleet (DESIGN §5 point 2). Static for this shell —
          filtering the fleet list is the Fleet screen body's job (.8), not this
          task's; deliberately not `.nav-item`/`role="tab"`, since they neither
          switch a top-level destination nor do anything yet, and a control that
          looks live and isn't fails `ui-ux-pro-max` empty-nav-state. -->
-    <div class="nav-views">
+    <div class="nav-views" hidden>
       <div class="nav-view-item" id="nav-view-needs" role="button" tabindex="0" onclick="setFleetView('needs')" onkeydown="if(event.key==='Enter'||event.key===' '){event.preventDefault();setFleetView('needs')}">Needs attention</div>
       <div class="nav-view-item" id="nav-view-expensive" role="button" tabindex="0" onclick="setFleetView('expensive')" onkeydown="if(event.key==='Enter'||event.key===' '){event.preventDefault();setFleetView('expensive')}">Expensive grants</div>
       <div class="nav-view-item" id="nav-view-never" role="button" tabindex="0" onclick="setFleetView('never')" onkeydown="if(event.key==='Enter'||event.key===' '){event.preventDefault();setFleetView('never')}">Never observed</div>
@@ -3398,8 +3417,24 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
       </div>
     </div>
 
+    <div class="panel active" id="panel-work" role="tabpanel">
+      <div class="work-page"><h1>Work</h1>
+        <form id="work-compose">
+          <label for="work-goal">What result do you need?</label>
+          <textarea id="work-goal" rows="3" required placeholder="Add CSV export with permission checks"></textarea>
+          <label for="work-host">Execution host</label>
+          <select id="work-host"><option value="claude-code">Claude Code</option><option value="codex">Controlled Codex</option></select>
+          <div id="work-allow-row" hidden><label for="work-allow">Codex write scope (comma-separated paths)</label><input id="work-allow" placeholder="src,tests,docs" /></div>
+          <p>Prepares a command. Run it in a terminal in the selected project. The board does not start a host session.</p>
+          <button type="submit" class="gate-btn">Copy command</button><pre id="work-command"></pre>
+        </form>
+        <p id="work-feedback" role="status" aria-live="polite"></p>
+        <div id="work-list">Loading project work…</div>
+      </div>
+    </div>
+    <div class="panel" id="panel-history" role="tabpanel"><div class="work-page"><h1>History</h1><p>Closed issues and terminal runs. Closing a record does not prove task acceptance.</p><div id="history-list">Loading project work…</div></div></div>
     <!-- Inbox -->
-    <div class="panel active" id="panel-inbox">
+    <div class="panel" id="panel-inbox">
       <div class="inbox-page">
         <!-- Fidelity pass (v3.27.1): the design's header is the screen's name and
              its count; the sentence the board used to shout in 52px display
@@ -3937,7 +3972,13 @@ const PRIORITY_LABEL = ['Urgent','High','Medium','Low'];
 let allTasks = [];
 let metrics = {};
 let shareState = { enabled: false, url: null };
-let currentTab = 'inbox';
+let currentTab = 'work';
+window.GctoWork.bind({
+  project: () => new URLSearchParams(location.search).get('project') || '',
+  visible: () => currentTab === 'work' || currentTab === 'history',
+  read: url => api(url),
+  openIssue: (id, decision) => { if (decision) switchTab('decisions'); openSideById(id); },
+});
 let searchQuery = '';
 let allProjects = [];
 let currentProject = '';
@@ -7003,6 +7044,7 @@ async function switchProject(slug) {
   // Close existing SSE so it doesn't push the wrong project's data
   if (window._gctoSSE) { try { window._gctoSSE.close(); } catch {} window._gctoSSE = null; }
   currentProject = slug;
+  window.GctoWork.reset();
   // Optimistic UI clear
   allTasks = [];
   renderKanban([]);
@@ -7069,6 +7111,7 @@ function filterTasks(q) {
 }
 
 function onSearch(q) {
+  window.GctoWork.search(q);
   searchQuery = q;
   renderKanban(filterTasks(q));
   document.getElementById('topbar-task-count').textContent =
@@ -7184,12 +7227,13 @@ async function init() {
   // Build version badge (fire-and-forget — never blocks the board).
   api('/api/version').then(v => { const el = document.getElementById('build-version'); if (el && v && v.version) el.textContent = 'v' + v.version; }).catch(() => {});
 
-  const [tasks, met, share, projs, inbox] = await Promise.all([
+  const [tasks, met, share, projs, inbox, serverWork] = await Promise.all([
     api(`/api/tasks${qs}`),
     api(`/api/metrics${qs}`),
     api(`/api/share${qs}`),
     api('/api/projects'),
     api(`/api/inbox${qs}`),
+    api(`/api/work${qs}`),
   ]);
   allTasks = tasks || [];
   metrics = met || {};
@@ -7206,11 +7250,13 @@ async function init() {
   const fromTaskId = (allTasks[0]?.id || '').split('-')[0];
   const registered = (allProjects || []).some((p) => p.slug === fromTaskId) ? fromTaskId : '';
   const proj = urlProject
+    || serverWork?.projectName
     || registered
     || (allProjects[0]?.slug)
     || fromTaskId
     || 'project';
   currentProject = proj;
+  window.GctoWork.reset();
   document.getElementById('project-name').textContent = proj;
   document.getElementById('crumb-project').textContent = proj;
   document.title = `${proj} · great_cto`;
@@ -7388,6 +7434,7 @@ function connectSSE() {
     try { renderKanban(filterTasks(searchQuery)); } catch (e) { console.warn('SSE renderKanban failed', e); }
     checkBoardFreshness();
     refreshInbox();
+    if (currentTab === 'work' || currentTab === 'history') window.GctoWork.refresh();
   };
   es.addEventListener('tasks', e => {
     const newTasks = JSON.parse(e.data);
@@ -8285,6 +8332,8 @@ let cmdkIndex = 0;
 
 function cmdkActions() {
   const out = [
+    { group: 'Go', label: 'Work — goals and execution', run: () => switchTab('work') },
+    { group: 'Go', label: 'History — recorded outcomes', run: () => switchTab('history') },
     { group: 'Go', label: 'Decisions — what needs you', run: () => switchTab('decisions') },
     { group: 'Go', label: 'Ledger — what it cost, what is running', run: () => switchTab('ledger') },
     { group: 'Go', label: 'Fleet — the agents and what they may do', run: () => switchTab('fleet') },
@@ -8481,13 +8530,17 @@ try {
 // panels, not keys.
 const DEST = { decisions: 'inbox', ledger: 'budgets', fleet: 'agents', dashboard: 'budgets', share: 'settings', notifications: 'settings' };
 const NAV = { inbox: 'decisions', budgets: 'ledger', agents: 'fleet', dashboard: 'ledger', share: 'settings', notifications: 'settings' };
-const ROUTES = { decisions: 1, ledger: 1, fleet: 1, harness: 1, settings: 1, kanban: 1 };
+const ROUTES = { work: 1, history: 1, decisions: 1, ledger: 1, fleet: 1, harness: 1, settings: 1, kanban: 1 };
 function switchTab(id, el) {
   const lid = DEST[id] || id;          // the panel's own name
   const navKey = NAV[id] || id;        // the destination to highlight
   if (!el) el = document.querySelector(`.nav-item[data-tab="${navKey}"]`)
     || document.querySelector('.nav-item[data-tab="decisions"]');
   currentTab = lid;
+  document.getElementById('nav-views-label').hidden = lid !== 'agents';
+  document.querySelector('.nav-views').hidden = lid !== 'agents';
+  if (['agents', 'budgets', 'harness'].includes(lid)) document.getElementById('tools-nav').open = true;
+  if (lid === 'work' || lid === 'history') window.GctoWork.refresh();
   if (ROUTES[id]) {
     if (location.hash !== `#/${id}`) history.replaceState(null, '', `#/${id}`);
     // BRD-R9: one local line per destination open, never blocking, never surfaced.
@@ -8507,7 +8560,7 @@ function switchTab(id, el) {
   // crumb — `labels` used to be referenced here but is only ever a function-local in
   // this file, so this threw ReferenceError on every tab switch and skipped the per-tab
   // loaders below (e.g. logs stuck on "Loading…"). Use a local label map.
-  const TAB_LABELS = { decisions: 'Decisions', ledger: 'Ledger', fleet: 'Fleet', harness: 'Harness', settings: 'Settings', budgets: 'Budgets', docs: 'Docs', dashboard: 'Board', inbox: 'Inbox', tasks: 'Tasks', agents: 'Agents', logs: 'Activity', notifications: 'Notifications', metrics: 'Metrics', share: 'Share' };
+  const TAB_LABELS = { work: 'Work', history: 'History', decisions: 'Decisions', ledger: 'Ledger', fleet: 'Fleet', harness: 'Harness', settings: 'Settings', budgets: 'Budgets', docs: 'Docs', dashboard: 'Board', inbox: 'Inbox', tasks: 'Tasks', agents: 'Agents', logs: 'Activity', notifications: 'Notifications', metrics: 'Metrics', share: 'Share' };
   const crumb = document.getElementById('crumb-here'); if (crumb) crumb.textContent = TAB_LABELS[id] || TAB_LABELS[lid] || 'Board';
   // Budgets render on Metrics, so the heartbeat that feeds them has to be
   // fetched when Metrics opens — not only from the agents drill-in it used to
@@ -8544,7 +8597,7 @@ function switchTab(id, el) {
 
 // Sidebar tabs: Enter/Space activate, arrows move (WAI-ARIA tablist).
 function navTabKeydown(event, el) {
-  const items = [...document.querySelectorAll('.nav-item[role="tab"]')];
+  const items = [...document.querySelectorAll('.nav-item[role="tab"]')].filter(item => item.getClientRects().length);
   const i = items.indexOf(el);
   if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); el.click(); return; }
   if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
@@ -8576,7 +8629,7 @@ function routeFromHash() {
   return ROUTES[h] ? h : (LEGACY_ROUTES[h] || null);
 }
 addEventListener('hashchange', () => { const r = routeFromHash(); if (r) switchTab(r); });
-addEventListener('DOMContentLoaded', () => { const r = routeFromHash(); if (r && r !== 'decisions') switchTab(r); });
+addEventListener('DOMContentLoaded', () => { const r = routeFromHash(); if (r && r !== 'work') switchTab(r); });
 
 async function refreshLogs() {
   const data = await api(`/api/logs${pqs()}`);