session-steward 0.10.3 → 0.11.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.11.1] - 2026-09-14
+
+### Added
+
+- Added Official MCP Registry metadata and a package-name MCP launch command for registry clients.
+
+## [0.11.0] - 2026-09-14
+
+### Added
+
+- Sessions and workspaces can be marked Keep so manual and scheduled Session Steward cleanup skip them without indexing transcripts or changing provider data.
+
 ## [0.10.3] - 2026-09-10
 
 ### Fixed
@@ -162,6 +174,8 @@
 - Support for custom Codex home folders and a saved folder preference.
 - Streaming and bounded-memory discovery for large session collections and transcripts.
 
+[0.11.1]: https://github.com/mallikcheripally/session-steward/compare/v0.11.0...v0.11.1
+[0.11.0]: https://github.com/mallikcheripally/session-steward/compare/v0.10.3...v0.11.0
 [0.10.3]: https://github.com/mallikcheripally/session-steward/compare/v0.10.2...v0.10.3
 [0.10.2]: https://github.com/mallikcheripally/session-steward/compare/v0.10.1...v0.10.2
 [0.10.1]: https://github.com/mallikcheripally/session-steward/compare/v0.10.0...v0.10.1

package/README.md

@@ -4,339 +4,210 @@
 [![Build status](https://img.shields.io/github/actions/workflow/status/mallikcheripally/session-steward/validate.yml?branch=main&style=flat-square&label=build)](https://github.com/mallikcheripally/session-steward/actions/workflows/validate.yml)
 [![License: MIT](https://img.shields.io/npm/l/session-steward?style=flat-square)](https://github.com/mallikcheripally/session-steward/blob/main/LICENSE)
 
-A local Codex and Claude Code session manager for safely reviewing, backing up, and deleting old sessions from a browser UI or terminal CLI, or through MCP with ChatGPT or Claude.
+Session Steward is a local session manager for Codex and Claude Code. It helps you find old or large sessions across workspaces, decide what is worth keeping, and clean up the related records it recognizes. You can use it with browser UI or terminal CLI, or through MCP with ChatGPT or Claude.
 
-AI coding tools can accumulate hundreds or thousands of local sessions. A session may leave behind transcripts, history, logs, checkpoints, and linked artifacts, so manual cleanup can easily miss related data.
+Codex can delete a session, and Claude Code can purge a project. Built-in deletion works when you already know what should go. Session Steward helps when the hard part is reviewing many sessions across both tools.
 
-Session Steward makes session cleanup safer by finding those records, showing what cleanup will affect, creating a local backup, removing supported data, and verifying the result afterward. Session Steward runs locally.
+- Find inactive or large sessions across workspaces. Switch between Codex and Claude Code, then filter by archive status, name, or session ID.
+- Open a session before deciding. See a distilled timeline of recent messages, file changes, commands, and command results, plus recognized storage and token use.
+- Clean selected sessions using a plan you review first, with a local backup, verification afterward, and recovery when cleanup needs attention.
 
-![Session Steward cleanup demo](https://raw.githubusercontent.com/mallikcheripally/session-steward/main/docs/session-steward-demo.gif)
-
-## Manage local Codex and Claude Code sessions
-
-- Review and clean up sessions from the browser, terminal, ChatGPT, or Claude through MCP.
-- Switch between Codex and Claude Code without installing another package.
-- See session counts and the storage used by recognized session files.
-- Find sessions inactive for 30, 60, or 90 days.
-- Filter active or archived sessions by workspace, name, or session ID.
-- Inspect session details and affected records before deletion.
-- Read a session timeline of what you asked, what changed, and which commands ran.
-- See how many tokens a session used, split into fresh input, cached input, cache writes, and output.
-- Choose standard or thorough cleanup.
-- Use custom Codex or Claude home folders across browser and terminal sessions.
-
-## Safe by default
-
-- Cleanup happens entirely on your computer.
-- Only records included in the reviewed cleanup plan are removed.
-- A local recovery backup is created before anything changes.
-- Cleanup is verified before the backup is removed.
-- Unrecognized storage is reported and left untouched.
-- Thorough cleanup is unavailable when the detected storage format is not supported.
-- Cleanup stays local and does not upload session contents.
-
-At startup, Session Steward may contact the public npm registry to check for a newer version.
-
-### Session Steward does not remove
-
-- Sign-in data or saved API credentials
-- Configuration, plugins, caches, or custom prompt files
-- Project files, Git repositories, or worktrees
-- Sessions outside the reviewed cleanup plan
-- Conversations stored in your ChatGPT or Claude account
-- Claude Code worktrees, branches, repositories, remote sessions, SSH sessions, or Cowork data
-
-## Install and get started
+## Try Session Steward locally
 
-Session Steward supports macOS, Linux, and Windows and requires Node.js 24.15 or newer.
+Try the browser app for one run without installing it globally:
 
-Install it globally:
+Session Steward requires Node.js 24.15 or newer.
 
 ```bash
-npm install --global session-steward
+npx session-steward@latest
 ```
 
-Then launch it:
+The browser app listens only on `127.0.0.1` and does not upload session contents.
 
-```bash
-session-steward
-```
+![Session Steward cleanup demo](https://raw.githubusercontent.com/mallikcheripally/session-steward/main/docs/session-steward-demo.gif)
 
-Or try it without installing:
+For ongoing use, install it globally:
 
 ```bash
-npx session-steward@latest
+npm install --global session-steward
 ```
 
-Session Steward opens in your browser, listens only on `127.0.0.1`, and detects `~/.codex` and `~/.claude` by default. Claude Code CLI and local Claude Desktop sessions are detected on macOS and Windows; the Claude Code CLI is also supported on Linux. On Windows, these resolve to `%USERPROFILE%\.codex` and `%USERPROFILE%\.claude`.
-
-When run inside WSL, Session Steward uses the Linux home folder and manages sessions stored there. Run it from Windows to manage sessions in your Windows profile.
-
-To clean up sessions:
-
-1. Review the detected sessions.
-2. Select one or more sessions.
-3. Choose a cleanup option.
-4. Review exactly what will be removed.
-5. Close any selected sessions that may still be active.
-6. Confirm the cleanup.
+The global install provides four commands:
 
-Keep the terminal open while using Session Steward. Press `Ctrl+C` to stop it.
+| Command | Use it for |
+| --- | --- |
+| `session-steward` | Browser interface |
+| `session-steward-cli` | Interactive terminal and JSON output |
+| `session-steward-mcp` | MCP session management |
+| `session-steward-scheduler` | Automatic session cleanup |
 
-## Cleanup and recovery
+Session Steward supports macOS, Linux, and Windows. Run `session-steward` to open the browser interface. Leave its terminal open while you use it; press `Ctrl+C` to stop it.
 
-### Standard cleanup
+## Find old and large Codex and Claude Code sessions
 
-Recommended for routine removal. It removes supported transcripts, history, registry entries, logs, and linked session artifacts belonging to the selected sessions.
+Session Steward reads the local session folders already used by Codex and Claude Code. It looks for `~/.codex` and `~/.claude` by default and lets you switch providers from the same interface.
 
-### Thorough cleanup
+You can:
 
-Includes standard cleanup and removes additional recognized session-owned data. For Codex this can include supported Desktop references, memory outputs, and goal records. For Claude Code this includes recognized file checkpoints.
+- filter by inactivity, exact workspace, active or archived status, name, or session ID;
+- see recognized session-owned storage by session and workspace, then sort by size;
+- browse session timeline of recent messages, file changes, commands, and command results;
+- inspect fresh input, cached input, cache writes, output, and recorded reasoning tokens;
+- mark a session or workspace **Keep** so manual and scheduled cleanup skip it.
 
-Thorough cleanup is unavailable when Session Steward finds storage it does not recognize. Standard cleanup remains available for supported records that can be identified safely.
+A workspace Keep covers that folder, its descendants, and future sessions there. Keep affects Session Steward cleanup only. Codex or Claude Code can still remove their own data.
 
-### Recovery backups
+## Why not just delete sessions one at a time?
 
-A temporary backup is created inside the active provider folder under `session-steward-backups/`.
+The native delete commands are useful when you already know what should go. They do not cover the same cross-workspace review and cleanup job.
 
-After cleanup is successfully verified, the backup is removed automatically. If cleanup fails, Session Steward keeps the backup and lets you restore the sessions, keep the backup, or delete it.
+A session can have more than its transcript. Depending on the provider and storage version, it may also have history or registry entries, logs, checkpoints, and other linked records. Removing a JSONL file by hand can leave those records behind.
 
-Before restoring, the current versions of affected files are saved separately to provide another recovery point.
+Session Steward starts from the session instead of a file path. It finds supported related records, shows them in one cleanup plan, and leaves storage it does not recognize alone. You can review several candidates together without treating every old session as safe to delete.
 
-## Terminal CLI
+## Use the browser, CLI, or MCP
 
-Start the interactive terminal interface:
+### Browser
 
-```bash
-session-steward-cli
-```
-
-Use Claude Code instead of Codex:
+Run:
 
 ```bash
-session-steward-cli --provider claude-code
+session-steward
 ```
 
-List sessions as JSON:
+Choose Codex or Claude Code, filter or search the list, and open sessions you are unsure about. When you select sessions for cleanup, the browser shows the affected records before asking for confirmation.
 
-```bash
-session-steward-cli --json --limit 10
-```
+Use `session-steward --no-open` to start without opening a browser automatically. Open the local address printed in the terminal.
 
-<details>
-<summary>More terminal options</summary>
+### Terminal CLI
 
-Show session and workspace storage totals:
+Start the interactive terminal:
 
 ```bash
-session-steward-cli --overview
+session-steward-cli
 ```
 
-Add `--json` when the output will be read by another tool.
-
-Find sessions inactive for at least 60 days:
+Use Claude Code instead of Codex, or return a limited JSON result for another tool:
 
 ```bash
-session-steward-cli --inactive-days 60
+session-steward-cli --provider claude-code
+session-steward-cli --json --limit 10
 ```
 
-Show only archived sessions:
+Filter with options such as `--inactive-days 60`, `--archive-status archived`, or `--workspace /path/to/project`. Use `--events` for the timeline, `--tokens` for token use, and `--sort size` for the largest sessions first. Run `session-steward-cli --help` for every option.
 
-```bash
-session-steward-cli --archive-status archived
-```
+### MCP with ChatGPT, Codex, or Claude Code
 
-Show sessions from one exact workspace:
+Connect the local MCP server once:
 
 ```bash
-session-steward-cli --workspace /path/to/project
+codex mcp add session-steward -- session-steward-mcp
 ```
 
-Use `--include-internals` to include subagents and `--include-supporting` to include supporting sessions. Session sizes are shown in the interactive list, and `--sort size` places the largest sessions first.
-
-Start with `--events` to read what happened inside a session — what you asked, what the assistant concluded, which files changed, and which commands ran or failed. In the interactive list, `inspect <number>` then shows that session's timeline:
+Or connect it to Claude Code:
 
 ```bash
-session-steward-cli --events --events-limit 50
+claude mcp add --scope user session-steward -- session-steward-mcp
 ```
 
-With `--json`, each session carries its own `events`, plus a `coverage` summary of how much of the transcript was recognized:
-
-```bash
-session-steward-cli --json --limit 5 --events
-```
+Registry installers can start the same server without a global install using `npx session-steward@latest mcp`.
 
-Use `--tokens` to count what a session spent. The total is split into fresh input, cached input, cache writes, and output, with reasoning reported as a share of output where the provider records it:
+You can then ask your client to find inactive sessions, compare recognized session storage between Codex and Claude Code, inspect a session, keep a workspace, clean exact sessions, restore a backup, or manage a cleanup schedule.
 
-```bash
-session-steward-cli --tokens
-```
+Session Steward marks cleanup, restore, and schedule management as destructive MCP actions so the client can apply its configured approval policy.
 
-In the interactive list, `tokens` toggles the same breakdown into `inspect`. With `--json`, each session carries a `tokens` object:
+Scheduled cleanup continues in the background after you close the client. You can ask to pause, resume, run, change, or remove a schedule. Before uninstalling Session Steward, stop scheduled cleanup:
 
 ```bash
-session-steward-cli --json --limit 5 --tokens
-```
-
-Cached input usually dominates, because the whole conversation is re-sent on every turn. A forked session reports its own work separately from the tokens it inherited from the session it branched from, so the two are never added together.
-
-The interactive terminal accepts the same filters:
-
-```text
-inactive 30
-inactive 60
-inactive 90
-archive active
-archive archived
-workspace /path/to/project
-internals
-supporting
-tokens
-cleanup standard
-cleanup thorough
-overview
-backups
+session-steward-scheduler --stop
 ```
 
-Run `inactive`, `archive`, or `workspace` without a value to clear that filter.
-
-`backups` lists recovery backups retained after an interrupted or unsuccessful cleanup. Use `restore <number>` to restore one, or `delete-backup <number>` to remove it permanently. Both actions require an explicit confirmation.
-
-</details>
-
-Use `session-steward-cli --help` to see all available options.
-
-## Clean up sessions with ChatGPT or Claude
-
-Connect Session Steward once, then ask ChatGPT or Claude to find old or large
-sessions, delete them safely, restore a backup, or clean sessions automatically
-on a schedule.
+For another MCP client, configure a local stdio server named `session-steward` with the command `session-steward-mcp`.
 
-Connect it to ChatGPT and Codex:
+The MCP process uses Session Steward's saved provider folders or the defaults when none are saved. Its server command can set startup folders with `--codex-home` or `--claude-home`, and its `manage_settings` tool can change the saved folders. A one-time browser or CLI override does not carry into a later MCP process.
 
-```bash
-codex mcp add session-steward -- session-steward-mcp
-```
+The MCP server runs locally, but session details can contain messages, commands, file names, and workspace paths. Your MCP client may send that information to its AI provider.
 
-Connect it to Claude Code:
+## Review what will be deleted first
 
-```bash
-claude mcp add --scope user session-steward -- session-steward-mcp
-```
+For a manual cleanup:
 
-You can then ask things like:
+1. Select the sessions.
+2. Close any selected sessions that may still be active.
+3. Review the cleanup plan Session Steward builds.
+4. Confirm the plan.
+5. Session Steward creates a local recovery backup.
+6. It removes only supported records in the reviewed plan.
+7. It checks whether those records are gone.
 
-- “Find sessions I have not used in 60 days.”
-- “Show sessions from this workspace, largest first.”
-- “Delete those sessions.”
-- “Every 12 days, delete sessions I have not used in 45 days.”
-- “Restore my latest backup.”
+Every interface revalidates the selected sessions before changing data. If Session Steward can detect that a selected session is active, preflight or cleanup stops. When detection is unavailable, it warns you to confirm that the selected sessions are closed.
 
-Cleanup uses the same local backup and verification checks as the browser and
-terminal. Codex or Claude Code asks for approval before cleanup, restore, or
-schedule changes.
+### Standard and thorough cleanup
 
-Scheduled cleanup continues in the background after you close Codex or Claude
-Code. You can ask to pause, resume, run, change, or remove a schedule. Before
-uninstalling Session Steward, stop scheduled cleanup:
+**Standard cleanup** removes supported transcripts, history, registry entries, logs, and linked artifacts belonging to the selected sessions. It is the routine option.
 
-```bash
-session-steward-scheduler --stop
-```
+**Thorough cleanup** also removes additional recognized session-owned data. For Codex, that can include supported Desktop references, memory outputs, and goal records. For Claude Code, it includes recognized file checkpoints.
 
-Check or remove the MCP connection at any time:
+Thorough cleanup is unavailable when the detected storage layout is not supported. Standard cleanup can still remove records that Session Steward can identify safely.
 
-```bash
-codex mcp list
-codex mcp remove session-steward
+<details>
+<summary>Backup and restore behavior</summary>
 
-claude mcp list
-claude mcp remove --scope user session-steward
-```
+Recovery backups are stored under `session-steward-backups/` inside the active provider folder.
 
-For another MCP client, add a local server named `session-steward`:
+If cleanup from the browser or interactive terminal needs attention, the backup is kept until you decide whether to restore it. The browser offers **Restore**, and the terminal reports the backup for the `restore` command. MCP and scheduled cleanup try to restore automatically.
 
-```json
-{
-  "mcpServers": {
-    "session-steward": {
-      "command": "session-steward-mcp"
-    }
-  }
-}
-```
+After successful cleanup, Session Steward removes the recovery backup when it can. A restore first creates a temporary safety backup of the current files, then tries to remove both backups if the restore succeeds. If a restore or backup removal cannot complete, recovery data remains and Session Steward reports it.
 
-The MCP server uses the same provider folders selected in the browser or
-terminal.
+</details>
 
-### Privacy
+### What cleanup leaves alone
 
-The MCP server runs locally. Session details can include messages, commands,
-file names, and workspace paths, and your MCP client may send that information
-to its AI provider.
+- Sign-in data and saved API credentials
+- Configuration, plugins, caches, and custom prompt files
+- Project files, Git repositories, and worktrees
+- Sessions outside the reviewed cleanup plan
+- Conversations stored in your ChatGPT or Claude account
+- Claude Code worktrees, branches, repositories, remote sessions, SSH sessions, and Cowork data
 
-## Use a custom provider folder
+## Provider folders and platform support
 
-The browser interface displays the active provider folder. Select **Change** to choose another existing folder and remember it for later browser and terminal sessions.
+The browser shows the active provider folder. Select **Change** to choose another existing folder and save it for later browser, terminal, and MCP sessions.
 
-For a one-time override:
+For a one-time browser override:
 
 ```bash
 session-steward --codex-home /path/to/.codex
-```
-
-For Claude Code:
-
-```bash
 session-steward --claude-home /path/to/.claude
 ```
 
-The command-line override applies only to that run and does not replace your saved folder.
+The CLI and MCP commands accept the same flags. An override applies only to that process and does not replace the saved folder.
 
-## Other commands
+Codex and Claude Code CLI sessions are supported on macOS, Linux, and Windows. Local Claude Desktop sessions are also supported on macOS and Windows. On Windows, the default provider folders are `%USERPROFILE%\.codex` and `%USERPROFILE%\.claude`; both standalone and Microsoft Store Claude Desktop data locations are detected.
 
-Start without automatically opening the browser:
+Inside WSL, Session Steward uses the Linux home folder. Run it from Windows to manage sessions in your Windows profile.
 
-```bash
-session-steward --no-open
-```
+Archiving a Claude Desktop session does not delete it. It remains available until it is explicitly included in cleanup. Session Steward does not remove Claude worktrees.
 
-Update Session Steward:
+## Update or uninstall
 
 ```bash
 npm install --global session-steward@latest
-```
-
-Uninstall it:
-
-```bash
 npm uninstall --global session-steward
 ```
 
-Uninstalling Session Steward does not remove provider sessions, recovery backups, or saved folder preferences.
+Uninstalling does not remove provider sessions, recovery backups, or saved folder preferences.
 
 ## Troubleshooting
 
-- **The browser did not open:** Run `session-steward --no-open`, then open the local address shown in the terminal.
+- **The browser did not open:** Run `session-steward --no-open`, then open the local address printed in the terminal.
 - **No sessions were found:** Check the selected provider and displayed home folder. Use **Change** or pass a one-time home-folder override.
-- **Thorough cleanup is unavailable:** Review the compatibility details. Unrecognized storage is left untouched, but standard cleanup may still be available.
+- **Thorough cleanup is unavailable:** Unrecognized storage stays unchanged, while standard cleanup may still be available.
 - **Your Node.js version is too old:** Install Node.js 24.15 or newer and run Session Steward again.
 
-## Development
+## Benchmarks
 
-```bash
-git clone https://github.com/mallikcheripally/session-steward.git
-cd session-steward
-npm install
-npm test
-npm run build
-```
-
-## Performance and scale
-
-Session Steward uses paginated listings, incremental transcript reads, and bounded caches to remain responsive with large session libraries.
-
-Current synthetic benchmarks on an arm64 Mac with Node.js 24.15.0:
+Current benchmarks on an arm64 Mac with Node.js 24.15.0:
 
 | Scenario | Scale | Time | Measured memory growth |
 | --- | ---: | ---: | ---: |
@@ -358,11 +229,7 @@ Results vary with hardware, disk speed, and session layout. Tests and benchmarks
 
 ## Support
 
-Codex, Claude Code CLI, and local Claude Code Desktop sessions are supported. Claude Desktop archive is not treated as deletion, and Session Steward never removes its worktrees. On Windows, both the standalone and Microsoft Store Claude Desktop data locations are detected.
-
-Use [GitHub Issues](https://github.com/mallikcheripally/session-steward/issues) to report a bug, request a provider, or share a storage format that Session Steward does not recognize.
-
-See the [changelog](https://github.com/mallikcheripally/session-steward/blob/main/CHANGELOG.md) for published release history.
+Use [GitHub Issues](https://github.com/mallikcheripally/session-steward/issues) to report a bug, request a provider, or share a storage format that Session Steward does not recognize. See the [changelog](https://github.com/mallikcheripally/session-steward/blob/main/CHANGELOG.md) for release history.
 
 Session Steward is an independent project and is not affiliated with or endorsed by OpenAI or Anthropic.
 

package/bin/session-steward-cli.mjs

@@ -106,6 +106,7 @@ async function main() {
     archiveStatus: values["archive-status"],
     backups: values.backups ?? false,
     cleanup: values.cleanup,
+    configDirectory: settings.getConfigDirectory(),
     events: values.events ?? false,
     eventsLimit,
     help,

package/bin/session-steward-scheduler.mjs

@@ -37,13 +37,17 @@ Options:
     "../lib/cleanup-schedules.mjs"
   );
   const { createProviderSettings } = await import("../lib/settings.mjs");
+  const { createSessionProtectionStore } = await import("../lib/session-protections.mjs");
   const settings = await createProviderSettings({
     configDirectory: values["config-directory"],
   });
   const scheduleStore = createCleanupScheduleStore({
     configDirectory: settings.getConfigDirectory(),
   });
-  const results = await runDueCleanupSchedules({ scheduleStore, settings });
+  const protectionStore = createSessionProtectionStore({
+    configDirectory: settings.getConfigDirectory(),
+  });
+  const results = await runDueCleanupSchedules({ protectionStore, scheduleStore, settings });
   if (results.some((result) => ["failed", "recovery-failed"].includes(result.status))) {
     process.exitCode = 1;
   }

package/bin/session-steward.mjs

@@ -10,20 +10,32 @@ import { findAvailableUpdate, formatUpdateNotice } from "../lib/update-check.mjs
 
 assertSupportedNode();
 
-const { values } = parseArgs({
-  allowPositionals: false,
-  options: {
-    "codex-home": { type: "string" },
-    "claude-home": { type: "string" },
-    help: { short: "h", type: "boolean" },
-    "no-open": { type: "boolean", default: false },
-    port: { type: "string" },
-    version: { short: "v", type: "boolean" },
-  },
-});
-
-if (values.help) {
-  process.stdout.write(`Usage: session-steward [options]
+if (process.argv[2] === "mcp") {
+  process.argv.splice(2, 1);
+  await import("./session-steward-mcp.mjs");
+} else {
+  await startBrowser();
+}
+
+async function startBrowser() {
+  const { values } = parseArgs({
+    allowPositionals: false,
+    options: {
+      "codex-home": { type: "string" },
+      "claude-home": { type: "string" },
+      help: { short: "h", type: "boolean" },
+      "no-open": { type: "boolean", default: false },
+      port: { type: "string" },
+      version: { short: "v", type: "boolean" },
+    },
+  });
+
+  if (values.help) {
+    process.stdout.write(`Usage: session-steward [options]
+       session-steward mcp [options]
+
+Commands:
+  mcp                  Run the MCP server over stdio
 
 Options:
   --codex-home <path>  Use a custom Codex session folder
@@ -33,44 +45,45 @@ Options:
   -h, --help           Show this help
   -v, --version        Show the installed version
 `);
-  process.exit(0);
-}
+    return;
+  }
 
-if (values.version) {
-  process.stdout.write(`${packageMetadata.version}\n`);
-  process.exit(0);
-}
+  if (values.version) {
+    process.stdout.write(`${packageMetadata.version}\n`);
+    return;
+  }
 
-const { startLocalServer } = await import("../lib/server.mjs");
-const port = values.port === undefined ? 0 : Number.parseInt(values.port, 10);
-const availableUpdate = await findAvailableUpdate({ packageMetadata });
+  const { startLocalServer } = await import("../lib/server.mjs");
+  const port = values.port === undefined ? 0 : Number.parseInt(values.port, 10);
+  const availableUpdate = await findAvailableUpdate({ packageMetadata });
 
-if (availableUpdate) {
-  process.stdout.write(`${formatUpdateNotice(availableUpdate)}\n`);
-}
+  if (availableUpdate) {
+    process.stdout.write(`${formatUpdateNotice(availableUpdate)}\n`);
+  }
+
+  const server = await startLocalServer({
+    claudeHome: values["claude-home"],
+    codexHome: values["codex-home"],
+    port,
+  });
+
+  process.stdout.write(`Session Steward is running at http://127.0.0.1:${server.port}\n`);
 
-const server = await startLocalServer({
-  claudeHome: values["claude-home"],
-  codexHome: values["codex-home"],
-  port,
-});
-
-process.stdout.write(`Session Steward is running at http://127.0.0.1:${server.port}\n`);
-
-if (!values["no-open"]) {
-  const url = `http://127.0.0.1:${server.port}`;
-  const invocation = getBrowserOpenInvocation(url);
-
-  if (invocation) {
-    const opener = spawn(invocation.command, invocation.args, {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: invocation.windowsHide,
-    });
-    opener.unref();
-  } else {
-    process.stdout.write(`Open ${url} in a browser.\n`);
+  if (!values["no-open"]) {
+    const url = `http://127.0.0.1:${server.port}`;
+    const invocation = getBrowserOpenInvocation(url);
+
+    if (invocation) {
+      const opener = spawn(invocation.command, invocation.args, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: invocation.windowsHide,
+      });
+      opener.unref();
+    } else {
+      process.stdout.write(`Open ${url} in a browser.\n`);
+    }
   }
-}
 
-process.stdout.write("Press Ctrl+C to stop.\n");
+  process.stdout.write("Press Ctrl+C to stop.\n");
+}