create-pmos 0.82.0 → 0.83.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.82.0",
+  "version": "0.83.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@a09f396
+kernel-source: pmos@9bf7ec5
 assembled: 2026-10-07
 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-07T15:34:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T16:01:13Z"}
 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-07T15:34:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T16:01:13Z"}
 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-07T15:34:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T16:01:13Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -50,9 +50,9 @@ The dock holds your terminals, documents, conversations, skills and web pages. I
 
 - Press ⌘J (Ctrl-J), or the button on the rail, to open the dock. Press ⌘J again, or the fold button in the dock, to fold it to the rail.
 - The dock never opens by itself. A tab that opens while the dock is a rail waits in the dock until you open it.
-- The dock lists the sessions of the repository by initiative. A session is in the group of the initiative it is recorded on, or of its `initiative/<id>` branch. Then come **Not linked** (no initiative) and **Scheduled** (started by a schedule). Then **Open** lists the tabs that are not sessions, for example documents and skills. Each one shows its title, what it is (for example PRD, Document or Web page) and its branch when it is not main. **✕** on an Open row closes the tab only. A terminal keeps running.
+- The dock lists the sessions of the repository by initiative. A session is in the group of the initiative it is recorded on, or of its `initiative/<id>` branch. Then come **Not linked** (no initiative) and **Automatic** (started by the workspace itself, for example by a schedule or the day run). **Automatic** is hidden until you press **Show automatic** at the foot of the list (or beside the group select in the strip). A session in front, or one that waits on you, is always shown. Finished automatic sessions remove themselves a minute after a clean exit, and one with no output for 60 minutes is ended and removed. A failed one stays. The setting is in `state/session-policy.json`: `finish` (true or false) and `idleMinutes` (5 or more, or 0 for off). Then **Open** lists the tabs that are not sessions, for example documents and skills. Each one shows its title, what it is (for example PRD, Document or Web page) and its branch when it is not main. **✕** on an Open row closes the tab only. A terminal keeps running.
 - Each session row starts with a mark for its state: ● working, ◼ quiet, ◆ needs you, ◇ maybe blocked, ○ ended. Under the name, the row shows the state when the session is not working, the type of work when one is set, and the branch when it is not main and not the initiative's own branch. Running sessions come first and ended sessions last. Press the row to bring the session to the front.
-- Press the name of a group to fold it or open it. The number beside it counts its sessions. **Scheduled** is folded while none of its runs is running, because each run leaves an ended session. The group of the session in front always stays open, and the workspace keeps your choice for each group.
+- Press the name of a group to fold it or open it. The number beside it counts its sessions. **Automatic** is folded while none of its sessions is running, because each run leaves an ended session. The group of the session in front always stays open, and the workspace keeps your choice for each group.
 - **⋯** and **✕** show on the row in front, on the row under the pointer and on the row with the keyboard focus. On a touch screen they always show.
 - Press **⋯** on a row to change the name, the initiative or the type of work.
 - Press **✕** on a row to end the session. The row asks "End “name”?". Press **End** or **Cancel**. When you end the last running session on its own working copy, the message offers **Remove working copy**. This removes the folder only. The branch stays. If the folder has unsaved work, the workspace keeps it and tells you why.

package/workspace/lib/session-origin.js

@@ -0,0 +1,65 @@
+/* lib/session-origin.js — which sessions the PM did not start, and when they may end themselves.
+ *
+ * Every session records an `origin` at spawn (null for one the PM opened). Some origins are the workspace acting on its
+ * own: a schedule firing, the day run's tasks and checks, a background read, a doc sync. Those sessions pile up in the list
+ * and, when the job is done, have nothing left to say. This module is the one place that names them and decides what may
+ * be done to them. Pure: the server passes in the rows and the clock, so the rules are testable without a server.
+ *
+ * Next step, Hand to agent, a skill draft and an alignment are NOT automatic: the PM pressed those, and often talks on.
+ */
+'use strict';
+
+const AUTOMATIC_EXACT = Object.freeze(['day-task', 'day-check', 'my-work-read', 'docs:sync', 'docs:check']);
+const AUTOMATIC_PREFIX = Object.freeze(['schedule:']);
+
+/** True when the workspace, not the PM, started a session with this origin. */
+function isAutomatic(origin) {
+  const o = String(origin || '');
+  if (!o) return false;
+  return AUTOMATIC_EXACT.includes(o) || AUTOMATIC_PREFIX.some((p) => o.startsWith(p));
+}
+
+const DEFAULT_POLICY = Object.freeze({ finish: true, idleMinutes: 60 });
+const FINISH_GRACE_MS = 60 * 1000;   // a finished job stays this long, so a PM watching it sees it end
+const IDLE_MIN = 5;
+const IDLE_MAX = 7 * 24 * 60;
+
+/** A stored or posted policy, made safe. Anything unusable falls back to the default for that key. idleMinutes 0 or null = off. */
+function normalizePolicy(raw) {
+  const r = raw && typeof raw === 'object' ? raw : {};
+  const finish = typeof r.finish === 'boolean' ? r.finish : DEFAULT_POLICY.finish;
+  let idle = DEFAULT_POLICY.idleMinutes;
+  if (r.idleMinutes === null || r.idleMinutes === 0) idle = null;
+  else if (typeof r.idleMinutes === 'number' && Number.isFinite(r.idleMinutes)) {
+    idle = Math.min(IDLE_MAX, Math.max(IDLE_MIN, Math.round(r.idleMinutes)));
+  }
+  return { finish, idleMinutes: idle };
+}
+
+/** Did the session end cleanly? The note the server writes on exit reads "exited (code 0)". Anything else is kept. */
+function endedCleanly(s) {
+  return /^exited \(code 0\)$/.test(String(s.note || '').trim());
+}
+
+/**
+ * What the sweep should do with one session row: 'remove' (it has ended and may go), 'end' (it is idle: stop it, and
+ * it is removed on a later sweep), or null (leave it).
+ * Row fields read: origin, state, shown, note, lastOutputAt, autoDelete ('never' opts one job out), autoEnded.
+ */
+function decide(s, policy, now) {
+  if (!s || !isAutomatic(s.origin) || s.autoDelete === 'never') return null;
+  const last = Number(s.lastOutputAt) || 0;
+  if (!last) return null;   // no clock for it (restored from disk): never guess an age
+  const age = now - last;
+  if (s.state === 'exited') {
+    if (!policy.finish && !s.autoEnded) return null;
+    if (!s.autoEnded && !endedCleanly(s)) return null;   // a failed job needs the PM's eye
+    return age >= FINISH_GRACE_MS ? 'remove' : null;
+  }
+  if (!policy.idleMinutes) return null;
+  // waiting on a person is not idle: the session is asking something
+  if (s.shown === 'needs' || s.shown === 'blocked') return null;
+  return age >= policy.idleMinutes * 60 * 1000 ? 'end' : null;
+}
+
+module.exports = { isAutomatic, normalizePolicy, decide, endedCleanly, DEFAULT_POLICY, FINISH_GRACE_MS, AUTOMATIC_EXACT, AUTOMATIC_PREFIX };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/components.css

@@ -2547,6 +2547,8 @@
     opacity: 1;
   }
 }
+.fr-ds-autobar { padding: 6px 8px; }
+.fr-ds-autotoggle[aria-pressed="true"] { color: var(--foreground); }
 .fr-ds-confirm {
   display: flex;
   flex-wrap: wrap;

package/workspace/public/pm/dock-sessions.js

@@ -4,7 +4,8 @@
  * working on which initiative, and ending a session, naming it or starting one on a branch took a trip to a separate sheet.
  * This module is the dock's list of the repository's SESSIONS:
  *
- *   railNodes(repo, otherRows)     the side list: one group per initiative, then "Not linked", then "Scheduled", then the
+ *   railNodes(repo, otherRows)     the side list: one group per initiative, then "Not linked", then "Automatic" (hidden unless
+ *                                  the PM shows it), then the
  *                                  open tabs that are not sessions (documents, skills, views) under "Open"
  *   stripNodes(repo, otherNodes)   the strip on top: a group select, the group's sessions as chips, ＋ and ✕
  *   listedSessionIds(repo)         the sessions the list shows, so the caller does not draw their tabs twice
@@ -12,7 +13,9 @@
  *                                  the one new-session sheet: name, initiative, where it runs, and how it starts
  *
  * The initiative of a session is the one it recorded (spawn or the PM's word), else the one its branch names
- * (initiative/<id>). A session started by a schedule is in "Scheduled" whatever it is for. Ending a session asks in the row;
+ * (initiative/<id>). A session the workspace started itself (a schedule, the day run, a doc sync: the server marks it
+ * `automatic`) is in "Automatic" whatever it is for, and that group is hidden until the PM turns on Show automatic; the
+ * session in front is always shown. The server also ends and removes finished or idle automatic sessions (lib/session-origin.js). Ending a session asks in the row;
  * when it was the last live session on its own working copy, the toast offers to remove that copy (the branch is kept; the
  * server refuses unsaved work and says why). Live mode only.
  */
@@ -63,28 +66,51 @@ function sessionsOfRepo(repo, trees) {
   return (Array.isArray(state.sessions) ? state.sessions : []).filter((s) => s && in_.has(s.ws));
 }
 
-/** [{ key, title, initiative, scheduled, sessions }]: initiatives in board order, then Not linked, then Scheduled. */
-export function groupsOf(repo) {
+const isAuto = (s) => !!(s && (s.automatic || String(s.origin || '').startsWith('schedule:')));
+
+/** Every automatic session of the repository, shown or not. */
+export function automaticSessions(repo) {
+  return sessionsOfRepo(repo, treesOf(repo)).filter(isAuto);
+}
+
+/** [{ key, title, initiative, automatic, sessions }]: initiatives in board order, then Not linked, then Automatic when shown. */
+export function groupsOf(repo, { all = false } = {}) {
   const trees = treesOf(repo);
   const order = ((boardOf() || {})[repo] || []).flatMap((g) => g.slugs || []);
   const rank = (slug) => { const i = order.indexOf(slug); return i < 0 ? order.length : i; };
   const by = new Map(); const none = []; const sched = [];
   for (const s of sessionsOfRepo(repo, trees)) {
-    if (String(s.origin || '').startsWith('schedule:')) { sched.push(s); continue; }
+    if (isAuto(s)) { sched.push(s); continue; }
     const i = initiativeOf(s, trees);
     if (!i) { none.push(s); continue; }
     if (!by.has(i)) by.set(i, []);
     by.get(i).push(s);
   }
   const out = [...by.keys()].sort((a, b) => rank(a) - rank(b) || a.localeCompare(b))
-    .map((i) => ({ key: 'i:' + i, title: titleOf(i), initiative: i, scheduled: false, sessions: by.get(i) }));
-  if (none.length) out.push({ key: 'none', title: C().notLinked, initiative: null, scheduled: false, sessions: none });
-  if (sched.length) out.push({ key: 'sched', title: C().scheduled, initiative: null, scheduled: true, sessions: sched });
+    .map((i) => ({ key: 'i:' + i, title: titleOf(i), initiative: i, automatic: false, sessions: by.get(i) }));
+  if (none.length) out.push({ key: 'none', title: C().notLinked, initiative: null, automatic: false, sessions: none });
+  // hidden by default; the session in front is never hidden, and neither is one that is waiting on the PM
+  const front = frontSessionId();
+  const show = all || state.dsShowAuto || sched.some((s) => s.id === front || s.shown === 'needs' || s.shown === 'blocked');
+  if (sched.length && show) out.push({ key: 'auto', title: C().automatic, initiative: null, automatic: true, sessions: sched });
   return out;
 }
 
+/** Ids the list owns, shown or hidden, so the caller does not draw a hidden session's tab under "Open". */
 export function listedSessionIds(repo) {
-  return new Set(groupsOf(repo).flatMap((g) => g.sessions.map((s) => s.id)));
+  return new Set(groupsOf(repo, { all: true }).flatMap((g) => g.sessions.map((s) => s.id)));
+}
+
+function setShowAuto(on) { setState({ dsShowAuto: !!on }); }
+
+/** The Show automatic switch, or '' when the repository has no automatic sessions. `compact` drops the count into the title. */
+function autoToggle(repo, cls) {
+  const n = automaticSessions(repo).length;
+  if (!n) return '';
+  const on = !!state.dsShowAuto;
+  return button({ label: on ? C().hideAuto : C().showAuto(n), variant: 'ghost', size: 'sm', icon: 'bot',
+    onClick: () => setShowAuto(!on),
+    attrs: { class: cls, 'data-ds': 'auto-toggle', 'aria-pressed': on ? 'true' : 'false', title: C().autoHint } });
 }
 
 const frontTab = () => (state.tabs || []).find((t) => t.id === state.active) || null;
@@ -337,7 +363,22 @@ function sessionRow(repo, s, trees, front) {
 export function groupFolded(g) {
   const m = state.dsFolded || {};
   if (Object.prototype.hasOwnProperty.call(m, g.key)) return !!m[g.key];
-  return !!g.scheduled && g.sessions.every(isEnded);
+  return !!g.automatic && g.sessions.every(isEnded);
+}
+
+/** Remove every ended session of the Automatic group in one press (the server also does this on its own for clean exits). */
+function clearEndedButton(g) {
+  const ended = g.sessions.filter(isEnded);
+  if (!ended.length) return '';
+  return iconButton({ icon: 'x', ariaLabel: C().clearEnded(ended.length), size: 'sm', attrs: { 'data-ds': 'auto-clear', class: 'fr-ds-head__new' },
+    onClick: async () => {
+      if (!dataMod) return;
+      const tabIds = ended.flatMap((s) => (tabsMod && typeof tabsMod.tabIdsOfSession === 'function' ? tabsMod.tabIdsOfSession(s.id) : []));
+      let n = 0;
+      for (const s of ended) { const o = await dataMod.removeSessionById(s.id); if (o && o.ok !== false && o.removed !== false) n += 1; }
+      if (tabsMod && typeof tabsMod.closeTabsById === 'function') tabsMod.closeTabsById(tabIds);
+      toast({ text: C().clearedEnded(n) });
+    } });
 }
 
 function groupHead(repo, g, folded) {
@@ -352,7 +393,7 @@ function groupHead(repo, g, folded) {
   return el('div', { class: 'fr-ds-head', 'data-ds-group': g.key },
     toggle,
     el('span', { class: 'fr-ds-head__count', 'aria-hidden': 'true' }, count),
-    g.scheduled ? '' : iconButton({ icon: 'plus', ariaLabel: g.initiative ? C().newFor(g.title) : C().newTitle, size: 'sm',
+    g.automatic ? clearEndedButton(g) : iconButton({ icon: 'plus', ariaLabel: g.initiative ? C().newFor(g.title) : C().newTitle, size: 'sm',
       onClick: () => openNewSessionSheet(repo, { initiative: g.initiative }), attrs: { 'data-ds': 'group-new', class: 'fr-ds-head__new' } }));
 }
 
@@ -375,7 +416,9 @@ export function railNodes(repo, otherRows) {
       el('div', { class: 'fr-ds-head fr-ds-head--plain' }, el('h3', { class: 'fr-ds-head__title' }, C().openTabs),
         el('span', { class: 'fr-ds-head__count', 'aria-hidden': 'true' }, String(otherRows.length))), ...otherRows));
   }
-  if (!groups.length && !(otherRows && otherRows.length)) out.push(el('p', { class: 'fr-ds-note' }, C().none));
+  const sw = autoToggle(repo, 'fr-ds-autotoggle');
+  if (sw) out.push(el('div', { class: 'fr-ds-autobar' }, sw));
+  if (!groups.length && !sw && !(otherRows && otherRows.length)) out.push(el('p', { class: 'fr-ds-note' }, C().none));
   return out;
 }
 
@@ -407,6 +450,7 @@ export function stripNodes(repo, otherNodes) {
         attrs: { class: 'fr-ds-chip', 'data-ds-session': s.id, 'aria-pressed': on ? 'true' : 'false', title: s.name + ' · ' + metaOf(s, trees) } }));
     }
   } else if (g) out.push(...otherNodes);
+  out.push(autoToggle(repo, 'fr-ds-tool'));
   out.push(iconButton({ icon: 'plus', ariaLabel: g && g.initiative ? C().newFor(g.title) : C().newTitle,
     onClick: () => openNewSessionSheet(repo, { initiative: g && g.initiative }), attrs: { 'data-ds': 'strip-new', 'data-fr': 'session', class: 'fr-ds-push' } }));
   out.push(iconButton({ icon: 'x', ariaLabel: C().endFront, attrs: { 'data-ds': 'strip-end', class: 'fr-ds-tool' }, onClick: () => {

package/workspace/public/pm/frame-copy.js

@@ -76,7 +76,12 @@ export const COPY = {
     openTab: (title, what) => 'Open ' + title + ' · ' + what,
     ds: {
       notLinked: 'Not linked',
-      scheduled: 'Scheduled',
+      automatic: 'Automatic',
+      showAuto: (n) => 'Show automatic (' + n + ')',
+      hideAuto: 'Hide automatic',
+      autoHint: 'Sessions the workspace started itself (schedules, the day run, doc sync). Finished or idle ones remove themselves.',
+      clearEnded: (n) => 'Remove ' + n + ' ended automatic session' + (n === 1 ? '' : 's'),
+      clearedEnded: (n) => 'Removed ' + n + ' automatic session' + (n === 1 ? '' : 's') + '.',
       openTabs: 'Open',
       none: 'No sessions yet. Press Session to start one.',
       group: 'Show the sessions of',

package/workspace/public/pm/state.js

@@ -129,6 +129,7 @@ function initialBase() {
     newSessIsolate: null, newSessError: null, newSessBusy: false,
     newSessBranches: null, preflightProfile: null, profiles: null, branchInfo: null,
     col0: true, col1: true, col2: true, scratchOpen: false, scratchText: '', copied: false,
+    dsShowAuto: false,          // show the dock's Automatic group (sessions the workspace started itself) — persisted
     dsFolded: {},               // the dock's session groups the PM folded (true) or opened (false), by group key — persisted
     tabsVertical: false,        // the cockpit's tabs as a vertical list instead of a strip — persisted, per browser
     /* The scratchpad drawer's height in px (panel-tabs.js). 96 is the prototype's literal and stays
@@ -240,6 +241,7 @@ const PERSIST = {
   // the cockpit's tabs as a vertical list (true) or the horizontal strip (false, the default)
   tabsVertical: isBool,
   // the dock's session groups, folded (true) or open (false) by the PM; a group with no entry takes its default
+  dsShowAuto: isBool,
   dsFolded: isFlagMap,
   /* A restored height is re-validated on the way IN, not merely on the way out: a corrupted or
    * hand-edited record must not be able to render a drawer with no textarea in it, or one taller

package/workspace/server.js

@@ -69,6 +69,7 @@ ensureSpawnHelperExecutable();
 const { checkSurface } = require('./lib/surface-contract');
 const { createSinkGuard } = require('./lib/sink.js');
 const tsSettings = require('./lib/typesafe-settings.js');
+const sessionOrigin = require('./lib/session-origin');   // which sessions the workspace started itself, and when they may end (workspace-auto-sessions)
 const sessionFlag = require('./lib/session-flag');   // PMOS_WORKSPACE=1 in each agent terminal (cockpit mod, M12)
 const tsClient = require('./lib/typesafe.js');
 const jevRoute = require('./lib/jev-route.js');     // prompt-model-routing — the bridge between prompt routing and the one TypeSafe module
@@ -2490,6 +2491,8 @@ function persist(s) {
   // so a session survives even if the workspace registry is lost (it re-registers its root).
   const meta = { id: s.id, ws: s.ws, root: s.root, name: s.name, agent: s.agent, cwd: s.cwd,
     state: s.state, note: s.note || '', created: s.created, tmux: s.tmux || null, origin: s.origin || null };
+  if (s.autoDelete) meta.autoDelete = s.autoDelete;
+  if (s.autoEnded) meta.autoEnded = true;
   // The breakdown item a Hand to agent session is bound to, so a restart keeps the binding (pm-os-absorb Run 1).
   if (s.plan_item) meta.plan_item = s.plan_item;
   // pm-os-absorb Run 2 (R25): the SHA-256 of the agent's PMOS_SESSION token, never the token (D08). A restored session
@@ -2570,6 +2573,7 @@ function restorePersisted() {
       const s = {
         ...meta, ws: w ? w.id : wsId(SELF_ROOT), root: w ? w.root : SELF_ROOT,
         pty: null, buf, tmux: meta.tmux || null, cols: 80, rows: 24, clients: new Set(),
+        lastOutputAt: Date.now(),   // a restored session's idle clock starts at boot, never from a missing value
       };
       sessions.set(meta.id, s);
       if (TMUX && meta.tmux && tmuxHasSession(meta.tmux)) {
@@ -2765,6 +2769,8 @@ function sessionList() {
       id: s.id, ws: s.ws, name: s.name, agent: s.agent, state: s.state, created: s.created,
       model: 'model' in s ? s.model : null, model_line: modelLib.line('model' in s ? s.model : null),
       cwd: path.relative(s.root, s.cwd) || '.', note: s.note || '', origin: s.origin || null,
+      automatic: sessionOrigin.isAutomatic(s.origin),   // the workspace started it, not the PM: the dock hides these by default
+      auto_delete: s.autoDelete || null,
       plan_item: s.plan_item || null,   // Hand to agent: the breakdown item this session is bound to (pm-os-absorb Run 1)
       // No `token` and no `tokenHash` here, ever: the page never sees a session token (F5; r25-guards.test.js checks it).
       // Derived presentation state, JOINED from both sources: the cadence clock above and the
@@ -2861,6 +2867,41 @@ function heartbeat() {
 }
 try { const _hb = setInterval(heartbeat, LIVENESS_MS); if (_hb.unref) _hb.unref(); } catch {}
 
+// ── Clean-up of sessions the workspace started itself (workspace-auto-sessions). ─────────────────
+// Only AUTOMATIC origins (lib/session-origin.js) are ever touched; a session the PM started is never ended or removed here.
+// The policy is a small file the PM can change through /api/session/policy; unreadable or absent means the defaults.
+const SESSION_POLICY_FILE = () => path.join(STATE, 'session-policy.json');
+function readSessionPolicy() {
+  let raw = null;
+  try { raw = JSON.parse(fs.readFileSync(SESSION_POLICY_FILE(), 'utf8')); } catch { raw = null; }
+  return sessionOrigin.normalizePolicy(raw);
+}
+function sweepAutomaticSessions(now = Date.now()) {
+  const policy = readSessionPolicy();
+  const done = { ended: [], removed: [] };
+  for (const s of [...sessions.values()]) {
+    const act = sessionOrigin.decide({ ...s, shown: sessionShown(s, now) }, policy, now);
+    if (act === 'end' && s.pty) {
+      s.autoEnded = true; s.note = 'ended: idle too long (automatic session)';
+      if (s.tmux) tmuxKillSession(s.tmux);
+      try { s.pty.kill(); } catch {}
+      done.ended.push(s.id);
+    } else if (act === 'remove' && !s.pty) {
+      if (removeSession(s.id)) done.removed.push(s.id);
+    }
+  }
+  return done;
+}
+// The presented state ('needs' = waiting on the PM) for one session, the same join the list uses.
+function sessionShown(s, now) {
+  try {
+    const d = harness.deriveState(s.state, s.lastOutputAt, now);
+    const hx = transcriptHarness(s);
+    return sessionState.presented(d.state, hx && hx.turn);
+  } catch { return null; }
+}
+try { const _sw = setInterval(() => { try { sweepAutomaticSessions(); } catch {} }, Number(process.env.PMOS_SESSION_SWEEP_MS || 30000)); if (_sw.unref) _sw.unref(); } catch {}
+
 // Trim the ring from the FRONT at a LINE boundary. A blind slice cuts wherever the byte count
 // lands — which is routinely INSIDE an escape sequence, and the truncated tail then replays as
 // literal rubble ("5;203m") the next time a client attaches and we write the buffer to xterm.js;
@@ -3249,7 +3290,7 @@ function sendToSession(id, text) {
   try { firstInput.deliver(s, safeFirstInput(t) + '\r'); return true; } catch { return false; }
 }
 
-function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, initiative, modelAsk, planItem, workType }) {
+function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, initiative, modelAsk, planItem, workType, autoDelete }) {
   const id = nextSessionId();
   /* pm-os-absorb Run 1 — every AGENT session gets a token, `<id>.<8 hex>`, in its environment as PMOS_SESSION, and
    * PMOS_BIN, this workspace's own bin/pmos.js. `pmos item` run inside it is then attributed `agent:<token>` (the token
@@ -3297,6 +3338,8 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
   // Hand to agent: the breakdown item this session was started for, or null. Set only by /api/plan-items/handoff/go.
   base.plan_item = planItem || null;
   base.token = sessionToken;
+  // 'never' opts this one job out of the automatic clean-up (lib/session-origin.js); anything else is the workspace policy.
+  if (autoDelete === 'never') base.autoDelete = 'never';
   const wt = workTypeOrNull(workType);
   if (wt) base.workType = wt;
 
@@ -5591,6 +5634,16 @@ async function handleRequest(req, res) {
     const out = createBranchOnly({ ws: body.ws, name: body.name, from: body.from || null, worktree: body.worktree !== false });
     return json(res, out, out.ok ? 200 : 400);
   }
+  if (p === '/api/session/policy' && (req.method === 'GET' || req.method === 'POST')) {
+    if (req.method === 'POST') {
+      let body = {};
+      try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+      const next = sessionOrigin.normalizePolicy({ ...readSessionPolicy(), ...body });
+      fs.mkdirSync(STATE, { recursive: true });
+      fs.writeFileSync(SESSION_POLICY_FILE(), JSON.stringify(next, null, 2) + '\n');
+    }
+    return json(res, { ok: true, policy: readSessionPolicy(), automatic_origins: [...sessionOrigin.AUTOMATIC_EXACT, ...sessionOrigin.AUTOMATIC_PREFIX.map((x) => x + '*')] });
+  }
   // End a session and remove it, with an answer. The WebSocket kill/remove messages return nothing,
   // so a refusal or a slow exit left the PM clicking a control that seemed to do nothing.
   if (p === '/api/session/remove' && req.method === 'POST') {

package/workspace/test-files.json

@@ -43,6 +43,7 @@
     "proactive-prepare.test.js",
     "learn.test.js",
     "session-flag.test.js",
+    "session-origin.test.js",
     "live-notes.test.js",
     "plan-items.test.js",
     "plan-tree.test.js",
@@ -144,6 +145,7 @@
     "proactive-prepare.test.js": 9,
     "learn.test.js": 3,
     "session-flag.test.js": 1,
+    "session-origin.test.js": 1,
     "live-notes.test.js": 3,
     "pm-shell-test.js": 6,
     "pm-repos-test.js": 3,