@mmnto/cli 1.113.1 → 1.115.0

package/dist/commands/init.js

@@ -188,7 +188,39 @@ export function wirePreparePackageJson(pkgPath) {
     return { action: 'wired' };
 }
 // --- Gemini CLI hook installer ---
-async function installGeminiHooks(cwd) {
+/**
+ * Whether a consumer owns a custom `<stem>.js` sibling of a managed `<stem>.cjs` vendor
+ * hook (mmnto-ai/totem#2601 — the strategy#482 incident: the generic template dropped
+ * beside a repo's own SessionStart.js, double-firing or regressing orientation depending
+ * on Gemini's hook discovery). Ownership is the same positional gate `scaffoldFile` and
+ * `migrateLegacyGeminiHooks` use, so a marker-headed sibling — the legacy `.js`→`.cjs`
+ * migration case — never reports here; only an UNOWNED sibling does. A sibling that
+ * cannot be read is not provably totem-owned and reports (non-destructive posture,
+ * never a crash). Returns the sibling's basename when one is present.
+ *
+ * This is a PREDICATE, not the policy: whether a report withholds the scaffold or only
+ * discloses a coexistence depends on whether the managed `.cjs` already exists — see
+ * `installGeminiHooks`, the sole caller.
+ */
+export function findUnownedHookSibling(cjsPath) {
+    if (!cjsPath.endsWith('.cjs'))
+        return undefined;
+    const siblingPath = `${cjsPath.slice(0, -'.cjs'.length)}.js`;
+    if (!fs.existsSync(siblingPath))
+        return undefined;
+    // totem-context: intentional cleanup — an unreadable sibling cannot be proven totem-owned, so it withholds the scaffold (non-destructive) rather than aborting init.
+    try {
+        const existing = fs.readFileSync(siblingPath, 'utf-8');
+        if (markerOpensFile(existing, TOTEM_FILE_MARKER))
+            return undefined;
+        // totem-context: intentional cleanup — see directive above the try; dual placement so the rule fires on either the catch-keyword line or the catch-body line.
+    }
+    catch {
+        // fall through to withhold
+    }
+    return path.basename(siblingPath);
+}
+export async function installGeminiHooks(cwd) {
     const results = [];
     // The two whole-file hooks carry the managed end marker (mmnto-ai/totem#2410) so a
     // drifted-but-bounded artifact self-repairs on re-init; the skill is marker-block
@@ -218,13 +250,43 @@ async function installGeminiHooks(cwd) {
     ];
     for (const { rel, content, marker, endMarker } of files) {
         const filePath = path.join(cwd, rel);
+        // Vendor-hook managed-marker guard (mmnto-ai/totem#2601): a custom same-stem `.js`
+        // the consumer owns withholds the managed `.cjs` — the drop is disclosed, never
+        // silent, because a withheld hook otherwise reads as an installed one.
+        //
+        // The withhold is scoped to the FRESH path (no `.cjs` on disk yet), where it is what
+        // prevents the twin from being introduced. Once the `.cjs` EXISTS the twin is already
+        // live: withholding there would suppress drift-repair of a file that fires anyway and
+        // would report "not installed" about an installed hook. That case scaffolds normally
+        // and discloses the coexistence plus the two ways out.
+        const unownedSibling = findUnownedHookSibling(filePath);
+        if (unownedSibling !== undefined && !fs.existsSync(filePath)) {
+            results.push({
+                file: rel,
+                action: 'skipped',
+                summaryActionOverride: `Skipped — custom ${unownedSibling} present — totem hook not installed; remove or rename it to adopt the managed hook`,
+            });
+            continue;
+        }
         const result = scaffoldFile(filePath, content, marker, endMarker);
         // Map the scaffold action onto HookInstallerResult: a bounded drift-repair
         // (`refreshed`) surfaces as `merged` (file mutated) for installer summary parity
         // with scaffoldClaudeSkill's mapping.
+        const action = result.action === 'refreshed' ? 'merged' : result.action;
+        // The coexistence line is true only when the `.cjs` really is totem's — `exists`
+        // (canonical) or `merged` (drift-repaired). A USER-owned `.cjs` (no marker) takes
+        // scaffoldFile's preserve path: totem installed nothing, so claiming a "managed
+        // .cjs" and steering the user to delete their own file would be false both ways
+        // (scoped leg round 2, D3) — that state gets the truthful not-installed line.
+        const coexistenceOverride = unownedSibling === undefined
+            ? undefined
+            : action === 'exists' || action === 'merged'
+                ? `Custom ${unownedSibling} coexists with the managed ${path.basename(filePath)} — both may fire; remove one (delete the managed .cjs to keep yours, or your .js to keep totem's)`
+                : `Custom ${unownedSibling} and ${path.basename(filePath)} are both present and neither is totem's — totem hook not installed`;
         results.push({
             file: rel,
-            action: result.action === 'refreshed' ? 'merged' : result.action,
+            action,
+            ...(coexistenceOverride !== undefined ? { summaryActionOverride: coexistenceOverride } : {}),
             ...(result.err ? { err: result.err } : {}),
         });
     }
@@ -236,7 +298,7 @@ async function installGeminiHooks(cwd) {
     // Dynamic-imported to keep the migration co-located with the upgrade-path
     // drift-repair machinery.
     const { migrateGeminiHookRegistration, migrateLegacyGeminiHooks } = await import('./install-hooks.js');
-    for (const { file, action } of await migrateLegacyGeminiHooks(cwd)) {
+    for (const { file, action, reason } of await migrateLegacyGeminiHooks(cwd)) {
         if (action === 'migrated') {
             results.push({
                 file,
@@ -246,6 +308,23 @@ async function installGeminiHooks(cwd) {
                 summaryActionOverride: `Migrated legacy Gemini ${path.basename(file)} → .cjs`,
             });
         }
+        else if (action === 'skipped' && reason === 'unreadable-legacy') {
+            // Unreadable outcomes are the non-migrated ones init discloses: the path
+            // exists and could not be read at all, so the user is the only one who can
+            // resolve it — and "user-owned" must never render for them (#2601).
+            results.push({
+                file,
+                action: 'skipped',
+                summaryActionOverride: `Skipped — legacy ${path.basename(file)} could not be read; left in place (remove or rename it to complete the .cjs migration)`,
+            });
+        }
+        else if (action === 'skipped' && reason === 'unreadable-successor') {
+            results.push({
+                file,
+                action: 'skipped',
+                summaryActionOverride: `Skipped — the .cjs successor of ${path.basename(file)} could not be read; left both files untouched (remove or rename the successor to complete the migration)`,
+            });
+        }
     }
     const registration = migrateGeminiHookRegistration(cwd);
     if (registration.err) {
@@ -487,7 +566,152 @@ if (claudeTool)
 const geminiTool = AI_TOOLS.find((t) => t.name === 'Gemini CLI');
 if (geminiTool)
     geminiTool.hookInstaller = installGeminiHooks;
-export function scaffoldMcpConfig(filePath, serverEntry) {
+/** The npm package every Totem MCP registration invokes, under whatever entry name. */
+const MCP_PACKAGE = '@mmnto/mcp';
+/**
+ * Boundary-anchored name probe. A bare `includes('@mmnto/mcp')` also fires on
+ * `@mmnto/mcp-experimental` — a DIFFERENT package whose presence must not suppress the
+ * real registration. The lookahead rejects a following word char, hyphen, or dot
+ * (`@mmnto/mcp.js` is a different package name too); a `/`, an `@`, a quote, a space,
+ * or end-of-string all still match (`@mmnto/mcp/dist/index.js`, `@mmnto/mcp@1.2.3`).
+ * Non-global, so it carries no `lastIndex` state across calls.
+ */
+const MCP_PACKAGE_RE = /@mmnto\/mcp(?![\w.-])/;
+/**
+ * Whether a `command`/`args` string names a JS-family SCRIPT FILE worth an identity
+ * walk. A suffix gate, not a separator gate: a separator-shaped non-script arg
+ * (`--cwd ./`) resolves to a DIRECTORY, and `path.dirname` on a directory would start
+ * the walk one level above it — outside the config, potentially outside the repo
+ * (scoped leg round 2, D2). Non-global, so `.test()` carries no `lastIndex` state.
+ */
+const SCRIPT_FILE_RE = /\.(?:cjs|mjs|js)$/i;
+function looksLikeScriptPath(value) {
+    return SCRIPT_FILE_RE.test(value);
+}
+/**
+ * Whether a `command` is a Node-family runtime — the only commands whose FIRST
+ * script-suffixed argument is, by the runtime's own semantics, the ENTRYPOINT.
+ * The path probe is scoped to this shape: probing every `.js` argument of every
+ * command would let an unrelated server's plugin/config argument (a file totem
+ * happens to own) masquerade as a totem registration and silently suppress the
+ * real install (Greptile P2 on #2606). Package-manager launchers (`npx`,
+ * `pnpm dlx`, `cmd /c npx …`) name the package instead — the name probe's job.
+ */
+function isNodeCommand(command) {
+    const base = path.basename(command).toLowerCase();
+    return base === 'node' || base === 'node.exe';
+}
+/** No-throw file probe: only an existing regular FILE qualifies for the identity walk. */
+function isExistingFile(p) {
+    // totem-context: intentional cleanup — an unstat-able path is simply not an attributable registration; dedup must never abort the init scaffold.
+    try {
+        return fs.statSync(p).isFile();
+        // totem-context: intentional cleanup — see directive above the try; dual placement so the rule fires on either the catch-keyword line or the catch-body line.
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The package name owning a resolved script: walk from the script's directory to the
+ * filesystem root and read the nearest `package.json`'s `name`. A `package.json` that
+ * names nothing (the `{"type":"module"}` dual-package shim inside a `dist/`) is not an
+ * identity, so the walk continues past it.
+ */
+function packageNameForScript(scriptPath) {
+    let dir = path.dirname(scriptPath);
+    for (;;) {
+        const pkgPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            // totem-context: intentional cleanup — an unreadable/invalid package.json is not evidence of a DIFFERENT package, so the walk continues to the next parent; dedup must never abort the init scaffold.
+            try {
+                // `JSON.parse` also yields `null`, arrays, and scalars — checked explicitly
+                // (the wirePreparePackageJson posture) rather than left to throw into the catch.
+                const parsed = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (parsed !== null && typeof parsed === 'object') {
+                    const { name } = parsed;
+                    if (typeof name === 'string')
+                        return name;
+                }
+                // totem-context: intentional cleanup — see directive above the try; dual placement so the rule fires on either the catch-keyword line or the catch-body line.
+            }
+            catch {
+                // fall through to the next parent
+            }
+        }
+        // `path.dirname` is a fixpoint at the filesystem root — that fixpoint ends the walk.
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/**
+ * Find an existing registration of the Totem MCP package under ANY entry name
+ * (mmnto-ai/totem#2601). Dedup keys on the registered PACKAGE, not the entry name: a
+ * consumer that registered `@mmnto/mcp` as `totem-dev` / `totem-strategy` (a `--cwd`
+ * pin, a local path pin) must not collect a third duplicate `totem` entry on re-init.
+ *
+ * Two probes, both scoped to `command` and the string members of `args` — the only
+ * fields that can INVOKE anything. There is deliberately no whole-entry serialization
+ * scan: it false-positives on a prose mention in `env`, a field that cannot invoke
+ * anything.
+ *
+ *   1. Name probe — {@link MCP_PACKAGE_RE} on each candidate string.
+ *   2. Path probe — a registration need not spell the package at all. This repo's own
+ *      configs run `node ./packages/mcp/dist/index.js`; for a Node-family command
+ *      ({@link isNodeCommand}), the FIRST script-suffixed arg — the runtime's own
+ *      entrypoint — is resolved against every candidate base and, when it lands on a
+ *      real file, the owning package is read from the nearest `package.json` on the
+ *      written path (lexical — an aliased/symlinked script attributes to its host
+ *      package) via {@link packageNameForScript}.
+ *
+ * `baseDirs` carries the config's own directory AND the project root: hosts launch
+ * the server from the project root, and three of the four host configs live in
+ * subdirectories (`.gemini/`, `.cursor/`, `.junie/mcp/`) while their pins are written
+ * root-relative — the config's directory alone is the right base only for the
+ * root-level `.mcp.json` (scoped leg round 2, D1).
+ *
+ * A path that does not resolve to an existing file under any base is a stale pin, not
+ * a registration we can attribute — it falls through and init appends its own entry.
+ */
+function findMcpPackageRegistration(servers, baseDirs) {
+    for (const [name, entry] of Object.entries(servers)) {
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const { command, args } = entry;
+        const candidates = [];
+        if (typeof command === 'string')
+            candidates.push(command);
+        if (Array.isArray(args)) {
+            for (const arg of args)
+                if (typeof arg === 'string')
+                    candidates.push(arg);
+        }
+        if (candidates.some((candidate) => MCP_PACKAGE_RE.test(candidate)))
+            return name;
+        // Path probe: only a Node-family command has a script ENTRYPOINT to attribute,
+        // and only its FIRST script-suffixed arg is that entrypoint (node's own CLI
+        // semantics). Later `.js` args are plugin/config inputs — attributing those
+        // would suppress a real registration over a file the server merely consumes.
+        if (typeof command !== 'string' || !isNodeCommand(command))
+            continue;
+        const entrypoint = Array.isArray(args)
+            ? args.find((arg) => typeof arg === 'string' && looksLikeScriptPath(arg))
+            : undefined;
+        if (entrypoint === undefined)
+            continue;
+        for (const baseDir of baseDirs) {
+            const resolved = path.resolve(baseDir, entrypoint);
+            if (!isExistingFile(resolved))
+                continue;
+            if (packageNameForScript(resolved) === MCP_PACKAGE)
+                return name;
+        }
+    }
+    return undefined;
+}
+export function scaffoldMcpConfig(filePath, serverEntry, opts) {
     try {
         if (!fs.existsSync(filePath)) {
             const dir = path.dirname(filePath);
@@ -522,6 +746,15 @@ export function scaffoldMcpConfig(filePath, serverEntry) {
         if ('totem' in servers) {
             return { action: 'skipped' };
         }
+        // Package-level dedup runs after the name check so the `totem`-key skip keeps its
+        // bare shape: `existingName` marks the different-name case the caller discloses.
+        const baseDirs = [path.dirname(filePath)];
+        if (opts?.projectRoot !== undefined)
+            baseDirs.push(opts.projectRoot);
+        const existingName = findMcpPackageRegistration(servers, baseDirs);
+        if (existingName !== undefined) {
+            return { action: 'skipped', existingName };
+        }
         servers.totem = serverEntry;
         parsed.mcpServers = servers;
         fs.writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
@@ -535,9 +768,11 @@ export function scaffoldMcpConfig(filePath, serverEntry) {
 /**
  * Install the Universal AI Developer Baseline lessons into the lessons file.
  * Returns 'installed', 'exists' (already present), or 'skipped' (user declined).
- * In non-TTY mode (CI), defaults to installing without prompting.
+ * In non-interactive mode (CI, `--yes`, piped input), defaults to installing without
+ * prompting. `interactive` is threaded from init's single non-interactive predicate
+ * (mmnto-ai/totem#2601) and falls back to the bare TTY probe for standalone callers.
  */
-export async function installBaselineLessons(baselinePath, rl, ecosystems) {
+export async function installBaselineLessons(baselinePath, rl, ecosystems, interactive = process.stdin.isTTY === true) {
     const { UNIVERSAL_BASELINE_LESSONS, UNIVERSAL_BASELINE_MARKER } = await import('../assets/universal-baseline.js');
     const { log } = await import('../ui.js');
     try {
@@ -547,12 +782,15 @@ export async function installBaselineLessons(baselinePath, rl, ecosystems) {
                 existing.includes('<!-- totem:baseline -->'))
                 return 'exists';
         }
-        // In non-TTY mode (CI, piped input), default to installing
+        // Non-interactive (CI, `--yes`, piped input): take the (Y) default — install.
         let declined = false;
-        if (process.stdin.isTTY) {
+        if (interactive) {
             const answer = await rl.question('Install baseline lessons? (Y/n): ');
             declined = answer.trim().toLowerCase() === 'n' || answer.trim().toLowerCase() === 'no';
         }
+        else {
+            log.info('Totem', 'Non-interactive mode — installing baseline lessons.');
+        }
         if (declined)
             return 'skipped';
         const dir = path.dirname(baselinePath);
@@ -621,8 +859,31 @@ export function upgradeReflexes(content) {
     const startIdx = content.indexOf(REFLEX_START);
     const endIdx = content.indexOf(REFLEX_END);
     if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
-        const before = content.slice(0, startIdx).replace(/\n+$/, '\n');
-        const after = content.slice(endIdx + REFLEX_END.length);
+        // Both seams must be owned by exactly one party for regen to be a
+        // byte-fixpoint. Before-seam: normalize the prefix to end with exactly one
+        // `\n` (AI_PROMPT_BLOCK's own leading `\n` supplies the separating blank
+        // line); a prefix that is nothing but that added newline drops to '' so a
+        // marker-at-byte-0 file cannot grow a leading blank line per regen.
+        let before = content.slice(0, startIdx).replace(/(?:\r?\n)*$/, '\n');
+        if (before === '\n')
+            before = '';
+        let after = content.slice(endIdx + REFLEX_END.length);
+        // After-seam: AI_PROMPT_BLOCK already ends with the end marker's own line
+        // terminator, so the OLD block's terminator must not re-enter through
+        // `after` — that duplication accreted one blank line per regen into the
+        // after-end span that is contractually user content (#1890; byte-verified
+        // v7→v9, #2599). A tail of nothing but ASCII whitespace is totem's own
+        // accretion residue, not user content: normalize it away entirely so
+        // already-damaged files heal instead of freezing their residue.
+        if (/^[ \t\r\n]*$/.test(after)) {
+            after = '';
+        }
+        else if (after.startsWith('\r\n')) {
+            after = after.slice(2);
+        }
+        else if (after.startsWith('\n')) {
+            after = after.slice(1);
+        }
         return { content: before + AI_PROMPT_BLOCK + after, clean: true };
     }
     // Case 2: Legacy block (v1) — no boundaries, appended at end of file
@@ -666,6 +927,19 @@ function applyReflexUpgrade(filePath) {
     fs.writeFileSync(filePath, updated, 'utf-8');
     return clean;
 }
+/**
+ * Resolve the AI-tool selection prompt's answer. Anything that is not an explicit
+ * `none` / `select` is the Enter default, `all` — which is also the answer the
+ * non-interactive path takes without raising the prompt (mmnto-ai/totem#2601).
+ */
+export function resolveToolSelection(answer) {
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === 'none')
+        return 'none';
+    if (trimmed === 'select')
+        return 'select';
+    return 'all';
+}
 export async function initCommand(options) {
     // ─── Doctrine pin wiring (mmnto-ai/totem#2088, Proposal 292 S1) ───
     // Self-contained non-interactive path: point orient.parityManifest at the
@@ -773,6 +1047,11 @@ export default {
     const existingConfig = CONFIG_FILES.map((f) => path.join(cwd, f)).find((p) => fs.existsSync(p));
     const configExists = !!existingConfig;
     const rl = readline.createInterface({ input, output });
+    // The ONE non-interactive predicate (mmnto-ai/totem#2601). Every `rl.question` site
+    // below is guarded by it: a prompt raised without a TTY never settles, and init's
+    // mutations land BEFORE the prompts, so a half-run reads as a silent no-op. Each
+    // guarded site logs the default it took.
+    const interactive = process.stdin.isTTY === true && options?.yes !== true;
     const summary = [];
     try {
         printBanner();
@@ -823,6 +1102,11 @@ export default {
                 else if (embeddingTier === 'gemini') {
                     log.info('Totem', `Detected ${bold('GEMINI_API_KEY')} in environment. Using Gemini embeddings (single-key DX).`);
                 }
+                else if (!interactive) {
+                    // Non-interactive: take the Enter default (Lite tier). The other two answers
+                    // MUTATE (an .env write, an Ollama pin) and must not fire unattended.
+                    log.info('Totem', 'Non-interactive mode — no embedding key entered; starting in Lite tier.');
+                }
                 else {
                     // No key detected — prompt the user
                     const answer = await rl.question('Enter your OpenAI API key, type "ollama" for a local model, or press Enter for Lite tier: ');
@@ -929,7 +1213,7 @@ export default {
         // --- Baseline lessons (core + detected ecosystem packs) ---
         const baselinePath = path.join(lessonsDir, 'baseline.md');
         const detectedEcosystems = detectProject(cwd).ecosystems;
-        const baselineResult = await installBaselineLessons(baselinePath, rl, detectedEcosystems);
+        const baselineResult = await installBaselineLessons(baselinePath, rl, detectedEcosystems, interactive);
         if (baselineResult === 'installed') {
             const extraPacks = detectedEcosystems.filter((e) => e !== 'javascript');
             const packLabel = extraPacks.length > 0 ? ` + ${extraPacks.join(', ')}` : '';
@@ -994,31 +1278,38 @@ export default {
             if (detectedTools.length > 0) {
                 const toolNames = detectedTools.map((t) => t.name).join(', ');
                 log.info('Totem', `Detected AI tools: ${bold(toolNames)}`);
-                const toolAnswer = await rl.question('Which tools should Totem configure? [all/none/select] (default: all): ');
                 let selectedTools;
-                const trimmed = toolAnswer.trim().toLowerCase();
-                if (trimmed === 'none') {
-                    selectedTools = [];
+                if (!interactive) {
+                    // Non-interactive: the Enter default is 'all'. The per-tool `select` loop is
+                    // unreachable from here — it is entered only by an interactive 'select'.
+                    selectedTools = detectedTools;
+                    log.info('Totem', `Non-interactive mode — configuring all detected tools (${toolNames}).`);
                 }
-                else if (trimmed === 'select') {
-                    selectedTools = [];
-                    for (const tool of detectedTools) {
-                        const pick = await rl.question(`  Configure ${tool.name}? (Y/n): `);
-                        if (pick.trim().toLowerCase() !== 'n' && pick.trim().toLowerCase() !== 'no') {
-                            selectedTools.push(tool);
+                else {
+                    const toolAnswer = await rl.question('Which tools should Totem configure? [all/none/select] (default: all): ');
+                    const selection = resolveToolSelection(toolAnswer);
+                    if (selection === 'none') {
+                        selectedTools = [];
+                    }
+                    else if (selection === 'select') {
+                        selectedTools = [];
+                        for (const tool of detectedTools) {
+                            const pick = await rl.question(`  Configure ${tool.name}? (Y/n): `);
+                            if (pick.trim().toLowerCase() !== 'n' && pick.trim().toLowerCase() !== 'no') {
+                                selectedTools.push(tool);
+                            }
                         }
                     }
-                }
-                else {
-                    // 'all' or Enter (default)
-                    selectedTools = detectedTools;
+                    else {
+                        selectedTools = detectedTools;
+                    }
                 }
                 // --- MCP scaffolding for selected tools ---
                 for (const tool of selectedTools) {
                     if (!tool.mcpPath || !tool.serverEntry)
                         continue;
                     const filePath = path.join(cwd, tool.mcpPath);
-                    const result = scaffoldMcpConfig(filePath, tool.serverEntry);
+                    const result = scaffoldMcpConfig(filePath, tool.serverEntry, { projectRoot: cwd });
                     if (result.err) {
                         log.error('Totem Error', result.err); // totem-ignore — result.err is internal scaffolding error, not LLM output
                         console.error(`To fix this, add the following manually to your ${tool.mcpPath} under "mcpServers":\n`);
@@ -1030,6 +1321,15 @@ export default {
                     else if (result.action === 'merged') {
                         summary.push({ file: tool.mcpPath, action: `Added totem to mcpServers` });
                     }
+                    else if (result.existingName !== undefined) {
+                        // Package-level dedup hit (mmnto-ai/totem#2601): no append, but the skip is
+                        // disclosed rather than silent — the user's registration is under a name
+                        // they chose, and a silent no-op reads as init having done nothing.
+                        summary.push({
+                            file: tool.mcpPath,
+                            action: `Totem MCP already registered as \`${result.existingName}\` — no duplicate added`,
+                        });
+                    }
                 }
                 // --- Reflex injection & upgrade for selected tools ---
                 const outdatedFiles = [];
@@ -1056,13 +1356,14 @@ export default {
                     const fileList = outdatedFiles.map((f) => f.tool.reflexFile).join(', ');
                     log.warn('Totem', `Outdated reflexes found in: ${bold(fileList)}`);
                     let shouldUpgrade = false;
-                    if (process.stdin.isTTY) {
+                    if (interactive) {
                         const answer = await rl.question(`Upgrade reflexes to v${REFLEX_VERSION}? (Y/n): `);
                         shouldUpgrade =
                             answer.trim().toLowerCase() !== 'n' && answer.trim().toLowerCase() !== 'no';
                     }
                     else {
-                        // Non-TTY (CI/scripted): auto-upgrade to match baseline lessons behavior
+                        // Non-interactive (CI/scripted/`--yes`): take the (Y) default, matching
+                        // baseline lessons behavior.
                         shouldUpgrade = true;
                         log.info('Totem', 'Non-interactive mode — auto-upgrading reflexes.');
                     }
@@ -1122,6 +1423,16 @@ export default {
                                 action: result.summaryActionOverride ?? `Merged ${tool.name} hook into existing config`,
                             });
                         }
+                        else if ((result.action === 'skipped' || result.action === 'exists') &&
+                            result.summaryActionOverride) {
+                            // A no-op an installer chose to DISCLOSE (mmnto-ai/totem#2601 vendor-hook
+                            // guard). Bare `skipped`/`exists` stay silent; an override means the user
+                            // must know why the file was left alone. `exists` carries one too: a
+                            // custom `.js` coexisting with an already-canonical managed `.cjs` is the
+                            // same live double-fire hazard as the drift-repaired case, and the fact
+                            // that nothing needed rewriting must not silence it.
+                            summary.push({ file: result.file, action: result.summaryActionOverride });
+                        }
                     }
                 }
             }
@@ -1164,7 +1475,10 @@ export default {
             // 'exists' (already canonical) and 'missing' (no package.json) are silent no-ops.
             // --- Always run: enforcement hooks (pre-commit + pre-push) ---
             const hookTier = options?.strict ? 'strict' : undefined;
-            const enforcement = await installEnforcementHooks(cwd, rl, { tier: hookTier });
+            const enforcement = await installEnforcementHooks(cwd, rl, {
+                tier: hookTier,
+                interactive,
+            });
             if (enforcement.preCommit === 'installed' || enforcement.preCommit === 'appended') {
                 summary.push({
                     file: '.git/hooks/pre-commit',
@@ -1190,7 +1504,7 @@ export default {
                 });
             }
             // --- Always run: post-merge git hook ---
-            await installPostMergeHook(cwd, rl);
+            await installPostMergeHook(cwd, rl, { interactive });
             // --- Always run: .gitignore ---
             const gitignorePath = path.join(cwd, '.gitignore');
             if (fs.existsSync(gitignorePath)) {
@@ -1220,8 +1534,19 @@ export default {
             const { scanCursorInstructions } = await import('@mmnto/totem');
             const cursorInstructions = scanCursorInstructions(cwd);
             if (cursorInstructions.length > 0) {
-                const answer = await rl.question(`\nFound ${cursorInstructions.length} existing AI rule(s) (.cursorrules / .mdc). Compile into deterministic invariants? (Y/n): `);
-                if (answer.trim().toLowerCase() !== 'n' && answer.trim().toLowerCase() !== 'no') {
+                // The one non-interactive default that is NOT the Enter default: compiling is
+                // an LLM-driven rewrite of compiled-rules.json, so it stays opt-in and the
+                // manual command is disclosed instead (mmnto-ai/totem#2601).
+                let shouldCompile = false;
+                if (interactive) {
+                    const answer = await rl.question(`\nFound ${cursorInstructions.length} existing AI rule(s) (.cursorrules / .mdc). Compile into deterministic invariants? (Y/n): `);
+                    shouldCompile =
+                        answer.trim().toLowerCase() !== 'n' && answer.trim().toLowerCase() !== 'no';
+                }
+                else {
+                    log.info('Totem', `Non-interactive mode — found ${cursorInstructions.length} existing AI rule(s) (.cursorrules / .mdc); not compiling. Run \`totem compile --from-cursor\` to compile them.`);
+                }
+                if (shouldCompile) {
                     try {
                         const { compileCommand } = await import('./compile.js');
                         await compileCommand({ fromCursor: true });