sentinelayer-cli 0.40.0 → 0.42.0

package/src/session/agent-registry.js

@@ -4,16 +4,14 @@ import path from "node:path";
 import process from "node:process";
 
 import { STUCK_THRESHOLDS } from "../agents/jules/pulse.js";
-import { createAgentEvent } from "../events/schema.js";
 import { inferSessionAgentIdentity } from "./agent-identity.js";
 import { resolveSessionPaths } from "./paths.js";
-import { emitContextBriefing } from "./recap.js";
+import { buildContextBriefing } from "./recap.js";
 import {
   assignFriendlyName,
   buildSentiWelcome,
   shouldAutoRenameInRegistry,
 } from "./senti-naming.js";
-import { appendToStream } from "./stream.js";
 
 const AGENT_SNAPSHOT_SCHEMA_VERSION = "1.0.0";
 
@@ -177,28 +175,6 @@ async function writeAgentSnapshot(snapshotPath, snapshot) {
   }
 }
 
-async function emitAgentEvent(
-  sessionId,
-  event,
-  payload,
-  { targetPath = process.cwd(), awaitRemoteSync = false } = {}
-) {
-  const envelope = createAgentEvent({
-    event,
-    agent: {
-      id: payload.agentId,
-      model: payload.model,
-      displayName: payload.displayName,
-      provider: payload.provider,
-      role: payload.role,
-      clientKind: payload.clientKind,
-    },
-    sessionId,
-    payload,
-  });
-  await appendToStream(sessionId, envelope, { targetPath, awaitRemoteSync });
-}
-
 function buildAgentSnapshotPath(paths, agentId) {
   const normalizedAgentId = normalizeString(agentId);
   if (!normalizedAgentId) {
@@ -288,17 +264,15 @@ function _untrackLocalAgent(sessionId, agentId) {
   _localAgents.delete(_agentKey(sessionId, agentId));
 }
 
-async function _emitLeaveForAllLocalAgents(reason) {
+async function _leaveAllLocalAgents(reason) {
   const entries = [..._localAgents.values()];
   _localAgents.clear();
   for (const entry of entries) {
     try {
-      await emitAgentEvent(
-        entry.sessionId,
-        "agent_leave",
-        { agentId: entry.agentId, reason, model: "unknown", role: "participant" },
-        { targetPath: entry.targetPath },
-      );
+      await unregisterAgent(entry.sessionId, entry.agentId, {
+        reason,
+        targetPath: entry.targetPath,
+      });
     } catch {
       // Best-effort: a stuck filesystem or network shouldn't block exit.
     }
@@ -309,7 +283,7 @@ function _ensureExitHooksInstalled() {
   if (_exitHooksInstalled) return;
   _exitHooksInstalled = true;
   const onSignal = (signal) => {
-    void _emitLeaveForAllLocalAgents("manual").finally(() => {
+    void _leaveAllLocalAgents("manual").finally(() => {
       process.removeListener(signal, onSignal);
       process.kill(process.pid, signal);
     });
@@ -317,7 +291,7 @@ function _ensureExitHooksInstalled() {
   process.on("SIGINT", onSignal);
   process.on("SIGTERM", onSignal);
   process.on("beforeExit", () => {
-    void _emitLeaveForAllLocalAgents("manual");
+    void _leaveAllLocalAgents("manual");
   });
 }
 
@@ -332,7 +306,6 @@ export async function registerAgent(
     role = "observer",
     targetPath = process.cwd(),
     trackProcessExit = true,
-    awaitRemoteSync = false,
   } = {}
 ) {
   const paths = resolveSessionPaths(sessionId, { targetPath });
@@ -426,46 +399,39 @@ export async function registerAgent(
   );
 
   await writeAgentSnapshot(snapshotPath, snapshot);
-  await emitAgentEvent(paths.sessionId, "agent_join", {
-    agentId: snapshot.agentId,
-    model: snapshot.model,
-    displayName: snapshot.displayName,
-    provider: snapshot.provider,
-    clientKind: snapshot.clientKind,
-    role: snapshot.role,
-    status: snapshot.status,
-  }, { targetPath, awaitRemoteSync });
   if (trackProcessExit) {
     _trackLocalAgent(paths.sessionId, snapshot.agentId, targetPath);
   }
 
+  let welcome = null;
   if (renamedFrom) {
-    const welcome = buildSentiWelcome({
+    welcome = buildSentiWelcome({
       agentId: snapshot.agentId,
       model: snapshot.model,
       role: snapshot.role,
       wasAnonymous: true,
       originalAgentId: renamedFrom,
     });
-    await emitAgentEvent(paths.sessionId, "agent_identified", {
-      ...welcome,
-      sessionId: paths.sessionId,
-    }, { targetPath });
   }
 
+  let contextBriefing = null;
   if (normalizeString(snapshot.agentId).toLowerCase() !== "senti") {
-    await emitContextBriefing(paths.sessionId, {
+    contextBriefing = await buildContextBriefing(paths.sessionId, {
       forAgentId: snapshot.agentId,
       targetPath,
-      awaitRemoteSync,
     }).catch(() => {});
   }
 
   return {
     ...snapshot,
     snapshotPath,
-    emittedJoinEvent: true,
-    emittedContextBriefing: normalizeString(snapshot.agentId).toLowerCase() !== "senti",
+    emittedJoinEvent: false,
+    emittedContextBriefing: false,
+    returnedContextBriefing: Boolean(contextBriefing),
+    onboarding: {
+      welcome,
+      contextBriefing,
+    },
     refreshedExistingAgent: false,
   };
 }
@@ -607,16 +573,9 @@ export async function unregisterAgent(
   );
 
   await writeAgentSnapshot(snapshotPath, snapshot);
-  await emitAgentEvent(paths.sessionId, "agent_leave", {
-    agentId: snapshot.agentId,
-    reason: normalizedReason,
-    role: snapshot.role,
-    model: snapshot.model,
-    displayName: snapshot.displayName,
-    provider: snapshot.provider,
-    clientKind: snapshot.clientKind,
-  }, { targetPath });
-  // Already left explicitly — don't double-emit on process exit.
+  // Presence and roster state are projections, not transcript events. The
+  // snapshot is authoritative for this workspace; remote listener presence is
+  // renewed through the TTL endpoint.
   _untrackLocalAgent(paths.sessionId, snapshot.agentId);
 
   return {

package/src/session/checkpoints.js

@@ -17,6 +17,15 @@ const DEFAULT_RESTORE_MAX_EVENTS = 120;
 const MAX_RESTORE_CONTEXT_EVENTS = 50;
 const MAX_RESTORE_EVENTS = 200;
 const DEFAULT_CREATED_BY_AGENT_ID = "senti";
+// Checkpoint origin honesty (Carter, room 430135 lane 2): a cut is `service` ONLY when a managed
+// infra cutter creates it; everything else — an agent's CLI, an agent-run `sl session daemon` — is
+// `agent`. Never INFER `service`: absent/unknown/anything-but-the-literal-string collapses to `agent`,
+// so honesty can't ride on a remembered flag. `createdBy` only defaults to the service id on `service`.
+const CHECKPOINT_ORIGIN_SERVICE = "service";
+const CHECKPOINT_ORIGIN_AGENT = "agent";
+function normalizeCheckpointOrigin(origin) {
+  return normalizeString(origin) === CHECKPOINT_ORIGIN_SERVICE ? CHECKPOINT_ORIGIN_SERVICE : CHECKPOINT_ORIGIN_AGENT;
+}
 
 function normalizeString(value) {
   return String(value ?? "").trim();
@@ -196,6 +205,7 @@ export function buildManualCheckpointPayload(sessionId, {
   title,
   summary,
   createdByAgentId = "",
+  origin = "",
   tokenStart,
   tokenEnd,
 } = {}) {
@@ -229,6 +239,7 @@ export function buildManualCheckpointPayload(sessionId, {
   if (normalizedCreatedBy) {
     body.createdByAgentId = normalizedCreatedBy;
   }
+  body.origin = normalizeCheckpointOrigin(origin);
   if (tokenRange) {
     body.tokenRange = tokenRange;
   }
@@ -243,6 +254,7 @@ export function buildGenerateCheckpointPayload(sessionId, {
   minEvents = DEFAULT_MIN_EVENTS,
   maxEvents = DEFAULT_MAX_EVENTS,
   createdByAgentId = "",
+  origin = "",
   idempotencyKey = "",
 } = {}) {
   const normalizedSessionId = normalizeString(sessionId);
@@ -268,6 +280,7 @@ export function buildGenerateCheckpointPayload(sessionId, {
   if (normalizedCreatedBy) {
     body.createdByAgentId = normalizedCreatedBy;
   }
+  body.origin = normalizeCheckpointOrigin(origin);
   return {
     body,
     idempotencyKey:
@@ -612,9 +625,17 @@ export async function generateSessionCheckpointBestEffort(sessionId, options = {
     return buildCheckpointNoop("remote_sync_disabled_env");
   }
   try {
+    // ORIGIN HONESTY (lane 2): default `createdBy` to the service id ONLY for a real `service`-origin cut.
+    // An agent-run best-effort cut (the CLI, an agent's daemon) is `agent` — its createdBy is the real agent
+    // id or ABSENT, never silently "senti". Absence of a creator is not the service; the humble state is honest.
+    const origin = normalizeCheckpointOrigin(options.origin);
+    const createdByAgentId = origin === CHECKPOINT_ORIGIN_SERVICE
+      ? (normalizeString(options.createdByAgentId) || DEFAULT_CREATED_BY_AGENT_ID)
+      : normalizeString(options.createdByAgentId);
     const result = await generateSessionCheckpoint(normalizedSessionId, {
       ...options,
-      createdByAgentId: normalizeString(options.createdByAgentId) || DEFAULT_CREATED_BY_AGENT_ID,
+      origin,
+      createdByAgentId,
     });
     return normalizeCheckpointGenerationResult(result);
   } catch (error) {
@@ -633,6 +654,9 @@ export async function generateSessionCheckpointBestEffort(sessionId, options = {
 
 export {
   DEFAULT_CREATED_BY_AGENT_ID,
+  CHECKPOINT_ORIGIN_SERVICE,
+  CHECKPOINT_ORIGIN_AGENT,
+  normalizeCheckpointOrigin,
   DEFAULT_BATCH_MAX_CHECKPOINTS,
   DEFAULT_MAX_EVENTS,
   DEFAULT_MIN_EVENTS,

package/src/session/codebase-context.js

@@ -0,0 +1,54 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isMainThread, parentPort, Worker, workerData } from "node:worker_threads";
+
+const CACHE_LIMIT_BYTES = 2 * 1024 * 1024;
+const CACHE_TIMEOUT_MS = 750;
+
+// Session creation is not an ingest command. Never recursively walk the cwd:
+// it can be a home directory, a monorepo, or a slow network filesystem.
+// The worker owns only a read; it cannot write metadata after its deadline.
+if (!isMainThread && workerData?.kind === "session-context-cache") {
+  let context = {};
+  try {
+    const cachePath = path.join(workerData.targetPath, ".sentinelayer", "CODEBASE_INGEST.json");
+    const stat = await fs.stat(cachePath);
+    if (stat.isFile() && stat.size <= CACHE_LIMIT_BYTES) {
+      const raw = await fs.readFile(cachePath);
+      if (raw.byteLength <= CACHE_LIMIT_BYTES) {
+        const parsed = JSON.parse(raw.toString("utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) context = parsed;
+      }
+    }
+  } catch {
+    // Missing, malformed, unreadable or oversized optional context is absent.
+  }
+  parentPort.postMessage(context);
+}
+
+export async function readSessionCodebaseContext(targetPath, { timeoutMs = CACHE_TIMEOUT_MS } = {}) {
+  let worker;
+  let timer;
+  try {
+    worker = new Worker(new URL("./codebase-context.js", import.meta.url), {
+      workerData: { kind: "session-context-cache", targetPath },
+      resourceLimits: { maxOldGenerationSizeMb: 32 },
+      stdout: true,
+      stderr: true,
+    });
+    worker.stdout.resume();
+    worker.stderr.resume();
+    return await new Promise((resolve) => {
+      timer = setTimeout(() => resolve({}), timeoutMs);
+      worker.once("message", resolve);
+      worker.once("error", () => resolve({}));
+      worker.once("exit", () => resolve({}));
+    });
+  } catch {
+    return {};
+  } finally {
+    clearTimeout(timer);
+    // Await actual worker termination, not merely a race against its promise.
+    if (worker) await worker.terminate();
+  }
+}

package/src/session/coordination-guidance.js

@@ -2,12 +2,12 @@ export const COORDINATION_GUIDANCE_TITLE = "Multi-Agent Coordination Protocol";
 
 export const COORDINATION_ETIQUETTE_ITEMS = Object.freeze([
   "Find the recent Senti session for this codebase: run `sl session list --path .` and `sl session list --remote --path .`; join the right room with `sl session join <id> --name <your-name> --role coder`.",
-  "When you have an agent grant, post agent updates with `sl session post-agent <id> \"status: <update>\" --agent <your-agent-id>` so they render as the agent, not the human relay.",
-  "Before implementation, post a short plan and file claims with `sl session say <id> \"plan: <scope>; files: <paths>\"`.",
-  "Claim shared files before editing with `lock: <file> - <intent>` and release them with `unlock: <file> - done`.",
-  "Run one background/secondary listener for replies with `sl session listen --session <id> --agent <your-name> --interval 60 --active-interval 5 --emit ndjson --no-presence`; this idles at 60s, switches to 5s after human activity, and avoids durable listener heartbeat noise. `session listen` now refuses duplicate local listeners for the same session/agent by default; use `--force` only to stop and replace an existing local owner and `--allow-duplicate` only when you intentionally need parallel wake hooks. `session listen` is only a delivery cursor, not a grounding command; join or recap before acting. For your primary interactive listener, omit `--no-presence` so other participants can see you online. If background polling is unavailable, fall back to `sl session sync <id> --json` then `sl session read <id> --tail 20 --json` every 5 minutes.",
-  "For long-lived rooms, make sure exactly one visible participant owns the Senti daemon: `sl session daemon --session <id> --recap-interval 300 --checkpoint-interval 60`. If no durable recap/checkpoint is appearing, run `sl session recap now <id> --remote --agent <your-name> --json` before posting a long plan.",
-  "Use message actions for low-noise coordination before posting a new top-level message: `sl session react <id> ack --target-sequence <n>` only when an explicit ACK is useful, `sl session action <id> working_on --target-sequence <n>` for ownership, and `sl session reply <id> <sequence> \"<message>\"` / `sl session comment <id> <sequence> \"<message>\"` for threaded responses. Read receipts are automatic when you use `sl session read <id> --remote --agent <your-name>`; reserve `sl session view <id> <sequence>` for repair/backfill. Run `sl session actions` for the full list.",
+  "Keep transient activity outside chat with `sl session action <id> working_on --target-sequence <n>`; post through `sl session post-agent` only for a material decision, finding, blocker, handoff, or completion so the transcript remains readable.",
+  "Before implementation, post a short semantic plan only when peers need it; keep routine ownership and progress in message actions.",
+  "Claim shared files outside chat before editing with `sl session lock <id> <file> --agent <your-agent-id> --intent \"<intent>\"`; install terminal/editor preflights once with `sl session guard-install <id> --agent <your-agent-id>`, inspect with `sl session locks <id>`, renew long work with `sl session renew`, and release with `sl session unlock`. Lease lifecycle never belongs in chat; guarded terminal/editor denials report the file, holder, intent, and expiry directly to the blocked agent.",
+  "Run one background/secondary listener for replies with `sl session listen --session <id> --agent <your-name> --transport poll --interval 60 --active-interval 60 --emit ndjson --no-presence`; polling applies bounded jitter, exponential transient backoff, and `Retry-After` as a hard floor. `session listen` refuses duplicate local listeners for the same session/agent by default; use `--force` only to stop and replace an existing local owner and `--allow-duplicate` only when you intentionally need parallel wake hooks. `session listen` is only a delivery cursor, not a grounding command; join or recap before acting. For your primary interactive listener, omit `--no-presence` so it renews an ephemeral TTL outside the transcript. Unsupported or degraded presence remains unknown and never falls back to durable heartbeat events. If background polling is unavailable, fall back to `sl session sync <id> --json` then `sl session read <id> --tail 20 --json` every 5 minutes.",
+  "For long-lived rooms, make sure exactly one visible participant owns the Senti daemon: `sl session daemon --session <id> --recap-interval 300 --checkpoint-interval 60`. Routine room health is a derived status projection, not a transcript event; run `sl session recap now <id> --remote --agent <your-name> --json` for local grounding and use an explicit checkpoint only for a durable semantic handoff.",
+  "Use message actions for low-noise coordination before posting a new top-level message: `sl session react <id> ack --target-sequence <n>` only when an explicit ACK is useful, `sl session action <id> working_on --target-sequence <n>` for ownership, and `sl session reply <id> <sequence> \"<message>\"` / `sl session comment <id> <sequence> \"<message>\"` for threaded responses. `sl session read <id> --remote --agent <your-name>` advances one monotonic per-agent delivery cursor for the displayed window; it never appends per-message view events or proves human viewing. Correct your own message with `sl session edit <id> <sequence-or-reply-uuid> \"<replacement>\"`; edits retain audit history and notify recipients. Run `sl session actions` for the full list.",
   "Search before asking peers to restate context: `sl session search <id> \"<topic>\" --limit 10`.",
   "Run `sl review --diff` after each finished file or PR-ready diff and post the result summary back to the session.",
   "Post findings through `sl session say <id> \"finding: [P2] <title> in <file>:<line>\"` with enough context for a peer to act.",

package/src/session/daemon-spawn.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 
 import { resolveSessionPaths } from "./paths.js";
 import {
@@ -116,9 +117,22 @@ export async function getDaemonStatus(sessionId, { targetPath = process.cwd() }
   };
 }
 
+// The daemon is ALWAYS this package's own CLI entry, never "whatever script is running".
+// It used to be process.argv[1]: under a test runner that is the TEST FILE, so the "daemon"
+// re-ran the tests, and every bootstrapped session spawned more detached copies of them.
+// On 2026-09-29 one such run became a detached fork bomb that took the machine down and
+// created thousands of sessions on the API.
+const CLI_ENTRY_PATH = fileURLToPath(new URL("../../bin/sl.js", import.meta.url));
+
 export function resolveCliEntryPath() {
-  const entry = normalizeString(process.argv[1]);
-  return entry ? path.resolve(entry) : "";
+  return CLI_ENTRY_PATH;
+}
+
+// Under the node test runner (it sets NODE_TEST_CONTEXT in every test process), a detached
+// daemon outlives the test that started it. One is spawned only when the test names the
+// entry itself (cliPath), deliberately; never as a side effect of code under test.
+function underTestRunner() {
+  return normalizeString(process.env.NODE_TEST_CONTEXT) !== "";
 }
 
 /**
@@ -156,6 +170,10 @@ export async function spawnDetachedSentiDaemon({
     };
   }
 
+  if (!normalizeString(cliPath) && underTestRunner()) {
+    return { spawned: false, pid: null, reason: "test_runner", logPath: "" };
+  }
+
   const entryPath = normalizeString(cliPath) || resolveCliEntryPath();
   if (!entryPath) {
     return { spawned: false, pid: null, reason: "cli_entry_unresolved", logPath: "" };

package/src/session/daemon.js

@@ -22,11 +22,6 @@ import {
   registerAgent,
   unregisterAgent,
 } from "./agent-registry.js";
-import {
-  DEFAULT_FILE_LOCK_TTL_SECONDS,
-  lockFile,
-  unlockFile,
-} from "./file-locks.js";
 import {
   DEFAULT_MAX_EVENTS as DEFAULT_CHECKPOINT_MAX_EVENTS,
   DEFAULT_MIN_EVENTS as DEFAULT_CHECKPOINT_MIN_EVENTS,
@@ -65,8 +60,6 @@ const DEFAULT_CHECKPOINT_INTERVAL_MS = 60_000;
 const DEFAULT_CHECKPOINT_EVENT_THRESHOLD = DEFAULT_CHECKPOINT_MIN_EVENTS;
 const DEFAULT_CHECKPOINT_IDLE_MS = DEFAULT_RECAP_INACTIVITY_MS_OVERRIDE;
 const CHECKPOINT_MEANINGFUL_EVENT_NAMES = new Set([
-  "file_lock",
-  "file_unlock",
   "finding",
   "help_request",
   "help_response",
@@ -84,6 +77,9 @@ const CHECKPOINT_IGNORED_EVENT_NAMES = new Set([
   "agent_status",
   "context_briefing",
   "daemon_alert",
+  "file_lock",
+  "file_lock_expired",
+  "file_unlock",
   "session_checkpoint",
   "session_listen_error",
   "session_recap",
@@ -138,14 +134,27 @@ async function emitSentiEvent(
   payload = {},
   { targetPath = process.cwd(), nowIso = new Date().toISOString() } = {}
 ) {
+  const projectionOnly = normalizeString(event) === "daemon_alert";
   const envelope = createAgentEvent({
     event,
     agentId: SENTI_IDENTITY.id,
     agentModel: SENTI_IDENTITY.model,
     sessionId,
     ts: normalizeIsoTimestamp(nowIso, new Date().toISOString()),
-    payload,
+    payload: projectionOnly
+      ? {
+          ...payload,
+          ephemeral: true,
+          projection: "session_health",
+        }
+      : payload,
   });
+  // Daemon health, presence, conflict hints, and lifecycle notices are
+  // operational projections. They are returned to the caller/status surface,
+  // but never become durable conversation rows.
+  if (projectionOnly) {
+    return envelope;
+  }
   await appendToStream(sessionId, envelope, {
     targetPath,
   });
@@ -731,126 +740,12 @@ async function runHelpWatcher(daemonState) {
   }
 }
 
-function splitFileAndIntent(raw = "") {
-  const normalized = normalizeString(raw);
-  if (!normalized) {
-    return {
-      filePath: "",
-      intent: "",
-    };
-  }
-  const separatorMatch = /\s(?:—|–|-)\s/.exec(normalized);
-  if (!separatorMatch) {
-    return {
-      filePath: normalizeString(normalized),
-      intent: "",
-    };
-  }
-  const separatorIndex = Number(separatorMatch.index || 0);
-  return {
-    filePath: normalizeString(normalized.slice(0, separatorIndex)),
-    intent: normalizeString(normalized.slice(separatorIndex + separatorMatch[0].length)),
-  };
-}
-
-function parseSessionDirective(event = {}) {
-  if (normalizeString(event.event) !== "session_message") {
-    return null;
-  }
-  const message = normalizeString(event.payload?.message);
-  if (!message) {
-    return null;
-  }
-  const directive = /^(lock|unlock)\s*:\s*(.+)$/i.exec(message);
-  if (!directive) {
-    return null;
-  }
-  const action = normalizeString(directive[1]).toLowerCase();
-  const body = normalizeString(directive[2]);
-  const parsed = splitFileAndIntent(body);
-  if (!parsed.filePath) {
-    return null;
-  }
-  return {
-    action,
-    filePath: parsed.filePath,
-    intent: parsed.intent,
-  };
-}
-
-async function maybeHandleSessionDirective(daemonState, event) {
+async function maybeHandleTaskDirective(daemonState, event) {
   const agentId = normalizeString(event.agent?.id);
   if (!agentId || agentId === SENTI_IDENTITY.id) {
     return null;
   }
   const nowIso = normalizeIsoTimestamp(event.ts, new Date().toISOString());
-  const fileDirective = parseSessionDirective(event);
-  if (fileDirective) {
-    if (fileDirective.action === "lock") {
-      const result = await lockFile(
-        daemonState.sessionId,
-        agentId,
-        fileDirective.filePath,
-        {
-          intent: fileDirective.intent,
-          ttlSeconds: DEFAULT_FILE_LOCK_TTL_SECONDS,
-          targetPath: daemonState.targetPath,
-          nowIso,
-        }
-      );
-      if (!result.locked) {
-        await emitSentiEvent(
-          daemonState.sessionId,
-          "daemon_alert",
-          {
-            alert: "file_lock_denied",
-            file: result.file || fileDirective.filePath,
-            requestedBy: agentId,
-            heldBy: result.heldBy || null,
-            since: result.since || null,
-            suggestion: `${fileDirective.filePath} is locked by ${result.heldBy || "another agent"} (${result.since || "recently"}). Coordinate before editing.`,
-          },
-          {
-            targetPath: daemonState.targetPath,
-            nowIso,
-          }
-        );
-      }
-      return result;
-    }
-    if (fileDirective.action === "unlock") {
-      const result = await unlockFile(
-        daemonState.sessionId,
-        agentId,
-        fileDirective.filePath,
-        {
-          reason: "session_message_unlock",
-          targetPath: daemonState.targetPath,
-          nowIso,
-        }
-      );
-      if (!result.unlocked && result.reason === "held_by_other_agent") {
-        await emitSentiEvent(
-          daemonState.sessionId,
-          "daemon_alert",
-          {
-            alert: "file_unlock_denied",
-            file: result.file || fileDirective.filePath,
-            requestedBy: agentId,
-            heldBy: result.heldBy || null,
-            since: result.since || null,
-            suggestion: `${fileDirective.filePath} is locked by ${result.heldBy || "another agent"}. Only the lock holder can release it.`,
-          },
-          {
-            targetPath: daemonState.targetPath,
-            nowIso,
-          }
-        );
-      }
-      return result;
-    }
-  }
-
   try {
     return await handleTaskDirective(daemonState.sessionId, event, {
       targetPath: daemonState.targetPath,
@@ -888,10 +783,10 @@ async function runSessionDirectiveWatcher(daemonState) {
       if (!daemonState.running) {
         return;
       }
-      if (normalizeString(event.event) !== "session_message") {
+      if (normalizeString(event.event) !== "session_message" || Number(event.messageRevision || 1) > 1) {
         continue;
       }
-      await maybeHandleSessionDirective(daemonState, event);
+      await maybeHandleTaskDirective(daemonState, event);
     }
   } catch (error) {
     if (error && typeof error === "object" && error.name === "AbortError") {
@@ -1385,6 +1280,12 @@ async function maybeGenerateSessionCheckpoint(
       targetPath: daemonState.targetPath,
       minEvents: daemonState.checkpointMinEvents,
       maxEvents: daemonState.checkpointMaxEvents,
+      // origin is the AUTHORITATIVE field (lane 2): this daemon is a process an agent
+      // started, so its cuts are origin:'agent' — never the managed service, even though
+      // #800's humble default would already resolve to agent. Declaring it explicitly means
+      // the daemon's honesty does not silently ride on that default. createdBy stays the
+      // descriptive "senti" persona; origin:'agent' is what a DoD/audit keys on.
+      origin: "agent",
       createdByAgentId: SENTI_IDENTITY.id,
       nowIso: normalizedNow,
     });

package/src/session/event-identity.js

@@ -25,6 +25,9 @@ export function sessionEventHasDurableCursor(event = {}) {
 }
 
 export function sessionEventUpgradesExisting(existingEvent = {}, candidateEvent = {}) {
+  const existingRevision = Number(existingEvent.messageRevision ?? 1);
+  const candidateRevision = Number(candidateEvent.messageRevision ?? 1);
+  if (candidateRevision !== existingRevision) return candidateRevision > existingRevision;
   const existingSequence = readSessionEventSequence(existingEvent);
   const candidateSequence = readSessionEventSequence(candidateEvent);
   if (candidateSequence > 0 && existingSequence <= 0) {
@@ -85,7 +88,10 @@ function mergeObjectPreferringPrimary(primaryValue, secondaryValue) {
 function mergeDuplicateEvent(existingEvent = {}, candidateEvent = {}) {
   const existingScore = eventDurabilityScore(existingEvent);
   const candidateScore = eventDurabilityScore(candidateEvent);
-  const candidateIsPrimary = candidateScore > existingScore || (
+  const existingRevision = Number(existingEvent.messageRevision ?? 1);
+  const candidateRevision = Number(candidateEvent.messageRevision ?? 1);
+  const differentRevision = existingRevision !== candidateRevision;
+  const candidateIsPrimary = differentRevision ? candidateRevision > existingRevision : candidateScore > existingScore || (
     candidateScore === existingScore &&
     sessionEventUpgradesExisting(existingEvent, candidateEvent)
   ) || (
@@ -99,7 +105,8 @@ function mergeDuplicateEvent(existingEvent = {}, candidateEvent = {}) {
     ...secondaryEvent,
     ...primaryEvent,
     agent: mergeObjectPreferringPrimary(primaryEvent.agent, secondaryEvent.agent),
-    payload: mergeObjectPreferringPrimary(primaryEvent.payload, secondaryEvent.payload),
+    // Revision snapshots replace, rather than merge, the body/routing fields.
+    payload: differentRevision ? primaryEvent.payload : mergeObjectPreferringPrimary(primaryEvent.payload, secondaryEvent.payload),
   };
 }