create-snipara 2.0.6 → 2.0.8

package/README.md

@@ -12,8 +12,8 @@ npx create-snipara
 
 `create-snipara` is the simple onboarding package for the agent path. It
 creates or reuses auth, writes Hosted MCP config, and prepares the local project
-so an LLM client can use Snipara context and reviewed memory. Install once with
-`create-snipara`; continue every session with `snipara-companion`.
+so an LLM client can use Snipara context and reviewed memory. The default path is
+hosted-only so the first success is a grounded answer, not a local tooling tour.
 
 Use it when the goal is outcome-first agent work: the user asks for judgment,
 implementation, release, or verification, and the agent handles Snipara context,
@@ -54,7 +54,7 @@ The product surfaces remain:
 - Hosted MCP for LLM agents, context, and reviewed memory
 - HTTP API / SDK for apps, integrators, backends, and pipelines
 
-The default CLI path wires the local companion around those surfaces:
+Advanced flags can wire local helpers around those surfaces:
 
 - `snipara-companion` for Git-style status, briefs, timelines, phase commits,
   handoffs, resume, and local workflow commands
@@ -69,12 +69,12 @@ The CLI now works around explicit install profiles:
 
 | 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                                                                                 |
+| `hosted-only`      | Hosted MCP config only                        | Default: first grounded answer with no local companion, hooks, or sandbox                                           |
+| `hosted-companion` | MCP + `snipara-companion`                     | Hosted context plus managed local workflow after first value                                                        |
 | `full-stack`       | MCP + `snipara-companion` + `snipara-sandbox` | Hosted context plus sandboxed local execution. Does not include orchestrator unless `--with-orchestrator` is passed |
 | `runtime-only`     | `snipara-sandbox` only                        | Local execution without hosted API                                                                                  |
 
-Default profile: `hosted-companion`
+Default profile: `hosted-only`
 
 ## Free Account Fit
 
@@ -107,10 +107,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
-- activates the current folder locally through `snipara-companion source init` so docs and code overlay context are available before GitHub approval
+- can activate the current folder locally through `snipara-companion source init` after the user opts into Companion
 - explains the GitHub PR Answer Packs path for AI-assisted pull request workflows
-- installs `snipara-companion` by default for local status, briefs, timelines,
-  phase commits, handoffs, resume, and managed workflows
+- installs `snipara-companion` only with `--advanced`, `--profile hosted-companion`,
+  `--profile full-stack`, or `repair --with-companion`
 - installs optional `snipara-sandbox`
 - installs optional `snipara-orchestrator` for proof gates, drift checks, and htask workflows when requested
 - configures `.mcp.json`
@@ -118,8 +118,8 @@ That distinction matters:
 - creates `AGENTS.md` and `CLAUDE.md` when missing, or appends a marked Snipara section when those files already exist
 - creates `.cursor/rules/snipara.mdc` and `.codex/config.toml` when those files do not already exist
 - validates Codex config against Hosted MCP plus `bearer_token_env_var = "SNIPARA_API_KEY"` and tells users to restart Codex after MCP config changes
-- installs local code overlay Git hooks by default for Claude Code and Codex
-  companion setups, unless `--skip-hooks` is passed
+- installs local code overlay Git hooks only for explicit companion/full-stack
+  setups unless `--skip-hooks` is passed
 - runs a real hosted MCP `tools/list` check and warns if the server still advertises legacy `rlm_*` duplicate tools
 - generates Mistral Le Chat, Mistral Vibe, and LangChain `ChatMistralAI.bindTools` references without embedding secrets
 - writes client-specific companion packs such as `.snipara/companion/CODEX.md` or `.snipara/companion/GEMINI.md`
@@ -155,9 +155,10 @@ The interactive flow now asks for:
 - API key path: existing API key, free signup, or add key later
 - AI client
 
-By default, this uses the recommended `hosted-companion` setup: hosted MCP plus
-the local `snipara-companion` workflow helper. Add `--advanced` when you want profile selection, project id entry,
-hook prompts, GitHub automation prompts, or sandbox provider prompts.
+By default, this uses the minimal `hosted-only` setup: hosted MCP config and a
+doctor report, with no local Companion install, hooks, GitHub approval prompt, or
+sandbox prompt. Add `--advanced` when you want profile selection, project id
+entry, hook prompts, GitHub automation prompts, or sandbox provider prompts.
 Use `--with-orchestrator` only when you explicitly need the advanced production
 validation and htask package; it is not part of `full-stack` by default.
 
@@ -204,6 +205,12 @@ compaction-safe managed workflow and Git-style agent work commands. Keep the
 machine plan in JSON for stable phase ids; an optional Markdown file can remain
 the human-facing contract.
 
+Enable those local helpers later with:
+
+```bash
+npx create-snipara repair --with-companion
+```
+
 ```bash
 snipara-companion status
 snipara-companion source init .

package/dist/index.js

@@ -13,7 +13,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "create-snipara",
-  version: "2.0.6",
+  version: "2.0.8",
   description: "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   main: "dist/index.js",
   type: "module",
@@ -115,6 +115,409 @@ deployment, and production smoke checks behind the scenes. Surface important
 decisions, blockers, and evidence, but do not make the user manually orchestrate
 routine Snipara or release mechanics.`;
 var UNIVERSAL_CLIENT_GUIDANCE = "The target experience is outcome-first: the user can ask for engineering judgment or a release, and the agent should use Snipara context, workflow state, verification, package checks, Git, deploy, and smoke checks without making the user orchestrate routine mechanics.";
+function buildActivationId() {
+  return `act_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function getActivationDir() {
+  return path.join(process.cwd(), ".snipara", "activation");
+}
+function getActivationManifestPath() {
+  return path.join(getActivationDir(), "manifest.json");
+}
+function getActivationHandoffPath() {
+  return path.join(getActivationDir(), "handoff.md");
+}
+function getMemoryCandidatesPath() {
+  return path.join(getActivationDir(), "memory-candidates.json");
+}
+function writeActivationManifest(manifest) {
+  fs.mkdirSync(getActivationDir(), { recursive: true });
+  fs.writeFileSync(getActivationManifestPath(), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+}
+function updateActivationManifest(manifest) {
+  manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeActivationManifest(manifest);
+}
+function createActivationLane(status, detail, command) {
+  return command ? { status, detail, command } : { status, detail };
+}
+function failActivationLane(detail, command, error) {
+  const message = error instanceof Error && error.message ? error.message : "unknown error";
+  return {
+    status: "failed",
+    detail,
+    command,
+    error: message.slice(0, 500)
+  };
+}
+function readPackageJsonScripts() {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return Object.keys(parsed.scripts ?? {}).sort();
+  } catch {
+    return [];
+  }
+}
+function readGitRemote() {
+  try {
+    const remote = execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 500
+    }).trim();
+    return remote || null;
+  } catch {
+    return null;
+  }
+}
+function readGitStatusPorcelain() {
+  try {
+    const output = execSync("git status --short", {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    }).trim();
+    return output ? output.split(/\r?\n/).slice(0, 25) : [];
+  } catch {
+    return [];
+  }
+}
+function readRecentCommitSubjects() {
+  try {
+    const output = execSync("git log --oneline --max-count=5", {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    }).trim();
+    return output ? output.split(/\r?\n/) : [];
+  } catch {
+    return [];
+  }
+}
+function readMemoryCandidateLines(relativePath) {
+  const absolutePath = path.join(process.cwd(), relativePath);
+  if (!fs.existsSync(absolutePath) || fs.statSync(absolutePath).isDirectory()) {
+    return [];
+  }
+  const content = fs.readFileSync(absolutePath, "utf8").slice(0, 24e3);
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => /decision|decided|must|should|always|never|convention|rule/i.test(line)).slice(0, 3);
+}
+function buildMemoryCandidatePreviews(scan) {
+  return scan.files.candidateDocs.flatMap(
+    (source) => readMemoryCandidateLines(source).map((line) => ({
+      source,
+      text: line.slice(0, 280),
+      status: "needs_review",
+      reason: "Detected project guidance language. Review before storing as durable memory."
+    }))
+  ).slice(0, 12);
+}
+function writeMemoryCandidates(candidates) {
+  fs.mkdirSync(getActivationDir(), { recursive: true });
+  fs.writeFileSync(
+    getMemoryCandidatesPath(),
+    JSON.stringify({ candidates, note: "Review required before durable memory import." }, null, 2) + "\n",
+    "utf8"
+  );
+}
+function writeInitialHandoff(answers, manifest) {
+  fs.mkdirSync(getActivationDir(), { recursive: true });
+  const statusLines = readGitStatusPorcelain();
+  const recentCommits = readRecentCommitSubjects();
+  const lines = [
+    `# Initial Snipara Handoff`,
+    "",
+    `Project: ${answers.projectSlug}`,
+    `AI client: ${getClientDisplayName(answers.aiClient)}`,
+    `Repo path: ${manifest.repoPath}`,
+    `Git branch: ${manifest.git.branch ?? "not detected"}`,
+    `Git remote: ${manifest.git.remote ?? "not detected"}`,
+    "",
+    "## Activation lanes",
+    ...Object.entries(manifest.lanes).map(
+      ([name, lane]) => `- ${name}: ${lane.status} - ${lane.detail}`
+    ),
+    "",
+    "## Local status",
+    ...statusLines.length > 0 ? statusLines.map((line) => `- ${line}`) : ["- clean or unavailable"],
+    "",
+    "## Recent commits",
+    ...recentCommits.length > 0 ? recentCommits.map((line) => `- ${line}`) : ["- not available"],
+    "",
+    "## Next",
+    "- Ask the coding agent what it should know before editing the first target area.",
+    "- Review memory candidates before accepting durable memory.",
+    "- Connect GitHub later for PRs, reviews, team sync, and continuous sync.",
+    ""
+  ];
+  fs.writeFileSync(getActivationHandoffPath(), lines.join("\n"), "utf8");
+}
+function detectLocalActivationScan(detection) {
+  const cwd = process.cwd();
+  const exists = (relativePath) => fs.existsSync(path.join(cwd, relativePath));
+  const candidateDocs = [
+    "README.md",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "CHANGELOG.md",
+    "docs",
+    ".cursor/rules",
+    ".github"
+  ].filter(exists);
+  const lockfiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"].filter(
+    exists
+  );
+  const packageManagers = [
+    exists("pnpm-lock.yaml") ? "pnpm" : null,
+    exists("package-lock.json") ? "npm" : null,
+    exists("yarn.lock") ? "yarn" : null,
+    exists("bun.lockb") ? "bun" : null
+  ].filter((value) => Boolean(value));
+  const rootEntries = fs.existsSync(cwd) ? fs.readdirSync(cwd).slice(0, 250) : [];
+  const rootExtensions = new Set(
+    rootEntries.map((entry) => path.extname(entry).replace(/^\./, "")).filter(Boolean)
+  );
+  const languages = [
+    exists("package.json") || rootExtensions.has("ts") || rootExtensions.has("tsx") ? "typescript" : null,
+    exists("package.json") || rootExtensions.has("js") || rootExtensions.has("jsx") ? "javascript" : null,
+    exists("pyproject.toml") || exists("requirements.txt") || rootExtensions.has("py") ? "python" : null,
+    exists("go.mod") || rootExtensions.has("go") ? "go" : null,
+    exists("Cargo.toml") || rootExtensions.has("rs") ? "rust" : null
+  ].filter((value) => Boolean(value));
+  return {
+    files: {
+      candidateDocs,
+      lockfiles,
+      hasPackageJson: exists("package.json"),
+      hasPyproject: exists("pyproject.toml"),
+      hasRequirements: exists("requirements.txt"),
+      hasDockerfile: exists("Dockerfile")
+    },
+    packageManagers,
+    languages: [...new Set(languages)],
+    scripts: readPackageJsonScripts(),
+    git: {
+      detected: detection.inGitRepo,
+      branch: detection.inGitRepo ? detectGitBranch() : null,
+      remote: detection.inGitRepo ? readGitRemote() : null
+    }
+  };
+}
+function createInitialFirstWorkBrief(answers, detection, scan) {
+  const githubLine = answers.githubRepo ? `GitHub detected: ${answers.githubRepo.fullName}` : "No GitHub integration required for first value.";
+  const commands = scan.scripts.length > 0 ? scan.scripts.join(", ") : "no package scripts detected";
+  const docs = scan.files.candidateDocs.length > 0 ? scan.files.candidateDocs.join(", ") : "no standard docs detected";
+  const languages = scan.languages.length > 0 ? scan.languages.join(", ") : "not detected yet";
+  return {
+    title: `First Work Brief for ${answers.projectSlug}`,
+    status: "partial",
+    sections: [
+      {
+        title: "Repository summary",
+        lines: [
+          detection.inGitRepo ? "Local Git repository detected." : "Local folder detected.",
+          githubLine,
+          `AI client: ${getClientDisplayName(answers.aiClient)}.`,
+          `Languages: ${languages}.`
+        ]
+      },
+      {
+        title: "Current architecture",
+        lines: [
+          `Initial docs: ${docs}.`,
+          `Package scripts: ${commands}.`,
+          "Source indexing runs before claiming architecture certainty."
+        ]
+      },
+      {
+        title: "Current risks",
+        lines: [
+          "Treat generated memory as candidates until reviewed.",
+          "GitHub PR/review intelligence requires explicit GitHub connection later."
+        ]
+      },
+      {
+        title: "Suggested next task",
+        lines: ["Ask your agent what it should know before editing the first target area."]
+      },
+      {
+        title: "Top impacted modules",
+        lines: [
+          "Code Graph is indexing; impacted modules will improve as symbols are available.",
+          "Use the activation dashboard or companion code impact once indexing reports ready."
+        ]
+      }
+    ]
+  };
+}
+function createActivationManifest(answers, detection, mode = "default") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const hasHostedConfig = answers.profile !== "runtime-only";
+  const hasCompanion = answers.installCompanion;
+  const localScan = detectLocalActivationScan(detection);
+  return {
+    version: "create-snipara-activation-v1",
+    activationId: buildActivationId(),
+    mode,
+    projectSlug: answers.projectSlug,
+    projectId: answers.projectId || null,
+    repoPath: process.cwd(),
+    aiClient: answers.aiClient,
+    git: {
+      detected: detection.inGitRepo,
+      branch: answers.githubRepo?.branch ?? localScan.git.branch,
+      remote: answers.githubRepo?.remoteUrl ?? localScan.git.remote,
+      githubRepo: answers.githubRepo?.fullName ?? null
+    },
+    localScan,
+    lanes: {
+      connection: createActivationLane(
+        hasHostedConfig ? "ready" : "skipped",
+        hasHostedConfig ? "Hosted MCP config written." : "Runtime-only profile skipped Hosted MCP config."
+      ),
+      clientConfig: createActivationLane(
+        hasHostedConfig ? "ready" : "skipped",
+        hasHostedConfig ? `${getClientDisplayName(answers.aiClient)} project files generated.` : "No AI client config generated for runtime-only profile."
+      ),
+      localSnapshot: createActivationLane(
+        hasCompanion ? "queued" : "skipped",
+        hasCompanion ? "Local source activation will create a repository snapshot." : "Install companion later to activate local source context."
+      ),
+      contextIndex: createActivationLane(
+        hasCompanion ? "queued" : "skipped",
+        hasCompanion ? "Context indexing starts from local docs and instruction files." : "Context indexing requires companion or hosted provider sync."
+      ),
+      codeGraph: createActivationLane(
+        hasCompanion ? "queued" : "skipped",
+        hasCompanion ? "Code Graph indexing starts from local source overlay." : "Code Graph indexing requires companion or hosted provider sync."
+      ),
+      memoryCandidates: createActivationLane(
+        hasCompanion ? "needs_review" : "skipped",
+        hasCompanion ? "Candidate decisions stay pending review; no durable memory is auto-approved." : "Install companion later to extract reviewable memory candidates."
+      ),
+      handoff: createActivationLane(
+        hasCompanion ? "queued" : "skipped",
+        hasCompanion ? "Initial local handoff will summarize branch, files, and setup state." : "Install companion later to create local handoffs."
+      ),
+      firstBrief: createActivationLane(
+        "ready",
+        "First Work Brief preview generated from local setup signals."
+      ),
+      githubSync: createActivationLane(
+        answers.configureGitHub && answers.githubRepo ? "queued" : "skipped",
+        answers.configureGitHub && answers.githubRepo ? "GitHub automation can be connected after explicit approval." : "No GitHub integration required; connect later for PRs, reviews, and team sync."
+      )
+    },
+    artifacts: {
+      handoffPath: null,
+      memoryCandidatesPath: null
+    },
+    firstBrief: createInitialFirstWorkBrief(answers, detection, localScan),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function runLocalSourceActivation(answers, manifest) {
+  if (!answers.installCompanion || answers.profile === "runtime-only") {
+    updateActivationManifest(manifest);
+    return;
+  }
+  const companionCommand = detectCompanionCommand();
+  if (!companionCommand) {
+    const detail = `${COMPANION_COMMAND_NAME} ${MIN_COMPANION_VERSION}+ is not on PATH after setup.`;
+    manifest.lanes.localSnapshot = createActivationLane("skipped", detail);
+    manifest.lanes.contextIndex = createActivationLane("skipped", detail);
+    manifest.lanes.codeGraph = createActivationLane("skipped", detail);
+    updateActivationManifest(manifest);
+    return;
+  }
+  const initCommand = `${companionCommand} source init .`;
+  const syncCommand = `${companionCommand} source sync --json`;
+  const spinner = ora("Activating local Project Intelligence").start();
+  try {
+    execSync(initCommand, {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 3e4
+    });
+    manifest.lanes.localSnapshot = createActivationLane(
+      "ready",
+      "Local source snapshot created.",
+      initCommand
+    );
+  } catch (error) {
+    spinner.warn("Local source snapshot was not created");
+    manifest.lanes.localSnapshot = failActivationLane(
+      "Local source activation failed; setup can still continue.",
+      initCommand,
+      error
+    );
+    updateActivationManifest(manifest);
+    return;
+  }
+  try {
+    execSync(syncCommand, {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 45e3
+    });
+    manifest.lanes.contextIndex = createActivationLane(
+      "indexing",
+      "Local documents submitted for context indexing.",
+      syncCommand
+    );
+    manifest.lanes.codeGraph = createActivationLane(
+      "indexing",
+      "Local code overlay submitted for Code Graph indexing.",
+      syncCommand
+    );
+    spinner.succeed("Local Project Intelligence activation started");
+  } catch (error) {
+    spinner.warn("Local source sync did not complete");
+    manifest.lanes.contextIndex = failActivationLane(
+      "Context indexing could not be started from the local snapshot.",
+      syncCommand,
+      error
+    );
+    manifest.lanes.codeGraph = failActivationLane(
+      "Code Graph indexing could not be started from the local snapshot.",
+      syncCommand,
+      error
+    );
+  }
+  updateActivationManifest(manifest);
+}
+function createActivationArtifacts(answers, manifest) {
+  const candidates = buildMemoryCandidatePreviews(manifest.localScan);
+  writeMemoryCandidates(candidates);
+  manifest.artifacts.memoryCandidatesPath = path.relative(process.cwd(), getMemoryCandidatesPath());
+  manifest.lanes.memoryCandidates = createActivationLane(
+    candidates.length > 0 ? "needs_review" : "skipped",
+    candidates.length > 0 ? `${candidates.length} memory candidates prepared for review; none were imported.` : "No memory candidates found in local docs.",
+    manifest.artifacts.memoryCandidatesPath
+  );
+  writeInitialHandoff(answers, manifest);
+  manifest.artifacts.handoffPath = path.relative(process.cwd(), getActivationHandoffPath());
+  manifest.lanes.handoff = createActivationLane(
+    "ready",
+    "Initial local handoff created.",
+    manifest.artifacts.handoffPath
+  );
+  manifest.lanes.firstBrief = createActivationLane(
+    "ready",
+    "First Work Brief generated from local setup and scan signals.",
+    path.relative(process.cwd(), getActivationManifestPath())
+  );
+  updateActivationManifest(manifest);
+}
 var DeviceAuthorizationAborted = class extends Error {
 };
 var AI_CLIENT_CHOICES = [
@@ -197,14 +600,14 @@ function shouldInstallDefaultHooks(aiClient) {
 }
 function buildProgram() {
   const program = new Command();
-  program.name("create-snipara").description("Scaffold hosted Snipara MCP config plus companion workflow helpers").version(VERSION);
+  program.name("create-snipara").description("Scaffold hosted Snipara MCP config; advanced flags add local 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(
     "--client <client>",
     "AI client: claude-code, cursor, windsurf, codex, gemini, mistral, chatgpt, vscode, continue, claude-desktop, other"
   ).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 snipara-sandbox installation").option("--skip-hooks", "Skip hook generation").option("--skip-test", "Skip hosted connection test").option("--with-orchestrator", "Install optional snipara-orchestrator package").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").addOption(new Option("--full", "Legacy alias for --profile full-stack").hideHelp()).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("--with-orchestrator", "Install optional snipara-orchestrator package").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("--starter", "Mark this run as a starter activation and print dashboard-first guidance").option("--runtime-only", "Install only Snipara Sandbox").addOption(new Option("--full", "Legacy alias for --profile full-stack").hideHelp()).option("-y, --yes", "Accept defaults without prompting").action(async (options) => {
     printBanner();
     await runInit(options);
   });
@@ -219,6 +622,10 @@ function buildProgram() {
     printBanner();
     await runRepair(options);
   });
+  program.command("demo").description("Open the guided Snipara activation demo without changing this repository").option("--no-open", "Print demo links without opening a browser").action((options) => {
+    printBanner();
+    runDemo(options);
+  });
   program.command("upgrade").description("Upgrade installed Snipara local components").option("--slug <slug>", "Project slug override").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").option("--with-orchestrator", "Upgrade snipara-orchestrator even if not detected").action(async (options) => {
     printBanner();
     await runUpgrade(options);
@@ -241,7 +648,7 @@ function addSharedRootOptions(program) {
   ).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 snipara-sandbox installation").option("--skip-hooks", "Skip hook generation").option("--skip-test", "Skip hosted connection test").option("--with-orchestrator", "Install optional snipara-orchestrator package").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").addOption(new Option("--full", "Legacy alias for --profile full-stack").hideHelp()).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("--with-orchestrator", "Install optional snipara-orchestrator package").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("--starter", "Mark this run as a starter activation and print dashboard-first guidance").option("--runtime-only", "Install only Snipara Sandbox").addOption(new Option("--full", "Legacy alias for --profile full-stack").hideHelp()).option("-y, --yes", "Accept defaults without prompting");
 }
 async function main() {
   const program = buildProgram();
@@ -340,6 +747,7 @@ function parseInitOptionsFromArgv(args) {
     "--Full": "full",
     "--github": "github",
     "--skip-github": "skipGithub",
+    "--starter": "starter",
     "--yes": "yes",
     "-y": "yes"
   };
@@ -392,7 +800,14 @@ async function runInit(options) {
   await createCompanionPack(answers);
   const validationReport = await runValidation(answers, !normalizedOptions.skipTest);
   writeDoctorReport(validationReport);
-  printSuccess(answers, validationReport);
+  const activationManifest = createActivationManifest(
+    answers,
+    detectEnvironment(),
+    normalizedOptions.starter ? "starter" : "default"
+  );
+  runLocalSourceActivation(answers, activationManifest);
+  createActivationArtifacts(answers, activationManifest);
+  printSuccess(answers, validationReport, activationManifest);
   if (answers.configureGitHub && answers.githubRepo) {
     await openGitHubAutomation(answers);
   }
@@ -543,9 +958,9 @@ function printBanner() {
 \u2551                                                                       \u2551
 \u2551   \u2022 Hosted MCP for LLM agents                                         \u2551
 \u2551   \u2022 Free account path with hosted context and reviewed memory         \u2551
-\u2551   \u2022 Local source activation before GitHub approval                    \u2551
+\u2551   \u2022 First grounded answer before local workflow setup                 \u2551
 \u2551   \u2022 API / SDK for product integrations                                \u2551
-\u2551   \u2022 Optional local companion and Snipara Sandbox helpers              \u2551
+\u2551   \u2022 Optional advanced companion, hooks, 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
@@ -784,7 +1199,7 @@ function resolveRequestedProfile(options) {
   if (options.profile && isInstallProfile(options.profile)) {
     return options.profile;
   }
-  return "hosted-companion";
+  return "hosted-only";
 }
 function isInstallProfile(value) {
   return ["hosted-only", "hosted-companion", "full-stack", "runtime-only"].includes(value);
@@ -828,15 +1243,15 @@ function normalizeClientOption(value) {
 }
 function installProfileChoices() {
   return [
-    {
-      title: "Hosted + Companion",
-      value: "hosted-companion",
-      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"
+      description: "Default: hosted MCP config, no local companion, hooks, or sandbox"
+    },
+    {
+      title: "Hosted + Companion",
+      value: "hosted-companion",
+      description: "Add managed local workflow commands after first value"
     },
     {
       title: "Hosted + Companion + Sandbox",
@@ -1031,6 +1446,27 @@ function openBrowser(url) {
 `));
   }
 }
+function runDemo(options) {
+  const demoUrl = `${BASE_URL}/demo#sixty-second-demo`;
+  const docsUrl = `${BASE_URL}/docs/integration/create-snipara`;
+  const proofUrl = `${BASE_URL}/proof`;
+  console.log(chalk.bold("\nSnipara activation demo\n"));
+  console.log("Use this when you want to see the value before connecting a real repository.");
+  console.log("\nWhat to inspect:");
+  console.log("   1. What Changed");
+  console.log("   2. Start Work / First Work Brief");
+  console.log("   3. Project Intelligence");
+  console.log("   4. Impact Graph");
+  console.log("   5. Adaptive Routing");
+  console.log("\nLinks:");
+  console.log(`   Demo: ${demoUrl}`);
+  console.log(`   Setup docs: ${docsUrl}`);
+  console.log(`   Proof: ${proofUrl}`);
+  if (options.open !== false) {
+    console.log(chalk.dim("\nOpening the 60-second demo...\n"));
+    openBrowser(demoUrl);
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -2587,6 +3023,26 @@ function getClientGuidance(client) {
 function getCompanionCommands(answers) {
   const projectFlag = answers.projectSlug ? ` --project ${answers.projectSlug}` : "";
   const clientFlag = getCompanionInitClientFlag(answers.aiClient);
+  if (!answers.installCompanion) {
+    const commands = [
+      {
+        title: "Run doctor for this project",
+        command: `${CREATE_SNIPARA_NPX_COMMAND} doctor`,
+        purpose: "Inspect local wiring and hosted MCP reachability after the AI client restarts."
+      },
+      {
+        title: "Enable local companion later",
+        command: `${CREATE_SNIPARA_NPX_COMMAND} repair --with-companion`,
+        purpose: "Opt into local source activation, managed workflows, guards, and task commits after the first hosted answer works."
+      }
+    ];
+    commands.push({
+      title: answers.githubRepo ? "Connect GitHub PR Answer Packs later" : "Connect a GitHub repo for PR Answer Packs",
+      command: `${CREATE_SNIPARA_NPX_COMMAND} --github${answers.githubPath ? ` --github-path ${answers.githubPath}` : ""}`,
+      purpose: "Open the Snipara GitHub App flow only when the user is ready to approve repository access."
+    });
+    return commands;
+  }
   const localSourceCommands = answers.installCompanion ? [
     {
       title: "Activate this folder locally",
@@ -2598,13 +3054,7 @@ function getCompanionCommands(answers) {
       command: `${COMPANION_NPX_COMMAND} source sync --json`,
       purpose: "Refresh the local snapshot, document dry-run, and code overlay cache after files change."
     }
-  ] : [
-    {
-      title: "Enable local companion workflows",
-      command: `${CREATE_SNIPARA_NPX_COMMAND} repair --with-companion`,
-      purpose: `Install ${COMPANION_PACKAGE_NAME} so this project can run local source activation, folder onboarding, and managed workflow commands without the dashboard.`
-    }
-  ];
+  ] : [];
   const businessOnboardingCommands = answers.installCompanion ? [
     {
       title: "Preview a business folder import",
@@ -3629,7 +4079,63 @@ function printSetupVerdict(answers, report) {
     console.log("   AI client loaded MCP: not verifiable from this terminal");
   }
 }
-function printSuccess(answers, report) {
+function formatActivationStatus(status) {
+  if (status === "ready") {
+    return chalk.green("\u2713 ready");
+  }
+  if (status === "indexing" || status === "queued") {
+    return chalk.yellow(`\u23F3 ${status}`);
+  }
+  if (status === "needs_review") {
+    return chalk.yellow("review");
+  }
+  if (status === "failed") {
+    return chalk.red("failed");
+  }
+  return chalk.dim("skipped");
+}
+function printActivationSummary(manifest) {
+  console.log(chalk.bold("\nProject Intelligence activation:\n"));
+  const orderedLanes = [
+    ["Connected", manifest.lanes.connection],
+    ["AI client configured", manifest.lanes.clientConfig],
+    ["Repository analyzed", manifest.lanes.localSnapshot],
+    ["Context index", manifest.lanes.contextIndex],
+    ["Code Graph", manifest.lanes.codeGraph],
+    ["Memory candidates", manifest.lanes.memoryCandidates],
+    ["Initial handoff", manifest.lanes.handoff],
+    ["First Work Brief", manifest.lanes.firstBrief],
+    ["GitHub sync", manifest.lanes.githubSync]
+  ];
+  for (const [label, lane] of orderedLanes) {
+    console.log(`   ${formatActivationStatus(lane.status)} ${label} - ${lane.detail}`);
+  }
+  console.log(chalk.bold("\nFirst Work Brief:\n"));
+  for (const section of manifest.firstBrief.sections) {
+    console.log(`   ${section.title}`);
+    for (const line of section.lines.slice(0, 2)) {
+      console.log(chalk.dim(`   - ${line}`));
+    }
+  }
+  console.log(
+    chalk.dim(
+      `
+   Activation manifest: ${path.relative(process.cwd(), getActivationManifestPath())}`
+    )
+  );
+  if (manifest.artifacts.handoffPath) {
+    console.log(chalk.dim(`   Initial handoff: ${manifest.artifacts.handoffPath}`));
+  }
+  if (manifest.artifacts.memoryCandidatesPath) {
+    console.log(chalk.dim(`   Memory candidates: ${manifest.artifacts.memoryCandidatesPath}`));
+  }
+  if (manifest.mode === "starter") {
+    console.log(
+      chalk.dim(`   Starter tour: ${BASE_URL}/demo#sixty-second-demo and ${BASE_URL}/dashboard`)
+    );
+  }
+}
+function printSuccess(answers, report, activationManifest) {
   console.log(
     chalk.green(`
 \u2554\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\u2557
@@ -3674,7 +4180,12 @@ function printSuccess(answers, report) {
       chalk.green("   \u2713 Claude Code") + chalk.dim(" - .mcp.json MCP config, .claude/settings.json hooks when enabled")
     );
   }
-  console.log(chalk.green("   \u2713 .snipara/companion") + chalk.dim(" - Local pack + doctor report"));
+  console.log(
+    chalk.green("   \u2713 .snipara/companion") + chalk.dim(" - Doctor report and optional command references")
+  );
+  if (activationManifest) {
+    printActivationSummary(activationManifest);
+  }
   const failedChecks = report.checks.filter((check) => check.status === "fail");
   const warnedChecks = report.checks.filter((check) => check.status === "warn");
   console.log(chalk.bold("\nNext steps:\n"));
@@ -3684,6 +4195,11 @@ function printSuccess(answers, report) {
     nextStep += 1;
   };
   printNextStep("Restart your AI client if you created or changed hosted MCP config.");
+  if (!answers.installCompanion && answers.profile !== "runtime-only") {
+    printNextStep(
+      "Ask your AI client for a first grounded answer using snipara_context_query before enabling local workflow helpers."
+    );
+  }
   if (answers.aiClient === "claude-code") {
     printNextStep(
       "For Claude Code, start a new session and confirm Snipara appears in Settings -> MCP or ToolSearch."
@@ -3725,11 +4241,11 @@ function printSuccess(answers, report) {
       "For LangChain JavaScript, adapt .snipara/templates/mistral-langchain-tools.ts to bind Snipara recall, context_query, and settings tools to ChatMistralAI."
     );
   }
-  printNextStep("Open .snipara/companion/README.md for local commands and repair flow.");
   printNextStep(
     `Run ${CREATE_SNIPARA_NPX_COMMAND} doctor anytime you want a fresh local validation report.`
   );
   if (answers.installCompanion) {
+    printNextStep("Open .snipara/companion/README.md for local commands and repair flow.");
     printNextStep(
       `${COMPANION_COMMAND_NAME} ${MIN_COMPANION_VERSION}+ is installed for low-latency local hooks.`
     );
@@ -3745,7 +4261,7 @@ function printSuccess(answers, report) {
     );
   } else if (answers.profile !== "runtime-only") {
     printNextStep(
-      `For dashboardless business folder imports, enable companion with: ${CREATE_SNIPARA_NPX_COMMAND} repair --with-companion`
+      `Enable Companion, guards, managed workflows, and local folder helpers later with: ${CREATE_SNIPARA_NPX_COMMAND} repair --with-companion`
     );
   }
   if (answers.installRuntime && !answers.runSandboxInit) {
@@ -3892,7 +4408,7 @@ function resolveMaintenanceProfile(detection, explicitProfile) {
   if (detection.existingConfig.hasSniparaServer) {
     return "hosted-only";
   }
-  return "hosted-companion";
+  return "hosted-only";
 }
 function readApiKeyFromEnvFiles() {
   const candidates = [".env.local", ".env"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-snipara",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   "main": "dist/index.js",
   "type": "module",