create-pmos 0.55.2 → 0.55.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.55.2",
+  "version": "0.55.4",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@b7dc0a6
+kernel-source: pmos@46269fd
 assembled: 2026-10-06
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-06T07:31:23Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T09:30:22Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-06T07:31:23Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T09:30:22Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-06T07:31:23Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T09:30:22Z"}
 status: stable
 ---
 

package/workspace/guide/today.md

@@ -18,6 +18,10 @@ Press **Prepare my day** to start the day. It runs from the brief to the deliver
 
 If the morning-brief session stops before it submits a brief, the Read step says so and gives the reason. **Prepare my day** is then ready again, so press it to try once more. If the session says that its folder is not there, open the repository again from its current folder first.
 
+Each agent job runs in its own session, so you can open any job and follow or steer it. The workspace types the job's prompt into the session when the agent is ready to read, and presses Enter for you. When you approve or revise a job and its session is still open, the workspace uses that same session again. Prepare again works the same way: when the morning-brief session is still open and has finished its read, or has printed nothing for two minutes, the workspace types the read into that session and runs it again.
+
+**Agent results**, at the top of the left column, counts the jobs and lists each finished one with its draft summary or the reason it failed. The other things that wait for you, such as outcome checks, report drafts and sessions, are in **Also waiting for you** at the end of the left column. When the day is folded, they show under it.
+
 Each job has one of three kinds.
 
 | Kind | Who does it | What you do |

package/workspace/lib/day-run.js

@@ -149,6 +149,12 @@ function deliver(run, taskId, d, now) {
   });
 }
 
+/** The task leaves its session: `prev_session` keeps its id, so the next step can run in the same session while it is open. */
+function keepSession(t) {
+  if (t.session_id) t.prev_session = t.session_id;
+  t.session_id = null;
+}
+
 /**
  * The PM's decision on a draft.
  *   approve  review (approve task) → sending: a session will do exactly the approved step. done (auto task) → recorded.
@@ -162,7 +168,7 @@ function decide(run, taskId, op, now) {
   return withTask(run, taskId, (t) => {
     const at = iso(now);
     if (o.action === 'approve') {
-      if (t.status === 'review' && t.kind === 'approve') { t.status = 'sending'; t.session_id = null; t.started_at = null; }
+      if (t.status === 'review' && t.kind === 'approve') { t.status = 'sending'; keepSession(t); t.started_at = null; }
       else if (!(t.status === 'done' && t.kind === 'auto')) return `task ${taskId} is ${t.status} — only a draft waiting for you can be approved`;
       t.decided = { action: 'approve', at, ...(note ? { note: note.slice(0, 500) } : {}) };
       return null;
@@ -173,11 +179,11 @@ function decide(run, taskId, op, now) {
       if (note.length > 500) return 'the note is over 500 characters';
       if (t.revisions.length >= MAX_REVISIONS) return `task ${taskId} has had ${MAX_REVISIONS} revisions — at most ${MAX_REVISIONS}. Do the rest yourself.`;
       t.revisions.push({ note, at });
-      t.status = 'waiting'; t.session_id = null; t.decided = { action: 'revise', at, note };
+      t.status = 'waiting'; keepSession(t); t.decided = { action: 'revise', at, note };
       return null;
     }
     if (t.status !== 'failed') return `task ${taskId} is ${t.status} — only a failed task can be run again`;
-    t.status = 'waiting'; t.session_id = null; t.error = null; t.decided = { action: 'retry', at };
+    t.status = 'waiting'; keepSession(t); t.error = null; t.decided = { action: 'retry', at };
     return null;
   });
 }

package/workspace/lib/first-input.js

@@ -0,0 +1,89 @@
+'use strict';
+/* first-input.js — how the workspace types a session's first input, the prompt it was started for.
+ *
+ * The old way wrote the whole prompt and its Enter as one burst, 700 ms after the start. An agent CLI such as Claude Code
+ * is not ready to read at 700 ms: it is still starting, it may ask its own startup questions, and it reads a fast burst of
+ * text as a paste. So the prompt was lost or sat in the input box without Enter, and the PM opened an empty session.
+ *
+ * Now the workspace waits until the agent is ready, then types the prompt, then presses Enter as a separate key:
+ *   1. READY: the pane printed something and then was quiet for QUIET_MS, and at least MIN_MS passed. A program that prints
+ *      nothing (a plain reader of standard input) is ready after SILENT_MS. After MAX_MS it is typed in any case.
+ *   2. TYPE: when the program turned on bracketed paste (it printed ESC[?2004h), the prompt is sent as one paste, so its
+ *      lines stay one prompt. Otherwise it is sent as typed text.
+ *   3. ENTER: SUBMIT_MS later, Enter alone. A bracketed-paste program that printed nothing after that Enter gets Enter once
+ *      more after RETRY_MS, because the first one can land while the paste is still being read.
+ * The clock and the timers are injected, so the plan is tested without waiting. No I/O of its own: it writes only through
+ * `write`.
+ */
+
+const MIN_MS = 1200;
+const QUIET_MS = 800;
+const SILENT_MS = 3000;
+const MAX_MS = 20000;
+const POLL_MS = 200;
+const SUBMIT_MS = 500;
+const RETRY_MS = 1500;
+const PASTE_ON = '\x1b[?2004h';
+const PASTE_OFF = '\x1b[?2004l';
+
+/** True when the last bracketed-paste switch in `buf` turned it on. */
+function pasteOn(buf) {
+  const b = String(buf || '');
+  return b.lastIndexOf(PASTE_ON) > b.lastIndexOf(PASTE_OFF);
+}
+
+/** Is the pane ready for typed input? `t0` is when the wait began; `firstOut` is when output first came after t0. */
+function ready({ now, t0, lastOutputAt, firstOut }) {
+  const waited = now - t0;
+  if (waited >= MAX_MS) return true;
+  if (waited < MIN_MS) return false;
+  if (!firstOut) return waited >= SILENT_MS;
+  return now - lastOutputAt >= QUIET_MS;
+}
+
+/** Split a first input into the text and whether it ended with Enter. */
+function splitInput(input) {
+  const s = String(input == null ? '' : input);
+  const m = /[\r\n]+$/.exec(s);
+  return { text: m ? s.slice(0, m.index) : s, enter: !!m };
+}
+
+/**
+ * Type `input` into session `s` once it is ready. `s` is read live (s.pty, s.buf, s.lastOutputAt, s.state).
+ * @param {object} s       the session record
+ * @param {string} input   the prompt, with a trailing Enter when it must be submitted
+ * @param {object} [o]     { now, setTimeout, onDone } — injected for tests
+ */
+function deliver(s, input, o = {}) {
+  const now = o.now || (() => Date.now());
+  const later = o.setTimeout || setTimeout;
+  const done = typeof o.onDone === 'function' ? o.onDone : () => {};
+  const { text, enter } = splitInput(input);
+  if (!s || (!text && !enter)) { done('nothing'); return; }
+  const t0 = now();
+  const base = s.lastOutputAt || 0;
+  let firstOut = 0;
+  const alive = () => s.pty && s.state !== 'exited';
+  const write = (d) => { try { s.pty.write(d); return true; } catch { return false; } };
+  const tick = () => {
+    if (!alive()) { done('gone'); return; }
+    if (!firstOut && (s.lastOutputAt || 0) > base) firstOut = s.lastOutputAt;
+    if (!ready({ now: now(), t0, lastOutputAt: s.lastOutputAt || 0, firstOut })) { later(tick, POLL_MS); return; }
+    const paste = pasteOn(s.buf);
+    if (text) write(paste ? '\x1b[200~' + text + '\x1b[201~' : text);
+    if (!enter) { done('typed'); return; }
+    later(() => {
+      if (!alive()) { done('gone'); return; }
+      const before = s.lastOutputAt || 0;
+      write('\r');
+      if (!paste) { done('submitted'); return; }
+      later(() => {
+        if (alive() && (s.lastOutputAt || 0) <= before) { write('\r'); done('resubmitted'); return; }
+        done('submitted');
+      }, RETRY_MS);
+    }, text ? SUBMIT_MS : 0);
+  };
+  later(tick, POLL_MS);
+}
+
+module.exports = { deliver, ready, pasteOn, splitInput, MIN_MS, QUIET_MS, SILENT_MS, MAX_MS, SUBMIT_MS, RETRY_MS };

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.55.2",
+  "version": "0.55.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

package/workspace/public/pm/dest-today.js

@@ -122,8 +122,12 @@ function build(ctx0) {
   // joined to the cards of the first repository in scope, and its initiatives open in that repository
   const dayRepo = sc.repos.length ? sc.repos[0] : null;
   const dayWs = dayRepo ? wsOf(dayRepo) : null;
-  const day = daySection({ ws: dayWs, setState: ctx0.setState || setState, openIni: dayRepo ? (id) => openInitiative(dayRepo, id) : null });
-  return { children: [head, day, health, list, more], sig: JSON.stringify([sc.all, sc.repo, n, ready, expanded, banner]) + daySig(dayWs) + nodes.map((x) => x.outerHTML).join('') };
+  // the open day takes the list into its left column ("Also waiting for you"), so Today shows one layout; a folded day
+  // leaves it below, as before
+  const owed = { list, more, count: n };
+  const day = daySection({ ws: dayWs, setState: ctx0.setState || setState, openIni: dayRepo ? (id) => openInitiative(dayRepo, id) : null, owed });
+  const inDay = !!(day && day.contains(list));
+  return { children: inDay ? [head, day, health] : [head, day, health, list, more], sig: JSON.stringify([sc.all, sc.repo, n, ready, expanded, banner]) + daySig(dayWs) + nodes.map((x) => x.outerHTML).join('') };
 }
 
 /** The key of the control that has the focus inside the board, so it can be focused again after a rebuild. */

package/workspace/public/pm/today-copy.js

@@ -128,7 +128,11 @@ export const COPY = {
     unreached: 'The workspace did not answer.',
     refused: (why) => `Nothing changed. ${why}`,
     oldServer: 'This workspace server has no day run yet. Only your goals show.',
-    panels: { calendar: 'Calendar', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', detail: 'Detail' },
+    panels: { summary: 'Agent results', calendar: 'Calendar', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', waiting: 'Also waiting for you', detail: 'Detail' },
+    summary: (c) => [c.review ? `${c.review} ${c.review === 1 ? 'draft waits' : 'drafts wait'} for you` : null, c.done ? `${c.done} done` : null,
+      c.working ? `${c.working} working` : null, c.failed ? `${c.failed} failed` : null].filter(Boolean).join(' · ') || 'No agent job yet.',
+    summaryAll: (n) => `All ${n} agent ${n === 1 ? 'job has' : 'jobs have'} a result.`,
+    waitingHint: 'Outcome checks, reports and sessions from your repositories, outside today\'s jobs.',
     now: (at) => `now ${at}`,
     noCalendar: 'No events read for today.',
     noJobs: 'No jobs yet. Press Prepare my day. Each job shows here; select one to see what it needs.',

package/workspace/public/pm/today-day.js

@@ -378,6 +378,38 @@ function jobsPanel(ctx) {
     el('ul', { class: 'td-day__rows' }, ...l.map((j) => jobRow(ctx, j))))));
 }
 
+/* The coordinator's view of the run: what every agent job came back with, in one place. The server runs the jobs as one
+ * session each and keeps their state; this reads that state, so it needs no session of its own. */
+function summaryPanel(ctx) {
+  const { m } = ctx;
+  const ts = m.tasks;
+  if (!ts.length) return null;
+  const c = { review: 0, done: 0, working: 0, failed: 0 };
+  for (const t of ts) {
+    if (t.status === 'review') c.review++;
+    else if (t.status === 'done' || t.status === 'sent') c.done++;
+    else if (t.status === 'failed') c.failed++;
+    else c.working++;
+  }
+  const finished = ts.filter((t) => t.status !== 'waiting' && t.status !== 'working' && t.status !== 'sending');
+  const byTask = new Map(m.jobs.filter((j) => j.task).map((j) => [j.task.id, j]));
+  const rows = finished.map((t) => {
+    const j = byTask.get(t.id);
+    const what = t.status === 'failed' ? t.error : t.sent && t.sent.link ? t.sent.link : t.draft ? t.draft.summary : '';
+    return j ? rowBtn(ctx, 'job', j.id, { lead: '·', title: j.title, meta: what || '', trail: statusPill(j) }) : null;
+  }).filter(Boolean);
+  return panel('summary', null,
+    el('p', { class: 'td-day__note', 'data-day': 'summary' }, c.working ? D.summary(c) : D.summaryAll(ts.length) + ' ' + D.summary(c)),
+    rows.length ? el('ul', { class: 'td-day__rows', 'data-day-list': 'summary' }, ...rows) : null);
+}
+
+/* What waits for the PM outside today's jobs (the Today cards: outcome checks, reports, sessions). Today hands its list
+ * in, so the cards keep their own controls and the open day shows one layout. */
+function waitingPanel(owed) {
+  if (!owed || !owed.list) return null;
+  return panel('waiting', owed.count ? String(owed.count) : null, note(D.waitingHint), owed.list, owed.more || null);
+}
+
 function goalsPanel(ctx) {
   const { m } = ctx;
   return panel('goals', D.goalsCount(m.goals.filter((g) => g.status === 'open').length, m.maxGoals), goalRows(ctx), goalAdd(ctx));
@@ -721,7 +753,7 @@ function fold(open) {
 }
 
 /** The section. `ws` is the repository the day run belongs to; `openIni(id)` opens an initiative of it. */
-export function daySection({ ws, setState, openIni } = {}) {
+export function daySection({ ws, setState, openIni, owed } = {}) {
   if (FIXTURE) return null;
   // like Today's own feeds, a read that lands re-renders only while the section is on the page: a hidden Today must not
   // cause a whole-page render under whatever the PM is doing elsewhere
@@ -755,7 +787,7 @@ export function daySection({ ws, setState, openIni } = {}) {
     c.error ? el('p', { class: 'td-day__run td-day__run--failed', role: 'status', 'data-day': 'error' }, D.refused(c.error)) : null,
     m.d && m.d.legacy ? note(D.oldServer) : null,
     el('div', { class: 'td-day__cols' },
-      el('div', { class: 'td-day__left' }, calendar(ctx), jobsPanel(ctx), goalsPanel(ctx), mentionsPanel(ctx)),
+      el('div', { class: 'td-day__left' }, summaryPanel(ctx), calendar(ctx), jobsPanel(ctx), goalsPanel(ctx), mentionsPanel(ctx), waitingPanel(owed)),
       detail(ctx)));
 }
 

package/workspace/server.js

@@ -85,6 +85,7 @@ const repoWatch = require('./lib/repo-watch.js');
 tsSettings.adoptEnv(process.env);   // D79 — take the env key into memory and delete it, before anything is spawned
 const scheduleLogic = require('./lib/schedule-logic');
 const { safeFirstInput } = require('./lib/prompt-input');
+const firstInput = require('./lib/first-input');
 const transcriptsLib = require('./lib/transcripts');
 const initiativeFiles = require('./lib/initiative-files');
 const { deriveNextSteps } = require('./lib/next-steps');
@@ -3135,7 +3136,9 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
   // a scheduled run tags the session with its origin, and feeds the skill invocation as first input
   const tag = origin || null;
   // 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 {} } };
+  // firstInput.deliver waits until the agent is ready to read, types the prompt, then presses Enter as its own key
+  // (lib/first-input.js): a burst written at a fixed 700 ms was lost or left unsent while the agent was still starting.
+  const feed = (s) => { if (initialInput && s && s.pty) { try { firstInput.deliver(s, safeFirstInput(initialInput)); } 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;
@@ -3636,6 +3639,18 @@ function briefOfDay(date) {
   try { return JSON.parse(fs.readFileSync(path.join(STATE, 'briefs', date + '.json'), 'utf8')); } catch { return null; }
 }
 const daySessionAlive = (id) => { const s = id && sessions.get(id); return !!s && s.state !== 'exited'; };
+// An agent CLI does not exit when its work is done: the morning-brief session stays open after it submits the brief. So
+// "alive" alone does not mean "still reading". The read is over when today's brief arrived after the session started,
+// or when the pane has printed nothing for BRIEF_IDLE_MS without a brief (it waits on a question, or never got its prompt).
+const BRIEF_IDLE_MS = 2 * 60 * 1000;
+function briefSessionDone(run, date, now) {
+  const bs = run && run.brief_session; const s = bs && sessions.get(bs.id);
+  if (!s || s.state === 'exited' || bs.ended_at) return null;
+  let at = 0; try { at = fs.statSync(path.join(STATE, 'briefs', date + '.json')).mtimeMs; } catch { /* no brief yet */ }
+  if (at && at >= Date.parse(bs.started_at || 0)) return 'submitted';
+  if (now - Math.max(s.lastOutputAt || 0, Date.parse(bs.started_at || 0) || 0) >= BRIEF_IDLE_MS) return 'idle';
+  return null;
+}
 // The skill's own body is the prompt, as fireSchedule hands it over; the line after it names this run's task and mode.
 function daySkillPrompt(run, skillId) {
   const w = getWs(run.ws);
@@ -3647,8 +3662,15 @@ function daySkillPrompt(run, skillId) {
 function startDayTask(run, t, now) {
   const sk = daySkillPrompt(run, 'day-task');
   let s = null;
-  if (!sk.error) {
-    const prompt = `${sk.prompt}\n\nThis run: /day-task ${t.id} ${t.mode} — read the task first with: pmos proactive day show ${t.id}`;
+  const line = `This run: /day-task ${t.id} ${t.mode} — read the task first with: pmos proactive day show ${t.id}`;
+  // The session that did the task's last step is used again while it is open: it has the skill and the task in its
+  // context already, so only this run's line is typed into it, and the PM keeps one session per job.
+  const prev = t.prev_session && sessions.get(t.prev_session);
+  if (!sk.error && prev && prev.state !== 'exited' && prev.pty) {
+    try { firstInput.deliver(prev, line + '\r'); s = prev; } catch { s = null; }
+  }
+  if (!sk.error && !s) {
+    const prompt = `${sk.prompt}\n\n${line}`;
     s = spawnSession({ name: `${t.title} · day task`, agent: sk.task.agent || 'claude', ws: sk.w ? sk.w.id : run.ws, origin: 'day-task', initialInput: prompt + '\r',
       modelAsk: { scheduleTier: null, skillTier: sk.task.tier || null, skill: sk.task.skill } });
   }
@@ -7168,6 +7190,18 @@ async function handleRequest(req, res) {
     let run = readDayRun(pdate) || dayRunLib.newRun(pdate, pnow);
     run.ws = w.id;
     if (run.brief_session && !run.brief_session.ended_at) {
+      // A session that finished its read (or sits idle) is used again: the skill's prompt is typed into it and run.
+      const done = daySessionAlive(run.brief_session.id) ? briefSessionDone(run, pdate, pnow) : null;
+      if (done) {
+        const sk = daySkillPrompt(run, 'morning-brief');
+        const s = sessions.get(run.brief_session.id);
+        if (!sk.error) {
+          try { firstInput.deliver(s, `${sk.prompt}\n\nThis run: prepare the day again. Read every source again and submit a new brief for today.\r`); } catch { /* typed below as a new session */ }
+          run.brief_session = { id: s.id, started_at: new Date(pnow).toISOString(), ended_at: null };
+          writeDayRun(run);
+          return json(res, { ok: true, started: true, reused: true, session: s.id, run, goals: open.length });
+        }
+      }
       if (daySessionAlive(run.brief_session.id)) { writeDayRun(run); return json(res, { ok: true, running: true, session: run.brief_session.id, run, goals: open.length }); }
       run = dayRunLib.sessionEnded(run, run.brief_session.id, pnow).run;
     }
@@ -7220,7 +7254,8 @@ async function handleRequest(req, res) {
     const bs = run && run.brief_session; const bsess = bs ? sessions.get(bs.id) : null;
     const readFailed = !run || brief ? null
       : !bs ? { session: null, why: 'the morning-brief session did not start.' }
-      : (!!bs.ended_at || !bsess || bsess.state === 'exited') ? { session: bs.id, why: (bsess && bsess.note) || 'the session ended without submitting a brief.' } : null;
+      : (!!bs.ended_at || !bsess || bsess.state === 'exited') ? { session: bs.id, why: (bsess && bsess.note) || 'the session ended without submitting a brief.' }
+      : briefSessionDone(run, date, now) === 'idle' ? { session: bs.id, idle: true, why: 'the session has printed nothing for two minutes and has not submitted a brief.' } : null;
     return json(res, { ok: true, ws: w ? w.id : null, today: date, now: new Date(now).toISOString(), run, stage: dayRunLib.stage(run, brief), brief, plan, cards_error: cardsError, read_failed: readFailed,
       settings: { briefSources: st.briefSources, scopes: st.scopes, dayCheck: st.dayCheck, websites: st.websites }, sources,
       check: { every: st.dayCheck.every, last: run ? run.checks.last : null, next: due.next, running: !!(run && run.checks.session_id), log: run ? run.checks.log : [] } });