create-pmos 0.38.7 → 0.38.8

package/workspace/public/pm/state.js

@@ -24,7 +24,7 @@ const STORE_KEY = 'pmos.workspace.pm.v1';
 /** The initial state — the prototype's `state = {…}` block, key for key. */
 function initial() {
   return {
-    theme: 'dark', sel: null, q: '', mode: 'product', collapsedGroups: {}, settingsOpen: false,
+    theme: 'dark', sel: null, q: '', mode: 'product', collapsedGroups: {}, groupBy: 'objective', activeOnly: false, settingsOpen: false,
     product: null, intgSynced: {},
     addSrc: 'github', addRepo: 'github.com/acme/atlas-mobile', addPath: '~/code/notes-cli',
     addLog: [], addedProducts: [], extraKnow: {},
@@ -153,7 +153,9 @@ const TAB_FIELDS = ['id', 'kind', 'title', 'slug', 'repo', 'sess', 'sessionId',
   // a web tab's address (overhaul-r5, D69) — restored, re-validated, and loaded only on a PM press
   'url',
   // a skill tab's skill id — a reload reopens the same skill
-  'skillId'];
+  'skillId',
+  // a conversation tab's session id — a reload reopens the same transcript
+  'convId'];
 const MAX_TABS = 40;
 
 function packTab(t) {
@@ -181,6 +183,9 @@ const PERSIST = {
   product: isSlug,
   sel: isSlug,
   collapsedGroups: isFlagMap,
+  // how the initiative list is grouped: by objective (default) or by derived status (initiative-surface-batch R2)
+  groupBy: (v) => v === 'objective' || v === 'status',
+  activeOnly: isBool,
   collapsedPhases: isFlagMap,
   // per doc tab: true = 72ch measure, false = full width; absent = the viewport default (R5.1)
   docNarrow: isFlagMap,

package/workspace/server.js

@@ -63,6 +63,10 @@ ensureSpawnHelperExecutable();
 const { checkSurface } = require('./lib/surface-contract');
 const { createSinkGuard } = require('./lib/sink.js');
 const scheduleLogic = require('./lib/schedule-logic');
+const { safeFirstInput } = require('./lib/prompt-input');
+const transcriptsLib = require('./lib/transcripts');
+const initiativeFiles = require('./lib/initiative-files');
+const { deriveNextSteps } = require('./lib/next-steps');
 const harness = require('./lib/harness-parse');
 const transcript = require('./lib/transcript-read');
 const skillStore = require('./lib/skill-store');
@@ -2040,6 +2044,13 @@ const SEED_SETS = {
 function readSchedules() {
   try { const a = JSON.parse(fs.readFileSync(schedFile(), 'utf8')); return Array.isArray(a) ? a : []; } catch { return []; }
 }
+// R5 — count a fire against the schedule's own limits. A schedule that has run `max_runs` times, or whose `until`
+// day is over, turns itself off and says why; nothing about a schedule without either changes.
+function countRun(cur, now = new Date()) {
+  cur.runs = (+cur.runs || 0) + 1;
+  const why = scheduleLogic.finishReason(cur, now);
+  if (why) { cur.enabled = false; cur.endedReason = why; cur.nextRun = null; }
+}
 function writeSchedules(list) {
   try { fs.writeFileSync(schedFile(), JSON.stringify(list)); }
   catch (e) { warnWriteFail('schedules.json (scheduled tasks)', e); }
@@ -2088,7 +2099,7 @@ function fireSchedule(sched) {
       modelAsk: { scheduleTier: sched.tier || null, skillTier: task.tier || null, skill: task.skill } });
     const list = readSchedules(); const cur = list.find((x) => x.id === sched.id);
     const started = s.state !== 'exited';
-    if (cur) { cur.lastRun = nowISO(); cur.lastStatus = started ? 'started' : 'fail'; cur.nextRun = scheduleLogic.nextRun(cur); if (cur.cadence === 'once') cur.enabled = false; writeSchedules(list); }
+    if (cur) { cur.lastRun = nowISO(); cur.lastStatus = started ? 'started' : 'fail'; cur.nextRun = scheduleLogic.nextRun(cur); if (cur.cadence === 'once') cur.enabled = false; countRun(cur); writeSchedules(list); }
     // A run that started WITHOUT the profile it recorded is reported as such rather than as a
     // clean start: the session is real, the environment is not the one the schedule declared.
     return { ok: started, kind: 'agent', sessionId: s.id,
@@ -2110,7 +2121,7 @@ function fireSchedule(sched) {
   // stamp lastRun/lastStatus/nextRun via the pure module
   const list = readSchedules();
   const cur = list.find((s) => s.id === sched.id);
-  if (cur) { cur.lastRun = nowISO(); cur.lastStatus = ok ? 'ok' : 'fail'; cur.nextRun = scheduleLogic.nextRun(cur); writeSchedules(list); }
+  if (cur) { cur.lastRun = nowISO(); cur.lastStatus = ok ? 'ok' : 'fail'; cur.nextRun = scheduleLogic.nextRun(cur); countRun(cur); writeSchedules(list); }
   // surface it — the finished run reaches the PM through needs-you (R5), honest on failure
   try {
     const nf = needsFileFor(w);
@@ -2131,6 +2142,7 @@ function checkDueSchedules() {
   try {
     const list = readSchedules(); let changed = false;
     for (const s of list) if (scheduleLogic.isMissed(s)) { s.enabled = false; s.lastStatus = 'missed'; s.nextRun = null; changed = true; }
+    for (const s of list) { const why = s.enabled && scheduleLogic.finishReason(s); if (why) { s.enabled = false; s.endedReason = why; s.nextRun = null; changed = true; } }
     if (changed) writeSchedules(list);
   } catch {}
   return fired;
@@ -2145,7 +2157,29 @@ const sessions = new Map();
 const allClients = new Set();
 let seq = 0;
 
+// The initiative a session belongs to, for the conversation record: the PM's or spawn's explicit word first,
+// else the `initiative/<id>` branch its working tree is on (the same join the initiative detail makes).
+function initiativeOfSession(s) {
+  if (s && s.initiative) return String(s.initiative);
+  try {
+    const w = wsList().find((x) => x.id === (s && s.ws));
+    const m = w && w.branch ? /^initiative\/(.+)$/.exec(String(w.branch)) : null;
+    return m ? m[1] : null;
+  } catch { return null; }
+}
+// Save the conversation of a session that belongs to an initiative, so ending or removing it no longer erases it.
+// Runtime state only, never the repository (PM ruling 2026-10-03). Quiet when the session is on no initiative.
+function recordConversation(s) {
+  const initiative = initiativeOfSession(s);
+  if (!initiative) return { ok: false, skipped: true };
+  const r = transcriptsLib.save(STATE, { id: s.id, name: s.name, agent: s.agent, ws: s.ws, initiative,
+    state: s.state, started: s.created ? new Date(s.created).toISOString() : null, text: s.buf });
+  if (!r.ok) warnWriteFail('transcripts (conversation record)', new Error(r.error));
+  return r;
+}
 function persist(s) {
+  if (s.state === 'exited' && !s._txSaved) { s._txSaved = true; try { recordConversation(s); } catch {} }
+  else if (s.state !== 'exited') s._txSaved = false;
   // note IS persisted — a restored session must still say why it exited. `root` is persisted
   // so a session survives even if the workspace registry is lost (it re-registers its root).
   const meta = { id: s.id, ws: s.ws, root: s.root, name: s.name, agent: s.agent, cwd: s.cwd,
@@ -2872,7 +2906,8 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
   try { memoryLib.renderFor(root); } catch { /* memory is never a reason a session fails to start */ }
   // a scheduled run tags the session with its origin, and feeds the skill invocation as first input
   const tag = origin || null;
-  const feed = (s) => { if (initialInput && s && s.pty) { try { setTimeout(() => { try { s.pty.write(initialInput); } catch {} }, 700); } catch {} } };
+  // safeFirstInput: a first input that begins with `/` is read by the agent as a slash command, not as the task.
+  const feed = (s) => { if (initialInput && s && s.pty) { try { setTimeout(() => { try { s.pty.write(safeFirstInput(initialInput)); } catch {} }, 700); } catch {} } };
   // shell gets a real fallback to `sh`; agent CLIs run as-is (harness untouched), NO fallback —
   // falling back from `claude` to `sh` would be a lie.
   const cmd = isShell ? (commandExists(SHELL) ? SHELL : 'sh') : agent;
@@ -3302,6 +3337,7 @@ function removeSession(id) {
   const s = sessions.get(id);
   if (!s || s.pty) return false;
   if (s.tmux) tmuxKillSession(s.tmux);   // best-effort: never orphan a detached tmux session
+  try { recordConversation(s); } catch {}   // the conversation outlives the session (surface-batch R5)
   forgetScratchpad(s);                   // the tab's staging text goes with the tab
   // Drop a claim this session held. Correctness does not depend on this — treeShare.writerOf only
   // believes a claim whose holder is still live, so a stale entry already reads as vacant — but a
@@ -4229,6 +4265,7 @@ async function handleRequest(req, res) {
   // is the same two-hopper lib/four-panel.js makes per initiative on the server; the board makes it
   // once over every session, from this module, so 178 rows cost no requests.
   if (p === '/lib/working-set.js') return serveFile(res, path.join(__dirname, 'lib', 'working-set.js'));
+  if (p === '/lib/status-groups.js') return serveFile(res, path.join(__dirname, 'lib', 'status-groups.js'));
   // The editor computes its live diff with the SAME module the server saves through, so what the PM
   // sees while typing and what gets written cannot disagree. NB: /lib/ is an explicit allowlist, not
   // a directory route — a <script src> for a file missing from this list 404s silently, and the
@@ -4840,6 +4877,29 @@ async function handleRequest(req, res) {
     if (err) return json(res, { ok: false, error: err }, 500);
     return json(res, { ok: true, prefs });
   }
+  // One recorded conversation (R5): the live session's text, or the saved record once it has ended. Read-only.
+  if (p === '/api/transcript' && req.method === 'GET') {
+    const id = String(url.searchParams.get('id') || '');
+    const live = sessions.get(id);
+    if (live) {
+      const initiative = initiativeOfSession(live);
+      return json(res, { ok: true, id, name: live.name, initiative, state: live.state, live: live.state !== 'exited',
+        stored: 'the runtime state directory — not the repository, and never sent anywhere',
+        text: transcriptsLib.stripAnsi(live.buf).slice(-transcriptsLib.MAX_CHARS) });
+    }
+    const rec = transcriptsLib.read(STATE, id);
+    if (!rec) return json(res, { ok: false, error: 'no recorded conversation with that id' }, 404);
+    return json(res, { ok: true, ...rec, live: false, stored: 'the runtime state directory — not the repository, and never sent anywhere' });
+  }
+  // The tail of one session's terminal text, escape codes stripped, so a CLI can turn "what I just did" into a skill.
+  // Read-only, local, and capped; it names the session it read or says there is none.
+  if (p === '/api/sessions/transcript' && req.method === 'GET') {
+    const sess = sessions.get(String(url.searchParams.get('id') || ''));
+    if (!sess) return json(res, { ok: false, error: 'no such session' }, 404);
+    const max = Math.min(60000, Math.max(500, +url.searchParams.get('max') || 20000));
+    const text = transcriptsLib.stripAnsi(sess.buf).slice(-max);
+    return json(res, { ok: true, id: sess.id, name: sess.name, chars: text.length, text });
+  }
   if (p === '/api/schedules' && req.method === 'GET') {
     // `all=1` (overhaul-r4 D1): every repository's schedules — the drawer lists `scheduled` under "all
     // repositories", so filtering to the home workspace there would hide the PM's other schedules
@@ -4905,8 +4965,32 @@ async function handleRequest(req, res) {
     let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON' }, 400); }
     const list = readSchedules(); const s = list.find((x) => x.id === body.id);
     if (!s) return json(res, { ok: false, error: 'no such schedule' }, 404);
-    if (typeof body.enabled === 'boolean') s.enabled = body.enabled;
+    // R5 — `until` and `max_runs` are validated by the same rules a new schedule is, and null/'' clears one. A refused value
+    // returns BEFORE anything is changed, so a bad edit leaves the record as it was.
+    const lim = {};
+    for (const k of ['until', 'max_runs']) if (k in body) lim[k] = body[k];
+    if (Object.keys(lim).length) {
+      const chk = scheduleLogic.normalizeSchedule({ name: s.name, cadence: s.cadence === 'once' ? 'daily' : s.cadence, skill: s.skill, ...lim });
+      if (!chk.ok) return json(res, { ok: false, error: chk.error }, 400);
+      for (const k of Object.keys(lim)) { if (lim[k] == null || lim[k] === '') delete s[k]; else s[k] = chk.schedule[k]; }
+    }
+    if (typeof body.enabled === 'boolean') { s.enabled = body.enabled; if (body.enabled) delete s.endedReason; }
+    // Every field an edit may set is checked BEFORE any is applied (R2): a refused edit names the allowed values and
+    // leaves the record untouched. `skill` must be one that loads for this schedule's repository.
+    const bad = (m) => json(res, { ok: false, error: m }, 400);
+    if (body.cadence != null && !scheduleLogic.CADENCES.includes(body.cadence)) return bad(`cadence must be one of ${scheduleLogic.CADENCES.join(', ')}`);
+    if (body.day != null && !['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'].includes(body.day)) return bad('day must be one of Mon, Tue, Wed, Thu, Fri, Sat, Sun');
+    if (body.dayOfMonth != null && !(Number.isInteger(+body.dayOfMonth) && +body.dayOfMonth >= 1 && +body.dayOfMonth <= 28)) return bad('dayOfMonth must be a whole number from 1 to 28');
+    if (body.time != null && !/^([01]?\d|2[0-3]):[0-5]\d$/.test(String(body.time))) return bad('time must be HH:MM, 24-hour, this machine\'s clock');
+    if (body.date != null && !/^\d{4}-\d{2}-\d{2}$/.test(String(body.date))) return bad('date must be YYYY-MM-DD');
+    if (body.name != null && !String(body.name).trim()) return bad('name cannot be empty');
+    if (body.args != null && String(body.args).length > 2000) return bad('args is limited to 2000 characters');
+    for (const k of ['skill', 'task']) if (body[k] != null) {
+      const ws0 = workspaces.get(s.ws);
+      if (!taskById(body[k], ws0 ? ws0.root : null)) return bad(`no skill named "${body[k]}" is available to this schedule`);
+    }
     for (const k of ['name', 'cadence', 'day', 'dayOfMonth', 'time', 'task', 'skill', 'date', 'args']) if (body[k] != null) s[k] = body[k];
+    if ('args' in body && (body.args === null || body.args === '')) delete s.args;
     if ('tier' in body) { if (body.tier === null || body.tier === '') delete s.tier; else if (/^(fast|balanced|deep)$/.test(String(body.tier))) s.tier = String(body.tier); else return json(res, { ok: false, error: 'tier must be fast, balanced or deep' }, 400); }
     // `profile` is settable to null (clear it) as well as to an id, so it is checked for PRESENCE
     // of the key rather than for a non-null value — the other fields above cannot be cleared.
@@ -5189,7 +5273,30 @@ async function handleRequest(req, res) {
     // Discriminated READ results stay 200 — the body carries the reason, the transport code cannot.
     let lanes = null;
     try { if (typeof engine.engine.lanesFor === 'function') lanes = engine.engine.lanesFor(root); } catch { lanes = null; }
-    return json(res, { ws: w ? w.id : null, ...out, lanes });
+    // R4/R5/R6 — what remains to reach acceptance, the conversations that belong to this initiative, and the
+    // files git says were changed for it. Each is read, never guessed; a failed read says so.
+    const sessRows = sessionList();
+    const liveConv = sessRows.filter((x) => initiativeOfSession(sessions.get(x.id)) === id)
+      .map((x) => ({ id: x.id, name: x.name, state: x.state === 'exited' ? 'exited' : 'live', live: x.state !== 'exited', ws: x.ws }));
+    const savedConv = transcriptsLib.listFor(STATE, id).filter((c) => !liveConv.some((l) => l.id === c.id))
+      .map((c) => ({ id: c.id, name: c.name, state: 'ended', live: false, ws: c.ws, saved: c.saved, chars: c.chars, cut: c.cut }));
+    const conversations = [...liveConv, ...savedConv];
+    const listed = new Set(((out && out.artifacts) || []).map((a) => a && a.path).filter(Boolean));
+    let files;
+    try { files = initiativeFiles.filesFor(root, id, { exclude: listed }); }
+    catch (e) { files = { ok: false, reason: 'the files could not be read — ' + String((e && e.message) || 'error').slice(0, 120) }; }
+    let nextSteps = null;
+    try {
+      const acc = readAcceptances(w).get(id) || {};
+      const lc = readLifecycle(w).get(id) || null;
+      nextSteps = deriveNextSteps({
+        id, accepted: acc.action === 'accept', returned: acc.action === 'return',
+        lifecycle: lc && lc.state !== 'active' ? lc : null, ladder,
+        needs: (readNeeds(w) || []).filter((n) => n && n.initiative_id === id),
+        sessions: sessRows.filter((x) => (x.initiative === id) || conversations.some((c) => c.id === x.id && c.live)),
+      });
+    } catch (e) { nextSteps = { state: 'unreadable', summary: 'The next steps could not be derived — ' + String((e && e.message) || 'error').slice(0, 120), items: [] }; }
+    return json(res, { ws: w ? w.id : null, ...out, lanes, conversations, files, next_steps: nextSteps });
   }
   if (p === '/api/audit' && req.method === 'GET') {
     /* The workflow audit (D77): the sweep run on one repository, read-only. It reports state that contradicts