create-pmos 0.240.0 → 0.241.0

package/workspace/lib/charts-store.js

@@ -0,0 +1,124 @@
+'use strict';
+/* charts-store.js — the chart store: the charts a report structure defines once (initiative report-structure, contract section 6).
+ *
+ *   paths(root)                          → { file, rel }                       <state>/charts.jsonl
+ *   append(root, line, { actor, now })   → the line written. THE SINGLE WRITER of charts.jsonl. `at` and `actor` are set here.
+ *   readEvents(root) · fold(events)      → Map id → chart                      a torn line is skipped
+ *   get(root, id)                        → chart | null
+ *   addChart(root, chart, { actor })     → { ok, chart } | refusal             slugs the id, makes it unique, writes one 'add' line
+ *   list(root, { runtimeDir })           → [chart + { users: [{ kind: 'report' | 'dashboard', id, name }] }]
+ *   slugOf(text)                         → a chart id slug
+ *
+ * THE LINES. Every line is { ev, id, chart?, at, actor }: 'add' (a whole chart), 'change' (the fields that changed), 'remove'.
+ * A CHART is { id, name, question, source: { kind, name, via?, ref? }, from, how, compare, flag, query, why, created_by }.
+ * USERS are folded from the ACCEPTED plans (a report whose saved structure names the chart in charts[].chart) and from the Reports dashboards'
+ * layouts (<runtime>/report-dashboards/layouts.json: a key whose list holds the chart id). A chart from the store is REFERENCED by a plan, never copied.
+ *
+ * NOTHING HERE STARTS A JOB OR SENDS ANYTHING.
+ */
+const fs = require('fs');
+const path = require('path');
+const RD = require('./report-draft.js');
+
+const ID_RE = /^[a-z][a-z0-9-]{0,39}$/;
+const EVENTS = Object.freeze(['add', 'change', 'remove']);
+const FIELDS = Object.freeze(['name', 'question', 'from', 'how', 'compare', 'flag', 'query', 'why']);
+const PMOS_ACTOR = Object.freeze({ by: 'pmos', via: 'job' });
+
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const str = (v) => (typeof v === 'string' ? v : '');
+const refuse = (status, error) => ({ ok: false, status, error });
+
+function stateRel(root) { try { return RD.stateRel(root); } catch { return 'planning'; } }
+function paths(root) {
+  const abs = path.resolve(String(root));
+  const rel = `${stateRel(abs)}/charts.jsonl`;
+  return { abs, rel, file: path.join(abs, rel) };
+}
+function slugOf(text) {
+  const s = String(text == null ? '' : text).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').replace(/^[^a-z]+/, '').slice(0, 36).replace(/-+$/, '');
+  return s || 'chart';
+}
+
+function append(root, line, { actor, now } = {}) {
+  if (!isObj(line) || !EVENTS.includes(line.ev) || !ID_RE.test(str(line.id))) throw new Error(`charts-store: bad line ${JSON.stringify(line && line.ev)}`);
+  const p = paths(root);
+  const out = { ...line, at: new Date(now == null ? Date.now() : now).toISOString(), actor: isObj(actor) ? { by: str(actor.by), via: str(actor.via) } : { ...PMOS_ACTOR } };
+  fs.mkdirSync(path.dirname(p.file), { recursive: true });
+  fs.appendFileSync(p.file, JSON.stringify(out) + '\n');
+  return out;
+}
+function readEvents(root) {
+  let text = '';
+  try { text = fs.readFileSync(paths(root).file, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const raw of text.split('\n')) {
+    if (!raw.trim()) continue;
+    try { const l = JSON.parse(raw); if (isObj(l) && EVENTS.includes(l.ev) && ID_RE.test(str(l.id))) out.push(l); } catch { /* a torn line is skipped */ }
+  }
+  return out;
+}
+function fold(events) {
+  const m = new Map();
+  for (const l of events) {
+    if (l.ev === 'add' && isObj(l.chart)) m.set(l.id, { ...l.chart, id: l.id, added_at: l.at });
+    else if (l.ev === 'change' && m.has(l.id) && isObj(l.chart)) m.set(l.id, { ...m.get(l.id), ...l.chart, id: l.id, changed_at: l.at });
+    else if (l.ev === 'remove') m.delete(l.id);
+  }
+  return m;
+}
+const stateOf = (root) => fold(readEvents(root));
+function get(root, id) { return stateOf(root).get(String(id)) || null; }
+
+/** Write one new chart. The id is slugged from chart.id (else the name) and made unique with -2, -3, …. → { ok, chart } */
+function addChart(root, chart, { actor, now } = {}) {
+  if (!isObj(chart)) return refuse(400, 'chart must be an object');
+  const have = stateOf(root);
+  const base = slugOf(chart.id || chart.name);
+  let id = base; let k = 2;
+  while (have.has(id)) { id = `${base.slice(0, 36)}-${k++}`; }
+  const clean = { id, name: str(chart.name), question: str(chart.question), source: isObj(chart.source) ? chart.source : { kind: 'pmos-level', name: '' },
+    from: str(chart.from), how: str(chart.how), compare: str(chart.compare), flag: str(chart.flag), query: str(chart.query), why: str(chart.why), created_by: str(chart.created_by) };
+  append(root, { ev: 'add', id, chart: clean }, { actor, now });
+  return { ok: true, chart: clean };
+}
+
+/** The reports whose ACCEPTED structure uses each chart id: Map chart id → [{ kind: 'report', id, name }]. */
+function reportUsers(root, nameOf) {
+  const users = new Map();
+  const base = path.join(paths(root).abs, stateRel(root), 'reports');
+  let cadences = [];
+  try { cadences = fs.readdirSync(base); } catch { return users; }
+  const RS = require('./report-structure.js');
+  for (const cadence of cadences) {
+    if (!/^[a-z][a-z0-9-]{0,39}$/.test(cadence) || cadence === 'definitions') continue;
+    let st; try { st = RS.stateOf(root, cadence); } catch { continue; }
+    if (!st.saved) continue;
+    const plan = RS.readVersion(root, cadence, st.saved.n);
+    if (!plan) continue;
+    for (const c of plan.charts || []) {
+      if (!c.chart) continue;
+      if (!users.has(c.chart)) users.set(c.chart, []);
+      const list = users.get(c.chart);
+      if (!list.some((u) => u.id === cadence)) list.push({ kind: 'report', id: cadence, name: (nameOf && nameOf(cadence)) || cadence });
+    }
+  }
+  return users;
+}
+/** The dashboard layout keys whose list names the chart id. The layout reader keeps only the built-in ids, so the file is read as it is. */
+function dashboardUsers(runtimeDir, id) {
+  if (!runtimeDir) return [];
+  let raw; try { raw = JSON.parse(fs.readFileSync(path.join(runtimeDir, 'report-dashboards', 'layouts.json'), 'utf8')); } catch { return []; }
+  const src = isObj(raw) && isObj(raw.layouts) ? raw.layouts : raw;
+  if (!isObj(src)) return [];
+  return Object.entries(src).filter(([, v]) => Array.isArray(v) && v.includes(id)).map(([k]) => ({ kind: 'dashboard', id: k, name: k }));
+}
+
+function list(root, { runtimeDir, nameOf } = {}) {
+  const users = reportUsers(root, nameOf);
+  return [...stateOf(root).values()].sort((a, b) => (a.added_at < b.added_at ? -1 : a.added_at > b.added_at ? 1 : 0))
+    .map((c) => ({ ...c, users: [...(users.get(c.id) || []), ...dashboardUsers(runtimeDir, c.id)] }));
+}
+function one(root, id, opts) { return list(root, opts).find((c) => c.id === id) || null; }
+
+module.exports = { ID_RE, EVENTS, FIELDS, paths, append, readEvents, fold, stateOf, get, addChart, list, one, slugOf };

package/workspace/lib/headless.js

@@ -3,7 +3,7 @@
  * (initiative workspace-headless-jobs; PM decision 2026-10-11: keep Jev, no direct Claude API, background
  * jobs that need no human run headless).
  *
- *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | 'core-doc' | 'report-design' | 'report-sample-fetch' | null   (null: open a pane, as before)
+ *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | 'core-doc' | 'report-design' | 'report-sample-fetch' | 'report-structure' | 'report-structure-dry' | null   (null: open a pane, as before)
  *   argsFor(kind, { modelArgs, addDirs, writePaths }) → the argv after `claude` (writePaths: the one render file a report-design job may write)
  *   parseResult(stdout)                            → { ok, text, isError, turns, durationMs, costUsd, denied[] }
  *   streamLines(line)                              → { log: [lines], result: object|null }   one stream-json event, for the live log
@@ -48,6 +48,11 @@
  * (the cycle document, the samples, the earlier versions and the brief) and writes ONE file: the render at the pending path the server gives it, named in
  * its tool list as `Write(//<path>)` and `Edit(//<path>)`. It has no web tool, no Bash and no connector tool, and nothing that sends. The server sanitizes
  * the render before anything shows it. It never runs in a pane.
+ * The `report-structure` and `report-structure-dry` kinds are the report structure step (initiative report-structure): origins `report-structure:<id>` and
+ * `report-structure-dry:<id>`. A turn proposes or refines the plan of a report (sources, charts, outline); a dry run tries a saved version on the last complete
+ * period. Each reads the repository and, where the PM's own Claude Code settings allow it, reads through connectors (none is named in the list, as for
+ * `report-sample-fetch`), and each writes ONE file: structure/pending/<job>.json, named in its tool list like the design render. No Bash, no web fetch, no
+ * connector write tool, nothing that sends. The server validates the file before it lands. Neither kind ever runs in a pane.
  */
 
 // The skills whose every start runs headless: they read, file a result for PMOS, and send nothing out.
@@ -82,7 +87,10 @@ const CORE_DOC_ORIGINS = Object.freeze(['core-doc:']);
 const REPORT_DESIGN_ORIGINS = Object.freeze(['report-design:']);
 // report-design-studio: reading ONE linked Google or Confluence file through the PM's own connectors (origin `report-sample-fetch:<cadence>:<sampleId>`).
 const REPORT_SAMPLE_FETCH_ORIGINS = Object.freeze(['report-sample-fetch:']);
-const WRITE_PATH_KINDS = Object.freeze(['report-design', 'report-sample-fetch']);   // kinds whose one writable file the caller names (argsFor writePaths)
+// report-structure: a structure turn and a dry run on real data (origins `report-structure:<id>`, `report-structure-dry:<id>`).
+const REPORT_STRUCTURE_ORIGINS = Object.freeze(['report-structure:']);
+const REPORT_STRUCTURE_DRY_ORIGINS = Object.freeze(['report-structure-dry:']);
+const WRITE_PATH_KINDS = Object.freeze(['report-design', 'report-sample-fetch', 'report-structure', 'report-structure-dry']);   // kinds whose one writable file the caller names (argsFor writePaths)
 
 // What each kind may use. Read-only search is always allowed. The notes passes write their JSON (and rename the .tmp
 // file) in their notes folder, which --add-dir opens to them; the skills also run `pmos` verbs and repository scripts.
@@ -114,6 +122,9 @@ const TOOLS = Object.freeze({
   'report-design': Object.freeze(['Read', 'Glob', 'Grep']),
   // The link fetch run: Read, and its one write (the text copy of the linked file) is added per run by argsFor. No Bash, no web, no connector tool named.
   'report-sample-fetch': Object.freeze(['Read']),
+  // The structure runs: read and search; a connector read runs only where the PM's own settings allow it. Their one write, the JSON file, is added per run by argsFor.
+  'report-structure': Object.freeze(['Read', 'Glob', 'Grep']),
+  'report-structure-dry': Object.freeze(['Read', 'Glob', 'Grep']),
   skill: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(pmos *)', 'Bash(node *)',
     'Bash(git log *)', 'Bash(git status *)', 'Bash(git diff *)', 'Bash(ls *)', 'Bash(date *)']),
 });
@@ -139,6 +150,9 @@ function kindFor({ agent, origin, skill, env } = {}) {
   if (CORE_DOC_ORIGINS.some((p) => o.startsWith(p))) return 'core-doc';
   if (REPORT_DESIGN_ORIGINS.some((p) => o.startsWith(p))) return 'report-design';
   if (REPORT_SAMPLE_FETCH_ORIGINS.some((p) => o.startsWith(p))) return 'report-sample-fetch';
+  // 'report-structure-dry:' is not a prefix of 'report-structure:' (the colon differs), so the two are told apart by their prefix alone
+  if (REPORT_STRUCTURE_DRY_ORIGINS.some((p) => o.startsWith(p))) return 'report-structure-dry';
+  if (REPORT_STRUCTURE_ORIGINS.some((p) => o.startsWith(p))) return 'report-structure';
   if (skill && HEADLESS_SKILLS.includes(String(skill))) return 'skill';
   return null;
 }
@@ -265,4 +279,4 @@ function logLines(r, exitCode) {
   return out;
 }
 
-module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, CORE_DOC_ORIGINS, REPORT_DESIGN_ORIGINS, REPORT_SAMPLE_FETCH_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };
+module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, CORE_DOC_ORIGINS, REPORT_DESIGN_ORIGINS, REPORT_SAMPLE_FETCH_ORIGINS, REPORT_STRUCTURE_ORIGINS, REPORT_STRUCTURE_DRY_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };

package/workspace/lib/needs-providers.js

@@ -35,6 +35,7 @@ const PROVIDERS = Object.freeze([
   'report-needs',       // Run 5 (5C): a report to issue (kind 1), cycle rows (kind 7), a schedule left no output (kind 8)
   'driver-needs',       // initiative-driver: drafts the agent filed (kind 7), a target the PM is blocking (kind 7)
   'core-docs-needs',    // core-documents: one row per scope with core document drafts waiting for the PM (kind 1)
+  'report-structure-needs', // report-structure: a Chrome or computer source that failed its check while a draft waits for it (kind 8)
 ]);
 /** Kinds that already mean something in the needs queue. A provider may not reuse one. */
 const RESERVED_KINDS = Object.freeze(['question', 'accept', 'outcome', 'keep', 'evidence', 'plan-flag', 'provider-error']);

package/workspace/lib/report-structure-needs.js

@@ -0,0 +1,64 @@
+'use strict';
+/* report-structure-needs.js — the needs provider of the report structure step (initiative report-structure, contract section 8).
+ * lib/needs-providers.js folds these rows into server.js deriveNeeds, and from there into /api/needs, the Briefing and Work.
+ *
+ *   kinds: report-source-check
+ *   rowsFor(w, { lead }) → rows · sig(w) → string
+ *
+ *   report-source-check   one row for each Chrome or computer source that failed its check while a scheduled draft waits for it:
+ *                         "Check <source> for <report>". The draft waits up to 4 hours (lib/routes-report-structure.js sweep), then is drafted
+ *                         without the source. The row goes when the draft starts. Kind 8 (needs repair); the act is Check again on the report.
+ *
+ * The rows are repository-wide, so a tree that is not the lead returns []. Nothing here writes.
+ */
+const fs = require('fs');
+const path = require('path');
+const RD = require('./report-draft.js');
+
+const NAME = 'report-structure-needs';
+
+function holds(root) {
+  const out = [];
+  let base;
+  try { base = path.join(path.resolve(String(root)), RD.stateRel(root), 'reports'); } catch { return out; }
+  let ids = []; try { ids = fs.readdirSync(base); } catch { return out; }
+  for (const id of ids) {
+    if (!/^[a-z][a-z0-9-]{0,39}$/.test(id) || id === 'definitions') continue;
+    const dir = path.join(base, id, 'structure');
+    let hold = null; try { hold = JSON.parse(fs.readFileSync(path.join(dir, 'hold.json'), 'utf8')); } catch { hold = null; }
+    if (!hold || typeof hold !== 'object') continue;
+    out.push({ id, dir, hold });
+  }
+  return out;
+}
+const readJson = (f) => { try { const o = JSON.parse(fs.readFileSync(f, 'utf8')); return o && typeof o === 'object' ? o : null; } catch { return null; } };
+
+function rowsFor(w, { lead } = {}) {
+  if (!lead || !w || !w.root) return [];
+  const rows = [];
+  for (const { id, dir, hold } of holds(w.root)) {
+    const since = Date.parse(hold.since);
+    let name = id;
+    try { const s = require('./report-setups.js').stateOf(w.root).setups.get(id); if (s && s.name) name = s.name; } catch { /* the id is the name */ }
+    let plan = null;
+    try { const v = readJson(path.join(dir, 'versions', `S${hold.saved}.json`)); plan = v; } catch { plan = null; }
+    for (const sid of Array.isArray(hold.sources) ? hold.sources : []) {
+      const c = readJson(path.join(dir, 'checks', `${sid}.json`));
+      if (!c || c.running || c.ok || !(Date.parse(c.at) >= since - 1000)) continue;
+      const src = plan && Array.isArray(plan.sources) ? plan.sources.find((s) => s.id === sid) : null;
+      const step = (c.steps || []).find((s) => s.state === 'needs-you');
+      rows.push({
+        run_id: `${NAME}:${id}:${sid}`, kind: 'report-source-check', initiative_id: null, question: `Check ${(src && src.name) || sid} for ${name}`, doc: null, ws: w.id,
+        today: { kind: 8, source: NAME, cause: step ? `${step.label}: ${step.reason || 'needs you'}` : 'The check did not pass', evidence: `${path.relative(path.resolve(w.root), dir).split(path.sep).join('/')}/checks/${sid}.json`,
+          act: { label: 'Check again', cli: null } },
+      });
+    }
+  }
+  return rows;
+}
+function sig(w) {
+  if (!w || !w.root) return '';
+  return holds(w.root).map((h) => `${h.id}:${h.hold.since}:${(Array.isArray(h.hold.sources) ? h.hold.sources : []).map((s) => { try { return fs.statSync(path.join(h.dir, 'checks', `${s}.json`)).mtimeMs; } catch { return 0; } }).join(',')}`).join('|');
+}
+
+module.exports = { kinds: ['report-source-check'], rowsFor, sig };