create-pmos 0.206.0 → 0.208.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.206.0",
+  "version": "0.208.0",
   "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@eaa7977
+kernel-source: pmos@709d321
 assembled: 2026-10-14
 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-14T00:14:56Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T01:38:03Z"}
 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-14T00:14:56Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T01:38:03Z"}
 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-14T00:14:56Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T01:38:03Z"}
 status: stable
 ---
 

package/workspace/c3-ib-more-test.js

@@ -45,8 +45,8 @@ const { harness } = require('./c3-ini-harness');
   ok('SP1 the active sprint header says Jira, read-only, and there is no banner', /Jira, read-only/.test(await text('[data-inb="sprints-source"]')) && await st(() => !!document.querySelector('[data-inb-state="active"] [data-inb="sprints-source"]') && !document.querySelector('.fold [data-inb="sprints-source"], .fold[data-inb="sprints-source"]')));
   ok('SP2 the active sprint is drawn with its counts; future and closed sprints are listed', await st(() => !!document.querySelector('[data-inb-state="active"]') && !!document.querySelector('[data-inb-state="future"]') && !!document.querySelector('[data-inb-state="closed"]') && ((m) => !!m && Number(m[1]) === 12 && Number(m[2]) + Number(m[3]) + Number(m[4]) === 12)(/Items(\d+):(\d+)done,(\d+)inprogress,(\d+)todo/.exec(document.querySelector('[data-inb="sprint-counts"]').textContent.replace(/\s+/g, '')))));
   // sprint-goal-summary: the goal (from Jira, or written from the tickets and why), the team summary, closed sprints read once
-  ok('SP4 the active sprint\'s goal is written from the tickets, says Jira\'s goal is too broad and quotes it', await st(() => { const g = document.querySelector('[data-inb="sprint-summary"] [data-inb="sprint-goal"]'); return !!g && g.dataset.inbGoal === 'broad' && /written from the tickets/.test(g.textContent) && /too broad/.test(g.textContent) && /“Q4 delivery”/.test(g.textContent); })
-    && /no goal for this sprint/.test(await text('[data-inb-state="future"] [data-inb="sprint-goal"]')) && /SPRINT GOAL · from Jira/.test(await text('[data-inb-state="closed"] [data-inb="sprint-goal"]')));
+  ok('SP4 the sprint goal is written from the tickets, with Jira\'s goal only as a reference', await st(() => { const g = document.querySelector('[data-inb="sprint-summary"] [data-inb="sprint-goal"]'); return !!g && g.dataset.inbGoal === 'tickets' && /SPRINT GOAL · from the tickets/.test(g.textContent) && /In Jira: “Q4 delivery”/.test(g.textContent) && !/from Jira/.test(g.textContent); })
+    && /from the tickets/.test(await text('[data-inb-state="future"] [data-inb="sprint-goal"]')) && !(await text('[data-inb-state="future"] [data-inb="sprint-goal"]')).includes('In Jira') && /from the tickets/.test(await text('[data-inb-state="closed"] [data-inb="sprint-goal"]')));
   ok('SP5 what the team is working on: a row per theme, one with no initiative', await st(() => document.querySelectorAll('[data-inb="sprint-themes"] [data-inb-theme]').length === 2 && !!document.querySelector('[data-inb-theme="none"]') && /No initiative/.test(document.querySelector('[data-inb-theme="none"]').textContent)));
   ok('SP6 a closed sprint shows done of total, carried, and that it was read and summarised once', /5 of 7 done/.test(await text('[data-inb-state="closed"]')) && /2 carried to/.test(await text('[data-inb-state="closed"]'))
     && /Read and summarised once on 29 Sep\. PMOS does not read a closed sprint again\./.test(await text('[data-inb-state="closed"] [data-inb="sprint-read-once"]')) && /Closed sprints/.test(await text('[data-inb="sprints-how"]')));

package/workspace/guide/jira.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Jira: tickets drafted from the PRD, and their status"
 description: "How to draft Jira tickets from a PRD in your ticket template, push the ones that are ready, and see their status, sprint and progress on the initiative's Jira tickets tab."
-timestamp: 2026-10-13
+timestamp: 2026-10-14
 ---
 
 # Jira: tickets drafted from the PRD, and their status
@@ -119,6 +119,22 @@ pmos jira query --sprints
 pmos jira sync --sprints --from <file|-> [--query "<jql>"]
 ```
 
+## Each sprint's goal and summary
+
+The check then writes a goal and a short summary for each sprint, from the tickets it read. The Sprints tab shows them above the sprint's items, with one row for each group of related work.
+
+- The check always writes the goal from the sprint's tickets, because Jira's sprint goal is often empty, too broad (for example "Q4 delivery") or incomplete. The tab shows it as **from the tickets**.
+- When Jira has a sprint goal, the tab shows it under the goal as a reference: **In Jira: "…"**.
+- The active and the next sprint are summarised again at each check.
+- A closed sprint is read and summarised once. After that, the check does not search it again and keeps its first summary.
+
+The check writes `<state>/tracker/jira/_sprint-notes.md` with:
+
+```
+pmos jira summary
+pmos jira summary --from <file|-> [--dry-run]
+```
+
 ## Link an initiative to its Jira epics
 
 Your team may already plan in Jira, with an epic for each piece of work. Then link the initiative to its epics. You do not have to draft or push tickets.

package/workspace/guide/my-work.md

@@ -98,7 +98,9 @@ An item goes to the first view that fits these rules, in this order. Parked is S
 
 ### Let the agent draft an item
 
-Open an assigned item that shows **Agent can:**. The case file shows **What the agent will do**.
+Open an item that shows **Agent can:**. The case file shows **What the agent will do**.
+
+The offer is on Jira and WBS items with a suggestion, and on each item the morning brief suggests for you (for example a Slack reply or an email). On a brief item the offer is the reply or the note that the item asks for, and the draft goes back to the place the item came from, only when you post it.
 
 1. To change the instruction, select **Change what the agent does** and type a new one.
 2. Select **Let the agent draft this** and hold to confirm. This adds one job to today's day run, with the instruction.

package/workspace/lib/day-run.js

@@ -15,6 +15,7 @@
  *   newRun(date, now) · readRun(raw, date)
  *   addTasks(run, brief)                       agent priorities (kind approve|auto) → waiting tasks
  *   addBriefed(run, spec)                      one task the PM briefed in My work (initiative my-work, PRD R5)
+ *   withdraw(run, taskId)                      a failed task taken out, so its item can be briefed again
  *   addSend(run, spec, now)                    the PM's own text, written in the card, to post as written (today-act-prepare)
  *   toStart(run, limit)                        the tasks to start now, each with its mode (do | revise | send)
  *   started · deliver · decide · sent · fail · stop · sessionEnded · sessionStalled
@@ -283,6 +284,18 @@ function stop(run, taskId, reason, now) {
   });
 }
 
+/** Take a failed task out of the run (c3-work-agent amendment 10): the PM stopped the agent on a brief item, so the item
+ *  offers the draft again and a new press adds the task anew. */
+function withdraw(run, taskId) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  const t = findTask(run, taskId);
+  if (!t) return { ok: false, error: `no task ${taskId} in today's run` };
+  if (t.status !== 'failed') return { ok: false, error: `task ${taskId} is ${t.status} — only a stopped or failed task can be taken out` };
+  const next = clone(run);
+  next.tasks = next.tasks.filter((x) => x.id !== taskId);
+  return { ok: true, run: next };
+}
+
 /** A session ended. A task it was working on without delivering, or sending without reporting, has failed. */
 function sessionEnded(run, sessionId, now) {
   if (!run) return { ok: false, error: 'no day run today' };
@@ -400,5 +413,5 @@ function checkDone(run, { found = 0, resolved = 0 } = {}, now) {
 }
 
 module.exports = { MAX_PARALLEL, MAX_REVISIONS, MAX_CHECK_LOG, MAX_INTERVAL_MIN, STATUSES, KINDS, ACTIONS, TASK_RE,
-  newRun, readRun, findTask, modeOf, addTasks, addBriefed, addSend, toStart, started, deliver, decide, sent, fail, stop, sessionEnded, sessionStalled, stage, intervalMin,
+  newRun, readRun, findTask, modeOf, addTasks, addBriefed, addSend, toStart, started, deliver, decide, sent, fail, stop, withdraw, sessionEnded, sessionStalled, stage, intervalMin,
   checkDue, checkStarted, checkDone };

package/workspace/lib/engine/boards.js

@@ -656,7 +656,7 @@ function sprintsOf(snapshots, onBoard = () => true, whole = null, notes = null)
     const n = nl.find((x) => x.name === sp.name);
     const jg = jiraGoal(sp);
     if (n) {
-      sp.goal = { from: n.goal.from, text: n.goal.text, jira: n.goal.from === 'jira' ? n.goal.text : n.goal.jira || null };
+      sp.goal = { from: 'tickets', text: n.goal.text, jira: n.goal.jira || jg || null };   // always from the tickets; Jira's goal is a reference
       sp.summary = n.summary;
       sp.themes = (n.themes || []).map((t) => ({ title: t.title, line: t.line || '', tickets: t.tickets || 0, done: t.done || 0, blocked: t.blocked || 0, people: t.people || '', initiative: t.initiative || null }));
       sp.writtenAt = n.writtenAt || null;
@@ -664,7 +664,8 @@ function sprintsOf(snapshots, onBoard = () => true, whole = null, notes = null)
       sp.closed = sp.state === 'closed' && n.closed ? { ...n.closed } : null;
       sp.frozen = sp.state === 'closed' && n.state === 'closed';
     } else {
-      sp.goal = jg ? { from: 'jira', text: jg, jira: jg, unchecked: true } : null;
+      sp.goal = null;
+      sp.jiraGoal = jg;
       sp.summary = null; sp.themes = []; sp.writtenAt = null; sp.summarisedTickets = null; sp.closed = null; sp.frozen = false;
     }
   }

package/workspace/lib/jira-status.js

@@ -336,11 +336,10 @@ function syncSprints(root, raw, { query, dryRun = false, now } = {}) {
 function readSprints(root) { return readSnapshot(root, SPRINTS_FILE); }
 
 // ── the goal and summary of each sprint (sprint-goal-summary) ─────────────────────────────────────────
-// The Jira status check writes them from the tickets it read: Jira's goal when it says what the sprint delivers, else a goal
-// written from the tickets, with why (none: Jira has none; broad: too broad; partial: leaves out part of the sprint). A closed
-// sprint's note is written once and kept; its sprint is not searched again.
+// The Jira status check writes them from the tickets it read. The goal is always written from the tickets: Jira's sprint goal is
+// often empty, too broad or incomplete (the PM, 2026-10-14), so it is kept only as a reference (goal.jira). A closed sprint's
+// note is written once and kept; its sprint is not searched again.
 const NOTES_FILE = '_sprint-notes';
-const GOAL_FROM = ['jira', 'none', 'broad', 'partial'];
 const INI_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,80}$/;
 const sameSprint = (a, b) => !!a && !!b && ((a.id && b.id) ? String(a.id) === String(b.id) : String(a.name) === String(b.name));
 function readSprintNotes(root) {
@@ -364,15 +363,11 @@ function noteOne(x) {
   const state = String(x.state || '').toLowerCase();
   if (!SPRINT_STATES.includes(state)) return { error: `${name}: state is active, future or closed` };
   const g = x.goal && typeof x.goal === 'object' ? x.goal : null;
-  if (!g || !GOAL_FROM.includes(g.from)) return { error: `${name}: goal.from is jira, none, broad or partial` };
-  const gt = text(g.text, 240);
-  if (!gt) return { error: `${name}: the goal has no text` };
-  const goal = { from: g.from, text: gt };
-  if (g.from === 'broad' || g.from === 'partial') {
-    const j = text(g.jira, 300);
-    if (!j) return { error: `${name}: a ${g.from} goal carries Jira's own goal in goal.jira` };
-    goal.jira = j;
-  }
+  const gt = g ? text(g.text, 240) : '';
+  if (!gt) return { error: `${name}: the goal has no text — write it from the sprint's tickets` };
+  const goal = { from: 'tickets', text: gt };
+  const j = text(g.jira, 300);
+  if (j) goal.jira = j;   // Jira's own sprint goal, kept for reference only
   const summary = text(x.summary, 900);
   if (!summary) return { error: `${name}: the summary is empty` };
   const themes = [];
@@ -437,12 +432,12 @@ function saveSprintNotes(root, raw, { dryRun = false, now } = {}) {
   if (dryRun || !saved.length) return result;
   const file = snapshotPath(root, NOTES_FILE);
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  const rows = notes.map((o) => `| ${cell(o.name)} | ${cell(o.state)} | ${cell(o.goal.text)} | ${o.goal.from === 'jira' ? 'Jira' : 'written from the tickets'} | ${cell(o.writtenAt)} |`);
+  const rows = notes.map((o) => `| ${cell(o.name)} | ${cell(o.state)} | ${cell(o.goal.text)} | ${o.goal.jira ? cell(o.goal.jira) : '—'} | ${cell(o.writtenAt)} |`);
   const body = [
     '---', 'type: Reference', 'title: "Jira sprints: goal and summary"', `timestamp: ${writtenAt}`, '---', '',
     '# Jira sprints: goal and summary', '',
     'Written by the Jira status check from the tickets it read, read-only. The Sprints tab of a board shows it. A closed sprint is written once and kept. Written by `pmos jira summary`; do not edit by hand.', '',
-    '| Sprint | State | Goal | Goal from | Written |', '|---|---|---|---|---|', ...rows, '',
+    '| Sprint | State | Goal (from the tickets) | Goal in Jira | Written |', '|---|---|---|---|---|', ...rows, '',
     '```json', JSON.stringify({ written_at: writtenAt, sprints: notes }, null, 0), '```', '',
   ].join('\n');
   const tmp = `${file}.${process.pid}.tmp`;

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

@@ -28,6 +28,7 @@ const myWork = require('./my-work.js');
 const boardFold = require('./board-fold.js');
 const offloop = require('./offloop.js');
 const dayRun = require('./day-run.js');
+const assigned = require('./work-assigned.js');
 const { localDate } = require('./brief.js');
 
 const dirOf = (ctx) => path.join(ctx.runtimeDir, 'my-work');
@@ -121,6 +122,9 @@ async function handle(req, res, url, ctx) {
     return true;
   }
 
+  const bm = BRIEF_ITEM.exec(String((body && body.item) || ''));
+  if (bm && p !== '/api/my-work/refresh') { briefPress(ctx, res, p.slice('/api/my-work/'.length), body, bm[1], now); return true; }
+
   if (p === '/api/my-work/decide' || p === '/api/my-work/stop') { taskPress(ctx, res, p.slice('/api/my-work/'.length), body, now); return true; }
 
   // act
@@ -196,4 +200,44 @@ function taskPress(ctx, res, verb, body, now) {
   ctx.json(res, { ok: true, item: after });
 }
 
+/* ── the agent on an item the morning brief suggests for the PM (c3-work-agent amendment 10) ──────────────────────
+ * 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. */
+const BRIEF_ITEM = /^brief:([0-9a-f]{12})$/;
+
+function briefPress(ctx, res, verb, body, id, now) {
+  const today = localDate(now);
+  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 === id) : null;
+  if (!x || x.owner !== 'pm') { ctx.json(res, { ok: false, error: 'no item of yours with that id in today\'s brief' }, 404); return; }
+  const taskId = 't-' + id;
+  const after = (task) => ctx.json(res, { ok: true, item: { id: 'brief:' + id, agent: assigned.briefAgent(x, ctx.readDayRun ? ctx.readDayRun(today) : null) }, task: task || null });
+  if (verb === 'act') {
+    if (body.action !== 'brief') { ctx.json(res, { ok: false, error: 'a brief item takes only action brief here — mark it done or set it aside from Work' }, 400); return; }
+    // the offer as shown ("Draft your reply: …") is not a change: the task then gets the full ask, written for the agent
+    const own = typeof body.instruction === 'string' && body.instruction.trim() !== assigned.briefSuggest(x) ? body.instruction.trim().slice(0, 500) : '';
+    const b = ctx.myWorkBrief(assigned.briefDraftSpec(x, own), String(body.ws || ''));
+    if (!b.ok) { ctx.json(res, { ok: false, error: b.error }, b.status || 500); return; }
+    after(b.task); return;
+  }
+  const run = ctx.readDayRun ? ctx.readDayRun(today) : null;
+  const t = run ? dayRun.findTask(run, taskId) : null;
+  if (!t) { ctx.json(res, { ok: false, error: 'no agent works on this item — let the agent draft it first' }, 409); return; }
+  let next = null;
+  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;
+  } 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; }
+    if (t.session_id && t.status === 'working' && ctx.endSession) { try { ctx.endSession(t.session_id); } catch { /* the session already ended */ } }
+    const f = t.status === 'failed' ? { ok: true, run } : dayRun.stop(run, taskId, 'You stopped it.', now);
+    const w = f.ok ? dayRun.withdraw(f.run, taskId) : f;
+    if (!w.ok) { ctx.json(res, { ok: false, error: w.error }, 409); return; }
+    next = w.run;
+  }
+  if (!ctx.writeDayRun || !ctx.writeDayRun(next)) { ctx.json(res, { ok: false, error: 'could not save — nothing changed' }, 500); return; }
+  after(dayRun.findTask(next, taskId));
+}
+
 module.exports = { prefixes: ['/api/my-work'], handle, listFor, listForAsync };

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

@@ -116,19 +116,23 @@ function readBrief(ctx, now) {
   if (!ctx.runtimeDir) return null;
   try { return JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', require('./brief.js').localDate(now.getTime()) + '.json'), 'utf8')); } catch { return null; }
 }
-function assignedFrom(myWork, brief, now) {
+// today's day run, for the agent state of a brief item (c3-work-agent amendment 10). Best effort: no run, no task.
+function readRun(ctx, now) {
+  try { return typeof ctx.readDayRun === 'function' ? ctx.readDayRun(require('./brief.js').localDate(now.getTime())) : null; } catch { return null; }
+}
+function assignedFrom(myWork, brief, now, run) {
   const todayIso = require('./brief.js').localDate(now.getTime());
-  return [...assigned.fromMyWork(myWork && myWork.ok ? myWork.items : []), ...assigned.fromBrief(brief, todayIso)];
+  return [...assigned.fromMyWork(myWork && myWork.ok ? myWork.items : []), ...assigned.fromBrief(brief, todayIso, run)];
 }
 async function assignedAsync(ctx, now) {
   let mw = null;
   try { mw = await require('./routes-my-work.js').listForAsync(ctx, now.getTime()); } catch { mw = null; }
-  return assignedFrom(mw, readBrief(ctx, now), now);
+  return assignedFrom(mw, readBrief(ctx, now), now, readRun(ctx, now));
 }
 function assignedSync(ctx, now) {
   let mw = null;
   try { mw = require('./routes-my-work.js').listFor(ctx, now.getTime()); } catch { mw = null; }
-  return assignedFrom(mw, readBrief(ctx, now), now);
+  return assignedFrom(mw, readBrief(ctx, now), now, readRun(ctx, now));
 }
 const VIRTUAL_ID = /^(jira:|wbs:|brief:)/;
 

package/workspace/lib/work-assigned.js

@@ -14,7 +14,7 @@
 
 const TIER_PRIORITY = { P1: 'P1', P2: 'P2', P3: 'P3' };
 const AGENT = 'an agent';
-const SHOWN = ['origin', 'key', 'url', 'status', 'suggest', 'why', 'my_work_state', 'repo', 'initiative', 'agent'];
+const SHOWN = ['origin', 'key', 'url', 'status', 'suggest', 'why', 'my_work_state', 'repo', 'initiative', 'agent', 'place'];
 
 /* The agent on a my-work item (initiative c3-work-agent): its state, read from lib/my-work.js stateOf.
  *   suggest  nothing started (the suggestion, when there is one, is the offer)   queued · working · sending · failed  the day task
@@ -56,7 +56,33 @@ function fromMyWork(items) {
   return out;
 }
 
-function fromBrief(brief, todayIso) {
+/* An item the morning brief suggests for the PM (amendment 10): the agent drafts it on the PM's press, as Your day's "Have the
+ * agent draft it" does. Its task in today's day run is `t-<brief item id>`; the state is read from that task. */
+const BRIEF_VERB = { reply: 'reply', review: 'review notes', decide: 'answer', 'sign-off': 'sign-off comment', read: 'summary', do: 'draft' };
+const briefVerb = (x) => BRIEF_VERB[x.verb] || (x.reply_needed ? 'reply' : 'draft');
+const briefWhat = (x) => String(x.todo || x.how || x.ask || x.title || '').trim();
+/** The offer shown on the item: "Draft your reply: …". */
+function briefSuggest(x) { return `Draft your ${briefVerb(x)}: ${briefWhat(x)}`.slice(0, 300); }
+/** What lib/day-run.js addBriefed takes for brief item `x`; `instruction` is the PM's changed ask, or empty for the offer. */
+function briefDraftSpec(x, instruction) {
+  const ask = String(instruction || '').trim() || `Draft the PM's ${briefVerb(x)} for this item: ${briefWhat(x)}`;
+  return { id: 't-' + x.id, item_id: x.id, title: x.title, source: x.source, link: x.link || null,
+    instruction: `${ask}${/[.!?]$/.test(ask) ? '' : '.'} Draft only. Send nothing: the PM approves it first.`,
+    context: { from: x.who || null, where: x.where || null, about: x.about || null, ask: x.ask || null, how: x.how || null, why_now: x.why_now || null } };
+}
+const BRIEF_STATE = { waiting: 'queued', working: 'working', sending: 'sending', failed: 'failed', review: 'ready', done: 'ready', sent: 'sent' };
+function briefAgent(x, run) {
+  const t = run && Array.isArray(run.tasks) ? run.tasks.find((y) => y && y.id === 't-' + x.id) || null : null;
+  const base = { suggest: briefSuggest(x), 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: BRIEF_STATE[t.status] || 'queued', instruction: t.instruction || null,
+    draft: t.draft ? { summary: t.draft.summary || null, body: t.draft.body || 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 };
+}
+
+function fromBrief(brief, todayIso, run = null) {
   if (!brief || brief.date !== todayIso) return [];
   const list = [...(Array.isArray(brief.priorities) ? brief.priorities : []), ...(Array.isArray(brief.items) ? brief.items : [])];
   const seen = new Set();
@@ -65,7 +91,8 @@ function fromBrief(brief, todayIso) {
     if (!x || !x.id || !x.title || x.owner !== 'pm' || x.worth_asking || seen.has(x.id)) continue;
     seen.add(x.id);
     out.push({ id: 'brief:' + x.id, title: String(x.title), source: 'brief', origin: 'brief', suggested: true, flagged: true,
-      due: null, priority: null, waiting_on: null, job: null, why: x.why_now || null, initiative: x.initiative_id || null });
+      due: null, priority: null, waiting_on: null, job: null, why: x.why_now || null, initiative: x.initiative_id || null,
+      place: x.source || null, agent: briefAgent(x, run && run.date === todayIso ? run : null) });
   }
   return out;
 }
@@ -77,7 +104,7 @@ function addable(virtuals, itemLines) {
 }
 
 function createdEvent(v) {
-  const { id, source, agent, ...fields } = v;   // the agent state is read on every list, never stored
+  const { id, source, agent, place, ...fields } = v;   // the agent state (and a brief item's place) is read on every list, never stored
   return { event: 'created', id, fields, source };
 }
 
@@ -90,4 +117,4 @@ function overlay(item, byId) {
   return out;
 }
 
-module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, AGENT };
+module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, briefAgent, briefSuggest, briefDraftSpec, AGENT };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.206.0",
+  "version": "0.208.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

@@ -385,15 +385,15 @@ export function handle(S, method, path, p, body) {
       const counts = { todo: issues.filter((i) => i.category === 'todo').length, doing: issues.filter((i) => i.category === 'doing').length, done: issues.filter((i) => i.category === 'done').length };
       const num = key === 'IDPF' ? 42 : 19;
       const extra = (k, state, name, cat, n) => { const is = Array.from({ length: n }, (_, i) => ({ key: key + '-' + (1100 + k * 20 + i), summary: (own[i % Math.max(1, own.length)] || { title: 'Sprint work' }).title + ': part ' + (i + 1), status: cat === 'done' ? 'Done' : 'To Do', category: cat, initiative: (own[i % Math.max(1, own.length)] || {}).id || null })); return { name, state, issues: is, counts: { todo: cat === 'todo' ? n : 0, doing: 0, done: cat === 'done' ? n : 0 } }; };
-      // The goal and summary the Jira status check writes (sprint-goal-summary): Jira's goal is too broad for the active sprint,
-      // missing for the next, and fine for the closed one, which was summarised once.
+      // The goal and summary the Jira status check writes (sprint-goal-summary). The goal is always written from the tickets;
+      // Jira's goal, when it has one, is a reference. The closed sprint was summarised once.
       const ini0 = own[0] ? own[0].id : null;
       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: 'broad', text: 'Get the first initiative ready for internal users and clear the blocked work.', jira: 'Q4 delivery' },
+      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 };
-      const fut = { ...extra(1, 'future', key + ' Sprint ' + (num + 1), 'todo', 3), goal: { from: 'none', 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: 'jira', text: 'Start the first initiative.', jira: 'Start the first initiative.' }, 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 }],
+      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] });
     }

package/workspace/public/pm/c3-ib-sprints.js

@@ -2,10 +2,10 @@
  * and team summary from mockup-c3-sprint-goal v3, initiative sprint-goal-summary).
  *   registerBoardTab('sprints', (host, ctx) => ...)
  * Reads GET /api/boards/sprints { source: jira|none, readAt, sprints: [{ name, state: active|future|closed, start, end, issues: [{ key, summary,
- * status, category: todo|doing|done, initiative }], counts, goal: { from: jira|none|broad|partial, text, jira, unchecked? } | null, summary,
+ * status, category: todo|doing|done, initiative }], counts, goal: { from: 'tickets', text, jira } | null, jiraGoal?, summary,
  * themes: [{ title, line, tickets, done, blocked, people, initiative }], writtenAt, closed: { done, total, carried, carriedTo, points } | null,
  * frozen }] }. READ-ONLY: the sprints mirror Jira, so there is no create, edit or move control.
- * Left: the active sprint's goal and summary (the goal from Jira, or written from the tickets and saying why; what the team is working on,
+ * Left: the active sprint's goal and summary (the goal, always written from the tickets, with Jira's goal as a reference; what the team is working on,
  * one row per theme), its items (header chip: Jira, read-only and the read time; c3-board-declutter: no banner), then the next sprint
  * with its goal and summary, and each closed sprint with its goal, summary, done and carried counts and the read-once note. Right: the
  * active sprint's card, its burndown from GET /api/stage-tools/burndown (when that route is not on this server yet, the card says so
@@ -18,25 +18,24 @@ import { recordCards } from './c3-ini-records.js';
 
 const CAT = { todo: 'To do', doing: 'In progress', done: 'Done' };
 const readTime = (s) => { const m = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/.exec(String(s || '')); return m ? day(m[1]) + ', ' + m[2] : ''; };
-const WHY = { none: 'Jira has no goal for this sprint.', broad: 'The goal in Jira is too broad to tell what this sprint delivers.', partial: 'The goal in Jira leaves out part of the sprint.' };
 const timeOf = (s) => { const m = /T(\d{2}:\d{2})/.exec(String(s || '')); return m ? m[1] : ''; };
 /* Quiet pages (c3-quiet.css) hide .ini-note, .ini-lhm .dim and a row's third chip. The goal's reason, the theme chips and the
  * read-once note are the content of this tab (mockup v3), so they use their own classes. */
-/* The goal: Jira's when it says what the sprint delivers; else written from the tickets, with why and Jira's own text underneath. */
-function goalBlock(g) {
+/* The goal is always written from the sprint's tickets: Jira's sprint goal is often empty, too broad or incomplete (the PM,
+ * 2026-10-14). Jira's own text shows underneath as a reference. */
+const jiraRef = (j) => (j ? el('div', { class: 'dim ini-sp-note', 'data-inb': 'sprint-goal-jira' }, 'In Jira: “' + j + '”') : null);
+function goalBlock(g, jiraGoal) {
   if (!g) return el('div', { class: 'lh', 'data-inb': 'sprint-goal', 'data-inb-goal': 'missing' }, el('span', { class: 'ki' }, icon('target')),
-    el('div', { class: 'ini-sp-goal' }, lbl('SPRINT GOAL'), el('div', { class: 'dim ini-sp-note' }, 'No goal yet. The Jira status check writes one from the tickets at its next check.')));
-  const derived = g.from !== 'jira';
-  return el('div', { class: 'lh', 'data-inb': 'sprint-goal', 'data-inb-goal': g.from }, el('span', { class: 'ki' }, icon('target')),
-    el('div', { class: 'ini-sp-goal' }, lbl(derived ? 'SPRINT GOAL · written from the tickets' : 'SPRINT GOAL · from Jira'), el('b', null, g.text),
-      derived ? el('div', { class: 'dim ini-sp-note', 'data-inb': 'sprint-goal-why' }, (WHY[g.from] || '') + (g.jira ? ' In Jira: “' + g.jira + '”' : '')) : null));
+    el('div', { class: 'ini-sp-goal' }, lbl('SPRINT GOAL'), el('div', { class: 'dim ini-sp-note' }, 'No goal yet. The Jira status check writes one from the tickets at its next check.'), jiraRef(jiraGoal)));
+  return el('div', { class: 'lh', 'data-inb': 'sprint-goal', 'data-inb-goal': 'tickets' }, el('span', { class: 'ki' }, icon('target')),
+    el('div', { class: 'ini-sp-goal' }, lbl('SPRINT GOAL · from the tickets'), el('b', null, g.text), jiraRef(g.jira)));
 }
 const themeRow = (t, ctx) => nrow({ ic: t.blocked ? 'alert' : t.tickets && t.done === t.tickets ? 'check' : t.initiative ? 'bolt' : 'task', hot: !t.blocked && t.done < t.tickets && !!t.initiative,
   title: t.title, attrs: { 'data-inb-theme': t.initiative || 'none' },
   after: el('div', null, t.line ? el('div', { class: 'dim ini-sp-note' }, t.line) : null, el('div', { class: 'chips ini-sp-chips' }, ...[chip(plural(t.tickets, 'ticket')), t.done ? st('ok', 'check', t.done + ' done') : null, t.blocked ? st('warn', 'alert', t.blocked + ' blocked') : null,
     t.people ? chip(icon('user', 'sm'), t.people) : null,
     t.initiative ? lk({ onclick: () => ctx.openInitiative(t.initiative), 'data-inb-theme-ini': t.initiative }, icon('init', 'sm'), t.initiative) : el('span', { class: 'chip2 dim' }, 'No initiative')].filter(Boolean))) });
-const summaryBody = (sp, ctx) => [goalBlock(sp.goal), sp.summary ? el('p', { class: 'ini-sp-sum' }, sp.summary) : null,
+const summaryBody = (sp, ctx) => [goalBlock(sp.goal, sp.jiraGoal), sp.summary ? el('p', { class: 'ini-sp-sum' }, sp.summary) : null,
   sp.themes && sp.themes.length ? [lbl('WHAT THE TEAM IS WORKING ON'), list(sp.themes.map((t) => themeRow(t, ctx)), { 'data-inb': 'sprint-themes' })] : null];
 const countsOf = (sp) => { const c = sp.counts || {}; const f = (k) => (c[k] != null ? Number(c[k]) : (sp.issues || []).filter((i) => i.category === k).length); return { todo: f('todo'), doing: f('doing'), done: f('done') }; };
 
@@ -78,7 +77,7 @@ registerBoardTab('sprints', async (host, ctx) => {
       n ? list(active.issues.map(issueRow)) : empty('No items in this sprint yet.', { 'data-inb': 'sprint-no-issues' }))
       : empty(sprints.length ? 'No sprint is active.' : 'Jira has no sprints for this board.', { 'data-inb': sprints.length ? 'sprints-no-active' : 'sprints-empty' }),
     ...others.filter((s) => s.state !== 'closed').map((s) => sect({ ic: 'cal', title: s.name, count: (s.issues || []).length, right: tag(s.state || 'sprint'), attrs: { 'data-inb-sprint': s.name, 'data-inb-state': s.state } },
-      goalBlock(s.goal), s.summary ? el('p', { class: 'ini-sp-sum' }, s.summary) : null, itemsRow(s))),
+      goalBlock(s.goal, s.jiraGoal), s.summary ? el('p', { class: 'ini-sp-sum' }, s.summary) : null, itemsRow(s))),
     ...others.filter((s) => s.state === 'closed').map(closedSect),
   ];
   const right = [];
@@ -91,7 +90,7 @@ registerBoardTab('sprints', async (host, ctx) => {
     right.push(...await recordCards(pseudo, ['burndown']));
   }
   if (sprints.length) right.push(card({ ic: 'redo', title: 'How sprints are read', attrs: { 'data-inb': 'sprints-how' } }, kv([
-    ['Goal', 'From Jira when it says what the sprint delivers, otherwise written from the tickets'], ['Active sprint', 'Read and summarised at each Jira status check'],
+    ['Goal', 'Written from the sprint\'s tickets. Jira\'s goal is shown for reference'], ['Active sprint', 'Read and summarised at each Jira status check'],
     ['Next sprint', 'Read at each check, until it starts'], ['Closed sprints', 'Read and summarised once, then kept'], ['Jira', 'Read-only. PMOS changes nothing there']])));
   if (dead) return () => {};
   put(host, cols(left, right));

package/workspace/public/pm/pm-work-view.js

@@ -696,7 +696,7 @@ function startRun(inst, item, intent) {
 }
 
 
-/* ── the agent on a Jira or WBS item (initiative c3-work-agent, planning/prd/c3-work-agent-prd.md) ───────────────────
+/* ── the agent on a Jira, WBS or morning-brief item (initiative c3-work-agent, planning/prd/c3-work-agent-prd.md) ────────
  * item.agent = { state: suggest|queued|working|ready|sending|sent|failed, suggest, instruction, draft: { summary, body }, sent, error, … }
  * from lib/work-assigned.js. The suggestion is an option the PM picks; the day task does the work; nothing goes outward
  * until the PM holds Post (POST /api/my-work/decide approve). Stop ends a task that has not delivered (POST /api/my-work/stop). */
@@ -704,7 +704,9 @@ const AGENT_BUSY = ['queued', 'working', 'sending'];
 const AGENT_POLL_MS = 15000;
 const hhmm = (iso) => { const d = new Date(iso); return Number.isNaN(d.getTime()) ? '' : String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0'); };
 const minsAgo = (iso) => { const t = Date.parse(iso); if (!Number.isFinite(t)) return ''; const m = Math.max(0, Math.round((Date.now() - t) / 60000)); return m < 1 ? 'just now' : m < 60 ? m + ' min ago' : Math.floor(m / 60) + ' h ago'; };
-const whereOf = (item) => (item.origin === 'jira' ? 'Jira' : 'its source');
+// where a post goes: Jira for a ticket; for an item the morning brief suggests, the place it came from (amendment 10)
+const PLACE = { mail: 'email', slack: 'Slack', jira: 'Jira', confluence: 'Confluence', github: 'GitHub', drive: 'Drive', figma: 'Figma', calendar: 'the calendar', wispr: 'Wispr' };
+const whereOf = (item) => (item.origin === 'jira' ? 'Jira' : PLACE[item.place] || 'its source');
 const AG = {
   can: (t) => 'Agent can: ' + t, queued: 'Agent: queued', working: (ago) => 'Agent: working' + (ago ? ' · started ' + ago : ''), ready: 'Agent: draft ready',
   sending: 'Agent: posting', sent: (w, at) => 'Posted to ' + w + (at ? ' ' + at : ''), failed: (asks) => (asks ? 'Agent: needs you' : 'Agent stopped'),
@@ -747,7 +749,7 @@ async function agentPress(inst, path, body, text) {
 }
 
 function agentCase(inst, item, L) {
-  const a = item.agent; const w = whereOf(item); const k = item.key || item.title;
+  const a = item.agent; const w = whereOf(item); const k = item.key || (item.origin === 'brief' ? w : item.title);
   const o = (id, l, f, run, extra) => ({ id, l, rec: 0, fx: f, run, ...(extra || {}) });
   const own = L.opts.slice(0, 2).map((x) => ({ ...x, rec: 0 }));
   const ask = () => inst.asks.get(item.id) || a.instruction || a.suggest || '';

package/workspace/server.js

@@ -8474,11 +8474,8 @@ async function handleRequest(req, res) {
     const x = brief ? [...(brief.priorities || []), ...(brief.worth_asking || [])].find((y) => y.id === String(body.item || '')) : null;
     if (!x) return json(res, { ok: false, error: 'no item with that id in today\'s brief' }, 404);
     if (x.owner !== 'pm') return json(res, { ok: false, error: 'the agent already does this job: approve or revise its draft' }, 409);
-    const verb = { reply: 'reply', review: 'review notes', decide: 'answer', 'sign-off': 'sign-off comment', read: 'summary', do: 'draft' }[x.verb] || (x.reply_needed ? 'reply' : 'draft');
-    const spec = { id: 't-' + x.id, item_id: x.id, title: x.title, source: x.source, link: x.link || null,
-      instruction: `Draft the PM's ${verb} for this item: ${x.todo || x.how || x.ask || x.title}. Draft only. Send nothing: the PM approves it first.`,
-      context: { from: x.who || null, where: x.where || null, about: x.about || null, ask: x.ask || null, how: x.how || null, why_now: x.why_now || null } };
-    const r = myWorkBrief(spec, body.ws);
+    // the same ask as Work's "Let the agent draft this" on this item (lib/work-assigned.js, c3-work-agent amendment 10)
+    const r = myWorkBrief(require('./lib/work-assigned.js').briefDraftSpec(x, ''), body.ws);
     if (!r.ok) return json(res, { ok: false, error: r.error }, r.status || 400);
     return json(res, { ok: true, task: r.task });
   }

package/workspace/skills/jira-sync.skill

@@ -37,7 +37,7 @@ Procedure:
 4. Run `pmos jira sync <initiative> --from <the file> --query "<the JQL>"`. Then delete the file.
 4a. Read the whole sprints, after every initiative is synced. Run `pmos jira query --sprints`. It prints one Jira search for every issue in the sprints the tickets above are in, whoever the issue is assigned to. Do this even when the task names one initiative. If it prints "no Jira reading has a sprint yet" or "every sprint is closed and summarised once", skip to step 4b. Otherwise run that search with the same fields as step 2, fetch every page, save the result in the scratch folder in the same shape as step 3 (for example `<scratch>/jira-sprints.json`), run `pmos jira sync --sprints --from <the file> --query "<the JQL>"`, and delete the file. Do not record people from this search (step 5 is for the initiatives' own issues).
 4b. Write each sprint's goal and summary, after step 4a. Run `pmos jira summary`. Each line is a sprint that needs one: its name, its state, its number of issues and Jira's goal. A closed sprint that is already summarised is listed as kept: do not write it again. If it prints "no sprint needs a summary", skip this step. For each listed sprint, read its issues in the sprint search result of step 4a and write:
-   - `goal`: `{"from": "jira", "text": "<Jira's goal>"}` when Jira's goal says what the sprint delivers. Otherwise write the goal from the sprint's tickets in one sentence (at most 240 characters), and say why: `"from": "none"` when Jira has no goal, `"broad"` when Jira's goal is too broad to tell what the sprint delivers (for example "Q4 delivery"), `"partial"` when it leaves out a large part of the sprint's tickets. With `broad` or `partial`, put Jira's own goal in `"jira"`.
+   - `goal`: `{"text": "<the goal>", "jira": "<Jira's goal, or null>"}`. Always write the goal yourself from the sprint's tickets, in one sentence of at most 240 characters: what the sprint delivers when its tickets are done, naming the two or three largest outcomes. Do not copy Jira's sprint goal: it is often empty, too broad or incomplete. Put Jira's own goal in `"jira"` only as a reference, exactly as Jira writes it.
    - `summary`: two to four plain sentences on what the team is working on: what is done, what is moving, what is blocked. For a closed sprint, say if the goal was met and what moved to the next sprint.
    - `themes`: one entry per group of related tickets, at most 8, largest first: `{"title", "line", "tickets", "done", "blocked", "people", "initiative"}`. Group by initiative when the tickets belong to one (the initiative id from step 1); put tickets with no initiative in one theme such as "Fixes and upkeep" with `"initiative": null`. `line` is one sentence; `people` is the assignees' first names, comma-separated.
    - For a closed sprint, also `closed`: `{"done", "total", "carried", "carriedTo", "points"}` (`points` as "31 of 38" when the tickets have points).