create-snipara 2.0.8 → 2.0.10

package/README.md

@@ -26,6 +26,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
 
 ## Why It Exists
 
@@ -114,7 +115,7 @@ That distinction matters:
 - installs optional `snipara-sandbox`
 - installs optional `snipara-orchestrator` for proof gates, drift checks, and htask workflows when requested
 - configures `.mcp.json`
-- generates merge-ready AI agent templates in `.snipara/templates/`, including Pro+ symbol-card, code-impact, and managed workflow guidance for paid Context plans
+- generates merge-ready AI agent templates in `.snipara/templates/`, including symbol-card, code-impact, and managed workflow guidance within plan capacity
 - 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

package/dist/index.js

@@ -13,7 +13,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "create-snipara",
-  version: "2.0.8",
+  version: "2.0.10",
   description: "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   main: "dist/index.js",
   type: "module",
@@ -104,6 +104,9 @@ var SANDBOX_COMMAND_NAME = "snipara-sandbox";
 var LEGACY_SANDBOX_COMMAND_NAME = "rlm";
 var ORCHESTRATOR_COMMAND_NAME = "snipara-orchestrator";
 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 EXPERIENCE_GOAL_SECTION = `## Experience Goal
 
 The target experience is outcome-first agent work across supported clients:
@@ -115,6 +118,19 @@ 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.";
+var DECISION_COMMIT_TERMS = [
+  "adopt",
+  "because",
+  "decide",
+  "decision",
+  "drop",
+  "migrate",
+  "prefer",
+  "replace",
+  "revert",
+  "standardize",
+  "switch"
+];
 function buildActivationId() {
   return `act_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -200,23 +216,196 @@ function readRecentCommitSubjects() {
     return [];
   }
 }
+function readDecisionCommitSubjectLines() {
+  try {
+    const output = execSync("git log --pretty=format:%h%x20%s --max-count=50", {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1500
+    }).trim();
+    if (!output) {
+      return [];
+    }
+    return output.split(/\r?\n/).map((line) => line.trim()).filter((line) => DECISION_COMMIT_TERMS.some((term) => line.toLowerCase().includes(term))).slice(0, 8);
+  } 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);
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => /decision|decided|must|should|always|never|convention|rule/i.test(line)).slice(0, 4).map((line) => ({
+    source: relativePath,
+    text: line.slice(0, 280),
+    status: "needs_review",
+    reason: "Detected project guidance language. Review before storing as durable memory.",
+    evidence: classifyDecisionSource(relativePath)
+  }));
+}
+function estimateFileTokens(relativePath) {
+  const absolutePath = path.join(process.cwd(), relativePath);
+  if (!fs.existsSync(absolutePath) || fs.statSync(absolutePath).isDirectory()) {
+    return 0;
+  }
+  try {
+    const content = fs.readFileSync(absolutePath, "utf8");
+    return Math.ceil(content.length / 4);
+  } catch {
+    return 0;
+  }
 }
 function buildMemoryCandidatePreviews(scan) {
-  return scan.files.candidateDocs.flatMap(
-    (source) => readMemoryCandidateLines(source).map((line) => ({
+  const seen = /* @__PURE__ */ new Set();
+  const gitCandidates = scan.git.recentDecisionCommits.map((line) => ({
+    source: "git log",
+    text: line.slice(0, 280),
+    status: "needs_review",
+    reason: "Detected decision-language in recent commit history. Confirm intent before storing.",
+    evidence: "git_commit_subject"
+  }));
+  const candidates = [
+    ...scan.files.candidateDocs.flatMap(readMemoryCandidateLines),
+    ...gitCandidates
+  ];
+  return candidates.filter((candidate) => {
+    const key = `${candidate.source}:${candidate.text}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  }).slice(0, 20);
+}
+function readTextFileSnippet(relativePath, maxChars = 24e3) {
+  const absolutePath = path.join(process.cwd(), relativePath);
+  if (!fs.existsSync(absolutePath) || fs.statSync(absolutePath).isDirectory()) {
+    return "";
+  }
+  try {
+    return fs.readFileSync(absolutePath, "utf8").slice(0, maxChars);
+  } catch {
+    return "";
+  }
+}
+function collectDayZeroCorpusDocuments(scan) {
+  const documents = [];
+  let totalChars = 0;
+  const cwd = process.cwd();
+  const rootReadmes = fs.existsSync(cwd) ? fs.readdirSync(cwd).filter((entry) => /^readme(?:\.[a-z0-9_-]+)?\.mdx?$/i.test(entry)).sort() : [];
+  const sources = [
+    ...rootReadmes,
+    ...listFilesUnder("docs", DAY_ZERO_CORPUS_MAX_FILES * 8),
+    ...scan.files.candidateDocs
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const normalized = source.replace(/\\/g, "/");
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    const lower = normalized.toLowerCase();
+    const isReadme = /^readme(?:\.[a-z0-9_-]+)?\.mdx?$/.test(lower);
+    const isDocsMarkdown = lower.startsWith("docs/") && /\.(?:md|mdx|markdown|txt|rst|adoc)$/.test(lower);
+    if (!isReadme && !isDocsMarkdown) {
+      continue;
+    }
+    if (documents.length >= DAY_ZERO_CORPUS_MAX_FILES) {
+      break;
+    }
+    if (totalChars >= DAY_ZERO_CORPUS_MAX_TOTAL_CHARS) {
+      break;
+    }
+    const remainingChars = DAY_ZERO_CORPUS_MAX_TOTAL_CHARS - totalChars;
+    const content = readTextFileSnippet(
       source,
-      text: line.slice(0, 280),
-      status: "needs_review",
-      reason: "Detected project guidance language. Review before storing as durable memory."
-    }))
-  ).slice(0, 12);
+      Math.min(DAY_ZERO_CORPUS_MAX_FILE_CHARS, remainingChars)
+    ).trim();
+    if (!content) {
+      continue;
+    }
+    documents.push({
+      path: normalized,
+      content
+    });
+    totalChars += content.length;
+  }
+  return documents;
+}
+function createDayZeroCorpusReport(status, documents, detail, options = {}) {
+  return {
+    status,
+    documents: documents.map((document) => ({
+      path: document.path,
+      chars: document.content.length
+    })),
+    detail,
+    ...options.tool ? { tool: options.tool } : {},
+    ...options.error ? { error: options.error.slice(0, 500) } : {}
+  };
+}
+function buildStalenessFindings(scan) {
+  const findings = [];
+  const scriptSet = new Set(scan.scripts);
+  for (const source of scan.files.candidateDocs.slice(0, 30)) {
+    const content = readTextFileSnippet(source);
+    if (!content) {
+      continue;
+    }
+    const scriptMatches = [...content.matchAll(/\b(?:npm|pnpm|yarn|bun)\s+run\s+([a-z0-9:_-]+)/gi)];
+    for (const match of scriptMatches) {
+      const scriptName = match[1];
+      if (scriptName && !scriptSet.has(scriptName)) {
+        findings.push({
+          source,
+          severity: "possible",
+          summary: `Documentation references \`${match[0]}\`, but package.json has no \`${scriptName}\` script.`,
+          recommendation: "Verify the setup docs or add the missing script before relying on this instruction."
+        });
+      }
+    }
+    if (scan.packageManagers.length === 1 && scan.packageManagers[0] === "pnpm" && /\bnpm install\b/i.test(content)) {
+      findings.push({
+        source,
+        severity: "possible",
+        summary: "Documentation mentions `npm install`, but the repo has a pnpm lockfile.",
+        recommendation: "Confirm whether npm remains supported or update setup docs to pnpm."
+      });
+    }
+  }
+  return findings.slice(0, 8);
+}
+function buildContextEconomyReport(scan, dayZeroQuery) {
+  const indexedSourceTokens = scan.files.candidateDocs.reduce(
+    (total, source) => total + estimateFileTokens(source),
+    0
+  );
+  const rawWindowBaselineTokens = Math.max(indexedSourceTokens, 8e3);
+  const estimatedPromptTokens = Math.ceil(dayZeroQuery.length / 4);
+  const estimatedRetrievedTokens = Math.min(
+    rawWindowBaselineTokens,
+    Math.max(estimatedPromptTokens + scan.files.candidateDocs.length * 160, 1200)
+  );
+  const estimatedSavedTokens = Math.max(0, rawWindowBaselineTokens - estimatedRetrievedTokens);
+  return {
+    basis: "activation_estimate",
+    rawWindowBaselineTokens,
+    estimatedRetrievedTokens,
+    estimatedSavedTokens,
+    savingsPercent: rawWindowBaselineTokens > 0 ? Math.round(estimatedSavedTokens / rawWindowBaselineTokens * 100) : 0,
+    note: "Estimated from activation sources until hosted query receipts provide measured savings."
+  };
+}
+function buildAgentReadinessReport(scan) {
+  const findings = buildStalenessFindings(scan);
+  return {
+    stalenessFindings: findings,
+    summary: findings.length > 0 ? `${findings.length} possible doc staleness finding(s) need review.` : "No obvious setup-doc staleness found in activation sources."
+  };
 }
 function writeMemoryCandidates(candidates) {
   fs.mkdirSync(getActivationDir(), { recursive: true });
@@ -261,15 +450,7 @@ function writeInitialHandoff(answers, manifest) {
 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 candidateDocs = findDecisionArchaeologySources(cwd);
   const lockfiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"].filter(
     exists
   );
@@ -305,15 +486,76 @@ function detectLocalActivationScan(detection) {
     git: {
       detected: detection.inGitRepo,
       branch: detection.inGitRepo ? detectGitBranch() : null,
-      remote: detection.inGitRepo ? readGitRemote() : null
+      remote: detection.inGitRepo ? readGitRemote() : null,
+      recentDecisionCommits: detection.inGitRepo ? readDecisionCommitSubjectLines() : []
+    }
+  };
+}
+function classifyDecisionSource(relativePath) {
+  if (/(^|\/)(adr|decisions?)(\/|$)/i.test(relativePath)) {
+    return "adr_or_decision_doc";
+  }
+  if (/AGENTS\.md|CLAUDE\.md|MEMORY\.md|\.cursor\/rules|copilot-instructions/i.test(relativePath)) {
+    return "agent_instruction";
+  }
+  if (/CHANGELOG/i.test(relativePath)) {
+    return "changelog";
+  }
+  return "project_document";
+}
+function listFilesUnder(relativeDir, maxFiles) {
+  const root = path.join(process.cwd(), relativeDir);
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  const visit = (dir) => {
+    if (results.length >= maxFiles) {
+      return;
+    }
+    for (const entry of fs.readdirSync(dir).sort()) {
+      const absolutePath = path.join(dir, entry);
+      const stat = fs.statSync(absolutePath);
+      if (stat.isDirectory()) {
+        visit(absolutePath);
+      } else if (/\.(md|mdx|txt|mdc)$/i.test(entry)) {
+        results.push(path.relative(process.cwd(), absolutePath));
+      }
+      if (results.length >= maxFiles) {
+        return;
+      }
     }
   };
+  visit(root);
+  return results;
+}
+function findDecisionArchaeologySources(cwd) {
+  const exists = (relativePath) => fs.existsSync(path.join(cwd, relativePath));
+  const directSources = [
+    "README.md",
+    "CHANGELOG.md",
+    "MEMORY.md",
+    ...["AGENTS.md", "CLAUDE.md", ".github/copilot-instructions.md"].filter(
+      (source) => exists(source)
+    )
+  ].filter(exists);
+  const archaeologySources = [
+    ...listFilesUnder("docs/adr", 20),
+    ...listFilesUnder("docs/adrs", 20),
+    ...listFilesUnder("docs/decision", 20),
+    ...listFilesUnder("docs/decisions", 20),
+    ...listFilesUnder(".cursor/rules", 20)
+  ];
+  return [.../* @__PURE__ */ new Set([...directSources, ...archaeologySources])].slice(0, 80);
 }
 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";
+  const hotFiles = scan.files.candidateDocs.slice(0, 5);
+  const hotFileLine = hotFiles.length > 0 ? `First files to ground on: ${hotFiles.join(", ")}.` : "First grounding files will appear after local source sync or hosted provider sync.";
+  const dayZeroQuery = "What is this project, what is currently in flight, and what should an agent know before making the first edit?";
   return {
     title: `First Work Brief for ${answers.projectSlug}`,
     status: "partial",
@@ -332,9 +574,17 @@ function createInitialFirstWorkBrief(answers, detection, scan) {
         lines: [
           `Initial docs: ${docs}.`,
           `Package scripts: ${commands}.`,
+          hotFileLine,
           "Source indexing runs before claiming architecture certainty."
         ]
       },
+      {
+        title: "Day-zero answer pack",
+        lines: [
+          `Ask Snipara: "${dayZeroQuery}"`,
+          "Goal: reach one correct, non-obvious statement about this repository in under 5 minutes."
+        ]
+      },
       {
         title: "Current risks",
         lines: [
@@ -349,22 +599,40 @@ function createInitialFirstWorkBrief(answers, detection, scan) {
       {
         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."
+          "Code Graph is available on Free within capacity caps; first answers improve as symbols index.",
+          "For the first PR, run snipara_code_impact or companion code impact before editing."
         ]
       }
     ]
   };
 }
-function createActivationManifest(answers, detection, mode = "default") {
+function createActivationManifest(answers, detection, mode = "default", scan) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const hasHostedConfig = answers.profile !== "runtime-only";
   const hasCompanion = answers.installCompanion;
-  const localScan = detectLocalActivationScan(detection);
+  const localScan = scan ?? detectLocalActivationScan(detection);
+  const dayZeroQuery = "What is this project, what is currently in flight, and what should an agent know before making the first edit?";
   return {
     version: "create-snipara-activation-v1",
     activationId: buildActivationId(),
     mode,
+    activationMetric: {
+      name: "time_to_how_did_it_know_that",
+      targetMinutes: 5,
+      proof: "A correct, non-obvious statement about this repository from the first answer pack."
+    },
+    dayZeroQuery: {
+      tool: "snipara_context_query",
+      query: dayZeroQuery,
+      expectedOutcome: "First own-repo answer pack before the user reads product docs."
+    },
+    dayZeroCorpus: createDayZeroCorpusReport(
+      "queued",
+      collectDayZeroCorpusDocuments(localScan),
+      "README and docs Markdown will be submitted to hosted context before the first day-zero query when live hosted checks are enabled."
+    ),
+    agentReadiness: buildAgentReadinessReport(localScan),
+    contextEconomy: buildContextEconomyReport(localScan, dayZeroQuery),
     projectSlug: answers.projectSlug,
     projectId: answers.projectId || null,
     repoPath: process.cwd(),
@@ -390,12 +658,12 @@ function createActivationManifest(answers, detection, mode = "default") {
         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."
+        hasHostedConfig || hasCompanion ? "queued" : "skipped",
+        hasCompanion ? "Context indexing starts from local docs and instruction files." : hasHostedConfig ? "Day-zero README/docs sync will seed hosted context when live hosted checks run." : "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."
+        hasCompanion ? "Free Code Graph indexing starts from local source overlay within capacity caps." : "Free Code Graph is available after companion or hosted provider sync."
       ),
       memoryCandidates: createActivationLane(
         hasCompanion ? "needs_review" : "skipped",
@@ -407,7 +675,7 @@ function createActivationManifest(answers, detection, mode = "default") {
       ),
       firstBrief: createActivationLane(
         "ready",
-        "First Work Brief preview generated from local setup signals."
+        "First Work Brief and day-zero answer-pack prompt generated from local setup signals."
       ),
       githubSync: createActivationLane(
         answers.configureGitHub && answers.githubRepo ? "queued" : "skipped",
@@ -495,6 +763,115 @@ function runLocalSourceActivation(answers, manifest) {
   }
   updateActivationManifest(manifest);
 }
+async function runHostedDayZeroCorpusSync(answers, manifest, enabled) {
+  if (answers.profile === "runtime-only") {
+    manifest.dayZeroCorpus = createDayZeroCorpusReport(
+      "skipped",
+      [],
+      "Runtime-only profile skipped Hosted MCP config and hosted document sync."
+    );
+    updateActivationManifest(manifest);
+    return;
+  }
+  if (!enabled) {
+    const documents2 = collectDayZeroCorpusDocuments(manifest.localScan);
+    manifest.dayZeroCorpus = createDayZeroCorpusReport(
+      "skipped",
+      documents2,
+      "Skipped because hosted validation was disabled with --skip-test."
+    );
+    updateActivationManifest(manifest);
+    return;
+  }
+  if (answers.apiKeyType === "none" || answers.apiKey.includes("YOUR_")) {
+    manifest.dayZeroCorpus = createDayZeroCorpusReport(
+      "skipped",
+      [],
+      "Skipped because no live hosted API key was available."
+    );
+    updateActivationManifest(manifest);
+    return;
+  }
+  const documents = collectDayZeroCorpusDocuments(manifest.localScan);
+  if (documents.length === 0) {
+    manifest.dayZeroCorpus = createDayZeroCorpusReport(
+      "skipped",
+      [],
+      "No README or docs Markdown files were found to seed hosted context."
+    );
+    if (manifest.lanes.contextIndex.status === "queued") {
+      manifest.lanes.contextIndex = createActivationLane(
+        "skipped",
+        "No README or docs Markdown files were found to seed hosted context."
+      );
+    }
+    updateActivationManifest(manifest);
+    return;
+  }
+  const syncTool = "snipara_sync_documents";
+  const syncResponse = await callHostedMcp(answers, "tools/call", {
+    name: syncTool,
+    arguments: {
+      documents,
+      delete_missing: false
+    }
+  });
+  if (syncResponse.ok && !syncResponse.data.error) {
+    manifest.dayZeroCorpus = createDayZeroCorpusReport(
+      "submitted",
+      documents,
+      `Submitted ${documents.length} README/docs files to hosted context for the first day-zero answer pack.`,
+      { tool: syncTool }
+    );
+    manifest.lanes.contextIndex = createActivationLane(
+      "indexing",
+      "Day-zero README/docs corpus submitted to hosted context indexing.",
+      syncTool
+    );
+    updateActivationManifest(manifest);
+    return;
+  }
+  const uploadTool = "snipara_upload_document";
+  const uploadErrors = [];
+  for (const document of documents) {
+    const uploadResponse = await callHostedMcp(answers, "tools/call", {
+      name: uploadTool,
+      arguments: document
+    });
+    if (!uploadResponse.ok || uploadResponse.data.error) {
+      uploadErrors.push(
+        uploadResponse.ok ? describeJsonRpcError(uploadResponse.data) : describeHostedHttpFailure(uploadResponse.status, uploadResponse.bodyText)
+      );
+      break;
+    }
+  }
+  if (uploadErrors.length === 0) {
+    manifest.dayZeroCorpus = createDayZeroCorpusReport(
+      "submitted",
+      documents,
+      `Submitted ${documents.length} README/docs files to hosted context for the first day-zero answer pack.`,
+      { tool: uploadTool }
+    );
+    manifest.lanes.contextIndex = createActivationLane(
+      "indexing",
+      "Day-zero README/docs corpus submitted to hosted context indexing.",
+      uploadTool
+    );
+  } else {
+    const syncError = syncResponse.ok ? describeJsonRpcError(syncResponse.data) : describeHostedHttpFailure(syncResponse.status, syncResponse.bodyText);
+    const detail = `Could not submit the day-zero README/docs corpus. sync_documents: ${syncError}; upload_document: ${uploadErrors[0]}`;
+    manifest.dayZeroCorpus = createDayZeroCorpusReport("failed", documents, detail, {
+      tool: syncTool,
+      error: detail
+    });
+    manifest.lanes.contextIndex = failActivationLane(
+      "Hosted day-zero README/docs sync failed; the first answer may need GitHub, companion, or a later sync.",
+      syncTool,
+      new Error(detail)
+    );
+  }
+  updateActivationManifest(manifest);
+}
 function createActivationArtifacts(answers, manifest) {
   const candidates = buildMemoryCandidatePreviews(manifest.localScan);
   writeMemoryCandidates(candidates);
@@ -776,6 +1153,8 @@ function parseInitOptionsFromArgv(args) {
 async function runInit(options) {
   const normalizedOptions = normalizeInitOptions(options);
   const answers = await gatherConfiguration(normalizedOptions);
+  const activationDetection = detectEnvironment();
+  const activationScan = detectLocalActivationScan(activationDetection);
   if (answers.installMcp || answers.installRuntime || answers.installOrchestrator) {
     await installPythonPackages(answers, false);
   }
@@ -802,9 +1181,11 @@ async function runInit(options) {
   writeDoctorReport(validationReport);
   const activationManifest = createActivationManifest(
     answers,
-    detectEnvironment(),
-    normalizedOptions.starter ? "starter" : "default"
+    activationDetection,
+    normalizedOptions.starter ? "starter" : "default",
+    activationScan
   );
+  await runHostedDayZeroCorpusSync(answers, activationManifest, !normalizedOptions.skipTest);
   runLocalSourceActivation(answers, activationManifest);
   createActivationArtifacts(answers, activationManifest);
   printSuccess(answers, validationReport, activationManifest);
@@ -2201,8 +2582,8 @@ Agent task lifecycle:
    work.
 6. Use whichever structural code graph tools are exposed in the current session
    for callers, imports, neighbors, and path questions. Tool exposure can vary.
-7. On paid Context plans, use \`snipara_code_symbol_card\` for agent-ready symbol
-   context and \`snipara-companion code impact\` before risky multi-file changes, PR
+7. Use \`snipara_code_symbol_card\` for agent-ready symbol context within plan
+   capacity and \`snipara-companion code impact\` before risky multi-file changes, PR
    reviews, routes, services, jobs, auth, billing, deployment, schema, migrations,
    or explicit "what is missing" assessments.
 8. Use \`snipara_plan\` for complex or multi-surface work in any plan when
@@ -2269,7 +2650,7 @@ ${EXPERIENCE_GOAL_SECTION}
 - Use \`snipara_code_callers\`, \`snipara_code_imports\`, \`snipara_code_neighbors\`, or \`snipara_code_shortest_path\` for canonical structural code questions.
 - For code impact and structural code questions, use \`snipara-companion code callers/imports/neighbors/shortest-path/impact\` first when \`snipara-companion\` is installed; it auto-selects hosted MCP for clean indexed code or the local overlay for dirty/ahead worktrees and reports \`sourceSelection\`. Use hosted \`snipara_code_impact\` only when companion is unavailable or after push/reindex for canonical graph impact.
 - Run \`snipara-companion code impact\` before risky multi-file changes, PR reviews, routes, services, jobs, auth, billing, deployment, schema, migrations, or explicit "what is missing" assessments.
-- On paid Context plans, use \`snipara_code_symbol_card\` before editing important symbols.
+- Use \`snipara_code_symbol_card\` before editing important symbols within plan capacity.
 - Check every \`snipara_code_*\` response for indexed commit SHA, indexing time, included files, coverage, and freshness warnings.
 - Use local file reads, \`rg\`, \`git status --short\`, and tests for exact edits/current working tree; use Snipara for architecture and indexed code graph context.
 - If a broad query is slow, retry once with a narrow keyword query before falling back to local search.
@@ -2309,7 +2690,7 @@ ${EXPERIENCE_GOAL_SECTION}
 - Use \`snipara_code_callers\`, \`snipara_code_imports\`, \`snipara_code_neighbors\`, or \`snipara_code_shortest_path\` for canonical structural code questions.
 - For code impact and structural code questions, use \`snipara-companion code callers/imports/neighbors/shortest-path/impact\` first when \`snipara-companion\` is installed; it auto-selects hosted MCP for clean indexed code or the local overlay for dirty/ahead worktrees and reports \`sourceSelection\`. Use hosted \`snipara_code_impact\` only when companion is unavailable or after push/reindex for canonical graph impact.
 - Run \`snipara-companion code impact\` before risky multi-file changes, PR reviews, routes, services, jobs, auth, billing, deployment, schema, migrations, or explicit "what is missing" assessments.
-- On paid Context plans, use \`snipara_code_symbol_card\` before editing important symbols.
+- Use \`snipara_code_symbol_card\` before editing important symbols within plan capacity.
 - Check every \`snipara_code_*\` response for indexed commit SHA, indexing time, included files, coverage, and freshness warnings.
 - Use \`snipara_plan\` for complex or multi-surface work when available. Keep simple Q&A on targeted \`snipara_context_query\`; for FULL-mode audits, comparisons, roadmap/implementation planning, release readiness, or package-surface reviews, use \`snipara_decompose\` to preserve axes and \`snipara_multi_query\` for independent follow-up questions when Pro+ tools are exposed.
 - Use local file reads, \`rg\`, \`git status --short\`, and tests for exact code edits and current working-tree state.
@@ -3121,7 +3502,7 @@ function getCompanionCommands(answers) {
     {
       title: "Analyze code impact before a risky change",
       command: `${COMPANION_NPX_COMMAND} code impact --changed-files src/api/webhooks.ts tests/webhooks.test.ts --diff-summary "webhook retry hardening"`,
-      purpose: "Use paid Context code impact analysis to surface likely tests, docs, routes, config, and risks."
+      purpose: "Use code impact analysis within plan capacity to surface likely tests, docs, routes, config, and risks."
     },
     {
       title: answers.installOrchestrator ? "Run an explicit production orchestration gate" : "Enable explicit production orchestration",
@@ -3292,7 +3673,7 @@ ${guidance.map((line) => `- ${line}`).join("\n")}
 - Use \`answer_pack\` facts, caveats, source maps, and verification checks before making claims.
 - For coding tasks, choose a workflow mode before editing: LITE for small single-phase changes, FULL managed workflow for multi-file, risky, release/deploy, architectural, compaction-prone, or future-maintainer-sensitive work.
 - Use \`snipara_plan\` for complex or multi-surface work when exposed. Keep simple Q&A on targeted \`snipara_context_query\`; for FULL-mode audits, comparisons, roadmap/implementation planning, release readiness, or package-surface reviews, use \`snipara_decompose\` to preserve axes and \`snipara_multi_query\` for independent follow-up questions when Pro+ tools are exposed.
-- Use \`snipara_code_symbol_card\` for important symbols. For risky multi-file changes, PR reviews, routes, services, jobs, auth, billing, deployment, schema, migrations, or explicit "what is missing" assessments, use \`snipara-companion code impact\` first when companion is available; use hosted \`snipara_code_impact\` only when companion is unavailable or after push/reindex for canonical graph impact.
+- Use \`snipara_code_symbol_card\` for important symbols within plan capacity. For risky multi-file changes, PR reviews, routes, services, jobs, auth, billing, deployment, schema, migrations, or explicit "what is missing" assessments, use \`snipara-companion code impact\` first when companion is available; use hosted \`snipara_code_impact\` only when companion is unavailable or after push/reindex for canonical graph impact.
 - Use the installed \`snipara-companion\` binary for low-latency hooks; use \`${COMPANION_NPX_COMMAND}\` for one-off terminal commands when freshness matters.
 - If a broad query is slow, retry once with a narrow keyword query before falling back to local search.
 - Use a JSON machine plan plus \`snipara-companion workflow start\`, \`phase-start\`, \`phase-commit\`, \`workflow resume\`, and \`final-commit\` for multi-phase work. After \`workflow resume\`, rerun \`workflow phase-start <phase_id>\` before editing again.
@@ -4117,6 +4498,33 @@ function printActivationSummary(manifest) {
       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}`);
+  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("\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}`
+    )
+  );
   console.log(
     chalk.dim(
       `

package/package.json

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