create-snipara 2.0.10 → 2.0.12

package/README.md

@@ -14,6 +14,9 @@ npx create-snipara
 creates or reuses auth, writes Hosted MCP config, and prepares the local project
 so an LLM client can use Snipara context and reviewed memory. The default path is
 hosted-only so the first success is a grounded answer, not a local tooling tour.
+It is also the canonical activation engine behind editor setup docs: VS Code can
+surface activation as a native command, Cursor can pair OpenVSX UI with Hosted
+MCP, but both paths should land on the same project context.
 
 Use it when the goal is outcome-first agent work: the user asks for judgment,
 implementation, release, or verification, and the agent handles Snipara context,

package/dist/index.js

@@ -13,7 +13,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "create-snipara",
-  version: "2.0.10",
+  version: "2.0.12",
   description: "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   main: "dist/index.js",
   type: "module",
@@ -107,6 +107,8 @@ 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 ACTIVATION_MANIFEST_SCHEMA_VERSION = "snipara.activation.manifest.v1";
+var ACTIVATION_CONSUMER_CONTRACT_VERSION = "snipara.editor.activation.v1";
 var EXPERIENCE_GOAL_SECTION = `## Experience Goal
 
 The target experience is outcome-first agent work across supported clients:
@@ -140,15 +142,23 @@ function getActivationDir() {
 function getActivationManifestPath() {
   return path.join(getActivationDir(), "manifest.json");
 }
+function getStableActivationManifestPath() {
+  return path.join(getActivationDir(), "activation-manifest.json");
+}
 function getActivationHandoffPath() {
   return path.join(getActivationDir(), "handoff.md");
 }
+function getFirstWorkBriefPath() {
+  return path.join(getActivationDir(), "first-brief.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");
+  const payload = JSON.stringify(manifest, null, 2) + "\n";
+  fs.writeFileSync(getActivationManifestPath(), payload, "utf8");
+  fs.writeFileSync(getStableActivationManifestPath(), payload, "utf8");
 }
 function updateActivationManifest(manifest) {
   manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -427,6 +437,9 @@ function writeInitialHandoff(answers, manifest) {
     `Repo path: ${manifest.repoPath}`,
     `Git branch: ${manifest.git.branch ?? "not detected"}`,
     `Git remote: ${manifest.git.remote ?? "not detected"}`,
+    `Activation doctrine: ${manifest.surfaceContract.doctrine}`,
+    `Activation engine: ${manifest.surfaceContract.engine}`,
+    `Entry point: ${manifest.surfaceContract.entryPoint}`,
     "",
     "## Activation lanes",
     ...Object.entries(manifest.lanes).map(
@@ -440,6 +453,7 @@ function writeInitialHandoff(answers, manifest) {
     ...recentCommits.length > 0 ? recentCommits.map((line) => `- ${line}`) : ["- not available"],
     "",
     "## Next",
+    `- ${manifest.surfaceContract.nextSurfaceAction}`,
     "- 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.",
@@ -447,6 +461,24 @@ function writeInitialHandoff(answers, manifest) {
   ];
   fs.writeFileSync(getActivationHandoffPath(), lines.join("\n"), "utf8");
 }
+function writeFirstWorkBrief(manifest) {
+  fs.mkdirSync(getActivationDir(), { recursive: true });
+  const lines = [
+    `# ${manifest.firstBrief.title}`,
+    "",
+    `Status: ${manifest.firstBrief.status}`,
+    `Activation: ${manifest.activationId}`,
+    `Client: ${getClientDisplayName(manifest.aiClient)}`,
+    "",
+    ...manifest.firstBrief.sections.flatMap((section) => [
+      `## ${section.title}`,
+      "",
+      ...section.lines.map((line) => `- ${line}`),
+      ""
+    ])
+  ];
+  fs.writeFileSync(getFirstWorkBriefPath(), lines.join("\n"), "utf8");
+}
 function detectLocalActivationScan(detection) {
   const cwd = process.cwd();
   const exists = (relativePath) => fs.existsSync(path.join(cwd, relativePath));
@@ -549,6 +581,7 @@ function findDecisionArchaeologySources(cwd) {
   return [.../* @__PURE__ */ new Set([...directSources, ...archaeologySources])].slice(0, 80);
 }
 function createInitialFirstWorkBrief(answers, detection, scan) {
+  const surfaceContract = buildActivationSurfaceContract(answers.aiClient);
   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";
@@ -566,6 +599,7 @@ function createInitialFirstWorkBrief(answers, detection, scan) {
           detection.inGitRepo ? "Local Git repository detected." : "Local folder detected.",
           githubLine,
           `AI client: ${getClientDisplayName(answers.aiClient)}.`,
+          `Activation entry point: ${surfaceContract.entryPoint}.`,
           `Languages: ${languages}.`
         ]
       },
@@ -594,7 +628,10 @@ function createInitialFirstWorkBrief(answers, detection, scan) {
       },
       {
         title: "Suggested next task",
-        lines: ["Ask your agent what it should know before editing the first target area."]
+        lines: [
+          surfaceContract.nextSurfaceAction,
+          "Ask your agent what it should know before editing the first target area."
+        ]
       },
       {
         title: "Top impacted modules",
@@ -612,10 +649,14 @@ function createActivationManifest(answers, detection, mode = "default", scan) {
   const hasCompanion = answers.installCompanion;
   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?";
+  const surfaceContract = buildActivationSurfaceContract(answers.aiClient);
   return {
     version: "create-snipara-activation-v1",
+    schemaVersion: ACTIVATION_MANIFEST_SCHEMA_VERSION,
     activationId: buildActivationId(),
     mode,
+    surfaceContract,
+    consumerContract: buildEditorActivationConsumerContract(answers.aiClient),
     activationMetric: {
       name: "time_to_how_did_it_know_that",
       targetMinutes: 5,
@@ -683,9 +724,13 @@ function createActivationManifest(answers, detection, mode = "default", scan) {
       )
     },
     artifacts: {
+      activationManifestPath: path.relative(process.cwd(), getStableActivationManifestPath()),
+      legacyManifestPath: path.relative(process.cwd(), getActivationManifestPath()),
+      firstBriefPath: null,
       handoffPath: null,
       memoryCandidatesPath: null
     },
+    nextActions: buildActivationNextActions(surfaceContract, answers),
     firstBrief: createInitialFirstWorkBrief(answers, detection, localScan),
     createdAt: now,
     updatedAt: now
@@ -888,10 +933,12 @@ function createActivationArtifacts(answers, manifest) {
     "Initial local handoff created.",
     manifest.artifacts.handoffPath
   );
+  writeFirstWorkBrief(manifest);
+  manifest.artifacts.firstBriefPath = path.relative(process.cwd(), getFirstWorkBriefPath());
   manifest.lanes.firstBrief = createActivationLane(
     "ready",
     "First Work Brief generated from local setup and scan signals.",
-    path.relative(process.cwd(), getActivationManifestPath())
+    manifest.artifacts.firstBriefPath
   );
   updateActivationManifest(manifest);
 }
@@ -984,7 +1031,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("--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) => {
+  ).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("--json", "Print a machine-readable activation summary after setup").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);
   });
@@ -1025,7 +1072,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("--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");
+  ).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("--json", "Print a machine-readable activation summary after setup").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();
@@ -1125,6 +1172,7 @@ function parseInitOptionsFromArgv(args) {
     "--github": "github",
     "--skip-github": "skipGithub",
     "--starter": "starter",
+    "--json": "json",
     "--yes": "yes",
     "-y": "yes"
   };
@@ -1189,6 +1237,11 @@ async function runInit(options) {
   runLocalSourceActivation(answers, activationManifest);
   createActivationArtifacts(answers, activationManifest);
   printSuccess(answers, validationReport, activationManifest);
+  if (normalizedOptions.json) {
+    console.log(
+      JSON.stringify(buildActivationJsonSummary(activationManifest, validationReport), null, 2)
+    );
+  }
   if (answers.configureGitHub && answers.githubRepo) {
     await openGitHubAutomation(answers);
   }
@@ -1196,6 +1249,35 @@ async function runInit(options) {
     await runSandboxInit();
   }
 }
+function buildActivationJsonSummary(manifest, validation) {
+  const laneEntries = Object.entries(manifest.lanes);
+  const failedLanes = laneEntries.filter(([, lane]) => lane.status === "failed").map(([name]) => name);
+  const pendingLanes = laneEntries.filter(([, lane]) => lane.status === "queued" || lane.status === "indexing").map(([name]) => name);
+  const activationStatus = failedLanes.length > 0 ? "partial" : pendingLanes.length > 0 ? "partial" : "complete";
+  return {
+    ok: true,
+    activationStatus,
+    activationId: manifest.activationId,
+    schemaVersion: manifest.schemaVersion,
+    consumerContractVersion: manifest.consumerContract.version,
+    projectSlug: manifest.projectSlug,
+    aiClient: manifest.aiClient,
+    profile: validation.profile,
+    artifacts: manifest.artifacts,
+    lanes: Object.fromEntries(
+      laneEntries.map(([name, lane]) => [
+        name,
+        {
+          status: lane.status,
+          detail: lane.detail,
+          command: lane.command
+        }
+      ])
+    ),
+    nextActions: manifest.nextActions,
+    exitCode: activationStatus === "complete" ? 0 : manifest.consumerContract.exitCodes.activation_partial
+  };
+}
 async function runDoctor(options) {
   const normalizedOptions = normalizeMaintenanceOptions(options);
   const requestedClient = normalizeClientOption(normalizedOptions.client);
@@ -1279,11 +1361,12 @@ async function runUpgrade(options) {
   printDoctorReport(detectEnvironment(), report);
 }
 async function runPrintConfig(options) {
+  const normalizedOptions = normalizeMaintenanceOptions(options);
   const detection = detectEnvironment();
-  const answers = loadExistingAnswers(options);
+  const answers = loadExistingAnswers(normalizedOptions);
   const githubRepo = detectGitRepository();
   const githubAnswerPacks = githubRepo ? `${githubRepo.fullName} can be connected with npx create-snipara --github` : "requires a GitHub-backed git remote";
-  if (options.json) {
+  if (normalizedOptions.json) {
     console.log(
       JSON.stringify(
         {
@@ -3330,6 +3413,124 @@ function readCompanionConfigFile(filePath) {
     return {};
   }
 }
+function buildActivationSurfaceContract(client) {
+  const shared = {
+    doctrine: "one_activation_engine_multiple_entry_points",
+    engine: "create-snipara",
+    firstSuccessState: "Hosted MCP connected, local workspace context seeded, and a First Work Brief ready for the next agent session.",
+    mustNotDuplicate: [
+      "Local source scan heuristics",
+      "First Work Brief generation",
+      "memory-candidate extraction",
+      "Hosted MCP config contract"
+    ]
+  };
+  if (client === "cursor") {
+    return {
+      ...shared,
+      entryPoint: "Cursor extension or Cursor agent instructions call create-snipara",
+      clientRole: "Lightweight editor surface: expose rules, skills, and the canonical bootstrap path; do not fork activation logic.",
+      nextSurfaceAction: "In Cursor, ask the agent to run or verify `npx create-snipara@latest init --client cursor --starter`, then use the generated rules and Hosted MCP tools."
+    };
+  }
+  if (client === "vscode") {
+    return {
+      ...shared,
+      entryPoint: "VS Code extension command or create-snipara bootstrap",
+      clientRole: "Native editor UX surface: provide SecretStorage, progress, panels, status, and Copilot handoff while keeping activation semantics aligned with create-snipara.",
+      nextSurfaceAction: "In VS Code, run `Snipara: Activate Workspace` when the extension is installed, or keep using this generated pack when bootstrapping from the terminal."
+    };
+  }
+  if (client === "claude-code") {
+    return {
+      ...shared,
+      entryPoint: "Claude Code plugin or create-snipara bootstrap",
+      clientRole: "Agent-first surface: load Hosted MCP and project instructions, then use Companion only for explicit local continuity workflows.",
+      nextSurfaceAction: "Start a new Claude Code session and validate Snipara tools before enabling hooks or managed workflows."
+    };
+  }
+  return {
+    ...shared,
+    entryPoint: `${getClientDisplayName(client)} setup generated by create-snipara`,
+    clientRole: "MCP-compatible surface: consume the generated Hosted MCP reference and AGENTS.md rather than owning a separate activation model.",
+    nextSurfaceAction: "Restart or reload the client, verify Snipara tools, then ask the first grounded project question from the generated First Work Brief."
+  };
+}
+function buildEditorActivationConsumerContract(client) {
+  const secretRule = client === "vscode" ? "Use VS Code SecretStorage for SNIPARA_API_KEY and pass it to create-snipara through the child-process environment; never write raw secrets into extension settings or logs." : "Pass SNIPARA_API_KEY through the process environment or client secret store; never parse, log, or persist raw secrets from terminal output.";
+  return {
+    version: ACTIVATION_CONSUMER_CONTRACT_VERSION,
+    audience: "editor_extension",
+    stableFiles: {
+      activationManifest: ".snipara/activation/activation-manifest.json",
+      firstBrief: ".snipara/activation/first-brief.md",
+      handoff: ".snipara/activation/handoff.md",
+      memoryCandidates: ".snipara/activation/memory-candidates.json"
+    },
+    requiredManifestFields: [
+      "schemaVersion",
+      "consumerContract.version",
+      "surfaceContract",
+      "artifacts.activationManifestPath",
+      "artifacts.firstBriefPath",
+      "artifacts.handoffPath",
+      "lanes.connection.status",
+      "lanes.firstBrief.status",
+      "nextActions"
+    ],
+    laneStatuses: ["ready", "indexing", "queued", "needs_review", "skipped", "failed"],
+    exitCodes: {
+      success: 0,
+      activation_partial: 10,
+      auth_required: 20,
+      missing_api_key: 21,
+      missing_node_or_npm: 30,
+      activation_failed: 40
+    },
+    parseRule: "Read .snipara/activation/activation-manifest.json as the source of truth. If --json is used, parse the last JSON object from stdout as a summary pointer, not as the full durable state.",
+    secretRule
+  };
+}
+function buildActivationNextActions(surfaceContract, answers) {
+  const actions = [
+    {
+      id: "open_first_work_brief",
+      label: "Open First Work Brief",
+      target: "editor",
+      when: "artifacts.firstBriefPath is present and lanes.firstBrief.status is ready"
+    },
+    {
+      id: "handoff_to_agent",
+      label: "Hand off to the coding agent",
+      target: "agent",
+      when: "lanes.connection.status is ready and First Work Brief has been shown"
+    },
+    {
+      id: "review_memory_candidates",
+      label: "Review memory candidates",
+      target: "editor",
+      when: "lanes.memoryCandidates.status is needs_review"
+    }
+  ];
+  if (answers.aiClient === "vscode") {
+    actions.unshift({
+      id: "vscode_activate_workspace",
+      label: "Snipara: Activate Workspace",
+      command: "Snipara: Activate Workspace",
+      target: "editor",
+      when: "VS Code extension command is available"
+    });
+  } else {
+    actions.unshift({
+      id: "verify_surface_activation",
+      label: "Verify activation surface",
+      command: surfaceContract.nextSurfaceAction,
+      target: "agent",
+      when: "editor-specific command is unavailable"
+    });
+  }
+  return actions;
+}
 function getClientGuidance(client) {
   if (client === "claude-code") {
     return [
@@ -3339,6 +3540,7 @@ function getClientGuidance(client) {
   }
   if (client === "cursor") {
     return [
+      "Cursor is a lightweight editor entry point: use create-snipara as the canonical activation engine, then let Cursor consume the generated rules and Hosted MCP context.",
       "Cursor reads the generated .mcp.json directly, so the hosted Snipara MCP surface is available after restart.",
       "Use the companion CLI only for explicit upload, planning, chunk lookup, doctor, and task commit workflows outside the editor UI."
     ];
@@ -3374,6 +3576,7 @@ function getClientGuidance(client) {
   }
   if (client === "vscode") {
     return [
+      "VS Code can provide native activation UX, but create-snipara remains the canonical activation contract for generated files and local briefing semantics.",
       "VS Code and Copilot-style clients should use Hosted MCP plus AGENTS.md for project workflow rules.",
       "Use .snipara/templates/vscode-mcp-reference.json as the Snipara server reference when adding an MCP server."
     ];
@@ -3639,11 +3842,24 @@ function buildClientPackMarkdown(answers, commands, guidance) {
   const bootstrapCommand = commands.find(
     (command) => command.title === "Bootstrap local companion"
   );
+  const surfaceContract = buildActivationSurfaceContract(answers.aiClient);
   return `# Snipara Pack: ${clientName}
 
 This pack is the client-specific overlay for the generated Snipara project setup.
 Use \`AGENTS.md\` as the shared source of agent behavior, then apply the client-specific files below.
 
+## Activation Contract
+
+- Doctrine: one activation engine, multiple entry points
+- Canonical engine: \`${surfaceContract.engine}\`
+- Entry point: ${surfaceContract.entryPoint}
+- Client role: ${surfaceContract.clientRole}
+- First success state: ${surfaceContract.firstSuccessState}
+- Next surface action: ${surfaceContract.nextSurfaceAction}
+
+The client-specific files in this pack should not reimplement local source scanning,
+First Work Brief generation, memory-candidate extraction, or Hosted MCP config semantics.
+
 ## Hosted MCP
 
 - Endpoint: \`${buildHostedMcpEndpoint(answers)}\`
@@ -3692,6 +3908,8 @@ async function createCompanionPack(answers) {
   const readme = `# Snipara Companion Pack
 
 This project uses Snipara as a hosted-first project intelligence layer with source-backed context, reviewed memory, and local companion workflow helpers.
+The activation doctrine is: one shared activation engine, multiple entry points.
+\`create-snipara\` is the canonical bootstrap; editor extensions and plugins should provide UI, rules, or handoff affordances without forking the activation engine.
 
 ## Install Profile
 
@@ -3721,6 +3939,18 @@ This project uses Snipara as a hosted-first project intelligence layer with sour
 
 ${guidance.map((line) => `- ${line}`).join("\n")}
 
+## Activation Continuity Loop
+
+After the First Work Brief, use Companion when local continuity matters:
+
+1. Start or resume with \`${COMPANION_NPX_COMMAND} session-bootstrap --include-session-context --max-context-tokens 1000\`.
+2. Refresh local source context with \`${COMPANION_NPX_COMMAND} source sync --json\` after meaningful doc or code movement.
+3. Before risky edits, use \`${COMPANION_NPX_COMMAND} code impact --changed-files <files> --diff-summary "<change>"\`.
+4. End durable work with \`${COMPANION_NPX_COMMAND} task-commit --summary "<what changed>" --files <files>\`.
+
+Keep quick editor usage in the editor. Use Companion for explicit continuity, source refresh,
+workflow phase state, guards, impact checks, business-folder onboarding, and durable task memory.
+
 ## Business Folder Onboarding
 
 Use this when Claude, ChatGPT, Codex, or another LLM client has already materialized Drive, Notion, Gmail, or local business files into a folder.
@@ -4511,6 +4741,11 @@ function printActivationSummary(manifest) {
       `   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)) {

package/package.json

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