primcli 1.67.0 → 1.68.0

package/README.md

@@ -1052,17 +1052,30 @@ The SessionStart hook runs `primitive agent session-register --runtime claude --
 It gives the session an address once, named `<runtime>-<repository>`, using the
 saved member login, and only re-verifies on resume; a session whose agent was
 disconnected or removed never gets a second address. The SessionEnd hook runs
-`primitive agent session-end`, which disconnects only agents that
-`session-register` created, and only while the session's profile still holds
-that exact credential: an agent later connected into the same profile (for
-example with `primitive agent connect`) is left connected, and only the
-registered agent's own receive hooks are removed. Claude reports the same
-SessionEnd for a restart, a switch to another session and a real exit, so the
-hook waits five minutes before disconnecting, and a start of the same session
-within that time cancels the end. The end is recorded first, so a registration still
-running disconnects the agent it creates; when the local credential is gone it
+`primitive agent session-end`, which marks the session ended and removes its
+exact-session receive hooks, but keeps the agent's credential and profile, so
+closing a terminal does not cost the session its agent: resuming the session
+(for example `claude --resume <session>`) re-verifies the agent and reinstalls
+the hooks at the same address. Presence lapses on its own once the session
+stops running. Claude reports the same SessionEnd for a restart, a switch to
+another session and a real exit, so the hook waits five minutes first, and a
+start of the same session within that time cancels the end.
+
+An agent that `session-register` created is disconnected only when its session
+has not started again for 30 days, by `machine doctor --fix` or the next
+`session-register` on the machine, and only while the session's profile still
+holds that exact credential: an agent later connected into the same profile
+(for example with `primitive agent connect`) is never disconnected, and neither
+is one connected any other way. `primitive agent session-end --revoke`
+disconnects the agent at once instead; when its local credential is gone it
 revokes by address with the member login, and an unconfirmed disconnect is
-reported as `disconnect_pending` and retried by `machine doctor --fix`. Both always exit 0 and finish slow work in the
+reported as `disconnect_pending` and retried by `machine doctor --fix`. If a
+session's agent was already disconnected in Primitive, its next start reports
+it (status `revoked` or `ended`) instead of creating a new address; the owner
+can use Reconnect on the agent in the Primitive app, which invites the same
+address again, and paste that instruction into the session.
+
+Both commands always exit 0 and finish slow work in the
 background. Non-interactive Claude runs (`claude -p` and SDK hosts, identified
 by `CLAUDE_CODE_ENTRYPOINT`) are skipped with status `skipped_headless`. Codex
 sessions register from their SessionStart hook, with the instructions block as a
@@ -1220,6 +1233,17 @@ hooks print the same line as the live wake, including the load-the-skill line
 for verified mail (notices recorded by older CLI versions keep a shorter form
 with the same `to=` field and profile-selecting read command).
 
+Mail in one thread is announced once, by its newest message. A message whose
+thread already has newer mail (`newer=` above zero) does not wake the session
+on its own: the listener moves on to the newer one, and wakes for the held
+message only if nothing newer arrives within a few seconds. The hooks replay
+only the newest pending notice of each thread, followed by a line saying how
+many older pending messages in the thread it covers, and an older tick of a
+repeating message is dropped once a newer message in its thread is recorded.
+Reading a message, or replying to it from the session, also clears the pending
+notices for older messages in its thread, so a backlog left by a long gap never
+replays one message per turn.
+
 An exact reply that `primitive chat` or `primitive emails wait` returns inside
 a session is already handled: its pending notice for that session is removed,
 and a listener that receives the reply again (after a restart, or a redelivered

package/bin/claude-pending-mail.mjs

@@ -102,6 +102,7 @@ export function readPendingMail(configDir, profile, sessionId) {
         threadId: notice.thread_id?.toLowerCase() ?? null,
         inThread: notice.in_thread,
         newer: notice.newer,
+        receivedAt: Date.parse(notice.received_at),
         // Server-derived; an unreadable label is dropped, not the notice.
         interaction:
           notice.kind !== "status" &&
@@ -125,6 +126,56 @@ export function readPendingMail(configDir, profile, sessionId) {
   });
 }
 
+const REPEAT_TICK = "repeat.tick/1";
+
+/**
+ * One notice per thread: the newest mail notice in each thread stands for
+ * every older one, which it covers (reading or answering it clears them).
+ * A repeating message's tick that knows of newer mail in its thread is
+ * superseded even when that newer tick has no notice yet, since the newer
+ * one will arrive. Status notices and mail outside a thread are never
+ * collapsed. A kept notice carries `covered`, how many it stands for.
+ * Order is kept, so the oldest remaining notice still comes first.
+ */
+export function collapsePendingMail(notices) {
+  const newest = new Map();
+  notices.forEach((notice, index) => {
+    if (notice.kind === "status" || !notice.threadId) return;
+    const current = newest.get(notice.threadId);
+    if (
+      current === undefined ||
+      notice.receivedAt > notices[current].receivedAt ||
+      (notice.receivedAt === notices[current].receivedAt && index > current)
+    )
+      newest.set(notice.threadId, index);
+  });
+  const covered = new Map();
+  const kept = notices.filter((notice, index) => {
+    if (notice.kind === "status" || !notice.threadId) return true;
+    if (newest.get(notice.threadId) !== index) {
+      covered.set(notice.threadId, (covered.get(notice.threadId) ?? 0) + 1);
+      return false;
+    }
+    return !(
+      notice.interaction === REPEAT_TICK &&
+      Number.isSafeInteger(notice.newer) &&
+      notice.newer > 0
+    );
+  });
+  return kept.map((notice) =>
+    notice.kind !== "status" && notice.threadId && covered.get(notice.threadId)
+      ? { ...notice, covered: covered.get(notice.threadId) }
+      : notice,
+  );
+}
+
+/** The line after a notice that stands for older pending mail in its thread. */
+export function coveredLine(notice) {
+  const count = notice.covered;
+  if (!Number.isSafeInteger(count) || count < 1) return "";
+  return `${count === 1 ? "1 older pending message" : `${count} older pending messages`} in thread ${notice.threadId} ${count === 1 ? "is" : "are"} covered by ${notice.emailId}; reading or answering it clears ${count === 1 ? "that one" : "them"} too.\n`;
+}
+
 // Copies of WAKE_SENTENCES and the category mapping in
 // src/oclif/interaction-actions.ts; a test keeps them equal.
 export const WAKE_SENTENCES = {
@@ -234,6 +285,10 @@ const wakeSenderPattern = /^[a-z0-9._%+-]{1,64}@[a-z0-9.-]{1,253}$/;
  * line, including its load-the-skill line (naming `receiver.skillFile`).
  */
 export function formatPendingMail(notice, receiver = {}) {
+  return `${formatPendingLine(notice, receiver)}${coveredLine(notice)}`;
+}
+
+function formatPendingLine(notice, receiver) {
   if (notice.kind === "status")
     return `Primitive status arrived: ${notice.emailId}${recipientField(receiver.address)} from=${notice.sender} on_sent=${notice.refSentEmailId}. This is activity on a conversation this session started, not a new task.\n`;
   if (
@@ -475,7 +530,9 @@ async function main() {
         },
       );
     }
-    const notices = readPendingMail(configDir, profile, sessionId);
+    const notices = collapsePendingMail(
+      readPendingMail(configDir, profile, sessionId),
+    );
     if (notices.length) {
       const due = duePendingMail(configDir, profile, sessionId, notices);
       context(due, { profile, address, skillFile: claudeSkillFile(), cli });

package/bin/claude-wake.mjs

@@ -2,6 +2,7 @@ import { spawn, spawnSync } from "node:child_process";
 import {
   claudeSkillFile,
   clearDeliveredStatus,
+  collapsePendingMail,
   duePendingMail,
   formatPendingMail,
   readPendingMail,
@@ -180,7 +181,11 @@ try {
             configDir,
             profileName,
             session,
-            readPendingMail(configDir, profileName, session),
+            // Superseded notices never block Stop: only the newest notice
+            // in each thread is announced, standing for the older ones.
+            collapsePendingMail(
+              readPendingMail(configDir, profileName, session),
+            ),
           )
         : [];
     if (pending.length) {

package/dist/{api-command-Dh4hs7kh.js → api-command-D7DPn2Ro.js}

@@ -4875,6 +4875,19 @@ function write(configDir, profileName, session, notices) {
 		notices
 	});
 }
+const REPEAT_TICK = "repeat.tick/1";
+function receivedAt(row) {
+	return Date.parse(row.received_at);
+}
+/**
+* Whether `older` is a mail notice that `newer` covers: a mail notice in the
+* same thread, received before it. Reading or answering the newest message
+* in a thread covers every older pending one there; one received at the same
+* moment is not known to be older, so it stays.
+*/
+function coveredBy(older, newer) {
+	return older.kind === "mail" && older.thread_id !== null && older.thread_id === newer.thread_id && receivedAt(older) < Date.parse(newer.received_at);
+}
 /**
 * The notice list is full of unread mail. Nothing is dropped: the caller
 * leaves the event unacknowledged, so the mail stays queued and is
@@ -4899,7 +4912,7 @@ async function recordPendingMail(configDir, profileName, session, value) {
 	});
 	if (!row) throw new Error("Pending mail notice is invalid.");
 	return withMailLock(lockDirectory(configDir, profileName), () => {
-		const next = [...readPendingMail(configDir, profileName, session, true).filter((existing) => existing.email_id !== row.email_id), row];
+		const next = [...readPendingMail(configDir, profileName, session, true).filter((existing) => existing.email_id !== row.email_id && !(row.kind === "mail" && existing.interaction === REPEAT_TICK && coveredBy(existing, row))), row];
 		if (row.kind !== "status" && next.filter((existing) => existing.kind !== "status").length > 50) throw new PendingMailFullError();
 		while (next.length > 60) {
 			const status = next.findIndex((existing) => existing !== row && existing.kind === "status");
@@ -4929,28 +4942,77 @@ function pendingMailSessions(configDir, profileName) {
 	}
 }
 /**
-* Clear one email after a session read it, from that session's file only.
-* A read with no known runtime session (a terminal or script) clears
-* nothing: it is not evidence that any session has seen the email, and each
-* session keeps its notice until it reads the email itself.
+* Remove one email's notice and every older mail notice in its thread that
+* it covers. The thread and time come from the email's own notice, or from
+* `known` (the email as the API returned it) when it has none.
 */
-async function clearReadPendingMail(configDir, profileName, session, emailId) {
+async function removeCoveredPendingMail(configDir, profileName, session, emailId, known) {
+	const id = emailId.toLowerCase();
+	return withMailLock(lockDirectory(configDir, profileName), () => {
+		const current = readPendingMail(configDir, profileName, session, true);
+		const own = current.find((row) => row.email_id === id);
+		const anchor = own?.kind === "mail" ? own : known && typeof known.thread_id === "string" && UUID$1.test(known.thread_id.toLowerCase()) && Number.isFinite(Date.parse(known.received_at)) ? {
+			thread_id: known.thread_id.toLowerCase(),
+			received_at: known.received_at
+		} : null;
+		const next = current.filter((row) => row.email_id !== id && !(anchor !== null && coveredBy(row, anchor)));
+		if (next.length !== current.length) write(configDir, profileName, session, next);
+		return next;
+	});
+}
+/**
+* Clear one email after a session read it, from that session's file only,
+* with every older pending mail in its thread: reading the newest message
+* covers them. A read with no known runtime session (a terminal or script)
+* clears nothing: it is not evidence that any session has seen the email,
+* and each session keeps its notice until it reads the email itself.
+*/
+async function clearReadPendingMail(configDir, profileName, session, emailId, known) {
 	if (!session) return;
 	const sessions = pendingMailSessions(configDir, profileName).filter((id) => id === sessionId(session));
-	for (const id of sessions) await removePendingMail(configDir, profileName, id, [emailId]);
+	for (const id of sessions) await removeCoveredPendingMail(configDir, profileName, id, emailId, known);
 }
 /**
 * Clear one email's notices for a session after the session consumed it
 * without reading it by id: an exact reply that `primitive chat` or
 * `primitive emails wait` returned. Every profile of the session holding a
-* notice for the email is cleared, so a restarted wake does not announce a
-* reply the session already has. A key with no runtime session clears
-* nothing.
-*/
-async function clearConsumedPendingMail(configDir, sessionKey, emailId) {
+* notice for the email is cleared, with the older mail in its thread, so a
+* restarted wake does not announce a reply the session already has. A
+* listener leaves such a reply to the wait without writing a notice, so with
+* `known` (the reply's thread and time) the older notices in its thread are
+* also cleared for every profile of the session that receives at
+* `recipient`. A key with no runtime session clears nothing.
+*/
+async function clearConsumedPendingMail(configDir, sessionKey, emailId, known) {
 	const session = sessionKey?.slice(sessionKey.indexOf(":") + 1).toLowerCase();
 	if (!session || !UUID$1.test(session)) return;
-	for (const profile of pendingMailProfiles(configDir, session, emailId)) await removePendingMail(configDir, profile, session, [emailId]);
+	const profiles = new Set(pendingMailProfiles(configDir, session, emailId));
+	const anchor = typeof known?.thread_id === "string" && typeof known.received_at === "string" ? {
+		thread_id: known.thread_id,
+		received_at: known.received_at
+	} : null;
+	if (anchor && known?.recipient) for (const profile of receivingProfiles(configDir, session, known.recipient)) profiles.add(profile);
+	for (const profile of [...profiles].sort()) await removeCoveredPendingMail(configDir, profile, session, emailId, anchor);
+}
+/**
+* Profiles with a pending-mail file for the session whose connected address
+* is `recipient`.
+*/
+function receivingProfiles(configDir, session, recipient) {
+	let names;
+	try {
+		names = readdirSync(join(agentProfilesDirectory(configDir), "profiles"));
+	} catch {
+		return [];
+	}
+	const address = recipient.trim().toLowerCase();
+	return names.filter((name) => {
+		try {
+			return pendingMailSessions(configDir, name).includes(session) && loadConnectedAgentProfile(configDir, name)?.agent_address.toLowerCase() === address;
+		} catch {
+			return false;
+		}
+	});
 }
 /**
 * Record that this profile read one of its own pending emails and the API
@@ -5299,7 +5361,7 @@ function savedConnectedProfiles(configDir, exclude) {
 */
 async function otherProfiles(configDir, session, current) {
 	if (session) try {
-		const { connectedProfilesForSession } = await import("./machine-session-s6LvMvRd.js").then((n) => n.s);
+		const { connectedProfilesForSession } = await import("./machine-session-7bISVcRb.js").then((n) => n.s);
 		return {
 			inSession: true,
 			profiles: connectedProfilesForSession(configDir, session, current)