create-snipara 2.0.14 → 2.0.16

package/README.md

@@ -29,7 +29,7 @@ Use it for:
 - free account signup with reviewed Context + Memory
 - local project wiring, `doctor`, `repair`, and `upgrade`
 - local source activation without GitHub, plus optional GitHub repository sync and PR Answer Packs approval when the current folder is a GitHub repo
-- day-zero Project Intelligence proof: a First Work Brief, a ready-to-run `snipara_context_query`, a small hosted README/docs seed sync for virgin projects, review-only decision archaeology candidates, possible doc-staleness findings, and an estimated context economy report from the user's own repository
+- day-zero proof with a ready-to-ask grounded question, a small hosted README/docs seed sync, and an evidence-linked Project Bootstrap for new projects
 
 ## Why It Exists
 
@@ -137,6 +137,47 @@ That distinction matters:
 - optionally installs Claude Code agent hooks and companion local code overlay Git hooks
 - supports `doctor`, `repair`, `upgrade`, and `print-config`
 
+## Project Bootstrap: Cold-Start Intelligence
+
+During setup, `create-snipara` builds a reviewable picture of the repository
+before the first agent task. It writes both a machine-readable artifact and a
+human-readable report:
+
+- `.snipara/activation/project-bootstrap.json`
+- `.snipara/activation/project-bootstrap.md`
+
+The report summarizes eight dynamic sections. Counts come from the current
+repository; they are not fixed demo numbers:
+
+- architecture patterns
+- conventions
+- decision candidates
+- procedures
+- skills and candidate workflows
+- recurring failure candidates
+- critical code symbols
+- verification patterns
+
+The local pass uses bounded evidence from Git history, `AGENTS.md`,
+`CLAUDE.md`, `README`, `docs/`, CI configuration, package scripts, test
+patterns, and release history. Every item links back to its evidence. Directly
+detected facts can be marked `observed`; inferred decisions, workflows, and
+failure patterns remain `needs_review` and are not promoted to durable project
+memory automatically.
+
+The artifact also includes a coverage ledger. PR and issue history are marked
+`unavailable` until the user explicitly connects a source provider. Critical
+symbols are marked `deferred` until Code Graph indexing is available. Snipara
+does not invent candidates to make these sections look complete.
+
+After setup, start here:
+
+> Review what Snipara learned about your project.
+
+The Project Bootstrap summary is also carried into the First Work Brief so the
+agent begins with the repository's inherited experience and its remaining
+evidence gaps in view.
+
 ## Product Boundary
 
 Keep the package roles simple:
@@ -404,7 +445,7 @@ The intended split is:
 
 - `create-snipara`: Context + Memory onboarding, auth, config, inspect, repair, and upgrade
 - `snipara-openclaw-install`: OpenClaw-only setup wrapper that remains narrower than `create-snipara`
-- `snipara-companion`: default local workflow helper
+- `snipara-companion`: optional local workflow helper after first value
 - `snipara-mcp`: local stdio bridge, client-package development, compatibility, and testing
 - `snipara-sandbox`: optional local execution engine
 
@@ -416,8 +457,8 @@ companion add workflow ergonomics:
 - use Hosted MCP as the core Snipara surface
 - use `AGENTS.md` for project instructions
 - use the selected pack under `.snipara/companion/`, for example `CODEX.md`, `CURSOR.md`, or `GEMINI.md`
-- 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
+- start with the default `hosted-only` path for the shortest route to a grounded answer
+- choose `hosted-companion` after first value when you want compaction-safe local phase commits
 - use local `snipara-mcp` only for stdio compatibility, development, or tests
 
 Claude Code, Cursor, and Kimi Code CLI can receive generated automation files when
@@ -461,6 +502,10 @@ After setup, the project gets a local pack at `.snipara/companion/`:
 - `commands.json`: starter commands for the current project
 - `doctor.json`: most recent validation report
 
+Activation evidence is kept separately under `.snipara/activation/`, including
+the Project Bootstrap JSON/Markdown pair, First Work Brief, handoff, and memory
+candidate review artifacts.
+
 This pack is meant to be the local source of truth for machine-level setup. When
 `snipara-companion` is installed, it includes business-folder onboarding commands
 such as:

package/dist/index.js

@@ -13,8 +13,8 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "create-snipara",
-  version: "2.0.14",
-  description: "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
+  version: "2.0.16",
+  description: "Onboard Snipara Hosted MCP Context + Memory with project bootstrap intelligence and optional local workflows",
   main: "dist/index.js",
   type: "module",
   bin: {
@@ -23,7 +23,7 @@ var package_default = {
   scripts: {
     build: "tsup src/index.ts --format esm --dts --clean",
     dev: "tsup src/index.ts --format esm --watch",
-    prepublishOnly: "npm run build",
+    prepack: "npm run build",
     pretest: "pnpm build",
     test: "node --test test/*.test.cjs",
     "pack:smoke": "bash ../../scripts/smoke-node-package.sh packages/create-snipara create-snipara create-snipara --help",
@@ -107,6 +107,9 @@ var DEVICE_CLIENT_ID = "create-snipara";
 var DAY_ZERO_CORPUS_MAX_FILES = 8;
 var DAY_ZERO_CORPUS_MAX_FILE_CHARS = 12e3;
 var DAY_ZERO_CORPUS_MAX_TOTAL_CHARS = 5e4;
+var PROJECT_BOOTSTRAP_SCHEMA_VERSION = "snipara.project_bootstrap.v1";
+var PROJECT_BOOTSTRAP_MAX_WALKED_FILES = 2500;
+var PROJECT_BOOTSTRAP_MAX_MATCHED_FILES = 80;
 var ACTIVATION_MANIFEST_SCHEMA_VERSION = "snipara.activation.manifest.v1";
 var ACTIVATION_CONSUMER_CONTRACT_VERSION = "snipara.editor.activation.v1";
 var EXPERIENCE_GOAL_SECTION = `## Experience Goal
@@ -154,6 +157,12 @@ function getFirstWorkBriefPath() {
 function getMemoryCandidatesPath() {
   return path.join(getActivationDir(), "memory-candidates.json");
 }
+function getProjectBootstrapJsonPath() {
+  return path.join(getActivationDir(), "project-bootstrap.json");
+}
+function getProjectBootstrapMarkdownPath() {
+  return path.join(getActivationDir(), "project-bootstrap.md");
+}
 function writeActivationManifest(manifest) {
   fs.mkdirSync(getActivationDir(), { recursive: true });
   const payload = JSON.stringify(manifest, null, 2) + "\n";
@@ -561,6 +570,23 @@ function listFilesUnder(relativeDir, maxFiles) {
   visit(root);
   return results;
 }
+function isCreateSniparaGeneratedInstructionSource(relativePath) {
+  if (!["AGENTS.md", "CLAUDE.md", ".cursor/rules/snipara.mdc"].includes(relativePath)) {
+    return false;
+  }
+  try {
+    const prefix = fs.readFileSync(path.join(process.cwd(), relativePath), "utf8").slice(0, 4096);
+    return prefix.includes(
+      "## Snipara Context Workflow\n\nThis project uses Snipara Hosted MCP for project context and reviewed memory."
+    ) || prefix.includes(
+      "Canonical project context is in `AGENTS.md`. This file exists for Claude Code compatibility."
+    ) || prefix.includes(
+      "description: Use Snipara Hosted MCP for project context and reviewed memory."
+    );
+  } catch {
+    return false;
+  }
+}
 function findDecisionArchaeologySources(cwd) {
   const exists = (relativePath) => fs.existsSync(path.join(cwd, relativePath));
   const directSources = [
@@ -578,7 +604,528 @@ function findDecisionArchaeologySources(cwd) {
     ...listFilesUnder("docs/decisions", 20),
     ...listFilesUnder(".cursor/rules", 20)
   ];
-  return [.../* @__PURE__ */ new Set([...directSources, ...archaeologySources])].slice(0, 80);
+  return [.../* @__PURE__ */ new Set([...directSources, ...archaeologySources])].filter((source) => !isCreateSniparaGeneratedInstructionSource(source)).slice(0, 80);
+}
+function findBoundedProjectFiles(predicate, maxMatches = PROJECT_BOOTSTRAP_MAX_MATCHED_FILES) {
+  const ignoredDirectories = /* @__PURE__ */ new Set([
+    ".git",
+    ".next",
+    ".snipara",
+    ".turbo",
+    ".venv",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "target",
+    "vendor"
+  ]);
+  const results = [];
+  let walkedFiles = 0;
+  const visit = (directory) => {
+    if (walkedFiles >= PROJECT_BOOTSTRAP_MAX_WALKED_FILES || results.length >= maxMatches) {
+      return;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      const absolutePath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoredDirectories.has(entry.name)) {
+          visit(absolutePath);
+        }
+      } else if (entry.isFile()) {
+        walkedFiles += 1;
+        const relativePath = path.relative(process.cwd(), absolutePath).replace(/\\/g, "/");
+        if (predicate(relativePath)) {
+          results.push(relativePath);
+        }
+      }
+      if (walkedFiles >= PROJECT_BOOTSTRAP_MAX_WALKED_FILES || results.length >= maxMatches) {
+        return;
+      }
+    }
+  };
+  visit(process.cwd());
+  return results;
+}
+function readProjectPackageMetadata() {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return { scripts: {}, dependencies: [], workspaces: false };
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    const scripts = Object.fromEntries(
+      Object.entries(parsed.scripts ?? {}).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+    const dependencies = [
+      ...Object.keys(parsed.dependencies ?? {}),
+      ...Object.keys(parsed.devDependencies ?? {}),
+      ...Object.keys(parsed.peerDependencies ?? {})
+    ];
+    return {
+      scripts,
+      dependencies: [...new Set(dependencies)].sort(),
+      workspaces: Boolean(parsed.workspaces)
+    };
+  } catch {
+    return { scripts: {}, dependencies: [], workspaces: false };
+  }
+}
+function readBootstrapGitSubjects(maxCount) {
+  try {
+    const output = execSync(`git log --pretty=format:%h%x20%s --max-count=${maxCount}`, {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1500
+    }).trim();
+    return output ? output.split(/\r?\n/).map((line) => line.trim()) : [];
+  } catch {
+    return [];
+  }
+}
+function readBootstrapReleaseTags() {
+  try {
+    const output = execSync("git tag --sort=-creatordate", {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    }).trim();
+    return output ? output.split(/\r?\n/).slice(0, 20) : [];
+  } catch {
+    return [];
+  }
+}
+function createBootstrapItem(section, title, status, detail, evidence) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 56);
+  return {
+    id: `${section}:${slug || "candidate"}`,
+    title,
+    status,
+    detail,
+    evidence
+  };
+}
+function buildProjectBootstrap(scan) {
+  const cwd = process.cwd();
+  const exists = (relativePath) => fs.existsSync(path.join(cwd, relativePath));
+  const packageMetadata = readProjectPackageMetadata();
+  const allDetectedFiles = findBoundedProjectFiles(() => true, PROJECT_BOOTSTRAP_MAX_WALKED_FILES);
+  const testFiles = allDetectedFiles.filter(
+    (relativePath) => /(^|\/)(?:__tests__|tests?|spec)(\/|$)|(?:^|\/)[^/]+\.(?:test|spec)\.[^/]+$|(?:^|\/)test_[^/]+\.py$/i.test(
+      relativePath
+    )
+  );
+  const skillFiles = allDetectedFiles.filter(
+    (relativePath) => /(^|\/)SKILL\.md$/i.test(relativePath)
+  );
+  const ciFiles = [
+    ...allDetectedFiles.filter(
+      (relativePath) => /^\.github\/workflows\/[^/]+\.ya?ml$/i.test(relativePath)
+    ),
+    ...[".gitlab-ci.yml", "azure-pipelines.yml", "Jenkinsfile", ".circleci/config.yml"].filter(
+      exists
+    )
+  ].filter((value, index, values) => values.indexOf(value) === index);
+  const instructionSources = scan.files.candidateDocs.filter(
+    (source) => classifyDecisionSource(source) === "agent_instruction"
+  );
+  const documentationSources = [
+    ...["README.md", "CHANGELOG.md", "MEMORY.md"].filter(exists),
+    ...listFilesUnder("docs", 40)
+  ].filter((value, index, values) => values.indexOf(value) === index);
+  const releaseTags = scan.git.detected ? readBootstrapReleaseTags() : [];
+  const gitSubjects = scan.git.detected ? readBootstrapGitSubjects(120) : [];
+  const architecture = [];
+  if (scan.languages.length > 0) {
+    architecture.push(
+      createBootstrapItem(
+        "architecture",
+        `Languages: ${scan.languages.join(", ")}`,
+        "observed",
+        "Detected from root manifests and source extensions.",
+        scan.files.hasPackageJson ? [{ source: "package.json", kind: "manifest" }] : [{ source: ".", kind: "filesystem_scan" }]
+      )
+    );
+  }
+  if (scan.packageManagers.length > 0) {
+    architecture.push(
+      createBootstrapItem(
+        "architecture",
+        `Package manager: ${scan.packageManagers.join(", ")}`,
+        "observed",
+        "Detected from lockfiles.",
+        scan.files.lockfiles.map((source) => ({ source, kind: "lockfile" }))
+      )
+    );
+  }
+  const workspaceEvidence = ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json"].filter(
+    exists
+  );
+  if (packageMetadata.workspaces || workspaceEvidence.length > 0) {
+    architecture.push(
+      createBootstrapItem(
+        "architecture",
+        "Workspace or monorepo layout",
+        "observed",
+        "A workspace declaration or workspace configuration file is present.",
+        (workspaceEvidence.length > 0 ? workspaceEvidence : ["package.json"]).map((source) => ({
+          source,
+          kind: "config"
+        }))
+      )
+    );
+  }
+  for (const directory of ["apps", "packages", "services", "libs"].filter(exists)) {
+    architecture.push(
+      createBootstrapItem(
+        "architecture",
+        `${directory}/ project boundary`,
+        "observed",
+        "Top-level project organization detected; no architectural meaning was inferred beyond its presence.",
+        [{ source: `${directory}/`, kind: "directory" }]
+      )
+    );
+  }
+  const frameworks = [
+    ["next", "Next.js"],
+    ["react", "React"],
+    ["@nestjs/core", "NestJS"],
+    ["express", "Express"],
+    ["fastify", "Fastify"],
+    ["vitest", "Vitest"],
+    ["jest", "Jest"]
+  ];
+  for (const [dependency, label] of frameworks) {
+    if (packageMetadata.dependencies.includes(dependency)) {
+      architecture.push(
+        createBootstrapItem(
+          "architecture",
+          `${label} dependency`,
+          "observed",
+          `The root manifest declares ${dependency}; its role still needs code-level confirmation.`,
+          [{ source: "package.json", kind: "manifest" }]
+        )
+      );
+    }
+  }
+  if (scan.files.hasDockerfile) {
+    architecture.push(
+      createBootstrapItem(
+        "architecture",
+        "Container build surface",
+        "observed",
+        "A root Dockerfile is present.",
+        [{ source: "Dockerfile", kind: "config" }]
+      )
+    );
+  }
+  const candidates = buildMemoryCandidatePreviews(scan);
+  const conventions = candidates.filter(
+    (candidate) => candidate.evidence === "agent_instruction" || candidate.evidence === "project_document"
+  ).slice(0, 16).map(
+    (candidate) => createBootstrapItem(
+      "conventions",
+      candidate.text.slice(0, 100),
+      "needs_review",
+      candidate.reason,
+      [{ source: candidate.source, kind: candidate.evidence }]
+    )
+  );
+  const decisions = candidates.filter(
+    (candidate) => ["git_commit_subject", "adr_or_decision_doc", "changelog"].includes(candidate.evidence)
+  ).slice(0, 12).map(
+    (candidate) => createBootstrapItem(
+      "decisions",
+      candidate.text.slice(0, 100),
+      "needs_review",
+      candidate.reason,
+      [{ source: candidate.source, kind: candidate.evidence }]
+    )
+  );
+  const procedureScriptPattern = /(^|:)(build|dev|start|lint|test|type-?check|check|verify|deploy|release|migrate|seed|smoke|e2e)(:|$)/i;
+  const procedures = Object.keys(packageMetadata.scripts).filter((name) => procedureScriptPattern.test(name)).slice(0, 20).map(
+    (name) => createBootstrapItem(
+      "procedures",
+      `package script: ${name}`,
+      "observed",
+      "A root package script is configured; its exact command remains in package.json.",
+      [{ source: "package.json", kind: "package_script" }]
+    )
+  );
+  for (const source of ciFiles.slice(0, 8)) {
+    procedures.push(
+      createBootstrapItem(
+        "procedures",
+        `CI workflow: ${path.basename(source)}`,
+        "observed",
+        "Automation configuration detected; individual jobs were not interpreted during the bounded scan.",
+        [{ source, kind: "ci_workflow" }]
+      )
+    );
+  }
+  const skills = skillFiles.slice(0, 12).map(
+    (source) => createBootstrapItem(
+      "skills",
+      `Existing skill: ${path.basename(path.dirname(source)) || "root"}`,
+      "observed",
+      "An explicit SKILL.md workflow was found.",
+      [{ source, kind: "skill_definition" }]
+    )
+  );
+  const verificationScriptNames = Object.keys(packageMetadata.scripts).filter(
+    (name) => /test|lint|type|check|verify|smoke|e2e|build/i.test(name)
+  );
+  if (verificationScriptNames.length >= 2 && skills.length < 12) {
+    skills.push(
+      createBootstrapItem(
+        "skills",
+        "Verification workflow candidate",
+        "needs_review",
+        `Related scripts detected: ${verificationScriptNames.slice(0, 8).join(", ")}. Review their intended order before promoting this to a skill.`,
+        [{ source: "package.json", kind: "package_scripts" }]
+      )
+    );
+  }
+  const failureTerms = [
+    ["rollback or revert", /\b(?:rollback|revert)\b/i],
+    ["hotfix", /\bhotfix\b/i],
+    ["regression", /\bregression\b/i],
+    ["flaky verification", /\b(?:flaky|flakiness)\b/i],
+    ["broken or failing behavior", /\b(?:broken|failing|failure)\b/i]
+  ];
+  const recurringFailures = failureTerms.flatMap(([label, matcher]) => {
+    const matches = gitSubjects.filter((subject) => matcher.test(subject)).slice(0, 6);
+    if (matches.length < 2) {
+      return [];
+    }
+    return [
+      createBootstrapItem(
+        "recurringFailures",
+        `${label} signal (${matches.length} commits)`,
+        "needs_review",
+        "Repeated commit-language is a signal, not proof of a common root cause. Review the linked commits before accepting this anti-pattern.",
+        matches.map((source) => ({ source, kind: "git_commit_subject" }))
+      )
+    ];
+  });
+  const verificationPatterns = verificationScriptNames.slice(0, 16).map(
+    (name) => createBootstrapItem(
+      "verificationPatterns",
+      `Verification script: ${name}`,
+      "observed",
+      "A root verification script is configured; its exact command remains in package.json.",
+      [{ source: "package.json", kind: "package_script" }]
+    )
+  );
+  const testPatternGroups = [
+    ["*.test.*", /\.test\.[^/]+$/i],
+    ["*.spec.*", /\.spec\.[^/]+$/i],
+    ["__tests__/", /(^|\/)__tests__\//i],
+    ["test_*.py", /(^|\/)test_[^/]+\.py$/i]
+  ];
+  for (const [label, matcher] of testPatternGroups) {
+    const matches = testFiles.filter((source) => matcher.test(source));
+    if (matches.length === 0) {
+      continue;
+    }
+    verificationPatterns.push(
+      createBootstrapItem(
+        "verificationPatterns",
+        `Test pattern: ${label}`,
+        "observed",
+        `${matches.length} matching file(s) found in the bounded scan.`,
+        matches.slice(0, 6).map((source) => ({ source, kind: "test_file" }))
+      )
+    );
+  }
+  const sections = {
+    architecture: {
+      title: "Architecture",
+      status: architecture.length > 0 ? "observed" : "deferred",
+      detail: "Manifest, filesystem, dependency, and configuration patterns only.",
+      items: architecture.slice(0, 20)
+    },
+    conventions: {
+      title: "Conventions",
+      status: conventions.length > 0 ? "needs_review" : "deferred",
+      detail: "Guidance-language candidates require human review before durable import.",
+      items: conventions
+    },
+    decisions: {
+      title: "Decisions",
+      status: decisions.length > 0 ? "needs_review" : "deferred",
+      detail: "Commit and decision-document candidates are never auto-approved.",
+      items: decisions
+    },
+    procedures: {
+      title: "Procedures",
+      status: procedures.length > 0 ? "observed" : "deferred",
+      detail: "Configured scripts and CI files; execution order is not inferred.",
+      items: procedures.slice(0, 24)
+    },
+    skills: {
+      title: "Skills",
+      status: skills.some((item) => item.status === "needs_review") ? "needs_review" : skills.length > 0 ? "observed" : "deferred",
+      detail: "Explicit skill definitions plus reviewable workflow candidates.",
+      items: skills
+    },
+    recurringFailures: {
+      title: "Recurring failures",
+      status: recurringFailures.length > 0 ? "needs_review" : "deferred",
+      detail: "Only repeated failure-language signals are shown; no root cause is inferred.",
+      items: recurringFailures
+    },
+    criticalCode: {
+      title: "Critical code",
+      status: "deferred",
+      detail: "Critical symbols require Code Graph indexing; the local bootstrap does not guess them.",
+      items: []
+    },
+    verificationPatterns: {
+      title: "Verification patterns",
+      status: verificationPatterns.length > 0 ? "observed" : "deferred",
+      detail: "Configured checks and test naming patterns from the bounded local scan.",
+      items: verificationPatterns.slice(0, 24)
+    }
+  };
+  const summary = Object.fromEntries(
+    Object.entries(sections).map(([key, section]) => [key, section.items.length])
+  );
+  const coverage = {
+    gitHistory: createBootstrapCoverage(
+      scan.git.detected ? "partial" : "unavailable",
+      scan.git.detected ? "Inspected up to 120 recent commit subjects; commit bodies and diffs were not interpreted." : "No local Git repository was detected.",
+      scan.git.detected ? ["git log"] : []
+    ),
+    pullRequests: createBootstrapCoverage(
+      "unavailable",
+      "Pull request history requires an explicitly connected provider.",
+      []
+    ),
+    issues: createBootstrapCoverage(
+      "unavailable",
+      "Issue history requires an explicitly connected provider.",
+      []
+    ),
+    instructions: createBootstrapCoverage(
+      instructionSources.length > 0 ? "observed" : "unavailable",
+      instructionSources.length > 0 ? "Project instruction files were included in the bounded local scan." : "No AGENTS.md, CLAUDE.md, or Copilot instruction file was found.",
+      instructionSources
+    ),
+    documentation: createBootstrapCoverage(
+      documentationSources.length > 0 ? "partial" : "unavailable",
+      documentationSources.length > 0 ? `Inspected a bounded set of ${documentationSources.length} README, changelog, memory, and docs files.` : "No README, changelog, memory, or docs files were found.",
+      documentationSources
+    ),
+    ci: createBootstrapCoverage(
+      ciFiles.length > 0 ? "observed" : "unavailable",
+      ciFiles.length > 0 ? "CI configuration files were detected." : "No standard CI configuration was found.",
+      ciFiles
+    ),
+    packageScripts: createBootstrapCoverage(
+      Object.keys(packageMetadata.scripts).length > 0 ? "observed" : "unavailable",
+      Object.keys(packageMetadata.scripts).length > 0 ? "Root package scripts were inspected." : "No root package scripts were available.",
+      Object.keys(packageMetadata.scripts).length > 0 ? ["package.json"] : []
+    ),
+    testPatterns: createBootstrapCoverage(
+      testFiles.length > 0 ? "partial" : "unavailable",
+      testFiles.length > 0 ? `Found ${testFiles.length} test-like files within a ${PROJECT_BOOTSTRAP_MAX_WALKED_FILES}-file scan cap.` : `No test-like files were found within the ${PROJECT_BOOTSTRAP_MAX_WALKED_FILES}-file scan cap.`,
+      testFiles.slice(0, 20)
+    ),
+    releaseHistory: createBootstrapCoverage(
+      releaseTags.length > 0 || exists("CHANGELOG.md") ? "partial" : "unavailable",
+      releaseTags.length > 0 || exists("CHANGELOG.md") ? `Detected ${releaseTags.length} recent tag(s)${exists("CHANGELOG.md") ? " and CHANGELOG.md" : ""}.` : "No Git tags or root CHANGELOG.md were detected.",
+      [
+        ...releaseTags.map((tag) => `git tag ${tag}`),
+        ...exists("CHANGELOG.md") ? ["CHANGELOG.md"] : []
+      ]
+    ),
+    codeGraph: createBootstrapCoverage(
+      "deferred",
+      "Critical symbols and structural impact require Code Graph indexing after activation.",
+      []
+    )
+  };
+  return {
+    schemaVersion: PROJECT_BOOTSTRAP_SCHEMA_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoPath: cwd,
+    reviewPrompt: "Review what Snipara learned about your project.",
+    scanLimits: {
+      walkedFiles: PROJECT_BOOTSTRAP_MAX_WALKED_FILES,
+      matchedFilesPerQuery: PROJECT_BOOTSTRAP_MAX_MATCHED_FILES,
+      gitCommitSubjects: 120
+    },
+    summary,
+    coverage,
+    sections
+  };
+}
+function createBootstrapCoverage(status, detail, sources) {
+  return { status, detail, sources };
+}
+function writeProjectBootstrap(report) {
+  fs.mkdirSync(getActivationDir(), { recursive: true });
+  fs.writeFileSync(getProjectBootstrapJsonPath(), JSON.stringify(report, null, 2) + "\n", "utf8");
+  const lines = [
+    "# PROJECT BOOTSTRAP",
+    "",
+    `Generated: ${report.generatedAt}`,
+    `Repository: ${report.repoPath}`,
+    "",
+    "## Coverage",
+    "",
+    ...Object.entries(report.coverage).map(
+      ([name, entry]) => `- ${name}: ${entry.status} \u2014 ${entry.detail}`
+    ),
+    "",
+    ...Object.values(report.sections).flatMap((section) => [
+      `## ${section.title} \u2014 ${section.items.length}`,
+      "",
+      section.detail,
+      "",
+      ...section.items.length > 0 ? section.items.flatMap((item) => [
+        `- [${item.status}] ${item.title}`,
+        `  ${item.detail}`,
+        ...item.evidence.length > 0 ? [
+          `  Evidence: ${item.evidence.map((entry) => entry.source).join(", ")}`
+        ] : []
+      ]) : ["- No evidence-backed item available yet."],
+      ""
+    ]),
+    `**${report.reviewPrompt}**`,
+    ""
+  ];
+  fs.writeFileSync(getProjectBootstrapMarkdownPath(), lines.join("\n"), "utf8");
+}
+function addProjectBootstrapToFirstWorkBrief(manifest, report) {
+  manifest.firstBrief.sections.splice(1, 0, {
+    title: "Project Bootstrap",
+    lines: [
+      `Architecture: ${report.summary.architecture} pattern(s).`,
+      `Conventions: ${report.summary.conventions} candidate(s).`,
+      `Decisions: ${report.summary.decisions} inferred candidate(s).`,
+      `Procedures: ${report.summary.procedures} observed workflow(s).`,
+      `Skills: ${report.summary.skills} existing or candidate workflow(s).`,
+      `Recurring failures: ${report.summary.recurringFailures} review candidate(s).`,
+      `Critical code: ${report.summary.criticalCode}; deferred until Code Graph indexes symbols.`,
+      `Verification patterns: ${report.summary.verificationPatterns} observed pattern(s).`,
+      report.reviewPrompt
+    ]
+  });
 }
 function createInitialFirstWorkBrief(answers, detection, scan) {
   const surfaceContract = buildActivationSurfaceContract(answers.aiClient);
@@ -706,6 +1253,10 @@ function createActivationManifest(answers, detection, mode = "default", scan) {
         hasCompanion ? "queued" : "skipped",
         hasCompanion ? "Free Code Graph indexing starts from local source overlay within capacity caps." : "Free Code Graph is available after companion or hosted provider sync."
       ),
+      projectBootstrap: createActivationLane(
+        "queued",
+        "Bounded local cold-start analysis will prepare an evidence-linked Project Bootstrap."
+      ),
       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."
@@ -728,7 +1279,9 @@ function createActivationManifest(answers, detection, mode = "default", scan) {
       legacyManifestPath: path.relative(process.cwd(), getActivationManifestPath()),
       firstBriefPath: null,
       handoffPath: null,
-      memoryCandidatesPath: null
+      memoryCandidatesPath: null,
+      projectBootstrapJsonPath: null,
+      projectBootstrapMarkdownPath: null
     },
     nextActions: buildActivationNextActions(surfaceContract, answers),
     firstBrief: createInitialFirstWorkBrief(answers, detection, localScan),
@@ -918,6 +1471,22 @@ async function runHostedDayZeroCorpusSync(answers, manifest, enabled) {
   updateActivationManifest(manifest);
 }
 function createActivationArtifacts(answers, manifest) {
+  const projectBootstrap = buildProjectBootstrap(manifest.localScan);
+  writeProjectBootstrap(projectBootstrap);
+  manifest.artifacts.projectBootstrapJsonPath = path.relative(
+    process.cwd(),
+    getProjectBootstrapJsonPath()
+  );
+  manifest.artifacts.projectBootstrapMarkdownPath = path.relative(
+    process.cwd(),
+    getProjectBootstrapMarkdownPath()
+  );
+  manifest.lanes.projectBootstrap = createActivationLane(
+    "needs_review",
+    "Evidence-linked Project Bootstrap generated; inferred candidates require review.",
+    manifest.artifacts.projectBootstrapMarkdownPath
+  );
+  addProjectBootstrapToFirstWorkBrief(manifest, projectBootstrap);
   const candidates = buildMemoryCandidatePreviews(manifest.localScan);
   writeMemoryCandidates(candidates);
   manifest.artifacts.memoryCandidatesPath = path.relative(process.cwd(), getMemoryCandidatesPath());
@@ -3530,7 +4099,9 @@ function buildEditorActivationConsumerContract(client) {
       activationManifest: ".snipara/activation/activation-manifest.json",
       firstBrief: ".snipara/activation/first-brief.md",
       handoff: ".snipara/activation/handoff.md",
-      memoryCandidates: ".snipara/activation/memory-candidates.json"
+      memoryCandidates: ".snipara/activation/memory-candidates.json",
+      projectBootstrapJson: ".snipara/activation/project-bootstrap.json",
+      projectBootstrapMarkdown: ".snipara/activation/project-bootstrap.md"
     },
     requiredManifestFields: [
       "schemaVersion",
@@ -3539,7 +4110,10 @@ function buildEditorActivationConsumerContract(client) {
       "artifacts.activationManifestPath",
       "artifacts.firstBriefPath",
       "artifacts.handoffPath",
+      "artifacts.projectBootstrapJsonPath",
+      "artifacts.projectBootstrapMarkdownPath",
       "lanes.connection.status",
+      "lanes.projectBootstrap.status",
       "lanes.firstBrief.status",
       "nextActions"
     ],
@@ -4715,51 +5289,6 @@ function describeJsonRpcError(data) {
   const code = data.error.code !== void 0 ? ` ${data.error.code}` : "";
   return `JSON-RPC error${code}: ${data.error.message || "unknown error"}`;
 }
-function getCheck(report, name) {
-  return report.checks.find((check) => check.name === name);
-}
-function formatCheckStatus(check) {
-  if (!check) {
-    return "not checked";
-  }
-  if (check.status === "pass") {
-    return `OK - ${check.detail}`;
-  }
-  if (check.status === "fail") {
-    return `FAILED - ${check.detail}`;
-  }
-  return `NEEDS ATTENTION - ${check.detail}`;
-}
-function printSetupVerdict(answers, report) {
-  const hostedConnection = getCheck(report, "hosted_connection");
-  const sniparaTools = getCheck(report, "hosted_snipara_tools");
-  const legacyTools = getCheck(report, "hosted_legacy_tools_hidden");
-  const codexConfig = getCheck(report, "codex_config");
-  const mistralConfig = getCheck(report, "mistral_config");
-  const claudeTools = getCheck(report, "claude_tools_visible");
-  console.log(chalk.bold("\nSetup verdict:\n"));
-  console.log(`   Config written: ${answers.profile !== "runtime-only" ? "OK" : "not requested"}`);
-  console.log(`   Hosted MCP: ${formatCheckStatus(hostedConnection)}`);
-  if (sniparaTools) {
-    console.log(`   Snipara tools: ${formatCheckStatus(sniparaTools)}`);
-  }
-  if (legacyTools) {
-    console.log(`   Legacy tool duplicates: ${formatCheckStatus(legacyTools)}`);
-  }
-  if (codexConfig) {
-    console.log(`   Codex config: ${formatCheckStatus(codexConfig)}`);
-  }
-  if (mistralConfig) {
-    console.log(`   Mistral config: ${formatCheckStatus(mistralConfig)}`);
-  }
-  if (answers.aiClient === "claude-code" || answers.aiClient === "claude-desktop") {
-    console.log(
-      `   Claude loaded MCP: ${claudeTools ? formatCheckStatus(claudeTools) : "not verified"}`
-    );
-  } else {
-    console.log("   AI client loaded MCP: not verifiable from this terminal");
-  }
-}
 function formatActivationStatus(status) {
   if (status === "ready") {
     return chalk.green("\u2713 ready");
@@ -4776,60 +5305,14 @@ function formatActivationStatus(status) {
   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.bold("\nDay-zero proof:\n"));
-  console.log(`   Tool: ${manifest.dayZeroQuery.tool}`);
-  console.log(`   Query: ${manifest.dayZeroQuery.query}`);
+  const contextLane = manifest.dayZeroCorpus.status === "failed" ? { status: "failed", detail: manifest.dayZeroCorpus.detail } : manifest.dayZeroCorpus.status === "submitted" || manifest.dayZeroCorpus.status === "queued" ? { status: "indexing", detail: manifest.dayZeroCorpus.detail } : manifest.lanes.contextIndex;
+  console.log(chalk.bold("\nActivation status:\n"));
   console.log(
-    chalk.dim(
-      `   Target: ${manifest.activationMetric.targetMinutes} minutes to a true, non-obvious own-repo answer.`
-    )
-  );
-  console.log(
-    chalk.dim(
-      `   Day-zero corpus: ${manifest.dayZeroCorpus.status} - ${manifest.dayZeroCorpus.detail}`
-    )
-  );
-  console.log(chalk.bold("\nActivation surface:\n"));
-  console.log(`   Engine: ${manifest.surfaceContract.engine}`);
-  console.log(`   Entry point: ${manifest.surfaceContract.entryPoint}`);
-  console.log(chalk.dim(`   Role: ${manifest.surfaceContract.clientRole}`));
-  console.log(chalk.dim(`   Next: ${manifest.surfaceContract.nextSurfaceAction}`));
-  console.log(chalk.bold("\nAgent readiness:\n"));
-  console.log(`   ${manifest.agentReadiness.summary}`);
-  for (const finding of manifest.agentReadiness.stalenessFindings.slice(0, 3)) {
-    console.log(chalk.dim(`   - ${finding.source}: ${finding.summary}`));
-  }
-  console.log(chalk.bold("\nContext economy:\n"));
-  console.log(
-    `   Estimated ${manifest.contextEconomy.estimatedRetrievedTokens.toLocaleString("en-US")} tokens retrieved instead of ${manifest.contextEconomy.rawWindowBaselineTokens.toLocaleString("en-US")} raw-window tokens.`
-  );
-  console.log(
-    chalk.dim(
-      `   Saved about ${manifest.contextEconomy.estimatedSavedTokens.toLocaleString("en-US")} tokens (${manifest.contextEconomy.savingsPercent}%). ${manifest.contextEconomy.note}`
-    )
+    `   ${formatActivationStatus(manifest.lanes.connection.status)} Connected - ${manifest.lanes.connection.detail}`
   );
+  console.log(`   ${formatActivationStatus(contextLane.status)} Context - ${contextLane.detail}`);
+  console.log(`   ${chalk.dim("\u25CB pending")} First grounded answer`);
+  console.log(chalk.yellow("\n   Activation pending: first grounded answer needed."));
   console.log(
     chalk.dim(
       `
@@ -4840,12 +5323,7 @@ function printActivationSummary(manifest) {
     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`)
-    );
+    console.log(chalk.dim(`   Advanced details: ${manifest.artifacts.memoryCandidatesPath}`));
   }
 }
 function printSuccess(answers, report, activationManifest) {
@@ -4853,160 +5331,28 @@ function printSuccess(answers, report, activationManifest) {
     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
 \u2551                                                                       \u2551
-\u2551   ${chalk.bold("\u2713 Setup Complete!")}                                                 \u2551
+\u2551   ${chalk.bold("\u2713 Connection Ready")}                                                \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
 `)
   );
-  console.log(chalk.bold("Installed profile:\n"));
-  console.log(`   ${chalk.green("\u2713")} ${answers.profile}`);
-  printSetupVerdict(answers, report);
-  console.log(chalk.bold("\nWhat was installed:\n"));
-  if (answers.installMcp) {
-    console.log(
-      chalk.green("   \u2713 snipara-mcp") + chalk.dim(" - Local stdio compatibility package")
-    );
-  }
-  if (answers.installRuntime) {
-    console.log(
-      chalk.green(`   \u2713 ${stripExtras(SANDBOX_PACKAGE_NAME)}`) + chalk.dim(" - Safe code execution")
-    );
-  }
-  if (answers.installOrchestrator) {
-    console.log(
-      chalk.green(`   \u2713 ${ORCHESTRATOR_PACKAGE_NAME}`) + chalk.dim(" - Production gates, drift checks, and htask workflows")
-    );
-  }
-  if (answers.installCompanion) {
-    console.log(
-      chalk.green(`   \u2713 ${COMPANION_PACKAGE_NAME}`) + chalk.dim(" - Local companion workflows and hook bootstrap")
-    );
-  }
-  if (answers.installHooks) {
-    console.log(chalk.green("   \u2713 hooks") + chalk.dim(" - Local session lifecycle scripts"));
-  }
-  if (answers.profile !== "runtime-only") {
-    console.log(chalk.green("   \u2713 .mcp.json") + chalk.dim(" - Hosted MCP config"));
-  }
-  if (answers.aiClient === "claude-code" && answers.profile !== "runtime-only") {
-    console.log(
-      chalk.green("   \u2713 Claude Code") + chalk.dim(" - .mcp.json MCP config, .claude/settings.json hooks when enabled")
-    );
-  }
-  if (answers.aiClient === "kimi" && answers.profile !== "runtime-only") {
-    console.log(
-      chalk.green("   \u2713 Kimi Code CLI") + chalk.dim(" - .kimi-code/mcp.json with environment-backed authentication")
-    );
-  }
-  console.log(
-    chalk.green("   \u2713 .snipara/companion") + chalk.dim(" - Doctor report and optional command references")
-  );
+  console.log(`   Profile: ${answers.profile}`);
   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"));
-  let nextStep = 1;
-  const printNextStep = (message) => {
-    console.log(`  ${nextStep}. ${message}`);
-    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."
-    );
-    printNextStep(
-      `If Snipara tools are missing, run: ${CREATE_SNIPARA_NPX_COMMAND} doctor --client claude-code`
-    );
-  }
-  if (answers.aiClient === "claude-desktop") {
-    printNextStep(
-      "For Claude Desktop, confirm the Snipara server appears in the desktop MCP settings after restart."
-    );
-    printNextStep(
-      `If Snipara tools are missing, run: ${CREATE_SNIPARA_NPX_COMMAND} doctor --client claude-desktop`
-    );
-  }
-  if (answers.aiClient === "kimi") {
-    printNextStep(
-      "For Kimi Code CLI, export SNIPARA_API_KEY before launch and run /mcp to verify the project-local server."
-    );
-    printNextStep(
-      `To enable Companion lifecycle hooks, run ${COMPANION_NPX_COMMAND} automations install --client kimi, review .kimi-code/snipara-plugin, then install it in Kimi with /plugins install .kimi-code/snipara-plugin.`
-    );
-    printNextStep(
-      "Keep manual approval for risky tools because Kimi hooks are fail-open and are not a standalone security boundary."
-    );
-  }
-  if (answers.aiClient === "codex") {
-    printNextStep(
-      "For Codex, merge .snipara/templates/codex-config.toml into ~/.codex/config.toml if the app does not read project .codex/config.toml."
-    );
-    printNextStep(
-      "Restart Codex after changing ~/.codex/config.toml so it rediscovers the hosted Snipara MCP tools."
-    );
-    printNextStep(
-      "If Codex shows only the lean Snipara tool set, that is expected. Use snipara_help(query=...) for routed guidance, confirm specialist opt-in surfaces with snipara_help(list_all=true), and request exact htask or swarm tools only when the workflow explicitly needs them."
-    );
-    printNextStep(
-      "If Codex still does not expose the hosted task-routing tools, prefer snipara-orchestrator swarm-* and htask-* for shared queue or multi-agent task work."
-    );
-  }
-  if (answers.aiClient === "mistral") {
-    printNextStep(
-      "For Mistral Le Chat, add .snipara/templates/mistral-le-chat-mcp.json as a Custom MCP Connector reference in Connectors."
-    );
-    printNextStep(
-      "For Mistral Vibe, keep .vibe/config.toml or ~/.vibe/config.toml on the generated SNIPARA_API_KEY-backed streamable-http server block, then restart Vibe."
-    );
-    printNextStep(
-      "For LangChain JavaScript, adapt .snipara/templates/mistral-langchain-tools.ts to bind Snipara recall, context_query, and settings tools to ChatMistralAI."
-    );
-  }
-  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.`
-    );
-    printNextStep(`Activate local source context now with: ${COMPANION_NPX_COMMAND} source init .`);
-    printNextStep(
-      `Use ${COMPANION_NPX_COMMAND} recall / query / plan / upload / task-commit for explicit local workflows and as a fallback when an AI client exposes only a partial MCP surface.`
-    );
-    printNextStep(
-      `For business folders, preview with: ${COMPANION_NPX_COMMAND} onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json`
-    );
-    printNextStep(
-      `Apply after review with: ${COMPANION_NPX_COMMAND} onboard-folder ./client-export --source-provider local_folder --apply`
-    );
-  } else if (answers.profile !== "runtime-only") {
-    printNextStep(
-      `Enable Companion, guards, managed workflows, and local folder helpers later with: ${CREATE_SNIPARA_NPX_COMMAND} repair --with-companion`
-    );
-  }
-  if (answers.installRuntime && !answers.runSandboxInit) {
-    printNextStep(
-      `Run ${SANDBOX_COMMAND_NAME} init when you want to choose sandbox/docker/local execution.`
-    );
-  }
-  if (answers.installOrchestrator) {
-    printNextStep(
-      `Use ${ORCHESTRATOR_COMMAND_NAME} explicitly for production proof gates, drift checks, or htask coordination.`
-    );
-  }
-  if (answers.githubRepo) {
-    printNextStep(
-      `Connect GitHub automation for ${answers.githubRepo.fullName} from the generated Snipara link.`
-    );
+  console.log(chalk.bold("\nNext action:\n"));
+  if (activationManifest) {
+    console.log("   Restart your AI client or open a new agent session, then ask:");
+    console.log(chalk.cyan(`
+   "${activationManifest.dayZeroQuery.query}"
+`));
+    console.log(chalk.dim(`   If Snipara tools are missing: ${CREATE_SNIPARA_NPX_COMMAND} doctor`));
+  } else if (answers.installRuntime && !answers.runSandboxInit) {
+    console.log(`   Run ${SANDBOX_COMMAND_NAME} init to choose an execution backend.`);
+  } else {
+    console.log(`   Run ${CREATE_SNIPARA_NPX_COMMAND} doctor to verify the installation.`);
   }
   if (failedChecks.length > 0 || warnedChecks.length > 0) {
     console.log(chalk.bold("\nValidation summary:\n"));
@@ -5014,11 +5360,9 @@ function printSuccess(answers, report, activationManifest) {
       const symbol = check.status === "fail" ? chalk.red("\u2717") : chalk.yellow("!");
       console.log(`   ${symbol} ${check.name}: ${check.detail}`);
     }
-    console.log(
-      chalk.dim(`
-   Run ${CREATE_SNIPARA_NPX_COMMAND} repair to rebuild local wiring.
-`)
-    );
+    console.log(chalk.dim(`
+   Repair local wiring: ${CREATE_SNIPARA_NPX_COMMAND} repair
+`));
   } else {
     console.log(
       chalk.dim(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-snipara",
-  "version": "2.0.14",
-  "description": "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
+  "version": "2.0.16",
+  "description": "Onboard Snipara Hosted MCP Context + Memory with project bootstrap intelligence and optional local workflows",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -10,7 +10,7 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts --format esm --watch",
-    "prepublishOnly": "npm run build",
+    "prepack": "npm run build",
     "pretest": "pnpm build",
     "test": "node --test test/*.test.cjs",
     "pack:smoke": "bash ../../scripts/smoke-node-package.sh packages/create-snipara create-snipara create-snipara --help",