create-snipara 2.0.7 → 2.0.8

package/dist/index.js

@@ -13,7 +13,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "create-snipara",
-  version: "2.0.7",
+  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 = [
@@ -204,7 +607,7 @@ function buildProgram() {
   ).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);
   }
@@ -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));
 }
@@ -3643,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
@@ -3691,6 +4183,9 @@ function printSuccess(answers, 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"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-snipara",
-  "version": "2.0.7",
+  "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",