create-pmos 0.167.0 → 0.169.0

package/workspace/lib/driver-needs.js

@@ -0,0 +1,107 @@
+'use strict';
+/* driver-needs.js — the needs provider of the Initiative Driver (initiative initiative-driver, PRD sections 3 to 5).
+ * lib/needs-providers.js folds these rows into server.js deriveNeeds, and from there into /api/needs and Today.
+ *
+ *   kinds: driver-drafts, driver-blocked
+ *   rowsFor(w, { lead }) → rows · sig(w) → string · titlesOf(w) · rowsOf(state, { titleOf, now, ledgerRel })
+ *
+ *   driver-drafts   one row per initiative or Work task with open proposals: "Agent has 3 drafts on <title>".
+ *   driver-blocked  one row for a target the PM is blocking: its drafts have waited more than a day, and today's sweep raised
+ *                   the finding again. The sweep starts no run for it; the row is the reminder.
+ *
+ * SHADOW MODE raises no row (PRD section 5): the board mode, taken from the board of the target's latest run, decides. The
+ * rows are repository-wide, so a tree that is not the lead returns []. A row never carries a session token.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const D = require('./driver.js');
+
+const NAME = 'driver-needs';
+const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+const KIND_WORD = { initiative: 'the initiative', work: 'the Work task' };
+
+/** Titles for the targets of a workspace: initiative titles from the cached workflow rows, Work titles from the Work items. */
+function titlesOf(w) {
+  const out = new Map();
+  try {
+    const r = require('./initiative-rows.js').peek(w.root);
+    if (r && r.ok) for (const x of r.rows) out.set(`initiative:${x.id}`, x.title || x.id);
+  } catch { /* the id stands in */ }
+  try {
+    const pmItems = require('./pm-items.js');
+    const f = path.join(require('./state-root.js').defaultRoot(), 'pm-items', 'items.jsonl');
+    for (const i of pmItems.fold(pmItems.readLines(f))) out.set(`work:${i.id}`, i.title || i.id);
+  } catch { /* the id stands in */ }
+  return out;
+}
+
+function rowsOf(state, { titleOf = () => null, now = Date.now(), ledgerRel = 'pmos/state/driver.jsonl' } = {}) {
+  const rows = [];
+  const open = new Map();
+  for (const p of D.openProposals(state)) {
+    const k = D.targetKey(p.target);
+    if (!open.has(k)) open.set(k, { target: p.target, list: [] });
+    open.get(k).list.push(p);
+  }
+  const shadow = (target) => {
+    let board = target.kind === 'work' ? 'work' : null;
+    if (target.kind !== 'work') {
+      const runs = [...state.runs.values()].filter((r) => D.targetKey(r.target) === D.targetKey(target) && r.board);
+      if (runs.length) board = runs[runs.length - 1].board;
+    }
+    return D.modeOf(state, board) === 'shadow';
+  };
+  for (const [k, g] of open) {
+    if (shadow(g.target)) continue;
+    const title = titleOf(g.target) || g.target.id;
+    const whats = [...new Set(g.list.map((p) => p.what))].join(', ');
+    rows.push({
+      run_id: `${NAME}:drafts:${k}`, kind: 'driver-drafts', initiative_id: g.target.kind === 'initiative' ? g.target.id : null,
+      question: `Agent has ${plural(g.list.length, 'draft', 'drafts')} on ${title}`, doc: null,
+      today: { kind: 7, source: NAME, cause: `The agent filed ${plural(g.list.length, 'draft', 'drafts')} for ${KIND_WORD[g.target.kind]}: ${whats}`, evidence: ledgerRel, act: { label: 'Review', cli: null } },
+    });
+  }
+  const today = D.localDay(now);
+  const seen = new Set();
+  for (const b of state.blockers) {
+    if (b.owner !== 'pm' || b.day !== today || !b.target) continue;
+    const k = D.targetKey(b.target);
+    if (seen.has(k) || !open.has(k) || shadow(b.target)) continue;
+    const g = open.get(k);
+    const oldest = g.list.map((p) => Date.parse(p.at)).filter(Number.isFinite).sort((a, c) => a - c)[0];
+    if (!(now - oldest >= D.PM_WAIT_MS)) continue;
+    seen.add(k);
+    const days = Math.max(1, Math.floor((now - oldest) / D.DAY));
+    const title = titleOf(g.target) || g.target.id;
+    rows.push({
+      run_id: `${NAME}:blocked:${k}`, kind: 'driver-blocked', initiative_id: g.target.kind === 'initiative' ? g.target.id : null,
+      question: `${title} is waiting on you: the drafts are ${plural(days, 'day', 'days')} old`, doc: null,
+      today: { kind: 7, source: NAME, cause: 'The agent starts no new run on this until you keep, send back or drop its drafts', evidence: ledgerRel, act: { label: 'Review', cli: null } },
+    });
+  }
+  return rows;
+}
+
+function rowsFor(w, { lead } = {}) {
+  if (!lead || !w || !w.root) return [];
+  const dir = D.stateDirOf(w.root);
+  if (!dir) return [];
+  const file = D.ledgerFile(dir);
+  const state = D.fold(D.readLines(file));
+  if (!state.proposals.size) return [];
+  const titles = titlesOf(w);
+  let rel = 'driver.jsonl';
+  try { rel = path.relative(w.root, file).split(path.sep).join('/'); } catch { /* the plain name stands */ }
+  return rowsOf(state, { titleOf: (t) => titles.get(`${t.kind}:${t.id}`) || null, now: Date.now(), ledgerRel: rel });
+}
+
+function sig(w) {
+  if (!w || !w.root) return 'none';
+  const dir = D.stateDirOf(w.root);
+  let st = 'none';
+  try { const s = fs.statSync(D.ledgerFile(dir)); st = `${s.size}:${s.mtimeMs}:${s.ino}`; } catch { /* no ledger yet */ }
+  return crypto.createHash('sha1').update(`${st}|${D.localDay(Date.now())}`).digest('hex');
+}
+
+module.exports = { kinds: ['driver-drafts', 'driver-blocked'], rowsFor, sig, titlesOf, rowsOf };

package/workspace/lib/driver-run.js

@@ -0,0 +1,187 @@
+'use strict';
+/* driver-run.js — the Initiative Driver's part of the server tick (initiative initiative-driver, PRD sections 1 to 3).
+ *
+ *   create(deps) → { tick(opts), active() }
+ *
+ * server.js builds one driver at start and calls tick() from the 60-second tick. One tick, per repository (the lead tree of each):
+ *   1. writes the ledger's `epoch` on the first scan, so only events AFTER it wake a run (an old initiative is history);
+ *   2. closes runs that were alive when the server stopped (`run-end`, reason "interrupted"): they still count against the day;
+ *   3. finds the wakes: a `created` placement line (the page, Triage accept and `pmos initiative new` all write one), a board
+ *      `move` line, a proposal the PM sent back with a note. Each key wakes once (the ledger's `wake` line makes it idempotent);
+ *   4. every 30 minutes inside the day-check window, and outside quiet hours, runs the unblock sweep (no model, lib/driver.js);
+ *   5. starts the queued runs the rules allow (mode, pause, budget, 3 at once) through spawnSession with origin `drive:<kind>:<id>`
+ *      and the skill prompt, which lib/headless.js turns into a `claude -p` run with a fixed tool list.
+ * `PMOS_DRIVER=off` does none of it. A run ends in a `run-end` line with its reason when it fails or times out.
+ *
+ * deps: { gather?(w, ctx, opts) → facts answer (tests), workspaces() → [w], isLead(w), stateDirFor(w), ctx (for lib/routes-boards.js), runtimeDir, settings() → proactive settings,
+ *         inQuiet(now, quiet) → bool, spawn(spec) → session row, promptFor(kind) → skill body | null, boardOf(w, id) → board id | null,
+ *         homeId() → the workspace id that holds the Work tasks, headlessOff() → bool, env, warn(what, err) }
+ * `spawn(spec)` gets { name, ws, origin, initialInput, initiative, onDone }; it returns the session row ({ id, state, headless }).
+ */
+const fs = require('fs');
+const path = require('path');
+const D = require('./driver.js');
+const facts = require('./driver-facts.js');
+const proactive = require('./proactive.js');
+
+const off = (env) => /^(off|0|false|no)$/i.test(String((env || process.env).PMOS_DRIVER || '').trim());
+const hhmm = (ms) => { const d = new Date(ms); return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`; };
+const dayCheckOpen = (settings, now, inQuiet) => {
+  const dc = (settings && settings.dayCheck) || proactive.DEFAULTS.dayCheck;
+  const t = hhmm(now);
+  return settings && settings.enabled === false ? false : (t >= dc.start && t < dc.end && !inQuiet(now, settings && settings.quiet));
+};
+
+/** The lines of a plain JSONL file that parse; a missing file is empty. */
+function readJsonl(f) {
+  let text = '';
+  try { text = fs.readFileSync(f, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const raw of text.split('\n')) { if (!raw.trim()) continue; try { const l = JSON.parse(raw); if (l && typeof l === 'object') out.push(l); } catch { /* torn line */ } }
+  return out;
+}
+
+function create(deps) {
+  const active = new Map();     // run id → { target, ledger, session }
+  const lastSweep = new Map();  // ledger file → ms
+  const warn = deps.warn || (() => {});
+  const gather = deps.gather || facts.gather;   // tests pass their own facts
+
+  function readState(file) { return D.fold(D.readLines(file)); }
+
+  function describe(w, target, wakeLines, state, factsNow) {
+    const lines = [];
+    const reasons = [...new Set(wakeLines.map((x) => x.reason))];
+    let title = target.id; let stage = null; let facts1 = null;
+    if (factsNow) {
+      facts1 = target.kind === 'work' ? factsNow.work.find((x) => x.id === target.id) : factsNow.initiatives.find((x) => x.id === target.id);
+      if (facts1 && facts1.title) title = facts1.title;
+    }
+    lines.push(target.kind === 'work'
+      ? `Target: Work task ${target.id} "${title}" (workspace id ${target.ws}). Skill: work-unblock.`
+      : `Target: initiative ${target.id} "${title}" in repository ${w.name || path.basename(w.root)} (workspace id ${target.ws}). Skill: initiative-drive.`);
+    lines.push(`Why this run started: ${reasons.join(', ')}.`);
+    if (facts1 && target.kind === 'initiative') {
+      stage = facts1.cat;
+      lines.push(`Stage category: ${stage || 'unknown'}. Kept problem statement: ${facts1.has_problem ? 'yes' : 'no'}. Kept evidence: ${facts1.has_evidence ? 'yes' : 'no'}. PRD: ${facts1.has_prd ? 'yes' : 'no'}. Anchor: ${facts1.has_anchor ? 'yes' : 'no'}.`);
+    }
+    if (facts1 && target.kind === 'work') {
+      lines.push(`Placement: ${facts1.placement}. Due: ${facts1.due || 'none'}. Waiting on: ${facts1.waiting_on || 'nobody'}${facts1.waiting_since ? ` since ${String(facts1.waiting_since).slice(0, 10)}` : ''}. Steps: ${facts1.steps}.`);
+    }
+    const blockers = wakeLines.filter((x) => x.blocker).map((x) => x.blocker);
+    if (blockers.length) lines.push(`Blockers the sweep found: ${[...new Set(blockers)].join(', ')}.`);
+    const retNotes = wakeLines.filter((x) => x.reason === 'answered').map((x) => state.proposals.get(String(x.key).replace(/^answered:/, ''))).filter(Boolean);
+    for (const p of retNotes) lines.push(`The PM sent back ${p.id} (${p.what}) with this note: "${p.note}". Revise it and file a new proposal.`);
+    const mine = [...state.proposals.values()].filter((p) => D.targetKey(p.target) === D.targetKey(target));
+    if (mine.length) lines.push(`Proposals so far: ${mine.map((p) => `${p.id} ${p.what} (${p.state})`).join('; ')}. Do not file one again.`);
+    return lines;
+  }
+
+  function startRun(w, file, group, state, factsNow, now) {
+    const kind = group.target.kind;
+    const skill = deps.promptFor(kind === 'work' ? 'work-unblock' : 'initiative-drive');
+    const runId = D.newId('run');
+    const wakeLines = state.wakes.filter((x) => group.wakes.includes(x.key));
+    const board = group.board || null;
+    if (!skill) {
+      D.append(file, { ev: 'run-start', run: runId, target: group.target, board, wakes: group.wakes, session: null }, { now });
+      D.append(file, { ev: 'run-end', run: runId, ok: false, reason: `the ${kind === 'work' ? 'work-unblock' : 'initiative-drive'} skill is not installed`, agent_run: agentRun(runId, group.target, false, now) }, { now });
+      return;
+    }
+    const prompt = `${skill}\n\nThis run:\n${describe(w, group.target, wakeLines, state, factsNow).map((l) => '- ' + l).join('\n')}\n\nFile every result with \`pmos driver propose\`. Send nothing, edit nothing.`;
+    let session = null;
+    try {
+      session = deps.spawn({
+        name: `Driver · ${kind} ${group.target.id}`, ws: w.id, origin: `drive:${kind}:${group.target.id}`, initialInput: prompt + '\r',
+        initiative: kind === 'initiative' ? group.target.id : undefined,
+        onDone: (r) => endRun(file, runId, group.target, r),
+      });
+    } catch (e) { warn('driver run', e); }
+    D.append(file, { ev: 'run-start', run: runId, target: group.target, board, wakes: group.wakes, session: session ? session.id : null }, { now });
+    if (!session || session.state === 'exited' || session.headless !== 'drive') {
+      // A start that did not become a headless run (no `claude` on the PATH, a refused model choice, a pane because headless
+      // is off) is a failed run. It counts against the day, as every failed run does. Never leave a driver in a pane.
+      if (session && session.headless !== 'drive' && session.state !== 'exited' && deps.stop) { try { deps.stop(session); } catch { /* best effort */ } }
+      D.append(file, { ev: 'run-end', run: runId, ok: false, reason: (session && session.note) || 'the run could not start as a background run', agent_run: agentRun(runId, group.target, false, now) }, { now });
+      return;
+    }
+    active.set(runId, { target: group.target, ledger: file, session: session.id });
+  }
+
+  const agentRun = (runId, target, ok, now) => ({ run_id: runId, initiative_id: target.kind === 'initiative' ? target.id : null, kind: 'driver', target_kind: target.kind,
+    ok, human_corrections: 0, builder_model: 'not recorded in the repo', created_at: new Date(now == null ? Date.now() : now).toISOString() });
+
+  function endRun(file, runId, target, r) {
+    active.delete(runId);
+    const res = (r && r.result) || {};
+    const ok = !!(r && !r.timedOut && !r.stopped && r.code === 0 && res.ok && !res.isError);
+    const reason = ok ? null : (r && r.note) || 'the run failed';
+    try {
+      D.append(file, { ev: 'run-end', run: runId, ok, ...(reason ? { reason } : {}), ...(res.denied && res.denied.length ? { denied: res.denied } : {}),
+        agent_run: agentRun(runId, target, ok) });
+    } catch (e) { warn('driver run end', e); }
+  }
+
+  function tick({ now = Date.now(), env } = {}) {
+    if (off(env || deps.env)) return { off: true };
+    const summary = { epoch: 0, woke: 0, swept: 0, started: 0, refused: 0 };
+    const leads = [];
+    for (const w of deps.workspaces()) {
+      let dir = null;
+      try { dir = deps.isLead(w) ? deps.stateDirFor(w) : null; } catch { dir = null; }
+      if (dir) leads.push({ w, file: D.ledgerFile(dir), dir });
+    }
+    const settings = deps.settings();
+    const home = deps.homeId();
+    for (const { w, file, dir } of leads) {
+      try {
+        let state = readState(file);
+        if (!state.epoch) { D.append(file, { ev: 'epoch' }, { now }); state = readState(file); summary.epoch++; }
+        // Runs that were alive when the server stopped are over; they keep their place in the day's count.
+        for (const r of state.runs.values()) {
+          if (!r.end && !active.has(r.run)) D.append(file, { ev: 'run-end', run: r.run, ok: false, reason: 'interrupted: the workspace restarted', agent_run: agentRun(r.run, r.target, false, now) }, { now });
+        }
+        const boardOf = (id) => { try { return deps.boardOf(w, id); } catch { return null; } };
+        let created = [];
+        try { created = require('./plan-ledgers.js').readLines(w.root, 'placements').lines.map((x) => x.rec).filter((r) => r && r.ev === 'created'); } catch { created = []; }
+        const moved = readJsonl(path.join(dir, 'boards.jsonl')).filter((e) => e.kind === 'move');
+        const newWakes = [...D.wakesFromLedgers({ created, moved }, state, { ws: w.id, epoch: state.epoch, boardOf }), ...D.answeredWakes(state, { boardOf })];
+        for (const l of newWakes) { D.append(file, l, { now }); summary.woke++; }
+        state = readState(file);
+        // The unblock sweep: deterministic, every 30 minutes inside the day-check window.
+        const due = !lastSweep.has(file) || now - lastSweep.get(file) >= D.SWEEP_EVERY_MS;
+        let factsNow = null;
+        if (due && dayCheckOpen(settings, now, deps.inQuiet)) {
+          const g = gather(w, deps.ctx, { now, includeWork: w.id === home, runtimeDir: deps.runtimeDir, driverState: state });
+          if (g.ok) {
+            factsNow = g.facts;
+            lastSweep.set(file, now);
+            const sw = D.sweepLines(g.facts, state, { now, stalledDays: settings.stalledDays });
+            for (const l of sw.lines) { D.append(file, l, { now }); if (l.ev === 'wake') summary.swept++; }
+            state = readState(file);
+          } else if (!g.pending) warn('driver sweep', new Error(g.error));
+        }
+        // Start what the rules allow.
+        if (deps.headlessOff()) continue;   // a driver never runs in a pane
+        const running = [...active.values()];
+        const p = D.plan(state, { now, running: active.size, activeTargets: running.map((r) => D.targetKey(r.target)) });
+        for (const r of p.refused) { D.append(file, { ev: 'refused', target: r.target, wakes: r.wakes, reason: r.reason }, { now }); summary.refused++; }
+        if (p.start.length && !factsNow) {
+          const g = gather(w, deps.ctx, { now, includeWork: w.id === home, runtimeDir: deps.runtimeDir, driverState: state });
+          factsNow = g.ok ? g.facts : null;
+        }
+        let live = active.size;
+        for (const group of p.start) {
+          if (live >= D.BUDGET.concurrent) break;
+          startRun(w, file, group, state, factsNow, now);
+          live = active.size; summary.started++;
+        }
+      } catch (e) { warn('driver tick', e); }
+    }
+    return summary;
+  }
+
+  return { tick, active: () => [...active.keys()] };
+}
+
+module.exports = { create, off, dayCheckOpen };