create-pmos 0.183.0 → 0.185.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.183.0",
+  "version": "0.185.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@ab3a131
+kernel-source: pmos@a5090c5
 assembled: 2026-10-13
 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-13T03:53:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T05:02:49Z"}
 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-13T03:53:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T05:02:49Z"}
 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-13T03:53:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T05:02:49Z"}
 status: stable
 ---
 

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-12
+timestamp: 2026-10-13
 ---
 
 # Jira: tickets drafted from the PRD, and their status
@@ -110,6 +110,15 @@ pmos jira query [<initiative>]
 pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]
 ```
 
+## The board's Sprints tab shows the whole sprint
+
+After it reads the initiatives, the check reads every issue in the sprints their tickets are in. It reads every issue, not only the issues of an initiative and not only the issues assigned to you. The board's **Sprints** tab and the sprint burndown show all of them. An issue that is in no initiative of the board shows **No initiative**. The check writes `<state>/tracker/jira/_sprints.md` with:
+
+```
+pmos jira query --sprints
+pmos jira sync --sprints --from <file|-> [--query "<jql>"]
+```
+
 ## 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.
@@ -152,6 +161,8 @@ The morning brief, the day check and requirement gathering use it to tie a Jira
 - `pmos jira record <initiative> [ID=KEY …] [--epic KEY] [--updated ID,ID]`
 - `pmos jira query [<initiative>]`
 - `pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]`
+- `pmos jira query --sprints`
+- `pmos jira sync --sprints --from <file|-> [--query "<jql>"] [--dry-run]`
 - `pmos jira which <KEY>`
 
 Every command takes `--json` and `--root <dir>`.

package/workspace/guide/my-work.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "My work: every Jira ticket and WBS item assigned to you, ranked, briefed to an agent, approved in Agenda"
-timestamp: 2026-10-12
+timestamp: 2026-10-13
 ---
 
 # My work
@@ -77,7 +77,7 @@ The Work page holds all the work that is yours:
 - every open Jira ticket and WBS item assigned to you, from the same read as My work;
 - the items today's morning brief suggests for you. They are flagged, so they are in Today.
 
-A row of assigned work shows its Jira key (a link to the ticket) or **WBS** and the repository, and the agent's suggestion when the read has one. A suggested row shows **Suggested** and the reason. An agent at work on a ticket puts it in Waiting; a ticket in progress, or with a draft ready for you, is flagged. A ticket that is done in Jira leaves the page.
+A row of assigned work shows its Jira key (a link to the ticket) or **WBS** and the repository. When the read has a suggestion, the first chip on the row shows **Agent can:** and the suggestion. This chip is only a suggestion. No agent works on the item until you start it. A suggested row shows **Suggested** and the reason. An agent at work on a ticket puts it in Waiting; a ticket in progress, or with a draft ready for you, is flagged. A ticket that is done in Jira leaves the page.
 
 Every action works on these rows. The first action writes the item to your own list, with its source. **Drop** takes it off your Work page only; Jira and the Board keep it, and it does not come back.
 
@@ -96,6 +96,34 @@ The six views follow the OmniFocus style. The **Work** tab badge counts Inbox pl
 
 An item goes to the first view that fits these rules, in this order. Parked is Someday. Waiting on someone is Waiting. A defer date after today is Upcoming. Flagged is Today. Due today or earlier is Today. A later due date is Upcoming. An undated item whose defer date has arrived is Today. No date is Inbox.
 
+### Let the agent draft an item
+
+Open an assigned item that shows **Agent can:**. The case file shows **What the agent will do**.
+
+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.
+
+The row chip then shows the agent's state:
+
+| Chip | What it means |
+|---|---|
+| **Agent: queued** | The job waits for a free place in the day run. |
+| **Agent: working** | An agent session drafts the item. Select **stop** in the case file to end it. |
+| **Agent: draft ready** | The draft waits for you. |
+| **Agent: posting** | You approved the draft. A session posts exactly that text. |
+| **Posted to** the item | The draft went out. Select **Open what was posted** to see it. |
+| **Agent stopped** | The job failed or you stopped it. The case file gives the reason. Select **Try again** to run it again. |
+
+The page reads the state again every 15 seconds while an agent is queued, working or posting.
+
+When the draft is ready, the case file quotes it. Select **Open the draft** to read all of it. Then choose one option:
+
+- **Post it to** the ticket posts the exact text. Nothing goes out until you hold to confirm.
+- **Send it back with a note** returns the draft to the agent. Type what to change and press Enter.
+- **Keep it as a draft** leaves the draft as it is.
+
+The agent only drafts. It never posts to Jira until you approve the draft.
+
 ### Defer and flag
 
 A defer date means "not before this day". The item stays in Upcoming and shows **Not before** with the date. On that day it moves to Today by itself. A due date is when the work must be done. A defer date is when you start.

package/workspace/lib/day-run.js

@@ -17,7 +17,7 @@
  *   addBriefed(run, spec)                      one task the PM briefed in My work (initiative my-work, PRD R5)
  *   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 · sessionEnded · sessionStalled
+ *   started · deliver · decide · sent · fail · stop · sessionEnded · sessionStalled
  *   stage(run, brief)                          reading | working | review | done
  *   checkDue(run, {settings, now, events}) · checkStarted · checkDone
  *
@@ -272,6 +272,17 @@ function fail(run, taskId, reason, now) {
   });
 }
 
+/** The PM stopped a task that has not delivered (initiative c3-work-agent): waiting or working → failed with `reason`, so it
+ *  never starts and frees its place. The caller ends its session. A retry runs it again in a NEW session. */
+function stop(run, taskId, reason, now) {
+  return withTask(run, taskId, (t) => {
+    if (t.status !== 'waiting' && t.status !== 'working') return `task ${taskId} is ${t.status} — only a waiting or working task can be stopped`;
+    const why = text(reason) || 'Stopped by the PM.';
+    t.status = 'failed'; t.error = why.slice(0, 240); t.failed_at = iso(now); keepSession(t); t.prev_session = null;
+    return null;
+  });
+}
+
 /** 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' };
@@ -388,5 +399,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, sessionEnded, sessionStalled, stage, intervalMin,
+  newRun, readRun, findTask, modeOf, addTasks, addBriefed, addSend, toStart, started, deliver, decide, sent, fail, stop, sessionEnded, sessionStalled, stage, intervalMin,
   checkDue, checkStarted, checkDone };

package/workspace/lib/engine/boards.js

@@ -15,7 +15,7 @@
  *   filterRows(rows, query)                     → { total, offset, limit, rows, facets }
  *   health(rows)                                → 'ok' | 'warn' | 'bad'
  *   counts(rows, workflow)                      → { total, open, byCat, byStage, byStatus, risk, late }
- *   sprintsOf(snapshots, onBoard)               → { source, readAt, sprints }
+ *   sprintsOf(snapshots, onBoard, whole?)       → { source, readAt, sprints }
  *   INI_TEMPLATES · isBuildStage · templateBuilds · boardSettings(board)   the per-initiative workflows (console3-initiatives-parity)
  *   workflowOf(board, id, folded)               → the stages an initiative runs: its own (ini-workflow), else the board's
  *   applyIniWorkflow(board, wfNow, stage, template, stages, moveTo) → { ok, template, workflow, moved } | { ok:false, status, error }
@@ -523,8 +523,11 @@ function counts(rows, workflow) {
  * The Jira sprints of a board from the cached status snapshots (lib/jira-status.js readSnapshot), read-only.
  * snapshots: [{ initiative, fetchedAt, tickets: Map|[] of readings }]; onBoard(initiativeId) → boolean.
  * A ticket with no sprint (the backlog) is in no sprint. source is 'none' when no snapshot of the board was read.
+ * whole: the whole-sprint read (lib/jira-status.js readSprints), { fetchedAt, tickets }. A sprint the board's tickets are in then
+ * lists EVERY issue Jira holds in it, whoever it is assigned to; an issue no initiative of the board holds has initiative null
+ * (jira-sprint-scope). Without it, a sprint lists only the board's own tickets.
  */
-function sprintsOf(snapshots, onBoard = () => true) {
+function sprintsOf(snapshots, onBoard = () => true, whole = null) {
   const byName = new Map();
   let readAt = null;
   let any = false;
@@ -545,6 +548,28 @@ function sprintsOf(snapshots, onBoard = () => true) {
       sp.counts[category]++;
     }
   }
+  const wt = whole && whole.tickets ? (whole.tickets instanceof Map ? [...whole.tickets.values()] : Array.isArray(whole.tickets) ? whole.tickets : []) : [];
+  let widened = false;
+  for (const sp of byName.values()) {
+    const all = wt.filter((t) => t && t.key && t.sprint && String(t.sprint.name) === sp.name);
+    if (!all.length) continue;
+    widened = true;
+    const own = new Map(sp.issues.map((i) => [i.key, i]));
+    const keys = new Set(all.map((t) => t.key));
+    if (!sp.start && typeof all[0].sprint.start === 'string' && all[0].sprint.start) sp.start = all[0].sprint.start;
+    if (!sp.end && typeof all[0].sprint.end === 'string' && all[0].sprint.end) sp.end = all[0].sprint.end;
+    sp.issues = [
+      ...all.map((t) => {
+        const category = ['todo', 'doing', 'done'].includes(t.category) ? t.category : 'todo';
+        const o = own.get(t.key);
+        return { key: t.key, summary: t.summary || '', status: t.status || '', category, initiative: o ? o.initiative : null, flagged: !!t.flagged, reason: t.flagged && t.reason ? String(t.reason) : null };
+      }),
+      ...sp.issues.filter((i) => !keys.has(i.key)),   // a board ticket the sprint read has not seen yet keeps its own reading
+    ];
+    sp.counts = { todo: 0, doing: 0, done: 0 };
+    for (const i of sp.issues) sp.counts[i.category]++;
+  }
+  if (widened && whole.fetchedAt && (!readAt || whole.fetchedAt < readAt)) readAt = whole.fetchedAt;   // the oldest read is the honest age
   const order = { active: 0, future: 1, closed: 2 };
   const sprints = [...byName.values()].sort((a, b) => ((order[a.state] ?? 3) - (order[b.state] ?? 3)) || a.name.localeCompare(b.name));
   for (const sp of sprints) sp.issues.sort((a, b) => a.key.localeCompare(b.key, undefined, { numeric: true }));

package/workspace/lib/jira-cli.js

@@ -10,6 +10,8 @@
  *   pmos jira record <initiative> [ID=KEY …] [--epic KEY] [--updated ID,ID]   the keys the agent created
  *   pmos jira query [<initiative>]                              the Jira search for the tickets an initiative pushed
  *   pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]  a saved search → the status snapshot
+ *   pmos jira query --sprints                                   the Jira search for every issue in the sprints the tickets are in
+ *   pmos jira sync --sprints --from <file|-> [--query "<jql>"]  a saved whole-sprint search → the Sprints tab (jira-sprint-scope)
  *   pmos jira which <KEY>                                       the initiative a Jira key belongs to
  *   every command: [--json] [--root <dir>]
  *
@@ -36,11 +38,13 @@ const USAGE = [
   '  pmos jira record <initiative> [ID=KEY …] [--epic KEY] [--updated ID,ID]   the keys created in Jira',
   '  pmos jira query [<initiative>]                     the Jira search for the pushed tickets',
   '  pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]   save the status read from Jira',
+  '  pmos jira query --sprints                          the Jira search for every issue in those tickets\' sprints',
+  '  pmos jira sync --sprints --from <file|-> [--query "<jql>"]   save every issue of the sprints, for the Sprints tab',
   '  pmos jira which <KEY>                              the initiative a Jira key belongs to',
   '  every command: [--json] [--root <dir>]',
   'This command never calls Jira. Your agent reads and writes Jira with your own connection.',
 ];
-const BOOL = new Set(['json', 'dry-run', 'help']);
+const BOOL = new Set(['json', 'dry-run', 'help', 'sprints']);
 const VALUE = new Set(['from', 'query', 'root', 'epic', 'updated']);
 const FLAG_TEXT = { 'prd-changed': 'PRD changed', removed: 'Removed from PRD', blocked: 'Blocked', incomplete: 'Missing text', pushing: 'Selected, waiting for the push', edited: 'Edited, not in Jira yet' };
 
@@ -92,6 +96,23 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
   const known = () => planItems.INIT_RE.test(initiative || '') && !!jiraTickets.recordFm(root, initiative);
 
   try {
+    if (flags.sprints && verb !== 'query' && verb !== 'sync') return fail('--sprints goes with query or sync', 2);
+    if (verb === 'query' && flags.sprints) {
+      const q = jiraStatus.sprintQuery(root);
+      return out(q, [q.linked ? q.query : 'no Jira reading has a sprint yet — run the initiatives\' searches first']);
+    }
+    if (verb === 'sync' && flags.sprints) {
+      if (!flags.from) return need('--sprints --from <file|->');
+      let raw;
+      try { raw = JSON.parse(readInput(flags.from, cwd, stdin)); }
+      catch (e) { return fail(`could not read ${flags.from} as JSON — ${String((e && e.message) || e).slice(0, 160)}`); }
+      const r = jiraStatus.syncSprints(root, raw, { query: flags.query || undefined, dryRun: !!flags['dry-run'], now });
+      if (!r.ok) return fail(r.error);
+      const lines = [`sprints · read ${r.read} ${r.read === 1 ? 'issue' : 'issues'}${r.ignored ? ` · ${r.ignored} in no sprint, ignored` : ''}${r.skipped ? ` · ${r.skipped} skipped (no key or summary)` : ''}${r.dryRun ? ' · dry run, nothing written' : ''}`];
+      for (const [name, n] of Object.entries(r.sprints)) lines.push(`  ${name} · ${n} ${n === 1 ? 'issue' : 'issues'}`);
+      if (!r.dryRun) lines.push(`snapshot ${r.snapshot}`);
+      return out(r, lines);
+    }
     if (verb === 'query') {
       if (initiative) {
         const q = jiraStatus.queryFor(root, initiative);

package/workspace/lib/jira-status.js

@@ -13,6 +13,10 @@
  *   sync(root, initiative, raw, opts)   → the snapshot, written to <state>/tracker/jira/<initiative>.md
  *   readSnapshot(root, initiative)      → { fetchedAt, query, tickets: Map<key, reading> } | null
  *   which(root, key)                    → the initiative and ticket a key belongs to
+ *   sprintQuery(root)                   → { linked, sprints, query } the JQL for EVERY issue in the sprints the initiatives' tickets
+ *                                         are in, whoever holds them (jira-sprint-scope); linked false when no reading has a sprint
+ *   syncSprints(root, raw, opts)        → the whole-sprint snapshot, written to <state>/tracker/jira/_sprints.md
+ *   readSprints(root)                   → { fetchedAt, query, tickets: Map<key, reading> } | null
  *
  * A READING is { key, summary, status, category: todo|doing|done, sprint: { name, state: active|future|closed, id?, start?, end?,
  * completed? } | null, subtasks: { done, total }, fixVersion: [names], points: number | null, resolved: YYYY-MM-DD | null,
@@ -206,12 +210,13 @@ function snapshotRel(root, initiative) { return jiraTickets.relOf(root, snapshot
 const cell = (s) => oneLine(s).replace(/\\/g, '\\\\').replace(/\|/g, '\\|') || '—';
 const SPRINT_WORD = { active: 'Active sprint', future: 'Next sprint', closed: 'Closed sprint' };
 function sprintLabel(s) { return s ? `${SPRINT_WORD[s.state] || 'Sprint'}: ${s.name}` : 'Backlog'; }
-function renderSnapshot({ initiative, fetchedAt, query, readings, ids }) {
+function renderSnapshot({ initiative, fetchedAt, query, readings, ids, title }) {
+  const name = title || initiative;
   const rows = readings.map((r) => `| ${cell(ids.get(r.key) || '')} | ${cell(r.key)} | ${cell(r.summary)} | ${cell(r.status)} | ${cell(r.category === 'done' ? 'Done' : sprintLabel(r.sprint))} | ${r.subtasks.total ? `${r.subtasks.done} of ${r.subtasks.total}` : '—'} | ${cell(r.flagged ? r.reason : '')} |${r.stale ? ' not in the last read |' : ''}`);
   return [
-    '---', 'type: Reference', `title: "Jira status: ${initiative}"`, `timestamp: ${fetchedAt}`, `initiative: ${initiative}`, '---', '',
-    `# Jira status: ${initiative}`, '',
-    `Read from Jira at ${fetchedAt} by the Jira status check, read-only. The Jira tickets tab of the initiative shows it. Written by \`pmos jira sync\`; do not edit by hand.`, '',
+    '---', 'type: Reference', `title: "Jira status: ${name}"`, `timestamp: ${fetchedAt}`, ...(title ? [] : [`initiative: ${initiative}`]), '---', '',
+    `# Jira status: ${name}`, '',
+    `Read from Jira at ${fetchedAt} by the Jira status check, read-only. ${title ? 'The Sprints tab and the sprint burndown of a board show it.' : 'The Jira tickets tab of the initiative shows it.'} Written by \`pmos jira sync\`; do not edit by hand.`, '',
     query ? `Search: \`${query.replace(/`/g, "'")}\`` : 'Search: not recorded', '',
     '| Ticket | Key | Summary | Status | Sprint | Subtasks | Blocked |', '|---|---|---|---|---|---|---|', ...rows, '',
     '```json', JSON.stringify({ fetched_at: fetchedAt, query: query || null, tickets: readings }, null, 0), '```', '',
@@ -275,6 +280,48 @@ function sync(root, initiative, raw, { query, dryRun = false, now } = {}) {
   return { ...result, fetchedAt };
 }
 
+// ── the whole sprint (jira-sprint-scope) ─────────────────────────────────────────────────────────────
+// An initiative's read holds only its own tickets, so a sprint drawn from those reads lists only the tickets PMOS knows,
+// not the sprint. This second read asks Jira for every issue in the sprints those tickets are in, whoever holds them.
+const SPRINTS_FILE = '_sprints';
+const jqlName = (n) => `"${String(n).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+function sprintQuery(root) {
+  const seen = new Map();
+  for (const q of linkedInitiatives(root).filter((x) => x.linked)) {
+    const snap = readSnapshot(root, q.initiative);
+    if (!snap) continue;
+    for (const t of snap.tickets.values()) {
+      const sp = t && t.sprint;
+      if (!sp || !sp.name) continue;
+      const k = sp.id || sp.name;
+      if (!seen.has(k)) seen.set(k, { name: sp.name, state: sp.state || null, ...(sp.id ? { id: sp.id } : {}) });
+    }
+  }
+  const sprints = [...seen.values()].sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
+  if (!sprints.length) return { ok: true, linked: false, sprints, query: null };
+  return { ok: true, linked: true, sprints, query: `sprint in (${sprints.map((s) => s.id || jqlName(s.name)).join(', ')}) ORDER BY key` };
+}
+/** Save a whole-sprint read. The read replaces the last one whole: an issue moved out of a sprint is gone from it. */
+function syncSprints(root, raw, { query, dryRun = false, now } = {}) {
+  const n = normalize(raw);
+  if (n.error) return { ok: false, error: n.error };
+  const kept = n.issues.filter((i) => i.sprint && i.sprint.name);
+  const fetchedAt = nowIso(now);
+  const prev = readSprints(root);
+  const bySprint = {};
+  for (const i of kept) bySprint[i.sprint.name] = (bySprint[i.sprint.name] || 0) + 1;
+  const result = { ok: true, read: kept.length, ignored: n.issues.length - kept.length, skipped: n.skipped, sprints: bySprint,
+    was: prev ? prev.tickets.size : null, snapshot: snapshotRel(root, SPRINTS_FILE), dryRun: !!dryRun };
+  if (dryRun) return result;
+  const file = snapshotPath(root, SPRINTS_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, renderSnapshot({ initiative: SPRINTS_FILE, title: 'every issue in the sprints', fetchedAt, query: query || (prev && prev.query) || null, readings: kept, ids: new Map() }));
+  fs.renameSync(tmp, file);
+  return { ...result, fetchedAt };
+}
+function readSprints(root) { return readSnapshot(root, SPRINTS_FILE); }
+
 // ── J13 · which initiative ─────────────────────────────────────────────────────────────────────────
 function which(root, key) {
   const k = String(key || '').trim().toUpperCase();
@@ -288,4 +335,4 @@ function which(root, key) {
   return { ok: true, key: k, initiatives: hits };
 }
 
-module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel };
+module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel, sprintQuery, syncSprints, readSprints, SPRINTS_FILE };

package/workspace/lib/my-work.js

@@ -194,7 +194,8 @@ 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 } : 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,
+    sent: t.sent || null, started_at: t.started_at || null, revisions: Array.isArray(t.revisions) ? t.revisions.length : 0 } : null;
   const base = { task, instruction: last.instruction, decided_at: last.at };
   if (!t) return { state: 'agent', sub: 'waiting', ...base };
   if (t.status === 'review') return { state: 'ready', sub: 'review', ...base };

package/workspace/lib/routes-boards.js

@@ -489,7 +489,9 @@ const READS = {
         if (s) snaps.push({ initiative: q.initiative, fetchedAt: s.fetchedAt, tickets: s.tickets });
       }
     } catch { /* no snapshot yet */ }
-    ctx.json(res, { ok: true, ws: r.w.id, board: r.board.id, ...B.sprintsOf(snaps, (id) => ids.has(id)) });
+    let whole = null;
+    try { whole = jiraStatus.readSprints(r.w.root); } catch { whole = null; }
+    ctx.json(res, { ok: true, ws: r.w.id, board: r.board.id, ...B.sprintsOf(snaps, (id) => ids.has(id), whole) });
   },
 };
 
@@ -866,7 +868,9 @@ function meetingBoards(ctx) {
           if (s) snaps.push({ initiative: q.initiative, fetchedAt: s.fetchedAt, tickets: s.tickets });
         }
       } catch { /* no snapshot yet */ }
-      sprints = B.sprintsOf(snaps, (id) => ids.has(id));
+      let whole = null;
+      try { whole = jiraStatus.readSprints(w.root); } catch { whole = null; }
+      sprints = B.sprintsOf(snaps, (id) => ids.has(id), whole);
     }
     return { ...head, health: B.health(rows), counts: { total: c.total, open: c.open, risk: c.risk, late: c.late },
       rows: rows.filter((r) => r.status === 'late' || r.status === 'at risk').map((r) => ({ id: r.id, title: r.title, status: r.status, end: r.end || null, owner: r.owner || null })),

package/workspace/lib/routes-calendar-views.js

@@ -122,13 +122,13 @@ function readers(root, runtimeDir) {
       try { out.own = ownRows().map((o) => ({ id: o.id, title: o.title, due: o.due, done: !!o.done, priority: o.priority || null })); } catch { /* likewise */ }
       return out;
     },
-    /* each initiative's Jira epic progress, from the snapshots in the tracker folder (one file per initiative; the -tickets.md drafts are not snapshots) */
+    /* each initiative's Jira epic progress, from the snapshots in the tracker folder (one file per initiative; the -tickets.md drafts and the _sprints.md whole-sprint read are not) */
     readJira() {
       const fs = require('fs');
       const status = require('./jira-status.js');
       const out = new Map();
       let names = [];
-      try { names = fs.readdirSync(require('./jira-tickets.js').jiraDir(root)).filter((n) => n.endsWith('.md') && !n.endsWith('-tickets.md')); } catch { return out; }
+      try { names = fs.readdirSync(require('./jira-tickets.js').jiraDir(root)).filter((n) => n.endsWith('.md') && !n.endsWith('-tickets.md') && !n.startsWith('_')); } catch { return out; }
       for (const n of names) {
         const id = n.slice(0, -3);
         try { const p = require('./briefing-real.js').jiraProgress(status.readSnapshot(root, id)); if (p) out.set(id, p); } catch { /* one unreadable snapshot is left out */ }

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

@@ -7,6 +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? }
+ *                                        → { 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
+ *   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.
  * Both stay in the per-user runtime state and never land in a repository: they hold paraphrases of Jira comments. The
@@ -23,6 +27,7 @@ const guard = require('./pm-guard.js');
 const myWork = require('./my-work.js');
 const boardFold = require('./board-fold.js');
 const offloop = require('./offloop.js');
+const dayRun = require('./day-run.js');
 const { localDate } = require('./brief.js');
 
 const dirOf = (ctx) => path.join(ctx.runtimeDir, 'my-work');
@@ -92,7 +97,7 @@ async function handle(req, res, url, ctx) {
     ctx.json(res, await listForAsync(ctx, now));
     return true;
   }
-  if (!['/api/my-work/read', '/api/my-work/act', '/api/my-work/refresh'].includes(p)) return false;
+  if (!['/api/my-work/read', '/api/my-work/act', '/api/my-work/refresh', '/api/my-work/decide', '/api/my-work/stop'].includes(p)) return false;
   if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
   const got = await ctx.readJson(req);
   if (!got.ok) { ctx.json(res, { ok: false, error: 'invalid JSON body' }, 400); return true; }
@@ -116,6 +121,8 @@ async function handle(req, res, url, ctx) {
     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
   const c = myWork.checkAct(body, now);
   if (!c.ok) { ctx.json(res, { ok: false, error: c.error }, 400); return true; }
@@ -137,4 +144,56 @@ async function handle(req, res, url, ctx) {
   return true;
 }
 
+/* ── the agent's task of an item (initiative c3-work-agent) ─────────────────────────────────────────────────────── */
+
+const DAY_MS = 86400000;
+const nextDay = (d) => new Date(Date.parse(d + 'T00:00:00Z') + DAY_MS).toISOString().slice(0, 10);
+
+/** 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;
+  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 };
+  }
+  return null;
+}
+
+/** decide (approve | revise | retry) or stop, on the task of the item's last brief. */
+function taskPress(ctx, res, verb, body, now) {
+  const item = String((body && body.item) || '');
+  if (!myWork.ID_RE.test(item)) { ctx.json(res, { ok: false, error: 'item must be an item id like jira:ATL-491' }, 400); return; }
+  const list = listFor(ctx, now);
+  const it = list.items.find((x) => x.id === item);
+  if (!it) { ctx.json(res, { ok: false, error: `no item ${item} is assigned to you` }, 404); return; }
+  const brief = loadActions(ctx).filter((a) => a.item === item).pop();
+  if (!brief || brief.action !== 'brief') { ctx.json(res, { ok: false, error: 'no agent works on this item — let the agent draft it first' }, 409); return; }
+  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 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) });
+    return;
+  }
+  // stop: only a task that has not delivered yet; its session ends and the item offers the suggestion again
+  if (!(it.state === 'agent' && ['waiting', 'working', 'failed'].includes(it.sub))) { ctx.json(res, { ok: false, error: `the item is ${it.state === 'ready' ? 'a draft waiting for you' : it.state} — there is nothing to stop` }, 409); return; }
+  if (found) {
+    const t = dayRun.findTask(found.run, found.id);
+    if (t && (t.status === 'waiting' || t.status === 'working')) {
+      if (t.session_id && ctx.endSession) { try { ctx.endSession(t.session_id); } catch { /* the session already ended */ } }
+      const f = dayRun.stop(found.run, found.id, 'You stopped it.', now);
+      if (!f.ok) { ctx.json(res, { ok: false, error: f.error }, 409); return; }
+      if (!ctx.writeDayRun || !ctx.writeDayRun(f.run)) { ctx.json(res, { ok: false, error: 'could not save — nothing changed' }, 500); return; }
+    }
+  }
+  try { fs.mkdirSync(dirOf(ctx), { recursive: true }); fs.appendFileSync(actionsFile(ctx), JSON.stringify({ action: 'reopen', item, at: new Date(now).toISOString() }) + '\n'); }
+  catch { ctx.json(res, { ok: false, error: 'could not save your press' }, 500); return; }
+  const after = listFor(ctx, Date.now()).items.find((x) => x.id === item) || null;
+  ctx.json(res, { ok: true, item: after });
+}
+
 module.exports = { prefixes: ['/api/my-work'], handle, listFor, listForAsync };

package/workspace/lib/routes-stage-tools.js

@@ -164,6 +164,21 @@ function burndownFor(ctx, w, ids, board, sprint) {
     if (snap.readAt && (!readAt || snap.readAt < readAt)) readAt = snap.readAt;   // the oldest read is the honest age
   }
   if (!tickets.length) return { ok: true, available: false, reason: 'no Jira read for these initiatives yet' };
+  // jira-sprint-scope: a sprint burns down every issue in it, not only the initiatives' own tickets.
+  let whole = null;
+  try { whole = require('./jira-status.js').readSprints(w.root); } catch { whole = null; }
+  if (whole && whole.tickets.size) {
+    const names = new Set(tickets.filter((t) => t.sprint && t.sprint.name).map((t) => t.sprint.name));
+    const own = new Map(tickets.map((t) => [t.key, t]));
+    const add = [...whole.tickets.values()].filter((t) => t.sprint && names.has(t.sprint.name));
+    if (add.length) {
+      const keys = new Set(add.map((t) => t.key));
+      const merged = [...add.map((t) => ({ ...t, initiative: own.has(t.key) ? own.get(t.key).initiative : null })), ...tickets.filter((t) => !keys.has(t.key))];
+      tickets.length = 0;
+      tickets.push(...merged);
+      if (whole.fetchedAt && (!readAt || whole.fetchedAt < readAt)) readAt = whole.fetchedAt;
+    }
+  }
   return { ok: true, ...S.burndown(tickets, { sprint: sprint || null }), readAt };
 }
 

package/workspace/lib/work-assigned.js

@@ -6,6 +6,7 @@
  *   addable(virtuals, itemLines)   → [item]   the ones the PM's own ledger has never held (not added, not dropped)
  *   createdEvent(v)                → event    the `created` line that puts one in the PM's ledger on its first press
  *   overlay(item, byId)            → item     a ledger copy with the source's current status, suggestion and state
+ *   agentOf(x)                     → agent    what the agent does on a my-work item (initiative c3-work-agent), or null
  *
  * PURE: no file, process or clock. A virtual item has the Work item's fields (title, due, priority, waiting_on, flagged) and
  * says where it came from: origin jira | wbs | brief, plus key, url, status, suggest, why, my_work_state, repo. Its `source`
@@ -13,17 +14,40 @@
 
 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'];
+const SHOWN = ['origin', 'key', 'url', 'status', 'suggest', 'why', 'my_work_state', 'repo', 'initiative', 'agent'];
+
+/* 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
+ *   ready    the draft waits for the PM   sent  the PM posted it   null  the PM took the item, or there is nothing to offer */
+const SUB_STATE = { waiting: 'queued', working: 'working', sending: 'sending', failed: 'failed' };
+function agentOf(x) {
+  if (!x) return null;
+  const t = x.task || null;
+  let state = null;
+  if (x.state === 'brief') state = x.suggest ? 'suggest' : null;
+  else if (x.state === 'agent') state = SUB_STATE[x.sub] || 'queued';
+  else if (x.state === 'ready') state = 'ready';
+  else if (x.state === 'done' && x.sub === 'sent') state = 'sent';
+  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,
+    sent: t && t.sent ? { link: t.sent.link || null, at: t.sent.at || null } : null,
+    error: t ? t.error || null : null, revisions: t ? t.revisions || 0 : 0, started_at: t ? t.started_at || null : null, decided_at: x.decided_at || null,
+  };
+}
 
 function fromMyWork(items) {
   const out = [];
   for (const x of items || []) {
-    if (!x || !x.id || !x.title || x.state === 'done' || x.category === 'done') continue;
+    if (!x || !x.id || !x.title) continue;
+    // a posted item is done in my-work: it adds no new row, but the PM's own copy of it still shows that it was posted
+    if (x.state === 'done' || x.category === 'done') { if (x.state === 'done' && x.sub === 'sent') out.push({ id: String(x.id), overlay_only: true, agent: agentOf(x) }); continue; }
     const v = {
       id: String(x.id), title: String(x.title), source: x.source === 'wbs' ? 'wbs' : 'jira', origin: x.source === 'wbs' ? 'wbs' : 'jira', assigned: true,
       due: x.due || null, priority: TIER_PRIORITY[x.wsjf && x.wsjf.tier] || null, waiting_on: null, job: null,
       key: x.key || null, url: x.url || null, status: x.status || null, suggest: x.suggest || null, my_work_state: x.state || null,
-      repo: x.repo || null, initiative: x.initiative || null,
+      repo: x.repo || null, initiative: x.initiative || null, agent: agentOf(x),
     };
     if (x.state === 'agent') v.waiting_on = AGENT;
     if (x.state === 'ready' || x.category === 'doing') v.flagged = true;
@@ -49,11 +73,11 @@ function fromBrief(brief, todayIso) {
 /** The virtual items whose id the ledger never held: an item the PM added, pressed or dropped is the ledger's from then on. */
 function addable(virtuals, itemLines) {
   const held = new Set((itemLines || []).filter((l) => l && l.id).map((l) => l.id));
-  return (virtuals || []).filter((v) => !held.has(v.id));
+  return (virtuals || []).filter((v) => !v.overlay_only && !held.has(v.id));
 }
 
 function createdEvent(v) {
-  const { id, source, ...fields } = v;
+  const { id, source, agent, ...fields } = v;   // the agent state is read on every list, never stored
   return { event: 'created', id, fields, source };
 }
 
@@ -66,4 +90,4 @@ function overlay(item, byId) {
   return out;
 }
 
-module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, AGENT };
+module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, AGENT };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/console3.css

@@ -1879,6 +1879,15 @@
 .c3 .wkq{display:flex;flex-wrap:wrap;gap:var(--sp-2);align-items:center;margin-top:var(--sp-2)}
 .c3 .wkq-f{display:inline-flex;gap:6px;align-items:center;font-size:var(--fs-2)}
 .c3 .wkq input[type=date],.c3 .wkq-f input[type=text]{font:inherit;font-size:var(--fs-2);padding:4px 6px;border:1px solid var(--border);background:var(--background);color:var(--foreground);border-radius:6px;min-width:0;max-width:150px}
+/* c3-work-agent: what the agent will do, the note when the PM sends a draft back, the draft sheet */
+.c3 .wk-agent-ask{display:flex;gap:6px;align-items:center;margin-top:6px}
+.c3 .wk-agent-ask input{flex:1;min-width:0;font:inherit;font-size:var(--fs-2);padding:4px 8px;border:1px solid var(--border);background:var(--background);color:var(--foreground);border-radius:6px}
+.c3 .wk-agent-ask[hidden]{display:none}
+.c3 .wk-agent-sheet{display:grid;gap:var(--sp-3)}
+.c3 .wk-agent-will{font-size:var(--fs-2)}
+.c3 .wk-agent-sum{margin:0}
+.c3 .wk-agent-body{--tc:var(--acc)}
+.c3 .wk-agent-body .sit{white-space:pre-line}
 .c3 .tag.wk-off{background:var(--accw);color:var(--acc)}
 .c3 .tag.wk-nb{background:var(--muted);color:var(--foreground)}
 .c3 .tag.wk-on{background:var(--acc);color:var(--background)}

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

@@ -34,6 +34,7 @@ import { makeXp, attachExpand } from './c3-expand.js';
 import { attachSwipe } from './c3-swipe.js';
 import { toast } from './c3-toast.js';
 import { openSheet } from './c3-sheet.js';
+import { c3btn } from './page-agent.js';
 import { onBriefing, loadBriefing } from './shell-ticker.js';
 import { reviewSection } from './c3-brief.js';
 import { VIEWS, REVIEW_DAYS, workPlace, arrives, buildWork, addIso, daysBetween, untouchedDays } from './work-place.js';
@@ -165,7 +166,7 @@ export const COPY = Object.freeze({
   outcome: 'What came out of it (optional)', notYet: 'Not yet:', laterToday: 'Later today', tomorrow: 'Tomorrow', nextWeek: 'Next week',
   looksDone: 'Looks done?', confirm: 'Confirm done', flag: 'Flag', unflag: 'Unflag', notBefore: 'Not before', someday: 'Someday', bringBack: 'Bring back',
   waitingField: 'Waiting on', waitingWho: 'Who?', stopWaiting: 'Stop waiting', flagged: 'Flagged',
-  notBeforeChip: (d) => 'Not before ' + d, advances: (t) => 'Advances team task ' + t, suggested: 'Suggested', agentSuggests: (t) => 'Agent: ' + t, moved: (n) => `Moved ${n}×`,
+  notBeforeChip: (d) => 'Not before ' + d, advances: (t) => 'Advances team task ' + t, suggested: 'Suggested', agentSuggests: (t) => 'Agent can: ' + t, moved: (n) => `Moved ${n}×`,
   overdue: (n) => (n === 1 ? 'Overdue since yesterday' : `${n} days overdue`), dueToday: 'Due today', dueOn: (d) => 'Due ' + d,
   waitingSince: (w, since, ago) => `Waiting for ${w}` + (since ? ` since ${since}` : '') + (ago ? ` (${ago})` : ''), repeats: (r) => 'Repeats ' + String(r).toLowerCase(),
   /* Review (PRD R7) */
@@ -284,7 +285,7 @@ export function mountPmWork(host, ctx) {
   if (ctx && ctx.FIXTURE) return;
   ensureC3Css();
   inst = { host, ctx: ctx || {}, root: el('div', { class: 'c3 calwrap wk', 'data-pm-work': '' }), data: null, base: null, ov: newOv(), lens: 'today',
-    opens: new Set(), picks: new Map(), editing: new Set(), planning: new Set(), runs: new Map(), trays: new Set(), cases: new Set(), timers: new Set(), hidden: new Set(),
+    opens: new Set(), picks: new Map(), asks: new Map(), editing: new Set(), planning: new Set(), runs: new Map(), trays: new Set(), cases: new Set(), timers: new Set(), hidden: new Set(),
     focEdit: new Set(), rv: { ids: null, handled: new Set(), changing: false }, decisions: 0, drafts: null, draftsSig: '', draftsHost: el('div', { 'data-pm-review-drafts': '' }) };
   inst.body = el('div', { class: 'calbody pmw-body' });
   inst.bar = el('div', { class: 'calbar' });
@@ -328,6 +329,9 @@ async function load(inst) {
   inst.data = inst.base && DEMO() ? applyOv(inst.base, inst.ov) : inst.base;
   if (!inst.data) say({ text: (r && r.error) || COPY.readError, tone: 'error' });
   if (insts.get(inst.host) === inst) draw(inst);
+  /* an agent that is queued, working or posting changes on its own: read again until it stops (c3-work-agent) */
+  const busy = inst.data && !DEMO() && (inst.data.items || []).some((i) => i.agent && AGENT_BUSY.includes(i.agent.state));
+  if (busy && !inst.agentPoll) { inst.agentPoll = true; later(inst, () => { inst.agentPoll = false; load(inst); }, AGENT_POLL_MS); }
 }
 
 async function press(inst, path, body, { quiet } = {}) {
@@ -628,6 +632,7 @@ function itemCase(inst, item, lens) {
   const ix = item.ix || {}; const mock = item.mock_row === true;
   const j = item.job && jobById(inst, item.job);
   const L = lensOptions(inst, item, lens);
+  if (!mock && item.agent && item.kind !== 'offline') return agentCase(inst, item, L);
   const jm = j && (j.mock_name || j.want);
   const evidence = ix.chg ? ix.chg.slice() : (() => {
     const c = [];
@@ -691,12 +696,131 @@ function startRun(inst, item, intent) {
 }
 
 
+/* ── the agent on a Jira or WBS 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). */
+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');
+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: (why) => 'Agent stopped' + (why ? ': ' + why : ''),
+  sitSuggest: (w) => `The agent can draft this for you. You read it here first. Nothing goes to ${w} until you post it.`,
+  sitQueued: 'Queued. The agent starts as soon as a session is free. You can close this page.',
+  sitWorking: 'The agent is working on it. You can close this page: the item keeps its state.',
+  sitReady: (at, w) => `Draft ready${at ? ' at ' + at : ''}. Nothing went to ${w}.`,
+  sitSending: (k) => `Posting to ${k}. A session does exactly the step you approved and nothing else.`,
+  sitSent: (at, w) => `You posted it to ${w}${at ? ' at ' + at : ''}.`,
+  sitFailed: (why) => `The agent stopped${why ? ': ' + why : '.'} Nothing was sent.`,
+  willDo: 'What the agent will do: ', change: 'Change what the agent does', askLabel: 'What the agent will do',
+  draftIt: 'Let the agent draft this', tryAgain: 'Try again', post: (k) => 'Post it to ' + k, back: 'Send it back with a note', keepDraft: 'Keep it as a draft',
+  noteLabel: 'Tell the agent what to change', openDraft: 'Open the draft', draftSheet: (k) => 'Draft for ' + k, stop: 'stop',
+  handed: (w) => `Handed to the agent. Nothing goes to ${w} until you post it.`, stopped: 'Stopped. Nothing was kept.', kept: 'Kept as a draft. Post it when you are ready.',
+  posting: 'Approved. A session posts exactly this text.', sentBack: 'Sent back with your note. The agent drafts it again.', retried: 'The agent tries again.',
+  needNote: 'Say what to change first: type a note, then send it back.', link: 'Open what was posted',
+};
+
+function agentChip(item) {
+  const a = item.agent; if (!a || item.mock_row) return null;
+  const st = (cls, ic, text, spin) => el('span', { class: cls, 'data-pm-agent-state': a.state, 'data-pm-suggest': item.id }, spin ? el('span', { class: 'c3spin' }, c3ic(ic, 'sm')) : c3ic(ic, 'sm'), text);
+  if (a.state === 'suggest') return st('chip2', 'spark', AG.can(a.instruction || a.suggest || ''));
+  if (a.state === 'queued') return st('st', 'clock', AG.queued);
+  if (a.state === 'working') return st('st c3strip', 'spark', AG.working(minsAgo(a.started_at)), true);
+  if (a.state === 'ready') return st('st ok', 'check', AG.ready);
+  if (a.state === 'sending') return st('st c3strip', 'out', AG.sending, true);
+  if (a.state === 'sent') return st('st ok', 'out', AG.sent(whereOf(item), a.sent && a.sent.at ? hhmm(a.sent.at) : ''));
+  if (a.state === 'failed') return st('tag warn', 'alert', AG.failed(a.error));
+  return null;
+}
+
+async function agentPress(inst, path, body, text) {
+  const r = await pmPost(path, body);
+  if (!r || !r.ok) { say({ text: (r && r.error) || COPY.saveError, tone: 'error' }); return false; }
+  inst.picks.delete(body.item);
+  say({ text, timeout: 4000 });
+  await load(inst);
+  return true;
+}
+
+function agentCase(inst, item, L) {
+  const a = item.agent; const w = whereOf(item); const k = item.key || 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 || '';
+  let sit = ''; let opts = []; let quote = ''; const chg = []; let outbox = false; let cta = ''; let agentAsk = null; let after = null;
+  const extras = [];
+  const strip = (spin, ic, text) => el('div', { class: 'c3ag', 'data-pm-agent-strip': item.id }, el('div', { class: 'fold a', role: 'status' }, spin ? el('span', { class: 'c3spin' }, c3ic(ic, 'sm')) : c3ic(ic, 'sm'), ' ' + text + ' ',
+    c3btn('chip2 lk', { 'data-pm-agent-stop': item.id }, [c3ic('stop', 'sm'), AG.stop], () => agentPress(inst, '/api/my-work/stop', { item: item.id }, AG.stopped))));
+  if (a.state === 'suggest' || a.state === 'failed') {
+    sit = a.state === 'failed' ? AG.sitFailed(a.error) : AG.sitSuggest(w);
+    const brief = () => agentPress(inst, '/api/my-work/act', { action: 'brief', item: item.id, instruction: ask(), ws: inst.ctx.ws }, AG.handed(w));
+    const retry = () => agentPress(inst, '/api/my-work/decide', { item: item.id, action: 'retry' }, AG.retried);
+    opts = [o('agent', a.state === 'failed' ? AG.tryAgain : AG.draftIt, [fx('spark', 'Drafts it here in PMOS', 'ok'), fx('lock', 'Nothing goes to ' + w, 'ok')], a.state === 'failed' ? retry : brief), ...own];
+    cta = 'Slide to let the agent draft';
+    if (a.state === 'suggest') {
+      const editing = inst.editing.has('ask:' + item.id);
+      const input = el('input', { type: 'text', value: ask(), 'aria-label': AG.askLabel, 'data-pm-agent-ask': item.id, autocomplete: 'off' });
+      const save = () => { const v = input.value.trim(); if (v) inst.asks.set(item.id, v); inst.editing.delete('ask:' + item.id); draw(inst); };
+      input.addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.isComposing) save(); });
+      extras.push(el('div', { class: 'c3ag', 'data-pm-agent-will': item.id }, el('div', { class: 'dim mono wk-agent-will' }, c3ic('spark', 'sm'), ' ' + AG.willDo + (editing ? '' : ask())),
+        editing ? el('div', { class: 'form wk-agent-ask' }, input, button({ label: COPY.save, variant: 'outline', size: 'sm', onClick: save })) : null));
+      if (!editing) agentAsk = c3btn('chip2 lk', { 'data-pm-agent-change': item.id }, [c3ic('edit', 'sm'), AG.change], () => { inst.editing.add('ask:' + item.id); draw(inst); });
+    }
+  } else if (a.state === 'queued') {
+    sit = AG.sitQueued; extras.push(strip(false, 'clock', 'Queued' + (a.decided_at ? ' at ' + hhmm(a.decided_at) : '')));
+  } else if (a.state === 'working') {
+    sit = AG.sitWorking; extras.push(strip(true, 'spark', 'Working' + (a.started_at ? ' · started ' + minsAgo(a.started_at) : '')));
+  } else if (a.state === 'ready') {
+    const d = a.draft || {};
+    quote = d.body || ''; sit = AG.sitReady('', w);
+    if (d.summary) chg.push(['doc', d.summary, 'draft']);
+    if (a.revisions) chg.push(['reply', 'Redrafted after your note' + (a.revisions > 1 ? 's (' + a.revisions + ')' : ''), '']);
+    outbox = true; cta = 'Hold to post';
+    const note = el('input', { type: 'text', placeholder: AG.noteLabel, 'aria-label': AG.noteLabel, 'data-pm-agent-note-in': item.id, autocomplete: 'off' });
+    const back = () => { const v = note.value.trim(); if (!v) { say({ text: AG.needNote, timeout: 3500 }); note.focus(); return; } agentPress(inst, '/api/my-work/decide', { item: item.id, action: 'revise', note: v }, AG.sentBack); };
+    note.addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.isComposing) back(); });
+    opts = [
+      o('post', AG.post(k), [fx('lock', 'Outward: exactly this text', 'warn'), fx('out', 'Goes to ' + w + ' as you', 'warn')], () => agentPress(inst, '/api/my-work/decide', { item: item.id, action: 'approve' }, AG.posting), { outward: true }),
+      o('back', AG.back, [fx('reply', 'The agent drafts it again', 'ok')], back),
+      o('keep', AG.keepDraft, [fx('check', 'Nothing leaves PMOS', 'ok')], () => say({ text: AG.kept, timeout: 3000 })),
+    ];
+    const noteBox = el('div', { class: 'form wk-agent-ask', 'data-pm-agent-note': item.id }, note); noteBox.hidden = inst.picks.get(item.id) !== 'back';
+    extras.push(el('div', { class: 'chips2' }, c3btn('chip2 lk', { 'data-pm-agent-draft': item.id }, [c3ic('eye', 'sm'), AG.openDraft], () => openDraft(item))));
+    after = noteBox;
+  } else if (a.state === 'sending') {
+    sit = AG.sitSending(k);
+  } else if (a.state === 'sent') {
+    sit = AG.sitSent(a.sent && a.sent.at ? hhmm(a.sent.at) : '', w);
+    opts = L.opts.map((x) => ({ ...x }));
+    if (a.draft && a.draft.body) extras.push(el('div', { class: 'chips2' }, c3btn('chip2 lk', { 'data-pm-agent-draft': item.id }, [c3ic('eye', 'sm'), AG.openDraft], () => openDraft(item)),
+      a.sent && a.sent.link ? el('a', { class: 'chip2 lk', href: a.sent.link, target: '_blank', rel: 'noopener noreferrer' }, c3ic('out', 'sm'), AG.link) : null));
+  }
+  if (opts.length) opts[0].rec = 1;
+  const model = { id: 'task:' + item.id, sit, quote, chg, conf: 0, cta, opts: opts.map((x) => ({ id: x.id, l: x.l, rec: x.rec, fx: x.fx, outward: !!x.outward })), why: '', outbox,
+    outboxReason: OUT_REASON, agentAsk, agentExtras: () => extras, agentAfterOpts: after };
+  const run = {}; opts.forEach((x) => { if (x.run) run[x.id] = x.run; });
+  return { model, run };
+}
+
+function openDraft(item) {
+  const a = item.agent || {}; const d = a.draft || {};
+  const body = el('div', { class: 'wk-agent-sheet' },
+    el('div', { class: 'chips' }, el('span', { class: 'tag' }, a.state === 'sent' ? 'posted' : 'draft'), item.key ? el('span', { class: 'chip2' }, c3ic('org', 'sm'), (item.origin === 'jira' ? 'Jira ' : '') + item.key) : null),
+    d.summary ? el('p', { class: 'dim wk-agent-sum' }, d.summary) : null,
+    el('div', { class: 'case wk-agent-body' }, el('p', { class: 'sit' }, d.body || '')),
+    el('div', { class: 'fold' }, c3ic('info', 'sm'), ' ' + (a.state === 'sent' ? 'This is the text that was posted.' : 'Nothing is in ' + whereOf(item) + ' yet. Post it from the item, after you read it.')));
+  openSheet({ title: AG.draftSheet(item.key || item.title), icon: 'doc', body });
+}
+
 /** The case file element of an item: c3-case.js plus what is Work's own (offline work, the shared actions, the steps, the agent tray, the edit fields). */
 function caseFile(inst, item, lens) {
   const { model, run } = itemCase(inst, item, lens);
   const root = renderCase(model, {
-    picked: inst.picks.get(item.id), outbox: false,
-    onPick: (id) => inst.picks.set(item.id, id),
+    picked: inst.picks.get(item.id), outbox: !!model.outbox,
+    onPick: (id) => { inst.picks.set(item.id, id); const n = root.querySelector('[data-pm-agent-note]'); if (n) { n.hidden = id !== 'back'; if (!n.hidden) n.querySelector('input').focus(); } },
     onConfirm: ({ option }) => {
       const fn = run[option.id];
       if (fn) fn(rowOf(inst, item));
@@ -711,6 +835,8 @@ function caseFile(inst, item, lens) {
   const rs = inst.runs.get(item.id);
   const agent = item.mock_row && item.agent_move && (item.ix || {}).move;
   if (item.kind === 'offline') extras.push(offlineBlock(inst, item));
+  if (model.agentExtras) extras.push(...model.agentExtras());
+  if (model.agentAfterOpts) { const sl = root.querySelector('.c3slide'); if (sl) sl.after(model.agentAfterOpts); }
   if (rs && rs.phase === 'work') {
     extras.push(el('div', { class: 'c3ag', 'data-ag': item.id }, el('div', { class: 'fold a', role: 'status' }, el('span', { class: 'c3spin' }, c3ic('spark', 'sm')), rs.steps[Math.min(rs.i, rs.steps.length - 1)] + ' · ' + (Math.min(rs.i, rs.steps.length - 1) + 1) + ' of ' + rs.steps.length,
       el('button', { type: 'button', class: 'chip2 lk', 'data-pm-agent-stop': item.id, onclick: () => { inst.runs.delete(item.id); say({ text: 'Stopped. Nothing was kept.', timeout: 2500 }); draw(inst); } }, c3ic('stop', 'sm'), 'stop'))));
@@ -725,7 +851,7 @@ function caseFile(inst, item, lens) {
       c3ib('Speak is off on this line: nothing on this page records. Type the reply here.', 'mic', { 'data-off': '', onclick: () => say({ text: 'The microphone needs the app. Nothing was recorded: type the reply here.', timeout: 4200 }) }, 'sm'),
       c3ib('Close the reply', 'x', { onClick: () => { inst.trays.delete(item.id); draw(inst); } }, 'sm')));
   }
-  const showSteps = !(rs && rs.phase) && item.kind !== 'offline' && (inst.planning.has(item.id) || (item.steps || []).length || (!agent && (!item.mock_row || item.src === 'You')));
+  const showSteps = !(rs && rs.phase) && item.kind !== 'offline' && !(item.agent && !item.mock_row && item.agent.state !== 'sent') && (inst.planning.has(item.id) || (item.steps || []).length || (!agent && (!item.mock_row || item.src === 'You')));
   if (showSteps) extras.push(stepsBlock(inst, item));
   const anchor = root.querySelector('.c3ag') || root.querySelector('.sit');
   if (anchor) anchor.after(...extras); else root.prepend(...extras);
@@ -734,8 +860,9 @@ function caseFile(inst, item, lens) {
   const form = editForm(inst, item); form.hidden = !inst.editing.has(item.id);
   const edit = el('button', { type: 'button', class: 'chip2 lk', 'aria-expanded': String(inst.editing.has(item.id)), 'data-pm-edit-toggle': item.id,
     onclick: () => { const on = !inst.editing.has(item.id); if (on) inst.editing.add(item.id); else inst.editing.delete(item.id); form.hidden = !on; edit.setAttribute('aria-expanded', String(on)); } }, c3ic('edit', 'sm'), 'Edit details');
-  const ft = root.querySelector('.cft');
-  if (ft) ft.append(edit); else root.append(el('div', { class: 'cft' }, edit));
+  const ft = root.querySelector('.cft') || root.appendChild(el('div', { class: 'cft' }));
+  if (model.agentAsk) ft.append(model.agentAsk);
+  ft.append(edit);
   root.append(form);
   return root;
 }
@@ -805,7 +932,8 @@ function workChips(inst, item, o = {}) {
     const label = item.origin === 'jira' ? 'Jira ' + (item.key || '') : 'WBS' + (item.repo ? ' ' + item.repo : '') + (item.key ? ' ' + item.key : '');
     const attrs = { class: 'tag', 'data-pm-origin': item.origin, title: item.status || '' };
     c.push(item.url ? el('a', { ...attrs, href: item.url, target: '_blank', rel: 'noopener', onclick: (e) => e.stopPropagation() }, label.trim()) : el('span', attrs, label.trim()));
-    if (item.suggest) c.push(el('span', { class: 'chip2', 'data-pm-suggest': item.id }, c3ic('spark', 'sm'), COPY.agentSuggests(item.suggest)));
+    // the agent's state is the row's first chip (itemRow), so quiet pages keep it in sight
+    if (item.suggest && !item.agent) c.push(el('span', { class: 'chip2', 'data-pm-suggest': item.id }, c3ic('spark', 'sm'), COPY.agentSuggests(item.suggest)));
   } else if (item.origin === 'brief') {
     c.push(el('span', { class: 'tag', 'data-pm-origin': 'brief', title: item.why || '' }, c3ic('spark', 'sm'), COPY.suggested));
     if (item.why) c.push(el('span', { class: 'chip2', 'data-pm-why': item.id }, item.why));
@@ -833,7 +961,9 @@ function itemRow(inst, item, lens, o = {}) {
   if (rs && rs.phase === 'work') chips.push(el('span', { class: 'st c3strip', 'data-sxs': item.id }, el('span', { class: 'c3spin' }, c3ic('spark', 'sm')), rs.steps[Math.min(rs.i, rs.steps.length - 1)] + ' · ' + (Math.min(rs.i, rs.steps.length - 1) + 1) + ' of ' + rs.steps.length));
   else if (rs && rs.phase === 'done') chips.push(el('span', { class: 'st ok' }, c3ic('check', 'sm'), 'agent: result ready'));
   else if (inst.planning.has(item.id)) chips.push(el('span', { class: 'st' }, el('span', { class: 'c3spin' }, c3ic('spark', 'sm')), 'planning the steps'));
-  if (item.waiting_on) {
+  const ac = !mock && agentChip(item);
+  if (ac) chips.push(ac);
+  if (item.waiting_on && !(ac && item.waiting_on === 'an agent')) {
     const since = item.waiting_since ? String(item.waiting_since).slice(0, 10) : '';
     chips.push(el('span', { class: 'chip2', 'data-pm-waiting-chip': item.id }, c3ic('wait', 'sm'), COPY.waitingSince(item.waiting_on, since ? dayLabel(since) : '', since ? ago(since, today) : '')));
   }

package/workspace/server.js

@@ -8988,6 +8988,12 @@ async function handleRequest(req, res) {
     headlessBusy: (id) => { const x = sessions.get(String(id || '')); return !!(x && x.headless && x.child); },
     // initiative my-work: every registered repository, the day runs, and the two presses that start sessions
     workspaceList: () => [...workspaces.values()], readDayRun, myWorkBrief, myWorkRead,
+    // c3-work-agent: the PM's decision on the agent's draft and Stop, on the day run that holds the item's task
+    writeDayRun, startDayTasks, endSession: (id) => {
+      const x = sessions.get(String(id || '')); if (!x) return;
+      if (x.child) stopHeadless(x);
+      else if (x.pty) { if (x.tmux) tmuxKillSession(x.tmux); try { x.pty.kill(); } catch { /* already ended */ } }
+    },
     // workspace-data-freshness: the source table, the facts rebuild and Refresh now's skill sessions
     freshness, factsRefresh: (root) => factsAsync.refresh(root, { force: true }), startSkill: startSkillSession,
     // c3-initiative-boards: the PMOS checkout this server is embedded in, whose default board keeps its derived ladder

package/workspace/skills/jira-sync.skill

@@ -1,7 +1,7 @@
 ---
 name: jira-sync
 label: "Jira status check"
-description: "Read, read-only, the status, sprint and subtasks of the Jira tickets each initiative pushed, or of its Jira epics and the issues under them, and save them in PMOS for the initiative's Jira tickets tab. It writes nothing to Jira."
+description: "Read, read-only, the status, sprint and subtasks of the Jira tickets each initiative pushed, or of its Jira epics and the issues under them, and every issue in the sprints those tickets are in, and save them in PMOS for the initiative's Jira tickets tab and the board's Sprints tab. It writes nothing to Jira."
 run: agent
 agent: claude
 output:
@@ -35,10 +35,11 @@ Procedure:
    - `url`: the issue's browse link, `https://<site>.atlassian.net/browse/<KEY>`.
    The shape Jira returned (`{"issues": [{"key", "self", "fields": {...}}]}`) is also accepted.
 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", skip this step. 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).
 5. Record the people in People. For each assignee and reporter other than the PM, write one sighting per issue (People adds each new person at once): {"source": "jira", "handle": {"kind": "jira", "value": "<their Jira display name>"}, "name": "<display name>", "interaction": {"date": "<the issue's last update, YYYY-MM-DD>", "kind": "Jira", "text": "<Assignee|Reporter> of <KEY>: <summary, at most 150 characters>", "pointer": "jira · <KEY> · <url>", "initiative": "<the initiative id>"}}. Put all of them in one file {"sightings": [...]} in the scratch folder, run `pmos people record --file <that file>` once, and delete the file. An issue with no assignee gives no assignee sighting.
 6. Finish with the three sections of the output contract, one short line each:
-   - Checked: the initiative, the number of tickets read, and each change (status, sprint, blocked). If nothing changed, say "no change". Add how many people you recorded.
-   - Not reached: each initiative whose search failed, with the reason.
+   - Checked: the initiative, the number of tickets read, and each change (status, sprint, blocked). If nothing changed, say "no change". Add how many people you recorded, and how many issues the sprint read saved per sprint.
+   - Not reached: each initiative whose search failed, with the reason, and the sprint read if it failed.
    - Needs you: tickets newly blocked, tickets the search did not return, and any refusal.
 
 Output contract — produce EXACTLY these sections, the same shape every run:

package/workspace/test-lists/c3-work-agent.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "Initiative c3-work-agent: the agent on a Jira or WBS item in Work (the suggestion as an option, queued, working, the draft, Send back, Stop, Post).",
+  "modules": ["work-agent.test.js"],
+  "panels": ["pm-c3-work-agent-test.js"],
+  "seconds": { "work-agent.test.js": 8, "pm-c3-work-agent-test.js": 30 }
+}