create-snipara 1.3.9 → 1.3.12

package/README.md

@@ -48,10 +48,10 @@ The product surfaces remain:
 - Hosted MCP for LLM agents, context, and reviewed memory
 - HTTP API / SDK for apps, integrators, backends, and pipelines
 
-The CLI can wire local helpers around those surfaces:
+The default CLI path wires the local companion around those surfaces:
 
-- `snipara-companion` for local `rlm-hook` workflows when you want them
-- `rlm-runtime` for optional local code execution
+- `snipara-companion` for local workflow commands and managed phase commits; legacy `rlm-hook` commands remain compatible
+- `snipara-sandbox` for optional local code execution
 - local config, env files, hook scripts, and a project companion pack
 - `snipara-mcp` only for local stdio compatibility, development, or testing
 
@@ -59,14 +59,14 @@ The CLI can wire local helpers around those surfaces:
 
 The CLI now works around explicit install profiles:
 
-| Profile            | What it installs                          | Best for                                            |
-| ------------------ | ----------------------------------------- | --------------------------------------------------- |
-| `hosted-only`      | Hosted MCP config only                    | Default: agents without local helper workflows      |
-| `hosted-companion` | MCP + `snipara-companion`                 | Hook-heavy clients that want local helper workflows |
-| `full-stack`       | MCP + `snipara-companion` + `rlm-runtime` | Hosted context plus local execution                 |
-| `runtime-only`     | `rlm-runtime` only                        | Local execution without hosted API                  |
+| Profile            | What it installs                              | Best for                                            |
+| ------------------ | --------------------------------------------- | --------------------------------------------------- |
+| `hosted-companion` | MCP + `snipara-companion`                     | Default: hosted context plus managed local workflow |
+| `hosted-only`      | Hosted MCP config only                        | Locked-down or minimal environments                 |
+| `full-stack`       | MCP + `snipara-companion` + `snipara-sandbox` | Hosted context plus sandboxed local execution       |
+| `runtime-only`     | `snipara-sandbox` only                        | Local execution without hosted API                  |
 
-Default profile: `hosted-only`
+Default profile: `hosted-companion`
 
 ## Free Account Fit
 
@@ -76,7 +76,7 @@ Free onboarding is now **Context + Memory**, not Context-only:
 - Memory Free: reviewed hosted memories for continuity across sessions
 - Hosted MCP: direct connection for Claude Code, Codex, Cursor, ChatGPT Desktop, and other MCP clients
 
-The CLI opens a browser device-flow login when the user does not already have a key, auto-provisions the free Context + Memory account when needed, then writes the returned project key into the local MCP config.
+The CLI opens a browser device-flow login when the user does not already have a key, auto-provisions the free Context + Memory account when needed, then writes the returned API key into the local MCP config.
 
 ## The Two Approval Paths
 
@@ -99,10 +99,10 @@ That distinction matters:
 - opens the browser device-flow free Context + Memory account flow when needed
 - writes Hosted MCP configuration
 - detects a GitHub remote and can open the Snipara GitHub App automation path
-- installs `snipara-companion` when the selected profile needs local helper workflows
-- installs optional `rlm-runtime`
+- installs `snipara-companion` by default for local managed workflows
+- installs optional `snipara-sandbox`
 - configures `.mcp.json`
-- generates merge-ready AI agent templates in `.snipara/templates/`, including Pro+ symbol-card and code-impact guidance for paid Context plans
+- generates merge-ready AI agent templates in `.snipara/templates/`, including Pro+ symbol-card, code-impact, and managed workflow guidance for paid Context plans
 - creates `AGENTS.md`, `CLAUDE.md`, `.cursor/rules/snipara.mdc`, and `.codex/config.toml` when those files do not already exist
 - updates `.env`, `.env.local`, and `.env.example`
 - generates `.snipara/companion/README.md`
@@ -131,12 +131,13 @@ npx create-snipara
 The interactive flow now asks for:
 
 - project slug
-- API key path: project key, team key, free signup, or add key later
+- API key path: existing API key, free signup, or add key later
 - AI client
 
-By default, this stays on the recommended `hosted-only` setup. Add
-`--advanced` when you want profile selection, project id entry, hook prompts,
-GitHub automation prompts, or runtime provider prompts.
+By default, this uses the recommended `hosted-companion` setup: hosted MCP plus
+the local `snipara-companion` workflow helper. Legacy `rlm-hook` commands remain
+compatible. Add `--advanced` when you want profile selection, project id entry,
+hook prompts, GitHub automation prompts, or sandbox provider prompts.
 
 The advanced flow asks for:
 
@@ -144,7 +145,7 @@ The advanced flow asks for:
 - optional project id
 - whether hooks should be generated
 - whether to open GitHub repository automation when a GitHub remote is detected
-- optional runtime provider config when `rlm-runtime` is installed
+- optional sandbox provider config when `snipara-sandbox` is installed
 
 The generated agent templates cover:
 
@@ -154,6 +155,17 @@ The generated agent templates cover:
 - Codex `.codex/config.toml` snippet
 - ChatGPT/OpenAI HTTP MCP snippet
 
+When `snipara-companion` is installed, the companion pack also includes the compaction-safe managed workflow:
+
+```bash
+snipara-companion workflow start --goal "ship auth hardening" --plan-file ./plan.md
+snipara-companion workflow phase-start context
+snipara-companion workflow run --mode full --include-session-context --query "load auth context"
+snipara-companion code impact --changed-files src/auth.ts tests/auth.test.ts --diff-summary "auth hardening"
+snipara-companion workflow phase-commit context --summary "Loaded context and mapped impacted files" --files src/auth.ts
+snipara-companion final-commit --summary "Shipped auth hardening and tests" --files src/auth.ts tests/auth.test.ts
+```
+
 ## Main Commands
 
 ### Install or initialize
@@ -175,7 +187,7 @@ Writes `.snipara/companion/doctor.json` and validates:
 
 - local config files
 - companion CLI presence
-- runtime CLI presence
+- Snipara Sandbox CLI presence
 - environment files
 - hosted MCP reachability when a live API key is available
 
@@ -247,15 +259,15 @@ That keeps business truth review separate from agent onboarding.
 
 ```bash
 # Use an explicit install profile
-npx create-snipara --profile hosted-only
 npx create-snipara --profile hosted-companion
+npx create-snipara --profile hosted-only
 npx create-snipara --profile full-stack
 npx create-snipara --advanced
 
-# Runtime-only local execution
+# Sandbox-only local execution
 npx create-snipara --runtime-only
 
-# Non-interactive setup
+# Non-interactive setup with an existing API key
 npx create-snipara -y --api-key rlm_xxx --slug my-project
 
 # Open GitHub automation after setup when a GitHub remote is detected
@@ -271,6 +283,7 @@ npx create-snipara --skip-github
 
 # Force extra layers during maintenance
 npx create-snipara repair --with-hooks
+npx create-snipara repair --with-runtime
 npx create-snipara upgrade --with-runtime
 ```
 
@@ -279,18 +292,19 @@ npx create-snipara upgrade --with-runtime
 The intended split is:
 
 - `create-snipara`: Context + Memory onboarding, auth, config, inspect, repair, and upgrade
-- `snipara-companion`: optional ongoing local runtime workflows through `rlm-hook`
+- `snipara-companion`: default local workflow helper; legacy `rlm-hook` commands remain compatible
 - `snipara-mcp`: local stdio bridge, client-package development, compatibility, and testing
-- `rlm-runtime`: optional local execution engine
+- `snipara-sandbox`: optional local execution engine
 
 ## Codex Setup
 
-For Codex, keep the setup minimal:
+For Codex, keep Hosted MCP as the core path and let companion add workflow
+ergonomics:
 
 - use Hosted MCP as the core Snipara surface
 - use `AGENTS.md` for project instructions
-- choose `hosted-only` if you do not need local helper workflows
-- add `snipara-companion` only if you explicitly want the local helper CLI
+- use the default `hosted-companion` path when you want compaction-safe local phase commits
+- choose `hosted-only` or `--skip-companion` only in locked-down environments
 - use local `snipara-mcp` only for stdio compatibility, development, or tests
 
 Codex does not require hook presets to use Snipara successfully.
@@ -310,8 +324,8 @@ This pack is meant to be the local source of truth for machine-level setup. When
 such as:
 
 ```bash
-rlm-hook onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json
-rlm-hook onboard-folder ./client-export --source-provider local_folder --apply
+snipara-companion onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json
+snipara-companion onboard-folder ./client-export --source-provider local_folder --apply
 ```
 
 Use this for dashboardless business-context imports after an LLM client has
@@ -342,23 +356,35 @@ Recommended explanation to users:
 
 ## API Key Requirements
 
-| Tooling                              | Snipara API key            | LLM API key |
-| ------------------------------------ | -------------------------- | ----------- |
-| Hosted MCP queries                   | Required                   | Not needed  |
-| Memory / planning tools              | Required with memory scope | Not needed  |
-| `snipara-companion` hosted workflows | Optional                   | Not needed  |
-| `rlm-runtime` `execute_python` MCP   | Not needed                 | Not needed  |
-| `rlm run` / `rlm agent` CLI          | Optional for context       | Required    |
+Existing manual API keys passed to `create-snipara --api-key` should start with `rlm_`.
+When `create-snipara` provisions a new account through the browser flow, Snipara returns a
+new `snp-` key from the current hosted API.
+
+| Tooling                                             | Snipara API key            | LLM API key |
+| --------------------------------------------------- | -------------------------- | ----------- |
+| Hosted MCP queries                                  | Required                   | Not needed  |
+| Memory / planning tools                             | Required with memory scope | Not needed  |
+| `snipara-companion` hosted workflows                | Optional                   | Not needed  |
+| `snipara-sandbox` `execute_python` MCP              | Not needed                 | Not needed  |
+| `snipara-sandbox run` / `snipara-sandbox agent` CLI | Optional for context       | Required    |
 
 ## Example Flows
 
-### Default hosted setup
+### Default managed hosted setup
+
+```bash
+npx create-snipara
+```
+
+Best when the user wants Hosted MCP Context + Memory plus `snipara-companion` managed workflows.
+
+### Minimal hosted setup
 
 ```bash
 npx create-snipara --profile hosted-only
 ```
 
-Best when the user only wants Hosted MCP Context + Memory.
+Best when the user only wants Hosted MCP Context + Memory and cannot install local helper tooling.
 
 ### Full local stack
 
@@ -366,7 +392,7 @@ Best when the user only wants Hosted MCP Context + Memory.
 npx create-snipara --profile full-stack --advanced
 ```
 
-Best when the user also wants `snipara-companion` and `rlm-runtime`.
+Best when the user also wants sandboxed `snipara-sandbox` execution.
 
 ### Connect the current repository
 
@@ -411,7 +437,7 @@ npx create-snipara print-config --json
 When testing a locally packed tarball, use `npm exec --package` instead of `npx`, for example:
 
 ```bash
-npm exec --package ./create-snipara-1.3.9.tgz create-snipara -- --help
+npm exec --package ./create-snipara-1.3.12.tgz create-snipara -- --help
 ```
 
 This avoids `npx` resolution issues with unpublished tarballs.

package/dist/index.js

@@ -9,12 +9,18 @@ import fs from "fs";
 import path from "path";
 import { execSync, spawn } from "child_process";
 import { homedir } from "os";
-var VERSION = "1.3.9";
+var VERSION = "1.3.12";
 var BASE_URL = "https://www.snipara.com";
 var API_URL = "https://api.snipara.com";
 var COMPANION_PACKAGE_NAME = "snipara-companion";
+var COMPANION_COMMAND_NAME = "snipara-companion";
+var LEGACY_COMPANION_COMMAND_NAME = "rlm-hook";
 var MCP_PACKAGE_NAME = "snipara-mcp";
-var RUNTIME_PACKAGE_NAME = "rlm-runtime[all]";
+var SANDBOX_PACKAGE_NAME = "snipara-sandbox[all]";
+var SANDBOX_SERVER_NAME = "snipara-sandbox";
+var LEGACY_RUNTIME_SERVER_NAME = "rlm-runtime";
+var SANDBOX_COMMAND_NAME = "snipara-sandbox";
+var LEGACY_SANDBOX_COMMAND_NAME = "rlm";
 var DEVICE_CLIENT_ID = "create-snipara";
 var DeviceAuthorizationAborted = class extends Error {
 };
@@ -26,11 +32,11 @@ function getCompanionInitClientFlag(aiClient) {
 }
 function buildProgram() {
   const program = new Command();
-  program.name("create-snipara").description("Scaffold hosted Snipara MCP config plus optional local helper workflows").version(VERSION);
-  program.command("init").description("Install and configure Snipara for this project").option("--api-key <key>", "Snipara project API key").option("--team-key <key>", "Snipara team API key").option("--slug <slug>", "Project slug").option("--project-id <id>", "Project ID").option("--advanced", "Show advanced profile, project id, hooks, GitHub, and runtime prompts").option(
+  program.name("create-snipara").description("Scaffold hosted Snipara MCP config plus companion workflow helpers").version(VERSION);
+  program.command("init").description("Install and configure Snipara for this project").option("--api-key <key>", "Snipara API key").option("--slug <slug>", "Project slug").option("--project-id <id>", "Project ID").option("--advanced", "Show advanced profile, project id, hooks, GitHub, and sandbox prompts").option(
     "--profile <profile>",
     "Install profile: hosted-only, hosted-companion, full-stack, runtime-only"
-  ).option("--skip-companion", "Skip local companion CLI installation").option("--skip-mcp", "Skip local snipara-mcp package installation").option("--skip-runtime", "Skip rlm-runtime installation").option("--skip-hooks", "Skip hook generation").option("--skip-test", "Skip hosted connection test").option("--github", "Open GitHub repository automation setup when a git remote is detected").option("--skip-github", "Skip the GitHub automation prompt").option("--github-path <path>", "Optional GitHub path filter for the initial repository sync").option("--runtime-only", "Install only RLM-Runtime").option("-y, --yes", "Accept defaults without prompting").action(async (options) => {
+  ).option("--skip-companion", "Skip local companion CLI installation").option("--skip-mcp", "Skip local snipara-mcp package installation").option("--skip-runtime", "Skip snipara-sandbox installation").option("--skip-hooks", "Skip hook generation").option("--skip-test", "Skip hosted connection test").option("--github", "Open GitHub repository automation setup when a git remote is detected").option("--skip-github", "Skip the GitHub automation prompt").option("--github-path <path>", "Optional GitHub path filter for the initial repository sync").option("--runtime-only", "Install only Snipara Sandbox").option("-y, --yes", "Accept defaults without prompting").action(async (options) => {
     printBanner();
     await runInit(options);
   });
@@ -38,11 +44,11 @@ function buildProgram() {
     printBanner();
     await runDoctor(options);
   });
-  program.command("repair").description("Rebuild local Snipara config and re-run validation").option("--api-key <key>", "Snipara project API key override").option("--team-key <key>", "Snipara team API key override").option("--slug <slug>", "Project slug override").option("--project-id <id>", "Project ID override").option("--profile <profile>", "Target install profile").option("--with-hooks", "Force hook generation").option("--with-runtime", "Force runtime server/config").option("--with-mcp", "Force MCP config").option("--with-companion", "Force companion pack generation").action(async (options) => {
+  program.command("repair").description("Rebuild local Snipara config and re-run validation").option("--api-key <key>", "Snipara API key override").option("--slug <slug>", "Project slug override").option("--project-id <id>", "Project ID override").option("--profile <profile>", "Target install profile").option("--with-hooks", "Force hook generation").option("--with-runtime", "Force Snipara Sandbox server/config").option("--with-mcp", "Force MCP config").option("--with-companion", "Force companion pack generation").action(async (options) => {
     printBanner();
     await runRepair(options);
   });
-  program.command("upgrade").description("Upgrade installed Snipara local components").option("--with-hooks", "Refresh hooks after upgrade").option("--with-runtime", "Upgrade runtime even if not detected").option("--with-mcp", "Upgrade snipara-mcp even if not detected").option("--with-companion", "Upgrade companion even if not detected").action(async (options) => {
+  program.command("upgrade").description("Upgrade installed Snipara local components").option("--with-hooks", "Refresh hooks after upgrade").option("--with-runtime", "Upgrade Snipara Sandbox even if not detected").option("--with-mcp", "Upgrade snipara-mcp even if not detected").option("--with-companion", "Upgrade companion even if not detected").action(async (options) => {
     printBanner();
     await runUpgrade(options);
   });
@@ -58,10 +64,10 @@ function buildProgram() {
   return program;
 }
 function addSharedRootOptions(program) {
-  program.option("--api-key <key>", "Snipara project API key").option("--team-key <key>", "Snipara team API key").option("--slug <slug>", "Project slug").option("--project-id <id>", "Project ID").option("--advanced", "Show advanced profile, project id, hooks, GitHub, and runtime prompts").option(
+  program.option("--api-key <key>", "Snipara API key").option("--slug <slug>", "Project slug").option("--project-id <id>", "Project ID").option("--advanced", "Show advanced profile, project id, hooks, GitHub, and sandbox prompts").option(
     "--profile <profile>",
     "Install profile: hosted-only, hosted-companion, full-stack, runtime-only"
-  ).option("--skip-companion", "Skip local companion CLI installation").option("--skip-mcp", "Skip local snipara-mcp package installation").option("--skip-runtime", "Skip rlm-runtime installation").option("--skip-hooks", "Skip hook generation").option("--skip-test", "Skip hosted connection test").option("--github", "Open GitHub repository automation setup when a git remote is detected").option("--skip-github", "Skip the GitHub automation prompt").option("--github-path <path>", "Optional GitHub path filter for the initial repository sync").option("--runtime-only", "Install only RLM-Runtime").option("-y, --yes", "Accept defaults without prompting");
+  ).option("--skip-companion", "Skip local companion CLI installation").option("--skip-mcp", "Skip local snipara-mcp package installation").option("--skip-runtime", "Skip snipara-sandbox installation").option("--skip-hooks", "Skip hook generation").option("--skip-test", "Skip hosted connection test").option("--github", "Open GitHub repository automation setup when a git remote is detected").option("--skip-github", "Skip the GitHub automation prompt").option("--github-path <path>", "Optional GitHub path filter for the initial repository sync").option("--runtime-only", "Install only Snipara Sandbox").option("-y, --yes", "Accept defaults without prompting");
 }
 async function main() {
   const program = buildProgram();
@@ -81,7 +87,6 @@ function parseInitOptionsFromArgv(args) {
   const parsed = {};
   const valueFlags = {
     "--api-key": "apiKey",
-    "--team-key": "teamKey",
     "--slug": "slug",
     "--project-id": "projectId",
     "--profile": "profile",
@@ -145,8 +150,8 @@ async function runInit(options) {
   if (answers.configureGitHub && answers.githubRepo) {
     await openGitHubAutomation(answers);
   }
-  if (answers.runRlmInit && answers.installRuntime) {
-    await runRlmInit();
+  if (answers.runSandboxInit && answers.installRuntime) {
+    await runSandboxInit();
   }
 }
 async function runDoctor(options) {
@@ -223,7 +228,7 @@ async function runPrintConfig(options) {
     `   Hosted MCP config: ${answers.profile !== "runtime-only" ? "enabled" : "disabled"}`
   );
   console.log(`   Local snipara-mcp package: ${answers.installMcp ? "enabled" : "disabled"}`);
-  console.log(`   Runtime: ${answers.installRuntime ? "enabled" : "disabled"}`);
+  console.log(`   Snipara Sandbox: ${answers.installRuntime ? "enabled" : "disabled"}`);
   console.log(`   Hooks: ${answers.installHooks ? "enabled" : "disabled"}`);
   console.log(`   Existing .mcp.json: ${detection.files.mcpConfig ? "yes" : "no"}`);
   console.log(`   Companion pack: ${detection.files.sniparaCompanionPack ? "yes" : "no"}`);
@@ -239,7 +244,7 @@ function printBanner() {
 \u2551   \u2022 Hosted MCP for LLM agents                                         \u2551
 \u2551   \u2022 Free account path with hosted context and reviewed memory         \u2551
 \u2551   \u2022 API / SDK for product integrations                                \u2551
-\u2551   \u2022 Optional local companion and runtime helpers                      \u2551
+\u2551   \u2022 Optional local companion and Snipara Sandbox helpers              \u2551
 \u2551   \u2022 One CLI for auth, config, doctor, repair, and upgrade             \u2551
 \u2551                                                                       \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
@@ -267,12 +272,16 @@ async function gatherConfiguration(options) {
     detectedProjectId = existingConfig.projectId || "";
   }
   const initialProfile = resolveRequestedProfile(options);
+  const providedApiKey = options.apiKey?.trim();
+  if (providedApiKey && !isManualApiKey(providedApiKey)) {
+    throw new Error(manualApiKeyValidationMessage());
+  }
   if (options.yes) {
     return buildAnswersFromProfile({
       projectSlug: options.slug || detectedSlug || "my-project",
       projectId: options.projectId || detectedProjectId,
-      apiKey: options.teamKey || options.apiKey || "YOUR_API_KEY_HERE",
-      apiKeyType: options.teamKey ? "team" : options.apiKey ? "project" : "none",
+      apiKey: providedApiKey || "YOUR_API_KEY_HERE",
+      apiKeyType: providedApiKey ? "api" : "none",
       profile: initialProfile,
       aiClient: detectedClient,
       skipCompanion: !!options.skipCompanion,
@@ -306,19 +315,14 @@ async function gatherConfiguration(options) {
       initial: options.projectId || detectedProjectId || ""
     },
     {
-      type: (_, values) => values.profile === "runtime-only" || options.apiKey || options.teamKey ? null : "select",
+      type: (_, values) => values.profile === "runtime-only" || providedApiKey ? null : "select",
       name: "apiKeyType",
-      message: "What type of API key do you have?",
+      message: "How do you want to add your Snipara API key?",
       choices: [
         {
-          title: "Project API key",
-          value: "project",
-          description: "Access to a single project"
-        },
-        {
-          title: "Team API key",
-          value: "team",
-          description: "Access to all projects in your team"
+          title: "I have an API key",
+          value: "api",
+          description: "Paste an API key that starts with rlm_"
         },
         {
           title: "Create free Context + Memory account",
@@ -332,10 +336,10 @@ async function gatherConfiguration(options) {
       ]
     },
     {
-      type: (_, values) => values.profile === "runtime-only" ? null : values.apiKeyType === "project" || values.apiKeyType === "team" ? "text" : null,
+      type: (_, values) => values.profile === "runtime-only" ? null : values.apiKeyType === "api" ? "text" : null,
       name: "apiKey",
-      message: (_, values) => values.apiKeyType === "team" ? "Enter your Team API key:" : "Enter your Project API key:",
-      validate: (value) => value.startsWith("rlm_") ? true : "API key should start with rlm_"
+      message: (_, values) => values.apiKeyType === "api" ? "Enter your Snipara API key:" : "Enter your API key:",
+      validate: (value) => isManualApiKey(value) ? true : manualApiKeyValidationMessage()
     },
     {
       type: "select",
@@ -392,17 +396,17 @@ async function gatherConfiguration(options) {
       initial: options.githubPath || ""
     }
   ]);
-  let apiKey = options.teamKey || options.apiKey;
-  let apiKeyType = response.profile === "runtime-only" ? "none" : options.teamKey ? "team" : options.apiKey ? "project" : "none";
+  let apiKey = providedApiKey;
+  let apiKeyType = response.profile === "runtime-only" ? "none" : providedApiKey ? "api" : "none";
   let signupResult = null;
   if (!apiKey && response.profile !== "runtime-only") {
     if (response.apiKeyType === "signup") {
       signupResult = await handleSignup();
       apiKey = signupResult.apiKey;
-      apiKeyType = "project";
-    } else if (response.apiKeyType === "project" || response.apiKeyType === "team") {
+      apiKeyType = "api";
+    } else if (response.apiKeyType === "api") {
       apiKey = response.apiKey;
-      apiKeyType = response.apiKeyType;
+      apiKeyType = "api";
     } else {
       apiKey = "YOUR_API_KEY_HERE";
       apiKeyType = "none";
@@ -430,7 +434,7 @@ async function gatherConfiguration(options) {
       {
         type: "select",
         name: "llmProvider",
-        message: "Will you use rlm run/agent CLI too?",
+        message: "Will you use the Snipara Sandbox run/agent CLI too?",
         choices: [
           {
             title: "No - execute_python only",
@@ -465,14 +469,14 @@ async function gatherConfiguration(options) {
       },
       {
         type: "confirm",
-        name: "runRlmInit",
-        message: "Run 'rlm init' now to choose sandbox/docker/local?",
+        name: "runSandboxInit",
+        message: "Run Snipara Sandbox init now to choose sandbox/docker/local?",
         initial: false
       }
     ]);
     answers.llmProvider = runtimeResponse.llmProvider;
     answers.llmApiKey = runtimeResponse.llmApiKey;
-    answers.runRlmInit = runtimeResponse.runRlmInit || false;
+    answers.runSandboxInit = runtimeResponse.runSandboxInit || false;
   }
   return answers;
 }
@@ -483,32 +487,32 @@ function resolveRequestedProfile(options) {
   if (options.profile && isInstallProfile(options.profile)) {
     return options.profile;
   }
-  return "hosted-only";
+  return "hosted-companion";
 }
 function isInstallProfile(value) {
   return ["hosted-only", "hosted-companion", "full-stack", "runtime-only"].includes(value);
 }
 function installProfileChoices() {
   return [
-    {
-      title: "Hosted only",
-      value: "hosted-only",
-      description: "Default: hosted MCP config, no local companion or runtime"
-    },
     {
       title: "Hosted + Companion",
       value: "hosted-companion",
-      description: "Hosted MCP config plus optional local companion workflows"
+      description: "Default: hosted MCP config plus managed local workflow commands"
+    },
+    {
+      title: "Hosted only",
+      value: "hosted-only",
+      description: "Minimal setup: hosted MCP config, no local companion or sandbox"
     },
     {
-      title: "Hosted + Companion + Runtime",
+      title: "Hosted + Companion + Sandbox",
       value: "full-stack",
-      description: "Add local runtime execution as well"
+      description: "Add Snipara Sandbox local execution as well"
     },
     {
-      title: "Runtime only",
+      title: "Sandbox only",
       value: "runtime-only",
-      description: "Local execution only, no hosted API key required"
+      description: "Snipara Sandbox execution only, no hosted API key required"
     }
   ];
 }
@@ -582,8 +586,8 @@ async function handleManualSignup() {
   const response = await prompts({
     type: "text",
     name: "apiKey",
-    message: "Paste your Project API key when ready:",
-    validate: (value) => value.startsWith("rlm_") ? true : "API key should start with rlm_"
+    message: "Paste your API key when ready:",
+    validate: (value) => isProvisionedApiKey(value) ? true : provisionedApiKeyValidationMessage()
   });
   return { apiKey: response.apiKey };
 }
@@ -618,7 +622,10 @@ async function runDeviceAuthorization() {
     );
     if (!tokenResponse.error) {
       if (!tokenResponse.api_key) {
-        throw new Error("Device flow completed but no project API key was returned");
+        throw new Error("Device flow completed but no API key was returned");
+      }
+      if (!isProvisionedApiKey(tokenResponse.api_key)) {
+        throw new Error("Device flow returned an API key that does not start with snp-");
       }
       spinner.succeed(
         tokenResponse.project_name ? `Authorized ${tokenResponse.project_name}` : "Authorized Snipara account"
@@ -669,6 +676,36 @@ function openBrowser(url) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function isManualApiKey(value) {
+  return value.trim().startsWith("rlm_");
+}
+function manualApiKeyValidationMessage() {
+  return "API key should start with rlm_";
+}
+function isProvisionedApiKey(value) {
+  return value.trim().startsWith("snp-");
+}
+function provisionedApiKeyValidationMessage() {
+  return "New Snipara API keys should start with snp-";
+}
+function detectCompanionCommand() {
+  if (commandExists(COMPANION_COMMAND_NAME)) {
+    return COMPANION_COMMAND_NAME;
+  }
+  if (commandExists(LEGACY_COMPANION_COMMAND_NAME)) {
+    return LEGACY_COMPANION_COMMAND_NAME;
+  }
+  return null;
+}
+function detectSandboxCommand() {
+  if (commandExists(SANDBOX_COMMAND_NAME)) {
+    return SANDBOX_COMMAND_NAME;
+  }
+  if (commandExists(LEGACY_SANDBOX_COMMAND_NAME)) {
+    return LEGACY_SANDBOX_COMMAND_NAME;
+  }
+  return null;
+}
 async function installPythonPackages(answers, upgrade) {
   console.log(chalk.bold(`
 \u{1F4E6} ${upgrade ? "Upgrading" : "Installing"} Python Packages
@@ -680,7 +717,7 @@ async function installPythonPackages(answers, upgrade) {
       console.log(chalk.gray(`      pip install ${upgrade ? "-U " : ""}${MCP_PACKAGE_NAME}`));
     }
     if (answers.installRuntime) {
-      console.log(chalk.gray(`      pip install ${upgrade ? "-U " : ""}${RUNTIME_PACKAGE_NAME}`));
+      console.log(chalk.gray(`      pip install ${upgrade ? "-U " : ""}${SANDBOX_PACKAGE_NAME}`));
     }
     console.log("");
     return;
@@ -690,27 +727,40 @@ async function installPythonPackages(answers, upgrade) {
     packages.push(MCP_PACKAGE_NAME);
   }
   if (answers.installRuntime) {
-    packages.push(RUNTIME_PACKAGE_NAME);
+    packages.push(SANDBOX_PACKAGE_NAME);
   }
   if (packages.length === 0) return;
   const spinner = ora(
     `${upgrade ? "Upgrading" : "Installing"} ${packages.map(stripExtras).join(", ")}...`
   ).start();
-  try {
-    const installCmd = pipCmd === "uv" ? `uv pip install ${upgrade ? "--upgrade " : ""}${packages.join(" ")}` : `${pipCmd} install ${upgrade ? "--upgrade " : ""}${packages.join(" ")}`;
-    execSync(installCmd, {
-      stdio: "pipe",
-      encoding: "utf-8"
-    });
-    spinner.succeed(
-      `${upgrade ? "Upgraded" : "Installed"} ${packages.map(stripExtras).join(", ")}`
-    );
-  } catch {
-    spinner.fail(`Failed to ${upgrade ? "upgrade" : "install"} Python packages`);
-    console.log(chalk.yellow("\n   Install manually with:"));
-    console.log(chalk.gray(`   pip install ${upgrade ? "--upgrade " : ""}${packages.join(" ")}
-`));
+  const attempts = [packages];
+  const failures = [];
+  for (const attemptPackages of attempts) {
+    try {
+      const installCmd = pipCmd === "uv" ? `uv pip install ${upgrade ? "--upgrade " : ""}${attemptPackages.join(" ")}` : `${pipCmd} install ${upgrade ? "--upgrade " : ""}${attemptPackages.join(" ")}`;
+      execSync(installCmd, {
+        stdio: "pipe",
+        encoding: "utf-8"
+      });
+      spinner.succeed(
+        `${upgrade ? "Upgraded" : "Installed"} ${attemptPackages.map(stripExtras).join(", ")}`
+      );
+      return;
+    } catch (error) {
+      const detail = error instanceof Error && "message" in error ? error.message.split("\n")[0] : "unknown error";
+      failures.push(`${attemptPackages.join(" ")}: ${detail}`);
+    }
   }
+  spinner.fail(`Failed to ${upgrade ? "upgrade" : "install"} Python packages`);
+  if (failures.length > 0) {
+    console.log(chalk.yellow("\n   Attempt summary:"));
+    for (const failure of failures) {
+      console.log(chalk.gray(`   - ${failure}`));
+    }
+  }
+  console.log(chalk.yellow("\n   Install manually with:"));
+  console.log(chalk.gray(`   pip install ${upgrade ? "--upgrade " : ""}${packages.join(" ")}
+`));
 }
 function stripExtras(name) {
   return name.replace(/\[.*\]$/, "");
@@ -753,14 +803,15 @@ async function installNodeCompanion(upgrade) {
         stdio: "pipe",
         encoding: "utf-8"
       });
-      if (commandExists("rlm-hook")) {
+      const installedCommand = detectCompanionCommand();
+      if (installedCommand) {
         spinner.succeed(
           `${upgrade ? "Upgraded" : "Installed"} ${COMPANION_PACKAGE_NAME} via ${packageManager}`
         );
         return;
       }
       failures.push(
-        `${packageManager}: command completed but rlm-hook is still not available on PATH`
+        `${packageManager}: command completed but ${COMPANION_COMMAND_NAME} is still not available on PATH (legacy ${LEGACY_COMPANION_COMMAND_NAME} is also accepted)`
       );
     } catch (error) {
       const detail = error instanceof Error && "message" in error ? error.message.split("\n")[0] : "unknown error";
@@ -802,7 +853,7 @@ async function createMcpConfig(answers) {
     };
   }
   if (answers.installRuntime) {
-    mcpConfig.mcpServers["rlm-runtime"] = {
+    mcpConfig.mcpServers[SANDBOX_SERVER_NAME] = {
       type: "http",
       url: "http://localhost:8765/mcp",
       headers: {}
@@ -887,22 +938,26 @@ function buildAgentsMdTemplate(answers) {
 This project uses Snipara Hosted MCP for project context and reviewed memory.
 
 - Endpoint: \`${buildHostedMcpEndpoint(answers)}\`
-- Auth: use \`SNIPARA_API_KEY\` or \`RLM_API_KEY\` from the environment. Never commit keys.
+- Auth: use \`SNIPARA_API_KEY\` from the environment. Never commit keys.
 
 Agent task lifecycle:
 
-1. Start substantial work with \`rlm_recall\` and a targeted \`rlm_context_query\`.
-2. Use \`rlm_context_query\` for docs, business context, client/project truth, architecture notes, runbooks, and narrative source material.
-3. When \`rlm_context_query\` returns \`answer_pack\`, treat it as the first-pass response plan: use its source facts, caveats, source map, and verification checklist before drafting claims.
-4. Use \`rlm_get_chunk\` to load cited source sections returned by reference-based queries before relying on precise wording.
-5. Use \`rlm_code_callers\`, \`rlm_code_imports\`, \`rlm_code_neighbors\`, or \`rlm_code_shortest_path\` for structural code questions.
-6. On paid Context plans, use \`rlm_code_symbol_card\` for agent-ready symbol context and \`rlm_code_impact\` before risky multi-file changes or PR reviews.
-7. Use \`rlm_plan\` or \`rlm_decompose\` only for complex work and only when the hosted server exposes them.
-8. Use local file reads, \`rg\`, git commands, and test commands for exact edits, current working-tree state, and verification.
-9. Use RLM Runtime only when sandboxed execution, repeatable validation, or isolated transformations materially help.
-10. If a broad query is slow, retry once with a narrow keyword query before falling back to local search.
-11. End substantial work with \`rlm_end_of_task_commit\` when available. Use \`rlm_remember_if_novel\` for one reusable memory while avoiding duplicates, and use \`rlm_remember\` for explicit direct memory writes.
-12. Do not store secrets, tokens, passwords, private keys, raw logs, transient command output, or unreviewed guesses in memory.
+1. Start substantial work with \`snipara_recall\` and a targeted \`snipara_context_query\`.
+2. Use \`snipara_context_query\` for docs, business context, client/project truth, architecture notes, runbooks, and narrative source material.
+3. When \`snipara_context_query\` returns \`answer_pack\`, treat it as the first-pass response plan: use its source facts, caveats, source map, and verification checklist before drafting claims.
+4. Use \`snipara_get_chunk\` to load cited source sections returned by reference-based queries before relying on precise wording.
+5. Use \`snipara_code_callers\`, \`snipara_code_imports\`, \`snipara_code_neighbors\`, or \`snipara_code_shortest_path\` for structural code questions.
+6. On paid Context plans, use \`snipara_code_symbol_card\` for agent-ready symbol context and \`snipara_code_impact\` before risky multi-file changes or PR reviews.
+7. Use \`snipara_plan\` or \`snipara_decompose\` only for complex work and only when the hosted server exposes them.
+8. When the LLM has produced a visible multi-phase plan and \`snipara-companion\` is installed, run \`snipara-companion workflow start --goal "<goal>" --plan-file <plan_file>\`, then use \`workflow phase-start\`, \`workflow phase-commit\`, \`workflow resume\`, and \`final-commit\` so compaction cannot lose the next phase. Legacy \`rlm-hook\` commands remain compatible.
+9. Use local file reads, \`rg\`, git commands, and test commands for exact edits, current working-tree state, and verification.
+10. Treat every \`snipara_code_*\` response as indexed context: check its indexed commit SHA, indexing time, included file sample, coverage, freshness warnings, and sync guidance before relying on it. Legacy \`rlm_code_*\` tool IDs return the same payloads.
+11. If \`git status --short\` is dirty, warn that Snipara's indexed code graph may not include local edits; use local reads/tests for exact edits and Snipara for architecture/code graph context.
+12. Use Snipara Sandbox only when sandboxed execution, repeatable validation, or isolated transformations materially help.
+13. If a broad query is slow, retry once with a narrow keyword query before falling back to local search.
+14. End each substantial phase with \`snipara_end_of_task_commit\` or \`snipara-companion workflow phase-commit\` when companion manages the plan. End the whole managed workflow with \`snipara-companion final-commit\`.
+15. Use \`snipara_remember_if_novel\` for one reusable memory while avoiding duplicates, and use \`snipara_remember\` for explicit direct memory writes.
+16. Do not store secrets, tokens, passwords, private keys, raw logs, transient command output, or unreviewed guesses in memory.
 `;
 }
 function buildClaudeMdTemplate(answers) {
@@ -915,13 +970,17 @@ Canonical project context is in \`AGENTS.md\`. This file exists for Claude Code
 Use Snipara Hosted MCP before answering project-specific questions.
 
 - Endpoint: \`${buildHostedMcpEndpoint(answers)}\`
-- Start substantial work with \`rlm_recall\` and a targeted \`rlm_context_query\`.
-- Use \`rlm_context_query\` for source truth and \`rlm_get_chunk\` for exact cited sections.
-- When \`rlm_context_query\` returns \`answer_pack\`, use its facts, caveats, source map, and verification checklist before drafting claims.
-- Use \`rlm_code_callers\`, \`rlm_code_imports\`, \`rlm_code_neighbors\`, or \`rlm_code_shortest_path\` for structural code questions.
-- On paid Context plans, use \`rlm_code_symbol_card\` before editing important symbols and \`rlm_code_impact\` before risky multi-file changes or PR reviews.
-- Use RLM Runtime only when sandboxed execution or repeatable validation materially helps.
-- End substantial work with \`rlm_end_of_task_commit\` when available; use \`rlm_remember_if_novel\` or \`rlm_remember\` only for narrow durable memories.
+- Start substantial work with \`snipara_recall\` and a targeted \`snipara_context_query\`.
+- Use \`snipara_context_query\` for source truth and \`snipara_get_chunk\` for exact cited sections.
+- When \`snipara_context_query\` returns \`answer_pack\`, use its facts, caveats, source map, and verification checklist before drafting claims.
+- Use \`snipara_code_callers\`, \`snipara_code_imports\`, \`snipara_code_neighbors\`, or \`snipara_code_shortest_path\` for structural code questions.
+- On paid Context plans, use \`snipara_code_symbol_card\` before editing important symbols and \`snipara_code_impact\` before risky multi-file changes or PR reviews.
+- Check every \`snipara_code_*\` response for indexed commit SHA, indexing time, included files, coverage, and freshness warnings. Legacy \`rlm_code_*\` IDs return the same payloads.
+- Use local file reads, \`rg\`, \`git status --short\`, and tests for exact edits/current working tree; use Snipara for architecture and indexed code graph context.
+- When the plan is visible and \`snipara-companion\` is installed, use \`snipara-companion workflow start\`, \`phase-start\`, \`phase-commit\`, \`workflow resume\`, and \`final-commit\` to keep phase state durable across compaction. Legacy \`rlm-hook\` commands remain compatible.
+- Use Snipara Sandbox only when sandboxed execution or repeatable validation materially helps.
+- End substantial work with \`snipara_end_of_task_commit\` when available; for managed workflows, end every phase with \`snipara-companion workflow phase-commit\` and the task with \`snipara-companion final-commit\`.
+- Use \`snipara_remember_if_novel\` or \`snipara_remember\` only for narrow durable memories.
 - Do not store secrets, one-off command output, raw logs, or unreviewed guesses in memory.
 - Use the Snipara Claude Code plugin only when slash commands, skills, or hooks are helpful; Hosted MCP remains the normal agent path.
 `;
@@ -938,16 +997,18 @@ This workspace uses Snipara Hosted MCP for current project context, business/cli
 
 - Check the configured Snipara MCP server before answering project-specific questions.
 - Endpoint: \`${buildHostedMcpEndpoint(answers)}\`
-- Use \`rlm_recall\` for durable decisions, preferences, and validated learnings.
-- Use \`rlm_context_query\` for docs, business context, current client/project truth, and narrative source material.
-- When \`rlm_context_query\` returns \`answer_pack\`, use its facts, caveats, source map, and verification checklist before drafting claims.
-- Use \`rlm_get_chunk\` before relying on exact cited wording from reference-based results.
-- Use \`rlm_code_callers\`, \`rlm_code_imports\`, \`rlm_code_neighbors\`, or \`rlm_code_shortest_path\` for structural code questions.
-- On paid Context plans, use \`rlm_code_symbol_card\` before editing important symbols and \`rlm_code_impact\` before risky multi-file changes or PR reviews.
-- Use \`rlm_plan\` or \`rlm_decompose\` only for complex work and only when available.
-- Use local file reads and tests for exact code edits and current working-tree state.
-- Use RLM Runtime only when sandboxed execution or repeatable validation materially helps.
-- End substantial work with \`rlm_end_of_task_commit\` when available; use \`rlm_remember_if_novel\` or \`rlm_remember\` only for narrow durable memories. Never store secrets.
+- Use \`snipara_recall\` for durable decisions, preferences, and validated learnings.
+- Use \`snipara_context_query\` for docs, business context, current client/project truth, and narrative source material.
+- When \`snipara_context_query\` returns \`answer_pack\`, use its facts, caveats, source map, and verification checklist before drafting claims.
+- Use \`snipara_get_chunk\` before relying on exact cited wording from reference-based results.
+- Use \`snipara_code_callers\`, \`snipara_code_imports\`, \`snipara_code_neighbors\`, or \`snipara_code_shortest_path\` for structural code questions.
+- On paid Context plans, use \`snipara_code_symbol_card\` before editing important symbols and \`snipara_code_impact\` before risky multi-file changes or PR reviews.
+- Check every \`snipara_code_*\` response for indexed commit SHA, indexing time, included files, coverage, and freshness warnings. Legacy \`rlm_code_*\` IDs return the same payloads.
+- Use \`snipara_plan\` or \`snipara_decompose\` only for complex work and only when available.
+- Use local file reads, \`rg\`, \`git status --short\`, and tests for exact code edits and current working-tree state.
+- When \`snipara-companion\` is installed and the LLM has a visible multi-phase plan, use \`snipara-companion workflow start\`, \`phase-start\`, \`phase-commit\`, \`workflow resume\`, and \`final-commit\` so the next phase survives compaction. Legacy \`rlm-hook\` commands remain compatible.
+- Use Snipara Sandbox only when sandboxed execution or repeatable validation materially helps.
+- End substantial work with \`snipara_end_of_task_commit\` when available; for managed workflows, end every phase with \`snipara-companion workflow phase-commit\` and the task with \`snipara-companion final-commit\`. Use \`snipara_remember_if_novel\` or \`snipara_remember\` only for narrow durable memories. Never store secrets.
 `;
 }
 function buildCodexConfigTemplate(answers) {
@@ -1012,8 +1073,8 @@ async function createClaudeDesktopConfig(answers) {
       }
     };
     if (answers.installRuntime) {
-      config.mcpServers["rlm-runtime"] = {
-        command: "rlm",
+      config.mcpServers[SANDBOX_SERVER_NAME] = {
+        command: detectSandboxCommand() || SANDBOX_COMMAND_NAME,
         args: ["mcp-serve"],
         env: {
           SNIPARA_API_KEY: answers.apiKey,
@@ -1107,8 +1168,19 @@ set -euo pipefail
 export SNIPARA_PROJECT_SLUG="${answers.projectSlug}"
 ${answers.projectId ? `export SNIPARA_PROJECT_ID="${answers.projectId}"` : ""}
 
-if command -v rlm-hook >/dev/null 2>&1; then
-  rlm-hook session-bootstrap || true
+SNIPARA_COMPANION_BIN=""
+if command -v ${COMPANION_COMMAND_NAME} >/dev/null 2>&1; then
+  SNIPARA_COMPANION_BIN="${COMPANION_COMMAND_NAME}"
+elif command -v ${LEGACY_COMPANION_COMMAND_NAME} >/dev/null 2>&1; then
+  SNIPARA_COMPANION_BIN="${LEGACY_COMPANION_COMMAND_NAME}"
+fi
+
+if [ -n "$SNIPARA_COMPANION_BIN" ]; then
+  if [ -f ".snipara/workflow/current.json" ]; then
+    "$SNIPARA_COMPANION_BIN" workflow resume --include-session-context || true
+  else
+    "$SNIPARA_COMPANION_BIN" session-bootstrap || true
+  fi
 fi
 `;
 }
@@ -1119,8 +1191,15 @@ set -euo pipefail
 export SNIPARA_PROJECT_SLUG="${answers.projectSlug}"
 ${answers.projectId ? `export SNIPARA_PROJECT_ID="${answers.projectId}"` : ""}
 
-if command -v rlm-hook >/dev/null 2>&1; then
-  rlm-hook emit-event --event-type tool_result --json '{"source":"claude-code-hook"}' || true
+SNIPARA_COMPANION_BIN=""
+if command -v ${COMPANION_COMMAND_NAME} >/dev/null 2>&1; then
+  SNIPARA_COMPANION_BIN="${COMPANION_COMMAND_NAME}"
+elif command -v ${LEGACY_COMPANION_COMMAND_NAME} >/dev/null 2>&1; then
+  SNIPARA_COMPANION_BIN="${LEGACY_COMPANION_COMMAND_NAME}"
+fi
+
+if [ -n "$SNIPARA_COMPANION_BIN" ]; then
+  "$SNIPARA_COMPANION_BIN" emit-event --event-type tool_result --json '{"source":"claude-code-hook"}' || true
 fi
 `;
 }
@@ -1131,8 +1210,19 @@ set -euo pipefail
 export SNIPARA_PROJECT_SLUG="${answers.projectSlug}"
 ${answers.projectId ? `export SNIPARA_PROJECT_ID="${answers.projectId}"` : ""}
 
-if command -v rlm-hook >/dev/null 2>&1; then
-  rlm-hook task-commit --summary "Claude Code compacted local session context" --outcome partial || true
+SNIPARA_COMPANION_BIN=""
+if command -v ${COMPANION_COMMAND_NAME} >/dev/null 2>&1; then
+  SNIPARA_COMPANION_BIN="${COMPANION_COMMAND_NAME}"
+elif command -v ${LEGACY_COMPANION_COMMAND_NAME} >/dev/null 2>&1; then
+  SNIPARA_COMPANION_BIN="${LEGACY_COMPANION_COMMAND_NAME}"
+fi
+
+if [ -n "$SNIPARA_COMPANION_BIN" ]; then
+  if [ -f ".snipara/workflow/current.json" ]; then
+    "$SNIPARA_COMPANION_BIN" task-commit --summary "Claude Code compacted while a managed workflow state existed. Resume with snipara-companion workflow resume --include-session-context and continue from .snipara/workflow/current.json." --category workflow-compaction --outcome partial || true
+  else
+    "$SNIPARA_COMPANION_BIN" task-commit --summary "Claude Code compacted local session context" --outcome partial || true
+  fi
 fi
 `;
 }
@@ -1154,7 +1244,7 @@ ${answers.projectId ? `SNIPARA_PROJECT_ID=${answers.projectId}` : ""}
     const llmVarName = answers.llmProvider === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY";
     envVars += `
 
-# RLM-Runtime LLM Provider (for rlm run/agent CLI)
+# Snipara Sandbox LLM Provider (for snipara-sandbox run/agent CLI)
 ${llmVarName}=${answers.llmApiKey}`;
   }
   envVars = envVars.trim();
@@ -1195,7 +1285,7 @@ ${envVars}
 function getClientGuidance(client) {
   if (client === "claude-code") {
     return [
-      "Claude Code can use both the hosted MCP surface and the local rlm-hook companion flows.",
+      "Claude Code can use both the hosted MCP surface and the local snipara-companion flows.",
       "If hooks are enabled, the edge layer forwards lifecycle signals without owning durable memory locally."
     ];
   }
@@ -1230,30 +1320,30 @@ function getClientGuidance(client) {
 }
 function getCompanionCommands(answers) {
   const projectIdFlag = answers.projectId ? ` --project-id ${answers.projectId}` : "";
-  const apiKeyFlag = answers.apiKeyType === "none" || answers.apiKey.includes("YOUR_") ? " --api-key <rlm_key>" : ` --api-key ${answers.apiKey}`;
+  const apiKeyFlag = answers.apiKeyType === "none" || answers.apiKey.includes("YOUR_") ? " --api-key <rlm-key>" : ` --api-key ${answers.apiKey}`;
   const clientFlag = getCompanionInitClientFlag(answers.aiClient);
   const businessOnboardingCommands = answers.installCompanion ? [
     {
       title: "Preview a business folder import",
-      command: "rlm-hook onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json",
+      command: `${COMPANION_COMMAND_NAME} onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json`,
       purpose: "Classify a local or LLM-materialized business folder and review the Snipara sync manifest before upload."
     },
     {
       title: "Apply a business folder import",
-      command: "rlm-hook onboard-folder ./client-export --source-provider local_folder --apply",
+      command: `${COMPANION_COMMAND_NAME} onboard-folder ./client-export --source-provider local_folder --apply`,
       purpose: "Upload approved business-context documents to hosted Snipara and trigger document reindexing."
     }
   ] : [
     {
       title: "Enable business folder onboarding",
       command: "npx create-snipara repair --with-companion",
-      purpose: "Install snipara-companion so this project can run rlm-hook onboard-folder without using the dashboard."
+      purpose: `Install ${COMPANION_PACKAGE_NAME} so this project can run ${COMPANION_COMMAND_NAME} onboard-folder without using the dashboard.`
     }
   ];
   return [
     {
       title: "Bootstrap local companion",
-      command: `rlm-hook init${clientFlag}${projectIdFlag}${apiKeyFlag}`,
+      command: `${COMPANION_COMMAND_NAME} init${clientFlag}${projectIdFlag}${apiKeyFlag}`,
       purpose: "Write local companion config for this workstation."
     },
     {
@@ -1268,44 +1358,69 @@ function getCompanionCommands(answers) {
     },
     {
       title: "Run a focused hosted query",
-      command: 'rlm-hook query --query "how does auth middleware work?" --max-tokens 4000',
+      command: `${COMPANION_COMMAND_NAME} query --query "how does auth middleware work?" --max-tokens 4000`,
       purpose: "Pull ranked source context before editing, reviewing, or drafting."
     },
     {
       title: "Load linked standards only when needed",
-      command: "rlm-hook shared-context --categories MANDATORY BEST_PRACTICES",
+      command: `${COMPANION_COMMAND_NAME} shared-context --categories MANDATORY BEST_PRACTICES`,
       purpose: "Fetch project-linked team or workspace guidance without treating it as memory."
     },
     {
       title: "Generate a hosted plan",
-      command: 'rlm-hook plan --query "Implement webhook retry hardening" --max-tokens 3000',
+      command: `${COMPANION_COMMAND_NAME} plan --query "Implement webhook retry hardening" --max-tokens 3000`,
       purpose: "Produce a structured execution plan against indexed project knowledge."
     },
+    {
+      title: "Start a managed workflow from the visible plan",
+      command: `${COMPANION_COMMAND_NAME} workflow start --goal "Implement webhook retry hardening" --plan-file ./plan.md`,
+      purpose: "Record the LLM-visible plan in .snipara/workflow/current.json so phase state survives compaction."
+    },
+    {
+      title: "Start the current workflow phase",
+      command: `${COMPANION_COMMAND_NAME} workflow phase-start context`,
+      purpose: "Mark a phase active and print the required Snipara context gate for the agent."
+    },
+    {
+      title: "Analyze code impact before a risky change",
+      command: `${COMPANION_COMMAND_NAME} code impact --changed-files src/api/webhooks.ts tests/webhooks.test.ts --diff-summary "webhook retry hardening"`,
+      purpose: "Use paid Context code impact analysis to surface likely tests, docs, routes, config, and risks."
+    },
     {
       title: "Upload or refresh a doc",
-      command: "rlm-hook upload --path docs/local-playbook.md --file ./docs/local-playbook.md",
+      command: `${COMPANION_COMMAND_NAME} upload --path docs/local-playbook.md --file ./docs/local-playbook.md`,
       purpose: "Push local notes or docs into hosted Snipara context."
     },
     ...businessOnboardingCommands,
     {
       title: "Inspect a specific chunk",
-      command: "rlm-hook chunk get --chunk-id <chunk_id>",
+      command: `${COMPANION_COMMAND_NAME} chunk get --chunk-id <chunk_id>`,
       purpose: "Open an exact chunk returned by references-based search."
     },
     {
       title: "Bootstrap the session memory view",
-      command: "rlm-hook session-bootstrap",
+      command: `${COMPANION_COMMAND_NAME} session-bootstrap`,
       purpose: "Load durable decisions, learnings, and optional short-lived carryover at session start."
     },
     {
       title: "Ask memory about past decisions",
-      command: 'rlm-hook recall --query "What did we decide about auth retries?" --type decision',
+      command: `${COMPANION_COMMAND_NAME} recall --query "What did we decide about auth retries?" --type decision`,
       purpose: "Query durable memory for past decisions, preferences, or validated learnings."
     },
     {
       title: "Commit durable task memory",
-      command: 'rlm-hook task-commit --summary "Hardened webhook retries and updated tests" --category engineering --outcome completed --files src/api/webhooks.ts tests/webhooks.test.ts',
+      command: `${COMPANION_COMMAND_NAME} task-commit --summary "Hardened webhook retries and updated tests" --category engineering --outcome completed --files src/api/webhooks.ts tests/webhooks.test.ts`,
       purpose: "Persist reusable outcomes back into hosted memory after the work is done."
+    },
+    {
+      title: "Commit a managed workflow phase",
+      command: `${COMPANION_COMMAND_NAME} workflow phase-commit context --summary "Loaded context and mapped impacted files" --files src/api/webhooks.ts tests/webhooks.test.ts`,
+      purpose: "Persist this phase through hosted memory and advance the local managed workflow state."
+    },
+    {
+      title: "Commit the final managed workflow result",
+      command: `${COMPANION_COMMAND_NAME} final-commit --summary "Shipped webhook retry hardening and tests" --files src/api/webhooks.ts tests/webhooks.test.ts`,
+      purpose: "Persist the final workflow outcome and close the managed workflow after verification."
     }
   ];
 }
@@ -1318,7 +1433,7 @@ async function createCompanionPack(answers) {
   fs.mkdirSync(packDir, { recursive: true });
   const readme = `# Snipara Companion Pack
 
-This project uses Snipara as a hosted-first context and memory layer with an optional local companion CLI.
+This project uses Snipara as a hosted-first context and memory layer with local companion workflow helpers.
 
 ## Install Profile
 
@@ -1329,7 +1444,7 @@ This project uses Snipara as a hosted-first context and memory layer with an opt
 - Installed local companion: \`${answers.installCompanion ? "yes" : "no"}\`
 - Generated hosted MCP config: \`${answers.profile !== "runtime-only" ? "yes" : "no"}\`
 - Installed local snipara-mcp package: \`${answers.installMcp ? "yes" : "no"}\`
-- Installed runtime: \`${answers.installRuntime ? "yes" : "no"}\`
+- Installed Snipara Sandbox: \`${answers.installRuntime ? "yes" : "no"}\`
 - Generated hooks: \`${answers.installHooks ? "yes" : "no"}\`
 
 ## Local Detection Snapshot
@@ -1338,7 +1453,7 @@ This project uses Snipara as a hosted-first context and memory layer with an opt
 - .mcp.json present: \`${detection.files.mcpConfig ? "yes" : "no"}\`
 - .env.local present: \`${detection.files.envLocal ? "yes" : "no"}\`
 - Companion CLI on PATH: \`${detection.tooling.companionCli ? "yes" : "no"}\`
-- Runtime CLI on PATH: \`${detection.tooling.runtimeCli ? "yes" : "no"}\`
+- Snipara Sandbox CLI on PATH: \`${detection.tooling.runtimeCli ? "yes" : "no"}\`
 
 ## Client Guidance
 
@@ -1350,11 +1465,11 @@ Use this when Claude, ChatGPT, Codex, or another LLM client has already material
 
 ${answers.installCompanion ? `Preview first:
 
-\`rlm-hook onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json\`
+\`${COMPANION_COMMAND_NAME} onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json\`
 
 Apply only after reviewing the manifest:
 
-\`rlm-hook onboard-folder ./client-export --source-provider local_folder --apply\`` : `This setup did not install snipara-companion. Enable it before business folder imports:
+\`${COMPANION_COMMAND_NAME} onboard-folder ./client-export --source-provider local_folder --apply\`` : `This setup did not install snipara-companion. Enable it before business folder imports:
 
 \`npx create-snipara repair --with-companion\``}
 
@@ -1384,6 +1499,7 @@ ${item.purpose}`
 
 - Context first: use hosted queries, shared-context, and document loads for source truth.
 - Memory second: use session bootstrap and task commit for durable decisions, learnings, and preferences.
+- Managed workflow when a visible plan exists: \`workflow start\`, \`phase-start\`, \`phase-commit\`, \`workflow resume\`, and \`final-commit\` keep phase state durable across compaction.
 - Durable memory, policy, and orchestration stay hosted in Snipara.
 - The local companion is optional tooling for capture, bootstrap, upload, exploration, doctor, repair, and explicit task summaries.
 `;
@@ -1405,30 +1521,36 @@ ${item.purpose}`
   console.log(chalk.green("   \u2713 Created .snipara/companion/README.md"));
   console.log(chalk.green("   \u2713 Created .snipara/companion/commands.json"));
 }
-async function runRlmInit() {
-  console.log(chalk.bold("\n\u{1F527} Running RLM-Runtime Configuration\n"));
+async function runSandboxInit() {
+  const sandboxCommand = detectSandboxCommand() || SANDBOX_COMMAND_NAME;
+  console.log(chalk.bold("\n\u{1F527} Running Snipara Sandbox Configuration\n"));
   console.log(
-    chalk.dim("   Starting 'rlm init' - follow the prompts to configure execution environment...\n")
+    chalk.dim(
+      `   Starting '${sandboxCommand} init' - follow the prompts to configure execution environment...
+`
+    )
   );
   return new Promise((resolve) => {
-    const child = spawn("rlm", ["init"], {
+    const child = spawn(sandboxCommand, ["init"], {
       stdio: "inherit",
       shell: true
     });
     child.on("close", (code) => {
       if (code === 0) {
-        console.log(chalk.green("\n   \u2713 RLM-Runtime configured successfully"));
+        console.log(chalk.green("\n   \u2713 Snipara Sandbox configured successfully"));
       } else if (code !== null) {
         console.log(chalk.yellow(`
-   \u26A0\uFE0F  rlm init exited with code ${code}`));
-        console.log(chalk.dim("   You can run 'rlm init' manually later."));
+   \u26A0\uFE0F  ${sandboxCommand} init exited with code ${code}`));
+        console.log(chalk.dim(`   You can run '${sandboxCommand} init' manually later.`));
       }
       resolve();
     });
     child.on("error", (error) => {
       console.log(chalk.yellow(`
-   \u26A0\uFE0F  Could not run rlm init: ${error.message}`));
-      console.log(chalk.dim("   Run 'rlm init' manually after installation completes."));
+   \u26A0\uFE0F  Could not run ${sandboxCommand} init: ${error.message}`));
+      console.log(
+        chalk.dim(`   Run '${SANDBOX_COMMAND_NAME} init' manually after installation completes.`)
+      );
       resolve();
     });
   });
@@ -1483,9 +1605,9 @@ async function runValidation(answers, includeHostedCheck) {
     detail: answers.installCompanion && !detection.tooling.companionCli ? `${COMPANION_PACKAGE_NAME} not found on PATH` : "Companion CLI ready or not requested"
   });
   checks.push({
-    name: "runtime_cli",
+    name: "sandbox_cli",
     status: answers.installRuntime ? detection.tooling.runtimeCli ? "pass" : "warn" : "pass",
-    detail: answers.installRuntime && !detection.tooling.runtimeCli ? "rlm CLI not found on PATH" : "Runtime CLI ready or not requested"
+    detail: answers.installRuntime && !detection.tooling.runtimeCli ? `${SANDBOX_COMMAND_NAME} CLI not found on PATH` : "Snipara Sandbox CLI ready or not requested"
   });
   checks.push({
     name: "companion_pack",
@@ -1581,14 +1703,14 @@ async function testHostedConnection(answers) {
       }
     ];
     const settingsResponse = await callHostedMcp(answers, "tools/call", {
-      name: "rlm_settings",
+      name: "snipara_settings",
       arguments: {}
     });
     if (settingsResponse.ok && !settingsResponse.data.error) {
       checks.push({
         name: "hosted_settings",
         status: "pass",
-        detail: "rlm_settings tool call succeeded"
+        detail: "snipara_settings tool call succeeded"
       });
     } else {
       checks.push({
@@ -1640,7 +1762,7 @@ async function callHostedMcp(answers, method, params) {
 function describeHostedHttpFailure(status, bodyText) {
   const detail = bodyText.trim().slice(0, 120);
   if (status === 401 || status === 403) {
-    return `Auth failed (${status}). Check the project/team API key and project slug.`;
+    return `Auth failed (${status}). Check the API key and project slug.`;
   }
   if (status === 404) {
     return "Endpoint or project slug was not found. Check the hosted MCP URL.";
@@ -1679,7 +1801,9 @@ function printSuccess(answers, report) {
     );
   }
   if (answers.installRuntime) {
-    console.log(chalk.green("   \u2713 rlm-runtime") + chalk.dim(" - Safe code execution"));
+    console.log(
+      chalk.green(`   \u2713 ${stripExtras(SANDBOX_PACKAGE_NAME)}`) + chalk.dim(" - Safe code execution")
+    );
   }
   if (answers.installCompanion) {
     console.log(
@@ -1710,20 +1834,27 @@ function printSuccess(answers, report) {
   printNextStep("Open .snipara/companion/README.md for local commands and repair flow.");
   printNextStep("Run create-snipara doctor anytime you want a fresh local validation report.");
   if (answers.installCompanion) {
-    printNextStep("Use rlm-hook query / plan / upload / task-commit for explicit local workflows.");
     printNextStep(
-      "For business folders, preview with: rlm-hook onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json"
+      `${COMPANION_COMMAND_NAME} is the primary companion command; legacy ${LEGACY_COMPANION_COMMAND_NAME} remains compatible.`
     );
     printNextStep(
-      "Apply after review with: rlm-hook onboard-folder ./client-export --source-provider local_folder --apply"
+      `Use ${COMPANION_COMMAND_NAME} query / plan / upload / task-commit for explicit local workflows.`
+    );
+    printNextStep(
+      `For business folders, preview with: ${COMPANION_COMMAND_NAME} onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json`
+    );
+    printNextStep(
+      `Apply after review with: ${COMPANION_COMMAND_NAME} onboard-folder ./client-export --source-provider local_folder --apply`
     );
   } else if (answers.profile !== "runtime-only") {
     printNextStep(
       "For dashboardless business folder imports, enable companion with: npx create-snipara repair --with-companion"
     );
   }
-  if (answers.installRuntime && !answers.runRlmInit) {
-    printNextStep("Run rlm init when you want to choose sandbox/docker/local execution.");
+  if (answers.installRuntime && !answers.runSandboxInit) {
+    printNextStep(
+      `Run ${SANDBOX_COMMAND_NAME} init when you want to choose sandbox/docker/local execution.`
+    );
   }
   if (answers.githubRepo) {
     printNextStep(
@@ -1749,11 +1880,11 @@ function printSuccess(answers, report) {
 }
 function commandExists(command) {
   try {
-    execSync(`${command} --version`, { stdio: "ignore", shell: "/bin/sh" });
+    execSync(`${command} --version`, { stdio: "ignore", shell: "/bin/sh", timeout: 2500 });
     return true;
   } catch {
     try {
-      execSync(`command -v ${command}`, { stdio: "ignore", shell: "/bin/sh" });
+      execSync(`command -v ${command}`, { stdio: "ignore", shell: "/bin/sh", timeout: 1e3 });
       return true;
     } catch {
       return false;
@@ -1790,8 +1921,8 @@ function detectEnvironment() {
       uv: commandExists("uv"),
       docker: commandExists("docker"),
       git: commandExists("git"),
-      companionCli: commandExists("rlm-hook"),
-      runtimeCli: commandExists("rlm")
+      companionCli: Boolean(detectCompanionCommand()),
+      runtimeCli: Boolean(detectSandboxCommand())
     },
     existingConfig: {
       slug: existingConfig?.slug,
@@ -1804,8 +1935,13 @@ function detectEnvironment() {
 function loadExistingAnswers(options) {
   const detection = detectEnvironment();
   const effectiveProfile = resolveMaintenanceProfile(detection, options.profile);
-  const apiKey = options.teamKey || options.apiKey || readApiKeyFromEnvFiles() || "YOUR_API_KEY_HERE";
-  const apiKeyType = options.teamKey ? "team" : options.apiKey || readApiKeyFromEnvFiles() ? "project" : effectiveProfile === "runtime-only" ? "none" : "none";
+  const providedApiKey = options.apiKey?.trim();
+  if (providedApiKey && !isManualApiKey(providedApiKey)) {
+    throw new Error(manualApiKeyValidationMessage());
+  }
+  const envApiKey = readApiKeyFromEnvFiles();
+  const apiKey = providedApiKey || envApiKey || "YOUR_API_KEY_HERE";
+  const apiKeyType = effectiveProfile === "runtime-only" ? "none" : providedApiKey || envApiKey ? "api" : "none";
   return buildAnswersFromProfile({
     projectSlug: options.slug || detection.existingConfig.slug || detection.projectSlug || "my-project",
     projectId: options.projectId || detection.existingConfig.projectId || "",
@@ -1832,7 +1968,7 @@ function resolveMaintenanceProfile(detection, explicitProfile) {
   if (detection.existingConfig.hasSniparaServer) {
     return "hosted-only";
   }
-  return "hosted-only";
+  return "hosted-companion";
 }
 function readApiKeyFromEnvFiles() {
   const candidates = [".env.local", ".env"];
@@ -1952,7 +2088,7 @@ function getExistingConfig() {
   try {
     const config = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
     const sniparaServer = config.mcpServers?.snipara;
-    const runtimeServer = config.mcpServers?.["rlm-runtime"];
+    const runtimeServer = config.mcpServers?.[SANDBOX_SERVER_NAME] || config.mcpServers?.[LEGACY_RUNTIME_SERVER_NAME];
     const match = sniparaServer?.url?.match(/\/mcp\/([^/]+)$/);
     return {
       slug: match?.[1],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-snipara",
-  "version": "1.3.9",
-  "description": "Onboard Snipara Hosted MCP Context + Memory with auth plus optional local helper and runtime workflows",
+  "version": "1.3.12",
+  "description": "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "snipara",
     "create-snipara",
     "mcp",
-    "rlm-runtime",
+    "snipara-sandbox",
     "context-optimization",
     "llm",
     "ai-agents",