create-pmos 0.52.0 → 0.53.0

package/workspace/public/pm/fixture.js

@@ -5,7 +5,7 @@
 // character: the comparator diffs rendered text, so a reworded label is a bug.
 //
 // Pure data + pure functions. No DOM, no fetch, no state. Where the prototype
-// SYNTHESISES data (tasks from steps, faux-shell replies, doc bodies, new
+// SYNTHESISES data (faux-shell replies, doc bodies, new
 // initiative records) the synthesis function is ported alongside the data so the
 // app derives exactly what the prototype derives.
 //
@@ -32,10 +32,6 @@ export const wash = (c, p) => `color-mix(in oklab, ${c} ${p || 10}%, transparent
 export const DOT = { done: ['✓', C.suc], current: ['●', C.brand], pending: ['○', C.mut], blocked: ['✗', C.des] };
 export const SDOT = { working: ['●', C.suc], quiet: ['◐', C.wrn], needs: ['●', C.brand], blocked: ['✗', C.des], exited: ['○', C.mut] };
 export const TONE = { warn: C.wrn, bad: C.des, info: C.inf, ok: C.suc };
-export const TDOT = { done: ['✓', C.suc], doing: ['◐', C.inf], blocked: ['✗', C.des], todo: ['○', C.mut] };
-
-// Task status → colour in the task pane (line 2014).
-export const TASK_STATUS_COLOR = { done: C.suc, doing: C.inf, blocked: C.des, todo: C.mut };
 
 // Literal, non-token colours. Panel 4 and the terminal are hard-coded in the
 // prototype (lines 1975–1978, 1984–1988, 2103) — do NOT tokenise them.
@@ -82,30 +78,6 @@ export const PROFILES = [
   }
 ];
 
-// Component.INTG (lines 1048–1053)
-export const INTG = [
-  { id: 'jira', name: 'Jira', scope: 'project ATL', st: 'connected', synced: '12:38', does: 'handed-off initiatives read epic + story status from here — their build and eval ladder stages render from the epic, not from local files' },
-  { id: 'confluence', name: 'Confluence', scope: 'space PM', st: 'connected', synced: '11:02', does: 'PRDs publish here when spec completes; the Confluence page is the handoff copy — planning/prd/ stays the source of truth' },
-  { id: 'slack', name: 'Slack', scope: '#pm-updates', st: 'connected', synced: '12:40', does: 'session and blocker notifications post here' },
-  { id: 'google-workspace', name: 'Google Workspace', scope: 'drive + calendar', st: 'connected', synced: '09:15', does: 'calendar holds scheduled-task windows; research docs import from Drive' }
-];
-
-// line 1952 — the two connections that can preview a document.
-export const INTG_PREVIEWS = {
-  jira: ['jira://ATL-482', 'open ATL-482 preview'],
-  confluence: ['confluence://PM/crm-import-wizard-prd', 'open PRD page preview']
-};
-
-/* ────────────────────────────── skills ────────────────────────────── */
-
-// SKILLS (lines 1491–1496)
-export const SKILLS = [
-  { name: 'write-prd', d: 'draft a PRD from an initiative record', reads: 'planning/initiatives/<slug>.md', writes: 'planning/prd/<slug>-prd.md', usedIn: 'spec stage of adlc-feature, adlc-research' },
-  { name: 'contract-run', d: 'agree done_criteria + test_method, log the run', reads: 'planning/prd/<slug>-prd.md', writes: 'planning/runs/agent-runs.jsonl', usedIn: 'contract stage of adlc-feature' },
-  { name: 'score-rubric', d: 'run Review-Gate, append verdict', reads: 'planning/evals/<slug>-eval-rubric.md', writes: 'planning/evals/evals.jsonl', usedIn: 'eval stage of adlc-feature; verify stage of health-upkeep' },
-  { name: 'kanban-view', d: 'project the ladder as a board (same data)', reads: 'planning/initiatives/*.md', writes: 'nothing — a pure projection', usedIn: 'any initiative panel' }
-];
-
 /* ────────────────────────────── knowledge ────────────────────────────── */
 
 // Component.KNOW (lines 1082–1087)
@@ -122,49 +94,6 @@ export const INGESTED_KNOW = {
   'M-ADR-12': { grp: 'mobile · ingested', d: 'crash budget — 2% of sessions', badge: 'ingested', path: 'docs/adr/0012-crash-budget.md', body: 'Imported from acme/atlas-mobile by repo scan. Crash rate above 2% of sessions freezes feature work until triaged. Review it, then accept or supersede.', rels: [] }
 };
 
-/* ─────────────────── scheduled tasks / agents / memory ─────────────────── */
-
-// schedList() (lines 1055–1061)
-const SCHED_SEED = [
-  { name: 'nightly evals sweep', when: '02:00 daily', runCmd: 'pmos run score-rubric --all', scope: 'all initiatives with a rubric', profile: 'claude-personal', enabled: true, log: [{ ts: '02:00', t: 'ok — 0 failures', c: 'var(--success)' }, { ts: 'yesterday 02:00', t: 'ok — 0 failures', c: 'var(--success)' }] },
-  { name: 'prd freshness check', when: 'mon 09:00', runCmd: 'pmos check prd-freshness', scope: 'all initiatives', profile: 'claude-work', enabled: true, log: [{ ts: 'mon 09:00', t: 'ok — 2 stale PRDs flagged', c: 'var(--success)' }] },
-  { name: 'agent-runs compaction', when: 'fri 18:00', runCmd: 'pmos compact agent-runs', scope: 'planning/runs/', profile: 'claude-personal', enabled: false, log: [{ ts: 'fri 18:00', t: 'skipped — repo busy', c: 'var(--warning)' }] }
-];
-
-// agentList() (lines 1062–1067)
-const AGENTS_SEED = [
-  { name: 'sonnet-builder', role: 'builder', model: 'claude-sonnet-4-5', profile: 'claude-work', paused: false, sessions: [{ name: 'spine build', slug: 'workspace-pm-spine', st: 'working' }, { name: 'rubric fix', slug: 'workspace-pm-spine', st: 'needs' }] },
-  { name: 'haiku-scout', role: 'scout', model: 'claude-haiku-4', profile: 'claude-personal', paused: false, sessions: [{ name: 'doc-editor scout', slug: 'workspace-doc-editor', st: 'quiet' }] }
-];
-
-// memory() (lines 1068–1081)
-const MEMORY_SEED = {
-  short: [
-    { id: 's1', text: 'spine build: current diff touches navigator.tsx + spine.ts', src: 'session · spine build', ts: '12:39' },
-    { id: 's2', text: 'rubric fix: waiting on PM to confirm 0–10 scoring scale', src: 'session · rubric fix', ts: '12:22' },
-    { id: 's3', text: 'doc-editor scout: PRD lacks acceptance criteria — flagged', src: 'session · doc-editor scout', ts: '12:23' }
-  ],
-  long: [
-    { id: 'l1', text: 'PM prefers diffs over prose summaries', src: 'promoted 2026-07-12', pinned: true },
-    { id: 'l2', text: 'repo uses pnpm — never run npm install', src: 'promoted 2026-06-30', pinned: false },
-    { id: 'l3', text: 'no verdict recorded is not a pass (house rule)', src: 'added by PM 2026-07-02', pinned: true }
-  ]
-};
-
-// A new agent (line 1526) and a new long-term memory note (line 1538).
-export const NEW_AGENT = { role: 'builder', model: 'claude-sonnet-4-5', paused: false, sessions: [] };
-export const NEW_MEMORY_NOTE = { text: 'new note — edit me', src: 'added by PM · now', pinned: false };
-// A new scheduled task (line 1476).
-export const NEW_SCHED = { when: 'daily 06:00', runCmd: '', scope: 'all initiatives', enabled: true, log: [] };
-// The line a scheduled task shows when it has never run (line 1846).
-export const SCHED_NEVER_RUN = { ts: '—', t: 'never run yet — that is stated, not implied', c: C.mut };
-
-const clone = v => JSON.parse(JSON.stringify(v));
-/** Fresh, mutable copies of the three editable seed lists. */
-export const defaultSched = () => clone(SCHED_SEED);
-export const defaultAgents = () => clone(AGENTS_SEED);
-export const defaultMemory = () => clone(MEMORY_SEED);
-
 /* ───────────────────── repositories + board groups ───────────────────── */
 
 // allProds (line 1431) — the two repositories present before anything is added.
@@ -261,23 +190,6 @@ export const DATA = {
     steps: [
       { k: 'intake', s: 'current', t: 'nothing filed yet — a successful read of nothing', action: 'file the research brief', cmd: 'planning/prd/pmos-ui-research-brief.md' },
       { k: 'explore', s: 'pending', t: '' }, { k: 'synthesize', s: 'pending', t: '' }, { k: 'decide', s: 'pending', t: '' }],
-    tasks: {
-      intake: [
-        { title: 'frame the discovery question', status: 'done', instruction: 'Write the single, falsifiable question this discovery must answer, and file it at the top of the brief.', input: 'the KR this sits under + the raw ask', expect: 'One sentence a stranger could judge as answered or not.', evalNote: 'a reviewer agrees the question is specific and falsifiable', output: 'planning/prd/pmos-ui-research-brief.md' },
-        { title: 'list what we know vs. must learn', status: 'doing', instruction: 'Separate standing assumptions from open questions; capture each unknown as its own line so it can be assigned later.', input: 'the brief + any prior notes on this space', expect: 'Two short lists — known, unknown — in the brief.', evalNote: 'every unknown is phrased as something an observation could resolve', output: '—' },
-        { title: 'set the go / drop gate', status: 'todo', instruction: 'Define the evidence that would make this worth picking up — and the evidence that means drop it. Write both as explicit criteria.', input: 'the unknowns list', expect: 'Explicit drop criteria so discovery can end cleanly.', evalNote: 'the gate can be evaluated without further judgement calls', output: '—' }
-      ],
-      explore: [
-        { title: 'shadow 5 PMs, one session each', status: 'todo', instruction: 'Observe five real terminal-workspace sessions end to end; take raw, timestamped notes without interpreting yet.', input: 'the go/drop gate + a recruit list', expect: 'Raw notes per session, filed under research/.', evalNote: 'notes are observations, not conclusions', output: '—' },
-        { title: 'mine support + sales-call themes', status: 'todo', instruction: 'Pull recurring asks from prior transcripts and tag each with a theme and a count.', input: 'support + sales transcript archive', expect: 'A themed list with counts.', evalNote: 'themes are mutually exclusive and cover the corpus', output: '—' }
-      ],
-      synthesize: [
-        { title: 'cluster findings into candidate needs', status: 'todo', instruction: 'Group the observations into 3–5 need statements, each backed by evidence lines.', input: 'session notes + theme list', expect: 'A short, ranked list of candidate needs.', evalNote: 'each need cites at least two independent observations', output: '—' }
-      ],
-      decide: [
-        { title: 'write the pick-up / drop recommendation', status: 'todo', instruction: 'Recommend whether this becomes a real initiative, measured against the go/drop gate, and record the rationale.', input: 'candidate needs + the gate', expect: 'A decision record a PM can accept or reject.', evalNote: 'the recommendation maps directly to the gate criteria', output: '—' }
-      ]
-    },
     sessions: [], noSess: 'No sessions — normal, not an error.',
     arts: [], eval: null, l2: ['intake', 'nothing filed', C.mut]
   },
@@ -488,63 +400,14 @@ export function rawFor(tab, savedDocs = {}) {
 
 /* ────────────────────────── modes + titles ────────────────────────── */
 
-// MENU (line 1404) — computed by the prototype but never rendered; kept for parity.
-export const MENU = [['product', '◧'], ['scheduled', '◔'], ['workflow', '▤'], ['skills', '◇'], ['knowledge', '◈'], ['agent', '◐'], ['memory', '◒'], ['connect', '⌁']];
-
-// modeTitle (line 1409) — panel 2's heading per mode.
-export const MODE_TITLES = { product: 'initiatives', scheduled: 'scheduled tasks', workflow: 'workflows', skills: 'skills', knowledge: 'knowledge', agent: 'agents', memory: 'memory', connect: 'connections', focus: 'focus' };
+// modeTitle (line 1409) and detailTitle (line 1699): the headings of panel 2 and panel 3, for the modes and details that remain (R29).
+export const MODE_TITLES = { product: 'initiatives', workflow: 'workflows', validate: 'validate', today: 'today' };
 export const modeTitle = mode => MODE_TITLES[mode] || 'initiatives';
 
-// modeMeta (line 2051) — glyph + label for the settings drawer entries.
-export const MODE_META = { focus: ['◎', 'focus'], scheduled: ['◔', 'scheduled tasks'], workflow: ['▤', 'workflows'], skills: ['◇', 'skills'], knowledge: ['◈', 'knowledge'], agent: ['◐', 'agents'], memory: ['◒', 'memory'], connect: ['⌁', 'connections'] };
-
-// settingsGroups (lines 2053–2056) — EXACTLY two groups, no `workflow` entry.
-export const SETTINGS_GROUPS = [
-  { label: 'this repository', items: ['agent', 'memory', 'knowledge'] },
-  { label: 'all repositories', items: ['focus', 'skills', 'connect', 'scheduled'] }
-];
-
 // detailTitle (line 1699) — panel 3's heading per detail kind.
-export const DETAIL_TITLES = { init: 'initiative', flow: 'workflow', sched: 'scheduled task', skill: 'skill', know: 'decision', agent: 'agent', mem: 'memory', prof: 'claude profile', intg: 'connection', addprod: 'add product', new: 'file new' };
+export const DETAIL_TITLES = { init: 'initiative', flow: 'workflow', skill: 'skill', prof: 'claude profile', addprod: 'add product', new: 'file new' };
 export const detailTitle = kind => DETAIL_TITLES[kind] || 'detail';
 
-/* ────────────────────────────── focus mode ────────────────────────────── */
-
-// focusFirst / focusWaiting / focusSyn / focusSaw (lines 1544–1566).
-export const FOCUS_FIRST = [
-  { n: '1', slug: 'workspace-harness-tower', prod2: 'workspace', why: 'read failed — the board lies until the frontmatter is fixed', read: 'read: YAML error at line 3 · nothing derived' },
-  { n: '2', slug: 'workspace-pm-spine', prod2: 'workspace', why: 'contract owed — agents build against nothing until you agree it', read: 'read: PRD · runs.jsonl — no contract line' },
-  { n: '3', slug: 'crm-billing-sync', prod2: 'atlas-crm', why: 'stories 4/9 — the Jira handoff waits on you', read: 'read: PRD draft · stories file' },
-  { n: '4', slug: 'workspace-doc-editor', prod2: 'workspace', why: '2 intake blockers — each names its fix', read: 'read: initiative record · KR WIP 3/3' }
-];
-export const FOCUS_WAITING = [
-  { slug: 'crm-import-wizard', prod2: 'atlas-crm', why: 'app team builds — Jira ATL-482 · 3/7 stories done', read: 'synced 12:38 · nothing owed by you' }
-];
-// `action` replaces the prototype's inline handler; the mode module binds it.
-export const FOCUS_SYN = [
-  { t: 'sonnet-builder · spine build — running, no input needed', hasBtn: false },
-  { t: 'haiku-scout can draft the billing-sync stories — you edit instead of write', hasBtn: true, btn: '▶ delegate', action: 'delegate-billing-stories' }
-];
-// The session the delegate button starts (line 1558).
-export const DELEGATE_SESSION = { slug: 'crm-billing-sync', sess: { name: 'stories draft · haiku-scout', st: 'working', label: 'working', profile: 'claude-personal' } };
-
-/** focusSaw (line 1563) — the unpinned count is read from live memory. */
-export function focusSaw(memory) {
-  const unpinned = memory.long.filter(m => !m.pinned).length;
-  return [
-    { t: 'groom long-term memory — ' + unpinned + ' unpinned entries may be compacted away', action: 'mode:memory' },
-    { t: 'health budget — shadcn upkeep accepted 07-21 · 19% of budget spent', action: 'jump:workspace|workspace-shadcn-design-system' }
-  ];
-}
-
-/** focusEnds (line 1567) — one line per repository naming its first group. */
-export function focusEnds(products) {
-  return products.map(([id]) => {
-    const g0 = (ALLGROUPS[id] || [])[0];
-    return g0 ? { prod: id, obj: g0.gid + ' · ' + g0.gname } : null;
-  }).filter(Boolean);
-}
-
 /* ──────────────────────── derivation: repos + board ──────────────────────── */
 
 /** allProds (line 1431) — seed repositories plus anything the PM added. */
@@ -663,66 +526,8 @@ export function flowUse(userInits = {}) {
   return use;
 }
 
-/* ─────────────────── derivation: phases, tasks, detail ─────────────────── */
+/* ─────────────────── derivation: detail ─────────────────── */
 
-/**
- * synthTasks (lines 1720–1734) — the tasks a phase gets when the record does
- * not author any. Titles depend on the step's status; statuses and every field
- * are derived, never invented per initiative.
- */
-export function synthTasks(slug, k, s) {
-  const titles = {
-    done: ['read the inputs for ' + k, 'produce the ' + k + ' output', 'record the result'],
-    current: ['read the inputs for ' + k, 'produce the ' + k + ' output', 'record the result'],
-    blocked: ['resolve the ' + k + ' blocker', 'produce the ' + k + ' output'],
-    pending: ['read the inputs for ' + k, 'produce the ' + k + ' output']
-  }[s] || ['work the ' + k + ' step'];
-  return titles.map((title, idx) => {
-    let st = 'todo';
-    if (s === 'done') st = 'done';
-    else if (s === 'current') st = idx === 0 ? 'done' : (idx === 1 ? 'doing' : 'todo');
-    else if (s === 'blocked') st = idx === 0 ? 'blocked' : 'todo';
-    return {
-      title, status: st,
-      instruction: 'Run the ' + k + ' step for ' + slug + ' — ' + title + '. Read the referenced inputs, do the work, and write the phase output back to planning/.',
-      input: 'planning/initiatives/' + slug + '.md + prior phase outputs',
-      expect: 'A reviewable ' + k + ' artifact exists on disk so the phase can advance.',
-      evalNote: st === 'done' ? 'passed the ' + k + ' rubric' : 'graded against the ' + k + ' rubric before the phase advances',
-      output: st === 'done' ? 'planning/' + k + '/' + slug + '-' + k + '.md' : '—'
-    };
-  });
-}
-
-/** Authored tasks win; otherwise synthesise (line 1737). */
-export function tasksForPhase(record, step, slug) {
-  return (record.tasks && record.tasks[step.k]) ? record.tasks[step.k] : synthTasks(slug, step.k, step.s);
-}
-
-/** Phase status from its tasks (lines 1738–1743). Order matters. */
-export function phaseStatus(tasks) {
-  const doneN = tasks.filter(t => t.status === 'done').length;
-  if (tasks.some(t => t.status === 'blocked')) return 'blocked';
-  if (tasks.some(t => t.status === 'doing')) return 'doing';
-  if (doneN === tasks.length) return 'done';
-  if (doneN > 0) return 'doing';
-  return 'todo';
-}
-
-/**
- * phases (lines 1736–1756), without presentation. One entry per step:
- * `{ key, step, tasks, doneN, status, count }`. The panel adds dots, carets and
- * handlers — `TDOT[status]` gives the glyph + colour.
- */
-export function phasesFor(record, slug) {
-  return (record.steps || []).map(s => {
-    const tasks = tasksForPhase(record, s, slug);
-    const doneN = tasks.filter(t => t.status === 'done').length;
-    return { key: s.k, label: s.k, step: s, tasks, doneN, status: phaseStatus(tasks), count: doneN + '/' + tasks.length };
-  });
-}
-
-/** Task tab id (line 1750). */
-export const taskTabId = (slug, phaseKey, idx) => 'task:' + slug + ':' + phaseKey + '#' + idx;
 /** Terminal tab id (line 1399). */
 export const termTabId = (slug, sessName) => 'term:' + slug + ':' + sessName;
 /** Doc tab id (line 1400). */
@@ -829,20 +634,6 @@ export function makeLink(slug, src, existing = []) {
 export const sessionProfileNote = id => (id === 'claude-work'
   ? 'claude-work — workspace MCP live: jira · confluence · slack · google-workspace'
   : 'claude-personal — no workspace MCP; the session cannot touch Jira or Confluence');
-// scheduled-task note (line 1844)
-export const schedProfileNote = id => ((id || 'claude-work') === 'claude-work'
-  ? 'runs with workspace MCP — can read Jira and Confluence'
-  : 'runs without workspace MCP — local files only');
-// agent note (line 1892)
-export const agentProfileNote = id => ((id || 'claude-work') === 'claude-work'
-  ? 'claude-work — this agent reaches Jira, Confluence, Slack, Google Workspace over MCP'
-  : 'claude-personal — no workspace MCP; this agent cannot touch Jira or Confluence');
-// memory note (lines 1918–1920)
-export const memoryNote = scope => (scope === 'short'
-  ? 'Dies when its session exits. Promote it to keep it — the agent will see it in every future run.'
-  : 'Injected into every agent run. Pinned entries survive compaction; unpinned ones may be summarized away.');
-export const memoryPath = scope => (scope === 'short' ? 'runtime — session context' : 'memory/long-term.jsonl');
-
 /* ─────────────────────── the faux shell (fixture only) ─────────────────────── */
 
 /** The five lines a terminal pane opens with (lines 1983–1989). */
@@ -989,14 +780,11 @@ export const ADD_SOURCES = [['github', 'github repo'], ['local', 'local folder']
  * exports; they are needed in normal mode too.
  */
 export const FIXTURE = {
-  C, DOT, SDOT, TDOT, TONE,
-  FLOWS, PROFILES, INTG, INTG_PREVIEWS, SKILLS, KNOW, INGESTED_KNOW,
+  C, DOT, SDOT, TONE,
+  FLOWS, PROFILES, KNOW, INGESTED_KNOW,
   PRODUCTS, ADDABLE_PRODUCTS, ADD_DEFAULTS, ALLGROUPS, DATA, RAW_DOCS,
-  MENU, MODE_META, MODE_TITLES, SETTINGS_GROUPS, DETAIL_TITLES,
-  FOCUS_FIRST, FOCUS_WAITING, FOCUS_SYN, DELEGATE_SESSION,
+  MODE_TITLES, DETAIL_TITLES,
   TAB_COLORS, TERM_COLORS, SCRATCH_SEND_COLOR,
-  sched: SCHED_SEED, agents: AGENTS_SEED, memory: MEMORY_SEED,
-  defaultSched, defaultAgents, defaultMemory
 };
 
 export default FIXTURE;
@@ -1009,7 +797,6 @@ export default FIXTURE;
 const COCKPIT_SEED = (() => { try { return new URLSearchParams(location.search).get('fixture') === 'cockpit'; } catch { return false; } })();
 const SEED_DEFAULTS = { microsites: 'ooh-weather-expansion', pmos: 'cockpit-terminal-mod', 'scarlet': 'scarlet-onboarding' };
 if (COCKPIT_SEED) {
-  const task = (title, status, k) => ({ title, status, instruction: 'Run ' + title + '.', input: 'planning/ + prior phase outputs', expect: 'A reviewable ' + k + ' artifact exists.', evalNote: 'graded against the ' + k + ' rubric', output: status === 'done' ? 'planning/' + k + '/' + k + '.md' : '—' });
   PRODUCTS.splice(0, PRODUCTS.length, ['microsites', '6', 'github'], ['pmos', '3', 'local'], ['scarlet', '1', 'github']);
   for (const k of Object.keys(ALLGROUPS)) delete ALLGROUPS[k];
   ALLGROUPS.microsites = [{ gid: 'O2', idc: C.fg, gname: 'Microsites ship on time', gct: '6', hasKr: true, krid: 'KR1', krname: 'q3-2026', krct: '6',
@@ -1024,12 +811,6 @@ if (COCKPIT_SEED) {
     { k: 'spec', s: 'done', t: '' }, { k: 'build', s: 'done', t: '' }, { k: 'eval', s: 'blocked', t: '' }, { k: 'accepted', s: 'pending', t: '' }], {
     pills: [{ t: 'feature', c: C.mut }, { t: 'q3-2026 · O2 · KR1', c: C.mut }, { t: '⇄ Jira OOH-212', c: C.mut }],
     blocker: { label: 'Merge', evidence: 'needs a grant for PR 41', next: '' },
-    tasks: {
-      spec: [task('Write the PRD', 'done', 'spec'), task('Write the rubric', 'done', 'spec')],
-      build: [task('Build the forecast units', 'done', 'build'), task('Wire the regional feed', 'done', 'build'), task('Add the tests', 'done', 'build')],
-      eval: [task('Run independent review', 'blocked', 'eval'), task('Record outcome check', 'todo', 'eval')],
-      accepted: [task('Accept the run', 'todo', 'accepted')],
-    },
     sessions: [{ name: 'claude · merge PR 41', st: 'working', label: 'working' }, { name: 'review run', st: 'working', label: 'working' }],
     arts: [{ role: 'PRD', path: 'planning/prd/ooh-weather-expansion-prd.md', dest: null }] });
   DATA['psle-paywall-revamp'] = mk('PSLE paywall revamp', 'accepted', oneStep('accepted', 'pending'));

package/workspace/public/pm/frame-copy.js

@@ -0,0 +1,94 @@
+/* pm/frame-copy.js — every string of the frame: the top bar, the dock, the phone chrome and the Settings destination
+ * (pm-os-absorb Run 3, slice 3A; PRD R9, R10, R15).
+ *
+ * Pure data, no import: glossary.test.js loads this file in Node and holds every string, and guide/layout.md, to the R2
+ * rules. The words follow the PMOS-STE instructional register: short sentences, one instruction each, the active voice.
+ */
+
+export const COPY = {
+  repo: {
+    all: 'All repositories',
+    none: 'No repository',
+    menu: 'Choose a repository',
+    open: (name) => 'Repository: ' + name + '. Choose a repository.',
+  },
+  nav: {
+    label: 'Destinations',
+    today: 'Today',
+    initiatives: 'Initiatives',
+    board: 'Board',
+    reports: 'Reports',
+    agent: 'Agent',
+    settings: 'Settings',
+  },
+  /** The Today count on the top bar and on the phone tab, for a screen reader. */
+  needs: (n) => (n === 1 ? '1 needs you' : n + ' need you'),
+  search: 'Search or capture',
+  searchKey: '⌘K',
+  sync: {
+    label: 'Sync',
+    busy: 'Syncing',
+    title: 'Sync this repository: fetch, bring in the work of the other machine, record your changes, push.',
+    done: 'The repository is in sync.',
+    stopped: (step, why) => 'Sync stopped at ' + step + ': ' + why,
+  },
+  settings: 'Settings',
+  dock: {
+    open: 'Open the agent dock (⌘J)',
+    fold: 'Fold the agent dock (⌘J)',
+    session: 'Session',
+    sessionMenu: 'Start a session',
+    newSession: 'New session',
+    withOptions: 'Session with options',
+    skillsHead: 'Start from a skill',
+    noSkills: 'No skills to start from.',
+    skillsUnread: 'The skills list did not load.',
+  },
+  detail: { close: 'Close the detail' },
+  phone: {
+    back: 'Back',
+    pin: 'Search or capture',
+  },
+  page: {
+    title: 'Settings',
+    intro: 'Settings for this workspace. Your work is in Today, Initiatives, Board and Reports.',
+    repos: 'Repositories',
+    reposEmpty: 'No repository is registered. Add one to start.',
+    add: 'Add repository',
+    addClose: 'Close Add repository',
+    current: 'Current',
+    use: 'Use this repository',
+    show: 'Show its initiatives',
+    rename: 'Rename',
+    remove: 'Remove from PMOS',
+    more: (name) => 'More for ' + name,
+    profiles: 'Profiles',
+    profilesRow: 'Claude profiles',
+    profilesMeta: 'Open the profiles a Claude session can start with.',
+    profilesOpen: 'Open the profiles',
+    sessions: 'New sessions',
+    cli: 'Default CLI',
+    cliShell: 'Shell',
+    cliClaude: 'Claude',
+    model: 'Default model',
+    modelAuto: 'Auto',
+    modelFast: 'Fast',
+    modelBalanced: 'Balanced',
+    modelDeep: 'Deep',
+    sessionsNote: 'The dock starts new sessions with these defaults. A model applies only to a Claude session.',
+    validate: 'Validate consent',
+    validateOn: 'Validation is on for this repository.',
+    validateOff: 'Validation is off. Nothing from this repository is sent.',
+    validateUnread: 'The consent of this repository did not load.',
+    validateNoRepo: 'Choose a repository to set its consent.',
+    validateOpen: 'Open Validate',
+    turnOn: 'Turn on',
+    turnOff: 'Turn off',
+    theme: 'Theme',
+    dark: 'Dark',
+    light: 'Light',
+  },
+};
+
+/* The rules of glossary.test.js apply to every string above and to guide/layout.md, with no exemption. */
+export const GLOSSARY = { guide: 'layout.md' };

package/workspace/public/pm/handoff-box.js

@@ -0,0 +1,82 @@
+/* pm/handoff-box.js — Hand to agent, inside the item sheet (pm-os-absorb Run 1, PRD R14).
+ *
+ * Two presses, as the next-step Work path does: the first asks the server what it WOULD start (prepare, which starts
+ * nothing) and shows it in one line — "Agent will: <first line of the prompt> · <where>" — with the full prompt and the
+ * branch folded under Details. Go starts exactly that: it sends the hash of the prompt the PM was shown, and the server
+ * refuses a prompt that changed in the meantime. On success the sheet closes and the new session opens in its terminal tab.
+ *
+ * Nothing else starts a session from the Breakdown: no drag, drop or state change calls a handoff route.
+ */
+
+import { el } from './dom.js';
+import { button, toast } from './primitives.js';
+import { COPY } from './breakdown-copy.js';
+import { prepareHandoff, goHandoff } from './breakdown-api.js';
+
+let iniMod = null;
+const iniReady = () => (iniMod ? Promise.resolve(iniMod) : import('./panel-initiatives.js').then((m) => { iniMod = m; return m; }).catch(() => null));
+
+/** Open the terminal tab of a running session, the way next-step-ui.js does after Go. */
+export async function openSessionTab(slug, session) {
+  const m = await iniReady();
+  if (m && session) m.openTerm(slug, { id: session.id, name: session.name || session.id, st: 'working' });
+}
+
+/**
+ * handoffBox({ ws, slug, item, sessions, onCancel, onStarted(session) }) -> the box element. It prepares at once.
+ * `sessions` is the app's session list, used only to name a session the server says is already bound.
+ */
+export function handoffBox({ ws, slug, item, sessions, onCancel, onStarted }) {
+  const box = el('div', { class: 'bd-handoff', 'data-bd-handoff': item.id, role: 'group', 'aria-label': COPY.handToAgent });
+  const say = (...kids) => { while (box.firstChild) box.removeChild(box.firstChild); for (const k of kids) if (k) box.appendChild(k); };
+  const cancel = button({ label: COPY.cancel, variant: 'ghost', attrs: { 'data-bd-handoff-cancel': '' }, onClick: () => { if (onCancel) onCancel(); } });
+
+  const busy = (sessionId) => {
+    const s = (sessions || []).find((x) => x && x.id === sessionId) || (sessionId ? { id: sessionId, name: sessionId } : null);
+    say(el('div', { class: 'bd-handoff__line' }, COPY.busy),
+      el('div', { class: 'bd-handoff__actions' },
+        s ? button({ label: COPY.openSession, variant: 'outline', attrs: { 'data-bd-handoff-open': '' }, onClick: () => openSessionTab(slug, s) }) : null,
+        cancel));
+  };
+  const failed = (text) => say(el('div', { class: 'bd-handoff__line bd-handoff__error' }, text),
+    el('div', { class: 'bd-handoff__actions' }, cancel));
+
+  const ready = (prep) => {
+    const go = button({
+      label: COPY.go, variant: 'primary', attrs: { 'data-bd-handoff-go': '' },
+      onClick: async () => {
+        go.disabled = true;
+        const out = await goHandoff(ws, item.id, prep.prompt_sha);
+        if (out && out.ok !== false && out.session) {
+          if (onStarted) onStarted(out.session);
+          await openSessionTab(slug, out.session);
+          toast({ text: COPY.sessionStarted(out.session.name || out.session.id) });
+          return;
+        }
+        if (out && out.session) { busy(out.session); return; }
+        failed((out && out.error) || 'nothing was started');
+      },
+    });
+    const facts = el('dl', { class: 'bd-handoff__facts' },
+      el('dt', null, COPY.branch), el('dd', null, (prep.details && prep.details.branch) || prep.where || ''),
+      el('dt', null, COPY.folder), el('dd', null, (prep.details && prep.details.tree) || ''));
+    say(el('div', { class: 'bd-handoff__line', 'data-bd-handoff-line': '' }, prep.line || COPY.agentWill(prep.first || '', prep.where || '')),
+      el('div', { class: 'bd-handoff__actions' }, go, cancel),
+      el('details', { class: 'bd-handoff__details' },
+        el('summary', null, COPY.details),
+        el('pre', { class: 'bd-handoff__prompt' }, prep.prompt || ''),
+        facts));
+    go.focus({ preventScroll: true });
+    // the whole box in view, above the sheet's sticky action row (scroll-margin in components.css)
+    if (typeof box.scrollIntoView === 'function') box.scrollIntoView({ block: 'nearest' });
+  };
+
+  say(el('div', { class: 'bd-handoff__line bd-muted' }, COPY.preparing), el('div', { class: 'bd-handoff__actions' }, cancel));
+  prepareHandoff(ws, item.id).then((out) => {
+    if (!box.isConnected && !box.parentNode) return;
+    if (out && out.ok !== false) ready(out);
+    else if (out && out.session) busy(out.session);
+    else failed((out && out.error) || 'could not prepare');
+  });
+  return box;
+}

package/workspace/public/pm/http.js

@@ -0,0 +1,88 @@
+/* pm/http.js — the one way new page code calls the workspace server (pm-os-absorb Runs 2 to 5, PRD R25).
+ *
+ *   pmPost(path, body, { keepalive })  → Promise of the server's JSON, or { ok:false, status?, error }
+ *   pmGet(path)                        → the same
+ *   pmHeaders()                        → the headers every request carries
+ *   pressFetch(url, init)              → fetch with pmHeaders; a 403 from a stale nonce is retried once with the new one
+ *   pageNonce()                        → this launch's nonce as the page holds it ('' when none)
+ *
+ * Every PM-only press (Move to Now, adopt, Issue, Release, lifecycle, Accept) goes through pmPost, so Run 2 adds the
+ * per-launch nonce in pmHeaders and every press carries it at once. Relative URLs only, to this server; the browser
+ * sends the page's own Origin header. Nothing here sends `by`, `via` or `at`: the writer sets them from the call path.
+ * None of these throws. In FIXTURE mode none of them makes a request.
+ *
+ * THE NONCE (Run 2, slice 2A). The server writes a per-launch value into `<meta name="pmos-nonce">` when it serves the
+ * page. pmHeaders reads it once and sends it as `x-pmos-nonce`; the server refuses a press without it (403). The older
+ * POST helpers (data.js postJson, breakdown-api.js call, view-addrepo.js act) send through pressFetch, so they carry it
+ * too and keep their own error texts. A restarted server mints a new value, and an open page still holds the old one:
+ * on a 403, pressFetch reads the meta again from GET / and, when the value changed, sends the same press once more.
+ * The terminal's WebSocket sends the nonce as the `pmos-nonce` query parameter (tab-term.js), because a browser
+ * WebSocket cannot set a header; without it a new session starts with no initiative.
+ */
+
+import { FIXTURE } from './state.js';
+
+let nonce = null;
+/** The meta's value, read once. '' when the page has none (fixture mode, or a server that mints none). */
+function launchNonce() {
+  if (nonce !== null) return nonce;
+  let v = '';
+  try {
+    const m = typeof document !== 'undefined' ? document.querySelector('meta[name="pmos-nonce"]') : null;
+    v = (m && m.getAttribute('content')) || '';
+  } catch { v = ''; }
+  nonce = v;
+  return nonce;
+}
+
+export const pageNonce = () => launchNonce();
+
+/** Read the nonce again from GET /. True only when the server now holds a different, non-empty value. */
+async function refreshNonce() {
+  if (FIXTURE) return false;
+  let html;
+  try {
+    const r = await fetch('/', { cache: 'no-store' });
+    if (!r.ok) return false;
+    html = await r.text();
+  } catch { return false; }
+  const m = /<meta name="pmos-nonce" content="([^"]*)"/.exec(html || '');
+  const v = m ? m[1] : '';
+  if (!v || v === launchNonce()) return false;
+  nonce = v;
+  try { const el = document.querySelector('meta[name="pmos-nonce"]'); if (el) el.setAttribute('content', v); } catch { /* no DOM */ }
+  return true;
+}
+
+/** fetch with this page's headers. Throws as fetch throws; the callers turn that into their own error text. */
+export async function pressFetch(url, init = {}) {
+  const send = () => fetch(url, { ...init, headers: { ...pmHeaders(), ...(init.headers || {}) } });
+  const res = await send();
+  if (res.status !== 403 || !(await refreshNonce())) return res;
+  return send();   // the workspace restarted since this page loaded: the same press, once, with the new nonce
+}
+
+export function pmHeaders() {
+  const n = launchNonce();
+  return n ? { 'Content-Type': 'application/json', 'x-pmos-nonce': n } : { 'Content-Type': 'application/json' };
+}
+
+async function request(method, path, body, opts) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode' };
+  let res;
+  try {
+    res = method === 'GET' ? await fetch(path, { headers: pmHeaders() }) : await pressFetch(path, {
+      method, body: JSON.stringify(body === undefined ? {} : body), keepalive: !!(opts && opts.keepalive),
+    });
+  } catch (e) {
+    return { ok: false, error: 'could not reach the workspace server — ' + ((e && e.message) || String(e)) };
+  }
+  let out;
+  try { out = await res.json(); } catch { return { ok: false, status: res.status, error: path + ' did not answer JSON (HTTP ' + res.status + ')' }; }
+  if (!res.ok && out && out.ok !== false) return { ok: false, status: res.status, error: 'HTTP ' + res.status + ' from ' + path };
+  if (out && typeof out === 'object' && !res.ok) out.status = res.status;
+  return out;
+}
+
+export const pmPost = (path, body, opts) => request('POST', path, body, opts);
+export const pmGet = (path) => request('GET', path);

package/workspace/public/pm/icons.js

@@ -0,0 +1,53 @@
+/* pm/icons.js — the lucide icons the Breakdown uses (D86 point 6).
+ *
+ * The 29 symbols live in one vendored sprite, /vendor/lucide-sprite.js, generated from lucide-static 1.52.0 (see
+ * workspace/third-party/README.md). `ensureSprite()` loads it once and puts it in the overlay layer; `icon(name)` returns
+ * an <svg> that points at one symbol. Icons are decoration only: every one is aria-hidden, and a control that shows only
+ * an icon carries its own aria-label (primitives.js `iconButton` refuses to build one without).
+ */
+
+import { layer } from './primitives.js';
+
+const SVG_NS = 'http://www.w3.org/2000/svg';
+let loading = null;
+
+/** Load the sprite once and insert it into the layer. Resolves to true when the symbols are on the page. */
+export function ensureSprite() {
+  const host = layer();
+  if (!host) return Promise.resolve(false);
+  if (host.querySelector('.pmc-sprite')) return Promise.resolve(true);
+  if (!loading) {
+    loading = import('/vendor/lucide-sprite.js').then((m) => {
+      const holder = layer();
+      if (!holder || holder.querySelector('.pmc-sprite')) return true;
+      const box = document.createElement('div');
+      box.className = 'pmc-sprite';
+      box.setAttribute('aria-hidden', 'true');
+      box.innerHTML = m.SPRITE;
+      holder.appendChild(box);
+      return true;
+    }).catch((e) => {
+      loading = null;
+      console.warn('[breakdown] the icon sprite did not load:', (e && e.message) || e);
+      return false;
+    });
+  }
+  return loading;
+}
+
+/** `<svg class="pmc-icon" aria-hidden="true" focusable="false"><use href="#lucide-NAME"></use></svg>`, 16px, currentColor. */
+export function icon(name) {
+  const svg = document.createElementNS(SVG_NS, 'svg');
+  svg.setAttribute('class', 'pmc-icon');
+  svg.setAttribute('aria-hidden', 'true');
+  svg.setAttribute('focusable', 'false');
+  /* 16 × 16 before components.css arrives: without a size an <svg> renders at the UA default of 300 × 150, and the
+   * detail jumped by ~150px on first paint. The stylesheet still governs the size once it loads. */
+  svg.setAttribute('width', '16');
+  svg.setAttribute('height', '16');
+  svg.setAttribute('data-icon', name);
+  const use = document.createElementNS(SVG_NS, 'use');
+  use.setAttribute('href', '#lucide-' + name);
+  svg.appendChild(use);
+  return svg;
+}