create-pmos 0.42.0 → 0.44.0

package/workspace/public/pm/modes-live.js

@@ -831,7 +831,7 @@ async function tScan() {
 }
 async function tSettings(patch) {
   const out = await post('/api/proactive/settings', patch);
-  reload('today'); reload('brief');
+  reload('today'); reload('brief'); reload('prepare');
   tSay(!out || out.ok === false ? 'bad' : 'ok', !out || out.ok === false ? ((out && out.error) || 'not saved') : 'saved');
 }
 function tCard(c) {
@@ -843,6 +843,7 @@ function tCard(c) {
     el('span', { style: 'display:block;font-size:11px;color:var(--muted-foreground);margin:2px 0 4px' }, iv(c.why + (c.evidence ? ' — ' + c.evidence : ''))),
     el('span', { style: 'display:flex;gap:4px;flex-wrap:wrap' },
       c.open ? b('open', 'open', () => tOpen(c)) : null,
+      c.initiative_id && c.ws ? el('button', { style: BTN, hover: 'color:var(--foreground)', 'data-r23': 'prepare', onClick: () => bgShowPlan(c) }, 'prepare in the background') : null,
       b('useful', 'useful', () => tFeedback({ candidate_id: c.id, verdict: 'useful' }, 'thanks — recorded as useful')),
       b('not useful', 'not-useful', () => tFeedback({ candidate_id: c.id, verdict: 'not-useful' }, 'recorded as not useful')),
       b('wrong priority', 'wrong-priority', () => tFeedback({ candidate_id: c.id, verdict: 'wrong-priority' }, 'recorded as wrong priority')),
@@ -900,6 +901,72 @@ function briefSection() {
   }
   return kids;
 }
+
+/* background preparation (proactive-engine D3): the PM approves one plan; the workspace starts it later, under the same rules as a next-step go */
+let bgPlan = null;            // { cid, state: 'loading'|'ok'|'error', data, error }
+let bgNote = null;
+async function bgShowPlan(c) {
+  if (bgPlan && bgPlan.cid === c.id) { bgPlan = null; setState({}); return; }
+  bgPlan = { cid: c.id, state: 'loading' }; setState({});
+  const out = await post('/api/proactive/prepare/plan', { ws: c.ws, initiative_id: c.initiative_id });
+  bgPlan = !out || out.ok === false ? { cid: c.id, state: 'error', error: (out && out.error) || 'no plan' } : { cid: c.id, state: 'ok', data: out, c };
+  setState({});
+}
+async function bgQueue(c, d) {
+  const out = await post('/api/proactive/prepare/queue', { ws: d.ws, initiative_id: d.initiative_id, item_id: d.item.id, prompt_sha: d.prompt_sha, candidate_id: c.id, confirm: true });
+  bgNote = !out || out.ok === false ? { tone: 'bad', text: (out && out.error) || 'not queued' } : { tone: 'ok', text: 'queued — the workspace starts it when the budget allows' + (d.background.quiet ? ', after quiet hours' : '') + '. It expires in ' + d.background.expire_hours + ' hours.' };
+  if (out && out.ok) bgPlan = null;
+  reload('prepare'); setState({});
+}
+async function bgCancel(e) {
+  const out = await post('/api/proactive/prepare/cancel', { id: e.id });
+  bgNote = !out || out.ok === false ? { tone: 'bad', text: (out && out.error) || 'not cancelled' } : { tone: 'ok', text: 'cancelled' };
+  reload('prepare'); setState({});
+}
+async function bgRun() {
+  const out = await post('/api/proactive/prepare/run', {});
+  bgNote = !out || out.ok === false ? { tone: 'bad', text: (out && out.error) || 'the run failed' }
+    : { tone: 'ok', text: out.results.length ? out.results.map((x) => x.action + (x.reason ? ' (' + x.reason + ')' : '')).join('; ') : 'nothing is queued' };
+  reload('prepare'); setState({});
+}
+function bgPlanView() {
+  if (!bgPlan) return null;
+  if (bgPlan.state === 'loading') return el('div', { style: NOTE, 'data-r23': 'plan-loading' }, iv('reading the plan …'));
+  if (bgPlan.state === 'error') return el('div', { style: NOTE + ';color:var(--destructive)', 'data-r23': 'plan-error' }, iv(bgPlan.error));
+  const d = bgPlan.data; const c = bgPlan.c;
+  const kids = [el('div', { style: 'font-size:12px', 'data-r23': 'plan-step' }, iv('Step: ' + d.item.key + ' — ' + d.item.text))];
+  if (d.refused) { kids.push(el('div', { style: NOTE + ';color:var(--destructive)', 'data-r23': 'plan-refused' }, iv(d.refused.why))); }
+  else {
+    kids.push(el('div', { style: NOTE, 'data-r23': 'plan-where' }, iv(d.plan.why || d.plan.plan)));
+    kids.push(el('div', { style: NOTE, 'data-r23': 'plan-budget' }, iv(d.budget.running + ' of ' + d.budget.limits.concurrent + ' prepared sessions running · ' + d.budget.startedToday + ' of ' + d.budget.limits.perDay + ' started today. The session proposes only: no push, pull request, send, post, acceptance or merge. No outside source and no typed scoring.')));
+    kids.push(el('pre', { 'data-r23': 'plan-prompt', style: 'white-space:pre-wrap;font-family:var(--mono);font-size:10.5px;max-height:140px;overflow:auto;border:1px solid var(--border);padding:6px;margin:4px 0' }, iv(d.prompt)));
+    if (!d.background.enabled) kids.push(el('div', { style: NOTE, 'data-r23': 'plan-off' }, iv('Background prepare is off. Turn it on in the settings below to queue this.')));
+    else kids.push(el('button', { style: BTN + ';color:var(--foreground);border-color:var(--foreground)', hover: 'background:var(--accent)', 'data-r23': 'queue', onClick: () => bgQueue(c, d) }, 'queue it (plan ' + d.prompt_sha + ')'));
+  }
+  return el('div', { 'data-r23': 'plan', style: 'padding:6px 14px 8px;border-bottom:1px solid var(--border)' }, kids);
+}
+function backgroundSection() {
+  const r = read('prepare', '/api/proactive/prepare');
+  const st = status(r, 'the background queue');
+  const kids = [el('div', { style: LABEL }, iv('background preparation'))];
+  if (st) return [...kids, st];
+  const d = r.data;
+  kids.push(el('div', { style: NOTE, 'data-r23': 'bg-state' }, iv((d.enabled ? 'On' : 'Off') + '. ' + d.budget.running + ' of ' + d.budget.limits.concurrent + ' prepared sessions running · ' + d.budget.startedToday + ' of ' + d.budget.limits.perDay + ' started today' + (d.quiet ? ' · quiet hours now' : '') + '. An approval is for one plan and expires in ' + d.expire_hours + ' hours. It runs only while the workspace server runs.')));
+  if (bgNote) kids.push(el('div', { 'data-r23': 'bg-note', style: NOTE + ';color:' + (bgNote.tone === 'bad' ? 'var(--destructive)' : 'var(--foreground)') }, iv(bgNote.text)));
+  if (!d.entries.length) kids.push(el('div', { style: NOTE, 'data-r23': 'bg-empty' }, iv('Nothing has been queued.')));
+  for (const e of d.entries) {
+    kids.push(el('div', { 'data-r23': 'entry', 'data-id': e.id, 'data-status': e.status, style: 'padding:6px 14px;border-bottom:1px solid var(--border)' },
+      el('span', { style: 'display:flex;gap:8px;align-items:baseline' },
+        el('span', { style: 'font-size:12px' }, iv(e.label)),
+        el('span', { style: 'margin-left:auto;font-family:var(--mono);font-size:10px;color:var(--muted-foreground)' }, iv(e.status))),
+      e.reason ? el('span', { style: 'display:block;font-size:11px;color:var(--muted-foreground)', 'data-r23': 'entry-reason' }, iv(e.reason)) : null,
+      el('span', { style: 'display:flex;gap:4px;margin-top:3px' },
+        e.status === 'queued' ? el('button', { style: BTN, hover: 'color:var(--foreground)', 'data-r23': 'cancel', onClick: () => bgCancel(e) }, 'cancel') : null,
+        e.status === 'started' && e.session_id ? el('button', { style: BTN, hover: 'color:var(--foreground)', 'data-r23': 'switch', onClick: async () => { const ini = await import('./panel-initiatives.js'); ini.openTerm(null, { id: e.session_id, name: e.label }); } }, 'switch to it') : null)));
+  }
+  if (d.entries.some((e) => e.status === 'queued')) kids.push(el('div', { style: 'padding:4px 14px' }, el('button', { style: BTN, hover: 'color:var(--foreground)', title: 'look at the queue now; ignores quiet hours only', 'data-r23': 'run', onClick: bgRun }, 'run the queue now')));
+  return kids;
+}
 export function todayList() {
   const r = read('today', '/api/proactive/today');
   const kids = [el('div', { style: NOTE, 'data-r22': 'intro' }, iv('What is waiting for you, worked out from the ledgers and git on this computer. It runs only while the workspace server runs, reads no mail or calendar, and changes nothing: your feedback only changes how this list is ordered later.'))];
@@ -925,7 +992,8 @@ export function todayList() {
   if ((d.unreadable || []).length && !tRetry && typeof setTimeout === 'function') tRetry = setTimeout(() => { tRetry = null; reload('today'); setState({}); }, 4000);
   for (const u of d.unreadable || []) kids.push(el('div', { style: NOTE + ';color:var(--destructive)', 'data-r22': 'unreadable' }, iv('Not read — ' + (u.name || u.repo || 'a repository') + ': ' + (u.error || 'unknown reason') + '. Nothing is shown for it, which is not the same as nothing waiting.')));
   if (d.empty) kids.push(el('div', { style: NOTE, 'data-r22': 'empty' }, iv('Nothing is waiting on any repository that was read.')));
-  for (const c of d.candidates || []) kids.push(tCard(c));
+  for (const c of d.candidates || []) { kids.push(tCard(c)); if (bgPlan && bgPlan.cid === c.id) kids.push(bgPlanView()); }
+  kids.push(...backgroundSection());
   if (d.dismissed) kids.push(el('div', { style: NOTE, 'data-r22': 'dismissed' }, iv(d.dismissed + ' dismissed item(s) hidden for 7 days.')));
   // settings
   kids.push(el('div', { style: LABEL }, iv('settings')));
@@ -933,6 +1001,7 @@ export function todayList() {
     el('input', { type: 'checkbox', checked: on ? 'checked' : null, 'data-r22': attr, onChange: () => tSettings(patch(!on)) }), iv(label));
   kids.push(chk('engine on', s.enabled, 'set-enabled', (v) => ({ enabled: v })));
   for (const t of Object.keys(s.triggers)) kids.push(chk('watch: ' + t, s.triggers[t], 'set-' + t, (v) => ({ triggers: { [t]: v } })));
+  kids.push(chk('background prepare (starts approved sessions by itself)', s.backgroundPrepare, 'set-bg', (v) => ({ backgroundPrepare: v })));
   kids.push(el('div', { style: LABEL }, iv('morning brief')));
   for (const k of Object.keys(s.briefSources || {})) kids.push(chk('read ' + k + (k === 'mail' ? ' (titles and senders only)' : ''), s.briefSources[k], 'set-src-' + k, (v) => ({ briefSources: { [k]: v } })));
   kids.push(chk('typed scoring (sends titles and metadata to the Typesafe service)', s.briefScoring, 'set-scoring', (v) => ({ briefScoring: v })));

package/workspace/server.js

@@ -79,6 +79,7 @@ const sessionBudget = require('./lib/session-budget');
 const judgmentLib = require('./lib/judgment');
 const proactiveLib = require('./lib/proactive');
 const briefLib = require('./lib/brief');
+const prepareQueue = require('./lib/prepare-queue');
 const harness = require('./lib/harness-parse');
 const transcript = require('./lib/transcript-read');
 const skillStore = require('./lib/skill-store');
@@ -2189,7 +2190,7 @@ function checkDueSchedules() {
   return fired;
 }
 // the tick — the persistent server checks on an interval; unref'd so it never blocks exit
-try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); }, 60000); if (_tick.unref) _tick.unref(); } catch {}
+try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } }, 60000); if (_tick.unref) _tick.unref(); } catch {}
 
 // ── Sessions: real PTYs, owned by the server, with disk-backed scrollback + metadata. ──
 /** @type {Map<string, {id,ws,name,agent,cwd,state,note,created,pty,buf,cols,rows,clients:Set}>} */
@@ -3358,6 +3359,58 @@ function prepareNextStep(body) {
     judgment: { on: judgmentOn, outside_service: judgmentOn, needs_key: judgmentOn, note: judgmentOn ? 'The question text leaves this machine for the Typesafe service. It needs TYPESAFE_API_KEY in the session.' : 'No outside service is used.' } };
 }
 
+// ── Background prepare, slice D3 (initiative proactive-engine) ──────────────────────────────────────────────────
+// The PM approves ONE plan hash from Today. The 60-second tick later starts that session through the SAME path a next-step
+// `go` uses (startWork with origin next-step and the prompt that was shown), only while background prepare is on, outside quiet
+// hours, with session budget, and while the plan still has the approved hash. Every rule is in lib/prepare-queue.js.
+const PRO_QUEUE = () => path.join(STATE, 'prepare-queue.jsonl');
+function queueEntries() { return prepareQueue.fold(nsRead(PRO_QUEUE())); }
+// The step an agent session may work on now for an initiative: the first `work` step the ladder lets it start.
+function currentWorkItem(w, id) {
+  const got = nextStepsFor(w, id);
+  if (!got.ok) return { ok: false, status: got.status || 500, error: got.error };
+  const item = got.ns.items.find((x) => x.act && x.act.type === 'work' && !nextStepActions.refusal(x, got.ns));
+  if (item) return { ok: true, item };
+  const first = got.ns.items.find((x) => x.first) || got.ns.items[0];
+  const why = first ? nextStepActions.refusal(first, got.ns) : null;
+  return { ok: false, status: 409, error: 'No step is open for an agent session right now' + (why ? ': ' + why.why : '.') };
+}
+function preparePlanFor(w, id, itemId) {
+  return prepareNextStep({ ws: w.id, initiative_id: id, item_id: itemId, agent: 'claude', judgment: false });
+}
+function prepareState() {
+  const settings = proSettings();
+  return { enabled: settings.backgroundPrepare === true, quiet: proactiveLib.inQuietHours(Date.now(), settings.quiet), budget: nsBudget(), max_queued: prepareQueue.MAX_QUEUED, expire_hours: prepareQueue.EXPIRE_MS / 3600000 };
+}
+function prepareTick({ manual = false } = {}) {
+  const out = [];
+  const settings = proSettings();
+  const queued = queueEntries().filter((e) => e.status === 'queued');
+  if (!queued.length) return out;
+  const now = Date.now();
+  const quiet = proactiveLib.inQuietHours(now, settings.quiet);
+  for (const e of queued) {
+    const w = getWs(e.ws);
+    const fresh = w ? preparePlanFor(w, e.initiative_id, e.item_id) : { ok: false, error: 'the repository is no longer registered' };
+    const d = prepareQueue.decide({ entry: e, now, settings, quiet, manual, fresh, budget: nsBudget() });
+    if (d.action === 'wait') { out.push({ id: e.id, action: 'wait', reason: d.reason }); continue; }
+    if (d.action === 'expire' || d.action === 'skip') {
+      nsAppend(PRO_QUEUE(), { id: e.id, at: nowISO(), event: d.action === 'expire' ? 'expired' : 'skipped', reason: d.reason }, 'prepare queue');
+      out.push({ id: e.id, action: d.action, reason: d.reason }); continue;
+    }
+    const started = startWork({ initiative: fresh.initiative_id, ws: fresh.ws, agent: fresh.agent, name: `${fresh.item.key} · ${fresh.initiative_id} (background)`, origin: 'next-step', initialInput: fresh.prompt + '\r' });
+    if (!started.ok) {
+      nsAppend(PRO_QUEUE(), { id: e.id, at: nowISO(), event: 'skipped', reason: 'it could not start — ' + started.error }, 'prepare queue');
+      out.push({ id: e.id, action: 'skip', reason: started.error }); continue;
+    }
+    nsAppend(NS_RUNS(), { id: 'nsr-' + Date.now().toString(36), at: nowISO(), ws: fresh.ws, initiative_id: fresh.initiative_id, item_id: fresh.item.id, key: fresh.item.key, session_id: started.session.id,
+      branch: fresh.plan.branch || null, plan: fresh.plan.plan, prompt_sha: fresh.prompt_sha, judgment: false, profile: null, via: 'background', queue_id: e.id }, 'next-step run');
+    nsAppend(PRO_QUEUE(), { id: e.id, at: nowISO(), event: 'started', session_id: started.session.id }, 'prepare queue');
+    out.push({ id: e.id, action: 'start', session_id: started.session.id });
+  }
+  return out;
+}
+
 // ── Proactive engine, slice D1 (initiative proactive-engine) ─────────────────────────────────────────────────────
 // A scan reads ledgers and git for five conditions and appends each new one to signals.jsonl; Today is computed from what
 // is true now. No model call, no network call, no write into any repository, no session started (lib/proactive.js is
@@ -6221,6 +6274,53 @@ async function handleRequest(req, res) {
     if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
     return json(res, { ok: true, ws: w.id, name: w.name, ...validateLib.readFindings(validationFindingsFile(w)) });
   }
+  /* ── background prepare (D3): plan is read-only; queue records an approval; the runner starts it later ── */
+  if (p === '/api/proactive/prepare/plan' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w = getWs(body.ws);
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    const id = String(body.initiative_id || '');
+    if (!fourPanel.validId(id)) return json(res, { ok: false, error: 'an initiative id is required' }, 400);
+    const cur = currentWorkItem(w, id);
+    if (!cur.ok) return json(res, { ok: false, error: cur.error }, cur.status || 409);
+    const r = preparePlanFor(w, id, cur.item.id);
+    return json(res, { ...r, background: prepareState() }, r.ok ? 200 : (r.status || 400));
+  }
+  if (p === '/api/proactive/prepare/queue' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const c = prepareQueue.checkRequest(body);
+    if (!c.ok) return json(res, { ok: false, error: c.error }, 400);
+    const why = prepareQueue.canQueue({ settings: proSettings(), entries: queueEntries(), req: c.req });
+    if (why) return json(res, { ok: false, error: why }, 409);
+    const w = getWs(c.req.ws);
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    const r = preparePlanFor(w, c.req.initiative_id, c.req.item_id);
+    if (!r.ok) return json(res, { ok: false, error: r.error }, r.status || 400);
+    if (r.refused) return json(res, { ok: false, refused: r.refused, error: r.refused.why }, 409);
+    if (r.prompt_sha !== c.req.prompt_sha) return json(res, { ok: false, error: 'the plan changed since you reviewed it — read it again', prompt_sha: r.prompt_sha }, 409);
+    const rec = { id: 'pq-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5), at: nowISO(), event: 'queued', ws: w.id, initiative_id: c.req.initiative_id, item_id: c.req.item_id, key: r.item.key,
+      candidate_id: c.req.candidate_id, prompt_sha: r.prompt_sha, branch: r.plan.branch || null };
+    const wrote = nsAppend(PRO_QUEUE(), rec, 'prepare queue');
+    if (!wrote.ok) return json(res, { ok: false, error: wrote.error }, 500);
+    return json(res, { ok: true, entry: rec });
+  }
+  if (p === '/api/proactive/prepare/cancel' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const e = queueEntries().find((x) => x.id === String(body.id || ''));
+    if (!e) return json(res, { ok: false, error: 'no such queued entry' }, 404);
+    if (e.status !== 'queued') return json(res, { ok: false, error: `it is already ${e.status} — only a queued entry can be cancelled` }, 409);
+    const wrote = nsAppend(PRO_QUEUE(), { id: e.id, at: nowISO(), event: 'cancelled', reason: 'cancelled by you' }, 'prepare queue');
+    if (!wrote.ok) return json(res, { ok: false, error: wrote.error }, 500);
+    return json(res, { ok: true });
+  }
+  if (p === '/api/proactive/prepare/run' && req.method === 'POST') {
+    // A PM press: look at the queue now. Quiet hours are ignored; the switch, the budget, the plan hash and the 24 hours are not.
+    return json(res, { ok: true, results: prepareTick({ manual: true }) });
+  }
+  if (p === '/api/proactive/prepare' && req.method === 'GET') {
+    const entries = queueEntries().slice(-30).reverse().map((e) => ({ ...e, label: e.key + ' · ' + e.initiative_id }));
+    return json(res, { ok: true, ...prepareState(), entries });
+  }
   /* ── proactive engine (D1): Today is computed, feedback is recorded, nothing is sent, started or changed ── */
   if (p === '/api/proactive/today' && req.method === 'GET') {
     const now = Date.now();