create-pmos 0.54.0 → 0.55.0

package/workspace/lib/day-run.js

@@ -0,0 +1,297 @@
+'use strict';
+/* day-run.js — the day run behind "Prepare my day" (initiative `today-goals`, PRD G13, G14, G21, G22).
+ *
+ * The PM's press of "Prepare my day" records a run for the local day and starts the morning-brief session. When the
+ * brief arrives, every agent-owned priority the agent may work on becomes a task. The workspace starts one session per
+ * task, at most 5 at once. A task session submits ONE draft and sends nothing. The PM then approves the draft, or
+ * revises it with a note (at most 3 times). Approving an `approve` task starts one more session that does exactly the
+ * approved outward step and reports it sent. An `auto` task is done when its draft arrives. In the working hours a
+ * check session reads what changed and merges it into the brief.
+ *
+ * PURE: no require at all — no file, process, network or clock of its own. The server reads goals/<date>.run.json,
+ * passes it in with `now`, starts the sessions this module names, and writes what an edit returns. Every edit returns
+ * a NEW record ({ ok:true, run, ... }) or the reason it is refused ({ ok:false, error }); a refusal changes nothing.
+ *
+ *   newRun(date, now) · readRun(raw, date)
+ *   addTasks(run, brief)                       agent priorities (kind approve|auto) → waiting tasks
+ *   toStart(run, limit)                        the tasks to start now, each with its mode (do | revise | send)
+ *   started · deliver · decide · sent · fail · sessionEnded
+ *   stage(run, brief)                          reading | working | review | done
+ *   checkDue(run, {settings, now, events}) · checkStarted · checkDone
+ *
+ * Status of a task:  waiting → working → review (approve) | done (auto)
+ *                    review --approve--> sending → sent        review|done --revise--> waiting (with the note)
+ *                    working|sending --fail or session ended--> failed --retry--> waiting
+ */
+
+const MAX_PARALLEL = 5;
+const MAX_REVISIONS = 3;
+const MAX_CHECK_LOG = 20;
+const MAX_INTERVAL_MIN = 120;
+const BEFORE_MEETING_MIN = 15;
+const STATUSES = ['waiting', 'working', 'review', 'sending', 'sent', 'done', 'failed'];
+const KINDS = ['approve', 'auto'];
+const ACTIONS = ['approve', 'revise', 'retry'];
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const TASK_RE = /^t-[0-9a-f]{12}$/;
+const MIN = 60000;
+
+const iso = (ms) => new Date(ms).toISOString();
+const clone = (x) => JSON.parse(JSON.stringify(x));
+const isUrl = (v) => typeof v === 'string' && v.length <= 500 && /^https?:\/\/\S+$/.test(v);
+const text = (v) => (typeof v === 'string' ? v.trim() : '');
+const pad = (n) => String(n).padStart(2, '0');
+const localDate = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+/** ms of HH:MM on the local day of `ms`. */
+const atClock = (ms, hhmm) => { const d = new Date(ms); const [h, m] = String(hhmm).split(':').map(Number); return new Date(d.getFullYear(), d.getMonth(), d.getDate(), h, m).getTime(); };
+
+function emptyChecks() { return { session_id: null, last: null, next: null, empty_streak: 0, log: [] }; }
+
+function newRun(date, now) {
+  return { date, started_at: iso(now), brief_session: null, tasks: [], checks: emptyChecks() };
+}
+
+/** A run record read from disk, checked. Anything that is not a run for `date` reads as null (no run). */
+function readRun(raw, date) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw) || raw.date !== date || !DATE_RE.test(String(date))) return null;
+  if (typeof raw.started_at !== 'string' || Number.isNaN(Date.parse(raw.started_at)) || !Array.isArray(raw.tasks)) return null;
+  const run = clone(raw);
+  const bs = run.brief_session;
+  run.brief_session = bs && typeof bs === 'object' && typeof bs.id === 'string' ? { id: bs.id, started_at: bs.started_at || null, ended_at: bs.ended_at || null } : null;
+  run.tasks = run.tasks.filter((t) => t && typeof t === 'object' && TASK_RE.test(t.id) && STATUSES.includes(t.status) && KINDS.includes(t.kind))
+    .map((t) => ({ ...t, attempts: Number.isInteger(t.attempts) ? t.attempts : 0, revisions: Array.isArray(t.revisions) ? t.revisions : [],
+      draft: t.draft || null, decided: t.decided || null, error: t.error || null, session_id: t.session_id || null, started_at: t.started_at || null }));
+  const c = run.checks && typeof run.checks === 'object' ? run.checks : {};
+  run.checks = { session_id: c.session_id || null, last: c.last || null, next: c.next || null,
+    empty_streak: Number.isInteger(c.empty_streak) && c.empty_streak >= 0 ? c.empty_streak : 0, log: Array.isArray(c.log) ? c.log.slice(-MAX_CHECK_LOG) : [] };
+  return run;
+}
+
+const findTask = (run, id) => (run && Array.isArray(run.tasks) ? run.tasks.find((t) => t.id === id) || null : null);
+
+/** The mode a task's session runs in: `send` for an approved draft, `revise` when the PM sent it back with a note. */
+function modeOf(t) {
+  if (t.status === 'sending') return 'send';
+  return t.revisions.length && t.draft ? 'revise' : 'do';
+}
+
+/** Edit one task of a copy of the run; `fn` returns an error string to refuse, or nothing. */
+function withTask(run, taskId, fn) {
+  if (!run) return { ok: false, error: 'no day run today — press Prepare my day first' };
+  const next = clone(run);
+  const t = findTask(next, taskId);
+  if (!t) return { ok: false, error: `no task ${taskId} in today's run` };
+  const err = fn(t, next);
+  if (err) return { ok: false, error: err };
+  return { ok: true, run: next, task: t };
+}
+
+/**
+ * Every priority the agent owns and may work on (kind approve or auto) becomes a waiting task, once. A brief for
+ * another day adds nothing. An item the PM owns, a `you` item and a worth-asking item never become tasks.
+ */
+function addTasks(run, brief) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  const next = clone(run);
+  const added = [];
+  if (!brief || brief.date !== run.date) return { ok: true, run: next, added };
+  for (const x of brief.priorities || []) {
+    const kind = x.kind || (x.owner === 'agent' ? 'approve' : 'you');
+    if (x.owner !== 'agent' || !KINDS.includes(kind)) continue;
+    const id = 't-' + x.id;
+    if (findTask(next, id)) continue;
+    next.tasks.push({ id, item_id: x.id, title: x.title, kind, source: x.source, link: x.link || null, goal: x.goal || null,
+      status: 'waiting', session_id: null, started_at: null, attempts: 0, revisions: [], draft: null, decided: null, error: null });
+    added.push(id);
+  }
+  return { ok: true, run: next, added };
+}
+
+/**
+ * The tasks to start now, oldest first, so that the sessions running (working, and sending with a session) stay at
+ * most `limit`. An approved task waiting for its send session comes first: the PM is waiting on it.
+ * @returns {Array<object>} copies of the tasks, each with its `mode`
+ */
+function toStart(run, limit = MAX_PARALLEL) {
+  if (!run) return [];
+  const busy = run.tasks.filter((t) => t.status === 'working' || (t.status === 'sending' && t.session_id)).length;
+  const free = Math.max(0, limit - busy);
+  const ready = [...run.tasks.filter((t) => t.status === 'sending' && !t.session_id), ...run.tasks.filter((t) => t.status === 'waiting')];
+  return ready.slice(0, free).map((t) => ({ ...clone(t), mode: modeOf(t) }));
+}
+
+/** A session was started for the task. `sessionId` is null when the start failed (the caller then calls fail). */
+function started(run, taskId, sessionId, now) {
+  return withTask(run, taskId, (t) => {
+    if (t.status === 'waiting') { t.status = 'working'; t.attempts += 1; }
+    else if (t.status === 'sending' && !t.session_id) { /* the approved outward step */ }
+    else return `task ${taskId} is ${t.status} — only a waiting or an approved task can start`;
+    t.session_id = sessionId || null; t.started_at = iso(now); t.error = null;
+    return null;
+  });
+}
+
+/** The task session's ONE draft. An `auto` task is then done; an `approve` task waits for the PM. */
+function deliver(run, taskId, d, now) {
+  return withTask(run, taskId, (t) => {
+    if (t.status !== 'working') return `task ${taskId} is ${t.status} — only a working task can deliver a draft`;
+    const b = d && typeof d === 'object' ? d : {};
+    const summary = text(b.summary); const body = typeof b.body === 'string' ? b.body.trim() : '';
+    if (!summary) return 'a draft needs a summary';
+    if (summary.length > 240) return 'the summary is over 240 characters';
+    if (!body) return 'a draft needs a body';
+    if (body.length > 8000) return 'the body is over 8000 characters';
+    if (b.link !== undefined && b.link !== null && b.link !== '' && !isUrl(b.link)) return 'the link must be an http(s) address of at most 500 characters';
+    t.draft = { summary, body, link: b.link || null, at: iso(now) };
+    t.status = t.kind === 'auto' ? 'done' : 'review';
+    t.error = null;
+    return null;
+  });
+}
+
+/**
+ * The PM's decision on a draft.
+ *   approve  review (approve task) → sending: a session will do exactly the approved step. done (auto task) → recorded.
+ *   revise   review or done, with a note of 1 to 500 characters, at most 3 times → waiting (the next session revises).
+ *   retry    failed → waiting.
+ */
+function decide(run, taskId, op, now) {
+  const o = op && typeof op === 'object' ? op : {};
+  if (!ACTIONS.includes(o.action)) return { ok: false, error: `action must be one of ${ACTIONS.join(', ')}` };
+  const note = text(o.note);
+  return withTask(run, taskId, (t) => {
+    const at = iso(now);
+    if (o.action === 'approve') {
+      if (t.status === 'review' && t.kind === 'approve') { t.status = 'sending'; t.session_id = null; t.started_at = null; }
+      else if (!(t.status === 'done' && t.kind === 'auto')) return `task ${taskId} is ${t.status} — only a draft waiting for you can be approved`;
+      t.decided = { action: 'approve', at, ...(note ? { note: note.slice(0, 500) } : {}) };
+      return null;
+    }
+    if (o.action === 'revise') {
+      if (t.status !== 'review' && t.status !== 'done') return `task ${taskId} is ${t.status} — only a delivered draft can be revised`;
+      if (!note) return 'say what to change: a revise needs a note';
+      if (note.length > 500) return 'the note is over 500 characters';
+      if (t.revisions.length >= MAX_REVISIONS) return `task ${taskId} has had ${MAX_REVISIONS} revisions — at most ${MAX_REVISIONS}. Do the rest yourself.`;
+      t.revisions.push({ note, at });
+      t.status = 'waiting'; t.session_id = null; t.decided = { action: 'revise', at, note };
+      return null;
+    }
+    if (t.status !== 'failed') return `task ${taskId} is ${t.status} — only a failed task can be run again`;
+    t.status = 'waiting'; t.session_id = null; t.error = null; t.decided = { action: 'retry', at };
+    return null;
+  });
+}
+
+/** The send session reports the approved step done, with the link to what it posted. */
+function sent(run, taskId, s, now) {
+  return withTask(run, taskId, (t) => {
+    if (t.status !== 'sending') return `task ${taskId} is ${t.status} — only an approved task being sent can be reported sent`;
+    const link = s && s.link;
+    if (link !== undefined && link !== null && link !== '' && !isUrl(link)) return 'the link must be an http(s) address of at most 500 characters';
+    t.status = 'sent'; t.sent = { link: link || null, at: iso(now) };
+    return null;
+  });
+}
+
+/** The session could not finish. The PM sees the reason and can run the task again. */
+function fail(run, taskId, reason, now) {
+  return withTask(run, taskId, (t) => {
+    if (t.status !== 'working' && t.status !== 'sending') return `task ${taskId} is ${t.status} — only a working or sending task can fail`;
+    const why = text(reason);
+    if (!why) return 'a failure needs a reason';
+    if (why.length > 240) return 'the reason is over 240 characters';
+    t.status = 'failed'; t.error = why; t.failed_at = iso(now);
+    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' };
+  const next = clone(run);
+  let changed = false;
+  for (const t of next.tasks) {
+    if (!sessionId || t.session_id !== sessionId) continue;
+    if (t.status === 'working') { t.status = 'failed'; t.error = 'the session ended without a draft'; t.failed_at = iso(now); changed = true; }
+    else if (t.status === 'sending') { t.status = 'failed'; t.error = 'the session ended before it reported sent'; t.failed_at = iso(now); changed = true; }
+  }
+  if (next.brief_session && next.brief_session.id === sessionId && !next.brief_session.ended_at) { next.brief_session.ended_at = iso(now); changed = true; }
+  if (next.checks.session_id === sessionId) { next.checks.session_id = null; changed = true; }
+  return { ok: true, run: next, changed };
+}
+
+/** Where the run is: reading (no brief for the day yet), working, review (drafts wait for the PM) or done. */
+function stage(run, brief) {
+  if (!run) return null;
+  if (!brief || brief.date !== run.date) return 'reading';
+  if (run.tasks.some((t) => t.status === 'waiting' || t.status === 'working' || t.status === 'sending')) return 'working';
+  if (run.tasks.some((t) => t.status === 'review')) return 'review';
+  return 'done';
+}
+
+/* ── the daytime check (G22) ──────────────────────────────────────────────────────────────────────────────────── */
+
+/** The wait between two checks: the setting, doubled for each empty check after the first, at most two hours. */
+function intervalMin(every, emptyStreak) {
+  return Math.min(MAX_INTERVAL_MIN, every * Math.pow(2, Math.max(0, emptyStreak - 1)));
+}
+
+/**
+ * Whether a check is due now, and why. Not due with no run, while a check runs, with the check off, on another day,
+ * or outside the working hours. Due 15 minutes before a meeting (once), after a meeting ends (once), and at the
+ * interval from the last check (or the press).
+ * @returns {{due:boolean, reason:'interval'|'before-meeting'|'after-meeting'|null, next:string|null}}
+ */
+function checkDue(run, { settings = {}, now, events = [] } = {}) {
+  const no = (next = null) => ({ due: false, reason: null, next });
+  if (!run) return no();
+  const dc = settings.dayCheck || { every: 60, start: '09:00', end: '18:00' };
+  if (!dc.every) return no();
+  const winStart = atClock(now, dc.start); const winEnd = atClock(now, dc.end);
+  const base = Date.parse(run.checks.last || run.started_at);
+  const nextMs = Math.max(base + intervalMin(dc.every, run.checks.empty_streak) * MIN, winStart);
+  const next = localDate(now) === run.date && nextMs < winEnd ? iso(nextMs) : null;
+  if (run.checks.session_id || localDate(now) !== run.date || now < winStart || now >= winEnd) return no(next);
+  const last = run.checks.last ? Date.parse(run.checks.last) : null;
+  for (const e of events || []) {
+    const s = Date.parse(e && e.start);
+    if (!Number.isFinite(s)) continue;
+    const before = s - BEFORE_MEETING_MIN * MIN;
+    if (now >= before && now < s && (last === null || last < before)) return { due: true, reason: 'before-meeting', next };
+  }
+  for (const e of events || []) {
+    const s = Date.parse(e && e.start);
+    const f = e && e.end ? Date.parse(e.end) : s + 30 * MIN;
+    if (Number.isFinite(f) && f <= now && f > base) return { due: true, reason: 'after-meeting', next };
+  }
+  if (now >= nextMs) return { due: true, reason: 'interval', next };
+  return no(next);
+}
+
+/** A check session started. The log keeps the last 20 checks. */
+function checkStarted(run, sessionId, reason, now) {
+  if (!run) return { ok: false, error: 'no day run today — press Prepare my day first' };
+  if (run.checks.session_id) return { ok: false, error: 'a check is already running' };
+  const next = clone(run);
+  next.checks.session_id = sessionId || null;
+  next.checks.last = iso(now);
+  next.checks.log = [...next.checks.log, { at: iso(now), reason: String(reason || 'manual'), found: null, resolved: null }].slice(-MAX_CHECK_LOG);
+  return { ok: true, run: next };
+}
+
+/** The check submitted its merge. Two empty checks in a row make the next wait twice as long. */
+function checkDone(run, { found = 0, resolved = 0 } = {}, now) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  const next = clone(run);
+  const f = Math.max(0, Number(found) || 0); const r = Math.max(0, Number(resolved) || 0);
+  next.checks.empty_streak = f === 0 && r === 0 ? next.checks.empty_streak + 1 : 0;
+  next.checks.session_id = null;
+  const open = [...next.checks.log].reverse().find((x) => x.found === null);
+  if (open) { open.found = f; open.resolved = r; open.done_at = iso(now); }
+  else next.checks.log = [...next.checks.log, { at: iso(now), reason: 'merge', found: f, resolved: r }].slice(-MAX_CHECK_LOG);
+  return { ok: true, run: next };
+}
+
+module.exports = { MAX_PARALLEL, MAX_REVISIONS, MAX_CHECK_LOG, MAX_INTERVAL_MIN, STATUSES, KINDS, ACTIONS, TASK_RE,
+  newRun, readRun, findTask, modeOf, addTasks, toStart, started, deliver, decide, sent, fail, sessionEnded, stage, intervalMin,
+  checkDue, checkStarted, checkDone };

package/workspace/lib/goals.js

@@ -14,6 +14,11 @@
  * THE JOIN IS CHECKABLE. A brief item or calendar event belongs to a goal when it names the goal's id (the morning-brief
  * session sets it). Failing that, an item or Today card belongs to the first open goal tied to the same initiative. There
  * is no word matching: a link is an id, so the PM can see why a step is under a goal. One step is under one goal only.
+ * Only an OPEN goal takes steps (PRD G9): an item that names a done or dropped goal is placed as if it named none.
+ *
+ * The day view (PRD G10, G12) reads three more lists from the same plan: `mentions_by_source` ({source: [step]}), and
+ * `you` and `agent`, the priorities split by who acts. A step carries the item's context (link, where, who, about, ask,
+ * reply_needed, how, kind, new) as the brief gave it.
  */
 const crypto = require('crypto');
 
@@ -98,10 +103,15 @@ function freeTime(events, at, endOfDay = END_OF_DAY) {
 
 const stepOrder = (a, b) => (a.owner === b.owner ? 0 : a.owner === 'pm' ? -1 : 1) || (b.confidence - a.confidence) || a.title.localeCompare(b.title);
 
+// The context a job carries (G18) rides on its step unchanged, so Today and the CLI show what the brief said.
+const ITEM_CONTEXT = ['link', 'where', 'who', 'about', 'ask', 'reply_needed', 'how', 'kind', 'new'];
 function itemStep(x) {
-  return { ref: 'brief:' + x.id, from: 'brief', source: x.source, title: x.title, why: x.why_now, evidence: x.evidence || '', owner: x.owner,
-    effort: x.effort, confidence: x.confidence, initiative_id: x.initiative_id || null, mention: !!x.mention, worth_asking: !!x.worth_asking,
+  const step = { ref: 'brief:' + x.id, item_id: x.id, from: 'brief', source: x.source, title: x.title, why: x.why_now, evidence: x.evidence || '', owner: x.owner,
+    effort: x.effort, confidence: x.confidence, initiative_id: x.initiative_id || null, goal: x.goal || null, mention: !!x.mention, worth_asking: !!x.worth_asking,
     prepare: x.owner === 'agent' && !!x.initiative_id };
+  for (const k of ITEM_CONTEXT) if (x[k] !== undefined) step[k] = x[k];
+  if (!step.kind) step.kind = x.owner === 'pm' ? 'you' : 'approve';
+  return step;
 }
 function cardStep(c) {
   return { ref: 'today:' + c.id, from: 'today', source: c.source || 'today', title: c.cause, why: c.cause, evidence: c.evidence || '', owner: 'pm',
@@ -125,11 +135,14 @@ function planDay({ day, brief = null, cards = [], now = Date.now(), endOfDay = E
   const goals = (day && day.goals ? day.goals : []).map((g) => ({ ...g, steps: [], context: [] }));
   const open = goals.filter((g) => g.status === 'open');
   const byId = new Map(goals.map((g) => [g.id, g]));
+  const openById = new Map(open.map((g) => [g.id, g]));
   const byIni = (ini) => (ini ? open.find((g) => g.initiative_id === ini) || null : null);
   const unplaced = { items: [], cards: [] };
 
+  // G9: a step goes only under an OPEN goal. A done or dropped goal draws no steps, so an item that names one is
+  // placed as if it named no goal (by initiative, else "also" or "worth asking"); it is never lost under a closed goal.
   for (const x of items) {
-    const g = (x.goal && byId.get(x.goal)) || byIni(x.initiative_id);
+    const g = (x.goal && openById.get(x.goal)) || byIni(x.initiative_id);
     if (g) g.steps.push(itemStep(x)); else unplaced.items.push(x);
   }
   for (const c of cards || []) {
@@ -150,6 +163,14 @@ function planDay({ day, brief = null, cards = [], now = Date.now(), endOfDay = E
     ...unplaced.cards.map(cardStep),
   ].sort(stepOrder);
   const worthAsking = unplaced.items.filter((x) => x.worth_asking).map(itemStep).sort(stepOrder);
+  // G10: every mention, grouped by the service it came from. G12: the priorities split by who acts — "You" also holds the
+  // Today cards that no goal took; a mention the agent owns is in both the mentions and "Agent".
+  const mentionsBySource = {};
+  for (const x of items) if (x.mention) (mentionsBySource[x.source] = mentionsBySource[x.source] || []).push(itemStep(x));
+  for (const k of Object.keys(mentionsBySource)) mentionsBySource[k].sort(stepOrder);
+  const prio = items.filter((x) => !x.worth_asking);
+  const you = [...prio.filter((x) => x.owner === 'pm').map(itemStep), ...unplaced.cards.map(cardStep)].sort(stepOrder);
+  const agent = prio.filter((x) => x.owner === 'agent').map(itemStep).sort(stepOrder);
   const notRead = fresh ? Object.entries(brief.sources || {}).filter(([, v]) => v !== 'read').map(([k, v]) => ({ source: k, state: v })) : [];
   const counts = { open: open.length, done: goals.filter((g) => g.status === 'done').length, planned: goals.filter((g) => g.coverage === 'planned').length,
     needs_plan: goals.filter((g) => g.coverage === 'needs-plan').length };
@@ -159,6 +180,7 @@ function planDay({ day, brief = null, cards = [], now = Date.now(), endOfDay = E
     not_read: notRead,
     time: fresh ? freeTime(events, now, endOfDay) : null,
     mentions: items.filter((x) => x.mention).length,
+    mentions_by_source: mentionsBySource, you, agent,
   };
 }
 

package/workspace/lib/proactive-cli.js

@@ -11,9 +11,20 @@
  *   pmos proactive feedback <id> useful|not-useful|wrong-priority|opened|dismissed [--note TEXT]
  *   pmos proactive feedback --missed TEXT
  *   pmos proactive brief [show]
- *   pmos proactive brief submit --file PATH
+ *   pmos proactive settings [--brief-source NAME=on|off] [--scope SERVICE:NAME=watch|search|ignore|none] [--day-check 30|60|off]
+ *                           [--website URL] [--no-website URL]
+ *   pmos proactive brief submit --file PATH [--merge]
  *   pmos proactive brief schedule [--repo PATH]
  *   pmos proactive goals [list] | add TEXT [--initiative ID] | done N | drop N | reopen N | remove N | plan [--repo PATH]
+ *   pmos proactive day [--repo PATH]                     the day run: its stage, its tasks and the daytime check
+ *   pmos proactive day show TASK                         one task with its item, draft and revision notes (what day-task reads)
+ *   pmos proactive day deliver TASK --summary S --body-file F [--link URL]
+ *   pmos proactive day sent TASK [--link URL] | day fail TASK --reason R
+ *   pmos proactive day approve|revise|retry TASK [--note N] | day check
+ *
+ * The day verbs are the one exception to "starts nothing": `day approve`, `day revise`, `day retry` and `day check`
+ * are the PM's presses, and the server starts the session each implies (today-goals G14, G21, G22). `deliver`, `sent`
+ * and `fail` are how a task session reports; they start nothing themselves.
  *   pmos proactive prepare plan --initiative ID [--repo PATH]
  *   pmos proactive prepare queue --initiative ID --item ITEM --sha HASH [--repo PATH]
  *   pmos proactive prepare status | cancel ID | run
@@ -24,8 +35,8 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 const { parseArgs } = require('./schedule-cli');
 
-const COMMANDS = { proactive: ['today', 'scan', 'settings', 'feedback', 'brief', 'goals', 'prepare', 'learn'] };
-const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'slack', 'jira', 'confluence'];
+const COMMANDS = { proactive: ['today', 'scan', 'settings', 'feedback', 'brief', 'goals', 'prepare', 'learn', 'day'] };
+const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'slack', 'jira', 'confluence', 'github', 'drive', 'figma', 'website'];
 const onOff = (v, what) => (v === 'on' || v === 'true' ? true : v === 'off' || v === 'false' ? false : { err: `${what} takes on or off` });
 
 async function run(argv, { call, say, cwd = process.cwd() }) {
@@ -75,6 +86,22 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
       if (!m) return fail(`--brief-source takes NAME=on or NAME=off, where NAME is one of ${BRIEF_SOURCES.join(', ')}`);
       patch.briefSources = { [m[1]]: m[2] === 'on' };
     }
+    if ('scope' in flags) {
+      const m = /^(slack|jira|confluence):(.+)=(watch|search|ignore|none)$/.exec(flags.scope);
+      if (!m) return fail('--scope takes SERVICE:NAME=LEVEL, where SERVICE is slack, jira or confluence and LEVEL is watch, search, ignore or none — for example slack:#pm-team=watch');
+      patch.scopes = { [m[1]]: { [m[2]]: m[3] === 'none' ? null : m[3] } };
+    }
+    if ('day-check' in flags) {
+      const v = flags['day-check'];
+      if (!['30', '60', 'off'].includes(v)) return fail('--day-check takes 30, 60 or off');
+      patch.dayCheck = { every: v === 'off' ? 0 : Number(v) };
+    }
+    if ('website' in flags || 'no-website' in flags) {
+      let list = [...((probe.settings && probe.settings.websites) || [])];
+      if ('website' in flags) list.push(flags.website);
+      if ('no-website' in flags) list = list.filter((u) => u !== flags['no-website']);
+      patch.websites = [...new Set(list)];
+    }
     if ('stalled-days' in flags) patch.stalledDays = Number(flags['stalled-days']);
     if ('quiet' in flags) {
       if (flags.quiet === 'none') patch.quiet = null;
@@ -89,6 +116,12 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
     say(`engine ${s.enabled ? 'on' : 'off'} · stalled after ${s.stalledDays} days · quiet ${s.quiet ? s.quiet.start + '-' + s.quiet.end : 'none'} · learning ${s.pauseLearning ? 'paused' : 'on'}`);
     say('brief sources: ' + BRIEF_SOURCES.map((k) => `${k} ${s.briefSources && s.briefSources[k] ? 'on' : 'off'}`).join(', ') + ' · scoring ' + (s.briefScoring ? 'on' : 'off') + (s.name ? ' · name ' + s.name : ''));
     say('background prepare ' + (s.backgroundPrepare ? 'on' : 'off'));
+    const dc = s.dayCheck || { every: 60, start: '09:00', end: '18:00' };
+    say('day check ' + (dc.every ? `every ${dc.every} min, ${dc.start}-${dc.end}` : 'off') + ' · websites: ' + ((s.websites || []).join(', ') || 'none'));
+    for (const svc of ['slack', 'jira', 'confluence']) {
+      const lv = Object.entries((s.scopes || {})[svc] || {});
+      if (lv.length) say(`${svc} levels: ` + lv.map(([n, l]) => `${n} ${l}`).join(', ') + ' (any other place: search)');
+    }
     say('watching: ' + Object.entries(s.triggers).map(([k, v]) => `${k} ${v ? 'on' : 'off'}`).join(', '));
     return 0;
   }
@@ -190,6 +223,82 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
     for (const l of r.lessons.filter((x) => x.status === 'proposed' || x.status === 'approved')) say(`${l.id}  ${l.status}  ${l.text}`);
     return 0;
   }
+  if (verb === 'day') {
+    const sub = pos[0] || 'status';
+    const usage = 'usage: pmos proactive day [status] | show TASK | deliver TASK --summary S --body-file F [--link URL] | sent TASK [--link URL] | fail TASK --reason R | approve|revise|retry TASK [--note N] | check';
+    const wsOfRepo = async () => {
+      let root; try { root = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: flags.repo ? path.resolve(cwd, flags.repo) : cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+      const wl = await call('GET', '/api/workspaces');
+      const hit = ((wl && wl.workspaces) || []).find((w) => path.resolve(w.root) === path.resolve(root));
+      return hit ? hit.id : null;
+    };
+    const get = async () => { const ws = await wsOfRepo(); return call('GET', '/api/proactive/day' + (ws ? '?ws=' + encodeURIComponent(ws) : '')); };
+    // A task is named by its id (t-…) or by its position in `pmos proactive day`.
+    const taskOf = (d, ref) => {
+      const tasks = (d.run && d.run.tasks) || [];
+      return /^\d+$/.test(String(ref)) ? tasks[Number(ref) - 1] || null : tasks.find((t) => t.id === ref) || null;
+    };
+    const post = async (what, body, done) => {
+      const r = await call('POST', '/api/proactive/day/' + what, body);
+      if (!r || r.ok === false) return fail(`refused — ${(r && r.error) || 'the server did not answer'}. Nothing changed.`);
+      say(done(r)); return 0;
+    };
+    if (sub === 'check') {
+      const ws = await wsOfRepo();
+      return post('check', ws ? { ws } : {}, (r) => `check started (session ${r.session}) — it merges what changed into today's brief`);
+    }
+    const d = await get();
+    if (!d || d.ok === false) return fail((d && d.error) || 'the server did not answer');
+    if (sub === 'status') {
+      if (!d.run) { say(`No day run for ${d.today}. Start one with "Prepare my day" on Today, or: pmos proactive goals plan`); return 0; }
+      say(`day run ${d.run.date} · stage: ${d.stage} · started ${d.run.started_at}${d.run.brief_session ? ` · brief session ${d.run.brief_session.id}${d.run.brief_session.ended_at ? ' (ended)' : ' (running)'}` : ''}`);
+      if (!d.run.tasks.length) say('No agent tasks yet.');
+      d.run.tasks.forEach((t, i) => say(`${i + 1}. ${t.id}  ${t.status}  ${t.kind}  ${t.title}${t.revisions.length ? ` (${t.revisions.length} revision${t.revisions.length > 1 ? 's' : ''})` : ''}${t.error ? ' — ' + t.error : ''}`));
+      const c = d.check;
+      say(`daytime check: ${c.every ? `every ${c.every} min` : 'off'}${c.running ? ' · running now' : ''} · last ${c.last || 'none'} · next ${c.next || 'none'}`);
+      return 0;
+    }
+    const ref = pos[1];
+    const t = d.run ? taskOf(d, ref) : null;
+    if (!d.run) return fail('no day run today — press Prepare my day first');
+    if (!t) return fail(`no task ${ref || ''} in today's run — ${usage}`);
+    if (sub === 'show') {
+      // What the day-task skill reads: the job as the brief gave it, the draft so far, and the PM's notes.
+      const it = d.brief ? [...(d.brief.priorities || []), ...(d.brief.worth_asking || [])].find((x) => x.id === t.item_id) : null;
+      const mode = t.status === 'sending' ? 'send' : (t.revisions.length && t.draft ? 'revise' : 'do');
+      say(`${t.id}  ${t.status}  ${t.kind}  mode ${mode}  ${t.title}`);
+      say(`source: ${t.source}${t.link ? ' · link ' + t.link : ''}${t.goal ? ' · goal ' + t.goal : ''} · attempts ${t.attempts}`);
+      if (it) {
+        say(`why now: ${it.why_now}`);
+        if (it.evidence) say(`evidence: ${it.evidence}`);
+        for (const k of ['where', 'who', 'about', 'ask', 'how']) if (it[k]) say(`${k}: ${it[k]}`);
+        if (it.reply_needed !== undefined) say(`reply needed: ${it.reply_needed ? 'yes' : 'no'}`);
+        if (it.initiative_id) say(`initiative: ${it.initiative_id}`);
+      } else say('(the item is no longer in today\'s brief)');
+      if (t.kind === 'approve') say('kind approve: deliver ONE draft; nothing goes out until the PM approves it.');
+      else say('kind auto: deliver ONE draft; nothing leaves this machine.');
+      if (t.draft) { say(`draft (${t.draft.at}): ${t.draft.summary}${t.draft.link ? ' · ' + t.draft.link : ''}`); say(t.draft.body); }
+      t.revisions.forEach((rv, i) => say(`revision note ${i + 1} (${rv.at}): ${rv.note}`));
+      if (t.decided) say(`decided: ${t.decided.action} at ${t.decided.at}${t.decided.note ? ' — ' + t.decided.note : ''}`);
+      if (t.sent) say(`sent ${t.sent.at}${t.sent.link ? ' · ' + t.sent.link : ''}`);
+      if (t.error) say(`error: ${t.error}`);
+      return 0;
+    }
+    if (sub === 'deliver') {
+      if (!flags.summary || !flags['body-file']) return fail('usage: pmos proactive day deliver TASK --summary S --body-file F [--link URL]');
+      let body; try { body = fs.readFileSync(path.resolve(cwd, flags['body-file']), 'utf8'); } catch (e) { return fail(`could not read ${flags['body-file']} — ${e.message}`); }
+      return post('deliver', { task: t.id, summary: flags.summary, body, ...(flags.link ? { link: flags.link } : {}) }, (r) => `delivered — ${t.id} is now ${r.task.status}`);
+    }
+    if (sub === 'sent') return post('sent', { task: t.id, ...(flags.link ? { link: flags.link } : {}) }, () => `sent — ${t.id}`);
+    if (sub === 'fail') {
+      if (!flags.reason) return fail('usage: pmos proactive day fail TASK --reason R');
+      return post('fail', { task: t.id, reason: flags.reason }, () => `failed — ${t.id}: ${flags.reason}`);
+    }
+    if (['approve', 'revise', 'retry'].includes(sub)) {
+      return post('decide', { task: t.id, action: sub, ...(flags.note ? { note: flags.note } : {}) }, (r) => `${sub === 'approve' ? 'approved' : sub === 'revise' ? 'sent back with your note' : 'running again'} — ${t.id} is now ${r.task.status}`);
+    }
+    return fail(usage);
+  }
   if (verb === 'goals') {
     const sub = pos[0] || 'list';
     const usage = 'usage: pmos proactive goals [list] | add TEXT [--initiative ID] | done N | drop N | reopen N | remove N | plan [--repo PATH]';
@@ -224,7 +333,8 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
       if (!ws) return fail('this is not inside a registered workspace — open it with pmos first, or use --repo PATH');
       const r = await call('POST', '/api/proactive/goals/plan', { ws });
       if (!r || r.ok === false) return fail(`not started — ${(r && r.error) || 'the server did not answer'}`);
-      say(`${r.seeded ? `scheduled the morning brief daily at ${r.schedule.time}, and ` : ''}started a morning-brief session to plan ${r.goals} goal(s). The plan shows when it submits the brief.`);
+      if (r.running) { say(`the morning-brief session ${r.session} is still running — nothing new was started. See the run with: pmos proactive day`); return 0; }
+      say(`${r.seeded ? `scheduled the morning brief daily at ${r.schedule.time}, and ` : ''}started a morning-brief session to plan ${r.goals} goal(s). The plan shows when it submits the brief; then the agent's tasks start. See them with: pmos proactive day`);
       return 0;
     }
     if (sub !== 'list') return fail(usage);
@@ -248,11 +358,14 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
   if (verb === 'brief') {
     const sub = pos[0] || 'show';
     if (sub === 'submit') {
-      if (!flags.file) return fail('usage: pmos proactive brief submit --file PATH');
+      if (!flags.file) return fail('usage: pmos proactive brief submit --file PATH [--merge]');
       let raw; try { raw = JSON.parse(fs.readFileSync(path.resolve(cwd, flags.file), 'utf8')); } catch (e) { return fail(`could not read ${flags.file} as JSON — ${e.message}`); }
+      const merge = 'merge' in flags;
+      if (merge && raw && typeof raw === 'object' && !Array.isArray(raw)) raw.merge = true;
       const r = await call('POST', '/api/proactive/brief', raw);
       if (!r || r.ok === false) return fail(`refused — ${(r && r.error) || 'the server did not answer'}. Nothing was stored.`);
-      say(`stored the brief for ${r.brief.date} — ${r.brief.priorities.length} priorities, ${r.brief.worth_asking.length} worth asking`);
+      if (merge) say(`merged into the brief for ${r.brief.date} — ${r.merged ? r.merged.found : 0} new, ${r.merged ? r.merged.resolved : 0} resolved; it now holds ${r.brief.priorities.length} priorities, ${r.brief.worth_asking.length} worth asking`);
+      else say(`stored the brief for ${r.brief.date} — ${r.brief.priorities.length} priorities, ${r.brief.worth_asking.length} worth asking`);
       return 0;
     }
     if (sub === 'schedule') {