create-pmos 0.123.0 → 0.125.0

package/workspace/lib/routes-roadmap-ops.js

@@ -0,0 +1,141 @@
+'use strict';
+/* routes-roadmap-ops.js — the Roadmap's and the Breakdown's writes (console3 wave E1b; HANDOFF 14e/14f).
+ *
+ *   POST /api/roadmap-ops/bet/add     { title, anchor, horizon?, confidence?, initiative? } → { ok, rid } | 400 refusal
+ *   POST /api/roadmap-ops/bet/move    { id, to, confirmSwap? } → { ok, written } | { ok, proposal } (a full column: nothing moved)
+ *   POST /api/roadmap-ops/bet/take-off { id, reason }          → { ok }       reason required
+ *   GET  /api/roadmap-ops/bet/anchor-suggestions?id=           → { ok, suggestions }   word overlap only, empty when none
+ *   POST /api/roadmap-ops/breakdown/add    { title, phase, source?, owner?, points?, initiative? } → { ok, rid }
+ *   POST /api/roadmap-ops/breakdown/edit   { rid, fields }     → { ok } | { ok, proposal:true, proposals } for Jira-owned fields
+ *   POST /api/roadmap-ops/breakdown/delete { rid }             → { ok, undo_ms } | 409 with unlink advice for a Jira-backed item
+ *   POST /api/roadmap-ops/breakdown/undo   { rid }             → { ok } inside 8 seconds
+ *   POST /api/roadmap-ops/breakdown/dependency { rid, jira, remove? } → { ok }   the item waits on that Jira ticket
+ *   POST /api/roadmap-ops/people  { id, points_per_week }      → { ok, people }  writes <runtime>/people.json
+ *
+ * STATE: bets in planning/records/bets.jsonl (scripts/records); breakdown items in <records>/breakdown-pmos.jsonl
+ * (scripts/breakdown-ops.js); people in <runtime>/people.json (the file routes-forecast.js already reads).
+ * WHO WRITES: every POST passes pm-guard requirePagePress; an agent session is refused (403). Pure handlers are exported.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
+const ledger = require(path.join(__dirname, '..', '..', 'scripts', 'trust', 'ledger.js'));
+const roadmap = require(path.join(__dirname, '..', '..', 'scripts', 'roadmap-ops.js'));
+const breakdown = require(path.join(__dirname, '..', '..', 'scripts', 'breakdown-ops.js'));
+
+const REPO = path.join(__dirname, '..', '..');
+const rootOf = (ctx) => (ctx && ctx.recordsDir) || path.join((ctx && ctx.repoRoot) || REPO, 'planning', 'records');
+const UI = () => ledger.actorFrom({ ui: true });
+const out = (status, body) => ({ status, body });
+const refusal = (r, status = 400) => out(status, { ok: false, error: r.error, ...Object.fromEntries(Object.entries(r).filter(([k]) => !['ok', 'error'].includes(k))) });
+
+function writeBets(root, r) {
+  const w = roadmap.apply(root, r.events, UI());
+  return w.ok ? out(200, { ok: true, written: w.written, rid: w.written[0], ...(r.swapped ? { swapped: r.swapped } : {}) }) : out(400, { ok: false, error: w.reasons.join('; '), reasons: w.reasons });
+}
+function writeBreakdown(root, r, extra, opts) {
+  const w = breakdown.apply(root, r.events, UI(), opts);
+  return w.ok ? out(200, { ok: true, ...extra }) : out(400, { ok: false, error: w.error });
+}
+
+/** Pure handlers: (root, body, ...) -> { status, body }. The press check happens before these. */
+function betAdd(root, body, ctx) {
+  const krs = records.list(root, 'kr-metrics').map((k) => ({ id: k.rid, title: k.metric }));
+  const r = roadmap.addBet(records.list(root, 'bets'), body, { krs: (ctx && ctx.krs) || krs });
+  return r.ok ? writeBets(root, r) : refusal(r);
+}
+function betMove(root, body, ctx) {
+  const krs = records.list(root, 'kr-metrics').map((k) => ({ id: k.rid, title: k.metric }));
+  const r = roadmap.moveBet(records.list(root, 'bets'), body.id, body.to, body.capacity, { confirmSwap: body.confirmSwap === true, krs: (ctx && ctx.krs) || krs });
+  if (!r.ok) return refusal(r);
+  return r.proposal ? out(200, { ok: true, proposal: r.proposal }) : writeBets(root, r);
+}
+function betTakeOff(root, body) {
+  const r = roadmap.takeOff(records.list(root, 'bets'), body.id, body.reason);
+  return r.ok ? writeBets(root, r) : refusal(r);
+}
+function healthBudgets(repoRoot) {
+  try {
+    const t = fs.readFileSync(path.join(repoRoot, 'planning', 'okrs', 'health-budgets.md'), 'utf8');
+    return [...t.matchAll(/^\|\s*`health:([a-z0-9-]+)`\s*\|\s*([^|]+?)\s*\|/gm)].map((m) => ({ id: 'health:' + m[1], title: m[2] }));
+  } catch { return []; }
+}
+function betAnchorSuggestions(root, query, ctx) {
+  const bet = records.list(root, 'bets').find((b) => b.rid === (query && query.id));
+  if (!bet) return out(404, { ok: false, error: 'no such bet' });
+  const krs = (ctx && ctx.krs) || records.list(root, 'kr-metrics').map((k) => ({ id: k.rid, title: k.metric }));
+  const hb = (ctx && ctx.healthBudgets) || healthBudgets((ctx && ctx.repoRoot) || REPO);
+  return out(200, { ok: true, id: bet.rid, suggestions: roadmap.anchorSuggestions(bet, krs, hb) });
+}
+function breakdownAdd(root, body) {
+  const r = breakdown.addItem(breakdown.list(root), body);
+  return r.ok ? writeBreakdown(root, r, { rid: r.rid }) : refusal(r);
+}
+function breakdownEdit(root, body) {
+  const r = breakdown.editItem(breakdown.list(root), body.rid, body.fields);
+  if (!r.ok) return refusal(r, /no such/.test(r.error) ? 404 : 400);
+  const extra = r.proposal ? { proposal: true, proposals: r.proposals, note: r.note, applied: r.events.length > 0 } : {};
+  return r.events.length ? writeBreakdown(root, r, extra) : out(200, { ok: true, ...extra });
+}
+function breakdownDelete(root, body, opts) {
+  const r = breakdown.deleteItem(breakdown.list(root), body.rid, opts);
+  if (!r.ok) return refusal(r, r.jira_backed ? 409 : /no such/.test(r.error) ? 404 : 400);
+  return writeBreakdown(root, r, { undo_ms: r.undo_ms }, opts);
+}
+function breakdownUndo(root, body, opts) {
+  const r = breakdown.undoEvent(breakdown.readLines(root), body.rid, opts && opts.now);
+  return r.ok ? writeBreakdown(root, r, {}, opts) : refusal(r, r.expired ? 410 : 404);
+}
+function breakdownDependency(root, body) {
+  const r = breakdown.setDependency(breakdown.list(root), body.rid, body.jira, { remove: body.remove === true });
+  return r.ok ? writeBreakdown(root, r, {}) : refusal(r);
+}
+function setPeople(runtimeDir, body) {
+  const ppw = Number(body && body.points_per_week);
+  if (!body || !String(body.id || '').trim()) return out(400, { ok: false, error: 'a person id is required' });
+  if (!Number.isFinite(ppw) || ppw < 0 || ppw > 100) return out(400, { ok: false, error: 'points_per_week must be a number from 0 to 100' });
+  const file = path.join(runtimeDir, 'people.json');
+  let doc = { people: [] };
+  try { doc = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { /* none yet */ }
+  const people = Array.isArray(doc.people) ? doc.people : [];
+  const i = people.findIndex((p) => p && p.id === body.id);
+  if (i >= 0) people[i] = { ...people[i], points_per_week: ppw }; else people.push({ id: body.id, points_per_week: ppw, skills: [] });
+  fs.mkdirSync(runtimeDir, { recursive: true });
+  fs.writeFileSync(file, JSON.stringify({ ...doc, people }, null, 2) + '\n');
+  return out(200, { ok: true, people });
+}
+
+const POSTS = {
+  '/bet/add': (c, b) => betAdd(rootOf(c), b, c),
+  '/bet/move': (c, b) => betMove(rootOf(c), b, c),
+  '/bet/take-off': (c, b) => betTakeOff(rootOf(c), b),
+  '/breakdown/add': (c, b) => breakdownAdd(rootOf(c), b),
+  '/breakdown/edit': (c, b) => breakdownEdit(rootOf(c), b),
+  '/breakdown/delete': (c, b) => breakdownDelete(rootOf(c), b),
+  '/breakdown/undo': (c, b) => breakdownUndo(rootOf(c), b),
+  '/breakdown/dependency': (c, b) => breakdownDependency(rootOf(c), b),
+  '/people': (c, b) => setPeople(c.runtimeDir, b),
+};
+
+module.exports = {
+  prefixes: ['/api/roadmap-ops'],
+  betAdd, betMove, betTakeOff, betAnchorSuggestions, breakdownAdd, breakdownEdit, breakdownDelete, breakdownUndo, breakdownDependency, setPeople, healthBudgets, rootOf,
+  handle: async (req, res, url, ctx) => {
+    const sub = url.pathname.slice('/api/roadmap-ops'.length);
+    if (req.method === 'GET' && sub === '/bet/anchor-suggestions') {
+      const r = betAnchorSuggestions(rootOf(ctx), { id: url.searchParams.get('id') }, ctx);
+      ctx.json(res, r.body, r.status);
+      return true;
+    }
+    if (req.method !== 'POST' || !POSTS[sub]) return false;
+    const got = await ctx.readJson(req);
+    if (!got.ok) { ctx.json(res, { ok: false, error: 'invalid JSON body' }, 400); return true; }
+    const body = got.body || {};
+    const g = guard.requirePagePress(req, body);
+    if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
+    const r = POSTS[sub](ctx, body);
+    ctx.json(res, r.body, r.status);
+    return true;
+  },
+};

package/workspace/lib/routes-runs.js

@@ -0,0 +1,119 @@
+'use strict';
+/* routes-runs.js — the agent runs surface (console3 wave A3).
+ *
+ *   GET  /api/runs              the sessions grouped (scripts/sessions-list.js) and, per run, its card (scripts/card-state.js)
+ *   POST /api/runs/answer       { run, request, behavior, message? }  the PM answers a held request (page press only)
+ *   POST /api/runs/correction   { run, kind, reason }                 a Reject or Revise, counted (page press only)
+ *
+ * Runs are read from the session meta files (<runtimeDir>/sessions/<id>.json), the reply lines
+ * (<runtimeDir>/replies/<id>.jsonl) and the hook lines (<runtimeDir>/hooks/<id>.jsonl). Nothing is sent outward.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const actor = require('./actor.js');
+const runAnswers = require('./run-answers.js');
+const { groupSessions } = require('../../scripts/sessions-list.js');
+const { cardFor, correctionEvent } = require('../../scripts/card-state.js');
+const { readLines, runFor, foldReplies } = require('../../scripts/replies.js');
+const C = require('../../scripts/reply-contract/reply-contract.js');
+const { appendOutbox } = require('../../scripts/outbox.js');
+
+const prefixes = ['/api/runs'];
+const RUN_RE = /^sess-\d+$/;
+
+function sessionsOf(sessDir) {
+  let names = [];
+  try { names = fs.readdirSync(sessDir).filter((n) => /^sess-\d+\.json$/.test(n)); } catch { return []; }
+  const out = [];
+  for (const n of names) {
+    let meta; let st;
+    try { const f = path.join(sessDir, n); meta = JSON.parse(fs.readFileSync(f, 'utf8')); st = fs.statSync(f); } catch { continue; }
+    if (!meta || !meta.id) continue;
+    const exited = meta.state === 'exited';
+    out.push({ id: meta.id, plan_item: meta.plan_item || null, name: meta.name || meta.id, origin: meta.origin || 'manual', cardId: meta.plan_item || null,
+      startedAt: meta.created || null, endedAt: exited ? st.mtimeMs : null });
+  }
+  return out;
+}
+
+// Open permission requests: a PermissionRequest line with no PM answer yet.
+function pendingFor(run, hookLines, answers) {
+  const seen = new Set();
+  const out = [];
+  for (const l of hookLines) {
+    if (!l || l.event !== 'PermissionRequest') continue;
+    const id = runAnswers.requestIdOf(l.body);
+    if (l.policy && l.policy.act !== 'card') continue;   // the contract's policy settled it; no card
+    if (seen.has(id) || runAnswers.answerFor(run, id, answers)) continue;
+    seen.add(id);
+    const b = l.body || {};
+    const inp = b.tool_input && typeof b.tool_input === 'object' ? b.tool_input : {};
+    out.push({ request: id, tool: b.tool_name || '', command: String(inp.command || inp.file_path || '').slice(0, 300), cwd: b.cwd || '', at: l.at });
+  }
+  return out;
+}
+
+function lastAtOf(lines) {
+  const t = lines.map((l) => l && l.at && Date.parse(l.at)).filter(Number.isFinite);
+  return t.length ? Math.max(...t) : 0;
+}
+
+function view(ctx, now = Date.now()) {
+  const sessions = sessionsOf(ctx.sessDir || path.join(ctx.runtimeDir, 'sessions'));
+  const answers = runAnswers.readAnswers(runAnswers.answersFile(ctx.runtimeDir));
+  const groups = groupSessions(sessions, now);
+  const cards = {};
+  for (const s of sessions) {
+    const live = s.endedAt == null;
+    const recent = !live && now - s.endedAt <= 7 * 864e5;
+    if (!live && !recent) continue;
+    const lines = readLines(path.join(ctx.runtimeDir, 'replies', s.id + '.jsonl'));
+    const run = runFor({ session: s.id, plan_item: s.plan_item });
+    const card = cardFor(lines, { run, extra: runAnswers.asEvents(run, answers), ended: !live, ctx: { now, lastAt: lastAtOf(lines) } });
+    card.asked = card.ask ? card.ask.id : null;
+    card.permissions = pendingFor(s.id, readLines(path.join(ctx.runtimeDir, 'hooks', s.id + '.jsonl')), answers);
+    cards[s.id] = card;
+  }
+  return { ok: true, groups, cards };
+}
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  if (p === '/api/runs') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    ctx.json(res, view(ctx));
+    return true;
+  }
+  if (p !== '/api/runs/answer' && p !== '/api/runs/correction') return false;
+  if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
+  const got = await ctx.readJson(req);
+  if (!got.ok) { ctx.json(res, { ok: false, error: 'body must be JSON' }, 400); return true; }
+  const body = got.body;
+  const tok = req.headers && req.headers['x-pmos-session'];
+  if (tok) { ctx.json(res, { ok: false, error: 'an agent session cannot answer a run' }, 403); return true; }
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
+  if (p === '/api/runs/answer') {
+    // An answer to the agent's own question must be one of the options it offered (the contract's answerLine).
+    if (body.behavior === 'answer' && typeof body.run === 'string' && RUN_RE.test(body.run)) {
+      const run = runFor({ session: body.run });
+      const open = foldReplies(readLines(path.join(ctx.runtimeDir, 'replies', body.run + '.jsonl')), run).ask;
+      if (open && open.id === body.request) {
+        const al = C.answerLine(run, open, body.message, { by: 'pm', via: 'ui' });
+        if (al.error) { ctx.json(res, { ok: false, error: al.error }, 400); return true; }
+      }
+    }
+    const r = runAnswers.recordAnswer(runAnswers.answersFile(ctx.runtimeDir), body, actor.fromUi());
+    ctx.json(res, r.ok ? { ok: true } : { ok: false, error: r.error }, r.ok ? 200 : r.status);
+    return true;
+  }
+  if (typeof body.run !== 'string' || !RUN_RE.test(body.run)) { ctx.json(res, { ok: false, error: 'run must be a session id' }, 400); return true; }
+  let ev;
+  try { ev = correctionEvent(body.kind, body.reason, body.run); } catch (e) { ctx.json(res, { ok: false, error: e.message }, 400); return true; }
+  appendOutbox(path.join(ctx.runtimeDir, 'corrections.jsonl'), ev);
+  ctx.json(res, { ok: true });
+  return true;
+}
+
+module.exports = { prefixes, handle, view, sessionsOf };

package/workspace/lib/routes-signals.js

@@ -0,0 +1,50 @@
+'use strict';
+/* routes-signals.js — the Signals page records (console3 wave E2a). Rules from scripts/signal-rules.js.
+ *
+ *   GET  /api/signals                 → { ok, rules, readings, trips, open }   readings = latest per metric; open = tripping now
+ *   POST /api/signals/rule    { id, metric, op, threshold, severity } → { ok, rule }
+ *   POST /api/signals/reading { metric, value, read_at? }                  → { ok, trips }  trips this reading started
+ *
+ * Every POST passes pm-guard requirePagePress: an agent token has no Origin and no nonce and is refused (403).
+ * File: <runtime>/signals/signals.jsonl (append only, scripts/trust/ledger.js). */
+const path = require('path');
+const guard = require('./pm-guard.js');
+const S = require('../../scripts/signal-rules.js');
+const L = require('../../scripts/trust/ledger.js');
+
+const fileOf = (runtimeDir) => path.join(runtimeDir, 'signals', 'signals.jsonl');
+const fail = (status, error) => ({ status, body: { ok: false, error } });
+
+function list(runtimeDir) { return { status: 200, body: { ok: true, ...S.foldSignals(L.read(fileOf(runtimeDir))) } }; }
+
+function ruleRoute(req, body, runtimeDir, now = new Date()) {
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return fail(g.status, g.error);
+  try { const l = S.appendRule(fileOf(runtimeDir), body, L.actorFrom({ ui: true }), now.toISOString()); return { status: 200, body: { ok: true, rule: l.rule } }; }
+  catch (e) { return fail(400, e.message); }
+}
+
+function readingRoute(req, body, runtimeDir, now = new Date()) {
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return fail(g.status, g.error);
+  try { const r = S.appendReading(fileOf(runtimeDir), { metric: body.metric, value: body.value, at: body.read_at }, L.actorFrom({ ui: true }), now.toISOString()); return { status: 200, body: { ok: true, trips: r.trips.map((t) => ({ rule_id: t.rule_id, severity: t.severity, reading: t.reading })) } }; }
+  catch (e) { return fail(400, e.message); }
+}
+
+const ROUTES = { 'POST /api/signals/rule': ruleRoute, 'POST /api/signals/reading': readingRoute };
+
+module.exports = {
+  prefixes: ['/api/signals'],
+  list, ruleRoute, readingRoute, ROUTES, fileOf,
+  handle: async (req, res, url, ctx) => {
+    const p = url.pathname;
+    if (p === '/api/signals' && req.method === 'GET') { const r = list(ctx.runtimeDir); ctx.json(res, r.body, r.status); return true; }
+    const fn = ROUTES[`${req.method} ${p}`];
+    if (!fn) return false;
+    const got = await ctx.readJson(req);
+    if (!got.ok) { ctx.json(res, { ok: false, error: 'invalid JSON body' }, 400); return true; }
+    const r = fn(req, got.body || {}, ctx.runtimeDir);
+    ctx.json(res, r.body, r.status);
+    return true;
+  },
+};

package/workspace/lib/run-answers.js

@@ -0,0 +1,69 @@
+'use strict';
+/* run-answers.js — the PM's answers to a held request from a run (planning-flows console3 wave A3).
+ *
+ *   requestIdOf(hookBody)                      → a stable id for a PermissionRequest body
+ *   recordAnswer(file, input, actor, now)      → { ok, line } | { ok: false, status, error }   single-writer append
+ *   readAnswers(file)                          → the lines
+ *   answerFor(run, requestId, lines)           → the PM's latest recorded answer, or null
+ *   asEvents(run, lines)                       → the contract's fold events (answer, decision) for one run's PM answers
+ *
+ * ONLY a PM can answer. The route passes pm-guard requirePagePress; recordAnswer checks the actor again, so a call that
+ * carries an agent actor (a session token) is refused here too. The answer file is append-only JSONL. Nothing is sent
+ * outward: the hook endpoint reads the answer when the CLI asks again.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const actor = require('./actor.js');
+const { appendOutbox } = require('../../scripts/outbox.js');
+
+const BEHAVIORS = ['allow', 'deny', 'accept', 'answer'];
+const RUN_RE = /^sess-\d+$/;
+
+function requestIdOf(body) {
+  const b = body && typeof body === 'object' ? body : {};
+  if (typeof b.tool_use_id === 'string' && b.tool_use_id) return b.tool_use_id.slice(0, 120);
+  const basis = JSON.stringify([b.tool_name || '', b.tool_input || null]);
+  return 'req-' + crypto.createHash('sha256').update(basis).digest('hex').slice(0, 16);
+}
+
+function recordAnswer(file, input, who, now = new Date()) {
+  if (!actor.isPm(who)) return { ok: false, status: 403, error: 'only the PM can answer a run' };
+  const i = input && typeof input === 'object' ? input : {};
+  if (typeof i.run !== 'string' || !RUN_RE.test(i.run)) return { ok: false, status: 400, error: 'run must be a session id' };
+  if (typeof i.request !== 'string' || !i.request || i.request.length > 120) return { ok: false, status: 400, error: 'request must be a short id' };
+  if (!BEHAVIORS.includes(i.behavior)) return { ok: false, status: 400, error: 'behavior must be one of ' + BEHAVIORS.join(', ') };
+  const message = typeof i.message === 'string' ? i.message.slice(0, 400) : '';
+  const line = { type: 'answer', run: i.run, request: i.request, behavior: i.behavior, message, by: who.by };
+  appendOutbox(file, line, now);
+  return { ok: true, line };
+}
+
+function readAnswers(file) {
+  try { return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((s) => { try { return JSON.parse(s); } catch { return null; } }); }
+  catch { return []; }
+}
+
+function answerFor(run, requestId, lines = []) {
+  let found = null;
+  for (const l of lines) {
+    if (l && l.type === 'answer' && l.run === run && l.request === requestId && typeof l.by === 'string' && l.by.startsWith('pm:')) found = l;
+  }
+  return found;
+}
+
+// The PM's recorded answers as the contract's own events (reply-contract.js fold): an answer to an ask, a decision on a
+// permission request. Only lines written by a PM become events; the fold then checks the ids against what is open.
+function asEvents(run, lines = []) {
+  const out = [];
+  for (const l of lines) {
+    if (!l || l.type !== 'answer' || l.run !== run.id || typeof l.by !== 'string' || !l.by.startsWith('pm:')) continue;
+    if (l.behavior === 'answer') out.push({ kind: 'answer', run: run.id, session: run.session, ask_id: l.request, answer: l.message, by: 'pm' });
+    else if (l.behavior === 'allow' || l.behavior === 'deny') out.push({ kind: 'decision', run: run.id, session: run.session, perm_id: l.request, decision: l.behavior, by: 'pm', at: l.at });
+  }
+  return out;
+}
+
+const answersFile = (runtimeDir) => path.join(runtimeDir, 'run-answers.jsonl');
+
+module.exports = { BEHAVIORS, requestIdOf, recordAnswer, readAnswers, answerFor, asEvents, answersFile };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.123.0",
+  "version": "0.125.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.123.0",
+      "version": "0.125.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.123.0",
+  "version": "0.125.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/c3.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="en" data-pm-page-theme="light">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+<meta name="pmos-nonce" content="" />
+<title>PMOS console</title>
+<!-- The console3 shell as its own page (header, tabs, three columns, dock). It composes the real views from pm/; the main
+     app at / is unchanged. Tokens and fonts are the main app's, so light and dark both resolve. pm/c3-shell.js sets the
+     theme attribute (default light, like the mockup). The nonce meta is filled by the server the way it is for /, so a press
+     from a view (Add, Accept, Allow) carries it. -->
+<link rel="preload" href="/vendor/ibm-plex-mono-400.woff2" as="font" type="font/woff2" crossorigin />
+<link rel="preload" href="/vendor/ibm-plex-mono-500.woff2" as="font" type="font/woff2" crossorigin />
+<link rel="stylesheet" href="/pm/tokens.css" />
+<style>
+  html { background: var(--background); }
+  body { margin: 0; background: var(--background); color: var(--foreground); }
+  noscript { display: block; padding: 16px; font-family: var(--font-mono, monospace); }
+</style>
+</head>
+<body>
+<div id="c3-root" class="c3 c3pg" data-pm-theme="light"></div>
+<noscript>This page needs JavaScript.</noscript>
+<script type="module" src="/pm/c3-shell.js"></script>
+</body>
+</html>