sentinelayer-cli 0.19.0 → 0.21.0

package/src/commands/session.js

@@ -1,7 +1,9 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { setTimeout as sleep } from "node:timers/promises";
 import { createHash, randomUUID } from "node:crypto";
+import { spawn as defaultSpawn } from "node:child_process";
 
 import pc from "picocolors";
 
@@ -26,6 +28,7 @@ import { createAgentEvent } from "../events/schema.js";
 import {
   detectStaleAgents,
   listAgents,
+  rememberAgentIdentity,
   registerAgent,
   unregisterAgent,
 } from "../session/agent-registry.js";
@@ -61,9 +64,11 @@ import {
 import { readSessionPreview } from "../session/preview.js";
 import {
   createSessionMessageAction,
+  fetchSessionPinnedMessages,
   listSessionMessageActions,
   listSessionsFromApi,
   probeSessionAccess,
+  pollSessionEvents,
   pollSessionEventsBefore,
   searchSessionEvents,
   syncSessionEventToApi,
@@ -85,8 +90,16 @@ import {
 import {
   createSessionCheckpoint,
   generateSessionCheckpoint,
+  generateSessionCheckpointBatch,
   listSessionCheckpoints,
 } from "../session/checkpoints.js";
+import {
+  buildCodexExecResumeInvocation,
+  buildCodexWakePrompt,
+  recordCodexWakeRegistration,
+  runCodexExecResume,
+} from "../session/wake/codex.js";
+import createSentid from "../session/wake/sentid.js";
 import { authLoginHint, preferredCliCommand } from "../ui/command-hints.js";
 import { parseCsvTokens } from "./ai/shared.js";
 
@@ -101,6 +114,164 @@ function normalizeString(value) {
   return String(value || "").trim();
 }
 
+const SESSION_SAY_CONFIRM_ATTEMPTS = 3;
+const SESSION_SAY_CONFIRM_DELAY_MS = 250;
+const SESSION_SAY_CONFIRM_PAGE_LIMIT = 200;
+const SESSION_SAY_CONFIRM_MAX_PAGES = 10;
+const SESSION_SAY_LOCAL_ONLY_REASONS = new Set([
+  "no_session",
+  "not_authenticated",
+  "remote_sync_disabled_env",
+]);
+
+function isLocalOnlySessionSayReason(reason) {
+  return SESSION_SAY_LOCAL_ONLY_REASONS.has(normalizeString(reason));
+}
+
+function sessionEventMatchesClientMessageId(event, clientMessageId) {
+  const normalizedClientMessageId = normalizeString(clientMessageId);
+  if (!normalizedClientMessageId || !event || typeof event !== "object") {
+    return false;
+  }
+  const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
+  const candidates = [
+    event.id,
+    event.eventId,
+    event.event_id,
+    event.idempotencyToken,
+    event.idempotency_token,
+    event.clientMessageId,
+    event.client_message_id,
+    payload.id,
+    payload.messageId,
+    payload.message_id,
+    payload.eventId,
+    payload.event_id,
+    payload.idempotencyToken,
+    payload.idempotency_token,
+    payload.clientMessageId,
+    payload.client_message_id,
+  ];
+  return candidates.some((candidate) => normalizeString(candidate) === normalizedClientMessageId);
+}
+
+async function readSessionConfirmationAnchor(sessionId, { targetPath } = {}) {
+  const result = await pollSessionEventsBefore(sessionId, {
+    targetPath,
+    limit: 1,
+    forceCircuitProbe: true,
+  });
+  if (!result?.ok) {
+    return {
+      ok: false,
+      reason: normalizeString(result?.reason) || "confirmation_anchor_failed",
+      cursor: null,
+    };
+  }
+  const events = Array.isArray(result.events) ? result.events : [];
+  const lastEvent = events[events.length - 1] || null;
+  return {
+    ok: true,
+    reason: "",
+    cursor: normalizeString(lastEvent?.cursor) || normalizeString(result.cursor) || null,
+    sequenceId: Number(lastEvent?.sequenceId ?? lastEvent?.sequence_id) || null,
+  };
+}
+
+async function confirmSessionEventVisible(sessionId, clientMessageId, { targetPath, anchorCursor = null } = {}) {
+  let lastReason = "not_visible";
+  let checked = 0;
+  let pages = 0;
+  const normalizedAnchorCursor = normalizeString(anchorCursor) || null;
+  for (let attempt = 1; attempt <= SESSION_SAY_CONFIRM_ATTEMPTS; attempt += 1) {
+    let pageCursor = normalizedAnchorCursor;
+    for (let page = 1; page <= SESSION_SAY_CONFIRM_MAX_PAGES; page += 1) {
+      pages += 1;
+      const result = await pollSessionEvents(sessionId, {
+        targetPath,
+        since: pageCursor,
+        limit: SESSION_SAY_CONFIRM_PAGE_LIMIT,
+        forceCircuitProbe: true,
+      });
+      if (!result?.ok) {
+        lastReason = normalizeString(result?.reason) || "confirmation_poll_failed";
+        break;
+      }
+      const events = Array.isArray(result.events) ? result.events : [];
+      checked += events.length;
+      const confirmedEvent = events.find((candidate) => sessionEventMatchesClientMessageId(candidate, clientMessageId));
+      if (confirmedEvent) {
+        return {
+          confirmed: true,
+          reason: "",
+          checked,
+          pages,
+          anchorCursor: normalizedAnchorCursor,
+          event: confirmedEvent,
+        };
+      }
+      lastReason = "not_visible";
+      const nextCursor = normalizeString(result.cursor);
+      if (!events.length || !nextCursor || nextCursor === pageCursor) {
+        break;
+      }
+      pageCursor = nextCursor;
+    }
+    if (attempt < SESSION_SAY_CONFIRM_ATTEMPTS) {
+      await sleep(SESSION_SAY_CONFIRM_DELAY_MS);
+    }
+  }
+  return {
+    confirmed: false,
+    reason: lastReason,
+    checked,
+    pages,
+    anchorCursor: normalizedAnchorCursor,
+  };
+}
+
+function formatSessionListText(value, { maxLength = 80 } = {}) {
+  const normalized = normalizeString(value)
+    .replace(/[\r\n\t]+/g, " ")
+    .replace(/\s+/g, " ")
+    .replace(/"/g, "'");
+  if (!normalized) {
+    return "";
+  }
+  const limit = Math.max(8, Number(maxLength) || 80);
+  return normalized.length > limit
+    ? `${normalized.slice(0, Math.max(0, limit - 3)).trimEnd()}...`
+    : normalized;
+}
+
+function sessionListCodebaseLabel(value) {
+  const normalized = formatSessionListText(value, { maxLength: 120 });
+  if (!normalized) {
+    return "";
+  }
+  const segments = normalized.split(/[\\/]+/).filter(Boolean);
+  if (segments.length <= 2) {
+    return formatSessionListText(normalized, { maxLength: 80 });
+  }
+  return formatSessionListText(`.../${segments.slice(-2).join("/")}`, {
+    maxLength: 80,
+  });
+}
+
+export function formatSessionListLine(item = {}) {
+  const sessionId = normalizeString(item.sessionId) || "unknown-session";
+  const status = normalizeString(item.status) || "unknown";
+  const archiveStatus = normalizeString(item.archiveStatus);
+  const archive = archiveStatus ? ` archive=${archiveStatus}` : "";
+  const title = formatSessionListText(item.title || item.summaryText, { maxLength: 72 });
+  const codebase = sessionListCodebaseLabel(item.codebasePath);
+  const titlePart = title ? ` title="${title}"` : "";
+  const codebasePart = codebase ? ` codebase="${codebase}"` : "";
+  const created = item.createdAt || "?";
+  const lastActivity = item.lastActivityAt ? ` last=${item.lastActivityAt}` : "";
+  return `${sessionId} status=${status}${archive}${titlePart}${codebasePart} created=${created}${lastActivity}`;
+}
+
 const SESSION_MESSAGE_ACTION_TYPES = new Set([
   "ack",
   "working_on",
@@ -150,7 +321,7 @@ const SESSION_MESSAGE_ACTION_DESCRIPTIONS = Object.freeze([
   {
     type: "view",
     command: "sl session view <id> <sequence>",
-    description: "Record a read receipt for a target message.",
+    description: "Manually backfill a read receipt for a target message; remote reads record views automatically.",
   },
 ]);
 
@@ -219,6 +390,7 @@ function actionDisplayMessage(action = {}) {
 function buildSessionActionEvent(sessionId, action = {}) {
   const actionType = normalizeString(action.actionType ?? action.action_type).toLowerCase();
   if (!SESSION_MESSAGE_ACTION_TYPES.has(actionType)) return null;
+  if (actionType === "view") return null;
   const id =
     normalizeString(action.id) ||
     shortSha256(
@@ -265,6 +437,91 @@ function buildSessionActionEvents(sessionId, actions = []) {
     .filter(Boolean);
 }
 
+function readProjectionUnacknowledgedHumanMessages(remoteActions = null) {
+  const messages = remoteActions?.projection?.unacknowledgedHumanMessages;
+  return Array.isArray(messages)
+    ? messages
+        .filter((event) => event && typeof event === "object")
+        .sort((left, right) => humanAskSortValue(right) - humanAskSortValue(left))
+    : [];
+}
+
+function messageActionCreatedMs(action = {}) {
+  const epoch = Date.parse(normalizeString(action.createdAt || action.created_at || action.ts || action.timestamp));
+  return Number.isFinite(epoch) ? epoch : 0;
+}
+
+function messageActionActorId(action = {}) {
+  return normalizeString(action.actorId || action.actor_id || action.agentId || action.agent_id) || "unknown";
+}
+
+function isHumanMessageAction(action = {}) {
+  if (action?.isHumanActivity === true) return true;
+  if (normalizeString(action.actorKind || action.actor_kind).toLowerCase() === "human") return true;
+  return messageActionActorId(action).startsWith("human-");
+}
+
+function readProjectionRecentHumanActivity(remoteActions = null) {
+  const projected = remoteActions?.projection?.recentActivity;
+  const source = Array.isArray(projected) && projected.length > 0 ? projected : remoteActions?.actions;
+  return Array.isArray(source)
+    ? source
+        .filter((action) => action && typeof action === "object" && isHumanMessageAction(action))
+        .sort((left, right) => {
+          const timeDiff = messageActionCreatedMs(right) - messageActionCreatedMs(left);
+          if (timeDiff !== 0) return timeDiff;
+          return normalizeString(right.id).localeCompare(normalizeString(left.id));
+        })
+    : [];
+}
+
+function formatMessageActionActivityLine(action = {}) {
+  const actionType = normalizeString(action.actionType || action.action_type) || "action";
+  const targetSequence = Number(action.targetSequenceId ?? action.target_sequence_id ?? 0);
+  const targetActionId = normalizeString(action.targetActionId || action.target_action_id);
+  const target = targetActionId
+    ? `action:${targetActionId}`
+    : targetSequence > 0
+      ? `#${Math.floor(targetSequence)}`
+      : normalizeString(action.targetCursor || action.target_cursor) || "unknown-target";
+  const ts = normalizeString(action.createdAt || action.created_at || action.ts || action.timestamp);
+  const note = normalizeString(action.note || action.message || "");
+  const shortNote = note.length > 220 ? `${note.slice(0, 217)}...` : note;
+  const suffix = shortNote ? `: ${shortNote}` : "";
+  return `${actionType} ${target} by ${messageActionActorId(action)}${ts ? ` ${ts}` : ""}${suffix}`;
+}
+
+function humanAskSequence(event = {}) {
+  const value = Number(event.sequenceId ?? event.sequence_id ?? event.sequence ?? 0);
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : null;
+}
+
+function humanAskAgentId(event = {}) {
+  return normalizeString(event.agent?.id || event.agentId || event.agent_id) || "human";
+}
+
+function humanAskMessage(event = {}) {
+  const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
+  return normalizeString(payload.message || payload.note || payload.reason || "");
+}
+
+function humanAskSortValue(event = {}) {
+  const sequence = humanAskSequence(event);
+  if (sequence) return sequence;
+  const epoch = Date.parse(normalizeString(event.ts || event.timestamp || event.createdAt || event.created_at));
+  return Number.isFinite(epoch) ? epoch : 0;
+}
+
+function formatHumanAskLine(event = {}) {
+  const sequence = humanAskSequence(event);
+  const sequenceLabel = sequence ? `#${sequence}` : normalizeString(event.cursor) || "unsequenced";
+  const ts = normalizeString(event.ts || event.timestamp || event.createdAt || event.created_at);
+  const message = humanAskMessage(event);
+  const shortMessage = message.length > 220 ? `${message.slice(0, 217)}...` : message;
+  const suffix = shortMessage ? `: ${shortMessage}` : "";
+  return `${sequenceLabel} ${humanAskAgentId(event)}${ts ? ` ${ts}` : ""}${suffix}`;
+}
+
 function eventTimestampMs(event = {}) {
   for (const key of ["ts", "timestamp", "createdAt", "at"]) {
     const epoch = Date.parse(normalizeString(event?.[key]));
@@ -329,6 +586,99 @@ function defaultActionIdempotencyKey({
   return `cli:${normalizeString(actionType).toLowerCase()}:${target}:${actor}:${noteHash}`;
 }
 
+function sessionReadViewTarget(event = {}) {
+  const eventType = normalizeString(event.event || event.type).toLowerCase();
+  if (eventType !== "session_message" || isSessionControlEvent(event)) {
+    return null;
+  }
+  const targetSequenceId = eventSequenceNumber(event);
+  const targetCursor = normalizeString(event.cursor);
+  if (!targetSequenceId && !targetCursor) {
+    return null;
+  }
+  return {
+    key: targetSequenceId ? `seq:${targetSequenceId}` : `cursor:${targetCursor}`,
+    targetSequenceId: targetSequenceId || null,
+    targetCursor,
+  };
+}
+
+async function recordSessionReadViews(sessionId, events = [], {
+  targetPath,
+  agentId,
+  enabled = false,
+  maxTargets = 50,
+} = {}) {
+  const maxAutoViewTargets = Math.max(0, Math.min(200, Number(maxTargets) || 0));
+  const summary = {
+    enabled: Boolean(enabled),
+    agentId: normalizeString(agentId) || "cli-user",
+    targetCount: 0,
+    attempted: 0,
+    recorded: 0,
+    duplicates: 0,
+    failed: 0,
+    skipped: 0,
+    reason: "",
+  };
+  if (!summary.enabled) {
+    summary.reason = "disabled";
+    return summary;
+  }
+
+  const seenTargets = new Set();
+  const targets = [];
+  for (const event of Array.isArray(events) ? events : []) {
+    const target = sessionReadViewTarget(event);
+    if (!target || seenTargets.has(target.key)) {
+      continue;
+    }
+    seenTargets.add(target.key);
+    targets.push(target);
+  }
+  summary.targetCount = targets.length;
+
+  const writeTargets = maxAutoViewTargets > 0 ? targets.slice(-maxAutoViewTargets) : [];
+  summary.skipped = Math.max(0, targets.length - writeTargets.length);
+  if (summary.skipped > 0) {
+    summary.reason = "target_cap_reached";
+  }
+
+  for (const target of writeTargets) {
+    const result = await createSessionMessageAction(sessionId, {
+      actionType: "view",
+      targetPath,
+      targetSequenceId: target.targetSequenceId,
+      targetCursor: target.targetCursor,
+      metadata: {
+        source: "cli_read",
+        agentId: summary.agentId,
+      },
+      idempotencyKey: defaultActionIdempotencyKey({
+        actionType: "view",
+        targetSequenceId: target.targetSequenceId,
+        targetCursor: target.targetCursor,
+        agentId: summary.agentId,
+      }),
+      timeoutMs: 15_000,
+    });
+    summary.attempted += 1;
+    if (result?.ok && result.action) {
+      summary.recorded += 1;
+      if (result.duplicate) {
+        summary.duplicates += 1;
+      }
+      continue;
+    }
+    summary.failed += 1;
+    summary.reason = normalizeString(result?.reason) || "view_write_failed";
+    summary.skipped = Math.max(0, targets.length - summary.attempted);
+    break;
+  }
+
+  return summary;
+}
+
 function compareIsoDesc(left = "", right = "") {
   return normalizeString(right).localeCompare(normalizeString(left));
 }
@@ -402,6 +752,10 @@ function parsePositiveInteger(rawValue, field, fallbackValue) {
   return Math.floor(normalized);
 }
 
+function parsePositiveMillisecondsFromSeconds(rawValue, field, fallbackSeconds) {
+  return parsePositiveInteger(rawValue, field, fallbackSeconds) * 1000;
+}
+
 function normalizeComparablePath(value) {
   return String(value || "")
     .trim()
@@ -961,6 +1315,140 @@ function normalizeAgentId(value, fallbackValue = "cli-user") {
   return normalized || fallbackValue;
 }
 
+function canPublishListenerPresence(agentId) {
+  const normalized = normalizeAgentId(agentId, "");
+  if (!normalized) return false;
+  if (["cli-user", "unknown", "human", "user", "operator"].includes(normalized)) return false;
+  return !(
+    normalized.startsWith("human-") ||
+    normalized.startsWith("user-") ||
+    normalized.startsWith("guest-")
+  );
+}
+
+function listenerLifecycleEventName(type = "") {
+  const normalized = normalizeString(type).toLowerCase();
+  if (normalized === "started") return "session_listener_started";
+  if (normalized === "stopped") return "session_listener_stopped";
+  return "session_listener_heartbeat";
+}
+
+function compactPayload(record = {}) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([, value]) => value !== undefined)
+  );
+}
+
+async function publishListenerPresenceEvent({
+  sessionId,
+  targetPath,
+  agentId,
+  agentModel = "cli",
+  displayName = "",
+  listenerId,
+  lifecycle = {},
+} = {}) {
+  const normalizedType = normalizeString(lifecycle.type) || "heartbeat";
+  const eventName = listenerLifecycleEventName(normalizedType);
+  const event = createAgentEvent({
+    event: eventName,
+    sessionId,
+    agent: {
+      id: agentId,
+      model: normalizeString(agentModel) || "cli",
+      role: "listener",
+      displayName: normalizeString(displayName) || agentId,
+      clientKind: "cli",
+    },
+    eventId: `session-listener-${listenerId}-${normalizedType}-${lifecycle.pollCount ?? 0}`,
+    idempotencyToken: `session-listener:${listenerId}:${normalizedType}:${lifecycle.pollCount ?? 0}`,
+    payload: compactPayload({
+      source: "session_listen",
+      listenerId,
+      lifecycle: normalizedType,
+      state: normalizeString(lifecycle.state) || normalizedType,
+      active: lifecycle.active,
+      cursor: lifecycle.cursor || null,
+      cursorSuffix: lifecycle.cursorSuffix,
+      cursorSource: lifecycle.cursorSource,
+      pollCount: lifecycle.pollCount,
+      matched: lifecycle.matched,
+      emitted: lifecycle.emitted,
+      persistedCursor: lifecycle.persistedCursor,
+      idleIntervalSeconds: lifecycle.idleIntervalSeconds,
+      activeIntervalSeconds: lifecycle.activeIntervalSeconds,
+      activeWindowSeconds: lifecycle.activeWindowSeconds,
+      lastHumanActivityAt: lifecycle.lastHumanActivityAt,
+      lastSleepMs: lifecycle.lastSleepMs,
+      nextPollMs: lifecycle.nextPollMs,
+      reason: lifecycle.reason || null,
+      startedAt: lifecycle.startedAt,
+      stoppedAt: lifecycle.stoppedAt,
+      aborted: lifecycle.aborted,
+      stopping: lifecycle.stopping,
+    }),
+  });
+  return syncSessionEventToApi(sessionId, event, { targetPath });
+}
+
+function formatListenerCatchupNotice(catchup = {}) {
+  const eventCount = Number(catchup.eventCount || 0);
+  const matchingEventCount = Number(catchup.matchingEventCount || 0);
+  const range = catchup.oldestEventAt && catchup.newestEventAt
+    ? ` (${catchup.oldestEventAt} -> ${catchup.newestEventAt})`
+    : "";
+  return [
+    `Listener catch-up from stored cursor ${catchup.cursor || "<none>"}:`,
+    `${eventCount} event${eventCount === 1 ? "" : "s"} in this page`,
+    `${matchingEventCount} addressed/broadcast to this agent${range}.`,
+    "Use --from-now only when you intentionally want to skip old backlog.",
+  ].join(" ");
+}
+
+function buildListenerCatchupEvent({
+  sessionId,
+  agentId,
+  agentModel = "cli",
+  displayName = "",
+  listenerId,
+  catchup = {},
+} = {}) {
+  const message = formatListenerCatchupNotice(catchup);
+  const pollCount = Number(catchup.pollCount || 0);
+  return createAgentEvent({
+    event: "session_listen_catchup",
+    sessionId,
+    agent: {
+      id: agentId,
+      model: normalizeString(agentModel) || "cli",
+      role: "listener",
+      displayName: normalizeString(displayName) || agentId,
+      clientKind: "cli",
+    },
+    eventId: `session-listener-${listenerId}-catchup-${pollCount}`,
+    idempotencyToken: `session-listener:${listenerId}:catchup:${pollCount}`,
+    payload: compactPayload({
+      source: "session_listen",
+      listenerId,
+      lifecycle: "catchup",
+      state: "catching_up",
+      message,
+      cursor: catchup.cursor || null,
+      candidateCursor: catchup.candidateCursor || null,
+      cursorSuffix: catchup.cursorSuffix,
+      cursorSource: catchup.cursorSource,
+      pollCount,
+      eventCount: Number(catchup.eventCount || 0),
+      matchingEventCount: Number(catchup.matchingEventCount || 0),
+      preStartEventCount: Number(catchup.preStartEventCount || 0),
+      limit: Number(catchup.limit || 0) || undefined,
+      replay: Boolean(catchup.replay),
+      oldestEventAt: catchup.oldestEventAt || null,
+      newestEventAt: catchup.newestEventAt || null,
+    }),
+  });
+}
+
 // Preserve the literal default identity for `session say`. This command is
 // often used by agents as a low-friction relay; silently rewriting the default
 // `cli-user` to the authenticated human makes a forgotten --agent flag look
@@ -973,6 +1461,217 @@ async function defaultAgentId(value, _targetPath) {
   return resolveSessionSayAgentId(value);
 }
 
+function formatAgentIdList(agentIds = []) {
+  const normalized = agentIds.map((agentId) => normalizeString(agentId)).filter(Boolean);
+  if (!normalized.length) return "";
+  if (normalized.length <= 3) return normalized.join(", ");
+  return `${normalized.slice(0, 3).join(", ")} +${normalized.length - 3} more`;
+}
+
+export function sessionSayRegistryRole(value) {
+  const normalized = normalizeString(value).toLowerCase();
+  if (["coder", "reviewer", "tester", "daemon", "observer", "persona"].includes(normalized)) {
+    return normalized;
+  }
+  return "coder";
+}
+
+export async function resolveSessionSayIdentity({
+  sessionId,
+  agentId = "",
+  targetPath = process.cwd(),
+  env = process.env,
+} = {}) {
+  const explicitAgentId = normalizeString(agentId);
+  if (explicitAgentId) {
+    return {
+      agentId: resolveSessionSayAgentId(explicitAgentId),
+      source: "option",
+      identityWarning: "",
+      candidateAgentIds: [],
+    };
+  }
+
+  const envAgentId = normalizeString(env?.SENTINELAYER_AGENT_ID || env?.SENTI_AGENT_ID);
+  if (envAgentId && canPublishListenerPresence(envAgentId)) {
+    return {
+      agentId: resolveSessionSayAgentId(envAgentId),
+      source: "env",
+      identityWarning: "",
+      candidateAgentIds: [],
+    };
+  }
+
+  let candidateAgentIds = [];
+  try {
+    const agents = await listAgents(sessionId, { targetPath, includeInactive: false });
+    candidateAgentIds = agents
+      .map((agent) => normalizeString(agent.agentId))
+      .filter((candidate) => canPublishListenerPresence(candidate));
+  } catch {
+    candidateAgentIds = [];
+  }
+
+  if (candidateAgentIds.length === 1) {
+    return {
+      agentId: resolveSessionSayAgentId(candidateAgentIds[0]),
+      source: "local-agent",
+      identityWarning: "",
+      candidateAgentIds,
+    };
+  }
+
+  const warningReason = candidateAgentIds.length > 1
+    ? `multiple local joined agents are active (${formatAgentIdList(candidateAgentIds)})`
+    : envAgentId && !canPublishListenerPresence(envAgentId)
+      ? `configured SENTINELAYER_AGENT_ID '${envAgentId}' is reserved or human-scoped`
+      : "no agent identity is configured";
+
+  return {
+    agentId: "cli-user",
+    source: "fallback",
+    identityWarning: `session say is sending as cli-user because ${warningReason}; pass --agent <id>, set SENTINELAYER_AGENT_ID, or run session join --agent <id> before posting.`,
+    candidateAgentIds,
+  };
+}
+
+export function shouldBlockImplicitCliUserSessionSay(identity = {}) {
+  return identity?.source === "fallback" && normalizeString(identity?.agentId) === "cli-user";
+}
+
+/**
+ * Wake hook for `session listen --wake "<command>"`. This is the reusable
+ * notify->resume bridge: when the listener emits an event addressed to this
+ * agent (or broadcast — including low-noise actions like ack/like), it runs a
+ * host command so the host can resume/wake its agent. The event JSON is piped
+ * to the command's stdin and key fields are exposed as SL_WAKE_* env vars.
+ *
+ * Bursts are coalesced: if a wake is already running, the latest event is
+ * queued and fired once when the current one finishes, so a flood of activity
+ * triggers one trailing wake instead of a storm of processes.
+ */
+export function createSessionWakeRunner({
+  command,
+  sessionId,
+  agentId,
+  emit = () => {},
+  spawnImpl = defaultSpawn,
+} = {}) {
+  const wakeCommand = normalizeString(command);
+  let busy = false;
+  let pending = null;
+
+  const run = (event) => {
+    if (!wakeCommand) return;
+    if (busy) {
+      pending = event ?? {};
+      return;
+    }
+    busy = true;
+    const env = {
+      ...process.env,
+      SL_WAKE_SESSION_ID: normalizeString(sessionId),
+      SL_WAKE_AGENT_ID: normalizeString(agentId),
+      SL_WAKE_EVENT_TYPE: normalizeString(event?.event),
+      SL_WAKE_EVENT_CURSOR: normalizeString(event?.cursor),
+      SL_WAKE_EVENT_SEQUENCE: String(event?.sequenceId ?? event?.sequence_id ?? ""),
+      SL_WAKE_ACTOR_ID: normalizeString(event?.agent?.id || event?.agentId),
+    };
+    let child;
+    try {
+      child = spawnImpl(wakeCommand, { shell: true, env, stdio: ["pipe", "ignore", "ignore"] });
+    } catch (error) {
+      busy = false;
+      emit({ status: "error", reason: normalizeString(error?.message) || "spawn_failed" });
+      return;
+    }
+    emit({
+      status: "fired",
+      eventType: env.SL_WAKE_EVENT_TYPE,
+      cursor: env.SL_WAKE_EVENT_CURSOR,
+      actorId: env.SL_WAKE_ACTOR_ID,
+    });
+    try {
+      if (child && child.stdin) {
+        child.stdin.write(JSON.stringify(event ?? {}));
+        child.stdin.end();
+      }
+    } catch {
+      // Broken pipe (command ignored stdin) is non-fatal for a wake hook.
+    }
+    const finish = (reason) => {
+      busy = false;
+      if (reason) emit({ status: "error", reason });
+      const next = pending;
+      pending = null;
+      if (next !== null) run(next);
+    };
+    if (child && typeof child.on === "function") {
+      child.on("error", (error) => finish(normalizeString(error?.message) || "wake_failed"));
+      child.on("exit", (code) => finish(code && code !== 0 ? `exit_${code}` : ""));
+    } else {
+      finish("");
+    }
+  };
+
+  return { trigger: run, hasCommand: Boolean(wakeCommand) };
+}
+
+// Message actions (ack/like/dislike/reply/view/working_on) must be authored by
+// a concrete agent identity. The CLI's bare `cli-user` default is a reserved
+// label the API rejects (api_422), so treat it as "unset" and resolve the real
+// agent the same way `session say` does (explicit --agent > SENTINELAYER_AGENT_ID
+// > the single joined agent). Returns the resolved identity; callers should use
+// shouldBlockImplicitCliUserSessionSay() to refuse the implicit cli-user
+// fallback before sending a request that is guaranteed to fail.
+export async function resolveMessageActionIdentity({
+  sessionId,
+  optionAgent = "",
+  targetPath = process.cwd(),
+  env = process.env,
+} = {}) {
+  const explicit = normalizeString(optionAgent);
+  const agentSeed = explicit && explicit.toLowerCase() !== "cli-user" ? explicit : "";
+  return resolveSessionSayIdentity({ sessionId, agentId: agentSeed, targetPath, env });
+}
+
+async function ensureSessionSayAgentRegistered(
+  sessionId,
+  agent = {},
+  { targetPath = process.cwd() } = {},
+) {
+  const agentId = normalizeString(agent.id);
+  if (!canPublishListenerPresence(agentId)) {
+    return { persisted: false, reason: "placeholder_agent" };
+  }
+
+  try {
+    const activeAgents = await listAgents(sessionId, { targetPath, includeInactive: false });
+    if (
+      activeAgents.some(
+        (existing) => normalizeString(existing.agentId).toLowerCase() === agentId.toLowerCase(),
+      )
+    ) {
+      return { persisted: false, reason: "already_registered" };
+    }
+  } catch {
+    // If the local registry is unreadable, let rememberAgentIdentity surface the
+    // filesystem problem with its normal error message.
+  }
+
+  const registered = await rememberAgentIdentity(sessionId, {
+    agentId,
+    model: normalizeString(agent.model) || "cli",
+    role: sessionSayRegistryRole(agent.role),
+    targetPath,
+  });
+
+  return {
+    persisted: true,
+    agentId: registered.agentId,
+  };
+}
+
 async function resolveSessionAgentEnvelope(
   sessionId,
   agentId,
@@ -1062,6 +1761,13 @@ function formatEventLine(event = {}) {
   return `${ts} ${agentId} ${type}`;
 }
 
+function isSessionControlEvent(event = {}) {
+  const payload = event?.payload && typeof event.payload === "object" ? event.payload : {};
+  const type = normalizeString(event.event || event.type).toLowerCase();
+  if (type.startsWith("session_listener_")) return true;
+  return normalizeString(payload.source).toLowerCase() === "session_listen";
+}
+
 function checkpointSequenceRange(checkpoint = {}) {
   const start = Number(checkpoint.startSequence || 0);
   const end = Number(checkpoint.endSequence || 0);
@@ -1926,6 +2632,7 @@ export function registerSessionCommand(program) {
         awaitRemoteSync: Boolean(explicitAgent),
       });
       const agentJoinRelayed =
+        joined.emittedJoinEvent !== false &&
         Boolean(explicitAgent) &&
         Boolean(resolvedAgentId) &&
         resolvedAgentId !== "cli-user" &&
@@ -1980,7 +2687,10 @@ export function registerSessionCommand(program) {
   session
     .command("say <sessionId> <message>")
     .description("Send a message to the session")
-    .option("--agent <id>", "Agent id to emit from", "cli-user")
+    .option(
+      "--agent <id>",
+      "Agent id to emit from; defaults to SENTINELAYER_AGENT_ID, then the sole local joined agent, then cli-user",
+    )
     .option(
       "--model <model>",
       "Agent model/provider hint; defaults to local joined agent metadata or SENTINELAYER_AGENT_MODEL",
@@ -1999,6 +2709,8 @@ export function registerSessionCommand(program) {
     .option("--to <agent>", "Direct the message to a specific agent id")
     .option("--reply-to <sequence>", "Mark this message as a reply to a target sequence id")
     .option("--reply-cursor <cursor>", "Mark this message as a reply to a target event cursor")
+    .option("--force-cli-user", "Allow fallback sends as cli-user when no agent identity can be resolved")
+    .option("--local-only", "Append only to the local session cache without remote send confirmation")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
     .action(async (sessionId, message, options, command) => {
@@ -2011,16 +2723,28 @@ export function registerSessionCommand(program) {
         throw new Error("message is required.");
       }
       const targetPath = path.resolve(process.cwd(), String(options.path || "."));
-      const agentId = await defaultAgentId(options.agent, targetPath);
+      const identity = await resolveSessionSayIdentity({
+        sessionId: normalizedSessionId,
+        agentId: options.agent,
+        targetPath,
+      });
+      const agentId = identity.agentId;
+      if (shouldBlockImplicitCliUserSessionSay(identity) && !options.forceCliUser) {
+        throw new Error(
+          `${identity.identityWarning} Re-run with --force-cli-user only for intentional anonymous/operator relay posts.`,
+        );
+      }
       const localSession = await ensureLocalSessionForRemoteCommand(normalizedSessionId, {
         targetPath,
       });
       const to = normalizeString(options.to);
       const replyToSequenceId = parseOptionalPositiveInteger(options.replyTo, "reply-to");
       const replyToCursor = normalizeString(options.replyCursor);
+      const clientMessageId = `cli-${randomUUID()}`;
       const eventPayload = {
         message: normalizedMessage,
         channel: "session",
+        clientMessageId,
       };
       if (to) {
         eventPayload.to = to;
@@ -2031,13 +2755,15 @@ export function registerSessionCommand(program) {
       if (replyToCursor) {
         eventPayload.replyToCursor = replyToCursor;
       }
-      const clientMessageId = `cli-${randomUUID()}`;
       const agent = await resolveSessionAgentEnvelope(normalizedSessionId, agentId, {
         targetPath,
         model: options.model,
         role: options.role,
         displayName: options.displayName,
       });
+      const agentRegistration = await ensureSessionSayAgentRegistered(normalizedSessionId, agent, {
+        targetPath,
+      });
       const event = createAgentEvent({
         event: "session_message",
         agent,
@@ -2047,7 +2773,22 @@ export function registerSessionCommand(program) {
       event.eventId = clientMessageId;
       event.idempotencyToken = clientMessageId;
       let remoteSync = null;
-      if (localSession.materialized) {
+      let remoteConfirmation = null;
+      let remoteConfirmationAnchor = null;
+      let localOnly = Boolean(options.localOnly) || remoteSessionLookupDisabled();
+      if (!localOnly) {
+        remoteConfirmationAnchor = await readSessionConfirmationAnchor(normalizedSessionId, { targetPath });
+        if (!remoteConfirmationAnchor?.ok) {
+          if (!localSession.materialized && isLocalOnlySessionSayReason(remoteConfirmationAnchor?.reason)) {
+            localOnly = true;
+          } else {
+            throw new Error(
+              `Remote send confirmation anchor failed (${remoteConfirmationAnchor?.reason || "unknown"}); local cache was not updated. Use --local-only only when you intentionally want an offline local note.`,
+            );
+          }
+        }
+      }
+      if (!localOnly) {
         for (let attempt = 0; attempt < 2; attempt += 1) {
           remoteSync = await syncSessionEventToApi(normalizedSessionId, event, {
             targetPath,
@@ -2056,13 +2797,23 @@ export function registerSessionCommand(program) {
         }
         if (!remoteSync?.synced) {
           throw new Error(
-            `Remote send failed (${remoteSync?.reason || "unknown"}); local cache was not updated.`,
+            `Remote send failed (${remoteSync?.reason || "unknown"}); local cache was not updated. Use --local-only only when you intentionally want an offline local note.`,
           );
+        } else {
+          remoteConfirmation = await confirmSessionEventVisible(normalizedSessionId, clientMessageId, {
+            targetPath,
+            anchorCursor: remoteConfirmationAnchor?.cursor,
+          });
+          if (!remoteConfirmation?.confirmed) {
+            throw new Error(
+              `Remote send was accepted but not visible in canonical session events (${remoteConfirmation?.reason || "not_visible"}); local cache was not updated.`,
+            );
+          }
         }
       }
       const persisted = await appendToStream(normalizedSessionId, event, {
         targetPath,
-        syncRemote: !localSession.materialized,
+        syncRemote: false,
       });
       const payload = {
         command: "session say",
@@ -2072,12 +2823,21 @@ export function registerSessionCommand(program) {
         event: persisted,
         materializedLocalSession: localSession.materialized,
         refreshedLocalSession: Boolean(localSession.refreshed),
+        identitySource: identity.source,
+        identityWarning: identity.identityWarning || undefined,
+        agentRegistration,
         remoteSync: remoteSync || undefined,
+        remoteConfirmationAnchor: remoteConfirmationAnchor || undefined,
+        remoteConfirmation: remoteConfirmation || undefined,
+        localOnly,
       };
       if (shouldEmitJson(options, command)) {
         console.log(JSON.stringify(payload, null, 2));
         return;
       }
+      if (identity.identityWarning) {
+        console.error(pc.yellow(`Identity warning: ${identity.identityWarning}`));
+      }
       console.log(formatEventLine(persisted));
     });
 
@@ -2109,11 +2869,13 @@ export function registerSessionCommand(program) {
         targetPath,
       });
       const to = normalizeString(options.to);
+      const clientMessageId = `cli-agent-${randomUUID()}`;
       const eventPayload = {
         message: normalizedMessage,
         channel: "session",
         source: "agent",
         clientKind: "cli",
+        clientMessageId,
       };
       if (to) {
         eventPayload.to = to;
@@ -2125,7 +2887,6 @@ export function registerSessionCommand(program) {
         role: normalizeString(options.role) || "coder",
         clientKind: "cli",
       };
-      const clientMessageId = `cli-agent-${randomUUID()}`;
       const event = createAgentEvent({
         event: "session_message",
         agent,
@@ -2135,6 +2896,19 @@ export function registerSessionCommand(program) {
       event.eventId = clientMessageId;
       event.idempotencyToken = clientMessageId;
 
+      const remoteConfirmationAnchor = await readSessionConfirmationAnchor(normalizedSessionId, {
+        targetPath,
+      });
+      if (!remoteConfirmationAnchor?.ok) {
+        if (remoteConfirmationAnchor?.reason === "api_403") {
+          throw new Error(
+            `Agent post failed (api_403). Ensure this user has an active grant for '${agentId}'.`,
+          );
+        }
+        throw new Error(
+          `Agent post confirmation anchor failed (${remoteConfirmationAnchor?.reason || "unknown"}); local cache was not updated.`,
+        );
+      }
       const remoteSync = await syncSessionEventToApi(normalizedSessionId, event, {
         targetPath,
       });
@@ -2143,6 +2917,15 @@ export function registerSessionCommand(program) {
           `Agent post failed (${remoteSync?.reason || "unknown"}). Ensure this user has an active grant for '${agentId}'.`,
         );
       }
+      const remoteConfirmation = await confirmSessionEventVisible(normalizedSessionId, clientMessageId, {
+        targetPath,
+        anchorCursor: remoteConfirmationAnchor?.cursor,
+      });
+      if (!remoteConfirmation?.confirmed) {
+        throw new Error(
+          `Agent post was accepted but not visible in canonical session events (${remoteConfirmation?.reason || "not_visible"}); local cache was not updated.`,
+        );
+      }
 
       const persisted = await appendToStream(normalizedSessionId, event, {
         targetPath,
@@ -2157,6 +2940,8 @@ export function registerSessionCommand(program) {
         materializedLocalSession: localSession.materialized,
         refreshedLocalSession: Boolean(localSession.refreshed),
         remoteSync,
+        remoteConfirmationAnchor,
+        remoteConfirmation,
       };
       if (shouldEmitJson(options, command)) {
         console.log(JSON.stringify(payload, null, 2));
@@ -2192,7 +2977,23 @@ export function registerSessionCommand(program) {
     }
     await ensureLocalSessionForRemoteCommand(normalizedSessionId, { targetPath });
     const note = normalizeString(noteOverride) || normalizeString(options.note);
-    const agentId = await defaultAgentId(options.agent, targetPath);
+    // Resolve the authoring agent. The bare `cli-user` default is rejected by
+    // the API (api_422); resolveMessageActionIdentity treats it as unset and
+    // falls back to the joined agent. If no concrete identity resolves, fail
+    // with actionable guidance instead of firing a request guaranteed to 422.
+    const identity = await resolveMessageActionIdentity({
+      sessionId: normalizedSessionId,
+      optionAgent: options.agent,
+      targetPath,
+      env: process.env,
+    });
+    if (shouldBlockImplicitCliUserSessionSay(identity)) {
+      throw new Error(
+        identity.identityWarning ||
+          `${commandName} requires an agent identity; pass --agent <id>, set SENTINELAYER_AGENT_ID, or run session join --agent <id> first.`,
+      );
+    }
+    const agentId = identity.agentId;
     const idempotencyKey =
       normalizeString(options.idempotencyKey) ||
       defaultActionIdempotencyKey({
@@ -2242,7 +3043,12 @@ export function registerSessionCommand(program) {
       console.log(JSON.stringify(payload, null, 2));
       return payload;
     }
-    console.log(formatEventLine(localAppend.event || actionEvent));
+    if (localAppend.event || actionEvent) {
+      console.log(formatEventLine(localAppend.event || actionEvent));
+    } else {
+      const targetLabel = targetSequenceId ? `#${targetSequenceId}` : targetCursor || targetActionId || "target";
+      console.log(pc.green(`Recorded ${normalizedActionType} on ${targetLabel}.`));
+    }
     return payload;
   }
 
@@ -2278,7 +3084,7 @@ export function registerSessionCommand(program) {
     .option("--target-cursor <cursor>", "Target event cursor")
     .option("--target-action-id <uuid>", "Target a threaded reply/action by action UUID")
     .option("--note <text>", "Optional action note or reply body")
-    .option("--agent <id>", "Agent id for local idempotency metadata", "cli-user")
+    .option("--agent <id>", "Agent id authoring the action (defaults to the joined session agent)")
     .option("--idempotency-key <key>", "Explicit idempotency key")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
@@ -2292,7 +3098,7 @@ export function registerSessionCommand(program) {
     .option("--target-sequence <n>", "Target event sequence id")
     .option("--target-cursor <cursor>", "Target event cursor")
     .option("--target-action-id <uuid>", "Target a threaded reply/action by action UUID")
-    .option("--agent <id>", "Agent id for local idempotency metadata", "cli-user")
+    .option("--agent <id>", "Agent id authoring the action (defaults to the joined session agent)")
     .option("--idempotency-key <key>", "Explicit idempotency key")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
@@ -2313,7 +3119,7 @@ export function registerSessionCommand(program) {
   session
     .command("reply <sessionId> <targetSequenceId> <message...>")
     .description("Reply to a target session event using the message-action channel")
-    .option("--agent <id>", "Agent id for local idempotency metadata", "cli-user")
+    .option("--agent <id>", "Agent id authoring the action (defaults to the joined session agent)")
     .option("--idempotency-key <key>", "Explicit idempotency key")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
@@ -2333,7 +3139,7 @@ export function registerSessionCommand(program) {
   session
     .command("comment <sessionId> <targetSequenceId> <message...>")
     .description("Alias for `session reply`; add a threaded comment to a target event")
-    .option("--agent <id>", "Agent id for local idempotency metadata", "cli-user")
+    .option("--agent <id>", "Agent id authoring the action (defaults to the joined session agent)")
     .option("--idempotency-key <key>", "Explicit idempotency key")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
@@ -2352,8 +3158,8 @@ export function registerSessionCommand(program) {
 
   session
     .command("view <sessionId> <targetSequenceId>")
-    .description("Record a read receipt for a target session event")
-    .option("--agent <id>", "Agent id for local idempotency metadata", "cli-user")
+    .description("Manually backfill a read receipt for a target session event")
+    .option("--agent <id>", "Agent id authoring the action (defaults to the joined session agent)")
     .option("--idempotency-key <key>", "Explicit idempotency key")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
@@ -2368,6 +3174,57 @@ export function registerSessionCommand(program) {
       });
     });
 
+  session
+    .command("pins <sessionId>")
+    .description("List the session's pinned messages with their content so agents can read them")
+    .option("--path <path>", "Workspace path for the session", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, options, command) => {
+      const normalizedSessionId = normalizeString(sessionId);
+      if (!normalizedSessionId) {
+        throw new Error("session id is required.");
+      }
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      await ensureLocalSessionForRemoteCommand(normalizedSessionId, { targetPath });
+      const result = await fetchSessionPinnedMessages(normalizedSessionId, { targetPath });
+      if (!result.ok) {
+        throw new Error(`Could not load pinned messages (${result.reason || "unknown"}).`);
+      }
+      const pinLimit = result.pinLimit || 10;
+      const payload = {
+        command: "session pins",
+        sessionId: normalizedSessionId,
+        pinLimit,
+        count: result.count,
+        pins: result.pins,
+      };
+      if (shouldEmitJson(options, command)) {
+        console.log(JSON.stringify(payload, null, 2));
+        return payload;
+      }
+      if (!result.count) {
+        console.log(pc.gray("No pinned messages in this session."));
+        return payload;
+      }
+      console.log(pc.bold(`📌 Pinned messages (${result.count}/${pinLimit})`));
+      for (const pin of result.pins) {
+        const seqLabel = pin.targetSequenceId ? `#${pin.targetSequenceId}` : "(unknown sequence)";
+        const author = pin.author || "unknown";
+        const pinnedBy = pin.pinnedBy ? ` · pinned by ${pin.pinnedBy}` : "";
+        const when = pin.pinnedAt ? ` · ${pin.pinnedAt}` : "";
+        console.log("");
+        console.log(pc.cyan(`${seqLabel}  ${author}${pinnedBy}${when}`));
+        if (pin.content) {
+          for (const line of String(pin.content).split("\n")) {
+            console.log(`  ${line}`);
+          }
+        } else {
+          console.log(pc.gray("  (no readable text content for this pinned event)"));
+        }
+      }
+      return payload;
+    });
+
   session
     .command("listen")
     .description("Background-poll a session for events addressed to this agent or broadcast")
@@ -2388,12 +3245,33 @@ export function registerSessionCommand(program) {
       "Seconds after a human message to keep the active interval (default 300)",
       "300",
     )
+    .option(
+      "--presence-interval <seconds>",
+      "Minimum seconds between remote listener heartbeat events (default 60)",
+      "60",
+    )
+    .option(
+      "--no-presence",
+      "Do not publish durable listener lifecycle/heartbeat events",
+    )
+    .option(
+      "--model <model>",
+      "Model/provider label to publish with listener presence",
+      process.env.SENTINELAYER_AGENT_MODEL || process.env.SENTINELAYER_MODEL || "cli",
+    )
+    .option("--display-name <name>", "Human-readable listener name for presence")
     .option("--emit <format>", "Output format: ndjson or text", "ndjson")
+    .option("--transport <mode>", "Listen transport: auto, stream, or poll (default auto)", "auto")
     .option("--limit <n>", "Maximum events to request per poll (default 200)", "200")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--since <cursor>", "Override the persisted listen cursor")
+    .option("--from-now", "Advance the listen cursor to the latest durable event before polling")
     .option("--replay", "Emit matching historical events on the first poll")
     .option("--max-polls <n>", "Stop after N poll cycles (useful for tests and smoke checks)")
+    .option(
+      "--wake <command>",
+      "Wake hook: run this shell command on each matched event (notify->resume bridge). Event JSON is piped to stdin; SL_WAKE_* env vars are set.",
+    )
     .action(async (options) => {
       const normalizedSessionId = resolveSessionIdOption(options);
       const targetPath = path.resolve(process.cwd(), String(options.path || "."));
@@ -2405,26 +3283,90 @@ export function registerSessionCommand(program) {
         5,
       );
       const activeWindowSeconds = parsePositiveInteger(options.activeWindow, "active-window", 300);
+      const presenceIntervalSeconds = parsePositiveInteger(
+        options.presenceInterval,
+        "presence-interval",
+        60,
+      );
+      const agentModel = normalizeString(options.model) || "cli";
+      const displayName = normalizeString(options.displayName) || agentId;
       const limit = parsePositiveInteger(options.limit, "limit", 200);
       const emitFormat = normalizeString(options.emit).toLowerCase() || "ndjson";
       if (!["ndjson", "text"].includes(emitFormat)) {
         throw new Error("--emit must be one of: ndjson, text.");
       }
+      // Optional wake hook: run a host command on each matched event so the
+      // host can resume/wake its agent (the notify->resume bridge).
+      const emitWakeNotice = (payload = {}) => {
+        if (emitFormat === "ndjson") {
+          console.log(
+            JSON.stringify(
+              createAgentEvent({
+                event: "session_wake_hook",
+                agentId,
+                sessionId: normalizedSessionId,
+                payload,
+              }),
+            ),
+          );
+        } else {
+          const status = normalizeString(payload.status) || "fired";
+          const detail = payload.reason ? ` (${payload.reason})` : payload.eventType ? ` ${payload.eventType}` : "";
+          console.log(pc.cyan(`wake hook ${status}${detail}`));
+        }
+      };
+      const wakeRunner = createSessionWakeRunner({
+        command: options.wake,
+        sessionId: normalizedSessionId,
+        agentId,
+        emit: emitWakeNotice,
+      });
+      const requestedTransport = normalizeString(options.transport).toLowerCase() || "auto";
+      if (!["auto", "stream", "poll"].includes(requestedTransport)) {
+        throw new Error("--transport must be one of: auto, stream, poll.");
+      }
       const maxPolls =
         options.maxPolls === undefined
           ? null
           : parsePositiveInteger(options.maxPolls, "max-polls", 1);
+      const listenTransport = requestedTransport === "auto" && maxPolls !== null
+        ? "poll"
+        : requestedTransport;
       const since = options.since === undefined ? undefined : String(options.since);
+      if (options.fromNow && options.since !== undefined) {
+        throw new Error("Use either --from-now or --since, not both.");
+      }
       const ac = new AbortController();
       const onSigint = () => ac.abort();
       process.on("SIGINT", onSigint);
+      const listenerId = `listener-${agentId}-${randomUUID()}`;
+      const durablePresenceEnabled = options.presence !== false;
+      const publishPresence = durablePresenceEnabled && canPublishListenerPresence(agentId);
+      const presenceIntervalMs = Math.max(1, presenceIntervalSeconds) * 1000;
+      let lastPresenceHeartbeatMs = 0;
 
       if (emitFormat === "text") {
         console.log(
           pc.gray(
-            `Listening to session ${normalizedSessionId} as ${agentId}; idle=${intervalSeconds}s active=${activeIntervalSeconds}s/${activeWindowSeconds}s. Press Ctrl+C to stop.`,
+            `Listening to session ${normalizedSessionId} as ${agentId}; transport=${listenTransport} idle=${intervalSeconds}s active=${activeIntervalSeconds}s/${activeWindowSeconds}s. Press Ctrl+C to stop.`,
           ),
         );
+        if (!durablePresenceEnabled) {
+          console.log(
+            pc.gray(
+              "Remote listener presence is disabled; no durable lifecycle events will be written.",
+            ),
+          );
+        } else if (!publishPresence) {
+          console.log(
+            pc.gray(
+              "Listener presence is local-only for placeholder, human, and guest agent ids.",
+            ),
+          );
+        }
+        if (options.fromNow) {
+          console.log(pc.gray("Priming listener from the latest durable event; old backlog will be skipped."));
+        }
       }
 
       try {
@@ -2438,14 +3380,38 @@ export function registerSessionCommand(program) {
           limit,
           since,
           replay: Boolean(options.replay),
+          fromNow: Boolean(options.fromNow),
+          persistStartCursor: Boolean(options.fromNow),
+          transport: listenTransport,
           maxPolls,
           signal: ac.signal,
+          onCatchup: async (catchup) => {
+            if (emitFormat === "ndjson") {
+              console.log(
+                JSON.stringify(
+                  buildListenerCatchupEvent({
+                    sessionId: normalizedSessionId,
+                    agentId,
+                    agentModel,
+                    displayName,
+                    listenerId,
+                    catchup,
+                  }),
+                ),
+              );
+            } else {
+              console.log(pc.yellow(formatListenerCatchupNotice(catchup)));
+            }
+          },
           onEvent: async (event) => {
             if (emitFormat === "ndjson") {
               console.log(JSON.stringify(event));
             } else {
               console.log(formatEventLine(event));
             }
+            // Fire the wake hook for any matched event (incl. ack/like) so the
+            // host can resume its agent.
+            wakeRunner.trigger(event);
           },
           onError: async (result) => {
             const reason = normalizeString(result?.reason) || "poll_failed";
@@ -2467,12 +3433,394 @@ export function registerSessionCommand(program) {
               console.log(pc.yellow(`Listen poll skipped (${reason}).`));
             }
           },
+          onLifecycle: async (lifecycle) => {
+            if (!publishPresence) return;
+            const lifecycleType = normalizeString(lifecycle?.type);
+            if (lifecycleType === "heartbeat") {
+              const nowMs = Date.now();
+              if (lastPresenceHeartbeatMs > 0 && nowMs - lastPresenceHeartbeatMs < presenceIntervalMs) {
+                return;
+              }
+              lastPresenceHeartbeatMs = nowMs;
+            }
+            await publishListenerPresenceEvent({
+              sessionId: normalizedSessionId,
+              targetPath,
+              agentId,
+              agentModel,
+              displayName,
+              listenerId,
+              lifecycle,
+            });
+          },
         });
       } finally {
         process.removeListener("SIGINT", onSigint);
       }
     });
 
+  session
+    .command("daemon [sessionId]")
+    .description("Run the Senti session daemon: hydrate events, emit recaps, and generate checkpoints")
+    .option("--session <id>", "Session id to monitor")
+    .option("--path <path>", "Workspace path for the session", ".")
+    .option("--tick-interval <seconds>", "Seconds between health ticks (default 30)", "30")
+    .option("--stale-agent-seconds <seconds>", "Seconds before an inactive agent is flagged stale (default 90)", "90")
+    .option("--recap-interval <seconds>", "Seconds between periodic recaps when activity continues (default 300)", "300")
+    .option("--recap-inactivity <seconds>", "Seconds of inactivity before a recap closeout (default 600)", "600")
+    .option("--recap-event-threshold <n>", "Meaningful events required to force a recap before interval (default 5)", "5")
+    .option("--checkpoint-interval <seconds>", "Minimum seconds between checkpoint attempts (default 60)", "60")
+    .option("--checkpoint-min-events <n>", "Minimum events for generated checkpoint windows (default 20)", "20")
+    .option("--checkpoint-max-events <n>", "Maximum events per generated checkpoint window (default 80)", "80")
+    .option("--checkpoint-event-threshold <n>", "Meaningful events required to attempt a checkpoint (default 20)", "20")
+    .option("--checkpoint-idle <seconds>", "Seconds after latest source event before idle checkpoint attempt (default 600)", "600")
+    .option("--no-checkpoints", "Disable durable checkpoint generation")
+    .option("--no-checkpoint-closeout", "Skip the final closeout checkpoint when the daemon stops")
+    .option("--once", "Run one Senti health tick and exit (CI/dogfood smoke)")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, options, command) => {
+      const emitJson = shouldEmitJson(options, command);
+      const normalizedSessionId = normalizeString(sessionId) || resolveSessionIdOption(options);
+      if (!normalizedSessionId) {
+        throw new Error("session daemon requires a session id (positional or --session).");
+      }
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const tickIntervalMs = parsePositiveMillisecondsFromSeconds(
+        options.tickInterval,
+        "tick-interval",
+        30,
+      );
+      const daemon = await startSenti(normalizedSessionId, {
+        targetPath,
+        autoStart: false,
+        tickIntervalMs,
+        staleAgentSeconds: parsePositiveInteger(options.staleAgentSeconds, "stale-agent-seconds", 90),
+        recapIntervalMs: parsePositiveMillisecondsFromSeconds(options.recapInterval, "recap-interval", 300),
+        recapInactivityMs: parsePositiveMillisecondsFromSeconds(options.recapInactivity, "recap-inactivity", 600),
+        recapActivityThreshold: parsePositiveInteger(options.recapEventThreshold, "recap-event-threshold", 5),
+        checkpointGenerator: options.checkpoints === false ? null : undefined,
+        checkpointIntervalMs: parsePositiveMillisecondsFromSeconds(options.checkpointInterval, "checkpoint-interval", 60),
+        checkpointMinEvents: parsePositiveInteger(options.checkpointMinEvents, "checkpoint-min-events", 20),
+        checkpointMaxEvents: parsePositiveInteger(options.checkpointMaxEvents, "checkpoint-max-events", 80),
+        checkpointEventThreshold: parsePositiveInteger(options.checkpointEventThreshold, "checkpoint-event-threshold", 20),
+        checkpointIdleMs: parsePositiveMillisecondsFromSeconds(options.checkpointIdle, "checkpoint-idle", 600),
+        checkpointCloseoutOnStop: options.once ? false : options.checkpointCloseout !== false,
+      });
+
+      const runTickAndBuildPayload = async () => {
+        const summary = await daemon.runTick(new Date().toISOString());
+        return {
+          command: "session daemon",
+          sessionId: normalizedSessionId,
+          targetPath,
+          once: Boolean(options.once),
+          running: daemon.isRunning(),
+          summary,
+          state: daemon.getState(),
+        };
+      };
+
+      if (options.once) {
+        const payload = await runTickAndBuildPayload();
+        const stopped = await daemon.stop("once_complete");
+        payload.running = false;
+        payload.stopped = {
+          stopped: Boolean(stopped?.stopped),
+          reason: stopped?.reason || "once_complete",
+          checkpointCloseout: stopped?.checkpointCloseout || null,
+        };
+        if (emitJson) {
+          console.log(JSON.stringify(payload, null, 2));
+          return;
+        }
+        const checkpoint = payload.summary?.checkpoint || {};
+        const recap = payload.summary?.recap || {};
+        console.log(
+          pc.green(
+            `senti tick: relayed=${Number(payload.summary?.humanMessages?.relayed || 0)} recap=${recap.emitted ? recap.mode || "emitted" : recap.reason || "none"} checkpoint=${checkpoint.created ? checkpoint.checkpointId || "created" : checkpoint.reason || "none"}`,
+          ),
+        );
+        return;
+      }
+
+      const controller = new AbortController();
+      const stop = () => controller.abort();
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      const waitForNextTick = () =>
+        new Promise((resolve) => {
+          let timer = null;
+          const cleanup = () => {
+            controller.signal.removeEventListener("abort", onAbort);
+            if (timer) {
+              clearTimeout(timer);
+              timer = null;
+            }
+          };
+          const finish = () => {
+            cleanup();
+            resolve();
+          };
+          const onAbort = () => {
+            finish();
+          };
+          controller.signal.addEventListener("abort", onAbort, { once: true });
+          timer = setTimeout(finish, tickIntervalMs);
+        });
+
+      try {
+        if (!emitJson) {
+          console.log(
+            pc.green(
+              `senti daemon: monitoring session ${normalizedSessionId}; tick=${Math.round(tickIntervalMs / 1000)}s. Ctrl-C to stop.`,
+            ),
+          );
+        }
+        let payload = await runTickAndBuildPayload();
+        if (emitJson) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log(pc.gray(`tick ${payload.summary.generatedAt}: recap=${payload.summary.recap.reason || payload.summary.recap.mode || "ok"} checkpoint=${payload.summary.checkpoint.reason || payload.summary.checkpoint.checkpointId || "ok"}`));
+        }
+        while (!controller.signal.aborted) {
+          await waitForNextTick();
+          if (controller.signal.aborted) break;
+          payload = await runTickAndBuildPayload();
+          if (emitJson) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log(pc.gray(`tick ${payload.summary.generatedAt}: recap=${payload.summary.recap.reason || payload.summary.recap.mode || "ok"} checkpoint=${payload.summary.checkpoint.reason || payload.summary.checkpoint.checkpointId || "ok"}`));
+          }
+        }
+      } finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        const stopped = await daemon.stop("signal");
+        if (emitJson) {
+          console.log(
+            JSON.stringify({
+              command: "session daemon",
+              sessionId: normalizedSessionId,
+              targetPath,
+              stopped: {
+                stopped: Boolean(stopped?.stopped),
+                reason: stopped?.reason || "signal",
+                checkpointCloseout: stopped?.checkpointCloseout || null,
+              },
+            }),
+          );
+        } else {
+          console.log(pc.gray(`senti daemon stopped (${stopped?.reason || "signal"}).`));
+        }
+      }
+    });
+
+  const wake = session
+    .command("wake")
+    .description("Wake or register host CLI sessions for the Senti notification bus");
+
+  wake
+    .command("codex [sessionId]")
+    .description("Resume a Codex CLI session with a Senti wake prompt")
+    .option("--session <id>", "Senti session id")
+    .option("--codex-session <id>", "Codex rollout/session id to resume")
+    .option("--last", "Resume the most recent Codex session instead of a specific id")
+    .option("--message <text>", "Senti message body to inject into Codex")
+    .option("--message-file <path>", "Read Senti message body from a file")
+    .option("--from <id>", "Senti sender id", "senti")
+    .option("--sequence <n>", "Senti source sequence id")
+    .option("--cursor <cursor>", "Senti source cursor")
+    .option("--priority <level>", "Senti source priority")
+    .option("--dashboard-url <url>", "Dashboard URL for the Senti session")
+    .option("--cwd <path>", "Workspace cwd for codex exec", ".")
+    .option("--codex-bin <path>", "Codex executable", "codex")
+    .option("--model <model>", "Optional Codex model override")
+    .option("--codex-json", "Pass --json through to codex exec resume")
+    .option("--skip-git-repo-check", "Pass --skip-git-repo-check through to codex")
+    .option(
+      "--dangerously-bypass-approvals-and-sandbox",
+      "Pass Codex's dangerous no-approval/no-sandbox flag through to the resumed process",
+    )
+    .option("--timeout-ms <n>", "Wake process timeout in milliseconds", "600000")
+    .option("--dry-run", "Print the resume invocation without spawning Codex")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, options, command) => {
+      const emitJson = shouldEmitJson(options, command);
+      const normalizedSessionId = normalizeString(sessionId) || resolveSessionIdOption(options);
+      const targetPath = path.resolve(process.cwd(), String(options.cwd || "."));
+      if (options.message && options.messageFile) {
+        throw new Error("Use either --message or --message-file, not both.");
+      }
+      const message = options.messageFile
+        ? await fsp.readFile(path.resolve(process.cwd(), String(options.messageFile)), "utf-8")
+        : normalizeString(options.message);
+      const prompt = buildCodexWakePrompt({
+        sentiSessionId: normalizedSessionId,
+        message,
+        from: options.from,
+        sequenceId: parseOptionalPositiveInteger(options.sequence, "sequence"),
+        cursor: options.cursor,
+        priority: options.priority,
+        dashboardUrl: options.dashboardUrl,
+      });
+      const invocation = buildCodexExecResumeInvocation({
+        codexSessionId: options.codexSession,
+        prompt,
+        cwd: targetPath,
+        codexBin: options.codexBin,
+        useLast: Boolean(options.last),
+        json: Boolean(options.codexJson),
+        model: options.model,
+        skipGitRepoCheck: Boolean(options.skipGitRepoCheck),
+        dangerouslyBypassApprovalsAndSandbox: Boolean(options.dangerouslyBypassApprovalsAndSandbox),
+      });
+      const payload = {
+        command: "session wake codex",
+        sessionId: normalizedSessionId,
+        dryRun: Boolean(options.dryRun),
+        invocation,
+        prompt,
+      };
+      if (options.dryRun) {
+        if (emitJson) {
+          console.log(JSON.stringify(payload, null, 2));
+          return;
+        }
+        console.log(pc.green("Codex wake dry run"));
+        console.log(`${payload.invocation.command} ${payload.invocation.args.map((arg) => JSON.stringify(arg)).join(" ")}`);
+        return;
+      }
+      const result = await runCodexExecResume({
+        invocation,
+        timeoutMs: parsePositiveInteger(options.timeoutMs, "timeout-ms", 600000),
+      });
+      const output = {
+        ...payload,
+        result,
+      };
+      if (emitJson) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+      }
+      const color = result.exitCode === 0 ? pc.green : pc.yellow;
+      console.log(color(`Codex wake completed with exit code ${result.exitCode}.`));
+      if (normalizeString(result.stderr)) {
+        console.log(pc.gray(result.stderr.trim()));
+      }
+      if (result.exitCode !== 0) {
+        process.exitCode = Number(result.exitCode) || 1;
+      }
+    });
+
+  wake
+    .command("codex-notify [sessionId] [notificationJson]")
+    .description("Record Codex notify payloads so sentid can resume the correct Codex rollout")
+    .option("--session <id>", "Senti session id")
+    .option("--agent <id>", "Senti agent id", process.env.SENTINELAYER_AGENT_ID || "codex")
+    .option("--notification <json>", "Notification JSON override")
+    .option("--path <path>", "Workspace path for the Senti session", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, notificationJson, options, command) => {
+      const emitJson = shouldEmitJson(options, command);
+      const normalizedSessionId = normalizeString(sessionId) || resolveSessionIdOption(options);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const payload = normalizeString(options.notification) || normalizeString(notificationJson);
+      const result = await recordCodexWakeRegistration({
+        sessionId: normalizedSessionId,
+        agentId: options.agent,
+        notificationPayload: payload,
+        targetPath,
+      });
+      const output = {
+        command: "session wake codex-notify",
+        sessionId: normalizedSessionId,
+        agentId: normalizeString(options.agent) || "codex",
+        ...result,
+      };
+      if (emitJson) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+      }
+      if (!result.registered) {
+        console.log(pc.gray(`Ignored Codex notification: ${result.reason}.`));
+        return;
+      }
+      console.log(pc.green(`Registered Codex wake target: ${result.registryPath}`));
+    });
+
+  wake
+    .command("daemon [sessionId]")
+    .description("Run the sentid wake daemon: watch the session stream and wake this agent on new messages")
+    .option("--session <id>", "Senti session id")
+    .option("--agent <id>", "Local agent this daemon wakes", process.env.SENTINELAYER_AGENT_ID || "")
+    .option("--host <name>", "Host adapter to wake (claude|codex)", "claude")
+    .option("--resume-session <id>", "Host session id to resume on wake")
+    .option("--cwd <path>", "Workspace cwd", ".")
+    .option("--idle-ms <n>", "Idle poll backoff in milliseconds", "1500")
+    .option("--max-attempts <n>", "Wake retries before dead-letter", "5")
+    .option("--once", "Run a single fetch/dispatch tick and exit (dogfood/CI)")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, options, command) => {
+      const emitJson = shouldEmitJson(options, command);
+      const normalizedSessionId = normalizeString(sessionId) || resolveSessionIdOption(options);
+      if (!normalizedSessionId) {
+        throw new Error("session wake daemon requires a Senti session id (positional or --session).");
+      }
+      const agentId = normalizeString(options.agent);
+      if (!agentId) {
+        throw new Error("session wake daemon requires --agent (the local agent to wake).");
+      }
+      const host = normalizeString(options.host) || "claude";
+      const resumeSessionId = normalizeString(options.resumeSession);
+      if (!resumeSessionId) {
+        throw new Error("session wake daemon requires --resume-session (the host session id to resume).");
+      }
+      const targetPath = path.resolve(process.cwd(), String(options.cwd || "."));
+      const sentid = createSentid({
+        sessionId: normalizedSessionId,
+        agentId,
+        host,
+        resumeSessionId,
+        targetPath,
+        idleMs: parseOptionalPositiveInteger(options.idleMs, "idle-ms") || 1500,
+        maxAttempts: parseOptionalPositiveInteger(options.maxAttempts, "max-attempts") || 5,
+        logger: emitJson
+          ? undefined
+          : (level, msg, meta) => console.error(`[sentid:${level}] ${msg}${meta ? ` ${JSON.stringify(meta)}` : ""}`),
+      });
+
+      if (options.once) {
+        const tick = await sentid.tickOnce({ fetchCursor: null });
+        const out = {
+          command: "session wake daemon",
+          once: true,
+          sessionId: normalizedSessionId,
+          agent: agentId,
+          host,
+          cursor: sentid.getCursor(),
+          dispatched: Array.isArray(tick.results) ? tick.results.length : 0,
+          idle: Boolean(tick.idle),
+        };
+        console.log(
+          emitJson
+            ? JSON.stringify(out, null, 2)
+            : pc.green(`sentid tick: cursor=${out.cursor} dispatched=${out.dispatched}${out.idle ? " (idle)" : ""}`),
+        );
+        return;
+      }
+
+      const ac = new AbortController();
+      const stop = () => ac.abort();
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      if (!emitJson) {
+        console.log(
+          pc.green(`sentid daemon: waking ${agentId} (host=${host}) on session ${normalizedSessionId}. Ctrl-C to stop.`),
+        );
+      }
+      await sentid.start({ signal: ac.signal });
+    });
+
   const recap = session
     .command("recap")
     .description("Build deterministic Senti session recaps");
@@ -2574,6 +3922,9 @@ export function registerSessionCommand(program) {
     )
     .option("--before-sequence <n>", "Remote page ending before this sequence id")
     .option("--no-actions", "Do not include remote message actions/replies/reactions")
+    .option("--agent <id>", "Agent id for automatic view receipts", process.env.SENTINELAYER_AGENT_ID || "cli-user")
+    .option("--no-view", "Do not record automatic view receipts for displayed remote messages")
+    .option("--include-control-events", "Include listener lifecycle/control-plane events in transcript output")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
     .action(async (sessionId, options, command) => {
@@ -2585,6 +3936,11 @@ export function registerSessionCommand(program) {
       const tail = parsePositiveInteger(options.tail, "tail", 20);
       const beforeSequence = parseOptionalPositiveInteger(options.beforeSequence, "before-sequence");
       const emitJson = shouldEmitJson(options, command);
+      const includeControlEvents = Boolean(options.includeControlEvents);
+      const remoteTailLimit = includeControlEvents
+        ? tail
+        : Math.min(200, Math.max(tail, tail + 20));
+      const readAgentId = await defaultAgentId(options.agent, targetPath);
 
       let hydration = null;
       let remoteTail = null;
@@ -2605,7 +3961,7 @@ export function registerSessionCommand(program) {
         remoteTail = await pollSessionEventsBefore(normalizedSessionId, {
           targetPath,
           beforeSequence,
-          limit: tail,
+          limit: remoteTailLimit,
           timeoutMs: 15_000,
         });
         if (options.actions !== false) {
@@ -2681,7 +4037,23 @@ export function registerSessionCommand(program) {
         const actionEvents = remoteActions?.ok
           ? buildSessionActionEvents(normalizedSessionId, remoteActions.actions)
           : [];
-        const events = mergeSessionActionEvents(displayEvents, actionEvents).slice(-tail);
+        const unacknowledgedHumanMessages = remoteActions?.ok
+          ? readProjectionUnacknowledgedHumanMessages(remoteActions)
+          : [];
+        const recentHumanActivity = remoteActions?.ok
+          ? readProjectionRecentHumanActivity(remoteActions)
+          : [];
+        const transcriptEvents = includeControlEvents
+          ? displayEvents
+          : displayEvents.filter((event) => !isSessionControlEvent(event));
+        const hiddenControlEventCount = displayEvents.length - transcriptEvents.length;
+        const events = mergeSessionActionEvents(transcriptEvents, actionEvents).slice(-tail);
+        const autoView = await recordSessionReadViews(normalizedSessionId, events, {
+          targetPath,
+          agentId: readAgentId,
+          enabled: Boolean(options.remote && options.view !== false),
+          maxTargets: process.env.SENTINELAYER_SESSION_READ_VIEW_MAX_TARGETS || 50,
+        });
         const remoteVerified = Boolean(
           options.remote &&
             ((hydration && hydration.ok) || (remoteTail && remoteTail.ok))
@@ -2694,6 +4066,13 @@ export function registerSessionCommand(program) {
           beforeSequence,
           count: events.length,
           events,
+          includeControlEvents,
+          hiddenControlEventCount,
+          unacknowledgedHumanMessageCount: unacknowledgedHumanMessages.length,
+          unacknowledgedHumanMessages,
+          recentHumanActivityCount: recentHumanActivity.length,
+          recentHumanActivity,
+          autoView,
           displaySource: !options.remote
             ? "local"
             : remoteTail?.ok
@@ -2737,6 +4116,18 @@ export function registerSessionCommand(program) {
           console.log(JSON.stringify(payload, null, 2));
           return;
         }
+        if (unacknowledgedHumanMessages.length > 0) {
+          console.log(pc.yellow(`Unacknowledged human asks: ${unacknowledgedHumanMessages.length}`));
+          for (const event of unacknowledgedHumanMessages.slice(0, 3)) {
+            console.log(pc.yellow(`- ${formatHumanAskLine(event)}`));
+          }
+        }
+        if (recentHumanActivity.length > 0) {
+          console.log(pc.yellow(`Recent human activity: ${recentHumanActivity.length}`));
+          for (const action of recentHumanActivity.slice(0, 3)) {
+            console.log(pc.yellow(`- ${formatMessageActionActivityLine(action)}`));
+          }
+        }
         for (const event of events) {
           console.log(formatEventLine(event));
         }
@@ -3048,6 +4439,8 @@ export function registerSessionCommand(program) {
     .description("Generate a checkpoint from the next uncheckpointed durable event window")
     .option("--min-events <n>", "Minimum source events required before creating (default 20)", "20")
     .option("--max-events <n>", "Maximum source events to summarize (default 80, max 200)", "80")
+    .option("--catch-up", "Generate multiple consecutive checkpoint windows until caught up or capped")
+    .option("--max-checkpoints <n>", "Maximum checkpoint windows to create with --catch-up (default 5, max 50)", "5")
     .option("--operation-id <key>", "Explicit retry key for this generate invocation")
     .option("--agent <id>", "Optional agent id recorded as checkpoint creator")
     .option("--path <path>", "Workspace path for auth/session context", ".")
@@ -3061,6 +4454,49 @@ export function registerSessionCommand(program) {
       const agentId = normalizeString(options.agent)
         ? await defaultAgentId(options.agent, targetPath)
         : "";
+      if (options.catchUp) {
+        const result = await generateSessionCheckpointBatch(normalizedSessionId, {
+          targetPath,
+          minEvents: options.minEvents,
+          maxEvents: options.maxEvents,
+          maxCheckpoints: options.maxCheckpoints,
+          idempotencyKey: options.operationId,
+          createdByAgentId: agentId,
+        });
+        const hydration = result.createdCount > 0
+          ? await hydrateAfterCheckpointMutation(normalizedSessionId, { targetPath })
+          : null;
+        const payload = {
+          command: "session checkpoint generate",
+          targetPath,
+          ...result,
+          hydration: hydration || undefined,
+        };
+        if (shouldEmitJson(options, command)) {
+          console.log(JSON.stringify(payload, null, 2));
+          return;
+        }
+        if (result.createdCount > 0) {
+          console.log(pc.bold(`checkpoint catch-up generated ${result.createdCount} checkpoint${result.createdCount === 1 ? "" : "s"}`));
+          for (const item of result.results) {
+            if (item.checkpoint) {
+              console.log(formatCheckpointLine(item.checkpoint));
+            }
+          }
+          console.log(pc.gray(`Stopped: ${result.stoppedReason || "complete"} after ${result.attemptedCount} attempt${result.attemptedCount === 1 ? "" : "s"}.`));
+          if (hydration && !hydration.ok) {
+            console.log(pc.gray(`Local hydrate skipped: ${hydration.reason || "unknown"}`));
+          }
+          return;
+        }
+        const last = result.lastResult || {};
+        console.log(
+          pc.gray(
+            `No checkpoint created: ${normalizeString(last.reason || result.stoppedReason) || "not_needed"} (${Number(last.eventCount || 0)} events, min ${Number(last.minEvents || options.minEvents || 0)}).`,
+          ),
+        );
+        return;
+      }
       const result = await generateSessionCheckpoint(normalizedSessionId, {
         targetPath,
         minEvents: options.minEvents,
@@ -3582,14 +5018,7 @@ export function registerSessionCommand(program) {
           return;
         }
         for (const item of trimmed) {
-          const archive = item.archiveStatus ? ` archive=${item.archiveStatus}` : "";
-          const created = item.createdAt || "?";
-          const lastActivity = item.lastActivityAt
-            ? ` last=${item.lastActivityAt}`
-            : "";
-          console.log(
-            `${item.sessionId} status=${item.status}${archive} created=${created}${lastActivity}`,
-          );
+          console.log(formatSessionListLine(item));
         }
         if (remote.count > trimmed.length || remote.hasMore) {
           console.log(
@@ -3637,10 +5066,9 @@ export function registerSessionCommand(program) {
         return;
       }
       for (const item of trimmed) {
-        const archive = item.archiveStatus ? ` archive=${item.archiveStatus}` : "";
-        console.log(
-          `${item.sessionId} status=${item.status}${archive} created=${item.createdAt} expires=${item.expiresAt}`,
-        );
+        const line = formatSessionListLine(item);
+        const expires = item.expiresAt ? ` expires=${item.expiresAt}` : "";
+        console.log(`${line}${expires}`);
       }
       if (sessions.length > trimmed.length) {
         console.log(