create-pmos 0.184.0 → 0.186.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.184.0",
+  "version": "0.186.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@14635e7
+kernel-source: pmos@4d636bc
 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-13T04:43:18Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T05:23:27Z"}
 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-13T04:43:18Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T05:23:27Z"}
 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-13T04:43:18Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T05:23:27Z"}
 status: stable
 ---
 

package/workspace/c3-report-setup-test.js

@@ -88,6 +88,7 @@ const TAB = '[data-rs-tab]';
   await page.click('[data-rs-card] [data-rs-act="setup"]');
   ok('Set up posts ONE setup with the ask and the proposal', !!(await until(() => sent('/api/report-setups/setup').length === 1)) && sent('/api/report-setups/setup')[0].body.ask && sent('/api/report-setups/setup')[0].body.proposal && /pricing/i.test(sent('/api/report-setups/setup')[0].body.proposal.name), JSON.stringify(sent('/api/report-setups/setup')).slice(0, 300));
   ok('the set-up appears marked New with its first draft in Documents', !!(await until(async () => (await page.$$('[data-rs-reg]')).length === 4)) && /New/.test(await text('[data-rs-setups]')) && (await page.$$('[data-rs-doc]')).length === 7);
+  ok('the Set up toast says the first draft is ready and offers Open', /first draft is ready/.test(await text('[data-c3-toast]')) && !!(await page.$('[data-c3-toast-action]')), await text('[data-c3-toast]'));
   ok('nothing else was posted: no copy, no issue', sent('/api/docs/create-copy').length === 0 && sent('/api/report/issue').length === 0);
 
   /* ── found: Set up, Not a report with Undo ── */

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/guide/reports-set-up.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Set up a report by asking, and the report finder"
 description: "How to ask PMOS to draft a report you send, how the report finder finds reports you already send, how to set one up, and how a cycle becomes a document you issue."
-timestamp: 2026-10-12
+timestamp: 2026-10-13
 ---
 
 # Set up a report by asking, and the report finder
@@ -17,6 +17,7 @@ Open the **Reports** tab of the console. It has four parts: Ask PMOS, Found in y
 2. Press **Set up**. PMOS reads your earlier copies and learns the sections. This takes a minute. You can leave the page. **Cancel** stops it.
 3. PMOS shows its proposal: what it found, the proposed report, what it learned from, and the fixes it will apply.
 4. Press **Set up** to accept the proposal. Press **Change** to say what to change, for example "Draft it on Tuesday instead". PMOS revises the proposal. Press **Cancel** to drop it.
+5. PMOS writes the first draft at once. Press **Open** in the message to read it. You do not wait for the day of the schedule.
 
 A proposal shows the name, the purpose, the audience, the output, the schedule, the sources and the sections in order. Change the output with the buttons: Google Slides, Google Doc, Google Sheets, Confluence or PDF. PMOS shows the report in the same format in the sheet.
 
@@ -39,6 +40,7 @@ The most likely finding also shows on the Briefing as **Report found**. Press **
 **Set up** has one row for each report: its source, output, schedule, next draft and last issue. Each row has these buttons:
 
 - **Open** opens the current draft.
+- **Draft it now** shows in place of Open when the report has no draft. PMOS writes the draft of the next cycle and opens it.
 - **All cycles** lists every cycle of the report.
 - **Pause** stops the drafts. **Resume** starts them again.
 
@@ -46,7 +48,7 @@ The most likely finding also shows on the Briefing as **Report found**. Press **
 
 ## What PMOS does and does not do
 
-- PMOS drafts on the day of the schedule. It sends nothing.
+- PMOS drafts the first cycle when you press Set up, and each next cycle on the day of the schedule. It sends nothing.
 - PMOS writes to Google or to Confluence only when you press **Create the copy** or **Update the copy**.
 - A download happens only when you press a download item.
 - You issue a report. An issued report is frozen.

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/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-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-report-setups.js

@@ -9,7 +9,8 @@
  *   POST /api/report-setups/ask        { ws, text }                          → { ok, id }       starts the report-setup run (headless)
  *   POST /api/report-setups/change     { ws, id, text }                      → { ok }           a correction to a proposal; a second run revises it
  *   POST /api/report-setups/cancel     { ws, id }                            → { ok }
- *   POST /api/report-setups/setup      { ws, ask? | finding?, proposal? }    → { ok, setup, first_draft }   THE press that sets a report up
+ *   POST /api/report-setups/setup      { ws, ask? | finding?, proposal? }    → { ok, setup, first_draft, drafted }   THE press that sets a report up; drafts the first cycle
+ *   POST /api/report-setups/draft      { ws, id }                            → { ok, drafted: { slot, path }, id }   Draft it now (the next cycle)
  *   POST /api/report-setups/dismiss    { ws, finding }                       → { ok }           "Not a report"
  *   POST /api/report-setups/pause | resume { ws, id }                         → { ok, setup }
  *   POST /api/report-setups/from-dashboard { ws, key, name, output, schedule, audience } → { ok, setup }
@@ -39,13 +40,14 @@ const RN = require('./report-needs.js');
 const RC = require('./report-checks.js');
 const RX = require('./report-export.js');
 const RF = require('./report-finder.js');
+const RD = require('./report-draft.js');
 const logic = require('./schedule-logic.js');
 const docSync = require('./doc-sync.js');
 const headless = require('./headless.js');
 
 const text = (v) => (typeof v === 'string' ? v : '');
 const bad = (status, error) => ({ status, body: { ok: false, error } });
-const POSTS = ['ask', 'change', 'cancel', 'setup', 'dismiss', 'pause', 'resume', 'from-dashboard', 'finder'];
+const POSTS = ['ask', 'change', 'cancel', 'setup', 'draft', 'dismiss', 'pause', 'resume', 'from-dashboard', 'finder'];
 const MADE_BY = ['schedule', 'you', 'agent'];
 
 const runs = new Map();   // ask id → session id, for the report-setup runs this server started
@@ -331,14 +333,30 @@ async function handle(req, res, url, ctx) {
     if (!proposal) return send(bad(400, 'say which request or finding to set up, or give the proposal'));
     const r = RS.setUp(root, { ...proposal, ...(from ? { from } : {}) }, opts);
     if (!r.ok) return fail(r);
-    const docsOf = { reports: [] };
-    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), docsOf, new Map()), first_draft: r.first_draft } });
+    // The first cycle is drafted now, at the slot of its first scheduled draft, so the PM has a document to read the moment it is set up
+    // (the approved mockup's "Sample draft made when you set up"). The schedule later redrafts the same slot. A failed draft leaves the set-up
+    // in place and says why; Draft it now on the row tries again.
+    const drafted = firstDraft(root, r, g.actor);
+    if (drafted.path) ctx.invalidateNeedsAgg && ctx.invalidateNeedsAgg();
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), documentsOf(ctx, w), copyIndex(root)), first_draft: r.first_draft, drafted } });
   }
   if (sub === 'dismiss') {
     const r = RS.dismissFinding(file, { id: text(body.finding), by: g.actor });
     if (!r.ok) return fail(r);
     return send({ status: 200, body: { ok: true } });
   }
+  if (sub === 'draft') {
+    // Draft it now: the next cycle of a set-up report, written at the slot of its next scheduled draft. A page write, like Draft now on the report.
+    const s = RS.fold(RS.readLines(file)).setups.get(text(body.id));
+    if (!s || s.status === 'removed') return send(bad(404, 'no such report'));
+    if (s.source !== 'work') return send(bad(400, 'a dashboard report is drafted from its dashboard on its day'));
+    let next = null; try { next = RS.nextDraftAt(s.schedule, s.last_run, new Date()); } catch { next = null; }
+    const day = next ? `${next.getFullYear()}-${String(next.getMonth() + 1).padStart(2, '0')}-${String(next.getDate()).padStart(2, '0')}` : null;   // the local day, as setUp names a slot
+    const d = draftCycle(root, s.id, day, g.actor);
+    if (d.error) return send(bad(500, 'the draft was not written: ' + d.error));
+    if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg();
+    return send({ status: 200, body: { ok: true, drafted: d, id: s.id + '/' + d.slot } });
+  }
   if (sub === 'pause' || sub === 'resume') {
     const r = RS[sub](root, text(body.id), opts);
     if (!r.ok) return fail(r);
@@ -365,4 +383,19 @@ async function handle(req, res, url, ctx) {
   return send(bad(404, 'no such report route'));
 }
 
+/** Draft a report's cycle now through the one writer (report-draft.js writeDraft). → { slot, path } | { error } */
+function draftCycle(root, cadence, slot, actor) {
+  const d = RD.draftOf(root, { cadence, slot: slot || undefined });
+  if (!d || d.ok === false) return { error: (d && d.error) || 'the drafter answered nothing' };
+  // A draft already at that slot is the answer: open it, never overwrite its notes.
+  try { if (d.path && fs.statSync(path.join(path.resolve(String(root)), d.path)).isFile()) return { slot: d.slot, path: d.path, existing: true }; } catch { /* not there yet */ }
+  const w = RD.writeDraft(root, d, { actor, fresh: true });
+  if (!w || w.ok === false) return { error: (w && w.error) || 'the writer answered nothing' };
+  return { slot: d.slot, path: w.path };
+}
+function firstDraft(root, r, actor) {
+  if (!r.setup || r.setup.source !== 'work') return { error: 'a dashboard report is drafted from its dashboard on its day' };
+  return draftCycle(root, r.setup.id, r.first_draft && r.first_draft.slot, actor);
+}
+
 module.exports = { prefixes: ['/api/report-setups', '/api/report-documents', '/api/report-export'], handle, tick, ensureMigrated, documentsOf, listAnswer, copyOf };

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.184.0",
+  "version": "0.186.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.184.0",
+      "version": "0.186.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.184.0",
+  "version": "0.186.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-rs.js

@@ -186,7 +186,8 @@ function setupFrom(b) {
   startDocs(s, F);
   if (F) findings = findings.filter((f) => f.id !== F.id);
   if (askRec) asks = asks.filter((a) => a.id !== askRec.id);
-  return json({ ok: true, setup: setupView(s), first_draft: { slot: next || '', at: next ? next + 'T08:00:00.000Z' : null, day: next || '' } });
+  const first = DOCS.filter((d) => d.setup === id && d.state === 'draft')[0];
+  return json({ ok: true, setup: setupView(s), first_draft: { slot: next || '', at: next ? next + 'T08:00:00.000Z' : null, day: next || '' }, drafted: first ? { slot: first.slot, path: first.path } : { error: 'nothing to draft' } });
 }
 function post(path, b) {
   const k = path.replace('/api/report-setups/', '');
@@ -198,6 +199,7 @@ function post(path, b) {
   }
   if (k === 'cancel') { asks = asks.filter((a) => a.id !== b.id); return json({ ok: true }); }
   if (k === 'setup') return setupFrom(b);
+  if (k === 'draft') { const s = SETUPS.find((x) => x.id === b.id); if (!s) return json({ ok: false, error: 'no such report' }, 404); const d = startDocs(s, null)[0]; return json({ ok: true, drafted: { slot: d.slot, path: d.path }, id: s.id + '/' + d.slot }); }
   if (k === 'dismiss') { findings = findings.filter((f) => f.id !== b.finding); dismissed.add(b.finding); return json({ ok: true }); }
   if (k === 'pause' || k === 'resume') { const s = SETUPS.find((x) => x.id === b.id); if (!s) return json({ ok: false, error: 'no such set-up' }, 404); s.status = k === 'pause' ? 'paused' : 'active'; return json({ ok: true, setup: setupView(s) }); }
   if (k === 'from-dashboard') {

package/workspace/public/pm/c3-report-setup.js

@@ -14,7 +14,7 @@ import { openSheet, closeSheet } from './c3-sheet.js';
 import { openDocSheet } from './c3-doc-sheet.js';
 import { toast } from './c3-toast.js';
 import { FORMATS, OUTPUTS, formatOf, ensureReportCss } from './c3-doc-formats.js';
-import { RS, onReports, loadReports, askPmos, changeIt, cancelAsk, setupFrom, dismissLater, pauseResume, fromDashboard, goTo, evidenceKind, normProposal, scheduleLabel, nextDraftDate, dayText, docsOf, outChip, copyChip, srcChip } from './c3-report-store.js';
+import { RS, onReports, loadReports, askPmos, changeIt, cancelAsk, setupFrom, draftNow, dismissLater, pauseResume, fromDashboard, goTo, evidenceKind, normProposal, scheduleLabel, nextDraftDate, dayText, docsOf, outChip, copyChip, srcChip } from './c3-report-store.js';
 
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 /** 'Wed 21 Oct 2026' for a day, 'Oct 2026' for a month, any other slot as it is. */
@@ -122,6 +122,7 @@ function askCard(a, redo) {
 }
 
 /* ── a report document in the document sheet ── */
+RS.openDoc = (d) => openReportDoc(d);   // the store's toasts open a document through this
 export function openReportDoc(d, mode) {
   ensureReportCss();
   const setup = RS.setups.find((x) => x.id === d.setup) || null; const cyc = slotText(d.slot);
@@ -205,7 +206,10 @@ export function mountReportSetup(host, ctx) {
     el('span', { class: 'chips2' }, stag(d), copyChip(d.output, d.copy), pbtn('ghost', 'Open', 'out', { onclick: () => openReportDoc(d) })))));
   function openSetup(s) {
     const L = docsOf(RS.docs, s.id); const d = L.find((x) => x.state === 'draft') || L[0];
-    if (d) openReportDoc(d); else toast('No draft yet. The first draft is ' + (s.next_draft ? dayText(s.next_draft) : 'when you confirm the day') + '.');
+    if (d) { openReportDoc(d); return; }
+    if (s.source !== 'work' || s.status !== 'active') { toast('No draft yet. The first draft is ' + (s.next_draft ? dayText(s.next_draft) : 'when you confirm the day') + '.'); return; }
+    toast('Drafting ' + s.name + ' now. Nothing is sent.');
+    draftNow(s).then((nd) => { if (nd) openReportDoc(nd); });
   }
   function setupRow(s) {
     const paused = s.status === 'paused'; const cy = docsOf(RS.docs, s.id); const n = s.cycles != null ? s.cycles : cy.length; const open = RS.cyc.has(s.id);
@@ -215,7 +219,8 @@ export function mountReportSetup(host, ctx) {
           chip(icon('cal', 'sm'), s.label || scheduleLabel(s.schedule)), paused ? null : chip(icon('clock', 'sm'), 'Next draft ' + (s.next_draft ? dayText(s.next_draft) : 'not set yet')),
           chip(icon('mail', 'sm'), 'Last issued ' + (s.last_issued ? dayText(s.last_issued) : 'not yet'))),
         open ? cycRows(s) : null),
-      el('div', { class: 'acts' }, pbtn('outline', 'Open', 'out', { 'data-rs-act': 'open-reg', onclick: () => openSetup(s) }),
+      el('div', { class: 'acts' }, cy.length || paused || s.source !== 'work' ? pbtn('outline', 'Open', 'out', { 'data-rs-act': 'open-reg', onclick: () => openSetup(s) })
+        : pbtn('outline', 'Draft it now', 'spark', { 'data-rs-act': 'draft-now', onclick: () => openSetup(s) }),
         pbtn('ghost', 'All cycles (' + n + ')', 'fold', { 'data-rs-act': 'cyc', 'aria-expanded': String(open), onclick: () => { if (RS.cyc.has(s.id)) RS.cyc.delete(s.id); else RS.cyc.add(s.id); drawSetups(); } }),
         pbtn('ghost', paused ? 'Resume' : 'Pause', paused ? 'play' : 'pause', { 'data-rs-act': 'pause', onclick: () => pauseResume(s, !paused) })));
   }

package/workspace/public/pm/c3-report-store.js

@@ -114,9 +114,22 @@ export async function setupFrom(body) {
   if (r.setup && r.setup.id) RS.newIds.add(r.setup.id);
   await loadReports(RS.ws, true);
   const fd = r.first_draft; const first = (r.setup && r.setup.next_draft) || (fd && typeof fd === 'object' ? fd.day || fd.slot : fd);
-  toast('Set up. First draft ' + (first ? dayText(first) : 'once you confirm the day') + '. Nothing is sent.');
+  if (r.drafted && r.drafted.path) openDraftToast(r.setup.id, 'Set up. The first draft is ready to read. Nothing is sent.');
+  else toast('Set up. First draft ' + (first ? dayText(first) : 'once you confirm the day') + '. Nothing is sent.' + (r.drafted && r.drafted.error ? ' It could not be drafted yet: ' + r.drafted.error + '.' : ''));
   return r;
 }
+/* the page that draws documents sets RS.openDoc, so a toast here can open one without this store importing the page */
+function openDraftToast(id, text) {
+  const d = (RS.docs || []).filter((x) => x.setup === id && x.state === 'draft').sort((a, b) => (a.slot < b.slot ? 1 : -1))[0];
+  if (d && typeof RS.openDoc === 'function') toast({ text, actionLabel: 'Open', timeout: 8000, onAction: () => RS.openDoc(d) });
+  else toast(text);
+}
+/** Draft it now: the next cycle of a set-up report. → the new draft document, or null. */
+export async function draftNow(setup) {
+  const r = await post('draft', { id: setup.id }); if (!r || !r.ok) { fail(r, 'It was not drafted'); return null; }
+  await loadReports(RS.ws, true);
+  return (RS.docs || []).find((x) => x.setup === setup.id && x.slot === r.drafted.slot) || null;
+}
 /** Not a report: the finding leaves the list at once, the POST waits five seconds, and Undo cancels it. */
 export function dismissLater(id, onChange) {
   RS.hidden.add(id); emit(); if (onChange) onChange();

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/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 }
+}