sentinelayer-cli 0.30.12 → 0.30.14

package/README.md

@@ -658,14 +658,19 @@ The CLI now includes deterministic MCP registry commands:
 - `sl mcp schema write`
 - `sl mcp registry init-aidenid`
 - `sl mcp registry init-aidenid-adapter`
+- `sl mcp registry init-session`
+- `sl mcp registry init-cli`
 - `sl mcp registry validate --file <path>`
 - `sl mcp registry validate-aidenid-adapter --file <path> [--registry-file <path>]`
 - `sl mcp server init --id <server-id> --registry-file <path>`
 - `sl mcp server validate --file <path>`
+- `sl mcp server run --path .`
 - `sl mcp bridge init-vscode --server-id <server-id> --server-config <path>`
 
 Use `init-aidenid` to scaffold an Anthropic-compatible tool schema wrapper for AIdenID provisioning APIs, then customize transport/auth before runtime wiring.
 Use `init-aidenid-adapter` to scaffold a deterministic AIdenID provisioning API contract (tool binding -> HTTP path/method -> response field mapping) and cross-check it against the registry with `validate-aidenid-adapter`.
+Use `init-session` plus `server run` for the local stdio Senti MCP server. It exposes session inbox, durable posts, actions/replies/reactions, file locks, and attention requests to local MCP clients. Hosted Claude-web/ChatGPT connectors need a separate HTTPS/OAuth service and are not shipped by the local stdio server. See [docs/mcp.md](docs/mcp.md).
+Use `init-cli` to generate a bridge registry for every `sl` leaf command from Commander metadata. This exposes the full CLI surface as `sl.<command.path>` tool schemas, but execution still requires a bridge-capable MCP host with OAuth/session-seat policy and human approval enforcement. The hosted connector target contract is documented in [docs/mcp-hosted-connector.md](docs/mcp-hosted-connector.md).
 
 ## Plugin governance foundation (Phase 5.2 slice)
 

package/package.json

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

package/src/commands/mcp.js

@@ -24,6 +24,7 @@ import {
   validateMcpToolRegistry,
   writeJsonFile,
 } from "../mcp/registry.js";
+import { buildSentinelayerCliRegistryTemplate } from "../mcp/cli-registry.js";
 import { runMcpStdioServer } from "../mcp/session-stdio-server.js";
 import { resolveOutputRoot } from "../config/service.js";
 
@@ -254,6 +255,39 @@ export function registerMcpCommand(program) {
       console.log(pc.gray("Next: run 'sl mcp server init --id sentinelayer-session --registry-file <path>'."));
     });
 
+  registry
+    .command("init-cli")
+    .description("Write a generated MCP registry for every SentinelLayer CLI leaf command")
+    .option("--path <path>", "Destination file path override")
+    .option("--output-dir <path>", "Optional artifact output root override")
+    .option("--force", "Overwrite destination file if it already exists")
+    .option("--json", "Emit machine-readable output")
+    .action(async (options, command) => {
+      const defaultPath = await resolveDefaultMcpOutputPath({
+        cwd: process.cwd(),
+        outputDir: options.outputDir,
+        env: process.env,
+      });
+      const outputPath = normalizeOutputPath(options.path, defaultPath.replace(".schema", ".cli-tools"));
+      const template = await buildSentinelayerCliRegistryTemplate();
+      validateMcpToolRegistry(template);
+      const writtenPath = await writeJsonFile(outputPath, template, { force: Boolean(options.force) });
+      const payload = {
+        command: "mcp registry init-cli",
+        outputPath: writtenPath,
+        toolCount: template.tools.length,
+        tools: template.tools.map((tool) => tool.name),
+      };
+
+      if (shouldEmitJson(options, command)) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+      }
+      console.log(pc.green(`Wrote SentinelLayer CLI MCP registry template: ${writtenPath}`));
+      console.log(pc.gray(`${template.tools.length} CLI leaf commands exposed as bridge tools.`));
+      console.log(pc.gray("Execution requires a bridge-capable MCP host; local stdio run still exposes session tools."));
+    });
+
   registry
     .command("validate")
     .description("Validate an MCP tool registry JSON payload against Sentinelayer contract")

package/src/commands/session.js

@@ -101,6 +101,11 @@ import { hydrateSessionFromRemote } from "../session/remote-hydrate.js";
 import { mergeLiveSources } from "../session/live-source.js";
 import { listenSessionEvents } from "../session/listener.js";
 import { SESSION_LIVE_SUCCESS_TIPS } from "../session/coordination-guidance.js";
+import {
+  DEFAULT_ROTATING_LOG_MAX_BYTES,
+  DEFAULT_ROTATING_LOG_MAX_FILES,
+  installRotatingConsoleLog,
+} from "../session/rotating-log.js";
 import { buildSessionRecap } from "../session/recap.js";
 import { computeTranscriptStats } from "../session/transcript.js";
 import { deriveSessionTitle } from "../session/senti-naming.js";
@@ -1811,7 +1816,10 @@ export function shouldPublishListenerPresenceHeartbeat({
   if (elapsedMs >= keepaliveMs) {
     return { publish: true, fingerprint, reason: "keepalive" };
   }
-  return { publish: false, fingerprint, reason: elapsedMs < minIntervalMs ? "interval" : "unchanged" };
+  if (elapsedMs >= minIntervalMs) {
+    return { publish: true, fingerprint, reason: "interval" };
+  }
+  return { publish: false, fingerprint, reason: "interval" };
 }
 
 async function publishListenerPresenceEvent({
@@ -4475,6 +4483,17 @@ export function registerSessionCommand(program) {
       "900",
     )
     .option("--no-coaching", "Do not emit periodic in-session success reminders")
+    .option("--log-file <path>", "Also write listener output to a bounded rotating log file")
+    .option(
+      "--log-max-bytes <bytes>",
+      `Rotate --log-file after this many bytes (default ${DEFAULT_ROTATING_LOG_MAX_BYTES})`,
+      String(DEFAULT_ROTATING_LOG_MAX_BYTES),
+    )
+    .option(
+      "--log-max-files <n>",
+      `Total log files to retain including the active file (default ${DEFAULT_ROTATING_LOG_MAX_FILES})`,
+      String(DEFAULT_ROTATING_LOG_MAX_FILES),
+    )
     .action(async (options) => {
       const normalizedSessionId = resolveSessionIdOption(options);
       const targetPath = path.resolve(process.cwd(), String(options.path || "."));
@@ -4511,6 +4530,9 @@ export function registerSessionCommand(program) {
       if (!["ndjson", "text"].includes(emitFormat)) {
         throw new Error("--emit must be one of: ndjson, text.");
       }
+      const listenLogPath = normalizeString(options.logFile)
+        ? path.resolve(targetPath, String(options.logFile))
+        : "";
       // Optional wake hook: run a host command on each matched event so the
       // host can resume/wake its agent (the notify->resume bridge).
       const emitWakeNotice = (payload = {}) => {
@@ -4571,6 +4593,14 @@ 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 ac = new AbortController();
       const onSigint = () => ac.abort();
       process.on("SIGINT", onSigint);
@@ -4802,6 +4832,9 @@ export function registerSessionCommand(program) {
         if (coachingTimer) {
           clearInterval(coachingTimer);
         }
+        if (restoreConsoleLog) {
+          restoreConsoleLog();
+        }
         process.removeListener("SIGINT", onSigint);
       }
     });
@@ -4826,6 +4859,17 @@ export function registerSessionCommand(program) {
     .option("--checkpoint-idle <seconds>", "Seconds after latest source event before idle checkpoint attempt (default 600)", "600")
     .option("--no-checkpoints", "Disable durable checkpoint generation")
     .option("--no-checkpoint-closeout", "Skip the final closeout checkpoint when the daemon stops")
+    .option("--log-file <path>", "Also write daemon output to a bounded rotating log file")
+    .option(
+      "--log-max-bytes <bytes>",
+      `Rotate --log-file after this many bytes (default ${DEFAULT_ROTATING_LOG_MAX_BYTES})`,
+      String(DEFAULT_ROTATING_LOG_MAX_BYTES),
+    )
+    .option(
+      "--log-max-files <n>",
+      `Total log files to retain including the active file (default ${DEFAULT_ROTATING_LOG_MAX_FILES})`,
+      String(DEFAULT_ROTATING_LOG_MAX_FILES),
+    )
     .option("--once", "Run one Senti health tick and exit (CI/dogfood smoke)")
     .option("--json", "Emit machine-readable output")
     .action(async (sessionId, options, command) => {
@@ -4840,6 +4884,18 @@ export function registerSessionCommand(program) {
         "tick-interval",
         30,
       );
+      const daemonLogPath = normalizeString(options.logFile)
+        ? path.resolve(targetPath, String(options.logFile))
+        : "";
+      const restoreConsoleLog = daemonLogPath
+        ? installRotatingConsoleLog({
+            logPath: daemonLogPath,
+            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;
+      try {
       // One manager per session: refuse to double-run unless --force.
       // A stale pid file (reboot, hard kill) reads as not-running and is
       // safely overwritten.
@@ -4883,26 +4939,32 @@ export function registerSessionCommand(program) {
       };
 
       if (options.once) {
-        const payload = await runTickAndBuildPayload();
-        const stopped = await daemon.stop("once_complete");
-        payload.running = false;
-        payload.stopped = {
-          stopped: Boolean(stopped?.stopped),
-          reason: stopped?.reason || "once_complete",
-          checkpointCloseout: stopped?.checkpointCloseout || null,
-        };
-        if (emitJson) {
-          console.log(JSON.stringify(payload, null, 2));
+        try {
+          const payload = await runTickAndBuildPayload();
+          const stopped = await daemon.stop("once_complete");
+          payload.running = false;
+          payload.stopped = {
+            stopped: Boolean(stopped?.stopped),
+            reason: stopped?.reason || "once_complete",
+            checkpointCloseout: stopped?.checkpointCloseout || null,
+          };
+          if (emitJson) {
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+          }
+          const checkpoint = payload.summary?.checkpoint || {};
+          const recap = payload.summary?.recap || {};
+          console.log(
+            pc.green(
+              `senti tick: relayed=${Number(payload.summary?.humanMessages?.relayed || 0)} recap=${recap.emitted ? recap.mode || "emitted" : recap.reason || "none"} checkpoint=${checkpoint.created ? checkpoint.checkpointId || "created" : checkpoint.reason || "none"}`,
+            ),
+          );
           return;
+        } finally {
+          if (restoreConsoleLog) {
+            restoreConsoleLog();
+          }
         }
-        const checkpoint = payload.summary?.checkpoint || {};
-        const recap = payload.summary?.recap || {};
-        console.log(
-          pc.green(
-            `senti tick: relayed=${Number(payload.summary?.humanMessages?.relayed || 0)} recap=${recap.emitted ? recap.mode || "emitted" : recap.reason || "none"} checkpoint=${checkpoint.created ? checkpoint.checkpointId || "created" : checkpoint.reason || "none"}`,
-          ),
-        );
-        return;
       }
 
       const controller = new AbortController();
@@ -4992,6 +5054,14 @@ export function registerSessionCommand(program) {
         } else {
           console.log(pc.gray(`senti daemon stopped (${stopped?.reason || "signal"}).`));
         }
+        if (restoreConsoleLog) {
+          restoreConsoleLog();
+        }
+      }
+      } finally {
+        if (restoreConsoleLog) {
+          restoreConsoleLog();
+        }
       }
     });