sentinelayer-cli 0.42.0 → 0.44.0

package/README.md

@@ -163,10 +163,56 @@ sl session join <session-id> --agent <agent-name>
 sl session action <session-id> working_on --target-sequence <n>
 ```
 
+For a room that requires agent admission, the agent declares its goal, requested
+actions, and TTL. The CLI creates an agent-held Ed25519 identity and waits for a
+human decision. When the API reports identity readiness on the approved
+admission, the CLI also waits for the minted AIdenID email and verified signed
+purpose receipt before it claims; when the API does not report it, the approved
+grant is claimed directly. The claim uses proof of possession, then the agent
+joins. The private key and scoped credential are stored locally and are never
+printed:
+
+```bash
+# Agent: request and wait for the owner's decision (maximum grant TTL is 24h).
+sl session join <session-id> --agent review-agent \
+  --goal "Review the release and report findings" \
+  --scope session.read,session.post --ttl 24h
+
+# Or request without waiting, for an asynchronous handoff.
+sl session access request <session-id> --agent review-agent \
+  --goal "Review the release and report findings" \
+  --scope session.read,session.post --ttl 24h --json
+
+# Owner/admin: inspect the untrusted goal claim, then approve, narrow, or deny.
+sl session access mode <session-id> required
+sl session access list <session-id> --status pending
+sl session access approve <session-id> <admission-id> \
+  --scope session.read,session.post --ttl 24h
+# sl session access deny <session-id> <admission-id> --note "reason"
+# sl session access revoke <session-id> <admission-id> --reason "work complete"
+```
+
+`session access list --json` reports the `email`, `purpose`, and Jev status the
+API returns; the CLI does not invent successful issuance. On an API that gates
+the claim on identity evidence, approval queues the AIdenID email and
+purpose-receipt work and the claim challenge is withheld until both are ready.
+On an API that does not, approval issues the claim challenge directly.
+The agent must re-run `session join` with the same goal, scope, and TTL after an
+asynchronous request so it can claim and verify its live session-bound receipt.
+A room's admission mode is whatever the API stored for it; `session access list`
+shows it, and an owner changes it with `session access mode <session-id>
+required` (or `legacy`).
+
+The owner actions (`approve`, `deny`, `revoke`, `mode`) run on the owner's own
+session. They are unavailable in an agent context, meaning `SENTINELAYER_AGENT_ID`
+is set or agent admission credentials are stored on the machine; owners use the
+web dashboard from such machines. `session access` commands are not exposed
+through the MCP CLI bridge.
+
 Sentinelayer includes a deterministic session coordination surface for multi-agent coding loops:
 
 - session event stream and replay (`start`, `join`, `say`, `read`, `status`, `leave`, `list`, `kill`)
-- low-noise message actions (`react ack|like|dislike`, `action working_on|disregard`, `reply`/`comment`, `actions`) plus one monotonic per-agent read cursor (`view`)
+- low-noise message actions (`react ack|like|dislike|unlike|undislike`, `action working_on|disregard`, `reply`/`comment`, `actions`) plus one monotonic per-agent read cursor (`view`)
 - agent lifecycle controls (join/ephemeral TTL presence/leave/kill); listener liveness never enters the durable transcript
 - recap and context briefing for late-joining agents
 - analytics + lineage artifacts at session closeout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {

package/src/commands/session.js

@@ -98,12 +98,24 @@ import {
   parseTtlSeconds as parseAdmissionTtlSeconds,
   runAdmissionJoin,
 } from "../session/admission.js";
+import {
+  decideSessionAdmission,
+  getSessionAdmission,
+  listSessionAdmissions,
+  revokeSessionAdmission,
+  setSessionAdmissionMode,
+} from "../session/admission-access.js";
 import {
   assertCanonicalAgentId,
   canonicalAgentId,
   currentAdmittedAgent,
   withAgentAdmission,
 } from "../session/admission-auth.js";
+import {
+  SESSION_REACTION_TYPES,
+  isSessionReactionType,
+  submitSessionReaction,
+} from "../session/reactions.js";
 import {
   claimTicket,
   listTickets,
@@ -557,10 +569,16 @@ const SESSION_MESSAGE_ACTION_TYPES = new Set([
   "reply",
   "like",
   "dislike",
+  "unlike",
+  "undislike",
   "disregard",
   "view",
 ]);
 
+// like/dislike/unlike/undislike all go through src/session/reactions.js, the path the
+// local MCP server shares; `ack` keeps the plain message-action path.
+const SESSION_REACT_COMMAND_TYPES = Object.freeze(["ack", ...SESSION_REACTION_TYPES]);
+
 const SESSION_MESSAGE_ACTION_ALIASES = new Map([
   ["comment", "reply"],
 ]);
@@ -592,6 +610,16 @@ const SESSION_MESSAGE_ACTION_DESCRIPTIONS = Object.freeze([
     command: "sl session react <id> dislike --target-sequence <n>",
     description: "Negative lightweight feedback. Use --target-action-id <uuid> to react to a threaded reply.",
   },
+  {
+    type: "unlike",
+    command: "sl session react <id> unlike --target-sequence <n>",
+    description: "Retract your own active like. Refused when you have none; needs a server with reaction undo.",
+  },
+  {
+    type: "undislike",
+    command: "sl session react <id> undislike --target-sequence <n>",
+    description: "Retract your own active dislike. Refused when you have none; needs a server with reaction undo.",
+  },
   {
     type: "disregard",
     command: "sl session action <id> disregard --target-sequence <n>",
@@ -623,7 +651,7 @@ function shortSha256(value) {
 
 function actionEventType(actionType) {
   if (actionType === "reply") return "session_reply";
-  if (actionType === "like" || actionType === "dislike") return "session_reaction";
+  if (isSessionReactionType(actionType)) return "session_reaction";
   return "session_action";
 }
 
@@ -679,6 +707,7 @@ function buildSessionActionEvent(sessionId, action = {}) {
       }),
     );
   const actorId = actionActorId(action);
+  const collapsedIntoActionId = normalizeString(action.collapsedIntoActionId ?? action.collapsed_into_action_id);
   const event = createAgentEvent({
     event: actionEventType(actionType),
     agent: {
@@ -703,6 +732,8 @@ function buildSessionActionEvent(sessionId, action = {}) {
       metadata: action.metadata && typeof action.metadata === "object" ? action.metadata : undefined,
       message: actionDisplayMessage(action),
       source: "session_action",
+      // A retained no-op reaction key (sentinelayer-api#914): evidence, not a reaction.
+      ...(collapsedIntoActionId ? { collapsedIntoActionId } : {}),
     },
   });
   event.eventId = `session-action-${id}`;
@@ -3488,17 +3519,24 @@ export function registerSessionCommand(program) {
           wait: options.wait !== false,
           waitTimeoutMs: (Number.isFinite(waitSeconds) && waitSeconds >= 0 ? waitSeconds : 900) * 1000,
           targetPath,
-          onPending: ({ approveUrl }) => {
+          onPending: ({ approveUrl, phase }) => {
             // stderr, so --json stdout stays a single parseable document.
-            const line = `Waiting for a room owner to approve this agent: ${approveUrl}`;
+            const line = phase === "identity"
+              ? "Approval received; waiting for the AIdenID email and signed purpose receipt."
+              : `Waiting for a room owner to approve this agent: ${terminalText(approveUrl, 1024)}`;
             if (emitJson) process.stderr.write(`${line}\n`);
-            else console.log(pc.yellow(line));
+            // Keep the line containing a remote URL free of all terminal control
+            // bytes. `terminalText()` strips controls from the value itself; adding
+            // local ANSI colour around it would make that guarantee untestable and
+            // lets OSC-looking input hide inside a coloured terminal span.
+            else if (phase === "identity") console.log(pc.yellow(line));
+            else console.log(line);
           },
         });
         if (admission.status !== "active") {
           // Only an ACTIVE admission joins. Pending, denied, cancelled or expired never
           // registers the agent or materializes the room for it.
-          process.exitCode = admission.status === "pending" ? 3 : 4;
+          process.exitCode = ["pending", "approved"].includes(admission.status) ? 3 : 4;
           const payload = {
             command: "session join",
             joined: false,
@@ -3510,9 +3548,12 @@ export function registerSessionCommand(program) {
           if (emitJson) {
             console.log(JSON.stringify(payload, null, 2));
           } else if (admission.status === "pending") {
-            console.log(pc.yellow(`Admission pending. A room owner approves it here: ${admission.approveUrl || "(see the session page)"}`));
+            const approval = terminalText(admission.approveUrl, 1024) || "(see the session page)";
+            console.log(`Admission pending. A room owner approves it here: ${approval}`);
+          } else if (admission.status === "approved") {
+            console.log(pc.yellow("Admission approved; AIdenID identity evidence is still provisioning. The agent was not joined."));
           } else {
-            console.log(pc.red(`Admission ${admission.status}. The agent was not joined.`));
+            console.log(pc.red(`Admission ${terminalText(admission.status, 16) || "unknown"}. The agent was not joined.`));
           }
           return;
         }
@@ -4265,6 +4306,21 @@ export function registerSessionCommand(program) {
       );
     }
     const agentId = identity.agentId;
+    if (isSessionReactionType(normalizedActionType)) {
+      return runReactionCommand({
+        sessionId: normalizedSessionId,
+        reaction: normalizedActionType,
+        agentId,
+        targetPath,
+        targetSequenceId,
+        targetCursor,
+        targetActionId,
+        note,
+        options,
+        command,
+        commandName,
+      });
+    }
     const idempotencyKey =
       normalizeString(options.idempotencyKey) ||
       defaultActionIdempotencyKey({
@@ -4347,6 +4403,89 @@ export function registerSessionCommand(program) {
     return payload;
   }
 
+  // like/dislike/unlike/undislike: the shared reaction path (src/session/reactions.js)
+  // decides admission, the operation key and the outcome; this only mirrors and prints.
+  // `--idempotency-key` is a RETRY of the intent that minted that key.
+  async function runReactionCommand({
+    sessionId,
+    reaction,
+    agentId,
+    targetPath,
+    targetSequenceId,
+    targetCursor,
+    targetActionId,
+    note,
+    options,
+    command,
+    commandName,
+  }) {
+    const outcome = await submitSessionReaction({
+      surface: "cli",
+      sessionId,
+      agentId,
+      reaction,
+      targetSequenceId,
+      targetCursor,
+      targetActionId,
+      note,
+      idempotencyKey: options.idempotencyKey,
+      targetPath,
+    });
+    let event = null;
+    let localAppend = { appended: false, reason: "not_recorded" };
+    if (outcome.action) {
+      const appended = await appendActionEventIfMissing(
+        sessionId,
+        buildSessionActionEvent(sessionId, outcome.action),
+        { targetPath },
+      );
+      event = appended.event;
+      localAppend = { appended: Boolean(appended.appended), reason: appended.reason || "" };
+    }
+    let evidenceEvent = null;
+    if (outcome.collapsedActionId && outcome.action) {
+      // Mirror the server's retained no-op row: this request's key, collapsed into
+      // the active reaction it repeated.
+      const appended = await appendActionEventIfMissing(
+        sessionId,
+        buildSessionActionEvent(sessionId, {
+          id: outcome.collapsedActionId,
+          actionType: reaction,
+          targetSequenceId: outcome.action.targetSequenceId,
+          targetCursor: outcome.action.targetCursor,
+          targetActionId: outcome.action.targetActionId,
+          actorKind: outcome.action.actorKind,
+          actorId: outcome.action.actorId,
+          actorRole: outcome.action.actorRole,
+          idempotencyKey: outcome.operationKey,
+          collapsedIntoActionId: outcome.action.id,
+        }),
+        { targetPath },
+      );
+      evidenceEvent = appended.event;
+    }
+    const payload = {
+      command: commandName,
+      targetPath,
+      ...outcome,
+      event,
+      evidenceEvent,
+      localAppend,
+    };
+    if (!outcome.ok) process.exitCode = 1;
+    if (shouldEmitJson(options, command)) {
+      console.log(JSON.stringify(payload, null, 2));
+      return payload;
+    }
+    if (!outcome.ok) {
+      console.error(pc.yellow(outcome.message));
+      return payload;
+    }
+    if (event) console.log(formatEventLine(event));
+    if (outcome.outcome !== "applied" || !event) console.log(pc.gray(outcome.message));
+    return payload;
+  }
+
   session
     .command("actions")
     .description("List supported low-noise message actions with examples")
@@ -4373,7 +4512,7 @@ export function registerSessionCommand(program) {
   session
     .command("action <sessionId> <actionType>")
     .description(
-      "Create a message action for a target session event (ack, working_on, reply/comment, like, dislike, disregard, view)",
+      "Create a message action for a target session event (ack, working_on, reply/comment, like, dislike, unlike, undislike, disregard, view)",
     )
     .option("--target-sequence <n>", "Target event sequence id")
     .option("--target-cursor <cursor>", "Target event cursor")
@@ -4389,18 +4528,23 @@ export function registerSessionCommand(program) {
 
   session
     .command("react <sessionId> <reaction>")
-    .description("React to or acknowledge a target session event with ack, like, or dislike")
+    .description(
+      "React to or acknowledge a target session event with ack, like, or dislike; retract your own like/dislike with unlike/undislike",
+    )
     .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 authoring the action (defaults to the joined session agent)")
-    .option("--idempotency-key <key>", "Explicit idempotency key")
+    .option(
+      "--idempotency-key <key>",
+      "Retry an earlier reaction as the SAME intent by resending its operationKey (without it, each call is a new intent)",
+    )
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
     .action(async (sessionId, reaction, options, command) => {
       const normalizedReaction = normalizeSessionMessageActionType(reaction);
-      if (!["ack", "like", "dislike"].includes(normalizedReaction)) {
-        throw new Error("reaction must be one of: ack, like, dislike.");
+      if (!SESSION_REACT_COMMAND_TYPES.includes(normalizedReaction)) {
+        throw new Error(`reaction must be one of: ${SESSION_REACT_COMMAND_TYPES.join(", ")}.`);
       }
       await runMessageActionCommand({
         sessionId,
@@ -6787,6 +6931,285 @@ export function registerSessionCommand(program) {
       }
     });
 
+  // ------------------------------------------------------- agent access
+  // Human control plane for the Agent Admission Contract. The request command
+  // delegates to the established agent-side flow; list/decision/revoke use the
+  // matching owner-only REST routes. Goal text is an agent claim and is always
+  // rendered as bounded, untrusted data.
+  const access = session
+    .command("access")
+    .description("Request and govern AIdenID-backed, scoped agent access to a session");
+
+  function accessOutput(options, command, payload, render) {
+    if (shouldEmitJson(options, command)) {
+      console.log(JSON.stringify(payload, null, 2));
+      return;
+    }
+    render();
+  }
+
+  function terminalText(value, maxLength = 240) {
+    let result = "";
+    for (const ch of normalizeString(value).normalize("NFC")) {
+      // Refuse terminal control/invisible formatting from remote values,
+      // including ANSI/OSC initiators and bidi overrides/isolates.
+      result += /[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}\p{Zl}\p{Zp}]/u.test(ch) ? " " : ch;
+      if (result.length >= maxLength) break;
+    }
+    return result.replace(/\s+/gu, " ").trim();
+  }
+
+  function renderAdmissionLine(admission) {
+    const requested = Array.isArray(admission?.requestedScope?.actions)
+      ? terminalText(admission.requestedScope.actions.join(","), 180)
+      : "scope unavailable";
+    const ttl = Number(admission?.requestedScope?.ttlSeconds);
+    const duration = Number.isFinite(ttl) ? ` for ${ttl}s` : "";
+    const identity = terminalText(admission?.displayName, 120) || terminalText(admission?.agentId, 64) || "unknown-agent";
+    console.log(`${terminalText(admission?.admissionId, 64) || "unknown"}  ${terminalText(admission?.status, 16) || "unknown"}  ${identity}`);
+    console.log(pc.gray(`  requested: ${requested}${duration}`));
+    const summary = terminalText(admission?.goal?.summary);
+    if (summary) console.log(pc.gray(`  claimed goal (untrusted): ${JSON.stringify(summary)}`));
+    if (admission?.email) {
+      // Human terminal output is routinely copied into logs and support
+      // transcripts. Keep the address in the explicit --json response only.
+      const inboxStatus = terminalText(admission.email.status, 32) || "unknown";
+      console.log(pc.gray(`  AIdenID inbox: ${inboxStatus}`));
+    }
+  }
+
+  access
+    .command("mode <sessionId> <mode>")
+    .description("Set whether this room requires admission for agent-attributed access (required or legacy)")
+    .option("--idempotency-key <key>", "Retry the same logical mode change safely")
+    .option("--path <path>", "Workspace path for auth context", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, mode, options, command) => {
+      const sid = normalizeString(sessionId);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const changed = await setSessionAdmissionMode(sid, mode, {
+        idempotencyKey: options.idempotencyKey,
+        targetPath,
+      });
+      accessOutput(
+        options,
+        command,
+        {
+          command: "session access mode",
+          idempotencyKey: changed.idempotencyKey,
+          ...changed.result,
+        },
+        () => console.log(
+          `Agent admission mode for ${terminalText(sid, 64)}: ${terminalText(changed.result.agentAdmissionMode, 16) || "unknown"}.`,
+        ),
+      );
+    });
+
+  access
+    .command("request <sessionId>")
+    .description("Request agent access; a human must approve before the agent can claim or join")
+    .requiredOption("--agent <id>", "Canonical agent id requesting access")
+    .requiredOption("--goal <text>", "What the agent is coming to do")
+    .option("--display-name <name>", "Human-readable agent name")
+    .option("--deliverable <text>", "An output this agent will produce (repeatable)", collectOption, [])
+    .option("--stop-when <text>", "A condition that ends this agent's work (repeatable)", collectOption, [])
+    .option(
+      "--scope <actions>",
+      "Comma-separated actions: session.read, session.post, session.react, tickets.read, tickets.work",
+    )
+    .option("--ttl <duration>", "Requested grant lifetime, e.g. 90m or 24h (5m..24h)", "2h")
+    .option("--model <model>", "Agent model hint", "cli")
+    .option("--provider <name>", "Model provider hint")
+    .option("--wait", "Wait for approval and claim the grant on this machine")
+    .option("--wait-seconds <n>", "Maximum approval wait when --wait is set", "900")
+    .option("--path <path>", "Workspace path for local admission state", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, options, command) => {
+      const sid = normalizeString(sessionId);
+      const agentId = canonicalAgentId(options.agent);
+      assertCanonicalAgentId(options.agent, "--agent");
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const waitSeconds = Number.parseInt(String(options.waitSeconds ?? "900"), 10);
+      if (!Number.isFinite(waitSeconds) || waitSeconds < 0) {
+        throw new Error("--wait-seconds must be a non-negative integer.");
+      }
+      const admission = await runAdmissionJoin(sid, {
+        agentId,
+        displayName: options.displayName,
+        model: options.model,
+        provider: options.provider,
+        goal: options.goal,
+        deliverables: options.deliverable || [],
+        stopConditions: options.stopWhen || [],
+        actions: parseAdmissionScope(options.scope),
+        ttlSeconds: parseAdmissionTtlSeconds(options.ttl),
+        wait: Boolean(options.wait),
+        waitTimeoutMs: waitSeconds * 1000,
+        targetPath,
+        onPending: ({ approveUrl, phase }) => {
+          const line = phase === "identity"
+            ? "Approval received; waiting for the AIdenID email and signed purpose receipt."
+            : `Waiting for a room owner to approve this agent: ${terminalText(approveUrl, 1024)}`;
+          if (shouldEmitJson(options, command)) process.stderr.write(`${line}\n`);
+          // A line carrying a remote URL must remain free of every terminal
+          // control byte, including trusted colour wrappers. This mirrors the
+          // guarded `session join` path and keeps raw support logs auditable.
+          else if (phase === "identity") console.log(pc.yellow(line));
+          else console.log(line);
+        },
+      });
+      const payload = {
+        command: "session access request",
+        sessionId: sid,
+        agentId,
+        admission,
+        readyToJoin: admission.status === "active",
+      };
+      accessOutput(options, command, payload, () => {
+        if (admission.status === "pending") {
+          console.log(`Access requested for ${agentId}; waiting for a room owner.`);
+          if (admission.approveUrl) console.log(`Approval: ${terminalText(admission.approveUrl, 1024)}`);
+        } else if (admission.status === "active") {
+          console.log(`Access active for ${agentId}. The scoped credential is stored locally and was not printed.`);
+          console.log(pc.gray("Run `sl session join` again with the same goal, scope, and TTL to attach this agent."));
+        } else if (admission.status === "approved") {
+          console.log("Access approved; waiting for the AIdenID inbox and signed purpose receipt before claim.");
+        } else {
+          console.log(`Access ${terminalText(admission.status, 16) || "unknown"} for ${agentId}.`);
+        }
+      });
+    });
+
+  access
+    .command("list <sessionId>")
+    .description("List admission requests visible to a room owner or admin")
+    .option("--status <status>", "Filter by admission status")
+    .option("--path <path>", "Workspace path for auth context", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, options, command) => {
+      const sid = normalizeString(sessionId);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const result = await listSessionAdmissions(sid, {
+        status: options.status,
+        targetPath,
+      });
+      const payload = { command: "session access list", ...result };
+      accessOutput(options, command, payload, () => {
+        console.log(pc.gray(`Admission mode: ${terminalText(result.agentAdmissionMode, 16) || "unknown"}`));
+        if (!Array.isArray(result.admissions) || result.admissions.length === 0) {
+          console.log("No admission requests.");
+          return;
+        }
+        for (const admission of result.admissions) renderAdmissionLine(admission);
+      });
+    });
+
+  access
+    .command("status <sessionId> <admissionId>")
+    .description("Show the requesting delegator's current admission status")
+    .option("--path <path>", "Workspace path for auth context", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, admissionId, options, command) => {
+      const sid = normalizeString(sessionId);
+      const aid = normalizeString(admissionId);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const result = await getSessionAdmission(sid, aid, { targetPath });
+      accessOutput(
+        options,
+        command,
+        { command: "session access status", sessionId: sid, ...result },
+        () => {
+          console.log(`${terminalText(result.admissionId, 64) || aid}  ${terminalText(result.status, 16) || "unknown"}  ${terminalText(result.agentId, 64) || "unknown-agent"}`);
+          if (result.approveUrl) console.log(`Approval: ${terminalText(result.approveUrl, 1024)}`);
+        },
+      );
+    });
+
+  access
+    .command("approve <sessionId> <admissionId>")
+    .description("Approve a pending request, optionally narrowing its scope or TTL")
+    .option("--scope <actions>", "Comma-separated granted actions; must be a subset of the request")
+    .option("--ttl <duration>", "Granted lifetime; may only shorten the request (5m..24h)")
+    .option("--note <text>", "Approval note (max 500 characters)")
+    .option("--idempotency-key <key>", "Retry the same logical approval safely")
+    .option("--path <path>", "Workspace path for auth context", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, admissionId, options, command) => {
+      const sid = normalizeString(sessionId);
+      const aid = normalizeString(admissionId);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const decision = await decideSessionAdmission(sid, aid, {
+        decision: "approve",
+        grantedActions: options.scope === undefined ? undefined : parseAdmissionScope(options.scope),
+        ttlSeconds: options.ttl === undefined ? undefined : parseAdmissionTtlSeconds(options.ttl),
+        note: options.note,
+        idempotencyKey: options.idempotencyKey,
+        targetPath,
+      });
+      const result = decision.result;
+      accessOutput(
+        options,
+        command,
+        { command: "session access approve", sessionId: sid, idempotencyKey: decision.idempotencyKey, admission: result },
+        () => {
+          console.log(`Approved ${terminalText(result.admissionId, 64) || aid} for ${terminalText(result.agentId, 64) || "the agent"}.`);
+          if (result.email) {
+            const inboxStatus = terminalText(result.email.status, 32) || "queued";
+            console.log(pc.gray(`AIdenID inbox: ${inboxStatus}. Use --json to inspect its address.`));
+          }
+        },
+      );
+    });
+
+  access
+    .command("deny <sessionId> <admissionId>")
+    .description("Deny a pending agent admission request")
+    .option("--note <text>", "Denial note (max 500 characters)")
+    .option("--idempotency-key <key>", "Retry the same logical denial safely")
+    .option("--path <path>", "Workspace path for auth context", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, admissionId, options, command) => {
+      const sid = normalizeString(sessionId);
+      const aid = normalizeString(admissionId);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const decision = await decideSessionAdmission(sid, aid, {
+        decision: "deny",
+        note: options.note,
+        idempotencyKey: options.idempotencyKey,
+        targetPath,
+      });
+      accessOutput(
+        options,
+        command,
+        { command: "session access deny", sessionId: sid, idempotencyKey: decision.idempotencyKey, admission: decision.result },
+        () => console.log(`Denied ${terminalText(decision.result.admissionId, 64) || aid}.`),
+      );
+    });
+
+  access
+    .command("revoke <sessionId> <admissionId>")
+    .description("Revoke an approved or active agent admission")
+    .option("--reason <text>", "Revocation reason (max 200 characters)")
+    .option("--idempotency-key <key>", "Retry the same logical revocation safely")
+    .option("--path <path>", "Workspace path for auth context", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, admissionId, options, command) => {
+      const sid = normalizeString(sessionId);
+      const aid = normalizeString(admissionId);
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const revoked = await revokeSessionAdmission(sid, aid, {
+        reason: options.reason,
+        idempotencyKey: options.idempotencyKey,
+        targetPath,
+      });
+      accessOutput(
+        options,
+        command,
+        { command: "session access revoke", sessionId: sid, idempotencyKey: revoked.idempotencyKey, admission: revoked.result },
+        () => console.log(`Revoked ${terminalText(revoked.result.admissionId, 64) || aid}.`),
+      );
+    });
+
   // ---------------------------------------------------------------- tickets
   // The room's shared backlog (API "Ticket Lease Contract (T2)"). Every subcommand is
   // an ACTOR command: the runCli choke point runs it on the agent's admission.

package/src/mcp/cli-command-tools.js

@@ -64,6 +64,9 @@ const SENSITIVE_COMMAND_PREFIXES = [
   "ai.identity.target.",
   "ai.identity.site.",
   "ai.identity.legal-hold.",
+  // Room access administration (request/list/status/approve/deny/revoke/mode) belongs to
+  // the room owner's own session; operators use the direct CLI or the web dashboard.
+  "session.access.",
 ];
 const REDACTION_MARKER = "[REDACTED]";
 

package/src/mcp/registry.js

@@ -655,7 +655,7 @@ export function buildSentinelayerSessionRegistryTemplate({ generatedAt = new Dat
         name: "session_action",
         title: "Record Senti Session Action",
         description:
-          "Record a low-noise message action such as ack, working_on, disregard, like, dislike, or reply; view advances the monotonic read cursor instead of appending an action.",
+          "Record a low-noise message action such as ack, working_on, disregard, like, dislike, unlike, undislike, or reply; view advances the monotonic read cursor instead of appending an action.",
         input_schema: {
           type: "object",
           additionalProperties: false,
@@ -665,7 +665,7 @@ export function buildSentinelayerSessionRegistryTemplate({ generatedAt = new Dat
             agentId: { type: "string" },
             actionType: {
               type: "string",
-              enum: ["ack", "working_on", "reply", "like", "dislike", "disregard", "view"],
+              enum: ["ack", "working_on", "reply", "like", "dislike", "unlike", "undislike", "disregard", "view"],
             },
             targetSequenceId: { type: "integer", minimum: 1 },
             targetCursor: { type: "string" },
@@ -702,7 +702,7 @@ export function buildSentinelayerSessionRegistryTemplate({ generatedAt = new Dat
         name: "session_react",
         title: "React To Senti Message",
         description:
-          "Acknowledge or react to a target session event with ack, like, or dislike.",
+          "Acknowledge or react to a target session event with ack, like, or dislike, or retract your own like/dislike with unlike/undislike. Reactions report an outcome and an operation key; resend that key as idempotencyKey only to retry the same intent.",
         input_schema: {
           type: "object",
           additionalProperties: false,
@@ -710,7 +710,7 @@ export function buildSentinelayerSessionRegistryTemplate({ generatedAt = new Dat
           properties: {
             sessionId: { type: "string" },
             agentId: { type: "string" },
-            reaction: { type: "string", enum: ["ack", "like", "dislike"] },
+            reaction: { type: "string", enum: ["ack", "like", "dislike", "unlike", "undislike"] },
             targetSequenceId: { type: "integer", minimum: 1 },
             targetCursor: { type: "string" },
             targetActionId: { type: "string" },