sentinelayer-cli 0.34.6 → 0.35.0

package/package.json

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

package/src/commands/session.js

@@ -65,6 +65,12 @@ import {
   updateSessionTitle,
 } from "../session/store.js";
 import { fetchSessionListeners, formatListenerLine } from "../session/listeners.js";
+import {
+  getListenerProcessStatus,
+  removeListenerPidRecord,
+  requestListenerProcessStop,
+  writeListenerPidRecord,
+} from "../session/listener-process.js";
 import {
   filterSessionMaterialEvents,
   isSessionControlEvent,
@@ -109,6 +115,7 @@ import {
 } from "../session/rotating-log.js";
 import { buildSessionRecap } from "../session/recap.js";
 import { computeTranscriptStats } from "../session/transcript.js";
+import { buildSessionUsageLedger } from "../session/pricing-ledger.js";
 import {
   buildSessionUsageReport,
   buildSessionUsageReportFromLedgerPayload,
@@ -150,6 +157,22 @@ function normalizeString(value) {
   return String(value || "").trim();
 }
 
+// A wake hook hands remote-influenced event fields to a local host command
+// (as SL_WAKE_* env vars). Bound + strip each value so a crafted event cannot
+// inject control chars / newlines into the child environment or blow it up.
+const WAKE_VALUE_MAX_LENGTH = 512;
+function sanitizeWakeValue(value) {
+  // Strip control chars (incl. NUL / newline) by codepoint so a crafted remote
+  // event cannot inject into the child env; a codepoint check avoids putting a
+  // control-char regex literal in source.
+  let out = "";
+  for (const ch of normalizeString(value)) {
+    const code = ch.codePointAt(0);
+    out += code < 0x20 || code === 0x7f ? " " : ch;
+  }
+  return out.slice(0, WAKE_VALUE_MAX_LENGTH);
+}
+
 function messagePartsHaveContent(messageParts) {
   const parts = Array.isArray(messageParts) ? messageParts : [messageParts];
   return parts.some((part) => normalizeString(part));
@@ -2160,14 +2183,28 @@ export function createSessionWakeRunner({
       return;
     }
     busy = true;
+    const rawSequence = event?.sequenceId ?? event?.sequence_id ?? "";
+    const sanitizedSequence = sanitizeWakeValue(rawSequence);
     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),
+      SL_WAKE_SESSION_ID: sanitizeWakeValue(sessionId),
+      SL_WAKE_AGENT_ID: sanitizeWakeValue(agentId),
+      SL_WAKE_EVENT_TYPE: sanitizeWakeValue(event?.event),
+      SL_WAKE_EVENT_CURSOR: sanitizeWakeValue(event?.cursor),
+      SL_WAKE_EVENT_SEQUENCE: sanitizedSequence,
+      SL_WAKE_ACTOR_ID: sanitizeWakeValue(event?.agent?.id || event?.agentId),
+    };
+    // Metadata-only wake envelope for the host command's stdin. Deliberately
+    // EXCLUDES the event body/content so session message text / PII never
+    // reaches an external process — the woken agent re-reads the room over its
+    // own authenticated channel using this cursor/sequence.
+    const wakePayload = {
+      event: env.SL_WAKE_EVENT_TYPE,
+      sessionId: env.SL_WAKE_SESSION_ID,
+      agentId: env.SL_WAKE_AGENT_ID,
+      cursor: env.SL_WAKE_EVENT_CURSOR,
+      sequenceId: typeof rawSequence === "number" && Number.isFinite(rawSequence) ? rawSequence : sanitizedSequence || null,
+      actorId: env.SL_WAKE_ACTOR_ID,
     };
     let child;
     try {
@@ -2185,7 +2222,7 @@ export function createSessionWakeRunner({
     });
     try {
       if (child && child.stdin) {
-        child.stdin.write(JSON.stringify(event ?? {}));
+        child.stdin.write(JSON.stringify(wakePayload));
         child.stdin.end();
       }
     } catch {
@@ -4507,9 +4544,17 @@ export function registerSessionCommand(program) {
     .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(
+      "--force",
+      "Stop and replace an existing local listener process for this session/agent",
+    )
+    .option(
+      "--allow-duplicate",
+      "Allow multiple local listeners for the same session/agent (advanced; can duplicate wake hooks)",
+    )
     .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.",
+      "Wake hook: run this shell command on each matched event (notify->resume bridge). Metadata JSON is piped to stdin; sanitized SL_WAKE_* env vars are set.",
     )
     .option(
       "--wake-host <name>",
@@ -4635,18 +4680,59 @@ export function registerSessionCommand(program) {
       if (options.fromNow && options.since !== undefined) {
         throw new Error("Use either --from-now or --since, not both.");
       }
-      const restoreConsoleLog = listenLogPath
-        ? installRotatingConsoleLog({
-            logPath: listenLogPath,
-            maxBytes: parsePositiveInteger(options.logMaxBytes, "log-max-bytes", DEFAULT_ROTATING_LOG_MAX_BYTES),
-            maxFiles: parsePositiveInteger(options.logMaxFiles, "log-max-files", DEFAULT_ROTATING_LOG_MAX_FILES),
-            tee: true,
-          })
-        : null;
+      const listenerId = `listener-${agentId}-${randomUUID()}`;
+      const singletonEnabled = maxPolls === null && !options.allowDuplicate;
+      let listenerPidRecordActive = false;
+      if (singletonEnabled) {
+        const existingListener = await getListenerProcessStatus(normalizedSessionId, agentId, {
+          targetPath,
+        });
+        if (existingListener.running && !options.force) {
+          throw new Error(
+            `A local session listener is already running for session ${normalizedSessionId} as ${agentId} (pid ${existingListener.pid}). Use --force to take over or --allow-duplicate if you intentionally need more than one.`,
+          );
+        }
+        if (existingListener.running && options.force) {
+          const stopResult = await requestListenerProcessStop(existingListener.pid);
+          if (!stopResult.stopped) {
+            throw new Error(
+              `Unable to stop existing listener pid ${existingListener.pid} for session ${normalizedSessionId} as ${agentId} (${stopResult.reason}). Stop it manually or use --allow-duplicate if parallel listeners are intentional.`,
+            );
+          }
+        }
+        await writeListenerPidRecord(normalizedSessionId, agentId, {
+          targetPath,
+          listenerId,
+          transport: listenTransport,
+          intervalSeconds,
+          activeIntervalSeconds,
+          presenceIntervalSeconds,
+          logFile: listenLogPath,
+        });
+        listenerPidRecordActive = true;
+      }
+      let restoreConsoleLog = null;
+      try {
+        restoreConsoleLog = listenLogPath
+          ? installRotatingConsoleLog({
+              logPath: listenLogPath,
+              maxBytes: parsePositiveInteger(options.logMaxBytes, "log-max-bytes", DEFAULT_ROTATING_LOG_MAX_BYTES),
+              maxFiles: parsePositiveInteger(options.logMaxFiles, "log-max-files", DEFAULT_ROTATING_LOG_MAX_FILES),
+              tee: true,
+            })
+          : null;
+      } catch (error) {
+        if (listenerPidRecordActive) {
+          await removeListenerPidRecord(normalizedSessionId, agentId, {
+            targetPath,
+            onlyForPid: process.pid,
+          }).catch(() => {});
+        }
+        throw error;
+      }
       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;
@@ -4878,6 +4964,12 @@ export function registerSessionCommand(program) {
           restoreConsoleLog();
         }
         process.removeListener("SIGINT", onSigint);
+        if (listenerPidRecordActive) {
+          await removeListenerPidRecord(normalizedSessionId, agentId, {
+            targetPath,
+            onlyForPid: process.pid,
+          }).catch(() => {});
+        }
       }
     });
 
@@ -6267,9 +6359,14 @@ export function registerSessionCommand(program) {
       const hiddenControlEventCount =
         dedupedEvents.length - transcriptBaseEvents.length + rawActionEvents.length - actionEvents.length;
       const exportEvents = mergeSessionActionEvents(transcriptBaseEvents, actionEvents);
+      const usageLedger = buildSessionUsageLedger(exportEvents, {
+        sessionId: normalizedSessionId,
+        includeEstimatedMessages: true,
+      });
       const stats = computeTranscriptStats({
         sessionMeta: sessionPayload,
         events: exportEvents,
+        usageLedger,
       });
       const participants = buildSessionParticipants({
         statsAgents: stats.agents,

package/src/mcp/registry.js

@@ -563,6 +563,47 @@ export function buildSentinelayerSessionRegistryTemplate({ generatedAt = new Dat
           server: "sentinelayer-session-mcp",
         },
       },
+      {
+        name: "read_history",
+        title: "Read Senti History",
+        description:
+          "Hydrate a bounded recent, older, or after-cursor SentinelLayer session transcript window without recipient filtering.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId"],
+          properties: {
+            sessionId: { type: "string" },
+            cursor: { type: "string" },
+            beforeSequence: { type: "integer", minimum: 1 },
+            limit: { type: "integer", minimum: 1, maximum: 200 },
+            actionLimit: { type: "integer", minimum: 1, maximum: 200 },
+            includeActions: { type: "boolean" },
+            includeControlEvents: { type: "boolean" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/read_history",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 60,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:read"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
       {
         name: "send_message",
         title: "Send Senti Message",
@@ -985,6 +1026,13 @@ export function buildHostedSentiSessionConnectorContract({
       long_lived_cli_token_passthrough_allowed: false,
     },
     tools: [
+      hostedSessionTool({
+        toolName: "join_and_hydrate",
+        operation: "join_and_hydrate",
+        allowedUserArgs: ["limit", "actionLimit", "includeActions"],
+        requiredScopes: ["session:read"],
+        wakePayload: { policy: "bounded_redacted_window", may_include_message_content: true, max_events: 50 },
+      }),
       hostedSessionTool({
         toolName: "poll_inbox",
         operation: "read_history",
@@ -992,6 +1040,13 @@ export function buildHostedSentiSessionConnectorContract({
         requiredScopes: ["session:read"],
         wakePayload: { policy: "bounded_redacted_window", may_include_message_content: true, max_events: 50 },
       }),
+      hostedSessionTool({
+        toolName: "read_history",
+        operation: "read_history",
+        allowedUserArgs: ["cursor", "beforeSequence", "limit", "actionLimit", "includeActions"],
+        requiredScopes: ["session:read"],
+        wakePayload: { policy: "bounded_redacted_window", may_include_message_content: true, max_events: 50 },
+      }),
       hostedSessionTool({
         toolName: "send_message",
         operation: "send_message",
@@ -1279,7 +1334,7 @@ export function validateHostedSentiSessionConnectorContract(payload, { registryP
     const registry = validateMcpToolRegistry(registryPayload);
     const localToolNames = new Set(registry.tools.map((tool) => tool.name));
     const missingLocalTools = parsed.tools
-      .filter((tool) => tool.operation !== "subscribe_wake" && tool.operation !== "presence_renew" && tool.operation !== "runner_teardown")
+      .filter((tool) => tool.operation !== "join_and_hydrate" && tool.operation !== "subscribe_wake" && tool.operation !== "presence_renew" && tool.operation !== "runner_teardown")
       .map((tool) => tool.local_tool_name)
       .filter((toolName) => !localToolNames.has(toolName));
     if (missingLocalTools.length > 0) {

package/src/mcp/session-stdio-server.js

@@ -31,6 +31,8 @@ const SESSION_MCP_CONFIRM_PAGE_LIMIT = 200;
 const SESSION_MCP_CONFIRM_MAX_PAGES = 10;
 const SESSION_MCP_CONFIRM_TOTAL_TIMEOUT_MS = 10_000;
 const SESSION_MCP_CONFIRM_REQUEST_TIMEOUT_MS = 2_000;
+const SESSION_MCP_HISTORY_MAX_PAGES = 10;
+const SESSION_MCP_HISTORY_MIN_RAW_PAGE_LIMIT = DEFAULT_TOOL_LIMIT;
 const JSON_RPC_VERSION = "2.0";
 const CONTENT_LENGTH_PREFIX = "content-length:";
 const SESSION_MESSAGE_ACTION_TYPES = new Set([
@@ -444,6 +446,110 @@ function recentHumanActivityFromActions(remoteActions = null, { limit = DEFAULT_
     : [];
 }
 
+function normalizeHistoryEvents(events = [], { includeControlEvents = false } = {}) {
+  return (Array.isArray(events) ? events : []).filter((event) => {
+    if (!includeControlEvents && isSessionControlEvent(event)) return false;
+    return true;
+  });
+}
+
+async function readSessionHistoryWindow({
+  sessionId,
+  targetPath,
+  cursor = null,
+  beforeSequence = null,
+  limit = DEFAULT_TOOL_LIMIT,
+  includeControlEvents = false,
+  forceCircuitProbe = false,
+  pollSessionEventsFn = pollSessionEvents,
+  pollSessionEventsBeforeFn = pollSessionEventsBefore,
+} = {}) {
+  const source = cursor ? "after_cursor" : beforeSequence ? "before_sequence" : "latest_tail";
+  let pageCursor = cursor;
+  let pageBeforeSequence = beforeSequence;
+  let responseCursor = cursor;
+  let responseBeforeSequence = beforeSequence || null;
+  let rawEventCount = 0;
+  let pages = 0;
+  let events = [];
+
+  while (events.length < limit && pages < SESSION_MCP_HISTORY_MAX_PAGES) {
+    const remaining = Math.max(1, limit - events.length);
+    const pageLimit = Math.max(
+      remaining,
+      Math.min(MAX_TOOL_LIMIT, SESSION_MCP_HISTORY_MIN_RAW_PAGE_LIMIT),
+    );
+    const result = cursor
+      ? await pollSessionEventsFn(sessionId, {
+          targetPath,
+          since: pageCursor,
+          limit: pageLimit,
+          forceCircuitProbe,
+        })
+      : await pollSessionEventsBeforeFn(sessionId, {
+          targetPath,
+          beforeSequence: pageBeforeSequence,
+          limit: pageLimit,
+          forceCircuitProbe,
+        });
+    if (!result?.ok) {
+      if (pages > 0) break;
+      return {
+        ok: false,
+        reason: result?.reason || "read_history_failed",
+        source,
+        cursor: responseCursor,
+        beforeSequence: responseBeforeSequence,
+        events: [],
+        eventCount: 0,
+        pages,
+      };
+    }
+
+    pages += 1;
+    const rawEvents = Array.isArray(result.events) ? result.events : [];
+    rawEventCount += rawEvents.length;
+    const materialEvents = normalizeHistoryEvents(rawEvents, { includeControlEvents });
+    if (cursor) {
+      events.push(...materialEvents);
+      const nextCursor = normalizeString(result.cursor) || pageCursor;
+      responseCursor = nextCursor || responseCursor;
+      if (!rawEvents.length || !nextCursor || nextCursor === pageCursor) break;
+      pageCursor = nextCursor;
+      continue;
+    }
+
+    events = [...materialEvents, ...events];
+    if (pages === 1) {
+      responseCursor = normalizeString(result.cursor) || responseCursor;
+    }
+    const nextBeforeSequence = normalizePositiveInteger(result.beforeSequence || result.before_sequence, null);
+    responseBeforeSequence = nextBeforeSequence;
+    if (!rawEvents.length || !nextBeforeSequence || nextBeforeSequence === pageBeforeSequence) break;
+    pageBeforeSequence = nextBeforeSequence;
+  }
+
+  const windowEvents = cursor ? events.slice(0, limit) : events.slice(-limit);
+  const firstWindowEvent = windowEvents[0] || null;
+  const lastWindowEvent = windowEvents[windowEvents.length - 1] || null;
+  const windowCursor = normalizeString(lastWindowEvent?.cursor);
+  const windowBeforeSequence = normalizePositiveInteger(
+    firstWindowEvent?.sequenceId ?? firstWindowEvent?.sequence_id,
+    null,
+  );
+
+  return {
+    ok: true,
+    reason: "",
+    source,
+    cursor: windowCursor || responseCursor,
+    beforeSequence: cursor ? null : windowBeforeSequence || responseBeforeSequence,
+    events: windowEvents,
+    eventCount: rawEventCount,
+    pages,
+  };
+}
+
 function requireSessionId(input = {}) {
   const sessionId = normalizeString(input.sessionId || input.session_id || input.session);
   if (!sessionId) {
@@ -807,6 +913,83 @@ export function createSessionMcpToolHandlers({
       };
     },
 
+    async read_history(input = {}) {
+      const sessionId = requireSessionId(input);
+      const cursor = normalizeString(input.cursor || input.after || input.since) || null;
+      const beforeSequence = normalizeOptionalPositiveInteger(
+        input.beforeSequence || input.before_sequence,
+        "beforeSequence",
+      );
+      if (cursor && beforeSequence) {
+        throw new Error("Use either cursor/after/since or beforeSequence, not both.");
+      }
+      const limit = normalizeLimit(input.limit || input.tail || input.maxEvents || input.max_events);
+      const actionLimit = normalizeLimit(input.actionLimit || input.action_limit || limit);
+      const includeActions = input.includeActions !== false && input.include_actions !== false;
+      const includeControlEvents = Boolean(input.includeControlEvents || input.include_control_events);
+      const includeRaw = Boolean(input.includeRaw || input.include_raw);
+      const forceCircuitProbe = input.forceCircuitProbe !== false && input.force_circuit_probe !== false;
+
+      const result = await readSessionHistoryWindow({
+        sessionId,
+        targetPath,
+        cursor,
+        beforeSequence,
+        limit,
+        includeControlEvents,
+        forceCircuitProbe,
+        pollSessionEventsFn,
+        pollSessionEventsBeforeFn,
+      });
+      if (!result?.ok) {
+        return {
+          ok: false,
+          reason: result?.reason || "read_history_failed",
+          sessionId,
+          source: result?.source || (cursor ? "after_cursor" : beforeSequence ? "before_sequence" : "latest_tail"),
+          cursor,
+          beforeSequence: beforeSequence || null,
+          events: [],
+          eventCount: 0,
+          materialEventCount: 0,
+        };
+      }
+
+      const events = Array.isArray(result.events) ? result.events : [];
+      const actionResult = includeActions
+        ? await listSessionMessageActionsFn(sessionId, {
+            targetPath,
+            limit: actionLimit,
+            forceCircuitProbe,
+          })
+        : null;
+      const recentHumanActivity = actionResult?.ok
+        ? recentHumanActivityFromActions(actionResult, { limit: actionLimit })
+        : [];
+
+      return {
+        ok: true,
+        reason: "",
+        sessionId,
+        source: result.source,
+        cursor: normalizeString(result.cursor) || cursor,
+        beforeSequence: normalizePositiveInteger(result.beforeSequence || result.before_sequence, null),
+        eventCount: normalizePositiveInteger(result.eventCount, 0),
+        materialEventCount: events.length,
+        pageCount: normalizePositiveInteger(result.pages, 0),
+        recentHumanActivityCount: recentHumanActivity.length,
+        recentHumanActivity,
+        actionProjection: actionResult
+          ? {
+              ok: Boolean(actionResult.ok),
+              reason: actionResult.reason || "",
+              count: Array.isArray(actionResult.actions) ? actionResult.actions.length : 0,
+            }
+          : null,
+        events: includeRaw ? events : events.map((event) => summarizeSessionEvent(event)),
+      };
+    },
+
     async send_message(input = {}) {
       const sessionId = requireSessionId(input);
       const agentId = requireAgentId(input);
@@ -1013,6 +1196,27 @@ export const SESSION_MCP_TOOLS = Object.freeze([
       },
     },
   },
+  {
+    name: "read_history",
+    title: "Read Senti History",
+    description:
+      "Hydrate a bounded recent, older, or after-cursor session transcript window without recipient filtering.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["sessionId"],
+      properties: {
+        sessionId: { type: "string", minLength: 1 },
+        cursor: { type: "string" },
+        beforeSequence: { type: "integer", minimum: 1 },
+        limit: { type: "integer", minimum: 1, maximum: MAX_TOOL_LIMIT, default: DEFAULT_TOOL_LIMIT },
+        actionLimit: { type: "integer", minimum: 1, maximum: MAX_TOOL_LIMIT, default: DEFAULT_TOOL_LIMIT },
+        includeActions: { type: "boolean", default: true },
+        includeControlEvents: { type: "boolean", default: false },
+        includeRaw: { type: "boolean", default: false },
+      },
+    },
+  },
   {
     name: "send_message",
     title: "Send Senti Message",
@@ -1285,7 +1489,7 @@ export async function handleMcpJsonRpcMessage(
         version: "0.20.0",
       },
       instructions:
-        "Use native Senti tools for coordination actions and generated sl.* bridge tools for the rest of SentinelLayer CLI. Poll first with poll_inbox, use session_action/session_react/session_reply/session_lock/session_unlock/session_locks for low-noise session work, use send_message for durable posts, and use generated command tools such as sl.auth.status or sl.review.scan for ordinary CLI commands.",
+        "Use native Senti tools for coordination actions and generated sl.* bridge tools for the rest of SentinelLayer CLI. Use poll_inbox for addressed wake-style delivery, read_history for recent/older transcript grounding, session_action/session_react/session_reply/session_lock/session_unlock/session_locks for low-noise session work, send_message for durable posts, and generated command tools such as sl.auth.status or sl.review.scan for ordinary CLI commands.",
     });
   }
 

package/src/scan/generator.js

@@ -227,16 +227,20 @@ export function buildSecurityReviewWorkflow({ secretName = DEFAULT_SCAN_SECRET_N
             with: {
               github_token: "${{ github.token }}",
               openai_api_key: "${{ secrets.OPENAI_API_KEY }}",
-              google_api_key: "${{ secrets.GOOGLE_API_KEY }}",
-              llm_provider: "${{ secrets.GOOGLE_API_KEY != '' && 'google' || 'openai' }}",
+              google_api_key:
+                "${{ secrets.GOOGLE_GEMINI_API_KEY != '' && secrets.GOOGLE_GEMINI_API_KEY || secrets.GOOGLE_API_KEY }}",
+              llm_provider:
+                "${{ (secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '') && 'google' || 'openai' }}",
               sentinelayer_token: `\${{ secrets.${normalizedSecret} }}`,
-              sentinelayer_managed_llm: `\${{ secrets.GOOGLE_API_KEY == '' && secrets.OPENAI_API_KEY == '' && secrets.${normalizedSecret} != '' }}`,
+              sentinelayer_managed_llm: `\${{ secrets.GOOGLE_GEMINI_API_KEY == '' && secrets.GOOGLE_API_KEY == '' && secrets.OPENAI_API_KEY == '' && secrets.${normalizedSecret} != '' }}`,
               scan_mode: profile.scanMode || "deep",
               severity_gate: profile.severityGate || "P1",
-              model: "${{ secrets.GOOGLE_API_KEY != '' && 'gemini-2.5-pro' || 'gpt-5.3-codex' }}",
+              model:
+                "${{ (secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '') && 'gemini-3.1-flash-lite' || 'gpt-5.3-codex' }}",
               codex_model: "gpt-5.3-codex",
-              model_fallback: "${{ secrets.GOOGLE_API_KEY != '' && 'gemini-2.5-flash' || 'gpt-4.1-mini' }}",
-              use_codex: "${{ secrets.GOOGLE_API_KEY == '' }}",
+              model_fallback:
+                "${{ (secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '') && 'gemini-3.1-flash-lite' || 'gpt-4.1-mini' }}",
+              use_codex: "${{ secrets.GOOGLE_GEMINI_API_KEY == '' && secrets.GOOGLE_API_KEY == '' }}",
               codex_only: "false",
               llm_failure_policy: "block",
               max_daily_scans: "${{ vars.OMAR_MAX_DAILY_SCANS || '200' }}",
@@ -295,11 +299,15 @@ export function buildSecurityReviewWorkflow({ secretName = DEFAULT_SCAN_SECRET_N
               OMAR_SEVERITY_GATE: "${{ github.event_name == 'workflow_dispatch' && inputs.severity_gate || 'P1' }}",
               OMAR_P2_MAX_ALLOWED: "${{ github.event_name == 'workflow_dispatch' && inputs.p2_max_allowed || '5' }}",
               OMAR_OPENAI_KEY_PRESENT: "${{ secrets.OPENAI_API_KEY != '' }}",
-              OMAR_GOOGLE_KEY_PRESENT: "${{ secrets.GOOGLE_API_KEY != '' }}",
-              OMAR_MANAGED_LLM: `\${{ secrets.GOOGLE_API_KEY == '' && secrets.OPENAI_API_KEY == '' && secrets.${normalizedSecret} != '' }}`,
-              OMAR_LLM_PROVIDER: "${{ secrets.GOOGLE_API_KEY != '' && 'google' || 'openai' }}",
-              OMAR_MODEL: "${{ secrets.GOOGLE_API_KEY != '' && 'gemini-2.5-pro' || 'gpt-5.3-codex' }}",
-              OMAR_MODEL_FALLBACK: "${{ secrets.GOOGLE_API_KEY != '' && 'gemini-2.5-flash' || 'gpt-4.1-mini' }}",
+              OMAR_GOOGLE_KEY_PRESENT:
+                "${{ secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '' }}",
+              OMAR_MANAGED_LLM: `\${{ secrets.GOOGLE_GEMINI_API_KEY == '' && secrets.GOOGLE_API_KEY == '' && secrets.OPENAI_API_KEY == '' && secrets.${normalizedSecret} != '' }}`,
+              OMAR_LLM_PROVIDER:
+                "${{ (secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '') && 'google' || 'openai' }}",
+              OMAR_MODEL:
+                "${{ (secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '') && 'gemini-3.1-flash-lite' || 'gpt-5.3-codex' }}",
+              OMAR_MODEL_FALLBACK:
+                "${{ (secrets.GOOGLE_GEMINI_API_KEY != '' || secrets.GOOGLE_API_KEY != '') && 'gemini-3.1-flash-lite' || 'gpt-4.1-mini' }}",
             },
             run: [
               "set -euo pipefail",

package/src/session/coordination-guidance.js

@@ -5,7 +5,7 @@ export const COORDINATION_ETIQUETTE_ITEMS = Object.freeze([
   "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 a 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` 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.",
+  "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.",
   "Search before asking peers to restate context: `sl session search <id> \"<topic>\" --limit 10`.",

package/src/session/first-message.js

@@ -38,7 +38,7 @@ export function buildFirstSentiMessage({ sessionId } = {}) {
     `7) sl session reply ${sid} <THIS_SEQ> "ACK <AGENT_ID> role=<role> model=<model> locks=none first_action=<one concrete action>" --agent <AGENT_ID>`,
     "",
     "STAY REACHABLE — two honest paths, use YOURS (always pass --agent <AGENT_ID> so the room knows who's listening):",
-    `- Persistent process (Codex/GPT): keep ONE listener alive + a 60s watchdog that restarts it if the pid dies (cursor catch-up replays anything missed):`,
+    `- Persistent process (Codex/GPT): keep ONE listener alive. Re-running listen refuses a duplicate local pid by default; use --force only to stop and replace an existing local owner and --allow-duplicate only for intentional parallel wake hooks. Pair it with a 60s watchdog that restarts it if the pid dies (cursor catch-up replays anything missed):`,
     `  sl session listen --session ${sid} --agent <AGENT_ID> --active-interval 30 --active-window 300 --interval 60 --presence-interval 60 --model <MODEL> --display-name <AGENT_ID>`,
     `- No socket (Claude Code): you are NOT continuously connected — you re-arm a wake each turn. 30-270s while actively waiting, 20-30min idle when quiet. Treat time-critical things as POSTED messages you catch next tick, never assumed instant.`,
     `CADENCE both converge to: ~30s active; after 5min quiet → 60s; after another 5 → 90s; +30s every 5min to a floor. Wake IMMEDIATELY on: new human/ORCH msg, a direct reply/@mention, a lock conflict, a deploy/gate notice.`,