create-pmos 0.213.0 → 0.215.0

package/workspace/lib/jira-status.js

@@ -355,6 +355,38 @@ function readSprintNotes(root) {
 function frozenNotes(root) { const r = readSprintNotes(root); return r ? r.notes.filter((x) => x.state === 'closed') : []; }
 const count = (v, max) => (Number.isInteger(v) && v >= 0 && v <= (max == null ? 100000 : max) ? v : null);
 const text = (v, n) => clip(oneLine(v), n);
+const HITS = ['met', 'partly', 'missed'];
+const HEALTH = ['ok', 'warn', 'bad'];
+const strs = (v, max, n) => (Array.isArray(v) ? v.map((x) => text(x, n)).filter(Boolean).slice(0, max) : []);
+const iniOrNull = (v) => { const ini = v == null || v === '' ? null : String(v).trim(); return ini == null || INI_RE.test(ini) ? { ini } : null; };
+/** The brief of an active or future sprint → { brief } | { error }. A plan is what the PM can do to move the ticket to done. */
+function briefOf(b, name) {
+  const health = String(b.health || '').toLowerCase();
+  if (!HEALTH.includes(health)) return { error: `${name}: brief.health is ok, warn or bad` };
+  const verdict = text(b.verdict, 600);
+  if (!verdict) return { error: `${name}: brief.verdict is empty — say where the sprint stands` };
+  const issues = [];
+  for (const i of Array.isArray(b.issues) ? b.issues.slice(0, 8) : []) {
+    const title = i && text(i.title, 120);
+    if (!title) return { error: `${name}: an issue has no title` };
+    const sev = String(i.sev || '').toLowerCase();
+    if (!['bad', 'warn'].includes(sev)) return { error: `${name}: issue "${title}" needs sev bad (blocked) or warn (watch)` };
+    const plan = strs(i.plan, 5, 240);
+    if (!plan.length) return { error: `${name}: issue "${title}" needs a plan — the steps that move it to done` };
+    const io = iniOrNull(i.initiative);
+    if (!io) return { error: `${name}: issue "${title}" has a bad initiative id` };
+    issues.push({ sev, title, keys: text(i.keys, 80), initiative: io.ini, why: text(i.why, 300), by: text(i.by, 60), plan, doneWhen: text(i.doneWhen, 200) });
+  }
+  const done = [];
+  for (const d of Array.isArray(b.done) ? b.done.slice(0, 8) : []) {
+    const title = d && text(d.title, 120);
+    if (!title) return { error: `${name}: a done entry has no title` };
+    const io = iniOrNull(d.initiative);
+    if (!io) return { error: `${name}: done "${title}" has a bad initiative id` };
+    done.push({ title, keys: text(d.keys, 80), initiative: io.ini, line: text(d.line, 200), waiting: d.waiting === true });
+  }
+  return { brief: { health, verdict, issues, done, asks: strs(b.asks, 4, 240) } };
+}
 /** One sprint's note from the agent → { note } | { error }. Nothing is guessed: a missing required field refuses the note. */
 function noteOne(x) {
   if (!x || typeof x !== 'object') return { error: 'a sprint note is not an object' };
@@ -381,6 +413,19 @@ function noteOne(x) {
     themes.push({ title, line: text(t.line, 200), tickets, done: Math.min(count(t.done) || 0, tickets), blocked: Math.min(count(t.blocked) || 0, tickets), people: text(t.people, 80), initiative: ini });
   }
   const note = { name, state, goal, summary, themes };
+  // The sprint brief (sprint-goal-summary, mockup-c3-sprint-brief): where the sprint stands, the issues to resolve with a proposed
+  // plan each, what is done and the asks for the PM. Written by the agent from the tickets; optional, so a note without one still loads.
+  if (state !== 'closed' && x.brief && typeof x.brief === 'object') {
+    const r = briefOf(x.brief, name);
+    if (r.error) return r;
+    note.brief = r.brief;
+  }
+  if (state === 'closed') {
+    const hit = String(x.hit || '').toLowerCase();
+    if (hit) { if (!HITS.includes(hit)) return { error: `${name}: hit is met, partly or missed` }; note.hit = hit; }
+    const gotInWay = text(x.got, 300);
+    if (gotInWay) note.got = gotInWay;
+  }
   const id = isStr(x.id) || Number.isInteger(x.id) ? String(x.id) : '';
   if (/^\d{1,12}$/.test(id)) note.id = id;
   if (state === 'closed' && x.closed && typeof x.closed === 'object') {
@@ -460,4 +505,4 @@ function which(root, key) {
 }
 
 module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel, sprintQuery, syncSprints, readSprints, SPRINTS_FILE,
-  sprintsToSummarise, saveSprintNotes, readSprintNotes, sameSprint, NOTES_FILE };
+  sprintsToSummarise, saveSprintNotes, readSprintNotes, sameSprint, noteOne, NOTES_FILE };

package/workspace/lib/my-work.js

@@ -194,7 +194,7 @@ function stateOf(item, presses, runs) {
   if (!last || last.action === 'reopen') return { state: 'brief', sub: null, task: null, instruction: null };
   if (last.action === 'handle') return { state: 'yours', sub: null, task: null, instruction: null, decided_at: last.at };
   const t = taskOf(runs, last);
-  const task = t ? { id: t.id, status: t.status, error: t.error || null, draft: t.draft ? t.draft.summary : null, body: t.draft ? t.draft.body || null : null,
+  const task = t ? { id: t.id, status: t.status, error: t.error || null, draft: t.draft ? t.draft.summary : null, body: t.draft ? t.draft.body || null : null, edited_at: t.draft ? t.draft.edited_at || null : null,
     sent: t.sent || null, started_at: t.started_at || null, revisions: Array.isArray(t.revisions) ? t.revisions.length : 0,
       session: t.stalled_session || null, asks: t.asks || null } : null;
   const base = { task, instruction: last.instruction, decided_at: last.at };

package/workspace/lib/proactive-cli.js

@@ -296,13 +296,19 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
       else {
         // an item the PM added in Work (initiative c3-work-agent, amendment 11): the PM's item is the ask
         const c = t.context || {};
-        say(`from Work: ${t.title}${c.due ? ' · due ' + c.due : ''}${c.from ? ' · with ' + c.from : ''}`);
+        say(`from Work: ${t.title}${c.due ? ' · due ' + c.due : ''}${c.from ? ' · with ' + c.from : ''}${t.link ? ' · link ' + t.link : ''}`);
+        for (const k of ['where', 'about', 'ask', 'how', 'why_now']) if (c[k] && c[k] !== t.title) say(`${k.replace('_', ' ')}: ${c[k]}`);
       }
       // the PM's ask, as Work or Your day gave it, including a changed ask (c3-work-agent amendments 10 and 11)
       if (t.instruction && !t.my_work) say(`instruction from the PM (this is the ask): ${t.instruction}`);
       if (t.kind === 'approve') say('kind approve: deliver ONE draft; nothing goes out until the PM approves it.');
       else say('kind auto: deliver ONE draft; nothing leaves this machine.');
-      if (t.draft) { say(`draft (${t.draft.at}): ${t.draft.summary}${t.draft.link ? ' · ' + t.draft.link : ''}`); say(t.draft.body); }
+      if (t.draft) {
+        say(`draft (${t.draft.at}): ${t.draft.summary}${t.draft.link ? ' · ' + t.draft.link : ''}`);
+        // the PM edited the draft (c3-work-agent amendment 13): the body below is the PM's text, to post as it is
+        if (t.draft.edited_at) say(`edited by the PM (${t.draft.edited_at}): the text below is the PM's own. Post it exactly as written.`);
+        say(t.draft.body);
+      }
       t.revisions.forEach((rv, i) => say(`revision note ${i + 1} (${rv.at}): ${rv.note}`));
       if (t.decided) say(`decided: ${t.decided.action} at ${t.decided.at}${t.decided.note ? ' — ' + t.decided.note : ''}`);
       if (t.sent) say(`sent ${t.sent.at}${t.sent.link ? ' · ' + t.sent.link : ''}`);

package/workspace/lib/routes-my-work.js

@@ -7,9 +7,10 @@
  *   POST /api/my-work/act   { action: brief|handle|reopen, item, instruction?, ws }
  *                                        → { ok, item, task? }      the PM's press; a brief adds one day task (R5)
  *   POST /api/my-work/refresh { ws }     → { ok, session }          Read again: starts the my-work-read skill
- *   POST /api/my-work/decide { item, action: approve|revise|retry, note? }
+ *   POST /api/my-work/decide { item, action: approve|revise|retry|edit, note?, body? }
  *                                        → { ok, item, task }      the PM's decision on the agent's draft (initiative c3-work-agent):
- *                                          approve posts exactly the draft, revise sends it back with the note, retry runs a failed task again
+ *                                          approve posts exactly the draft, revise sends it back with the note, retry runs a failed task
+ *                                          again, edit saves the PM's own text as the draft (approve with body: edit, then approve)
  *   POST /api/my-work/stop   { item }    → { ok, item }            ends the item's working or queued task and offers the suggestion again
  *
  * STATE. The latest read is <runtime>/my-work/read.json and the presses are <runtime>/my-work/actions.jsonl, append-only.
@@ -156,11 +157,13 @@ const nextDay = (d) => new Date(Date.parse(d + 'T00:00:00Z') + DAY_MS).toISOStri
 /** The day run that holds the task of the item's last brief: the brief's day (UTC, as the press records it) up to today. */
 function runOfTask(ctx, brief, today) {
   const id = myWork.taskSpec({ id: brief.item }, brief).id;
+  // the newest: an approved draft of an earlier day joins today's run (amendment 13)
+  let found = null;
   for (let d = String(brief.at).slice(0, 10), n = 0; d <= today && n < 400; d = nextDay(d), n++) {
     let run = null; try { run = ctx.readDayRun ? ctx.readDayRun(d) : null; } catch { run = null; }
-    if (run && dayRun.findTask(run, id)) return { run, id };
+    if (run && dayRun.findTask(run, id)) found = { run, id };
   }
-  return null;
+  return found;
 }
 
 /** decide (approve | revise | retry) or stop, on the task of the item's last brief. */
@@ -175,12 +178,10 @@ function taskPress(ctx, res, verb, body, now) {
   const found = runOfTask(ctx, brief, list.today);
   if (verb === 'decide') {
     if (!found) { ctx.json(res, { ok: false, error: 'the agent has not started this item yet' }, 409); return; }
-    const r = dayRun.decide(found.run, found.id, { action: body.action, note: body.note }, now);
-    if (!r.ok) { ctx.json(res, { ok: false, error: r.error }, 400); return; }
-    const run = ctx.startDayTasks ? ctx.startDayTasks(r.run, now) : r.run;
-    if (!ctx.writeDayRun || !ctx.writeDayRun(run)) { ctx.json(res, { ok: false, error: 'could not save — nothing changed' }, 500); return; }
+    const d = decideDraft(ctx, found.run, found.id, body, now);
+    if (!d.ok) { ctx.json(res, { ok: false, error: d.error }, d.status || 400); return; }
     const after = listFor(ctx, Date.now()).items.find((x) => x.id === item) || null;
-    ctx.json(res, { ok: true, item: after, task: dayRun.findTask(run, found.id) });
+    ctx.json(res, { ok: true, item: after, task: dayRun.findTask(d.run, found.id) });
     return;
   }
   // stop: only a task that has not delivered yet; its session ends and the item offers the suggestion again
@@ -200,6 +201,32 @@ function taskPress(ctx, res, verb, body, now) {
   ctx.json(res, { ok: true, item: after });
 }
 
+/**
+ * The PM's decision on a draft in `run` (amendment 13): edit saves the PM's text as the draft; approve posts the draft,
+ * with the PM's text first when the press carries `body`; revise and retry as lib/day-run.js decide. A draft of an earlier
+ * day is approved in today's run, because the job CLI reads today's run only. Returns { ok, run } (the run that holds the
+ * task now) or { ok: false, error, status }.
+ */
+function decideDraft(ctx, run, taskId, body, now) {
+  const save = (r) => (ctx.writeDayRun && ctx.writeDayRun(r) ? { ok: true, run: r } : { ok: false, status: 500, error: 'could not save — nothing changed' });
+  let cur = run;
+  if (body.action === 'edit' || (body.action === 'approve' && typeof body.body === 'string')) {
+    const e = dayRun.edit(cur, taskId, body.body, now);
+    if (!e.ok) return { ok: false, error: e.error };
+    if (body.action === 'edit') return save(e.run);
+    cur = e.run;
+  }
+  if (body.action === 'approve' && cur.date !== localDate(now)) {
+    const t = dayRun.findTask(cur, taskId);
+    if (cur !== run) { const w = save(cur); if (!w.ok) return w; }
+    const b = ctx.myWorkBrief(t, String(body.ws || cur.ws || ''), (today, spec, at) => dayRun.carry(today, spec, at));
+    return b.ok ? { ok: true, run: b.run } : { ok: false, status: b.status || 500, error: b.error };
+  }
+  const r = dayRun.decide(cur, taskId, { action: body.action, note: body.note }, now);
+  if (!r.ok) return { ok: false, error: r.error };
+  return save(ctx.startDayTasks ? ctx.startDayTasks(r.run, now) : r.run);
+}
+
 /* ── the agent on an item the morning brief suggests for the PM (c3-work-agent amendment 10) and on an item the PM added
  * in Work (amendment 11). Item `brief:<id>`: its task is `t-<id>` in today's day run, added as Your day's "Have the agent
  * draft it" adds it. Item `item-<hex>`: its task is `t-<hex>`, in the newest day run of the last 7 days that holds it. */
@@ -208,13 +235,13 @@ const LOCAL_ITEM = /^item-[0-9a-f]{12}$/;
 
 /** The item the press names, as the agent sees it: its task id, the offer, the spec a press adds and its agent field. */
 function targetOf(ctx, itemId, now) {
-  const today = localDate(now);
   const bm = BRIEF_ITEM.exec(itemId);
   if (bm) {
-    let brief = null; try { brief = JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', today + '.json'), 'utf8')); } catch { brief = null; }
-    const x = brief && brief.date === today ? [...(brief.priorities || []), ...(brief.items || [])].find((y) => y && y.id === bm[1]) : null;
-    if (!x || x.owner !== 'pm') return { error: 'no item of yours with that id in today\'s brief' };
-    const run = ctx.readDayRun ? ctx.readDayRun(today) : null;
+    // today's brief, or an earlier one of the last 7 days when the PM kept the item in Work (amendment 12)
+    const readBriefOf = (d) => { try { return JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', d + '.json'), 'utf8')); } catch { return null; } };
+    const x = assigned.findBriefItem(readBriefOf, bm[1], now);
+    if (!x) return { error: 'no item of yours with that id in a brief of the last 7 days' };
+    const run = assigned.runWith(assigned.recentRuns(ctx.readDayRun, now), 't-' + x.id);
     return { postable: true, taskId: 't-' + x.id, suggest: assigned.briefSuggest(x), spec: (own) => assigned.briefDraftSpec(x, own), run, agent: (r) => assigned.briefAgent(x, r) };
   }
   // an item the PM added in Work (amendment 11): its draft is kept across days, so the newest run that holds its task decides
@@ -257,9 +284,9 @@ function agentItemPress(ctx, res, verb, body, itemId, now) {
     after(b.run, b.task); return;
   }
   if (verb === 'decide') {
-    const r = dayRun.decide(run, taskId, { action: body.action, note: body.note }, now);
-    if (!r.ok) { ctx.json(res, { ok: false, error: r.error }, 400); return; }
-    next = ctx.startDayTasks ? ctx.startDayTasks(r.run, now) : r.run;
+    const d = decideDraft(ctx, run, taskId, body, now);
+    if (!d.ok) { ctx.json(res, { ok: false, error: d.error }, d.status || 400); return; }
+    after(d.run, dayRun.findTask(d.run, taskId)); return;
   } else {
     // stop: only a task that has not delivered; its session ends and the task leaves the run, so the item offers the draft again
     if (t.status !== 'waiting' && t.status !== 'working' && t.status !== 'failed') { ctx.json(res, { ok: false, error: `the agent's task is ${t.status} — there is nothing to stop` }, 409); return; }

package/workspace/lib/routes-pm-items.js

@@ -349,6 +349,14 @@ module.exports = {
       // an item the PM added: the agent can draft a first version of it (c3-work-agent amendment 11)
       const runs = assigned.recentRuns(ctx.readDayRun, c.now.getTime());
       for (const it of v.items) if (!it.agent && assigned.localOffer(it)) it.agent = assigned.localAgent(it, assigned.runWith(runs, assigned.localTaskId(it)));
+      // an item of an earlier brief the PM kept in Work keeps its offer (amendment 12): it is no longer in today's brief
+      const readBriefOf = (d) => { try { return JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', d + '.json'), 'utf8')); } catch { return null; } };
+      for (const it of v.items) {
+        const m = /^brief:([0-9a-f]{12})$/.exec(String(it.id || ''));
+        if (!m || it.agent || it.done || !ctx.runtimeDir) continue;
+        const x = assigned.findBriefItem(readBriefOf, m[1], c.now.getTime());
+        if (x) { it.agent = assigned.briefAgent(x, assigned.runWith(runs, 't-' + x.id)); if (!it.place) it.place = x.source || null; }
+      }
       ctx.json(res, v);
       return true;
     }

package/workspace/lib/transcript-read.js

@@ -50,7 +50,36 @@ const cp = require('child_process');
 // refusal stands (an honest floor, not a silent truncation — the pane pid still had no record).
 const MAX_WALK_DEPTH = 2;
 
-const HOME = () => process.env.PMOS_CLAUDE_HOME || path.join(os.homedir(), '.claude');
+/*
+ * Every folder Claude Code may keep its session records in. A PM with profiles runs Claude with CLAUDE_CONFIG_DIR set
+ * (`alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'`), so its records are in ~/.claude-work/sessions, not
+ * ~/.claude/sessions: reading only ~/.claude made every such session "wrote no session record". The folders: the server's
+ * own CLAUDE_CONFIG_DIR, ~/.claude, each ~/.claude-* folder that has a `sessions` folder, and each PMOS profile's
+ * CLAUDE_CONFIG_DIR. PMOS_CLAUDE_HOME, when set, is the only one (tests). A pid has at most one live record, so looking in
+ * several folders does not weaken the identity proof: the record still has to name a cwd inside the workspace root.
+ */
+const HOMES_MS = 30000;
+let homesSnap = null;
+function claudeHomes(now = Date.now()) {
+  if (process.env.PMOS_CLAUDE_HOME) return [process.env.PMOS_CLAUDE_HOME];
+  if (homesSnap && now - homesSnap.at < HOMES_MS) return homesSnap.list;
+  const hd = os.homedir();
+  const list = [];
+  const add = (d) => { if (d && typeof d === 'string' && path.isAbsolute(d) && !list.includes(path.resolve(d))) list.push(path.resolve(d)); };
+  add(process.env.CLAUDE_CONFIG_DIR);
+  add(path.join(hd, '.claude'));
+  try {
+    for (const n of fs.readdirSync(hd).sort()) {
+      if (/^\.claude-./.test(n) && fs.existsSync(path.join(hd, n, 'sessions'))) add(path.join(hd, n));
+    }
+  } catch { /* no home listing: ~/.claude alone */ }
+  try {
+    const r = require('./profiles').readProfiles(hd, { detect: true });
+    for (const pf of (r && r.profiles) || []) add(pf && pf.env && pf.env.CLAUDE_CONFIG_DIR);
+  } catch { /* profiles unreadable: the folders above */ }
+  homesSnap = { at: now, list };
+  return list;
+}
 // A transcript can grow large; cap what we read so a long session cannot stall a broadcast.
 const MAX_BYTES = 8 * 1024 * 1024;
 // Synthetic assistant records are the CLI's own bookkeeping, not model turns — never counted,
@@ -128,6 +157,15 @@ function descendants(pid, listChildren, maxDepth = MAX_WALK_DEPTH) {
  * consider, pane or descendant, identically.
  */
 function resolvePid(pid, root, home) {
+  if (Array.isArray(home)) {
+    let first = null;
+    for (const h of home) {
+      const r = resolvePid(pid, root, h);
+      if (!r.noRecord) return r;   // the folder that holds this pid's record answers
+      first = first || r;
+    }
+    return first || { noRecord: true };
+  }
   let reg;
   try {
     reg = JSON.parse(fs.readFileSync(path.join(home, 'sessions', `${pid}.json`), 'utf8'));
@@ -150,7 +188,7 @@ function resolvePid(pid, root, home) {
  * process levels for a descendant that resolves in-root — see the child-walk note at the head.
  * `listChildren` is injectable for tests; it defaults to a real `ps` snapshot.
  */
-function findTranscript(pid, root, home = HOME(), listChildren = defaultChildren) {
+function findTranscript(pid, root, home = claudeHomes(), listChildren = defaultChildren) {
   if (!pid) return { missing: "can't identify this session's transcript — no process id" };
   const direct = resolvePid(pid, root, home);
   if (direct.sessionId) return direct;
@@ -321,8 +359,8 @@ function readHarness(file, clean = (x) => x) {
  *   · a `user` record with string content (or text blocks) that is not meta, a sidechain or a compact
  *     summary, and is not the CLI's own command bookkeeping — a slash command shows as `/name`;
  *   · an `assistant` record's text blocks, from a real model turn (never `<synthetic>`);
- *   · tool calls fold into one activity line between them ("Used Bash, Read ×2"), never their input,
- *     which can hold anything.
+ *   · tool calls fold into one activity line between them ("Used Bash, Read ×2"); each call keeps a short
+ *     target (callTarget: the file, pattern or first command line), never the whole input, which can hold anything.
  * Every string goes through `clean` (server.js's scrub, D08). The newest `limit` items are returned. */
 const CONV_LIMIT = 80;
 const CONV_TEXT_MAX = 8000;
@@ -343,7 +381,29 @@ function userText(r) {
   return t.trim();
 }
 
-function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
+/* What one tool call worked on, in a few words: the file, the pattern, the first line of the command, the address. Only these
+ * named fields are read, never the whole input, and the result is at most TARGET_MAX characters (a path inside `root` is shown
+ * relative to it). The caller scrubs it (D08). Anything else gives ''. */
+const TARGET_MAX = 120;
+const CALLS_MAX = 40;
+function callTarget(input, root) {
+  if (!input || typeof input !== 'object') return '';
+  const str = (v) => (typeof v === 'string' ? v : '');
+  const rel = (p) => { const r = root && path.isAbsolute(p) ? path.relative(root, p) : ''; return r && !r.startsWith('..') && !path.isAbsolute(r) ? r : p; };
+  let t = '';
+  const file = str(input.file_path) || str(input.notebook_path);
+  if (file) t = rel(file);
+  else if (str(input.command)) t = str(input.command).split('\n')[0];
+  else if (str(input.pattern)) t = str(input.pattern) + (str(input.path) ? ' in ' + rel(str(input.path)) : '');
+  else if (str(input.url)) t = str(input.url);
+  else if (str(input.query)) t = str(input.query);
+  else if (str(input.description)) t = str(input.description);
+  else if (str(input.path)) t = rel(str(input.path));
+  t = t.replace(/\s+/g, ' ').trim();
+  return t.length > TARGET_MAX ? t.slice(0, TARGET_MAX - 1) + '…' : t;
+}
+
+function readConversation(file, clean = (x) => x, limit = CONV_LIMIT, root = null) {
   let raw;
   try {
     const st = fs.statSync(file);
@@ -362,13 +422,15 @@ function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
   const out = [];
   const cap = (t) => (t.length > CONV_TEXT_MAX ? t.slice(0, CONV_TEXT_MAX) + ' …' : t);
   const push = (role, text, at) => { out.push({ role, text: clean(cap(text)), at: at || null }); };
-  const tool = (name, at) => {
+  const tool = (name, input, at) => {
     const last = out[out.length - 1];
     const n = clean(prettyTool(name));
+    const call = { tool: n, target: clean(callTarget(input, root)) };
     if (last && last.role === 'tool') {
       last.tools[n] = (last.tools[n] || 0) + 1;
+      if (last.calls.length < CALLS_MAX) last.calls.push(call);
       last.at = at || last.at;
-    } else out.push({ role: 'tool', tools: { [n]: 1 }, at: at || null });
+    } else out.push({ role: 'tool', tools: { [n]: 1 }, calls: [call], at: at || null });
   };
   for (const line of raw.split('\n')) {
     if (!line) continue;
@@ -391,14 +453,35 @@ function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
         // one model turn can stream its text in several records: join them into one bubble
         if (last && last.role === 'assistant' && last.msgId && last.msgId === m.id) last.text = clean(cap(last.text + '\n\n' + c.text.trim()));
         else { push('assistant', c.text.trim(), r.timestamp); out[out.length - 1].msgId = m.id || null; }
-      } else if (c.type === 'tool_use' && c.name) tool(c.name, r.timestamp);
+      } else if (c.type === 'tool_use' && c.name) tool(c.name, c.input, r.timestamp);
     }
   }
   const messages = out.slice(-limit).map((x) => (x.role === 'tool'
-    ? { role: 'tool', tools: x.tools, at: x.at }
+    ? { role: 'tool', tools: x.tools, calls: x.calls, at: x.at }
     : { role: x.role, text: x.text, at: x.at }));
   return { messages };
 }
 
-module.exports = { findTranscript, readHarness, readConversation, CONV_LIMIT, prettyTool, slugFor, resolvePid, descendants,
+/*
+ * Claude Code's permission prompt, read from the pane's visible screen (tmux capture-pane -p, plain text). The transcript has
+ * the open call but not the question or its choices, which exist only on the screen. Returns { question, options:[{n, label}] }
+ * when the screen's last "Do you want to …" line is followed by numbered options, else null. The page types an option's
+ * number to answer, which is the key Claude Code's own menu takes. Box-drawing borders are dropped; labels are scrubbed.
+ */
+const ASK_RE = /^Do you want to .+\?$/;
+function permissionAsk(screen, clean = (x) => x) {
+  const lines = String(screen || '').split('\n').map((l) => l.replace(/[│┃]/g, ' ').replace(/\s+$/, '').trim());
+  let at = -1;
+  for (let i = lines.length - 1; i >= 0; i--) if (ASK_RE.test(lines[i])) { at = i; break; }
+  if (at < 0) return null;
+  const options = [];
+  for (const l of lines.slice(at + 1, at + 12)) {
+    const m = /^(?:[❯›>]\s*)?(\d)[.)]\s+(.+)$/.exec(l);
+    if (m) { if (options.length < 6 && !options.some((o) => o.n === m[1])) options.push({ n: m[1], label: clean(m[2].trim()).slice(0, 160) }); }
+    else if (options.length && l) break;
+  }
+  return options.length >= 2 ? { question: clean(lines[at]).slice(0, 200), options } : null;
+}
+
+module.exports = { permissionAsk, claudeHomes, callTarget, findTranscript, readHarness, readConversation, CONV_LIMIT, prettyTool, slugFor, resolvePid, descendants,
   MAX_BYTES, MAX_WALK_DEPTH, PS_SNAPSHOT_MS, defaultChildren };

package/workspace/lib/work-assigned.js

@@ -31,7 +31,7 @@ function agentOf(x) {
   if (!state) return null;
   return {
     state, suggest: x.suggest || null, instruction: x.instruction || null,
-    draft: t && (t.draft || t.body) ? { summary: t.draft || null, body: t.body || null } : null,
+    draft: t && (t.draft || t.body) ? { summary: t.draft || null, body: t.body || null, edited_at: t.edited_at || null } : null,
     sent: t && t.sent ? { link: t.sent.link || null, at: t.sent.at || null } : null,
     error: t ? t.error || null : null, session: t && t.session ? String(t.session) : null, asks: t ? t.asks || null : null, revisions: t ? t.revisions || 0 : 0, started_at: t ? t.started_at || null : null, decided_at: x.decided_at || null,
   };
@@ -77,7 +77,7 @@ function taskAgent(taskId, suggest, run) {
   const base = { suggest, instruction: null, draft: null, sent: null, error: null, session: null, asks: null, revisions: 0, started_at: null, decided_at: null };
   if (!t) return { state: 'suggest', ...base };
   return { ...base, state: TASK_STATE[t.status] || 'queued', instruction: t.instruction || null,
-    draft: t.draft ? { summary: t.draft.summary || null, body: t.draft.body || null } : null,
+    draft: t.draft ? { summary: t.draft.summary || null, body: t.draft.body || null, edited_at: t.draft.edited_at || null } : null,
     sent: t.sent ? { link: t.sent.link || null, at: t.sent.at || null } : null, error: t.error || null,
     session: t.stalled_session ? String(t.stalled_session) : null, asks: t.asks || null, revisions: Array.isArray(t.revisions) ? t.revisions.length : 0,
     started_at: t.started_at || null, decided_at: (t.decided && t.decided.at) || null };
@@ -100,17 +100,29 @@ function localDraftSpec(item, instruction) {
 const localAgent = (item, run) => taskAgent(localTaskId(item), localSuggest(item), run);
 /** The newest of `runs` (newest first) that holds task `taskId`, or null. An item the PM added keeps its draft across days. */
 const runWith = (runs, taskId) => (runs || []).find((r) => r && Array.isArray(r.tasks) && r.tasks.some((t) => t && t.id === taskId)) || null;
+/** The local dates of the last `days` days, newest first. */
+function recentDates(nowMs, days = 7) {
+  const pad = (n) => String(n).padStart(2, '0');
+  const out = [];
+  for (let i = 0; i < days; i++) { const d = new Date(nowMs); d.setDate(d.getDate() - i); out.push(`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`); }
+  return out;
+}
 /** The day runs of the last `days` days, newest first, through `readDayRun(date)`. */
 function recentRuns(readDayRun, nowMs, days = 7) {
-  const out = [];
-  if (typeof readDayRun !== 'function') return out;
-  const pad = (n) => String(n).padStart(2, '0');
-  for (let i = 0; i < days; i++) {
-    const d = new Date(nowMs); d.setDate(d.getDate() - i);
-    let r = null; try { r = readDayRun(`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`); } catch { r = null; }
-    if (r) out.push(r);
+  if (typeof readDayRun !== 'function') return [];
+  return recentDates(nowMs, days).map((d) => { try { return readDayRun(d); } catch { return null; } }).filter(Boolean);
+}
+/** The brief item `id` the PM owns, from the newest brief of the last `days` days that holds it (`readBrief(date)` → brief or
+ *  null), or null. An item of yesterday's brief that the PM kept in Work keeps its agent offer (amendment 12). */
+function findBriefItem(readBrief, id, nowMs, days = 7) {
+  if (typeof readBrief !== 'function') return null;
+  for (const d of recentDates(nowMs, days)) {
+    let b = null; try { b = readBrief(d); } catch { b = null; }
+    if (!b || b.date !== d) continue;
+    const x = [...(Array.isArray(b.priorities) ? b.priorities : []), ...(Array.isArray(b.items) ? b.items : [])].find((y) => y && y.id === id);
+    if (x) return x.owner === 'pm' && !x.worth_asking ? x : null;
   }
-  return out;
+  return null;
 }
 
 function fromBrief(brief, todayIso, run = null) {
@@ -148,4 +160,4 @@ function overlay(item, byId) {
   return out;
 }
 
-module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, briefAgent, briefSuggest, briefDraftSpec, taskAgent, localTaskId, localOffer, localSuggest, localDraftSpec, localAgent, runWith, recentRuns, AGENT };
+module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, briefAgent, briefSuggest, briefDraftSpec, taskAgent, localTaskId, localOffer, localSuggest, localDraftSpec, localAgent, runWith, recentRuns, recentDates, findBriefItem, AGENT };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.213.0",
+  "version": "0.215.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.213.0",
+      "version": "0.215.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/public/pm/c3-demo-boards.js

@@ -391,11 +391,20 @@ export function handle(S, method, path, p, body) {
       const themes = [{ title: own[0] ? own[0].title : 'Sprint work', line: 'Most items are in progress or in review.', tickets: issues.filter((i) => i.initiative === ini0).length || 1, done: issues.filter((i) => i.initiative === ini0 && i.category === 'done').length, blocked: 1, people: 'Ana, Budi', initiative: ini0 },
         { title: 'Fixes and upkeep', line: 'Small fixes outside any initiative.', tickets: 2, done: 1, blocked: 0, people: 'Chen', initiative: null }];
       const act = { name: key + ' Sprint ' + num, state: 'active', issues, counts, goal: { from: 'tickets', text: 'Get the first initiative ready for internal users and clear the blocked work.', jira: 'Q4 delivery' },
-        summary: 'Most of the sprint is on the first initiative. One item is blocked. Two small fixes sit outside any initiative.', themes, writtenAt: TODAY + 'T06:30:00Z', summarisedTickets: issues.length, closed: null, frozen: false };
+        summary: 'Most of the sprint is on the first initiative. One item is blocked. Two small fixes sit outside any initiative.', themes, writtenAt: TODAY + 'T06:30:00Z', summarisedTickets: issues.length, closed: null, frozen: false,
+        brief: { health: 'warn', verdict: 'At risk. Halfway through, 21 of 48 points are done. The team finishes about 27 points a sprint, so about 12 points will carry over unless scope is cut now. The blocked QA plan is the exposed part.',
+          issues: [{ sev: 'bad', title: 'QA test plan for the beta is blocked', keys: key + '-1373', initiative: ini0, why: 'Flagged in Jira for 4 days: no QA tester is free this sprint. The beta cannot start without it.', by: 'Decide today',
+            plan: ['Ask the QA lead whether another team can lend a tester for 3 days this week.', 'If yes, the tester writes the plan by Thursday and the beta keeps its date.', 'If no, move the beta by two weeks and tell the pilot customers this week.'], doneWhen: 'The ticket leaves Blocked with a named tester and a date.' },
+            { sev: 'warn', title: 'Code expiry has sat in review for 3 days', keys: key + '-1371', initiative: ini0, why: 'Review is the slowest step this sprint.', by: 'Raise at stand-up', plan: ['Ask at stand-up for a second reviewer this week.'], doneWhen: 'The ticket is merged.' }],
+          done: [{ title: 'Rate limiting approach chosen', keys: key + '-1370', initiative: ini0, line: 'Unblocks the build next sprint.', waiting: false }, { title: 'Footer shows the right year', keys: key + '-1379', initiative: null, line: 'Waiting for the next release to reach Prod.', waiting: true }],
+          asks: ['Decide how the beta gets QA: borrow a tester, or move the beta date.', 'Cut about 12 points now, starting with the lowest-value tickets.'] },
+        points: { committed: 48, done: 21, unestimated: 2 }, flow: [{ status: 'To Do', category: 'todo', n: counts.todo }, { status: 'In Progress', category: 'doing', n: counts.doing }, { status: 'Done', category: 'done', n: counts.done }].filter((f) => f.n),
+        pace: { day: 7, days: 14, daysLeft: 8, avg: 27, hitRate: 0.77, forecast: 36 } };
       const fut = { ...extra(1, 'future', key + ' Sprint ' + (num + 1), 'todo', 3), goal: { from: 'tickets', text: 'Finish the first initiative and start the beta.', jira: null }, summary: 'Planned so far: three follow-up items.', themes: [], writtenAt: TODAY + 'T06:30:00Z', closed: null, frozen: false };
       const old = { ...extra(0, 'closed', key + ' Sprint ' + (num - 1), 'done', 5), goal: { from: 'tickets', text: 'Start the first initiative.', jira: null }, summary: 'Goal met. Five items shipped; two moved to the next sprint.', themes: [{ title: 'Sprint work', line: '', tickets: 5, done: 5, blocked: 0, people: '', initiative: ini0 }],
-        writtenAt: '2026-09-29T06:30:00Z', closed: { done: 5, total: 7, carried: 2, carriedTo: key + ' Sprint ' + num, points: '21 of 26' }, frozen: true };
-      return okb({ source: 'jira', readAt: TODAY + 'T08:10:00', sprints: [act, fut, old] });
+        writtenAt: '2026-09-29T06:30:00Z', closed: { done: 5, total: 7, carried: 2, carriedTo: key + ' Sprint ' + num, points: '21 of 26' }, frozen: true, hit: 'met', got: 'The code entry screen waited 5 days on design.' };
+      const velocity = [{ name: key + ' Sprint ' + (num - 4), committed: 33, done: 24 }, { name: key + ' Sprint ' + (num - 3), committed: 36, done: 28 }, { name: key + ' Sprint ' + (num - 2), committed: 34, done: 26 }, { name: key + ' Sprint ' + (num - 1), committed: 38, done: 30 }];
+      return okb({ source: 'jira', readAt: TODAY + 'T08:10:00', sprints: [act, fut, old], velocity });
     }
     return fail(404, 'No route ' + path);
   }