codebase-snapshot 0.9.12 → 0.9.14

package/dist/mcp.d.cts

@@ -1,4 +1,4 @@
-export { G as GenerateSummary, W as WorkerResults, g as generateInWorker } from './generate-worker-D5Xgh27c.cjs';
+export { G as GenerateSummary, W as WorkerResults, g as generateInWorker } from './generate-worker-D_mUjgXw.cjs';
 import { Readable, Writable } from 'node:stream';
 
 /**
@@ -101,72 +101,6 @@ interface InputSchema extends JsonSchema {
     properties: Record<string, JsonSchema>;
 }
 
-type ProtocolEra = "legacy" | "modern";
-/** Per-connection state. The modern era has no session, so this stays empty until legacy init. */
-interface SessionState {
-    /** Which era the connection committed to, or null before the first decisive request. */
-    era: ProtocolEra | null;
-    /** The revision in force. Null in legacy until `initialize` has been negotiated. */
-    protocolVersion: string | null;
-    /** True once `initialize` has been answered, which is the legacy lifecycle's gate. */
-    ready: boolean;
-}
-declare function createSession(): SessionState;
-/** The modern request metadata, when a request carries it at all. */
-interface ModernMeta {
-    version: string;
-    clientCapabilities: JsonObject;
-    clientInfo: JsonObject | null;
-}
-type MetaInspection = {
-    kind: "absent";
-} | {
-    kind: "incomplete";
-    missing: string;
-} | {
-    kind: "present";
-    meta: ModernMeta;
-};
-/**
- * Reads `_meta` from a request.
- *
- * `absent` and `incomplete` are different answers: a request with no `_meta` at all is a legacy
- * client, while a request with `_meta` that lacks a required key is a modern client making a
- * mistake — and telling those two apart is what keeps the legacy era from being rejected for a
- * field it never had.
- */
-declare function inspectModernMeta(params: JsonObject | undefined): MetaInspection;
-type EraDecision = {
-    kind: "era";
-    era: ProtocolEra;
-    version: string | null;
-} | {
-    kind: "error";
-    code: number;
-    message: string;
-    data?: unknown;
-};
-/**
- * Decides which era a request belongs to, and whether its version is acceptable.
- *
- * Once a connection commits to an era it stays committed. A legacy client that suddenly sends
- * modern `_meta` is confused rather than clever, and silently switching would answer half a
- * session in each shape.
- */
-declare function classifyRequest(method: string, params: JsonObject | undefined, session: SessionState): EraDecision;
-interface LegacyNegotiation {
-    version: string;
-    /** False when the client asked for something we cannot speak and was negotiated down. */
-    matched: boolean;
-}
-/**
- * Legacy version negotiation: echo a supported request, otherwise answer with our best.
- *
- * A client that asked for a modern revision here gets the newest *legacy* revision, not an error:
- * under this lifecycle the server's answer is the offer, and the client decides.
- */
-declare function negotiateLegacyVersion(requested: unknown): LegacyNegotiation;
-
 /**
  * The capability records the MCP server serves.
  *
@@ -279,6 +213,72 @@ interface McpServerInfo {
     websiteUrl: string;
 }
 
+type ProtocolEra = "legacy" | "modern";
+/** Per-connection state. The modern era has no session, so this stays empty until legacy init. */
+interface SessionState {
+    /** Which era the connection committed to, or null before the first decisive request. */
+    era: ProtocolEra | null;
+    /** The revision in force. Null in legacy until `initialize` has been negotiated. */
+    protocolVersion: string | null;
+    /** True once `initialize` has been answered, which is the legacy lifecycle's gate. */
+    ready: boolean;
+}
+declare function createSession(): SessionState;
+/** The modern request metadata, when a request carries it at all. */
+interface ModernMeta {
+    version: string;
+    clientCapabilities: JsonObject;
+    clientInfo: JsonObject | null;
+}
+type MetaInspection = {
+    kind: "absent";
+} | {
+    kind: "incomplete";
+    missing: string;
+} | {
+    kind: "present";
+    meta: ModernMeta;
+};
+/**
+ * Reads `_meta` from a request.
+ *
+ * `absent` and `incomplete` are different answers: a request with no `_meta` at all is a legacy
+ * client, while a request with `_meta` that lacks a required key is a modern client making a
+ * mistake — and telling those two apart is what keeps the legacy era from being rejected for a
+ * field it never had.
+ */
+declare function inspectModernMeta(params: JsonObject | undefined): MetaInspection;
+type EraDecision = {
+    kind: "era";
+    era: ProtocolEra;
+    version: string | null;
+} | {
+    kind: "error";
+    code: number;
+    message: string;
+    data?: unknown;
+};
+/**
+ * Decides which era a request belongs to, and whether its version is acceptable.
+ *
+ * Once a connection commits to an era it stays committed. A legacy client that suddenly sends
+ * modern `_meta` is confused rather than clever, and silently switching would answer half a
+ * session in each shape.
+ */
+declare function classifyRequest(method: string, params: JsonObject | undefined, session: SessionState): EraDecision;
+interface LegacyNegotiation {
+    version: string;
+    /** False when the client asked for something we cannot speak and was negotiated down. */
+    matched: boolean;
+}
+/**
+ * Legacy version negotiation: echo a supported request, otherwise answer with our best.
+ *
+ * A client that asked for a modern revision here gets the newest *legacy* revision, not an error:
+ * under this lifecycle the server's answer is the offer, and the client decides.
+ */
+declare function negotiateLegacyVersion(requested: unknown): LegacyNegotiation;
+
 interface McpServerOptions {
     info: McpServerInfo;
     instructions: string;

package/dist/mcp.d.ts

@@ -1,4 +1,4 @@
-export { G as GenerateSummary, W as WorkerResults, g as generateInWorker } from './generate-worker-D5Xgh27c.js';
+export { G as GenerateSummary, W as WorkerResults, g as generateInWorker } from './generate-worker-D_mUjgXw.js';
 import { Readable, Writable } from 'node:stream';
 
 /**
@@ -101,72 +101,6 @@ interface InputSchema extends JsonSchema {
     properties: Record<string, JsonSchema>;
 }
 
-type ProtocolEra = "legacy" | "modern";
-/** Per-connection state. The modern era has no session, so this stays empty until legacy init. */
-interface SessionState {
-    /** Which era the connection committed to, or null before the first decisive request. */
-    era: ProtocolEra | null;
-    /** The revision in force. Null in legacy until `initialize` has been negotiated. */
-    protocolVersion: string | null;
-    /** True once `initialize` has been answered, which is the legacy lifecycle's gate. */
-    ready: boolean;
-}
-declare function createSession(): SessionState;
-/** The modern request metadata, when a request carries it at all. */
-interface ModernMeta {
-    version: string;
-    clientCapabilities: JsonObject;
-    clientInfo: JsonObject | null;
-}
-type MetaInspection = {
-    kind: "absent";
-} | {
-    kind: "incomplete";
-    missing: string;
-} | {
-    kind: "present";
-    meta: ModernMeta;
-};
-/**
- * Reads `_meta` from a request.
- *
- * `absent` and `incomplete` are different answers: a request with no `_meta` at all is a legacy
- * client, while a request with `_meta` that lacks a required key is a modern client making a
- * mistake — and telling those two apart is what keeps the legacy era from being rejected for a
- * field it never had.
- */
-declare function inspectModernMeta(params: JsonObject | undefined): MetaInspection;
-type EraDecision = {
-    kind: "era";
-    era: ProtocolEra;
-    version: string | null;
-} | {
-    kind: "error";
-    code: number;
-    message: string;
-    data?: unknown;
-};
-/**
- * Decides which era a request belongs to, and whether its version is acceptable.
- *
- * Once a connection commits to an era it stays committed. A legacy client that suddenly sends
- * modern `_meta` is confused rather than clever, and silently switching would answer half a
- * session in each shape.
- */
-declare function classifyRequest(method: string, params: JsonObject | undefined, session: SessionState): EraDecision;
-interface LegacyNegotiation {
-    version: string;
-    /** False when the client asked for something we cannot speak and was negotiated down. */
-    matched: boolean;
-}
-/**
- * Legacy version negotiation: echo a supported request, otherwise answer with our best.
- *
- * A client that asked for a modern revision here gets the newest *legacy* revision, not an error:
- * under this lifecycle the server's answer is the offer, and the client decides.
- */
-declare function negotiateLegacyVersion(requested: unknown): LegacyNegotiation;
-
 /**
  * The capability records the MCP server serves.
  *
@@ -279,6 +213,72 @@ interface McpServerInfo {
     websiteUrl: string;
 }
 
+type ProtocolEra = "legacy" | "modern";
+/** Per-connection state. The modern era has no session, so this stays empty until legacy init. */
+interface SessionState {
+    /** Which era the connection committed to, or null before the first decisive request. */
+    era: ProtocolEra | null;
+    /** The revision in force. Null in legacy until `initialize` has been negotiated. */
+    protocolVersion: string | null;
+    /** True once `initialize` has been answered, which is the legacy lifecycle's gate. */
+    ready: boolean;
+}
+declare function createSession(): SessionState;
+/** The modern request metadata, when a request carries it at all. */
+interface ModernMeta {
+    version: string;
+    clientCapabilities: JsonObject;
+    clientInfo: JsonObject | null;
+}
+type MetaInspection = {
+    kind: "absent";
+} | {
+    kind: "incomplete";
+    missing: string;
+} | {
+    kind: "present";
+    meta: ModernMeta;
+};
+/**
+ * Reads `_meta` from a request.
+ *
+ * `absent` and `incomplete` are different answers: a request with no `_meta` at all is a legacy
+ * client, while a request with `_meta` that lacks a required key is a modern client making a
+ * mistake — and telling those two apart is what keeps the legacy era from being rejected for a
+ * field it never had.
+ */
+declare function inspectModernMeta(params: JsonObject | undefined): MetaInspection;
+type EraDecision = {
+    kind: "era";
+    era: ProtocolEra;
+    version: string | null;
+} | {
+    kind: "error";
+    code: number;
+    message: string;
+    data?: unknown;
+};
+/**
+ * Decides which era a request belongs to, and whether its version is acceptable.
+ *
+ * Once a connection commits to an era it stays committed. A legacy client that suddenly sends
+ * modern `_meta` is confused rather than clever, and silently switching would answer half a
+ * session in each shape.
+ */
+declare function classifyRequest(method: string, params: JsonObject | undefined, session: SessionState): EraDecision;
+interface LegacyNegotiation {
+    version: string;
+    /** False when the client asked for something we cannot speak and was negotiated down. */
+    matched: boolean;
+}
+/**
+ * Legacy version negotiation: echo a supported request, otherwise answer with our best.
+ *
+ * A client that asked for a modern revision here gets the newest *legacy* revision, not an error:
+ * under this lifecycle the server's answer is the offer, and the client decides.
+ */
+declare function negotiateLegacyVersion(requested: unknown): LegacyNegotiation;
+
 interface McpServerOptions {
     info: McpServerInfo;
     instructions: string;

package/dist/mcp.js

@@ -1,2 +1,2 @@
-export { ERROR_CODES, LEGACY_PROTOCOL_VERSIONS, MAX_LINE_BYTES, METHOD, MODERN_PROTOCOL_VERSIONS, SERVER_INSTRUCTIONS, SUPPORTED_PROTOCOL_VERSIONS, buildPrompts, buildResourceProvider, buildTools, classifyRequest, coerceNumericStrings, createLineReader, createMcpServer, createServer, createSession, createWriter, findSection, inspectModernMeta, negotiateLegacyVersion, parsePartSections, runStdioServer, validateArguments, windowText } from './chunk-5OR3WVPW.js';
-export { generateInWorker } from './chunk-3H45YMBG.js';
+export { ERROR_CODES, LEGACY_PROTOCOL_VERSIONS, MAX_LINE_BYTES, METHOD, MODERN_PROTOCOL_VERSIONS, SERVER_INSTRUCTIONS, SUPPORTED_PROTOCOL_VERSIONS, buildPrompts, buildResourceProvider, buildTools, classifyRequest, coerceNumericStrings, createLineReader, createMcpServer, createServer, createSession, createWriter, findSection, inspectModernMeta, negotiateLegacyVersion, parsePartSections, runStdioServer, validateArguments, windowText } from './chunk-J4W74N4Y.js';
+export { generateInWorker } from './chunk-DUZK5VL2.js';

package/dist/{types-CTewen3J.d.cts → types-DIX6zWSt.d.cts}

@@ -568,9 +568,24 @@ interface CliOptions {
     includeSensitiveFiles?: boolean;
     maxMonolithBytes?: number | null;
     maxPartBytes?: number;
+    maxPartTokens?: ByteSize | null;
     largeFileBytes?: number;
     /** Artifact names to suppress for this invocation (`--skip-artifacts`). */
     skipArtifacts?: string[];
+    /**
+     * Artifact names to keep, with everything else off (`--only-artifacts`).
+     *
+     * Separate from the derived `skipArtifacts` because the two are not interchangeable: "only
+     * these" is a statement about the whole selection, and the suppression list cannot express it
+     * when the configuration has already turned one of the named artifacts off.
+     */
+    onlyArtifacts?: string[];
+    discovery?: DiscoveryMode;
+    changedSince?: string;
+    staged?: boolean;
+    withDependents?: boolean;
+    skeleton?: boolean;
+    sarif?: boolean;
 }
 interface ValidationDrift {
     missingInSnapshot: string[];

package/dist/{types-CTewen3J.d.ts → types-DIX6zWSt.d.ts}

@@ -568,9 +568,24 @@ interface CliOptions {
     includeSensitiveFiles?: boolean;
     maxMonolithBytes?: number | null;
     maxPartBytes?: number;
+    maxPartTokens?: ByteSize | null;
     largeFileBytes?: number;
     /** Artifact names to suppress for this invocation (`--skip-artifacts`). */
     skipArtifacts?: string[];
+    /**
+     * Artifact names to keep, with everything else off (`--only-artifacts`).
+     *
+     * Separate from the derived `skipArtifacts` because the two are not interchangeable: "only
+     * these" is a statement about the whole selection, and the suppression list cannot express it
+     * when the configuration has already turned one of the named artifacts off.
+     */
+    onlyArtifacts?: string[];
+    discovery?: DiscoveryMode;
+    changedSince?: string;
+    staged?: boolean;
+    withDependents?: boolean;
+    skeleton?: boolean;
+    sarif?: boolean;
 }
 interface ValidationDrift {
     missingInSnapshot: string[];

package/docs/cli.md

@@ -174,7 +174,7 @@ The whole first run in one command, with defaults and no prompts. This is the sa
 🚀 Setup for: /path/to/repo
 ✅ Created snapshot.config.ts (preset: nextjs)
    Added npm scripts: snapshot, snapshot:validate
-   Added devDependency: codebase-snapshot ^0.9.12
+   Added devDependency: codebase-snapshot ^0.9.14
    Added to .gitignore: snapshot/, snapshot.tmp/
 ⏳ Installing dependencies…
 ✅ Installed dependencies (npm install, 2.1s)
@@ -192,7 +192,9 @@ The whole first run in one command, with defaults and no prompts. This is the sa
   `generate` and `init`.
 - `--format json` emits **one** document:
   `{ "setup": { configPath, configReused, preset, scripts, dependency, gitignoreEntries, install, notes }, "manifest": { … } }`,
-  where `manifest` is the same object `generate --format json` writes.
+  where `manifest` is the same object `generate --format json` writes. If that generate fails, the
+  document is `{ "error": { … }, "setup": { … }, "manifest": null }` and the exit code is the
+  generate's: one document per invocation, a payload or an error, never a payload holding an error.
 - If `outDir` holds files this tool did not write, `setup` still refuses to replace it (exit 1,
   naming the entries) after writing the config — the guard is not weakened by the convenience.
 ### `init`
@@ -211,7 +213,7 @@ It also has three side effects on files you own, and it says so when it does the
 ```
 ✅ Created snapshot.config.ts (preset: node-lib)
    Added npm scripts: snapshot, snapshot:validate
-   Added devDependency: codebase-snapshot ^0.9.12
+   Added devDependency: codebase-snapshot ^0.9.14
    Added to .gitignore: snapshot/, snapshot.tmp/
 ```
 
@@ -407,16 +409,16 @@ narrowest cases of the same rule.
 | `--include-monolith` | flag | off | generate, validate, report, explain | Also write `full-codebase.json` and `full-codebase.md`. |
 | `--include-sensitive-files` | flag | off | generate, validate, report, explain, init | Emit `.env`, `*.pem`, `.npmrc` and similar. Off by default; they are reported as skipped. |
 | `--skip-artifacts <names>` | list | unset | generate, validate, report, explain, init | Comma-separated artifacts to omit. |
-| `--only-artifacts <names>` | list | unset | generate, validate, report, explain, init | Write only these. Cannot be combined with `--skip-artifacts`. |
+| `--only-artifacts <names>` | list | unset | generate, validate, report, explain, init | Write *only* these, and **turn on** any this names: a config with `artifacts: { audit: false }` still gets `reports/audit.md` from `--only-artifacts audit`, because "only these" is a statement about the whole selection rather than a suppression list. Cannot be combined with `--skip-artifacts`. |
 | `--format <text\|json>` | enum | `text` | generate, validate, report, explain, init, setup, diff, describe, skill | `json` writes a pure JSON payload to stdout. Every command honours it, and `describe` reports the same nine-command list. |
 | `--sarif` | flag | off | generate, validate, setup | Also write `reports/audit.sarif`: the redaction findings as SARIF 2.1.0, for upload to GitHub Code Scanning. The artefact carries the path, the line and the rule — never the value. Works with `--skip-artifacts audit`, because a CI gate does not read markdown. Rule ids are fixed per rule name, so adding a custom rule never re-points an existing alert. |
-| `--skeleton` | flag | off | generate, validate, setup | Emit TypeScript and TSX signatures instead of bodies: each function or method body becomes `{ /* ... */ }` in place, so formatting and comments around it are untouched. The summary still describes the whole file, and affected entries carry `inclusionMode: "signatures"`. `--include-monolith` still writes the whole body, so the monolith's `inclusionMode: "full"` stays true. |
+| `--skeleton` | flag | off | generate, validate, setup | Emit signatures instead of bodies: each function or method body becomes `{ /* ... */ }` in place, so formatting and comments around it are untouched. Covers `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs` and `.cjs`; `.d.ts` files are left alone because they are already declarations. The summary still describes the whole file, and affected entries carry `inclusionMode: "signatures"`. `--include-monolith` still writes the whole body, so the monolith's `inclusionMode: "full"` stays true. |
 | `--changed-since <ref>` | git ref | unset | generate, validate, explain | Include only files changed since this ref, plus untracked ones. Every other file is recorded in `manifest.skipped[]` with reason `unchanged` and is never opened. `validate` re-resolves the scope: a skipped file that has changed since is reported as drift, and one that has not is left alone — and with `--with-dependents`, so is a file that now imports one that changed. `explain` answers with the same rule. A ref beginning with `-` is refused. |
 | `--staged` | flag | off | generate, validate, explain | Include only files staged for the next commit. |
 | `--with-dependents` | flag | off | generate, validate, explain | With either of the two above, also include the files that import a changed one — a one-hop closure, not a transitive walk. Needs a scope; alone it is a usage error. |
 | `--install-hook` | flag | off | init, setup | Write `.git/hooks/pre-commit` so a commit is refused while the snapshot is out of date. The hook checks the `outDir` the config names, so it works for a project that does not use `snapshot/`. An existing hook is never replaced; the note says what to add to it instead. |
 | `--dry-run` | flag | off | generate, init, setup | Compute everything, print it, write nothing. |
-| `--watch` | flag | off | generate | Regenerate on every change until interrupted. |
+| `--watch` | flag | off | generate | Regenerate on every change until interrupted. Redaction and parsing are cached per file across runs in the same process, keyed on the content hash, so a one-file edit regenerates from that one file instead of from the whole repository. The cache is memory only and is dropped when the process exits. |
 | `--autopilot` | flag | off | generate | Set the project up without asking — config, `.gitignore`, npm scripts, devDependency, install — then generate. Never overwrites an existing config; refuses an empty directory (exit `1`); contradicts `--no-config` (exit `2`). |
 | `--no-install` | flag | off | setup, generate `--autopilot` | Skip the dependency install. Anywhere else it is a usage error, because it would change nothing. |
 | `--no-config` | flag | off | generate, validate, report, explain, diff | Ignore every `snapshot.config.*` file and run on the built-in defaults. `diff` never loads a config anyway and accepts the flag for consistency. |

package/docs/configuration.md

@@ -192,7 +192,7 @@ export default {
   // changedSince: "main",      // only files changed since this git ref
   // staged: true,             // only files staged for the next commit
   // withDependents: true,     // ...and the files that import them
-  // skeleton: true,           // TypeScript signatures instead of bodies (--skeleton)
+  // skeleton: true,           // signatures instead of bodies (--skeleton); TS, JS, TSX and JSX
   largeFileBytes: "200k",      // above this a file becomes a head/tail preview
   previewHeadLines: 80,
   previewTailLines: 40,
@@ -229,8 +229,9 @@ export default {
 ```
 
 Everything except `monolith` is on by default; `monolith` follows `includeMonolith`. Turn
-artifacts off with the config, `--skip-artifacts a,b`, or `--only-artifacts a,b` (the two
-cannot be combined).
+artifacts off with the config or `--skip-artifacts a,b`. `--only-artifacts a,b` is different: it
+*writes only* those and turns each named artifact **on**, so `--only-artifacts audit` still produces
+`reports/audit.md` in a project whose config says `audit: false`. The two flags cannot be combined.
 
 Two combinations warn because they produce a snapshot that contradicts itself: `manifest` off
 means `validate` and `report` cannot inspect the snapshot, and `parts` off with `navigation`
@@ -266,19 +267,52 @@ makes an audit entry mean something.
   matched span is masked, never the whole line, and no excerpt of a matched line reaches any
   artifact. Multi-line PEM keys are masked as a block.
 - `customPatterns` add rules; `disableDefaultPatterns` removes the built-in set — it does not
-  disable redaction itself.
+  disable redaction itself, and it applies to **paths** as well as to content, so a
+  credential-shaped file name is no longer skipped by a rule you switched off.
 
 Redaction is **fail-closed**, so a placeholder is indistinguishable from a secret: a
 `.env.example` whose line reads `JWT_SECRET=replace-with-base64url-48-bytes` is masked like a
 live key would be, and a test fixture literal such as `process.env.X_SECRET = "test-value"` is
-masked too. The same holds for an environment reference written as a quoted value —
-`password: "${DB_PASSWORD}"` is masked exactly like a literal password, because the rule sees a
-credential-shaped key followed by a string and a `${…}` reference cannot be told apart from a
-secret by shape alone. That is the intended trade-off — the alternative is guessing which values
-are throwaway — and it is worth knowing before you hand the snapshot to a model and find the
-template less readable than the original. To narrow it, remove a rule by name with
+masked too. That is the intended trade-off — the alternative is guessing which values are
+throwaway — and it is worth knowing before you hand the snapshot to a model and find the template
+less readable than the original. To narrow it, remove a rule by name with
 `disableDefaultPatterns: true` plus your own `customPatterns`.
 
+The one shape that is *not* masked is a value that is a single `${…}` reference and nothing else —
+`password: "${DB_PASSWORD}"`, `` `${process.env.TOKEN}` `` — because that is an expression and
+masking it rewrites a program (or an assertion message) rather than hiding a credential. Anything
+inside the braces that is not a plain reference settles it the other way:
+`password: "${DB_PASSWORD:-hunter2}"` is masked, because the shell and Compose idiom for a default
+puts a **hardcoded credential** in the fallback position. So does a second interpolation, or any
+quote inside the braces.
+
+The same default is masked when it is not quoted, which is how it is usually written:
+
+```bash
+# .env, docker-compose.yml, a workflow, a shell script — all of these are masked
+POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-MyProdPassword123!}
+POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-MyProdPassword123!}
+```
+
+The fallback is what gets replaced; the variable name stays, exactly as `POSTGRES_PASSWORD:` does.
+`${PORT:-3000}` is untouched: the name is not a credential name, and a port number is not one
+either.
+
+A credential assigned to a name inside a string is also masked — a connection string is a string:
+
+```js
+const dsn = "password=MySuperSecret123;host=db.internal";
+```
+
+What is left alone is a credential *name* in a literal, with nothing assigned to it:
+`["awsSecret:", "apiKey:"]` is a list of keys, not two credentials, and a documentation line showing
+`password: "…"` inside a code span is showing an example. The difference is whether the literal
+closes between the name and the value.
+
+`readonly` and `declare` are shell assignments in a shell file and declarations in a source file, and
+the file decides: `readonly api_key=hunter2` in `.envrc`, `.sh`, `.zsh`, a YAML or an INI file is
+masked, while `private readonly apiKey = someValue` in TypeScript is left alone.
+
 Findings are summarised in `reports/audit.md` (one row per line, naming every rule that matched
 it), counted in `manifest.totals.redactedLines`, and shown in the `generate` summary as a
 `Redacted:` line separate from `Warnings:`.

package/docs/mcp.md

@@ -10,7 +10,7 @@ walk — that the client sees.
 ## Start it
 
 ```bash
-npx -y codebase-snapshot@0.9.12 mcp
+npx -y codebase-snapshot@0.9.14 mcp
 ```
 
 The server serves the directory it was started in. `--cwd <path>` points it elsewhere, and that
@@ -25,7 +25,7 @@ Claude Desktop and Cursor:
   "mcpServers": {
     "codebase-snapshot": {
       "command": "npx",
-      "args": ["-y", "codebase-snapshot@0.9.12", "mcp", "--cwd", "/absolute/path/to/repo"]
+      "args": ["-y", "codebase-snapshot@0.9.14", "mcp", "--cwd", "/absolute/path/to/repo"]
     }
   }
 }
@@ -34,7 +34,7 @@ Claude Desktop and Cursor:
 Claude Code registers the same thing from a shell:
 
 ```bash
-claude mcp add codebase-snapshot -- npx -y codebase-snapshot@0.9.12 mcp --cwd /absolute/path/to/repo
+claude mcp add codebase-snapshot -- npx -y codebase-snapshot@0.9.14 mcp --cwd /absolute/path/to/repo
 ```
 
 On Windows, wrap the command as `cmd /c npx` with the same arguments — `npx` is a `.cmd` shim
@@ -61,6 +61,19 @@ still reachable: pass the same value to the read side that you passed to `snapsh
 that, only `snapshot_generate` honoured it and every other tool looked in the configured directory
 and reported "there is no snapshot manifest here".
 
+`snapshot_plan`, `snapshot_generate`, `snapshot_validate` and `snapshot_explain` also take the
+**scope and compression** switches `generate` accepts: `maxPartTokens`, `skeleton`, `sarif`,
+`changedSince`, `staged` and `withDependents`. They have to: `manifest.config.digest` covers those
+settings, so a snapshot generated with `--skeleton` was not merely un-inspectable over MCP, it was
+reported as configuration drift on every `snapshot_validate`. Pass the same switches you generated
+with, exactly as you would on the command line. The four remaining tools do not take them, because
+none of them re-derives the configuration and a flag that changes nothing is the command-line form
+of a silent fallback.
+
+`includeSensitiveFiles` is deliberately absent from every one of them. A prompt can ask for
+anything, and a tool that emits `.env` on request is a secret-exfiltration primitive with a
+friendly name.
+
 `snapshot_locate` is the one that makes the others usable: a twelve-part snapshot is hundreds of
 kilobytes, and asking "which part holds authentication?" is cheaper than reading all twelve. It
 searches the manifest's index — file paths, exported symbols, component names, routes, layers and

package/docs/output.md

@@ -31,6 +31,12 @@ fields in `manifest.json` for the same file. `manifest.json` reports what the pa
 (CRLF normalised, the trailing newline not counted); the monolith reports the content it
 embedded. Compare a file's fields within one artifact, not across the two.
 
+"CRLF normalised" covers all three line endings a file can have. A CR-only file — an old Mac file,
+or anything written by a tool that predates LF on that platform — is written to a part with LF too,
+and its `lines` count is the real one: the preview budget and the line counts used to split on `\n`
+alone, so such a file was one line, `largeFileBytes` never applied, and the whole file went into a
+part with its carriage returns intact.
+
 The manifest embedded in `full-codebase.json` is otherwise identical to `manifest.json` with one
 impossible field: a file cannot record its own sha256, so `artifacts.fullJson` is `null` in the
 embedded copy and a `selfReference` sentence points at `manifest.json`, which carries the real
@@ -202,6 +208,13 @@ has several at once, and "within budget" cannot be answered without knowing whic
   `variables`, `reactComponents`, `hooks`, `routeHandlers`), plus `parseErrors` when the parser
   reported syntax errors. JSON gets `{ shape, itemCount, keys, sampleKeys }` and Markdown gets
   `{ headings, frontmatterKeys }` — a shape description rather than a code summary.
+  `imports` covers `import` declarations, named and star re-exports, `require("…")`, `import("…")`
+  and `import x = require("…")`; a computed specifier is an expression and is not recorded, because
+  a wrong edge in the import graph is worse than a missing one. The JSON reader follows JSONC —
+  comments, trailing commas and a BOM — and reports `invalid-json` only for a file that still does
+  not parse. `headings` skips headings inside fenced code and inside YAML front matter, and a
+  document that *opens* with a `---` horizontal rule keeps its headings: the block has to look like
+  YAML before it counts as front matter.
 - `summaryOmitted: true` means the file's summary was dropped because the summary alone would
   not fit the part budget. The entry then has `summaryQuality` but no `summary`, and the
   file's body is still emitted in full. It is only ever present when `true`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebase-snapshot",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "Pack a codebase for an LLM into budgeted Markdown parts, with a manifest of every file and skip, and validate to prove the snapshot is current.",
   "keywords": [
     "codebase",