create-pmos 0.231.0 → 0.233.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.231.0",
+  "version": "0.233.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@26c827f
+kernel-source: pmos@c113f92
 assembled: 2026-10-14
 mode: vendor

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

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-14T08:36:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T09:17:36Z"}
 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-14T08:36:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T09:17:36Z"}
 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-14T08:36:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T09:17:36Z"}
 status: stable
 ---
 

package/workspace/bin/pmos.js

@@ -57,9 +57,9 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 // old 900ms was tight enough that a server under load read as "not running" — the launcher would
 // then start a second one and collide with the first.
 const PROBE_MS = 2500;
-function probe(port) {
+function probe(port, ms = PROBE_MS) {
   return new Promise((res) => {
-    const req = http.get(`${urlOf(port)}/api/sessions`, { timeout: PROBE_MS }, (r) => {
+    const req = http.get(`${urlOf(port)}/api/sessions`, { timeout: ms }, (r) => {
       let b = ''; r.on('data', (c) => (b += c));
       r.on('end', () => {
         let j = null; try { j = JSON.parse(b); } catch {}
@@ -94,6 +94,31 @@ async function discover() {
   return hits.filter(Boolean);
 }
 
+/**
+ * Our own servers that are running but did not answer the probe (lib/server-discovery.js busyServers).
+ * Pinned launches only look at the pin, the same as discover().
+ */
+async function busy(livePorts = []) {
+  const held = [];
+  for (const p of D.candidatePorts({ stateDir: STATE, pinned: PINNED })) if (!livePorts.includes(p) && !(await portFree(p))) held.push(p);
+  return D.busyServers(STATE, { livePorts, heldPorts: held });
+}
+
+// How long to wait for a busy server before giving up on it. A server that is only slow answers well
+// inside this; one that is stuck does not, and starting a second server beside it does not help.
+const BUSY_WAIT_MS = 60000;
+async function waitForBusy(servers) {
+  process.stdout.write(`the workspace on port ${servers[0].port} is busy; waiting for it to answer `);
+  const until = Date.now() + BUSY_WAIT_MS;
+  while (Date.now() < until) {
+    for (const b of servers) if (await probe(b.port, 10000)) { say(''); return b.port; }
+    process.stdout.write('.');
+    await sleep(1000);
+  }
+  say('');
+  return null;
+}
+
 /** Can we bind it ourselves? The only honest test of "free" — lsof answers a different question. */
 function portFree(port) {
   return new Promise((res) => {
@@ -257,7 +282,7 @@ async function servesTailnet(port) {
 
 // `remote` starts a NEW server in tailnet mode (pmos phone); a server that is already running is reused as it is.
 // `open: false` registers the repo without opening the desktop browser.
-async function up(dir, { remote = false, open = true } = {}) {
+async function up(dir, { remote = false, open = true, waited = false } = {}) {
   // 1. Is a workspace already running — on ANY port it recorded, not just the one this shell guesses?
   let live = await discover();
   // A server that predates this install is running OLD code under NEW files (or the reverse). Reusing
@@ -289,6 +314,15 @@ async function up(dir, { remote = false, open = true } = {}) {
     }
     return openWorkspace(dir, port, { open });
   }
+  // 2. Is one of OUR servers running but too busy to answer? Then wait for it. Starting a second
+  //    server on the next port is what left a Windows PM with two servers and neither loading.
+  const slow = waited ? [] : await busy();
+  if (slow.length) {
+    if (await waitForBusy(slow)) return up(dir, { remote, open, waited: true });   // re-run: it may be an older version
+    say(`✗ the workspace server on port ${slow[0].port} (pid ${slow[0].pid}) is running but has not answered for a minute.`);
+    say('  Run `pmos stop`, then `pmos` to restart it. If it happens again, run `pmos doctor` and send its output.');
+    return 1;
+  }
   if (!ensureInstalled()) return 1;
   fs.mkdirSync(STATE, { recursive: true });
   cleanStalePids([]);
@@ -337,7 +371,10 @@ async function up(dir, { remote = false, open = true } = {}) {
   child.unref();
   try { fs.writeFileSync(pidFile(port), String(child.pid)); } catch {}
   process.stdout.write('starting the workspace ');
-  for (let i = 0; i < 40 && !exited; i++) {             // up to ~10s
+  // Up to ~60s while the server process is alive. A first start on Windows (antivirus scanning every
+  // new file) can take longer than 10s, and giving up early left a server starting with nobody waiting.
+  for (let i = 0; i < 240 && !exited; i++) {
+    if (i === 40) process.stdout.write('\n  still starting — a first start can take up to a minute ');
     if (await probe(port)) {
       say('');
       say('  sessions keep running after you close this terminal · `pmos stop` shuts it down');
@@ -404,7 +441,8 @@ async function stopOne(port) {
   if (!pid) { say(`✗ could not locate the server on port ${port} (no pid file, and nothing I can see owns it). Stop it manually.`); return 1; }
   try { process.kill(pid); } catch (e) { say(`✗ could not signal pid ${pid}: ${e.message}`); return 1; }
   for (let i = 0; i < 20; i++) {
-    if (!(await probe(port))) { say(`✓ stopped — ${urlOf(port)}`); try { fs.unlinkSync(pidFile(port)); } catch {} return 0; }
+    // Gone means the process ended or the port is free. "Not answering" is not enough: a busy server does not answer either.
+    if (!D.pidAlive(pid) || await portFree(port)) { say(`✓ stopped — ${urlOf(port)}`); try { fs.unlinkSync(pidFile(port)); } catch {} return 0; }
     await sleep(250);
   }
   say(`✗ port ${port} still responding after 5s — kill it manually (pid ${pid}).`);
@@ -412,7 +450,9 @@ async function stopOne(port) {
 }
 
 async function stop() {
-  const live = await discover();
+  // A busy server does not answer the probe but is still ours, and still holds its port. Stop it too.
+  const answering = await discover();
+  const live = [...answering, ...await busy(answering.map((l) => l.port))];
   if (!live.length) { say('○ not running.'); cleanStalePids([]); return 0; }
   // sessions are tmux-backed: stopping the server leaves them running; the next `pmos` re-attaches.
   say('stopping the workspace — sessions keep running in tmux and re-attach on the next launch…');

package/workspace/c3-work-test.js

@@ -4,7 +4,7 @@
  * dimensions 1 to 5 and 7). Loads /c3.html?demo=1 at 1440 wide and then at 390 wide. Demo mode answers every /api call in the page,
  * so nothing reaches the server and the fixture (public/pm/c3-demo-data.js pmItems) is placed by the same rule the server uses.
  *
- *   views      six views in order (Inbox, Today, Upcoming, Waiting, Someday, Review), each with its count; no Triage, Week, Later
+ *   views      seven views in order (Inbox, Today, Upcoming, Waiting, Someday, Review, Done), each with its count; no Triage, Week, Later
  *              lens; the right column is Focus on every view, with no Flow today (console3-deck-flow-fixes); no Jobs card, Group by job, ring or plan deck (console3-work-parity)
  *   one home   none of the decisions and approvals whose home is Briefing · Needs you is a Work row or Work text
  *   Focus      Today opens with up to three suggestions, each with the reason; Accept pins, Not today hides, Edit title saves, Unpin
@@ -12,6 +12,8 @@
  *              to a later day; Done takes a one-line outcome
  *   Upcoming   the next 7 days by day, then Later; a deferred item says "Not before …"
  *   Review     one at a time with progress: Keep, Change (the edit fields), Drop, then "Review done"
+ *   Done       the last 30 days by day (Today, Yesterday, …) with the outcome and how it closed; the badge counts today; Reopen puts an
+ *              item back in its view, with Undo, also an item that was done before the page opened (c3-work-agent amendment 18)
  *   capture    the preview chip names the view the line lands in, by the server's rule, and never Triage
  *   phone      at 390 wide every view draws with no horizontal scroll
  * The page must raise no script error. Every wait polls the page; no fixed sleep stands in for a state.
@@ -40,8 +42,8 @@ const finish = async (code) => {
 };
 process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
 
-const VIEWS = ['inbox', 'today', 'upcoming', 'waiting', 'someday', 'review'];
-const LABELS = ['Inbox', 'Today', 'Upcoming', 'Waiting', 'Someday', 'Review'];
+const VIEWS = ['inbox', 'today', 'upcoming', 'waiting', 'someday', 'review', 'done'];
+const LABELS = ['Inbox', 'Today', 'Upcoming', 'Waiting', 'Someday', 'Review', 'Done'];
 /* The decisions and approvals the demo used to list in Work (PRD R9): their home is Briefing · Needs you. */
 const DECISIONS = ['Approve pricing-page copy before handoff', 'Confirm the growth assumption in the Q4 forecast', 'Say yes to Sam: ship the logging change',
   'Self-serve onboarding: continue or park?', 'Pick interview slots with 3 customers', 'Assign owners to 2 unowned workshop actions',
@@ -91,9 +93,9 @@ const W = '[data-pm-work]';
   const readBar = () => st((w) => [...document.querySelectorAll(w + ' [data-pm-lenses] [data-lens]')].filter((b) => b.offsetParent !== null).map((b) => [b.getAttribute('data-lens'), b.textContent.replace(/\d+$/, '').trim()]), W);
   await until(async () => (await readBar()).length === VIEWS.length, 10000, 100);
   const bar = await readBar();
-  ok('the bar has the six views in order: Inbox, Today, Upcoming, Waiting, Someday, Review', JSON.stringify(bar.map((b) => b[0])) === JSON.stringify(VIEWS) && JSON.stringify(bar.map((b) => b[1])) === JSON.stringify(LABELS), JSON.stringify(bar));
+  ok('the bar has the seven views in order: Inbox, Today, Upcoming, Waiting, Someday, Review, Done', JSON.stringify(bar.map((b) => b[0])) === JSON.stringify(VIEWS) && JSON.stringify(bar.map((b) => b[1])) === JSON.stringify(LABELS), JSON.stringify(bar));
   const c0 = await counts();
-  ok('each view shows its count (3, 5, 6, 2, 2, 3)', JSON.stringify(VIEWS.map((v) => c0[v])) === '[3,5,6,2,2,3]', JSON.stringify(c0));
+  ok('each view shows its count (3, 5, 6, 2, 2, 3; Done counts today: 0)', JSON.stringify(VIEWS.map((v) => c0[v])) === '[3,5,6,2,2,3,0]', JSON.stringify(c0));
   ok('the page opens on Today', await st((w) => (document.querySelector(w + ' [data-pm-lens-head]') || {}).getAttribute && document.querySelector(w + ' [data-pm-lens-head]').getAttribute('data-pm-lens-head') === 'today', W));
   const text0 = await st((w) => document.querySelector(w).textContent, W);
   ok('no Triage, Week or Later view', !(await st((w) => !!document.querySelector(w + ' [data-lens="triage"], ' + w + ' [data-lens="week"], ' + w + ' [data-lens="later"]'), W)));
@@ -174,6 +176,28 @@ const W = '[data-pm-work]';
   if (sam) { await page.fill(W + ' ' + sam + ' [data-pm-outcome]', 'Booked for Tuesday 10:00'); await click(W + ' ' + sam + ' [data-pm-offline-done]'); }
   ok('Done with a one-line outcome closes an offline item', !!sam && !!await until(async () => !(await titles()).includes('Set up a meeting with Sam about the logging rollout') && (await counts()).upcoming === 6, 5000));
 
+  /* Done (c3-work-agent amendment 18): what the PM finished, by day, with how it closed; Reopen puts it back */
+  ok('the Done badge counts the items done today', !!await until(async () => (await counts()).done === 1, 5000), JSON.stringify(await counts()));
+  await view('done');
+  const doneRows = () => st((w) => [...document.querySelectorAll(w + ' [data-pm-list="done"]')].map((s) => [s.getAttribute('data-pm-sect'), [...s.querySelectorAll('[data-pm-done-item]')].map((r) => ({
+    t: (r.querySelector('[data-pm-title]') || {}).textContent, out: (r.querySelector('[data-pm-done-outcome]') || {}).textContent || '', how: (r.querySelector('[data-pm-done-how]') || {}).textContent || '',
+    at: (r.querySelector('[data-pm-done-at]') || {}).textContent || '', reopen: !!r.querySelector('[data-pm-reopen]') }))]), W);
+  const d0 = await doneRows();
+  ok('Done groups the items by day: Today (Sam, done just now) and Yesterday (the PRD)', JSON.stringify(d0.map((g) => [g[0], g[1].map((r) => r.t)])) === JSON.stringify([['today', ['Set up a meeting with Sam about the logging rollout']], ['yday', ['Send revised PRD to Dara']]]), JSON.stringify(d0));
+  const samD = d0.length ? d0[0][1][0] : {};
+  ok('…a row shows the outcome, how it closed, the time and Reopen', String(samD.out).trim() === 'Booked for Tuesday 10:00' && samD.how === 'You marked it done' && /^Done \d\d:\d\d$/.test(samD.at) && samD.reopen, JSON.stringify(samD));
+  ok('…an older row shows the day it was done', d0.length > 1 && /^Done (Tue|Wed) 7 Oct$/.test(d0[1][1][0].at), JSON.stringify(d0[1]));
+  ok('…with the summary line and the header', await st((w) => /^2 done in the last 7 days, 2 in 30 days\. Older items stay in their job's sheet\.$/.test((document.querySelector(w + ' [data-pm-done-sum]') || {}).textContent.trim()) && /What you finished/.test(document.querySelector(w + ' [data-pm-lens-head]').textContent), W));
+  await click(W + ' [data-pm-done-item] [data-pm-reopen]');
+  ok('Reopen says where the item went back to', !!await until(() => st(() => /Reopened\. It is back in Upcoming\./.test(document.body.textContent)), 4000));
+  ok('…and it leaves Done and is back in Upcoming', !!await until(async () => { const c = await counts(); return c.done === 0 && c.upcoming === 7; }, 5000), JSON.stringify(await counts()));
+  await toastUndo();
+  ok('…Undo marks it done again', !!await until(async () => (await counts()).done === 1, 5000), JSON.stringify(await counts()));
+  await click(W + ' [data-pm-sect="yday"] [data-pm-reopen]');
+  ok('Reopen works on an item done before the page opened', !!await until(async () => !(await doneRows()).some((g) => g[1].some((r) => r.t === 'Send revised PRD to Dara')), 5000), JSON.stringify(await doneRows()));
+  await toastUndo();
+  ok('…and Undo puts it back in Done', !!await until(async () => (await doneRows()).some((g) => g[1].some((r) => r.t === 'Send revised PRD to Dara')), 5000));
+
   /* the shared actions: Flag from the Inbox (R2) */
   await view('inbox');
   const tear = await open('Read the competitor pricing teardown');

package/workspace/doctor.js

@@ -167,7 +167,11 @@ function binaryArch(file) {
     } else {
       const want = pinned || D.DEFAULT_PORT;
       if (await free(want)) ok(`no server running; port ${want} is free (start it with: pmos)`);
-      else {
+      else if (D.busyServers(STATE, { heldPorts: [want] }).length) {
+        const b = D.busyServers(STATE, { heldPorts: [want] })[0];
+        bad(`the workspace server on port ${want} (pid ${b.pid}) is running but did not answer within 2s — it is busy`,
+          'wait a minute and run `pmos` again; if it still does not answer, run `pmos stop`, then `pmos`');
+      } else {
         const who = owner(want) || 'another program';
         bad(`no workspace server is answering, but port ${want} is held by ${who}`,
           pinned ? `stop that process, or pin a free port:  PMOS_WS_PORT=7500 pmos`

package/workspace/guide/my-work.md

@@ -69,7 +69,7 @@ Agenda shows one card, **N items need your brief**, when items wait in To brief.
 
 None of these briefs an agent or takes an item. Do that in My work.
 
-## The Work page: your work in six views
+## The Work page: your work in seven views
 
 The Work page holds all the work that is yours:
 
@@ -83,7 +83,7 @@ Every action works on these rows. The first action writes the item to your own l
 
 The server decides where each item shows, so one item is never in two views.
 
-The six views follow the OmniFocus style. The **Work** tab badge counts Inbox plus Today.
+The seven views follow the OmniFocus style. The **Work** tab badge counts Inbox plus Today.
 
 | View | What it holds |
 |---|---|
@@ -93,6 +93,7 @@ The six views follow the OmniFocus style. The **Work** tab badge counts Inbox pl
 | Waiting | Items where you wait for someone. The item that has waited longest comes first. |
 | Someday | Items you parked. They do not appear anywhere else. |
 | Review | Items in Inbox, Someday or Waiting that nobody touched for 7 days. The most stale item comes first. |
+| Done | Items you marked done in the last 30 days, newest first. Each one shows the outcome and how it closed. |
 
 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.
 
@@ -166,6 +167,10 @@ An offline item can carry evidence that it is done. PMOS looks at your calendar
 
 Review is a weekly pass. It shows one item at a time. Press **Keep** to leave the item as it is and clear it from the queue for 7 days. Press **Change** to edit it. Press **Drop** to remove it. Any change to an item also clears it from the queue.
 
+### Done
+
+Done lists the items you marked done in the last 30 days, in four cards: **Today**, **Yesterday**, **Earlier this week** and **Earlier, last 30 days**. Each row shows the outcome you wrote, when the item was done, and how it closed: you marked it done, you closed it from the agent draft, the agent posted it, the agent did the step you approved, or you confirmed it. Press **Reopen** to put the item back in its view. The badge on Done counts the items done today. Older items stay in their job's sheet.
+
 ### Link to a team task
 
 A Work item can link to the plan item it advances. The link shows on the item with the title of the plan item. Closing the plan item is a separate step, in the initiative.
@@ -176,7 +181,7 @@ A decision or an approval only you can make is not a Work item. It shows in Brie
 
 ## Using the Work page
 
-The Work page in the console has six views: **Inbox**, **Today**, **Upcoming**, **Waiting**, **Someday** and **Review**. Each view button shows how many items it holds.
+The Work page in the console has seven views: **Inbox**, **Today**, **Upcoming**, **Waiting**, **Someday**, **Review** and **Done**. Each view button shows how many items it holds. The Done button shows how many items you finished today.
 
 Each item is in one view only. The rule, in order: an item in Someday stays in Someday. An item that waits on a person is in Waiting. An item with a Not before date after today is in Upcoming. A flagged item is in Today. An item due today or earlier is in Today. An item due later is in Upcoming. An item with no date is in Inbox.
 

package/workspace/lib/pm-items.js

@@ -17,6 +17,8 @@ const fs = require('fs');
 const path = require('path');
 
 const UNDO_MS = 8000;
+/* How an item was closed (Work › Done): the PM marked it, the PM closed it from the agent draft, or the PM confirmed offline work. */
+const DONE_HOW = ['you', 'agent', 'confirmed'];
 const LISTS = ['waiting', 'today', 'week', 'triage', 'later'];
 const WORK_LISTS = ['inbox', 'today', 'upcoming', 'waiting', 'someday'];
 const REVIEW_DAYS = 7;
@@ -136,9 +138,9 @@ function fold(lines) {
     else if (ev.event === 'edited' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), ...ev.fields, touched_at: ev.at });
     else if (ev.event === 'done' && items.has(ev.id)) {
       const outcome = typeof ev.outcome === 'string' && ev.outcome.trim() ? { outcome: ev.outcome.trim() } : {};
-      items.set(ev.id, { ...items.get(ev.id), done: true, done_at: ev.at, touched_at: ev.at, ...outcome });
+      items.set(ev.id, { ...items.get(ev.id), done: true, done_at: ev.at, done_how: DONE_HOW.includes(ev.how) ? ev.how : 'you', touched_at: ev.at, ...outcome });
     }
-    else if (ev.event === 'reopened' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: false, done_at: null, touched_at: ev.at });
+    else if (ev.event === 'reopened' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: false, done_at: null, done_how: null, touched_at: ev.at });
     else if (ev.event === 'kept' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), touched_at: ev.at });
     else if (ev.event === 'dropped' || ev.event === 'deleted') items.delete(ev.id);
   }
@@ -177,4 +179,4 @@ function readLines(file) {
   return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } });
 }
 
-module.exports = { UNDO_MS, LISTS, WORK_LISTS, REVIEW_DAYS, workPlacement, sortWorkList, reviewQueue, arrivesOn, parseLine, placement, fold, removalEvent, undoEvent, canUndo, appendEvent, readLines };
+module.exports = { UNDO_MS, DONE_HOW, LISTS, WORK_LISTS, REVIEW_DAYS, workPlacement, sortWorkList, reviewQueue, arrivesOn, parseLine, placement, fold, removalEvent, undoEvent, canUndo, appendEvent, readLines };

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

@@ -13,7 +13,7 @@
  *                                              defer, flagged, resolves, kind, person, evidence, outcome
  *   POST /api/pm-items/remove { id }       → { ok, undo_ms }         deleted (created here) or dropped (imported)
  *   POST /api/pm-items/undo   { id }       → { ok, item } | 409      restores the last removal inside the 8 s window
- *   POST /api/pm-items/done   { id, outcome? } → { ok }              folds to item.done + done_at (+ outcome, one line);  /reopen undoes it
+ *   POST /api/pm-items/done   { id, outcome?, how? } → { ok }        folds to item.done + done_at (+ outcome, one line; + done_how: you|agent|confirmed);  /reopen undoes it
  *   POST /api/pm-items/park   { id }       → { ok }                  parked: true, placed in Later;  /unpark clears it
  *   POST /api/pm-items/flag   { id, flagged }       → { ok }         flagged: boolean; a flagged item is in Today
  *   POST /api/pm-items/defer  { id, until|null }    → { ok }         defer: not before that date (null clears); clears parked
@@ -193,7 +193,8 @@ function flagItem(body, itemLines, events) {
 function doneItem(b, l) {
   if (b.outcome !== undefined && b.outcome !== null && typeof b.outcome !== 'string') return { status: 400, body: { ok: false, error: 'outcome must be a string' } };
   const outcome = typeof b.outcome === 'string' && b.outcome.trim() ? { outcome: b.outcome.trim() } : {};
-  return flagItem(b, l, [{ event: 'done', id: b.id, ...outcome }]);
+  const how = pmItems.DONE_HOW.includes(b.how) ? { how: b.how } : {};   // how it closed, for Work › Done (c3-work-agent amendment 18)
+  return flagItem(b, l, [{ event: 'done', id: b.id, ...outcome, ...how }]);
 }
 const reopenItem = (b, l) => flagItem(b, l, [{ event: 'reopened', id: b.id }]);
 const parkItem = (b, l) => flagItem(b, l, [{ event: 'edited', id: b.id, fields: { parked: true, list_override: null } }]);

package/workspace/lib/server-discovery.js

@@ -102,6 +102,21 @@ function stalePidFiles(stateDir, { livePorts = [], alive = pidAlive } = {}) {
     .map((r) => r.file);
 }
 
+/**
+ * The workspace servers that are running but did not answer: a record whose port is not among the
+ * live ones, whose port is still held, and whose pid is alive. A busy server (a long synchronous job,
+ * or a slow first start on Windows) looks exactly like this. Reading it as "something else holds the
+ * port" is how `pmos` started a second server beside a first one that was only slow. `heldPorts` is
+ * injected (the caller owns the socket), so this stays pure.
+ */
+function busyServers(stateDir, { livePorts = [], heldPorts = [], alive = pidAlive } = {}) {
+  const live = new Set(livePorts.map(Number));
+  const held = new Set(heldPorts.map(Number));
+  return pidRecords(stateDir)
+    .filter((r) => !live.has(r.port) && held.has(r.port) && alive(r.pid))
+    .map((r) => ({ port: r.port, pid: r.pid }));
+}
+
 /**
  * The first port at or after `start` that `isFree` accepts, within the bounded span. `isFree` is
  * injected (the caller owns the socket), so this stays pure and the span is assertable.
@@ -123,5 +138,5 @@ function looksLikeWorkspace(body) {
 
 module.exports = {
   DEFAULT_PORT, FALLBACK_SPAN, PID_RE,
-  pidFileName, pidRecords, candidatePorts, pidAlive, stalePidFiles, nextFreePort, looksLikeWorkspace,
+  pidFileName, pidRecords, candidatePorts, pidAlive, stalePidFiles, busyServers, nextFreePort, looksLikeWorkspace,
 };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.231.0",
+  "version": "0.233.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-data.js

@@ -387,7 +387,7 @@ const W_KEYS = it('Payments sandbox keys', { waiting_on: 'Dara', due: '2026-10-0
 const W_LABEL = it('Annual-plan label', { waiting_on: 'Lee', due: '2026-10-07', job: 'j1', priority: 'P3', touched_at: at('2026-09-29') });
 const W_JIRA = it('Clean up the Checkout Jira labels', { parked: true, created_at: '2026-09-10T09:00:00.000Z', touched_at: at('2026-09-18') });
 const W_NOMEET = it('Try a no-meeting Wednesday', { parked: true, touched_at: at('2026-10-02') });
-/* done yesterday: counts in its job, never drawn */
+/* done yesterday: counts in its job, and Work › Done lists it under Yesterday */
 const W_PRD = it('Send revised PRD to Dara', { due: '2026-10-07', job: 'j1', done: true, done_at: '2026-10-07T17:10:00.000Z' });
 const ITEMS = [W_TIMELINE, W_QA, W_CALL, W_RISK, W_PAGER, W_SAM, W_SSO, W_NOTES, W_SALES, W_TAGS, W_Q1, W_TEAR, W_BOOK, W_IDEA, W_KEYS, W_LABEL, W_JIRA, W_NOMEET, W_PRD];
 /* Focus: up to three jobs for today, each with the reason (rules first: an overdue promise, an offline item due, a flag) */

package/workspace/public/pm/console3.css

@@ -2039,6 +2039,10 @@
 }
 
 .c3 .wk-sm{font-size:var(--fs-2)}
+/* Work › Done (c3-work-agent amendment 18): the outcome line under the title, and the summary above the groups */
+.c3 .wk-done-out{display:flex;align-items:center;gap:4px;color:var(--foreground);font-size:var(--fs-2)}
+.c3 .wk-done-out .ic{color:var(--muted-foreground)}
+.c3 .wk-done-sum{margin-bottom:12px}
 .c3 .wk-bar{appearance:none;-webkit-appearance:none;width:100%;height:8px;border:0;border-radius:6px;overflow:hidden;background:var(--muted)}
 .c3 .wk-bar::-webkit-progress-bar{background:var(--muted)}
 .c3 .wk-bar::-webkit-progress-value{background:var(--acc);border-radius:6px}

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

@@ -110,9 +110,11 @@ export function c3ib(label, icon, attrs, cls) {
 
 const API = '/api/pm-items';
 const JOBS = '/api/pm-jobs';
-/* The six views (initiative console3-work-page, PRD R1): five places an open item can be, and the weekly Review pass. */
-const LENSES = [['inbox', 'Inbox'], ['today', 'Today'], ['upcoming', 'Upcoming'], ['waiting', 'Waiting'], ['someday', 'Someday'], ['review', 'Review']];
-const WLI = { inbox: 'inbox', today: 'sun', upcoming: 'cal', waiting: 'wait', someday: 'moon', review: 'check' };
+/* The seven views (initiative console3-work-page, PRD R1): five places an open item can be, the weekly Review pass, and Done:
+ * what the PM finished in the last 30 days (c3-work-agent amendment 18). */
+const LENSES = [['inbox', 'Inbox'], ['today', 'Today'], ['upcoming', 'Upcoming'], ['waiting', 'Waiting'], ['someday', 'Someday'], ['review', 'Review'], ['done', 'Done']];
+const WLI = { inbox: 'inbox', today: 'sun', upcoming: 'cal', waiting: 'wait', someday: 'moon', review: 'check', done: 'todo' };
+const DONE_DAYS = 30;
 const WHO = ['you', 'agent-drafts', 'agent-does'];
 const OUTWARD = /\b(send|sends|sending|email|emails|message|messages|tell|post|reply to)\b/i; // mirrors lib/item-steps.js
 const RESOLVES_TIP = 'Your work. The team task is separate: close it in its initiative.';
@@ -135,6 +137,7 @@ export const COPY = Object.freeze({
   lens: {
     inbox: 'Decide when or whether', today: 'Overdue, due today and flagged', upcoming: 'The next 7 days, then anything later',
     waiting: 'Things you handed to someone', someday: 'Parked on purpose', review: 'A weekly pass over items without a date',
+    done: 'What you finished',
   },
   lensSub: {
     inbox: 'Nothing here has a date. Tap Decide to give each item a day, park it or drop it.',
@@ -143,6 +146,7 @@ export const COPY = Object.freeze({
     waiting: 'You expect these back. Nudge when one goes quiet.',
     someday: 'Nothing here asks for attention until the weekly Review.',
     review: 'Items in Inbox, Waiting or Someday that nobody touched for 7 days, most stale first. One at a time: keep it, change it, or drop it.',
+    done: 'The last 30 days, newest first, with the outcome you wrote. Reopen puts an item back where it was.',
   },
   sect: { inbox: 'Inbox', waiting: 'Waiting', someday: 'Someday', overdue: 'Overdue', dueToday: 'Due today', flagged: 'Flagged', next7: 'Next 7 days', later: 'Later' },
   decisions: (n) => ` ${n} decision${n === 1 ? '' : 's'} wait${n === 1 ? 's' : ''} in Briefing, Needs you.`, openBriefing: 'Open Briefing',
@@ -153,7 +157,13 @@ export const COPY = Object.freeze({
   emptyView: {
     inbox: 'Inbox is empty. Capture anything that crosses your mind.', today: 'Nothing due, overdue or flagged. Pick from Upcoming when you are ready.',
     upcoming: 'Nothing dated in the days ahead.', waiting: 'Nobody owes you anything right now.', someday: 'Nothing parked.',
+    done: 'Nothing done in the last 30 days. Items you mark done land here.',
   },
+  /* Done (c3-work-agent amendment 18) */
+  doneSum: (w, m) => `${w} done in the last 7 days, ${m} in 30 days. Older items stay in their job's sheet.`,
+  doneSect: { today: 'Today', yday: 'Yesterday', week: 'Earlier this week', older: 'Earlier, last 30 days' }, doneLegend: 'Reopen puts it back',
+  doneAt: (t) => 'Done ' + t, reopen: 'Reopen', backTo: (v) => 'Back to ' + v, reopened: (v) => `Reopened. It is back in ${v}.`,
+  how: { you: 'You marked it done', agent: 'Closed from the agent draft', posted: 'Agent posted it', step: 'Agent did the step you approved', confirmed: 'You confirmed it' },
   done: 'Done', doneToast: 'Marked done.', steps: 'Steps', noSteps: 'No steps yet.', addStep: 'Add a step',
   who: { you: 'You', 'agent-drafts': 'Agent drafts', 'agent-does': 'Agent does' },
   whoOutward: 'Sends to a person: the agent drafts, you slide to send.', options: 'Options', plan: 'Plan the steps',
@@ -194,8 +204,9 @@ function applyOv(base, ov) {
   const jobOfItem = {};
   const wasDone = new Set((d.items || []).filter((i) => i.done).map((i) => i.id));
   const items = [...ov.added.slice().reverse(), ...(d.items || [])].filter((i) => !ov.gone.has(i.id)).map((i) => {
-    const m = { ...i, ...(ov.edits.get(i.id) || {}) };
-    m.done = !!(i.done || ov.done.has(i.id));
+    const e = ov.edits.get(i.id) || {};
+    const m = { ...i, ...e };
+    m.done = e.done !== undefined ? !!e.done : !!(i.done || ov.done.has(i.id));   // a reopen (done: false) also reopens a fixture's done item
     m.steps = [...(i.steps || []), ...(ov.steps.get(i.id) || [])].map((s) => (ov.who.has(s.id) ? { ...s, who: ov.who.get(s.id) } : s));
     jobOfItem[m.id] = m.job;
     return m;
@@ -229,8 +240,8 @@ function applyLocal(inst, path, body, r) {
   const now = new Date().toISOString();
   const edit = (f) => ov.edits.set(id, { ...(ov.edits.get(id) || {}), ...(f || {}), touched_at: now });   // the server stamps touched_at on every event
   switch (path.replace(API, '').replace(JOBS, '/job')) {
-    case '/done': ov.done.add(id); edit(body.outcome ? { outcome: body.outcome } : {}); break;
-    case '/reopen': ov.done.delete(id); edit(); break;
+    case '/done': ov.done.add(id); edit({ done: true, done_at: new Date(today + 'T' + new Date().toTimeString().slice(0, 8)).toISOString(), done_how: body.how || 'you', ...(body.outcome ? { outcome: body.outcome } : {}) }); break;   // done_at: now, on the fixture's day
+    case '/reopen': ov.done.delete(id); edit({ done: false, done_at: null, done_how: null }); break;
     case '/park': case '/someday': edit({ parked: true }); break;
     case '/unpark': edit({ parked: false }); break;
     case '/edit': edit(body.fields); break;
@@ -362,7 +373,8 @@ const undoBy = (inst, route, body) => async () => !!(await press(inst, API + rou
 /* Does the change move the item out of the view on screen? Then its row leaves; otherwise it stays and redraws. */
 const leaves = (inst, item, patch) => inst.lens === 'review' || workPlace({ ...item, ...patch }, inst.data.today) !== inst.lens;
 
-const doneAct = (inst, item, row, text, outcome) => act(inst, row, { route: '/done', body: outcome ? { id: item.id, outcome } : { id: item.id }, text: text || COPY.doneToast, undo: undoBy(inst, '/reopen', { id: item.id }) });
+/* `how` says how it closed, for the Done view: 'you' (the default), 'agent' (from the agent draft) or 'confirmed' (offline work the PM confirmed). */
+const doneAct = (inst, item, row, text, outcome, how) => act(inst, row, { route: '/done', body: { id: item.id, ...(outcome ? { outcome } : {}), ...(how ? { how } : {}) }, text: text || COPY.doneToast, undo: undoBy(inst, '/reopen', { id: item.id }) });
 const dropAct = (inst, item, row) => act(inst, row, { route: '/remove', body: { id: item.id }, text: COPY.removed, undo: undoBy(inst, '/undo', { id: item.id }) });
 const todayAct = (inst, item, row) => act(inst, row, { route: '/edit', body: { id: item.id, fields: { due: inst.data.today, defer: null } }, text: 'In Today.',
   undo: undoBy(inst, '/edit', { id: item.id, fields: { due: item.due || null, defer: item.defer || null } }), leave: leaves(inst, item, { due: inst.data.today, defer: null }) });
@@ -490,7 +502,10 @@ function views(inst) {
   return { inbox: L.triage || [], today: L.today || [], upcoming: [...(L.week || []), ...(L.later || []).filter((i) => !i.parked)], waiting: L.waiting || [], someday: (L.later || []).filter((i) => i.parked) };
 }
 const shown = (inst, id) => ((id === 'review' ? (inst.data || {}).review : views(inst)[id]) || []).filter((i) => !inst.hidden.has(i.id) && !i.done);
-const countOf = (inst, id) => { const c = (inst.data || {}).counts; return c && typeof c[id] === 'number' ? c[id] : shown(inst, id).length; };
+const countOf = (inst, id) => {
+  if (id === 'done') return doneItems(inst).filter((i) => doneAgo(inst, i) <= 0).length;   // the Done badge: items done today
+  const c = (inst.data || {}).counts; return c && typeof c[id] === 'number' ? c[id] : shown(inst, id).length;
+};
 const itemById = (inst, id) => ((inst.data && inst.data.items) || []).find((i) => i.id === id)
   || [...VIEWS.map((v) => views(inst)[v] || []).flat(), ...((inst.data && inst.data.review) || [])].find((i) => i.id === id);
 /* The title of the team task a Work item advances (PRD R8): the item's own copy, then a map the answer may carry, else the id. */
@@ -589,7 +604,7 @@ function offlineBlock(inst, item) {
   return el('div', { class: 'wkoff', 'data-pm-offline': item.id },
     el('p', { class: 'wkoff-n' }, c3ic('user', 'sm'), COPY.offlineNote(item.person)),
     item.evidence ? el('div', { class: 'wkev', 'data-pm-evidence': item.id }, c3ic('eye', 'sm'), el('span', { class: 'wk-min' }, el('b', null, COPY.looksDone + ' '), item.evidence),
-      pill(COPY.confirm, 'check', { class: 'pill pri', 'data-pm-confirm': item.id, onclick: () => doneAct(inst, item, rowOf(inst, item), 'Done. You confirmed it.') })) : null,
+      pill(COPY.confirm, 'check', { class: 'pill pri', 'data-pm-confirm': item.id, onclick: () => doneAct(inst, item, rowOf(inst, item), 'Done. You confirmed it.', undefined, 'confirmed') })) : null,
     el('div', { class: 'wkq' }, el('span', { class: 'form wkoff-o' }, out), pill(COPY.done, 'check', { class: 'pill pri', 'data-pm-offline-done': item.id, onclick: doneNow })),
     el('div', { class: 'wkq' }, el('span', { class: 'dim mono' }, COPY.notYet),
       ...[['later-today', COPY.laterToday], ['tomorrow', COPY.tomorrow], ['next-week', COPY.nextWeek]].map(([w, l]) => pill(l, null, { 'data-pm-notyet': w, onclick: () => notYetAct(inst, item, rowOf(inst, item), w) })),
@@ -807,10 +822,10 @@ function agentCase(inst, item, L) {
       // a step in another system replaces the post: the approved send does the step (amendment 17)
       step ? o('step', AG.doIt(step), [fx('lock', AG.stepFx1, 'warn'), fx('out', AG.stepFx2, 'warn')], () => agentPress(inst, '/api/my-work/decide', { item: item.id, action: 'approve' }, AG.doing), { outward: true }) : null,
       mine || step ? null : 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 }),
-      mine ? o('done', AG.doneIt, [fx('check', AG.doneFx, 'ok')], (r) => doneAct(inst, item, r, AG.doneToast)) : null,
+      mine ? o('done', AG.doneIt, [fx('check', AG.doneFx, 'ok')], (r) => doneAct(inst, item, r, AG.doneToast, undefined, 'agent')) : null,
       o('edit', AG.editDraft, [fx('edit', step ? 'The step then uses your version' : mine ? 'Your version replaces the draft here' : 'Post then sends your version', 'ok')], () => openDraft(item, inst, true)),
       o('keep', AG.keepDraft, [fx('check', 'Nothing leaves PMOS', 'ok')], () => say({ text: mine ? AG.keptMine : AG.kept, timeout: 3000 })),
-      mine ? null : o('done', AG.doneIt, [fx('check', AG.doneFx, 'ok')], (r) => doneAct(inst, item, r, AG.doneToast)),
+      mine ? null : o('done', AG.doneIt, [fx('check', AG.doneFx, 'ok')], (r) => doneAct(inst, item, r, AG.doneToast, undefined, 'agent')),
     ].filter(Boolean);
     extras.push(draftCard(inst, item, k, false), conversation(inst, item, false, w));
     before = el('div', { class: 'wk-conv-h', 'data-pm-agent-decide': item.id }, el('span', { class: 'dim mono' }, c3ic('check', 'sm'), AG.orDecide));
@@ -1376,6 +1391,71 @@ function openNewJob(inst) {
   later(inst, () => input.focus(), 30);
 }
 
+/* ── Done (c3-work-agent amendment 18): what the PM finished in the last 30 days, by day, with how it closed and Reopen ── */
+
+const localDay = (iso) => { const d = new Date(iso); return Number.isNaN(d.getTime()) ? '' : d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); };
+/* Days between the day an item was done and today: 0 = today. */
+const doneAgo = (inst, i) => daysBetween(localDay(i.done_at), inst.data.today);
+function doneItems(inst) {
+  if (!inst.data) return [];
+  return (inst.data.items || []).filter((i) => i.done && i.done_at && localDay(i.done_at) && doneAgo(inst, i) <= DONE_DAYS && !inst.hidden.has(i.id))
+    .sort((a, b) => String(b.done_at).localeCompare(String(a.done_at)));
+}
+/* How it closed: what the agent did wins (it posted, or did the approved step), else what the done press said. */
+const DONE_HOW_IC = { you: 'check', agent: 'spark', posted: 'out', step: 'spark', confirmed: 'eye' };
+function howOf(item) {
+  const a = item.agent;
+  if (a && a.state === 'sent') return a.draft && a.draft.step ? 'step' : 'posted';
+  return DONE_HOW_IC[item.done_how] ? item.done_how : 'you';
+}
+
+function doneRow(inst, item) {
+  const today = inst.data.today;
+  const how = howOf(item);
+  const was = workPlace({ ...item, done: false }, today);
+  const chips = [el('span', { class: 'st ok', 'data-pm-done-at': item.id }, c3ic('check', 'sm'), COPY.doneAt(doneAgo(inst, item) <= 0 ? hhmm(item.done_at) : dayLabel(localDay(item.done_at)))),
+    el('span', { class: 'chip2', 'data-pm-done-how': how }, c3ic(DONE_HOW_IC[how], 'sm'), COPY.how[how])];
+  if (item.origin === 'jira' || item.origin === 'wbs') {
+    const label = (item.origin === 'jira' ? 'Jira ' + (item.key || '') : 'WBS' + (item.key ? ' ' + item.key : '')).trim();
+    chips.push(item.url ? el('a', { class: 'tag', href: item.url, target: '_blank', rel: 'noopener' }, label) : el('span', { class: 'tag' }, label));
+  } else if (item.origin === 'brief') chips.push(el('span', { class: 'tag' }, COPY.suggested));
+  if (item.kind === 'offline' && item.person) chips.push(el('span', { class: 'chip2' }, c3ic('user', 'sm'), item.person));
+  if (item.resolves) chips.push(el('span', { class: 'chip2', title: RESOLVES_TIP }, c3ic('init', 'sm'), resolvesTitle(inst, item)));
+  const row = el('li', { class: 'nrow wrow wk-done-row', 'data-pm-done-item': item.id });
+  const reopen = pill(COPY.reopen, 'undo', { 'data-pm-reopen': item.id, title: COPY.backTo(labelOf(was)),
+    onclick: (e) => { e.stopPropagation(); act(inst, row, { route: '/reopen', body: { id: item.id }, text: COPY.reopened(labelOf(was)), undo: undoBy(inst, '/done', { id: item.id, ...(item.done_how ? { how: item.done_how } : {}) }) }); } });
+  row.append(el('span', { class: 'ki' }, c3ic('check')),
+    el('div', { class: 'nb' }, el('span', { class: 'tt', 'data-pm-title': item.id }, item.title),
+      item.outcome ? el('div', { class: 'wk-done-out', 'data-pm-done-outcome': item.id }, c3ic('reply', 'sm'), item.outcome) : null,
+      el('div', { class: 'chips' }, chips)),
+    el('div', { class: 'acts' }, reopen));
+  return row;
+}
+
+function doneMain(inst) {
+  const all = doneItems(inst);
+  if (!all.length) {
+    const sec = sect(el('div', { class: 'sh2' }, el('h2', null, c3ic('todo', 'sm'), labelOf('done'), ' ', el('span', { class: 'bdg g' }, '0'))),
+      el('ul', { class: 'list' }, el('li', { class: 'fold', 'data-pm-done-empty': '' }, c3ic('check', 'sm'), COPY.emptyView.done)));
+    sec.setAttribute('data-pm-list', 'done');
+    return [sec];
+  }
+  const g = { today: [], yday: [], week: [], older: [] };
+  all.forEach((i) => { const n = doneAgo(inst, i); (n <= 0 ? g.today : n === 1 ? g.yday : n <= 7 ? g.week : g.older).push(i); });
+  const week = all.filter((i) => doneAgo(inst, i) <= 7).length;
+  const out = [el('div', { class: 'fold wk-done-sum', 'data-pm-done-sum': '' }, c3ic('check', 'sm'), COPY.doneSum(week, all.length))];
+  let first = true;
+  [['today', 'sun'], ['yday', 'clock'], ['week', 'cal'], ['older', 'moon']].filter(([k]) => g[k].length).forEach(([k, ic]) => {
+    const sec = sect(el('div', { class: 'sh2' }, el('h2', null, c3ic(ic, 'sm'), COPY.doneSect[k], ' ', el('span', { class: 'bdg g' }, String(g[k].length))),
+      first ? el('span', { class: 'dim wk-sm' }, COPY.doneLegend) : null),
+    el('ul', { class: 'list', role: 'list' }, g[k].map((i) => doneRow(inst, i))));
+    first = false;
+    sec.setAttribute('data-pm-list', 'done'); sec.setAttribute('data-pm-sect', k);
+    out.push(sec);
+  });
+  return out;
+}
+
 /* ── the page ────────────────────────────────────────────────────────────────────────────────────────────────────── */
 
 /* The mockup's workHead() calbar: the .seg view bar with a count on every view (line 3281). */
@@ -1436,6 +1516,7 @@ function draw(inst) {
   if (lens === 'review') main = [reviewMain(inst), inst.draftsHost];
   else if (lens === 'upcoming') main = upcomingMain(inst, list);
   else if (lens === 'today') main = todayMain(inst, list);
+  else if (lens === 'done') main = doneMain(inst);
   else {
     const sec = sect(el('div', { class: 'sh2' }, el('h2', null, c3ic(WLI[lens], 'sm'), COPY.sect[lens], ' ', el('span', { class: 'bdg g' }, String(list.length))), legendEl()),
       el('ul', { class: 'list', role: 'list' }, list.length ? list.map((i) => itemRow(inst, i, lens)) : empty));

package/workspace/test-lists/one-line-setup.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "one-line-setup: on Windows the background server hides the console window of every command it runs (lib/win-hide.js).",
-  "modules": ["win-hide.test.js"],
-  "seconds": { "win-hide.test.js": 1 }
+  "_comment": "one-line-setup: on Windows the background server hides the console window of every command it runs (lib/win-hide.js); `pmos` waits for its own busy server instead of starting a second one (busy-server.test.js).",
+  "modules": ["win-hide.test.js", "busy-server.test.js"],
+  "seconds": { "win-hide.test.js": 1, "busy-server.test.js": 12 }
 }