@daemux/store-automator 0.10.62 → 0.10.64

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "App Store & Google Play automation for Flutter apps",
-    "version": "0.10.62"
+    "version": "0.10.64"
   },
   "plugins": [
     {
       "name": "store-automator",
       "source": "./plugins/store-automator",
       "description": "3 agents for app store publishing: reviewer, meta-creator, media-designer",
-      "version": "0.10.62",
+      "version": "0.10.64",
       "keywords": [
         "flutter",
         "app-store",

package/README.md

@@ -20,30 +20,46 @@ Plus CI/CD templates for GitHub Actions, Fastlane, web pages, and scripts.
 
 ## Installation
 
+**Project (default):** Full install into your Flutter project -- agents, CI/CD templates, MCP servers, and interactive setup:
+
 ```bash
 cd your-flutter-project
-npm install @daemux/store-automator@latest
+npx --yes @daemux/store-automator
 ```
 
-The postinstall script runs an interactive setup with five sections:
+The installer runs an interactive setup with five sections:
 
 1. **App Identity** -- App name, bundle ID, package name, SKU, Apple ID
-2. **Credentials** -- Guided steps for App Store Connect API key, Google Play service account, Android keystore, and Match code signing
+2. **Credentials** -- App Store Connect API key, Google Play service account, Android keystore, Match code signing
 3. **Store Settings** -- iOS categories/pricing, Android track/rollout, metadata languages
 4. **Web Settings** -- Domain, colors, company info, legal jurisdiction
-5. **MCP Tokens** -- Stitch and Cloudflare API keys (optional, press Enter to skip)
-
-All values are written to `ci.config.yaml`. The installer also:
+5. **MCP Tokens** -- Stitch and Cloudflare API keys (optional)
 
-- Configures `.mcp.json` with MCP servers (Playwright, mobile-mcp, Stitch, Cloudflare)
-- Installs `.claude/CLAUDE.md` with your app name and agent configurations
-- Copies CI/CD templates (Fastlane, scripts, web pages, GitHub Actions)
-- Configures `.claude/settings.json` with required env vars
-- Runs post-install guides for GitHub repo setup, secrets, and Firebase
+All values are written to `ci.config.yaml`. The installer also configures `.mcp.json`, installs `.claude/CLAUDE.md`, copies CI/CD templates, and configures `.claude/settings.json`.
 
 Re-running the installer reads existing `ci.config.yaml` values as defaults, so you can update individual fields without re-entering everything.
 
-## After Installation
+**Global (agents only):** Install the plugin into `~/.claude` for use across all projects, without touching the current directory:
+
+```bash
+npx --yes @daemux/store-automator --global
+```
+
+Global install:
+
+- Registers the marketplace and installs the plugin at user scope
+- Writes `~/.claude/CLAUDE.md` with agent configurations
+- Adds required env vars and statusLine to `~/.claude/settings.json`
+
+Global install does NOT:
+
+- Create `ci.config.yaml`, `fastlane/`, `scripts/`, `web/`, `Gemfile`, `.github/workflows/`, or any other project files
+- Write or modify `.mcp.json` in the current directory
+- Run any interactive prompts or post-install guides
+
+Use project install for any Flutter app you are actually publishing. Global install is for agent-only access from arbitrary directories.
+
+## After Installation _(project scope only)_
 
 1. Add any credential files not configured during the guided setup:
    - `creds/AuthKey.p8` -- Apple App Store Connect API key
@@ -52,7 +68,7 @@ Re-running the installer reads existing `ci.config.yaml` values as defaults, so
 2. Verify `ci.config.yaml` has all required values filled in
 3. Start Claude Code and use the agents
 
-## Manual Setup
+## Manual Setup _(project scope only)_
 
 If postinstall was skipped (CI environment), run manually:
 
@@ -240,19 +256,18 @@ web:
   google_play_url: ""                          # Filled after first Android publish
 ```
 
-## Usage
+## Uninstall
 
-### Global Install
+**Project uninstall:** Removes CI templates, `ci.config.yaml`, `.mcp.json` entries, `.claude/CLAUDE.md`, and settings from the current project. Marketplace files remain in `~/.claude/plugins/`.
 
 ```bash
-npx @daemux/store-automator -g
+npx --yes @daemux/store-automator --uninstall
 ```
 
-### Uninstall
+**Global uninstall:** Removes the plugin from `~/.claude` and clears the marketplace. Does NOT touch the current project's `ci.config.yaml`, CI templates, or `.mcp.json`.
 
 ```bash
-npx @daemux/store-automator -u         # project scope
-npx @daemux/store-automator -g -u      # global scope
+npx --yes @daemux/store-automator --global --uninstall
 ```
 
 ## Agents
@@ -269,7 +284,7 @@ Designs complete app UI screens, creates ASO-optimized store screenshots for all
 
 Reviews all metadata, screenshots, privacy policy, and IAP configuration against Apple and Google guidelines. Returns APPROVED or REJECTED with specific issues.
 
-## CI/CD Templates
+## CI/CD Templates _(project scope only)_
 
 The package installs these templates to your project:
 
@@ -282,7 +297,7 @@ The package installs these templates to your project:
 | `web/` | Marketing, privacy, terms, and support page templates |
 | `Gemfile` | Ruby gems for Fastlane |
 
-## Workflow
+## Workflow _(project scope only)_
 
 1. Install the package (interactive setup fills `ci.config.yaml`)
 2. Add any remaining credential files
@@ -291,7 +306,7 @@ The package installs these templates to your project:
 5. Use `appstore-reviewer` to verify compliance
 6. Push to GitHub -- GitHub Actions builds and publishes automatically
 
-## MCP Servers
+## MCP Servers _(project scope only)_
 
 The package configures these MCP servers in `.mcp.json`:
 
@@ -302,7 +317,7 @@ The package configures these MCP servers in `.mcp.json`:
 | stitch | AI design tool for screenshot generation | `STITCH_API_KEY` |
 | cloudflare | Cloudflare Pages deployment | `CLOUDFLARE_API_TOKEN` + Account ID |
 
-## Idempotency
+## Idempotency _(project scope only)_
 
 The installer is idempotent. Re-running it reads existing values from `ci.config.yaml` as defaults for each prompt. This means you can:
 

package/bin/cli.mjs

@@ -9,8 +9,6 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
 
-const notifier = updateNotifier({ pkg });
-
 const args = process.argv.slice(2);
 let scope = 'project';
 let action = 'install';
@@ -146,6 +144,13 @@ Examples:
   }
 }
 
+if (scope === 'user' && cliTokens.githubActions) {
+  console.error('Error: --github-actions and --global are mutually exclusive.');
+  console.error('  --global targets ~/.claude (no CI templates).');
+  console.error('  --github-actions targets a project repo. Pick one.');
+  process.exit(1);
+}
+
 if (cliTokens.githubActions) {
   const missing = [];
   if (!cliTokens.matchDeployKey) missing.push('--match-deploy-key');
@@ -163,7 +168,9 @@ if (cliTokens.githubActions) {
   }
 }
 
-notifier.notify();
+if (!isPostinstall) {
+  updateNotifier({ pkg }).notify();
+}
 
 try {
   if (action === 'uninstall') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.62",
+  "version": "0.10.64",
   "description": "Full App Store & Google Play automation for Flutter apps with Claude Code agents",
   "type": "module",
   "bin": {

package/plugins/store-automator/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "store-automator",
-  "version": "0.10.62",
+  "version": "0.10.64",
   "description": "App Store & Google Play automation agents for Flutter app publishing",
   "author": {
     "name": "Daemux"

package/src/backup.mjs

@@ -0,0 +1,99 @@
+import {
+  existsSync, mkdirSync, readFileSync, writeFileSync,
+  readdirSync, rmSync, statSync,
+} from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+
+const BACKUP_ROOT = join(homedir(), '.claude', 'backups', 'store-automator');
+const RETAIN_COUNT = 10;
+
+function utcTimestamp() {
+  return new Date().toISOString().slice(0, 19).replace(/:/g, '');
+}
+
+function sha256(buf) {
+  return createHash('sha256').update(buf).digest('hex');
+}
+
+function writeBackupFile(filePath, contentBuf) {
+  const ts = utcTimestamp();
+  const dir = join(BACKUP_ROOT, ts);
+  const dest = join(dir, `${basename(filePath)}.bak`);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(dest, contentBuf);
+  console.log(`Backup written to: ${dest}`);
+  return dest;
+}
+
+export function backupIfChanging(filePath, newContent) {
+  if (!existsSync(filePath)) {
+    return { backedUp: false, path: null };
+  }
+
+  const current = readFileSync(filePath);
+  const incoming = Buffer.isBuffer(newContent) ? newContent : Buffer.from(newContent, 'utf8');
+  if (sha256(current) === sha256(incoming)) {
+    return { backedUp: false, path: null };
+  }
+
+  const dest = writeBackupFile(filePath, current);
+  return { backedUp: true, path: dest };
+}
+
+// Snapshot arbitrary content to a timestamped backup. Used for post-hoc backups
+// when the caller only has access to pre-mutation content after the fact
+// (e.g. functions that mutate the target file in place).
+// No-op if preContent already matches postContent (nothing really changed).
+export function backupSnapshot(filePath, preContent, postContent) {
+  if (preContent == null) return { backedUp: false, path: null };
+  if (preContent === postContent) return { backedUp: false, path: null };
+  const buf = Buffer.isBuffer(preContent) ? preContent : Buffer.from(preContent, 'utf8');
+  const dest = writeBackupFile(filePath, buf);
+  return { backedUp: true, path: dest };
+}
+
+function listBackupEntries() {
+  if (!existsSync(BACKUP_ROOT)) return [];
+  const entries = [];
+  for (const tsDir of readdirSync(BACKUP_ROOT)) {
+    const tsPath = join(BACKUP_ROOT, tsDir);
+    let s;
+    try { s = statSync(tsPath); } catch { continue; }
+    if (!s.isDirectory()) continue;
+    for (const file of readdirSync(tsPath)) {
+      const fullPath = join(tsPath, file);
+      entries.push({ basename: file, ts: tsDir, fullPath, tsDir: tsPath });
+    }
+  }
+  return entries;
+}
+
+export function pruneBackups() {
+  const entries = listBackupEntries();
+  if (entries.length === 0) return;
+
+  const byBasename = new Map();
+  for (const e of entries) {
+    if (!byBasename.has(e.basename)) byBasename.set(e.basename, []);
+    byBasename.get(e.basename).push(e);
+  }
+
+  const toDelete = [];
+  for (const group of byBasename.values()) {
+    group.sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0));
+    toDelete.push(...group.slice(RETAIN_COUNT));
+  }
+
+  for (const e of toDelete) {
+    try { rmSync(e.fullPath, { force: true }); } catch { /* ignore */ }
+  }
+
+  const touchedTsDirs = new Set(toDelete.map((e) => e.tsDir));
+  for (const tsDir of touchedTsDirs) {
+    try {
+      if (readdirSync(tsDir).length === 0) rmSync(tsDir, { recursive: true, force: true });
+    } catch { /* ignore */ }
+  }
+}

package/src/install.mjs

@@ -1,4 +1,4 @@
-import { existsSync, rmSync, cpSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync, cpSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -13,6 +13,8 @@ import { getMcpServers, writeMcpJson } from './mcp-setup.mjs';
 import { installClaudeMd, installCiTemplates, installFirebaseTemplates } from './templates.mjs';
 import { readCiConfig, writeCiFields, writeCiLanguages, writeMatchConfig, isPlaceholder } from './ci-config.mjs';
 import { installGitHubActionsPath } from './install-paths.mjs';
+import { backupSnapshot, pruneBackups } from './backup.mjs';
+import { writeManagedSettings } from './managed-settings.mjs';
 
 function checkClaudeCli() {
   const result = exec('command -v claude') || exec('which claude');
@@ -152,7 +154,55 @@ function printNextSteps(prompted) {
   }
 }
 
+async function withReadline(fn) {
+  const { createInterface } = await import('node:readline');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await fn(rl);
+  } finally {
+    rl.close();
+  }
+}
+
+function readIfExists(filePath) {
+  return existsSync(filePath) ? readFileSync(filePath, 'utf8') : null;
+}
+
+function configureScopedSettings(baseDir, packageDir, appName, scopeLabel) {
+  ensureDir(baseDir);
+  installClaudeMd(join(baseDir, 'CLAUDE.md'), packageDir, appName);
+  console.log(`Configuring ${scopeLabel} settings...`);
+  const settingsPath = join(baseDir, 'settings.json');
+
+  // Snapshot pre-mutation state so we can back it up if inject* changes anything.
+  // inject* functions mutate in place (ensureFile creates {} when missing), so the
+  // backup must capture state before they run and be written only if a real change
+  // occurred — otherwise re-running install would churn backups on every invocation.
+  const preContent = readIfExists(settingsPath);
+
+  injectEnvVars(settingsPath);
+  injectStatusLine(settingsPath);
+
+  const postContent = readIfExists(settingsPath) ?? '';
+  backupSnapshot(settingsPath, preContent, postContent);
+
+  writeManagedSettings(baseDir);
+}
+
+function printGlobalNote() {
+  console.log('');
+  console.log('Note: Global install registers the marketplace and installs ~/.claude/CLAUDE.md only.');
+  console.log('To generate CI/CD templates, MCP config, and ci.config.yaml, run `npx @daemux/store-automator` inside a project directory.');
+}
+
 export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
+  const isGlobal = scope === 'user';
+
+  if (isPostinstall && isGlobal) {
+    console.log('Skipping postinstall in global scope.');
+    return;
+  }
+
   checkClaudeCli();
 
   console.log('Installing/updating Daemux Store Automator...');
@@ -160,102 +210,73 @@ export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
   const isGitHubActions = Boolean(cliTokens.githubActions);
   const nonInteractive = Boolean(process.env.npm_config_yes) || process.argv.includes('--postinstall');
   const projectDir = process.cwd();
-  const oldVersion = readMarketplaceVersion();
   const packageDir = getPackageDir();
+  const oldVersion = readMarketplaceVersion();
 
-  // 1. Copy plugin files + register marketplace
   copyPluginFiles(packageDir);
   clearCache();
   registerMarketplace();
   runClaudeInstall(scope);
-
   const newVersion = readMarketplaceVersion('unknown');
 
-  // 2. Install CI templates (creates ci.config.yaml if missing)
-  installCiTemplates(projectDir, packageDir);
-  installFirebaseTemplates(projectDir, packageDir);
-
-  // 3. Read current ci.config.yaml values
-  const currentConfig = readCiConfig(projectDir);
-
-  // 4. Run interactive prompts (or use CLI flags / skip in non-interactive)
-  let prompted;
-  if (isGitHubActions) {
-    prompted = {
-      bundleId: cliTokens.bundleId ?? '',
-      matchDeployKeyPath: cliTokens.matchDeployKey,
-      matchGitUrl: cliTokens.matchGitUrl,
-    };
-  } else if (nonInteractive) {
-    prompted = { ...cliTokens };
-  } else {
-    const { createInterface } = await import('node:readline');
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-      prompted = await promptAll(rl, cliTokens, currentConfig, projectDir);
-    } finally {
-      rl.close();
-    }
-  }
-
-  // 5. Write all prompted values to ci.config.yaml
-  const ciFields = mapPromptsToCiFields(prompted);
-  const wrote = writeCiFields(projectDir, ciFields);
-  if (wrote) console.log('Configuration written to ci.config.yaml');
-
-  if (prompted.matchDeployKeyPath || prompted.matchGitUrl) {
-    const wroteMatch = writeMatchConfig(projectDir, {
-      deployKeyPath: prompted.matchDeployKeyPath,
-      gitUrl: prompted.matchGitUrl,
-    });
-    if (wroteMatch) console.log('Match credentials written to ci.config.yaml');
-  }
+  let prompted = {};
+  if (!isGlobal) {
+    installCiTemplates(projectDir, packageDir);
+    installFirebaseTemplates(projectDir, packageDir);
+    const currentConfig = readCiConfig(projectDir);
 
-  // 6. Handle languages separately
-  if (prompted.languages) {
-    const langStr = Array.isArray(prompted.languages)
-      ? prompted.languages.join(',')
-      : prompted.languages;
-    if (writeCiLanguages(projectDir, langStr)) {
-      console.log('Languages updated in ci.config.yaml');
+    if (isGitHubActions) {
+      prompted = {
+        bundleId: cliTokens.bundleId ?? '',
+        matchDeployKeyPath: cliTokens.matchDeployKey,
+        matchGitUrl: cliTokens.matchGitUrl,
+      };
+    } else if (nonInteractive) {
+      prompted = { ...cliTokens };
+    } else {
+      prompted = await withReadline((rl) => promptAll(rl, cliTokens, currentConfig, projectDir));
     }
-  }
-
-  // 7. Configure MCP, CLAUDE.md, settings
-  if (!isGitHubActions) {
-    const servers = getMcpServers(prompted);
-    writeMcpJson(projectDir, servers);
-  }
-
-  const baseDir = scope === 'user'
-    ? join(homedir(), '.claude')
-    : join(process.cwd(), '.claude');
 
-  ensureDir(baseDir);
+    if (writeCiFields(projectDir, mapPromptsToCiFields(prompted))) {
+      console.log('Configuration written to ci.config.yaml');
+    }
 
-  installClaudeMd(join(baseDir, 'CLAUDE.md'), packageDir, prompted.appName);
+    if (prompted.matchDeployKeyPath || prompted.matchGitUrl) {
+      const wroteMatch = writeMatchConfig(projectDir, {
+        deployKeyPath: prompted.matchDeployKeyPath,
+        gitUrl: prompted.matchGitUrl,
+      });
+      if (wroteMatch) console.log('Match credentials written to ci.config.yaml');
+    }
 
-  installGitHubActionsPath(projectDir, packageDir, prompted);
+    if (prompted.languages) {
+      const langStr = Array.isArray(prompted.languages) ? prompted.languages.join(',') : prompted.languages;
+      if (writeCiLanguages(projectDir, langStr)) {
+        console.log('Languages updated in ci.config.yaml');
+      }
+    }
 
-  const scopeLabel = scope === 'user' ? 'global' : 'project';
-  console.log(`Configuring ${scopeLabel} settings...`);
-  const settingsPath = join(baseDir, 'settings.json');
-  injectEnvVars(settingsPath);
-  injectStatusLine(settingsPath);
+    if (!isGitHubActions) writeMcpJson(projectDir, getMcpServers(prompted));
+    installGitHubActionsPath(projectDir, packageDir, prompted);
 
-  // 8. Run post-install guides (interactive only)
-  if (!isGitHubActions && !nonInteractive) {
-    const { createInterface } = await import('node:readline');
-    const guideRl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-      const { runPostInstallGuides } = await import('./prompts/store-settings.mjs');
-      await runPostInstallGuides(guideRl, currentConfig);
-    } finally {
-      guideRl.close();
+    if (!isGitHubActions && !nonInteractive) {
+      await withReadline(async (rl) => {
+        const { runPostInstallGuides } = await import('./prompts/store-settings.mjs');
+        await runPostInstallGuides(rl, currentConfig);
+      });
     }
   }
 
-  // 9. Summary + dynamic next steps
+  const baseDir = isGlobal ? join(homedir(), '.claude') : join(projectDir, '.claude');
+  const appName = prompted.appName || (isGlobal ? 'your app' : undefined);
+  configureScopedSettings(baseDir, packageDir, appName, isGlobal ? 'global' : 'project');
+
+  pruneBackups();
+
   printSummary(scope, oldVersion, newVersion);
-  printNextSteps(prompted);
+  if (isGlobal) {
+    printGlobalNote();
+  } else {
+    printNextSteps(prompted);
+  }
 }

package/src/managed-settings.mjs

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const LEDGER_FILENAME = 'store-automator-managed-settings.json';
+
+export const HISTORICAL_ENV_VALUES = {
+  'CLAUDE_CODE_ENABLE_TASKS': 'true',
+  'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS': '1',
+};
+
+export const HISTORICAL_ENV_KEYS = Object.keys(HISTORICAL_ENV_VALUES);
+
+// Ledger is scoped to the settings.json baseDir (e.g. ~/.claude for global or
+// <project>/.claude for project). Keeping it adjacent to the settings file it
+// describes prevents global/project scope overlap.
+export function getLedgerPath(baseDir) {
+  return join(baseDir, LEDGER_FILENAME);
+}
+
+function getSettingsPath(baseDir) {
+  return join(baseDir, 'settings.json');
+}
+
+function sortedStringify(value) {
+  return JSON.stringify(value, (_, v) => {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      const out = {};
+      for (const key of Object.keys(v).sort()) out[key] = v[key];
+      return out;
+    }
+    return v;
+  }, 2) + '\n';
+}
+
+function readSettings(settingsPath) {
+  if (!existsSync(settingsPath)) return {};
+  try {
+    return JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function writeManagedSettings(baseDir) {
+  const settingsPath = getSettingsPath(baseDir);
+  const ledgerPath = getLedgerPath(baseDir);
+  const settings = readSettings(settingsPath);
+  const env = settings.env || {};
+
+  const envKeys = HISTORICAL_ENV_KEYS
+    .filter((k) => Object.prototype.hasOwnProperty.call(env, k))
+    .sort();
+
+  const envValues = {};
+  for (const k of envKeys) envValues[k] = env[k];
+
+  const statusLineValue = settings.statusLine;
+  const hasExpectedStatusLine = Boolean(
+    statusLineValue
+    && typeof statusLineValue === 'object'
+    && statusLineValue.type === 'command'
+    && typeof statusLineValue.command === 'string'
+    && statusLineValue.command.includes('context_window'),
+  );
+
+  const ledger = {
+    schemaVersion: 1,
+    plugin: 'daemux-store-automator',
+    envKeys,
+    envValues,
+    statusLine: hasExpectedStatusLine
+      ? { wasSet: true, content: statusLineValue }
+      : { wasSet: false, content: null },
+  };
+
+  mkdirSync(dirname(ledgerPath), { recursive: true });
+  writeFileSync(ledgerPath, sortedStringify(ledger), 'utf8');
+}
+
+export function readManagedSettings(baseDir) {
+  const ledgerPath = getLedgerPath(baseDir);
+  if (!existsSync(ledgerPath)) return null;
+  try {
+    return JSON.parse(readFileSync(ledgerPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}

package/src/settings.mjs

@@ -1,4 +1,3 @@
-import { existsSync } from 'node:fs';
 import { ensureFile, readJson, writeJson } from './utils.mjs';
 
 const ENV_DEFAULTS = {
@@ -47,28 +46,6 @@ export function injectEnvVars(settingsPath) {
   }
 }
 
-export function removeEnvVars(settingsPath) {
-  if (!existsSync(settingsPath)) return;
-
-  try {
-    const settings = readJson(settingsPath);
-    if (!settings.env) return;
-
-    for (const key of Object.keys(ENV_DEFAULTS)) {
-      delete settings.env[key];
-    }
-
-    if (Object.keys(settings.env).length === 0) {
-      delete settings.env;
-    }
-
-    writeJson(settingsPath, settings);
-    console.log('Removed env vars');
-  } catch {
-    // Silently skip if settings file is invalid
-  }
-}
-
 export function injectStatusLine(settingsPath) {
   try {
     ensureFile(settingsPath);
@@ -90,17 +67,3 @@ export function injectStatusLine(settingsPath) {
   }
 }
 
-export function removeStatusLine(settingsPath) {
-  if (!existsSync(settingsPath)) return;
-
-  try {
-    const settings = readJson(settingsPath);
-    if (!settings.statusLine) return;
-
-    delete settings.statusLine;
-    writeJson(settingsPath, settings);
-    console.log('Removed statusLine configuration');
-  } catch {
-    // Silently skip if settings file is invalid
-  }
-}

package/src/templates.mjs

@@ -1,6 +1,11 @@
 import { existsSync, cpSync, copyFileSync, chmodSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './utils.mjs';
+import { backupIfChanging } from './backup.mjs';
+
+const SENTINEL_BEGIN = '<!-- BEGIN daemux-store-automator -->';
+const SENTINEL_END = '<!-- END daemux-store-automator -->';
+const SENTINEL_BLOCK_RE = /<!-- BEGIN daemux-store-automator -->[\s\S]*?<!-- END daemux-store-automator -->/;
 
 const FILE_COPIES = [
   ['ci.config.yaml.template', 'ci.config.yaml'],
@@ -46,18 +51,60 @@ function copyIfMissing(srcPath, destPath, label, isDirectory) {
   }
 }
 
+function wrapInSentinels(body) {
+  const trimmed = body.replace(/\s+$/, '');
+  return `${SENTINEL_BEGIN}\n${trimmed}\n${SENTINEL_END}\n`;
+}
+
+function looksLikeUnsentineledPluginContent(existing) {
+  if (!existing) return false;
+  const startsWithHeader = /^#\s.+-\s*Development Standards\b/m.test(existing.split('\n').slice(0, 5).join('\n'));
+  const hasFastlane = existing.includes('fastlane');
+  return startsWithHeader && hasFastlane;
+}
+
+function composeNewFileContent(existing, wrappedBlock) {
+  if (!existing) {
+    return wrappedBlock;
+  }
+  if (SENTINEL_BLOCK_RE.test(existing)) {
+    return existing.replace(SENTINEL_BLOCK_RE, wrappedBlock.replace(/\n$/, ''));
+  }
+  if (looksLikeUnsentineledPluginContent(existing)) {
+    return wrappedBlock;
+  }
+  const sep = existing.endsWith('\n') ? '' : '\n';
+  return `${existing}${sep}\n${wrappedBlock}`;
+}
+
 export function installClaudeMd(targetPath, packageDir, appName) {
   const template = join(packageDir, 'templates', 'CLAUDE.md.template');
   if (!existsSync(template)) return;
-  const action = existsSync(targetPath) ? 'Updating' : 'Installing';
+  const targetExists = existsSync(targetPath);
+  const action = targetExists ? 'Updating' : 'Installing';
   console.log(`${action} CLAUDE.md...`);
   ensureDir(join(targetPath, '..'));
 
-  let content = readFileSync(template, 'utf8');
+  let body = readFileSync(template, 'utf8');
   if (appName) {
-    content = content.replace(/\{APP_NAME\}/g, appName);
+    body = body.split('{APP_NAME}').join(appName);
   }
-  writeFileSync(targetPath, content, 'utf8');
+  const wrappedBlock = wrapInSentinels(body);
+
+  const existing = targetExists ? readFileSync(targetPath, 'utf8') : '';
+  const migrating = targetExists
+    && !SENTINEL_BLOCK_RE.test(existing)
+    && looksLikeUnsentineledPluginContent(existing);
+
+  const newContent = composeNewFileContent(existing, wrappedBlock);
+
+  const backupResult = backupIfChanging(targetPath, newContent);
+  if (migrating) {
+    const backupPath = backupResult.path || '(no backup needed — content identical)';
+    console.log(`Migrating unsentineled plugin content to sentinel-wrapped form (backup: ${backupPath})`);
+  }
+
+  writeFileSync(targetPath, newContent, 'utf8');
 }
 
 export function installCiTemplates(projectDir, packageDir) {

package/src/uninstall.mjs

@@ -1,4 +1,7 @@
-import { existsSync, rmSync, unlinkSync, readdirSync } from 'node:fs';
+import {
+  existsSync, rmSync, unlinkSync, readdirSync,
+  readFileSync, writeFileSync,
+} from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -7,8 +10,15 @@ import {
   MARKETPLACE_NAME, PLUGIN_REF,
   readJson, writeJson,
 } from './utils.mjs';
-import { removeEnvVars, removeStatusLine } from './settings.mjs';
 import { removeMcpServers } from './mcp-setup.mjs';
+import { backupIfChanging, pruneBackups } from './backup.mjs';
+import {
+  readManagedSettings, getLedgerPath,
+  HISTORICAL_ENV_KEYS, HISTORICAL_ENV_VALUES,
+} from './managed-settings.mjs';
+
+const SENTINEL_BEGIN = '<!-- BEGIN daemux-store-automator -->';
+const SENTINEL_END = '<!-- END daemux-store-automator -->';
 
 function runClaudeUninstall(scope) {
   const scopeArg = scope === 'user' ? '' : ` --scope ${scope}`;
@@ -81,32 +91,156 @@ function removeGitHubWorkflow(projectDir) {
   }
 }
 
+function spliceSentinelBlock(content) {
+  const beginIdx = content.indexOf(SENTINEL_BEGIN);
+  const endIdx = content.indexOf(SENTINEL_END);
+  if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx) return null;
+
+  const before = content.slice(0, beginIdx);
+  let after = content.slice(endIdx + SENTINEL_END.length);
+  if (after.startsWith('\n')) after = after.slice(1);
+  return before.replace(/[ \t]+$/, '') + after;
+}
+
+function cleanClaudeMd(baseDir, scopeLabel) {
+  const claudeMdPath = join(baseDir, 'CLAUDE.md');
+  if (!existsSync(claudeMdPath)) return;
+
+  const content = readFileSync(claudeMdPath, 'utf8');
+  const spliced = spliceSentinelBlock(content);
+
+  if (spliced === null) {
+    console.log(
+      `Warning: ${scopeLabel} CLAUDE.md has no plugin sentinels; leaving untouched. ` +
+      `(If this file contains plugin content from an older version, remove the plugin section manually.)`
+    );
+    return;
+  }
+
+  backupIfChanging(claudeMdPath, spliced);
+  if (spliced.trim() === '') {
+    rmSync(claudeMdPath);
+    console.log(`Removed ${scopeLabel} CLAUDE.md (contained only plugin content)`);
+  } else {
+    writeFileSync(claudeMdPath, spliced, 'utf8');
+    console.log(`Removed plugin section from ${scopeLabel} CLAUDE.md`);
+  }
+}
+
+function looksLikeHistoricalPluginStatusLine(current) {
+  return Boolean(
+    current
+    && typeof current === 'object'
+    && current.type === 'command'
+    && typeof current.command === 'string'
+    && current.command.includes('context_window')
+  );
+}
+
+function pruneManagedEnv(settings, envKeys, envValues) {
+  if (!settings.env) return false;
+  let modified = false;
+  for (const key of envKeys) {
+    if (!(key in settings.env)) continue;
+    const expected = envValues ? envValues[key] : undefined;
+    if (expected === undefined || settings.env[key] === expected) {
+      delete settings.env[key];
+      modified = true;
+    } else {
+      console.log(`Preserving user-modified env.${key} in settings.json`);
+    }
+  }
+  if (Object.keys(settings.env).length === 0) delete settings.env;
+  return modified;
+}
+
+function pruneManagedStatusLine(settings, ledgerStatusLine) {
+  if (!settings.statusLine) return false;
+
+  if (ledgerStatusLine) {
+    if (ledgerStatusLine.wasSet !== true) return false;
+    const managed = ledgerStatusLine.content;
+    if (JSON.stringify(settings.statusLine) !== JSON.stringify(managed)) {
+      console.log('Preserving user-modified statusLine in settings.json');
+      return false;
+    }
+    delete settings.statusLine;
+    return true;
+  }
+
+  if (!looksLikeHistoricalPluginStatusLine(settings.statusLine)) {
+    console.log('Preserving non-plugin statusLine in settings.json (no ledger, signature mismatch)');
+    return false;
+  }
+  delete settings.statusLine;
+  return true;
+}
+
+function cleanSettings(baseDir, scopeLabel, ledger) {
+  const settingsPath = join(baseDir, 'settings.json');
+  if (!existsSync(settingsPath)) return;
+
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return;
+  }
+
+  const envKeys = ledger?.envKeys ?? HISTORICAL_ENV_KEYS;
+  const envValues = ledger?.envValues ?? HISTORICAL_ENV_VALUES;
+  const envChanged = pruneManagedEnv(settings, envKeys, envValues);
+  const statusLineChanged = pruneManagedStatusLine(settings, ledger?.statusLine);
+
+  if (!envChanged && !statusLineChanged) return;
+
+  const newRaw = JSON.stringify(settings, null, 2) + '\n';
+  backupIfChanging(settingsPath, newRaw);
+  writeFileSync(settingsPath, newRaw, 'utf8');
+  console.log(`Cleaned ${scopeLabel} settings`);
+}
+
+function removeLedger(baseDir) {
+  const ledgerPath = getLedgerPath(baseDir);
+  if (existsSync(ledgerPath)) {
+    try { rmSync(ledgerPath); } catch { /* best-effort */ }
+  }
+}
+
 export async function runUninstall(scope) {
   console.log(`Uninstalling Daemux Store Automator (scope: ${scope})...`);
 
   runClaudeUninstall(scope);
 
-  if (scope === 'user') {
-    console.log('Removing marketplace...');
-    rmSync(MARKETPLACE_DIR, { recursive: true, force: true });
-    rmSync(CACHE_DIR, { recursive: true, force: true });
-    unregisterMarketplace();
-  }
-
   const isGlobal = scope === 'user';
   const baseDir = isGlobal ? join(homedir(), '.claude') : join(process.cwd(), '.claude');
   const scopeLabel = isGlobal ? 'global' : 'project';
 
-  removeFileIfExists(join(baseDir, 'CLAUDE.md'), `${scopeLabel} CLAUDE.md`);
-  removeCiTemplates(process.cwd());
-  removeMcpServers(process.cwd());
+  const ledger = readManagedSettings(baseDir);
+
+  cleanClaudeMd(baseDir, scopeLabel);
+
+  if (!isGlobal) {
+    removeCiTemplates(process.cwd());
+    removeMcpServers(process.cwd());
+  }
 
   console.log(`Cleaning ${scopeLabel} settings...`);
-  removeEnvVars(join(baseDir, 'settings.json'));
-  removeStatusLine(join(baseDir, 'settings.json'));
+  cleanSettings(baseDir, scopeLabel, ledger);
 
-  console.log(isGlobal
-    ? '\nDone! store-automator uninstalled globally.'
-    : `\nDone! store-automator uninstalled from this project.\n\nNote: Marketplace files remain in ${MARKETPLACE_DIR}\nRun with --global --uninstall to remove marketplace completely.`
-  );
+  removeLedger(baseDir);
+  pruneBackups();
+
+  let doneMessage;
+  if (isGlobal) {
+    console.log('Removing marketplace...');
+    rmSync(MARKETPLACE_DIR, { recursive: true, force: true });
+    rmSync(CACHE_DIR, { recursive: true, force: true });
+    unregisterMarketplace();
+    doneMessage = '\nDone! store-automator uninstalled globally.';
+  } else {
+    doneMessage = '\nDone! store-automator uninstalled from this project.\n\nNote: Marketplace files remain under ~/.claude/plugins/marketplaces.\nRun with --global --uninstall to remove marketplace completely.';
+  }
+
+  console.log(doneMessage);
 }