@bli-cockpit/cli 0.2.240 → 0.2.241

package/dist/commands/manager-render-home.js

@@ -7,34 +7,50 @@
  * AI's working notes, kept inside the manager server. "Today" is Vancouver's day, as the manager server counts it.
  */
 import { dim } from "./cli-io.js";
+import { readReasonText } from "./manager-read-reasons.js";
 /** The manager's day (`TOWER_MANAGER_TIMEZONE`): a task due today is not overdue at 5 pm Pacific. */
 export const MANAGER_TIMEZONE = "America/Vancouver";
-const HEALTH = { on_track: "On track", at_risk: "At risk", blocked: "Blocked" };
-const FRESHNESS = {
+export const HEALTH = { on_track: "On track", at_risk: "At risk", blocked: "Blocked" };
+export const FRESHNESS = {
     reading: "being read now",
     never_read: "never read yet",
     failed: "the latest read failed",
     stale: "may be out of date (no good read in the last 36 hours)",
     fresh: "fresh",
 };
-const MISSING = {
+export const MISSING = {
     never_checked: "Not written yet: the next read writes it.",
     check_failed: "Not written yet: the last check failed; the next read tries again.",
     nothing_to_summarise: "Nothing to summarise yet: Tower has no open actions or timeline for this client.",
 };
-const CHANGE = { added: "added", changed: "changed", proposal: "proposed", closed: "closed" };
+export const CHANGE = { added: "added", changed: "changed", proposal: "proposed", closed: "closed" };
 const plural = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
 /** `YYYY-MM-DD` of Vancouver's day for an instant. */
 export function managerDay(at) {
     return new Intl.DateTimeFormat("en-CA", { timeZone: MANAGER_TIMEZONE, year: "numeric", month: "2-digit", day: "2-digit" }).format(at);
 }
 /** "Oct 16" for an instant, on Vancouver's calendar. */
-function shortDate(at) {
+export function shortDate(at) {
     const date = new Date(at);
     if (Number.isNaN(date.getTime()))
         return at;
     return new Intl.DateTimeFormat("en-US", { timeZone: MANAGER_TIMEZONE, month: "short", day: "numeric" }).format(date);
 }
+/** "Oct 1" for a `YYYY-MM-DD` day as written (no timezone shift: a bare date is a calendar day, not an instant). */
+function dayWords(day) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(day);
+    if (!match)
+        return day;
+    const noon = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), 12));
+    return new Intl.DateTimeFormat("en-US", { timeZone: "UTC", month: "short", day: "numeric" }).format(noon);
+}
+/** "Oct 16, 5:45 PM PDT": an instant as Tower's day and time (America/Vancouver, as Home reads it); an unreadable one is printed as it came. `--json` keeps the raw ISO. */
+export function managerTime(at) {
+    const date = new Date(at);
+    if (Number.isNaN(date.getTime()))
+        return at;
+    return new Intl.DateTimeFormat("en-US", { timeZone: MANAGER_TIMEZONE, month: "short", day: "numeric", hour: "numeric", minute: "2-digit", timeZoneName: "short" }).format(date);
+}
 /** "3 h ago", "2 d ago", "just now": how old an instant is. */
 export function ageText(at, now) {
     const ms = now.getTime() - new Date(at).getTime();
@@ -67,15 +83,22 @@ export function withTodayLine(rows, dates, today) {
     const line = [todayLine(today)];
     return at === -1 ? [...rows, line] : [...rows.slice(0, at), line, ...rows.slice(at)];
 }
+/** Who wrote the card, by its `source`: the credit's opening words (the day follows; a person's name comes after "Edited by"). */
+export const SUMMARY_SOURCE_WORDS = {
+    model: "Written by AI",
+    computed: "AI unavailable · computed from counts",
+    person: "Edited by",
+};
 /** Who wrote the card and when: "written by AI", "computed from counts", or "edited by" a person. */
 function authorLine(summary, now) {
-    const at = when(summary.writtenAt, now);
+    // The server's own Vancouver day when it sends one; never worked out here when it did.
+    const at = summary.writtenOn ? `${dayWords(summary.writtenOn)} (${ageText(summary.writtenAt, now)})` : when(summary.writtenAt, now);
     if (summary.source === "model")
-        return `Written by AI, ${at}.`;
+        return `${SUMMARY_SOURCE_WORDS.model}, ${at}.`;
     if (summary.source === "computed")
-        return `Computed from counts, ${at} (the model could not write it).`;
+        return `${SUMMARY_SOURCE_WORDS.computed}, ${at}.`;
     // Never a user id in a person's terminal: the door fills the name, or says "a teammate".
-    return `Edited by ${summary.editedByName ?? "a teammate"}, ${at}.`;
+    return `${SUMMARY_SOURCE_WORDS.person} ${summary.editedByName ?? "a teammate"}, ${at}.`;
 }
 const CAP_WORDS = {
     max_depth: "depth cap",
@@ -108,22 +131,25 @@ function freshnessLines(home, now) {
     const synced = home.client.lastSyncedAt;
     // A failed latest read names its reason, and the data shown is as old as the last good read (availability over completeness).
     const failed = read && home.freshness.state === "failed"
-        ? `failed ${when(read.finishedAt ?? read.startedAt, now)}${read.reason ? `: ${read.reason}` : ""}; ${synced ? `last good read ${when(synced, now)}` : "no good read yet"}`
+        ? `failed ${when(read.finishedAt ?? read.startedAt, now)}; ${synced ? `last good read ${when(synced, now)}` : "no good read yet"}`
         : null;
     const lastRead = failed ?? (read ? `last read ${when(read.finishedAt ?? read.startedAt, now)}${read.finishedAt ? "" : ", still running"}` : synced ? `last synced ${when(synced, now)}` : "never read");
     const notion = home.freshness.notionLastEditedAt ? `Notion last changed ${when(home.freshness.notionLastEditedAt, now)}` : "no Notion page yet";
     // What the read could not see sits under the Data line, so "fresh" never hides it.
-    return [`Data: ${FRESHNESS[home.freshness.state] ?? home.freshness.state}. ${lastRead[0].toUpperCase()}${lastRead.slice(1)}; ${notion}.`, ...coverageLines(home.client).map((line) => `  ${line}`)];
+    return [`Data: ${FRESHNESS[home.freshness.state] ?? home.freshness.state}. ${lastRead[0].toUpperCase()}${lastRead.slice(1)}; ${notion}.`, ...coverageLines(home.client).map((line) => `  ${line}`), ...(failed && read?.reason ? [`  Why the latest read failed: ${readReasonText(read.reason)}`] : [])];
 }
 function summaryLines(home, now, color) {
     const c = home.counts;
-    // The page's numbers beside the card: due this week is what needs attention beyond the overdue ones, and "to review" is
-    // the review queue's size (`review.total`), not `counts.toReview` (which also counts the first read's items).
-    const dueThisWeek = Math.max(0, home.needsAttention.total - c.overdue);
-    const counts = `  Live: ${plural(c.openActions, "open action")} (${c.overdue} overdue, ${dueThisWeek} due this week), ${plural(c.timeline, "timeline item")}, ${home.review.total} to review.`;
+    // The page's numbers beside the card: due this week is what needs attention beyond the overdue ones, and "new from syncs"
+    // is the review queue's size (`review.total`: changes after the first read), not `counts.toReview` (every unreviewed
+    // item, the first read's included), which `list` prints as "need review".
+    const dueThisWeek = home.needsAttention.dueThisWeek?.total ?? Math.max(0, home.needsAttention.total - c.overdue);
+    const counts = `  Live: ${plural(c.openActions, "open action")} (${c.overdue} overdue, ${dueThisWeek} due this week), ${plural(c.timeline, "timeline item")}, ${home.review.total} new from syncs.`;
     const summary = home.summary;
+    const first = home.client.onboardingStatus === "failed" ? firstReadSentence(home) : null;
+    // No promise that "the next read writes it" while the first read has failed: the page shows only the failure.
     if (!summary)
-        return [`Where we are: ${MISSING[home.summaryMissingReason ?? "never_checked"]}`, counts];
+        return [`Where we are: ${first ? `Not written yet. ${first}` : (MISSING[home.summaryMissingReason ?? "never_checked"] ?? "Not written yet.")}`, counts];
     const lines = [`Where we are: ${HEALTH[summary.health] ?? summary.health} — ${summary.headline}`];
     for (const bullet of summary.bullets)
         lines.push(`  ${bullet.date ?? "(no date)"}  ${bullet.text}`);
@@ -132,26 +158,71 @@ function summaryLines(home, now, color) {
     if (summary.blocker)
         lines.push(`  Blocker: ${summary.blocker}`);
     lines.push(`  ${authorLine(summary, now)}`);
-    if (summary.inputsChanged)
-        lines.push("  Inputs changed since: the client's data changed or an action went overdue (for an AI-written card, also a meeting or milestone came within a week or passed) after this was written; the next check writes it again.");
+    if (first)
+        lines.push(`  ${first}`);
+    // A failed check keeps the card and promises nothing; otherwise say how old the last look is.
+    if (summary.lastCheckFailed)
+        lines.push(`  The last check failed; showing the card from ${shortDate(summary.writtenAt)}.`);
+    else {
+        // Null until a real check has looked at the card: no line then (never "56 years ago").
+        const checked = summary.checkedAt ?? null;
+        if (checked !== null && Number.isFinite(new Date(checked).getTime()))
+            lines.push(`  Last checked ${ageText(checked, now)}.`);
+    }
+    if (summary.inputsChanged && !summary.lastCheckFailed)
+        lines.push("  Inputs changed since: the client's data changed, an action went overdue or an open action passed 14 days overdue (for an AI-written card, also a meeting or milestone came within a week or passed) after this was written; the next check writes it again.");
     lines.push(counts, dim(`  version ${summary.updatedAt} (what \`summary --version\` takes)`, color));
     return lines;
 }
-function attentionLines(home, color) {
-    const attention = home.needsAttention;
-    const head = `Needs attention: ${plural(attention.total, "open action")} overdue or due within 7 days.${attention.truncated ? ` Showing ${attention.items.length} of ${attention.total}.` : ""}`;
-    const lines = [head];
-    const byId = new Map(attention.items.map((item) => [item.id, item]));
-    for (const group of attention.byOwner) {
+/** The rows of one part, under their owners in the order `byOwner` gives; a row no group names is printed flat. */
+function partRows(home, part, color, keepEmptyOwners = false) {
+    const byId = new Map(part.items.map((item) => [item.id, item]));
+    const row = (item, indent) => `${indent}${item.dueAt ? `due ${item.dueAt}` : "no due date"}${item.overdue ? " (overdue)" : ""}  ${item.title}  ${dim(`id ${item.id}`, color)}`;
+    const lines = [];
+    const placed = new Set();
+    for (const group of home.needsAttention.byOwner) {
+        const rows = group.actionIds.map((id) => byId.get(id)).filter((item) => item !== undefined);
+        if (rows.length === 0 && !keepEmptyOwners)
+            continue;
         lines.push(`  ${group.owner ?? "No owner"}`);
-        for (const id of group.actionIds) {
-            const item = byId.get(id);
-            if (item)
-                lines.push(`    ${item.dueAt ? `due ${item.dueAt}` : "no due date"}${item.overdue ? " (overdue)" : ""}  ${item.title}  ${dim(`id ${item.id}`, color)}`);
+        for (const item of rows) {
+            lines.push(row(item, "    "));
+            placed.add(item.id);
         }
     }
+    for (const item of part.items)
+        if (!placed.has(item.id))
+            lines.push(row(item, "  "));
+    return lines;
+}
+function attentionLines(home, ref, color) {
+    const attention = home.needsAttention;
+    const parts = attention.dueThisWeek || attention.overdue ? [
+        ["Due this week", attention.dueThisWeek, "by owner; today to six days ahead, soonest first under each", `cockpit manager list ${ref}`],
+        ["Overdue", attention.overdue, "by owner; oldest first under each", `cockpit manager list ${ref} --overdue`],
+    ] : null;
+    const lines = [];
+    if (parts) {
+        const total = (attention.dueThisWeek?.total ?? 0) + (attention.overdue?.total ?? 0);
+        lines.push(`Needs attention: ${plural(total, "open action")} overdue or due within 7 days.`);
+        for (const [label, part, order, command] of parts) {
+            if (!part)
+                continue;
+            // Each part says its own total, and when it was cut, how to see the rest.
+            lines.push(`${label}: ${plural(part.total, "open action")} (${order}).${part.truncated ? ` Showing ${part.items.length} of ${part.total}; \`${command}\` lists them all.` : ""}`);
+            // The rows sit under their owners, so the first row is not the oldest: the server's overdue list is oldest-due first, and its first item is the longest overdue.
+            const longest = label === "Overdue" ? part.items[0] : undefined;
+            if (longest?.dueAt)
+                lines.push(`  Overdue longest: ${printable(longest.title)}, due ${dayWords(longest.dueAt)}.`);
+            lines.push(...partRows(home, part, color));
+        }
+    }
+    else {
+        lines.push(`Needs attention: ${plural(attention.total, "open action")} overdue or due within 7 days.${attention.truncated ? ` Showing ${attention.items.length} of ${attention.total}.` : ""}`);
+        lines.push(...partRows(home, { items: attention.items, total: attention.total, truncated: attention.truncated }, color, true));
+    }
     if (attention.undated > 0)
-        lines.push(`  ${plural(attention.undated, "open action")} ${attention.undated === 1 ? "has" : "have"} no due date (\`list <client>\` shows them).`);
+        lines.push(`  ${plural(attention.undated, "open action")} ${attention.undated === 1 ? "has" : "have"} no due date (\`cockpit manager list ${ref}\` shows them).`);
     return lines;
 }
 function comingUpLines(home) {
@@ -163,16 +234,113 @@ function comingUpLines(home) {
         lines.push(`  ${coming.undated} more ${coming.undated === 1 ? "has" : "have"} no date ("Needs a date").`);
     return lines;
 }
+/**
+ * The first read is not done: said instead of "nothing changed" / "nothing waits", which would be false. Null once a read has finished.
+ * A FAILED first read is the page's failure panel alone (it shows nothing else until a read succeeds): writes made here are saved, and
+ * the next read does not promise to write anything the page shows.
+ */
+export function firstReadSentence(home) {
+    if (home.client.onboardingStatus === "failed") {
+        const reason = home.client.lastRead?.reason;
+        const why = reason && reasonSentence(reason) ? ` ${reasonSentence(reason)}` : "";
+        return `First read failed.${why} The manager page shows only that failure until a read succeeds; anything written here is saved but does not show there until then. Sync now on the manager page tries again.`;
+    }
+    if (home.freshness.state === "never_read")
+        return "First read not done yet. Sync now on the manager page starts it.";
+    if (home.freshness.state === "reading" && home.client.lastSyncedAt === null)
+        return "First read running…";
+    return null;
+}
+/** The page's sentence alone (no label), or null for a label it has no sentence for. */
+function reasonSentence(reason) {
+    const text = readReasonText(reason);
+    return text === reason ? null : text.slice(0, text.lastIndexOf(" ("));
+}
+const CHANGE_ORDER = { proposal: 0, added: 1, changed: 2, closed: 3 };
+/** The window an answer without `days` is taken to span (a copy of the server's `TOWER_MANAGER_IN_TOWER_DAYS`, held equal by `manager-cli-mcp-rules.test.ts`). */
+export const IN_TOWER_DAYS_DEFAULT = 7;
+export const IN_TOWER = { added: "added", closed: "closed", dropped: "dropped", dismissed: "dismissed" };
+/**
+ * The names in the In Tower heading: every person in the window when the server sends `people`, else those on the rows, with "…"
+ * when the rows were cut. A person with no name is "a teammate" (several: "N teammates"), never their user id.
+ */
+export function inTowerNames(tower) {
+    const names = [];
+    if (tower.people) {
+        let unnamed = 0;
+        for (const person of tower.people) {
+            if (person.name) {
+                if (!names.includes(person.name))
+                    names.push(person.name);
+            }
+            else
+                unnamed += 1;
+        }
+        if (unnamed > 0)
+            names.push(unnamed === 1 ? "a teammate" : `${unnamed} teammates`);
+        return names;
+    }
+    for (const item of tower.items) {
+        const name = item.byName || "a teammate";
+        if (!names.includes(name))
+            names.push(name);
+    }
+    return tower.truncated ? [...names, "…"] : names;
+}
+/**
+ * "In Tower, last 7 days: people and agents added 3, closed 2, dropped 1, dismissed 1 (Can, Pip)": a part with none is left out, and when every part
+ * is none, "nothing added, closed, dropped or dismissed by people or agents" (no names). `dropped` absent is 0.
+ */
+export function inTowerHeading(days, counts, names) {
+    const parts = [["added", counts.added], ["closed", counts.closed], ["dropped", counts.dropped ?? 0], ["dismissed", counts.dismissed]].filter(([, n]) => n > 0).map(([word, n]) => `${word} ${n}`);
+    if (parts.length === 0)
+        return `In Tower, last ${days} days: nothing added, closed, dropped or dismissed by people or agents.`;
+    return `In Tower, last ${days} days: people and agents ${parts.join(", ")}${names.length > 0 ? ` (${names.join(", ")})` : ""}.`;
+}
+/** What people and agents did in Tower lately, with who (by name, never an id). Nothing when the server does not send it. */
+function inTowerLines(home) {
+    const tower = home.whatChanged.inTower;
+    if (!tower)
+        return [];
+    const names = inTowerNames(tower);
+    const c = tower.counts;
+    const head = `${inTowerHeading(tower.days ?? IN_TOWER_DAYS_DEFAULT, c, names)}${tower.truncated ? ` Showing ${tower.items.length} of ${tower.total}.` : ""}`;
+    return [head, ...tower.items.map((item) => `  ${IN_TOWER[item.change] ?? item.change}  ${item.table}  ${item.title}  (by ${item.byName ?? "a teammate"}, ${shortDate(item.at)})`)];
+}
 function changedLines(home, now) {
     const changed = home.whatChanged;
+    const first = firstReadSentence(home);
+    const tower = inTowerLines(home);
     if (!changed.read)
-        return ["What changed: no read has changed anything yet."];
-    const counts = Object.keys(CHANGE).map((kind) => `${changed.counts[kind] ?? 0} ${CHANGE[kind]}`).join(", ");
+        return [first ? `What changed: ${first}` : "What changed: no read has changed anything yet.", ...tower];
+    // As the page words it: a kind with none is left out ("12 added, 2 proposed"), and none at all is "nothing changed".
+    const counts = Object.keys(CHANGE).filter((kind) => (changed.counts[kind] ?? 0) > 0).map((kind) => `${changed.counts[kind]} ${CHANGE[kind]}`).join(", ") || "nothing changed";
     const total = Object.values(changed.counts).reduce((sum, n) => sum + (n ?? 0), 0);
     const lines = [`What changed in the newest read that changed anything (${when(changed.read.finishedAt ?? changed.read.startedAt, now)}): ${counts}.${changed.truncated ? ` Showing ${changed.items.length} of ${total}.` : ""}`];
-    for (const item of changed.items)
+    // Proposals first (they need a person), then added, changed, closed; the server already sends this order, and a stable sort keeps it if an older one does not.
+    const ordered = [...changed.items].sort((a, b) => (CHANGE_ORDER[a.change] ?? 9) - (CHANGE_ORDER[b.change] ?? 9));
+    for (const item of ordered)
         lines.push(`  ${CHANGE[item.change] ?? item.change}  ${item.table}  ${item.title}`);
-    return lines;
+    return [...lines, ...tower];
+}
+/** "New from syncs": changes a read made after the first one (`review.total`), which the queue lists. */
+function reviewLine(home, review, ref) {
+    const first = firstReadSentence(home);
+    const { decisions, toCheck } = home.review;
+    // The queue split, when the server sends it: suggested changes need a decision, new items need a look.
+    if (decisions !== undefined && toCheck !== undefined) {
+        // As the page words it: a part with none is left out; with both none, nothing waits.
+        const parts = [
+            decisions > 0 ? `${plural(decisions, "suggested change")} ${decisions === 1 ? "needs" : "need"} a decision` : null,
+            toCheck > 0 ? `${plural(toCheck, "new item")} to check` : null,
+        ].filter((part) => part !== null);
+        if (parts.length > 0)
+            return `Review: ${parts.join(" · ")} (\`cockpit manager queue ${ref}\` lists them).`;
+        return first ? `Review: nothing waits for review yet. ${first}` : "Review: nothing waits for review.";
+    }
+    if (review === 0)
+        return first ? `New from syncs: none yet. ${first}` : "New from syncs: 0 (no sync change waits for review).";
+    return `New from syncs: ${review} (\`cockpit manager queue ${ref}\` lists them).`;
 }
 /** The whole Home, top to bottom, for a person. `clientRef` is how they named the client, for the commands it suggests. */
 export function homeLines(home, clientRef, color, now = new Date()) {
@@ -184,25 +352,33 @@ export function homeLines(home, clientRef, color, now = new Date()) {
         "",
         ...summaryLines(home, now, color),
         "",
-        ...attentionLines(home, color),
+        ...attentionLines(home, ref, color),
         "",
         ...comingUpLines(home),
         "",
         ...changedLines(home, now),
         "",
-        review === 0 ? "Review: no sync change waits for review." : `Review: ${plural(review, "sync change")} ${review === 1 ? "waits" : "wait"} for review: \`cockpit manager queue ${ref}\`.`,
+        reviewLine(home, review, ref),
     ];
 }
+/** Anything that is not printable text in a title (an escape sequence, a line break) is a space: a title is a client's data, printed in a person's terminal. */
+const printable = (text) => text.replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").trim();
+/** One line per warning on a saved card. Never a refusal: the card is saved either way. */
+export function warningLines(warnings) {
+    return (warnings ?? []).map((warning) => warning.reason === "on_track_with_long_overdue" && warning.title && warning.dueAt
+        ? `Warning: “${printable(warning.title)}” was due ${dayWords(warning.dueAt)} and is still open; the card says ${HEALTH.on_track}.`
+        : `Warning: Tower flagged this card (${printable(warning.reason)}); it was saved.`);
+}
 /** What a summary edit printed: the card as written. */
 export function summaryWrittenLines(summary, color, now = new Date()) {
-    const lines = [`Saved "Where we are": ${HEALTH[summary.health] ?? summary.health} — ${summary.headline}`];
+    const lines = [`Saved "Where we are": ${HEALTH[summary.health] ?? summary.health} — ${summary.headline}`, ...warningLines(summary.warnings)];
     for (const bullet of summary.bullets)
         lines.push(`  ${bullet.date ?? "(no date)"}  ${bullet.text}`);
     if (summary.next)
         lines.push(`  Next: ${summary.next}`);
     if (summary.blocker)
         lines.push(`  Blocker: ${summary.blocker}`);
-    lines.push(`  ${authorLine(summary, now)} It stands until the client's data changes or an action goes overdue; the next check after that writes it again.`);
+    lines.push(`  ${authorLine(summary, now)} It stands until the client's data changes, an action goes overdue or an open action passes 14 days overdue; the next check after that writes it again.`);
     lines.push(dim(`  version ${summary.updatedAt}`, color));
     return lines;
 }

package/dist/commands/manager-render.js

@@ -7,8 +7,9 @@
  * change nobody read. Readable, not exhaustive: `--json` is the whole answer and never comes through here.
  */
 import { dim } from "./cli-io.js";
-import { managerDay, withTodayLine } from "./manager-render-home.js";
-const QUEUE_REASON = {
+import { managerDay, managerTime, shortDate, withTodayLine } from "./manager-render-home.js";
+import { keptReasonText, readReasonText, summaryRefusalText, summaryTriggerText } from "./manager-read-reasons.js";
+export const QUEUE_REASON = {
     added: "added by a sync, not looked at yet",
     changed: "changed by a sync since you last saw it",
     proposal: "has a suggested change waiting",
@@ -18,14 +19,18 @@ export function clientLines(clients, color) {
         return ["Tower has no clients yet."];
     return clients.flatMap((client) => [
         `${client.name}  [${client.enabled === false ? "disabled" : client.onboardingStatus}]${client.running ? "  [reading now]" : ""}`,
-        `  ${client.lastSyncedAt ? `last synced ${client.lastSyncedAt}` : "never synced"}${client.pagesWaiting ? `, ${client.pagesWaiting} pages waiting to be read` : ""}`,
+        `  ${client.lastSyncedAt ? `last synced ${managerTime(client.lastSyncedAt)}` : "never synced"}${client.pagesWaiting ? `, ${client.pagesWaiting} pages waiting to be read` : ""}`,
         dim(`  id ${client.id}`, color),
         "",
     ]).slice(0, -1);
 }
+/** An action's status in a list row: a dropped action was not done, and says so. */
+export const ACTION_STATUS_WORDS = { open: "open", done: "done", dropped: "dropped (not done)" };
+/** An item's review state in its row. */
+export const REVIEW_STATUS_WORDS = { unreviewed: "needs review", reviewed: "reviewed", rejected: "dismissed" };
 /** "needs review" when nobody has looked at it; a suggested change waiting is said too. */
 export function reviewLabel(item) {
-    const parts = [item.reviewStatus === "unreviewed" ? "needs review" : item.reviewStatus === "rejected" ? "dismissed" : "reviewed"];
+    const parts = [REVIEW_STATUS_WORDS[item.reviewStatus] ?? "reviewed"];
     const proposals = item.proposedChanges?.length ?? 0;
     if (proposals > 0)
         parts.push(`${proposals} suggested change${proposals === 1 ? "" : "s"} waiting`);
@@ -54,21 +59,31 @@ export function itemRowLines(item, timeline, color) {
     const review = reviewLabel(item);
     const facts = timeline
         ? [item.kind ?? "item", whenText(item, true), ownersText(item, true)]
-        : [ownersText(item, false), whenText(item, false), item.status ?? "open"];
+        // A dropped action was not done: the row says so, never just "closed".
+        : [ownersText(item, false), whenText(item, false), ACTION_STATUS_WORDS[item.status ?? "open"] ?? item.status ?? "open"];
     return [`${item.title}  [${review}]`, `  ${facts.join(" | ")}`, dim(`  id ${item.id}  version ${item.updatedAt}`, color)];
 }
-/** A list for a person; a timeline list carries the Today line between upcoming and past (Vancouver's day). */
-export function listLines(list, timeline, color, now = new Date()) {
+/**
+ * A list for a person; a timeline list carries the Today line between upcoming and past (Vancouver's day).
+ * Deleted (`--archived`) is ordered by when each item was archived; Dismissed (`--review dismissed`) is in date
+ * order but, as on the page, not about now. Neither has a Today line, so `dateOrdered` is false for both.
+ */
+export function listLines(list, timeline, color, now = new Date(), dateOrdered = true, ownerScoped = false) {
     const noun = timeline ? "timeline item" : "action";
     const shown = list.items.length;
     const head = shown < list.total ? `Showing ${shown} of ${list.total} ${noun}s.` : `${list.total} ${noun}${list.total === 1 ? "" : "s"}.`;
     const c = list.counts;
     const cut = list.truncated ? " A list holds at most 500 rows: narrow it with --status, --owner, --kind, --search or --needs-review." : "";
-    const lines = [`${head}${cut}`, `The client has ${c.openActions} open ${c.openActions === 1 ? "action" : "actions"} (${c.overdue} overdue) and ${c.toReview} ${c.toReview === 1 ? "item" : "items"} to review.`];
+    const review = `${c.toReview} ${c.toReview === 1 ? "needs" : "need"} review (every unreviewed item, the first read's included)`;
+    // An owner filter (--owner, --no-owner) narrows the open and overdue counts to that scope (the server's `OwnerScope`); the review count stays the client's.
+    const counts = ownerScoped
+        ? `${c.openActions} open ${c.openActions === 1 ? "action matches" : "actions match"} these filters (${c.overdue} overdue). The client has ${review}.`
+        : `The client has ${c.openActions} open ${c.openActions === 1 ? "action" : "actions"} (${c.overdue} overdue) and ${review}.`;
+    const lines = [`${head}${cut}`, counts];
     if (shown === 0)
         lines.push(`No ${noun}s match.`);
     const rows = list.items.map((item) => itemRowLines(item, timeline, color));
-    const placed = timeline && shown > 0 ? withTodayLine(rows, list.items.map((item) => item.occurredAt), managerDay(now)) : rows;
+    const placed = timeline && dateOrdered && shown > 0 ? withTodayLine(rows, list.items.map((item) => item.occurredAt), managerDay(now)) : rows;
     for (const row of placed)
         lines.push("", ...row);
     return lines;
@@ -78,13 +93,31 @@ export function queueLines(queue, color) {
     const lines = [`${count(queue.total.timeline, "timeline item")} and ${count(queue.total.actions, "action")} from syncs after onboarding are waiting for a person.`];
     if (queue.truncated)
         lines.push(`Showing ${queue.timeline.length} and ${queue.actions.length}: the oldest first.`);
-    for (const [heading, items, timeline] of [["Timeline items", queue.timeline, true], ["Actions", queue.actions, false]]) {
-        if (items.length === 0)
-            continue;
-        lines.push("", `${heading}:`);
-        for (const item of items) {
-            const rows = itemRowLines(item, timeline, color);
-            lines.push("", rows[0], `  ${QUEUE_REASON[item.queuedFor ?? ""] ?? "waiting for review"}`, ...rows.slice(1));
+    const rowsOf = (items, timeline, filter) => items.filter(filter).map((item) => ({ item, timeline }));
+    const printRow = ({ item, timeline }) => {
+        const rows = itemRowLines(item, timeline, color);
+        lines.push("", rows[0], `  ${QUEUE_REASON[item.queuedFor ?? ""] ?? "waiting for review"}`, ...rows.slice(1));
+    };
+    // The split: suggested changes that need a decision first, then the new items to check. An older server sends neither, and the plain two lists stay.
+    const split = queue.counts !== undefined || [...queue.timeline, ...queue.actions].some((item) => item.needsDecision !== undefined);
+    if (split) {
+        const decide = (item) => item.needsDecision === true;
+        const decisions = [...rowsOf(queue.timeline, true, decide), ...rowsOf(queue.actions, false, decide)];
+        const check = [...rowsOf(queue.timeline, true, (item) => !decide(item)), ...rowsOf(queue.actions, false, (item) => !decide(item))];
+        for (const [heading, total, rows] of [
+            ["Needs your decision (a suggested change waits on each; decide it with `proposal`, or approve or dismiss the item)", queue.counts?.decisions ?? decisions.length, decisions],
+            ["New items to check", queue.counts?.toCheck ?? check.length, check],
+        ]) {
+            lines.push("", `${heading}: ${total}${total > rows.length ? `, showing ${rows.length}` : ""}`);
+            rows.forEach(printRow);
+        }
+    }
+    else {
+        for (const [heading, items, timeline] of [["Timeline items", queue.timeline, true], ["Actions", queue.actions, false]]) {
+            if (items.length === 0)
+                continue;
+            lines.push("", `${heading}:`);
+            items.forEach((item) => printRow({ item, timeline }));
         }
     }
     // The queue leaves out the onboarding's own items by design, so an empty one is not "all reviewed".
@@ -97,16 +130,58 @@ function valueText(value, label) {
     const text = Array.isArray(value) ? value.join(", ") : value;
     return label ? `${label} (${text})` : text;
 }
-function sourceLine(source) {
+export function sourceLine(source) {
     if (source.addedBy === "human")
         return `from a person: ${[source.url, source.note].filter(Boolean).join(" | ") || "(empty)"}`;
     const page = source.pageTitle ?? source.pageUrl ?? "a page";
     return `${page}${source.quote ? `: "${source.quote}"` : ""}${source.verified === false ? " (not found in the page)" : ""}`;
 }
+/** A person by name; "a teammate" when the door could not name them. Never the user id. */
+const person = (name) => name ?? "a teammate";
+const onDay = (at) => (at ? `, ${shortDate(at)}` : "");
+/**
+ * Who handled an item, in the page drawer's words: who added it, who edited or reviewed or dismissed it, who closed it,
+ * who archived it. A line appears only when the answer has a person id for it (a model's item has no adder), and
+ * carries the name the door filled in, never the id.
+ */
+export function handledByLines(item, timeline) {
+    const lines = [];
+    const human = item.origin === "human";
+    if (human && item.createdBy)
+        lines.push(`Added by ${person(item.createdByName)}${onDay(item.createdAt)}.`);
+    if (item.reviewStatus === "rejected" && item.reviewedBy)
+        lines.push(`Dismissed by ${person(item.reviewedByName)}${onDay(item.reviewedAt)}.`);
+    else if (item.reviewedBy && item.reviewStatus === "reviewed") {
+        const sameAsAdder = human && item.reviewedBy === item.createdBy && Math.abs(Date.parse(item.reviewedAt ?? "") - Date.parse(item.createdAt ?? "")) <= 1_000;
+        if (!sameAsAdder)
+            lines.push(`${human ? "Edited" : "Reviewed"} by ${person(item.reviewedByName)}${onDay(item.reviewedAt)}.`);
+    }
+    if (!timeline && item.status && item.status !== "open" && item.closedBy) {
+        const who = item.closedBy === "ai" ? "the model" : person(item.closedByName);
+        lines.push(item.status === "done" ? `Closed as done by ${who}${onDay(item.closedAt)}.` : `Dropped by ${who}${onDay(item.closedAt)}: the work no longer applied and was not done.`);
+    }
+    if (item.archivedAt && item.archivedBy)
+        lines.push(`Archived by ${person(item.archivedByName)}${onDay(item.archivedAt)}.`);
+    return lines;
+}
+/**
+ * What an add saved beyond its row, so a person can check it is their words (the help says to): the detail, cut to 200 characters, and the source
+ * (a link, a note, or both) a person gave. An add with neither prints nothing more.
+ */
+export function savedTextLines(detail) {
+    const lines = [];
+    const text = (detail.item.detail ?? "").replace(/\s+/g, " ").trim();
+    if (text !== "")
+        lines.push(`  Detail: ${[...text].length > 200 ? `${[...text].slice(0, 200).join("")}…` : text}`);
+    for (const source of (detail.evidence ?? []))
+        if (source.addedBy === "human")
+            lines.push(`  Source: ${[source.url, source.note].filter(Boolean).join(" | ") || "(empty)"}`);
+    return lines;
+}
 /** One item in full: the detail, the sources, every suggested change with its id, and what a sync changed and why. */
 export function itemDetailLines(detail, timeline, color) {
     const item = detail.item;
-    const lines = [...itemRowLines(item, timeline, color)];
+    const lines = [...itemRowLines(item, timeline, color), ...handledByLines(item, timeline).map((line) => `  ${line}`)];
     if (!timeline && detail.timelineItem)
         lines.push(`  From the meeting: ${detail.timelineItem.title}${detail.timelineItem.occurredAt ? ` (${detail.timelineItem.occurredAt})` : ""}`);
     if (timeline && detail.actions && detail.actions.length > 0)
@@ -124,6 +199,9 @@ export function itemDetailLines(detail, timeline, color) {
         for (const proposal of proposals) {
             const fields = Object.entries(proposal.fields).map(([name, value]) => `${name}: ${valueText(value, proposal.labels?.[name])}`);
             lines.push(`  ${proposal.id} (${proposal.kind}): ${fields.join("; ") || "no field change"}`);
+            // Why the model suggested it: the page and quote it cited, or "not found in the page" when the quote was not in what it was handed.
+            for (const source of proposal.sources ?? [])
+                lines.push(`    source: ${sourceLine(source)}`);
         }
         lines.push(`  Decide one with: cockpit manager proposal <id> <proposal id> accept|dismiss|add-new --version <version>${timeline ? " --timeline" : ""}`);
     }
@@ -147,7 +225,7 @@ export function clientDetailLines(client, color) {
         lines.push(`  ${client.storedPages} stored pages${client.incompletePages ? `, ${client.incompletePages} only partly handed over by Notion` : ""}`);
     const read = client.lastRead;
     if (read) {
-        lines.push(`  Last read: ${read.kind}, ${read.reason}, started ${read.startedAt}${read.finishedAt ? `, finished ${read.finishedAt}` : ", still running"}`);
+        lines.push(`  Last read: ${read.kind}, ${read.reason}, started ${managerTime(read.startedAt)}${read.finishedAt ? `, finished ${managerTime(read.finishedAt)}` : ", still running"}`);
         lines.push(`    ${read.pagesSeen} pages seen, ${read.pagesChanged} changed; ${read.opsApplied} changes applied, ${read.opsProposed} proposed, ${read.opsRejected} refused`);
     }
     else {
@@ -155,14 +233,34 @@ export function clientDetailLines(client, color) {
     }
     const rebuild = client.lastBriefRebuild;
     if (rebuild)
-        lines.push(`  Last Rebuild brief: ${rebuild.reason}, started ${rebuild.startedAt}, ${rebuild.pages} pages, ${rebuild.briefWritten ? "brief replaced" : "old brief kept"}`);
+        lines.push(`  Last Rebuild brief: ${rebuild.reason}, started ${managerTime(rebuild.startedAt)}, ${rebuild.pages} pages, ${rebuild.briefWritten ? "brief replaced" : "old brief kept"}`);
     return lines;
 }
+/** A summary check is not a read: what it decided about the card, from the receipt's `summary` (null: an older server, which does not say). */
+function summaryRunLines(run) {
+    const check = run.summary;
+    const outcome = check
+        ? check.cardWritten
+            ? "Card written."
+            : `Card kept${check.keptReason ? `: ${keptReasonText(check.keptReason)}` : ", nothing written"}.`
+        : "This receipt does not say whether the card was written.";
+    return [
+        `summary check of "Where we are" (not a read): ${readReasonText(run.reason)}`,
+        `  started ${managerTime(run.startedAt)}${run.finishedAt ? `, finished ${managerTime(run.finishedAt)}` : ", still running"}`,
+        `  ${outcome}${check?.refusal ? ` ${summaryRefusalText(check.refusal)}` : ""}`,
+        ...(check && (check.promptVersion || check.trigger) ? [`  ${[check.promptVersion ? `prompt ${check.promptVersion}` : null, check.trigger ? `started by ${summaryTriggerText(check.trigger)}` : null].filter(Boolean).join(", ")}`] : []),
+        ...(run.model ? [`  model ${run.model}${run.tokensIn !== null ? `, ${run.tokensIn} tokens in, ${run.tokensOut ?? 0} out` : ""}`] : []),
+        ...(run.clientId ? [`  client ${run.clientId}`] : []),
+        `  id ${run.id}`,
+    ];
+}
 /** One run's receipt: what it read, what it changed, and why it ended. */
 export function runLines(run) {
+    if (run.kind === "summary")
+        return summaryRunLines(run);
     return [
         `${run.kind} run: ${run.reason}`,
-        `  started ${run.startedAt}${run.finishedAt ? `, finished ${run.finishedAt}` : ", still running"}`,
+        `  started ${managerTime(run.startedAt)}${run.finishedAt ? `, finished ${managerTime(run.finishedAt)}` : ", still running"}`,
         `  ${run.pagesSeen} pages seen, ${run.pagesChanged} changed, ${run.pagesFetched} fetched, ${run.pagesArchived} archived; ${run.versionsConsumed} versions read`,
         `  ${run.opsApplied} changes applied, ${run.opsProposed} proposed, ${run.opsRejected} refused${run.batchNo !== null ? ` (batch ${run.batchNo})` : ""}`,
         ...(run.model ? [`  model ${run.model}${run.tokensIn !== null ? `, ${run.tokensIn} tokens in, ${run.tokensOut ?? 0} out` : ""}`] : []),

package/dist/commands/manager-requests.js

@@ -24,7 +24,7 @@ export function planManagerRequest(command, clientId, newRequestId) {
                 fields["next"] = command.next;
             if (command.blocker !== undefined)
                 fields["blocker"] = command.blocker;
-            return { method: "PATCH", path: `${BASE}/clients/${enc(clientId ?? "")}/summary`, body: fields, logFields: (a) => ({ fields: Object.keys(fields).filter((key) => key !== "expectedUpdatedAt"), source: stringField(a, "source"), bullets: arrayLength(a, "bullets") }) };
+            return { method: "PATCH", path: `${BASE}/clients/${enc(clientId ?? "")}/summary`, body: fields, logFields: (a) => ({ fields: Object.keys(fields).filter((key) => key !== "expectedUpdatedAt"), source: stringField(a, "source"), bullets: arrayLength(a, "bullets"), warnings: arrayLength(a, "warnings") }) };
         }
         case "run":
             return { method: "GET", path: `${BASE}/runs/${enc(command.runId ?? "")}`, logFields: () => ({}) };
@@ -68,6 +68,8 @@ export function planManagerRequest(command, clientId, newRequestId) {
             return write("PATCH", item, { ...seen, ...fields });
         }
         case "done": return write("POST", `${item}/status`, { ...seen, status: "done" });
+        // A dropped action was not done: the work no longer applies. Same door as done and reopen.
+        case "drop": return write("POST", `${item}/status`, { ...seen, status: "dropped" });
         case "reopen": return write("POST", `${item}/status`, { ...seen, status: "open" });
         case "link": return write("POST", `${item}/link`, { ...seen, timelineItemId: command.timelineItemId ?? null });
         case "approve": return write("POST", `${item}/review`, { ...seen, decision: "accept" });
@@ -102,8 +104,10 @@ function listQuery(command) {
 }
 function itemLog(table) {
     return (answer) => {
-        const item = answer && typeof answer === "object" ? answer.item : undefined;
-        return { table, item_id: item?.id ?? null, review_status: item?.reviewStatus ?? null };
+        const body = answer && typeof answer === "object" ? answer : undefined;
+        const item = body?.item;
+        // An add's `created` (false: a true retry, nothing written) is logged when the answer has it; an older server sends none.
+        return { table, item_id: item?.id ?? null, review_status: item?.reviewStatus ?? null, ...(typeof body?.created === "boolean" ? { created: body.created } : {}) };
     };
 }
 /** Home's log line: which parts it holds and their sizes, never their words. */