create-pmos 0.522.0 → 0.524.0

package/workspace/lib/routes-onboard.js

@@ -14,7 +14,8 @@
  *   POST /api/onboard/discover                      the verified profile's connectors, no model call
  *   POST /api/onboard/search    { sources: [id], local: bool }          read-only search of the ticked sources
  *   POST /api/onboard/review    { fields, jira }    the PM's edits to the draft
- *   POST /api/onboard/init                          initialize or reuse, register, open in My Work (resumable)
+ *   POST /api/onboard/init                          initialize or reuse, register, settle the fundamentals (resumable)
+ *   POST /api/onboard/fundamental { key }           the one-press change of one fundamentals line (lib/onboard-fundamentals.js)
  *   POST /api/onboard/reset                         start again (the folder and anything written stay)
  */
 const fs = require('fs');
@@ -22,6 +23,7 @@ const path = require('path');
 const crypto = require('crypto');
 const guard = require('./pm-guard.js');
 const P = require('./project-onboard.js');
+const F = require('./onboard-fundamentals.js');
 
 function file(ctx) { return path.join(ctx.runtimeDir, 'onboarding', 'project.json'); }
 function journal(ctx) { return path.join(ctx.runtimeDir, 'onboarding', 'project-init.json'); }
@@ -62,10 +64,19 @@ function hasWork(root) {
   return INITIATIVE_DIRS.some((d) => ls(d).some((n) => n.endsWith('.md') && !/^README|template/i.test(n)))
     || RECORD_DIRS.some((d) => ls(d).some((n) => n.endsWith('.jsonl') && filled(d, n)));
 }
+/** The installer's home folder while it is still an empty kit (PMOS in it, no work yet), as folder facts; otherwise null. */
+function installerKit(ctx) {
+  if (!ctx.homeRoot || !(ctx.workspaceList ? ctx.workspaceList() : []).some((w) => w && w.root && path.resolve(w.root) === path.resolve(ctx.homeRoot))) return null;
+  const pm = P.pmosIn(ctx.homeRoot);
+  if (!pm || !pm.kit || hasWork(ctx.homeRoot)) return null;
+  const facts = P.folderFacts(ctx.homeRoot);
+  return facts.ok && facts.exists && !facts.inside_other_git ? facts : null;
+}
 function view(ctx) {
   const { st, bound } = fresh(ctx, read(ctx));
   const ws = st.done && st.done.ws && ctx.getWs(st.done.ws);
-  return { ok: true, progress: { ...st, verified: !!bound, done: ws ? st.done : null }, claude: ctx.claudeSetup.list(), platform: process.platform,
+  const fundamentals = st.fundamentals ? { at: st.fundamentals.at, lines: st.fundamentals.lines, error: st.fundamentals.error || null } : null;
+  return { ok: true, progress: { ...st, verified: !!bound, done: ws ? st.done : null, fundamentals }, claude: ctx.claudeSetup.list(), platform: process.platform,
     // a project the PM already has: a registered workspace with PMOS in it, or with the planning/ folder a PMOS workspace keeps its records in
     // ...that holds work: an initiative or a filled record file. A PMOS folder with none is not one: the one-line installer makes ~/PMOS with an empty kit
     // and registers it, so counting the bare folder skipped setup for every new user (bug 2026-11-02, Windows).
@@ -73,7 +84,7 @@ function view(ctx) {
 }
 
 async function handle(req, res, url, ctx) {
-  const m = /^\/api\/onboard\/(state|own|login|check|project|folder|discover|search|review|init|reset)$/.exec(url.pathname);
+  const m = /^\/api\/onboard\/(state|own|login|check|project|folder|discover|search|review|init|fundamental|reset)$/.exec(url.pathname);
   if (!m) return false;
   const send = (body, code = 200) => { ctx.json(res, body, code); return true; };
   if (!ctx.claudeSetup) return send({ ok: false, error: 'Claude setup is unavailable.' }, 503);
@@ -123,6 +134,15 @@ async function handle(req, res, url, ctx) {
         if (r.cancelled || !r.path) return send({ ok: false, cancelled: true });
         if (b.mode === 'new') parent = r.path; else root = r.path;
       }
+      // One folder per product: the one-line installer already made ~/PMOS a Git repository with an empty kit and opened it as the home
+      // product. The first proposal is that folder, so setup fills it (and renames it to the product) instead of nesting a second
+      // repository inside it and leaving an empty "PMOS" product behind (onboarding grill, 2026-11-04). Choosing "Make a new folder"
+      // afterwards still proposes a new one.
+      const reuse = b.mode === 'new' && !parent && !st.folder && installerKit(ctx);
+      if (reuse) {
+        write(ctx, { ...st, folder: { mode: 'existing', root: reuse.root, facts: reuse, chosen: false, reused: true } });
+        return send(view(ctx));
+      }
       if (b.mode === 'new') {
         const pr = P.proposeFolder(parent, st.project.name);
         if (!pr.ok) return send(pr, 400);
@@ -150,7 +170,8 @@ async function handle(req, res, url, ctx) {
       const picked = all.filter((s) => Array.isArray(b.sources) && b.sources.includes(s.id) && s.status === 'connected');
       const local = b.local !== false && st.folder && st.folder.mode === 'existing';
       if (!picked.length && !local) return send({ ok: false, error: 'Tick at least one source, or continue with your own description.' }, 400);
-      let found = { ok: true, sources: [], findings: [], jira: [], fields: {} };
+      let found = { ok: true, sources: [], findings: [], jira: [], fields: {}, highlights: [], goal: null, facts: {} };
+      const startedAt = new Date().toISOString();   // the reveal's ticks count from here (lib/first-reveal.js)
       if (picked.length) {
         const inv = await P.inventory({ bound, sources: picked });
         found = inv.ok ? await P.search({ bound, project: st.project, sources: picked, tools: inv.tools }) : { ok: false, error: inv.error };
@@ -160,12 +181,12 @@ async function handle(req, res, url, ctx) {
       if (local) found.sources.push({ id: 'folder', label: 'The folder', state: folder && folder.ok ? (folder.readme || folder.commits ? 'found' : 'empty') : 'failed', count: folder && folder.commits || 0 });
       const jiraMatches = found.jira.length ? found.jira : [];
       const draft = P.draftContext({ project: st.project, folder: folder || (st.folder && st.folder.facts), found });
-      write(ctx, { ...st, found: { fingerprint: bound.fingerprint, at: new Date().toISOString(), sources: found.sources, findings: found.findings, jira: jiraMatches }, review: { fields: draft, jira: jiraMatches.length === 1 ? jiraMatches[0].key : null } });
+      write(ctx, { ...st, found: { fingerprint: bound.fingerprint, started_at: startedAt, at: new Date().toISOString(), sources: found.sources, findings: found.findings, jira: jiraMatches, highlights: found.highlights || [], goal: found.goal || null, facts: found.facts || {} }, review: { fields: draft, jira: jiraMatches.length === 1 ? jiraMatches[0].key : null } });
       return send(view(ctx));
     }
     if (verb === 'review') {
       const fields = { ...((st.review && st.review.fields) || P.draftContext({ project: st.project, folder: st.folder && st.folder.facts, found: null })) };
-      for (const k of ['name', 'purpose', 'team', 'owner', 'timeline', 'goals']) {
+      for (const k of ['name', 'purpose', 'team', 'owner', 'timeline', 'weekly', 'goals']) {
         if (!(b.fields && k in b.fields)) continue;
         const v = str(b.fields[k], 400);
         fields[k] = v ? (fields[k] && fields[k].value === v ? fields[k] : { value: v, source: 'you' }) : null;
@@ -184,15 +205,31 @@ async function handle(req, res, url, ctx) {
       const fields = (st.review && st.review.fields) || P.draftContext({ project: st.project, folder: st.folder.facts, found: null });
       const jira = jiraKey && jiraKey !== 'none' ? (matches.find((j) => j.key === jiraKey) || null) : null;
       const name = (fields.name && fields.name.value) || st.project.name;
-      const plan = { mode: st.folder.mode, root: st.folder.root, name, context: { name, fields, jira, sources: (st.found && st.found.findings || []).slice(0, 20) } };
+      const fg = st.found && st.found.goal, gf = fg && (st.found.findings || []).find((x) => x.id === fg.finding);
+      const goal = fg ? { objective: fg.objective, kr: fg.kr, source_label: gf ? gf.source_label : null } : null;
+      const plan = { mode: st.folder.mode, root: st.folder.root, name, context: { name, fields, jira, goal, sources: (st.found && st.found.findings || []).slice(0, 20) } };
       const r = P.initialize({ plan, journalFile: journal(ctx) });
       if (!r.ok) { write(ctx, { ...st, init: { ok: false, step: r.step, error: r.error, steps: r.journal && r.journal.steps } }); return send({ ...view(ctx), ok: false, error: r.error, step: r.step }); }
       const w = ctx.registerWorkspace(r.root, name);
       if (!w) { write(ctx, { ...st, init: { ok: false, step: 'register', error: 'The project could not be added to My Work.', steps: r.journal.steps } }); return send({ ...view(ctx), ok: false, error: 'The project could not be added to My Work.' }); }
+      // A3: the fundamentals are settled for the PM right after init, read from the project-context.md just written. Once per product: a
+      // retried init keeps the card it already has, so a change the PM pressed is not undone.
+      let fundamentals = st.fundamentals && st.fundamentals.root === r.root ? st.fundamentals : null;
+      if (!fundamentals) {
+        try { fundamentals = F.settle({ root: r.root, ws: w.id, sources: (st.found && st.found.sources) || [], fresh: !!(r.journal.steps.kit && r.journal.steps.kit.detail === 'installed'), refresh: ctx.refreshSources ? ctx.refreshSources() : F.refreshAt(ctx.runtimeDir), ...(ctx.launcher !== undefined ? { launcher: ctx.launcher } : {}) }); }
+        catch { fundamentals = { root: r.root, ws: w.id, lines: [], did: {}, error: 'Some fundamentals could not be settled. Change them in Settings.' }; }
+      }
       if (ctx.broadcast) ctx.broadcast({ t: 'focus', ws: w.id });
-      write(ctx, { ...st, init: { ok: true, steps: r.journal.steps }, done: { ws: w.id, name, root: r.root, context: r.journal.steps.context && r.journal.steps.context.detail, at: new Date().toISOString() } });
+      write(ctx, { ...st, init: { ok: true, steps: r.journal.steps }, fundamentals, done: { ws: w.id, name, root: r.root, context: r.journal.steps.context && r.journal.steps.context.detail, at: new Date().toISOString() } });
       return send(view(ctx));
     }
+    if (verb === 'fundamental') {
+      if (!st.fundamentals) return send({ ok: false, error: 'Set up the project first.', need: 'init' }, 409);
+      const r = F.change(st.fundamentals, str(b.key, 20), { refresh: ctx.refreshSources ? ctx.refreshSources() : F.refreshAt(ctx.runtimeDir), ...(ctx.launcher !== undefined ? { launcher: ctx.launcher } : {}) });
+      if (!r.ok) return send({ ...view(ctx), ok: false, error: r.error });
+      if (r.state !== st.fundamentals) write(ctx, { ...st, fundamentals: r.state });
+      return send({ ...view(ctx), follow: r.follow || null });
+    }
   } catch { return send({ ok: false, error: 'This step could not finish. Nothing you had was removed. Try again.' }, 500); }
   return false;
 }

package/workspace/lib/routes-proposals.js

@@ -8,7 +8,7 @@
  *   POST /api/proposals/keep  { ws, board, initiative, ids?: [id] | all: true, choices?: { <from>><to>: 'keep' | 'ignore' } }
  *                             → { ok, batch, said, counts, props }   ✓ one proposal, or ✓ in the header (all: every one Claude is sure of;
  *                             Check these and a Jira ticket's comment never ride on it). One batch, one toast, one Undo.
- *   POST /api/proposals/drop  { ws, board, initiative, sig }   → { ok }   ✕ on a proposal or on one item of it, for good (rule 7); the line
+ *   POST /api/proposals/drop  { ws, board, initiative, sig, why? }   → { ok }   why: the PM's reason (the idle lab asks for one);   ✕ on a proposal or on one item of it, for good (rule 7); the line
  *                             also keeps its facts (PR.factsOf), so a re-sectioned task or a new day does not bring it back
  *   POST /api/proposals/undo  { ws, board, batch }           → { ok, back, kept }   the whole batch; a task changed since keeps its change
  *   POST /api/proposals/stop  { ws, board, initiative }      → { ok }   ■ Stop: the look ends; what was found so far stays proposed
@@ -142,6 +142,14 @@ function applyOne(ctx, p, g, f, ini, x, choices, outbox) {
     // the record's own description (initiative-description-field): ✓ writes its description line, Undo puts back what was there
     const r = require('./initiative-writer.js').setDescription(p.w.root, ini, (x.data || {}).text, { actor: g.actor });
     if (r.ok && !r.same) add({ op: 'description', from: r.from, to: r.text });
+  } else if (x.group === 'prototyped' || x.group === 'improved' || x.group === 'scanned') {
+    // the idle lab (lib/idle-lab.js): ✓ keeps it as the initiative's own document. A prototype is each specimen of round 1, or the new
+    // round; a scan finding is evidence. The specimen stays in the runtime folder; the document links it (GET /api/lab/specimen)
+    const LAB = require('./idle-lab.js'), d = x.data || {}, name = (sp) => 'Prototype ' + sp.key + ' · ' + sp.title;
+    const docOf = (title, ref, kind) => add({ op: 'doc', id: 'fd-' + PR.hash(ini + '|' + x.id + '|' + (ref || title)), title: String(title).slice(0, 140), source: 'Claude, while you were away', at: x.at || '', ref, kind, claude: true });
+    if (x.group === 'prototyped') for (const sp of d.specimens || []) docOf(name(sp), LAB.specimenUrl(sp.file), 'prototype');
+    else if (x.group === 'improved') docOf('Prototype ' + (d.base || '') + ' · round ' + d.round + ': ' + (d.changed || ''), LAB.specimenUrl(d.file), 'prototype');
+    else docOf(x.why, ((x.sources || [])[0] || {}).ref || '', 'evidence');
   } else if (x.group === 'grill') {
     // a grill finding (lib/grill.js): ✓ adds its next step as a task, with the finding and its sources in the notes
     // ✎ on the finding: the PM's own words for the next step (choices[id]) replace Claude's
@@ -279,7 +287,9 @@ const WRITES = {
         if (it) { facts = PR.factsOf(x, it); break; }
       }
     } catch { facts = []; }
-    PR.append(dirOf(ctx, p.w), g.actor, { kind: 'drop', ini, sig, ...(facts.length ? { facts } : {}) });
+    // the PM's reason, when given (the idle lab's ✕ asks for one; Claude learns from it)
+    const why = typeof body.why === 'string' ? body.why.replace(/\s+/g, ' ').trim().slice(0, 300) : '';
+    PR.append(dirOf(ctx, p.w), g.actor, { kind: 'drop', ini, sig, ...(facts.length ? { facts } : {}), ...(why ? { why } : {}) });
     ctx.json(res, { ok: true });
   },
   '/api/proposals/undo': (ctx, res, body, g, p) => {

package/workspace/lib/routes-reveal.js

@@ -0,0 +1,73 @@
+'use strict';
+/* routes-reveal.js — Home right after setup (onboarding build B2; lib/first-reveal.js has the model and the one write).
+ *
+ *   GET  /api/first-reveal?ws=<id>                 → the reveal of a product just set up, or { none: true }
+ *   POST /api/first-reveal/keep  { ws, outcome? }  → ✓ on the drafted initiative: it is created with its expected outcome and check date
+ *   POST /api/first-reveal/drop  { ws }            → ✕: nothing is written; the draft does not come back for this product
+ *
+ * It reads the onboarding progress of lib/routes-onboard.js (the per-user runtime folder) and nothing from a connector: what the portrait
+ * shows is what the read-only search returned during setup. Every POST is the PM's own page press (pm-guard requirePagePress).
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const R = require('./first-reveal.js');
+
+const pad = (n) => String(n).padStart(2, '0');
+const localDay = (d = new Date()) => d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
+const readJsonFile = (f) => { try { const v = JSON.parse(fs.readFileSync(f, 'utf8')); return v && typeof v === 'object' ? v : null; } catch { return null; } };
+const progressOf = (ctx) => readJsonFile(path.join(ctx.runtimeDir, 'onboarding', 'project.json')) || {};
+const journalOf = (ctx) => readJsonFile(path.join(ctx.runtimeDir, 'onboarding', 'project-init.json'));
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}$/;
+
+/** The default workflow's name for new initiatives of this product (D99; Product feature when none is set). */
+function workflowName(ctx, w) {
+  try {
+    const WS = require('./workflows-store.js');
+    const WF = require(require('./repo-script.js').repoScript('workflows.js'));
+    const dir = ctx.stateDirFor ? ctx.stateDirFor(w) : null;
+    return (dir && WF.defaultOf(WS.library(dir)).name) || 'Product feature';
+  } catch { return 'Product feature'; }
+}
+function hasKr(w) { return !!R.firstKr(w.root); }
+
+async function handle(req, res, url, ctx) {
+  const m = /^\/api\/first-reveal(?:\/(keep|drop))?$/.exec(url.pathname);
+  if (!m) return false;
+  const send = (body, code = 200) => { ctx.json(res, body, code); return true; };
+  if (!ctx.runtimeDir) return send({ ok: false, error: 'PMOS has no runtime folder.' }, 409);
+  if (!m[1]) {
+    if (req.method !== 'GET') return send({ ok: false, error: 'GET only' }, 405);
+    const ws = url.searchParams.get('ws') || '';
+    const st = progressOf(ctx);
+    if (!ws || !st.done || st.done.ws !== ws) return send({ ok: true, none: true });
+    const w = ctx.getWs(ws);
+    if (!w) return send({ ok: true, none: true });
+    const today = /^\d{4}-\d{2}-\d{2}$/.test(url.searchParams.get('today') || '') ? url.searchParams.get('today') : localDay();
+    return send(R.model({ st, journal: journalOf(ctx), ws, today, workflow: workflowName(ctx, w), decided: R.read(ctx.runtimeDir, ws), home: os.homedir(), hasKr: hasKr(w) }));
+  }
+  if (req.method !== 'POST') return send({ ok: false, error: 'POST only' }, 405);
+  const got = await ctx.readJson(req);
+  if (!got.ok || !got.body || typeof got.body !== 'object') return send({ ok: false, error: 'Invalid JSON.' }, 400);
+  const b = got.body, g = guard.requirePagePress(req, b);
+  if (!g.ok) return send({ ok: false, error: g.error }, g.status);
+  const ws = String(b.ws || '');
+  if (!ID_RE.test(ws)) return send({ ok: false, error: 'Name the product.' }, 400);
+  const st = progressOf(ctx);
+  if (!st.done || st.done.ws !== ws) return send({ ok: false, error: 'This product was not set up here.' }, 409);
+  const today = /^\d{4}-\d{2}-\d{2}$/.test(String(b.today || '')) ? String(b.today) : localDay();
+  try {
+    if (m[1] === 'drop') {
+      const d = R.read(ctx.runtimeDir, ws);
+      if (!d.kept && !d.dropped) R.write(ctx.runtimeDir, ws, { dropped: new Date().toISOString() });
+      return send({ ok: true, dropped: true });
+    }
+    const r = R.keep(ctx, g, { ws, outcome: typeof b.outcome === 'string' ? b.outcome : '', today, st });
+    if (!r.ok) return send({ ok: false, error: r.error, field: r.field || null }, r.status || 400);
+    if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(ws);
+    return send(r);
+  } catch { return send({ ok: false, error: 'This did not finish. Nothing was removed. Try again.' }, 500); }
+}
+
+module.exports = { prefixes: ['/api/first-reveal'], handle };

package/workspace/lib/scan-run.js

@@ -7,7 +7,8 @@
  *   1. closes a scan that was alive when the server stopped (`scan-end`, reason "interrupted"), and writes the report documents it already held;
  *   2. starts at most one job, and none while one is running (one scan at a time across the workspace):
  *        - a suggest run for a workspace with no watch list (lib/scan.js suggestDue), or
- *        - the portfolio scan, when it is due (lib/scan.js dueNow: the cadence, 09:00, the working hours, quiet hours, once per day).
+ *        - the portfolio scan, when it is due (lib/scan.js dueNow: the cadence, 09:00, the working hours, quiet hours, once per day) and the
+ *          queue gives it an idle turn (`idle`, lib/bg-queue.js step 5: the PM stepped away, or the last hour of the working day came first).
  * The routes call the other three: Scan now (`startNow`: at most 3 a day, never in quiet hours, one at a time), an approved research proposal
  * (`startResearch`) and Stop (`stop`).
  *
@@ -292,7 +293,7 @@ function create(deps) {
     return { ok: true, scans: stopped };
   }
 
-  function tick({ now = Date.now(), env } = {}) {
+  function tick({ now = Date.now(), env, idle = true } = {}) {
     if (off(env || deps.env)) return { off: true };
     const summary = { closed: 0, started: 0 };
     const settings = deps.settings();
@@ -318,7 +319,7 @@ function create(deps) {
           if (got && got.initiatives.length) { startSuggest(w, file, got, now); summary.started++; }
           continue;
         }
-        if (S.dueNow(state, null, now, { open }).ok) {
+        if (S.dueNow(state, null, now, { open, idle }).ok) {
           const sel = S.selectScan(state, {});
           if (!sel.ok) continue;
           let ctx = { boards: [], initiatives: [] };

package/workspace/lib/scan.js

@@ -430,7 +430,7 @@ function isWorkingDay(ms, cadence) {
   return false;
 }
 const slotMs = (ms) => { const d = new Date(ms); const [h, m] = SLOT.split(':').map(Number); d.setHours(h, m, 0, 0); return d.getTime(); };
-const scheduleText = (cadence) => (cadence === 'daily' ? 'Every working day, 09:00' : cadence === 'weekly' ? 'Every Monday, 09:00' : 'Off. No scan runs');
+const scheduleText = (cadence) => (cadence === 'daily' ? 'Every working day, when you step away after 09:00' : cadence === 'weekly' ? 'Every Monday, when you step away after 09:00' : 'Off. No scan runs');
 
 /** The report types a scan can write, given the repository switch and the number of web items it will search. Web reports (benchmark, competitive, insight)
  * need an item or the repository; the productivity report needs the repository. */
@@ -441,8 +441,9 @@ function effectiveTypes(types, { repo, items }) {
 
 /** May a scheduled scan start now? `open` is the day-check window and quiet hours as one boolean (lib/driver-run.js dayCheckOpen). `board` null = the portfolio.
  * → { ok } | { ok: false, why }. A scan that missed 09:00 starts at the first tick inside the working hours of that day, never outside them.
- * One scan per day across the portfolio, whoever started it: a manual scan today is today's scan. */
-function dueNow(state, board, now, { open = true } = {}) {
+ * One scan per day across the portfolio, whoever started it: a manual scan today is today's scan. `idle` is the turn lib/bg-queue.js gave
+ * (idle lab, frame I4): the daily scan starts in the first idle stretch of the day after 09:00, or in the last working hour if none came. */
+function dueNow(state, board, now, { open = true, idle = true } = {}) {
   const cadence = cadenceOf(state);
   if (cadence === 'off') return { ok: false, why: 'off' };
   const kept = keptItems(state, board);
@@ -453,6 +454,7 @@ function dueNow(state, board, now, { open = true } = {}) {
   if (scanDay(state, board, D.localDay(now)).length) return { ok: false, why: 'done-today' };
   if (openScans(state).some((x) => !board || x.board === board)) return { ok: false, why: 'running' };
   if (!effectiveTypes(state.setting.types, { repo: state.setting.repo, items: kept.length }).length) return { ok: false, why: 'no-reports' };
+  if (!idle) return { ok: false, why: 'waiting-for-idle' };
   return { ok: true };
 }
 

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.522.0",
+  "version": "0.524.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.522.0",
+      "version": "0.524.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

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

package/workspace/project-onboard-flow-test.js

@@ -2,9 +2,11 @@
 'use strict';
 /* project-onboard-flow-test.js — the project-first setup conversation in the real Home page, against the real server, with a FIXTURE `claude`
  * (fixtures/fake-claude-onboard.js). It proves the plumbing and the page, not a live account: no real sign-in, no real connector.
- * Covers: login gating (a failed test unlocks nothing), the project question, the proposed new folder, connector listing, the read-only
- * search flags, a denied source contributing nothing, two Jira matches needing a choice, a real kit install in a temporary folder, the project
- * shown in My Work with next steps, reuse of an existing PMOS folder, and desktop and phone widths. SHOTS=<dir> saves screenshots. */
+ * Covers (onboarding build B1): the silent login check (a failed check asks once, as ✦ Sign in), the composer open from the first screen, the
+ * product question, one ✦ for the folder + read-only search + sign-ins with ✓ ✕ only, ✕ answered in the composer, the read-only search flags,
+ * a denied source contributing nothing, the source tiles, two Jira matches needing a choice, a real kit install in a temporary folder, the
+ * fundamentals card with a source on every line and a one-press change, reuse of an existing PMOS folder, and desktop and phone widths.
+ * SHOTS=<dir> saves screenshots. */
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -33,76 +35,88 @@ const shot = async (p, name) => { if (SHOTS) { fs.mkdirSync(SHOTS, { recursive:
   const log = () => fs.existsSync(LOG) ? fs.readFileSync(LOG, 'utf8').trim().split('\n').map((l) => JSON.parse(l)) : [];
   const btn = (label) => p.locator('#obChat button', { hasText: label }).first();
 
-  await step('The old Welcome page opens the Home conversation, not the three-step wizard', async () => {
+  const press = (act) => p.locator(`#obChat [data-ob="${act}"]`).last().click();
+  const say = async (pg, text) => { await pg.fill('#obChat textarea', text); await pg.keyboard.press('Enter'); };
+
+  await step('The old Welcome page opens the Home conversation; the login is checked by itself and the composer is open', async () => {
     await p.goto(T.BASE + '/premium-welcome.html?ws=x&step=sources');
     assert.match(p.url(), /\/premium\.html\?onboard=1$/);
-    await p.waitForSelector('#obChat .ob-card');
+    await p.waitForSelector('#obChat .ob-prop');
     assert(await p.locator('#hmChat').isHidden(), 'one chat at a time'); assert(await p.locator('#hmList').isVisible(), 'the list stays');
+    assert.match(await p.locator('#obChat .ob-prop').innerText(), /Sign in to Claude Code/, 'only a failed check asks');
+    assert(!(await p.locator('#obChat input[name="ob-login"]').count()), 'no login picker on the first screen');
+    assert(await p.locator('#obChat textarea').isEnabled(), 'the composer is open from the first screen');
+    assert.match(await p.locator('#obChat').innerText(), /What product or project is this for\?/);
+    const check = log().find((a) => a.includes('-p') && a.includes('--output-format') && a[a.indexOf('--output-format') + 1] === 'json');
+    assert(check && check.includes('--safe-mode') && check[check.indexOf('--tools') + 1] === '', 'the silent check is the bounded, tool-free check');
+    await shot(p, 'onboard-1-first-open');
   });
-  await step('A failed login test is honest and unlocks nothing', async () => {
-    await shot(p, 'onboard-1-connect');
-    await btn('Test this login').click();
-    await p.waitForSelector('#obChat .ob-bad');
-    assert.match(await p.locator('#obChat .ob-bad').innerText(), /won’t switch to a different account/);
-    assert(await p.locator('#obChat textarea').isDisabled(), 'no project question before a passing test');
-  });
-  await step('A passing test of that login asks about the project', async () => {
+  await step('An answer typed before the check passes waits; a passing test of another login sends it', async () => {
+    await say(p, 'Checkout redesign, payments team. Jira key PAY.');
+    await p.waitForFunction(() => /I start as soon as the Claude check passes/.test(document.querySelector('#obChat').innerText));
     fs.writeFileSync(MODE, 'ready');
+    await press('chooser');
     await btn('Test this login').click();
     await p.waitForSelector('#obChat .ob-good');
-    assert(await p.locator('#obChat textarea').isEnabled());
-    const check = log().find((a) => a.includes('-p') && a.includes('--output-format') && a[a.indexOf('--output-format') + 1] === 'json');
-    assert(check && check.includes('--safe-mode') && check[check.indexOf('--tools') + 1] === '', 'the test is the bounded, tool-free check');
-    await shot(p, 'onboard-2-tested');
+    assert.match(await p.locator('#obChat .ob-good').innerText(), /signed in on this computer, and I just tested it/);
   });
-  await step('The answer names the project and proposes a new folder that overwrites nothing', async () => {
-    await p.fill('#obChat textarea', 'Checkout redesign, payments team. Jira key PAY.');
-    await p.keyboard.press('Enter');
-    await p.waitForSelector('#obChat input[name="ob-folder"][value="new"]');
-    const card = await p.locator('#obChat .ob-card').first().innerText();
+  await step('One ✦ proposes the folder, the read-only search and what needs a sign-in; nothing is created or searched before ✓', async () => {
+    await p.waitForSelector('#obChat [data-ob="plan-yes"]', { timeout: 15000 });
+    const card = await p.locator('#obChat .ob-prop').last().innerText();
     assert(card.includes(path.join(HOME, 'PMOS', 'checkout-redesign')), card);
+    assert.match(card, /Atlassian, Slack for “Checkout redesign” and PAY/); assert.match(card, /Google Drive needs signing in inside Claude/);
     assert(!fs.existsSync(path.join(HOME, 'PMOS', 'checkout-redesign')), 'nothing created before the confirmation');
+    assert(!log().some((a) => a.includes('--allowedTools')), 'nothing searched before ✓');
+    assert(log().some((a) => a[0] === 'mcp' && a[1] === 'list'), 'the sources come from the verified login, with no model call');
+    assert.equal(await p.locator('#obChat .ob-prop').last().locator('button.ut-ib').count(), 2, '✓ and ✕ only');
+    await shot(p, 'onboard-2-plan');
   });
-  await step('Sources come from the verified login, with no model call, and nothing is searched before the press', async () => {
-    const before = log().length;
-    await btn('Show what I can read').click();
-    await p.waitForSelector('#obChat input[name="ob-src"]');
-    assert.deepEqual(log().slice(before), [['mcp', 'list']]);
-    assert(await p.locator('#obChat input[name="ob-src"][value="claude.ai Google Drive"]').isDisabled(), 'a source that needs sign-in cannot be ticked');
-    await shot(p, 'onboard-3-folder-sources');
+  await step('✕ asks what to change in the composer; leaving a source out changes the ✦', async () => {
+    await press('plan-no');
+    await p.waitForFunction(() => /What should I change\?/.test(document.querySelector('#obChat').innerText));
+    await say(p, 'leave out Google Drive');
+    await p.waitForFunction(() => /Left out: Google Drive/.test(document.querySelector('#obChat').innerText));
   });
-  await step('The search is read-only by its flags; a denied source contributes nothing; two Jira matches ask for a choice', async () => {
-    await btn('Search, read-only').click();
-    await p.waitForSelector('#obChat input[name="ob-jira"]', { timeout: 30000 });
+  await step('✓ searches read-only by its flags; a denied source contributes nothing; the findings are source tiles', async () => {
+    await press('plan-yes');
+    await p.waitForSelector('#obChat .ob-tile', { timeout: 30000 });
     const run = log().find((a) => a.includes('--allowedTools'));
     const at = (f) => run[run.indexOf(f) + 1];
     assert.equal(at('--permission-mode'), 'dontAsk'); assert.equal(at('--tools'), ''); assert.deepEqual(JSON.parse(at('--settings')), { disableAllHooks: true });
-    const allow = at('--allowedTools').split(',');
-    assert.deepEqual(allow.sort(), ['mcp__claude_ai_Atlassian__getVisibleJiraProjects', 'mcp__claude_ai_Atlassian__searchJiraIssuesUsingJql', 'mcp__claude_ai_Slack__slack_search_public']);
+    assert.deepEqual(at('--allowedTools').split(',').sort(), ['mcp__claude_ai_Atlassian__getVisibleJiraProjects', 'mcp__claude_ai_Atlassian__searchJiraIssuesUsingJql', 'mcp__claude_ai_Slack__slack_search_public']);
     const text = await p.locator('#obChat').innerText();
-    assert.match(text, /Atlassian · 3 found/); assert.match(text, /Slack · couldn’t read/); assert(!text.includes('#checkout'), 'nothing from the denied source');
-    assert.equal(await p.locator('#obChat input[name="owner"]').inputValue(), '', 'a field cited from a failed source stays empty');
-    assert.equal(await p.locator('#obChat input[name="purpose"]').inputValue(), 'Reduce checkout drop-off on mobile');
-    await shot(p, 'onboard-4-review');
+    assert.match(text, /I found one thing about/); assert.match(text, /Slack: This login is not allowed to search it/); assert(!text.includes('#checkout'), 'nothing from the denied source');
+    const ctxCard = await p.locator('#obChat form[data-ob-form="review"]').innerText();
+    assert.match(ctxCard, /Reduce checkout drop-off on mobile/); assert.match(ctxCard, /Owner\s*Not found\. Tell me, or leave blank/);
+    assert(!/Invented Person/.test(ctxCard), 'a field cited from a failed source stays empty');
+    await shot(p, 'onboard-3-found');
   });
-  await step('Setup waits for the Jira choice, then installs PMOS for real and opens the project in My Work', async () => {
-    await btn('Set up PMOS in').click();
+  await step('Setup waits for the Jira choice, installs PMOS for real, and shows the fundamentals card', async () => {
+    await press('init');
     await p.waitForFunction(() => /Choose which Jira project/.test((document.querySelector('#obChat .ob-live') || {}).innerText || ''), null, { timeout: 15000 });
     await p.check('#obChat input[name="ob-jira"][value="PAY"]');
+    await p.locator('#obChat [data-ob-edit="goals"]').click();
     await p.fill('#obChat input[name="goals"]', 'Raise mobile checkout conversion');
-    await btn('Set up PMOS in').click();
-    try { await p.waitForURL(/onboarded=1/, { timeout: 60000 }); } catch (e) { await shot(p, 'onboard-x-stuck'); console.log(await p.locator('#obChat').innerText()); throw e; }
-    await p.waitForSelector('#obChat .ob-done');
+    await press('init');
+    try { await p.waitForSelector('#obChat .ob-fund', { timeout: 60000 }); } catch (e) { await shot(p, 'onboard-x-stuck'); console.log(await p.locator('#obChat').innerText()); throw e; }
     const root = path.join(HOME, 'PMOS', 'checkout-redesign');
-    for (const f of ['.git', 'pmos/AGENTS.md', 'pmos/state', 'CLAUDE.md', '.pmos-profile']) assert(fs.existsSync(path.join(root, f)), f);
+    for (const f of ['.git', 'pmos/AGENTS.md', 'pmos/state', 'CLAUDE.md', '.pmos-profile', 'pmos/planning/okrs/okrs-draft.md']) assert(fs.existsSync(path.join(root, f)), f);
     const ctxText = fs.readFileSync(path.join(root, 'pmos', 'planning', 'project-context.md'), 'utf8');
     assert.match(ctxText, /Reduce checkout drop-off on mobile \(source: Atlassian, Checkout brief/); assert.match(ctxText, /Raise mobile checkout conversion \(source: the PM\)/);
     assert.match(ctxText, /Jira:\*\* PAY · Payments Platform/); assert(!/Invented Person/.test(ctxText));
+    const fund = await p.locator('#obChat .ob-fund').innerText();
+    assert.match(fund, /A document product/); assert.match(fund, /Workflow: Product feature/); assert.match(fund, /Jira PAY linked: read-only/); assert.match(fund, /About: “Reduce checkout drop-off on mobile”/);
+    assert(!/Applications/.test(fund), 'a scratch server writes no launcher, and says nothing about it');
+    assert.equal((await p.locator('#obChat .ob-fund li').count()), (await p.locator('#obChat .ob-fund li em').count()), 'every line names its source');
+    await shot(p, 'onboard-4-fundamentals');
+    await p.locator('#obChat [data-ob="f:goal"]').click();
+    await p.waitForFunction(() => /No goal file/.test(document.querySelector('#obChat .ob-fund').innerText));
+    assert(!fs.existsSync(path.join(root, 'pmos', 'planning', 'okrs', 'okrs-draft.md')), 'one press removes the draft');
+    await Promise.all([p.waitForURL(/onboarded=1&first=draft/, { timeout: 15000 }), press('first-yes')]);
+    await p.waitForSelector('#rvChat .rv-ticks'); await p.waitForSelector('#rvChat .rv-draft');   // B2: Home opens on the reveal, with the drafted initiative
     await p.waitForFunction(() => /Checkout redesign/i.test(document.querySelector('#hmList').innerText), null, { timeout: 15000 });
-    assert(await p.locator('#obChat a.hm-chip').count() >= 3, 'a next action, not an empty success');
-    await shot(p, 'onboard-5-done');
     const ph = await (await browser.newContext({ viewport: { width: 390, height: 844 } })).newPage();
-    await ph.goto(p.url()); await ph.waitForSelector('#obChat .ob-done'); await shot(ph, 'onboard-5-done-phone');
+    await ph.goto(T.BASE + '/premium.html?onboard=1'); await ph.waitForSelector('#obChat .ob-fund'); await shot(ph, 'onboard-5-fundamentals-phone');
     assert(await ph.locator('#obChat').isVisible()); await ph.close();
   });
   await step('The same folder again is reused as existing PMOS, never reinstalled', async () => {
@@ -112,17 +126,16 @@ const shot = async (p, name) => { if (SHOTS) { fs.mkdirSync(SHOTS, { recursive:
     await fetch(T.BASE + '/api/onboard/reset', { method: 'POST', headers: h, body: '{}' });
     const ph = await (await browser.newContext({ viewport: { width: 390, height: 844 } })).newPage();
     await ph.goto(T.BASE + '/premium.html?onboard=1');
-    await ph.locator('#obChat button', { hasText: 'Test this login' }).click();
-    await ph.waitForSelector('#obChat .ob-good');
-    await ph.fill('#obChat textarea', `Checkout redesign. The folder is ${root}`); await ph.keyboard.press('Enter');
-    await ph.waitForSelector('#obChat input[name="ob-folder"][value="existing"]');
-    assert.match(await ph.locator('#obChat .ob-card').first().innerText(), /PMOS is already here/);
+    await ph.waitForSelector('#obChat .ob-good', { timeout: 15000 });
+    await say(ph, `Checkout redesign. The folder is ${root}`);
+    await ph.waitForSelector('#obChat [data-ob="plan-yes"]', { timeout: 15000 });
+    assert.match(await ph.locator('#obChat .ob-prop').last().innerText(), /PMOS is already here/);
     await shot(ph, 'onboard-6-existing-pmos-phone');
-    await ph.locator('#obChat button', { hasText: 'Show what I can read' }).click();
-    await ph.locator('#obChat button', { hasText: 'Skip, use my description' }).click();
-    await Promise.all([ph.waitForURL(/onboarded=1/, { timeout: 60000 }), ph.locator('#obChat button', { hasText: 'Open PMOS in' }).click()]);
-    await ph.waitForSelector('#obChat .ob-done');
-    assert.match(await ph.locator('#obChat .ob-done').innerText(), /reused as it is/);
+    await ph.locator('#obChat [data-ob="plan-no"]').click();
+    await say(ph, 'no search');
+    await ph.waitForSelector('#obChat [data-ob="init"]');
+    await ph.locator('#obChat [data-ob="init"]').click();
+    await ph.waitForSelector('#obChat .ob-fund', { timeout: 60000 });
     assert.equal(fs.readFileSync(path.join(root, 'pmos', 'AGENTS.md'), 'utf8'), '# edited by the PM');
     await ph.close();
   });

package/workspace/public/pm/cozy-ev.css

@@ -381,3 +381,6 @@
 @media (max-width: 760px) { .ev-st [data-claude-setup] .wl-btn, .ev-st [data-claude-setup] select { min-height: 44px; } .ev-st [data-claude-setup] .cs-label { flex-wrap: wrap; } }
 /* Settings › Claude › Your own rules (batch 26 item 2) */
 .ev-st textarea.ev-rules { display: block; width: 100%; box-sizing: border-box; margin-top: 8px; min-height: 72px; padding: 10px 12px; border: 0; border-radius: 14px; background: var(--cz-well); color: var(--cz-ink); font: inherit; font-size: var(--fs-3); line-height: 1.45; resize: vertical; }
+/* a quiet place (pm/quiet-place.js, onboarding B3 ObA4Gradual): one honest line instead of empty tables, until its moment comes */
+.qp-on > :not(.qp-line) { display: none !important; }
+.qp-line { margin: 18vh auto 0; max-width: 520px; padding: 0 16px; text-align: center; font-size: var(--fs-row); font-weight: var(--fw-strong); color: var(--cz-ink2); line-height: 1.5; }