showdar-skills 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -6,6 +6,31 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.13.0]
+
+### Added
+
+- `showdar add profile <profile>`: additive union of built-in profile primitives without replacing an existing base profile or other installed skills.
+- `showdar add workflow <name>`: install built-in workflow skills and any missing stage primitives; `showdar add feature` / `showdar add showdar-feature` remain equivalent aliases.
+- `showdar add workflow ./local.json`: convenient spelling for existing project-scoped custom workflow installation.
+
+### Changed
+
+- Additive installation preserves existing extension metadata and supports projects initialized with `--ai all`.
+- `showdar init --profile ...` retains its explicit replace semantics; existing standalone `showdar add-workflow` remains supported.
+- Added installer regression coverage for existing-skill preservation, aliases, workflow stage closure, custom workflows, foreign-path safety and re-init replacement.
+
+
+## [0.12.1]
+
+### Fixed
+
+- Added read-only `showdar guard --mutation local-write --json` to block task writes on integration branches until task branch preparation, with an explicit repository-local direct-work opt-in.
+- Updated native harness guidance and mutating skills to require automatic branch preparation and a passing guard before agent-controlled file writes; Cursor routing rules now apply automatically.
+- Re-adding an existing Showdar-managed skill refreshes its packaged SKILL.md from the upgraded CLI only when its recorded hash matches; user-modified skill files are preserved and cause an explicit error.
+- This is an agent/tool-instruction gate, not a cross-harness filesystem interceptor, and does not grant source/remote mutation authority.
+
+
 ## [0.12.0]
 
 ### Added

package/README.md

@@ -40,6 +40,32 @@ Claude Code as supported installation targets. Choose `backend`, `qa`, or
 `product` when that gives discovery a more precise context; use `full` when
 you want all capabilities available.
 
+## Additive installation
+
+`showdar init --profile <name>` **replaces** the Showdar-owned skill selection.
+`showdar add` always **preserves** existing skills and the selected base profile:
+
+```bash
+showdar init --profile developer --ai opencode
+showdar add git                         # same as showdar add showdar-git
+showdar add profile insurance           # union, no deletions
+showdar add workflow feature            # workflow + missing primitive stages
+showdar add workflow ./acme-release.json # standalone custom workflow, project scope
+```
+
+Both `showdar add feature` and `showdar add showdar-feature` are aliases for
+`showdar add workflow feature`, including automatic installation of missing
+primitive stage skills. All built-in profiles are additive via `add profile`;
+`init` remains the explicit replace operation. Existing workflow packs and
+custom workflow definitions are preserved when adding skills. The runtime
+router is included in the Showdar CLI and is automatically referenced by
+updated native guidance; it does not require an additional skill.
+
+Built-in workflow dependency installation does **not** execute the workflow,
+authorize source mutation, commit, merge or push. A custom workflow JSON file
+uses the existing `add-workflow` validation/manifest semantics; remote files
+and arbitrary executable plugins are unsupported.
+
 ## Runtime routing and task branches
 
 ```bash
@@ -47,6 +73,7 @@ printf '%s\n' 'Implement the approved underwriting form and add tests' | showdar
 showdar route --prompt "Explain insurance terminology"
 showdar git-start --dry-run --type feature --name "IDP-123 Add pricing form"
 showdar git-start --type feature --name "IDP-123 Add pricing form"
+showdar guard --mutation local-write --json
 ```
 
 Prefer `--stdin` for arbitrary or multiline prompts. Supply stdin as literal data;
@@ -91,6 +118,18 @@ The four workflows remain native discoverable/installable skills; `route` does n
 introduce workflow selection. Profiles remain primitive-only: `full` contains all
 18 primitives, and the insurance profile remains unchanged.
 
+Before the first local-write task source edit, the coding agent must run
+`showdar guard --mutation local-write --json` and require `ok=true` and
+`data.allowed=true`. When on develop/main/integration, it must execute
+`showdar git-start` (not only suggest it), confirm the branch, and rerun guard.
+This is an instruction-level agent preflight, **not an OS/filesystem hook**:
+tools that ignore Showdar can still write files. Cursor's generated rule now
+uses `alwaysApply: true` so the Git preflight isn't limited to manually
+activated skill calls. Existing project guidance must be refreshed after the
+package update (for example by running `showdar add git` with the new CLI).
+Re-adding an installed skill refreshes its managed SKILL.md and guidance only
+if the owned copy has not been locally modified; drift refuses to overwrite.
+
 Before the first local-write task source edit on develop/development/dev/main/master
 or the repository default/integration branch, prepare a task branch. Priority is
 repository instructions/documented convention, explicit current user instruction,
@@ -832,6 +871,8 @@ Product behavior notes:
 ```bash
 showdar init [--scope <project|global>] --ai <target> --profile <profile>
 showdar add <skill> [--ai <target>] [--scope <project|global>]
+showdar add profile <profile> [--ai <target>] [--scope <project|global>]
+showdar add workflow <builtin-name|local-json-path> [--ai <target>] [--scope <project|global>]
 showdar add-pack <local-path>
 showdar remove-pack <name>
 showdar add-workflow <local-path>

package/bin/showdar.js

@@ -2,12 +2,13 @@
 import path from 'node:path';
 import { parseArgs } from 'node:util';
 import { startTaskBranch, formatGitStart } from '../src/git-start.js';
+import { guardMutation, formatMutationGuard } from '../src/git-guard.js';
 import { routeRequest, formatRoute } from '../src/runtime-route.js';
 import { homedir } from 'node:os';
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
-import { AI_TARGETS, PRIMITIVE_COUNT, PROFILE_ALIASES, PROFILES, SKILLS, TOTAL_COUNT, WORKFLOW_COUNT, canonicalProfile, isDeprecatedProfile, resolveProfile } from '../src/catalog.js';
-import { addPack, addSkill, addWorkflow, globalManifestPath, initGlobal, initProject, inspectGlobal, inspectProject, listExtensions, listExtensionsDetailed, removeGlobal, removePack, removeProject, validatePackSource, createPack, inspectPack, doctor, updatePack, readProjectOverrides } from '../src/project.js';
+import { AI_TARGETS, PRIMITIVE_COUNT, PROFILE_ALIASES, PROFILES, SKILLS, TOTAL_COUNT, WORKFLOW_COUNT, canonicalProfile, isDeprecatedProfile, resolveProfile, getWorkflow, normalizeSkillName } from '../src/catalog.js';
+import { addPack, addSkill, addSkills, addWorkflow, globalManifestPath, initGlobal, initProject, inspectGlobal, inspectProject, listExtensions, listExtensionsDetailed, removeGlobal, removePack, removeProject, validatePackSource, createPack, inspectPack, doctor, updatePack, readProjectOverrides } from '../src/project.js';
 import { formatPlanPreviewHuman, projectPackUpdatePreview } from '../src/pack-plan.js';
 import { assessCheckpointAgainstCandidate } from '../src/pack-inspect.js';
 import { validateRepository } from '../src/validate.js';
@@ -44,6 +45,10 @@ function printHelp(version, command = null) {
     console.log('Usage: showdar git-start --type <type> --name <task> [--base <branch>] [--dry-run] [--json]');
     return;
   }
+  if (command === 'guard') {
+    console.log('Usage: showdar guard --mutation <read-only|local-write> [--json]');
+    return;
+  }
   if (command === 'init') {
     console.log(`Showdar Skills ${version}\n\nUsage:\n  showdar init ${scopeUsage} [--profile <name>] [--ai <universal|codex|opencode|cursor|claude|all>]\n\nDefaults: scope project, profile full, AI target universal.\nProject scope writes native skills, one native instruction surface, and project .showdar.json. Global scope writes verified user skill directories and ~/.showdar/global.json without instruction files. Codex and universal use .agents/skills in project scope and ~/.agents/skills in global scope; cursor uses .cursor/skills in project scope and ~/.cursor/skills in global scope; --ai all writes each shared destination once, generates OpenCode and Claude commands, and writes only the AGENTS.md block.\n\nProfiles: ${Object.keys(PROFILES).join(', ')}\nDeprecated aliases: ${Object.entries(PROFILE_ALIASES).map(([alias, target]) => `${alias} -> ${target}`).join(', ')}\nAI targets: ${AI_TARGETS.join(', ')}`);
     return;
@@ -53,10 +58,10 @@ function printHelp(version, command = null) {
     return;
   }
   if (command === 'add') {
-    console.log(`Showdar Skills ${version}\n\nUsage:\n  showdar add <skill> [--ai <universal|codex|opencode|cursor|claude>] [--scope <project|global>]\n\nExamples:\n  showdar add debug\n  showdar add showdar-security\n  showdar add test --ai cursor\n  showdar add review --scope global --ai claude\n\nDefault scope: project. Default AI target: universal, or the configured .showdar.json value when present.`);
+    console.log(`Showdar Skills ${version}\n\nUsage:\n  showdar add <skill> [--ai <target>] [--scope <project|global>]\n  showdar add profile <profile> [--ai <target>] [--scope <project|global>]\n  showdar add workflow <builtin-name|local-json-path> [--ai <target>] [--scope <project|global>]\n\nExamples:\n  showdar add git\n  showdar add showdar-git\n  showdar add profile insurance\n  showdar add workflow feature\n  showdar add workflow ./workflows/acme-release.json\n\nAdd preserves installed skills; init replaces the managed set. Built-in workflows add required stages.`);
     return;
   }
-  console.log(`Showdar Skills ${version}\n\nUsage:\n  showdar init ${scopeUsage} [--profile <name>] [--ai <universal|codex|opencode|cursor|claude|all>] [--pack <local-path>]\n  showdar add <skill> [--ai <universal|codex|opencode|cursor|claude>] [--scope <project|global>]\n  showdar route (--stdin | --prompt <text>) [--json]\n  showdar git-start --type <type> --name <task> [--base <branch>] [--dry-run] [--json]\n  showdar add-pack <local-path>\n  showdar remove-pack <name>\n  showdar add-workflow <local-path>\n  showdar status ${scopeUsage}\n  showdar doctor ${scopeUsage}\n  showdar validate\n  showdar list [--extensions]\n  showdar remove ${scopeUsage}\n  showdar create-pack <path> [--vendor <vendor>] [--description <text>] [--with-workflow <id>] [--with-profile <name>]\n  showdar validate-pack <local-path> [--json]\n  showdar inspect-pack <local-path> [--json] [--checkpoint <file>]\n  showdar doctor ${scopeUsage} [--extensions] [--json]\n  showdar update-pack <local-path> [--dry-run] [--json]\n  showdar validate\n  showdar list [--extensions] [--json]\n  showdar remove ${scopeUsage}\n\nExtension packs accept local directories/workspace paths only; tarball, URL, Git, and registry sources are rejected.\n\nDefaults: scope project, profile full, AI target universal.\nProfiles: ${Object.keys(PROFILES).join(', ')}\nDeprecated aliases: ${Object.entries(PROFILE_ALIASES).map(([alias, target]) => `${alias} -> ${target}`).join(', ')}\nAI targets: ${AI_TARGETS.join(', ')}`);
+  console.log(`Showdar Skills ${version}\n\nUsage:\n  showdar init ${scopeUsage} [--profile <name>] [--ai <universal|codex|opencode|cursor|claude|all>] [--pack <local-path>]\n  showdar add <skill> [--ai <target>] [--scope <project|global>]\n  showdar add profile <profile> [--ai <target>] [--scope <project|global>]\n  showdar add workflow <builtin-name|local-json-path> [--ai <target>] [--scope <project|global>]\n  showdar route (--stdin | --prompt <text>) [--json]\n  showdar git-start --type <type> --name <task> [--base <branch>] [--dry-run] [--json]\n  showdar guard --mutation <read-only|local-write> [--json]\n  showdar add-pack <local-path>\n  showdar remove-pack <name>\n  showdar add-workflow <local-path>\n  showdar status ${scopeUsage}\n  showdar doctor ${scopeUsage}\n  showdar validate\n  showdar list [--extensions]\n  showdar remove ${scopeUsage}\n  showdar create-pack <path> [--vendor <vendor>] [--description <text>] [--with-workflow <id>] [--with-profile <name>]\n  showdar validate-pack <local-path> [--json]\n  showdar inspect-pack <local-path> [--json] [--checkpoint <file>]\n  showdar doctor ${scopeUsage} [--extensions] [--json]\n  showdar update-pack <local-path> [--dry-run] [--json]\n  showdar validate\n  showdar list [--extensions] [--json]\n  showdar remove ${scopeUsage}\n\nExtension packs accept local directories/workspace paths only; tarball, URL, Git, and registry sources are rejected.\n\nDefaults: scope project, profile full, AI target universal.\nProfiles: ${Object.keys(PROFILES).join(', ')}\nDeprecated aliases: ${Object.entries(PROFILE_ALIASES).map(([alias, target]) => `${alias} -> ${target}`).join(', ')}\nAI targets: ${AI_TARGETS.join(', ')}`);
 }
 
 async function main() {
@@ -70,10 +75,22 @@ async function main() {
     console.log(version);
     return;
   }
-  if (!['route', 'git-start'].includes(command) && (args.includes('--help') || args.includes('-h'))) return printHelp(version, command);
+  if (!['route', 'git-start', 'guard'].includes(command) && (args.includes('--help') || args.includes('-h'))) return printHelp(version, command);
 
   const scope = ['init', 'status', 'doctor', 'remove', 'add'].includes(command) ? scopeAfter(args) : null;
 
+  if (command === 'guard') {
+    const { values } = parseArgs({ args: args.slice(1), options: { mutation: { type: 'string' }, json: { type: 'boolean' }, help: { type: 'boolean', short: 'h' } } });
+    if (values.help) return printHelp(version, command);
+    const data = guardMutation({ cwd: projectRoot, mutation: values.mutation });
+    const errors = data.allowed ? [] : [{ code: data.code, message: 'Task-owned source mutation is blocked until Git preflight passes.' }];
+    console.log(values.json
+      ? JSON.stringify({ schemaVersion: 1, command, ok: data.allowed, data, warnings: [], errors }, null, 2)
+      : formatMutationGuard(data));
+    if (!data.allowed) process.exitCode = 1;
+    return;
+  }
+
   if (command === 'git-start') {
     const { values } = parseArgs({ args: args.slice(1), options: { type: { type: 'string' }, name: { type: 'string' }, base: { type: 'string' }, 'dry-run': { type: 'boolean' }, json: { type: 'boolean' }, help: { type: 'boolean', short: 'h' } } });
     if (values.help) return printHelp(version, command);
@@ -225,20 +242,49 @@ async function main() {
   }
 
   if (command === 'add') {
-    const positional = args.filter((a, i) => i > 0 && !a.startsWith('--') && args[i - 1] !== '--ai' && args[i - 1] !== '--scope');
-    const skillArg = positional[0];
-    if (!skillArg) throw new Error('Skill name is required. Usage: showdar add <skill> [--ai <target>] [--scope <project|global>]');
+    const positional = args.filter((arg, index) => index > 0 && !arg.startsWith('--') && args[index - 1] !== '--ai' && args[index - 1] !== '--scope');
+    const kind = positional[0];
+    if (!kind) throw new Error('Usage: showdar add <skill> | profile <profile> | workflow <builtin-name|local-json-path>');
     const hasAiFlag = args.includes('--ai');
     const hasScopeFlag = args.includes('--scope');
-    const result = await addSkill({
+    const options = {
       cwd: projectRoot,
-      skill: skillArg,
       ai: hasAiFlag ? valueAfter(args, '--ai', 'universal') : null,
       scope: hasScopeFlag ? scope : null,
       home: homedir(),
       packageRoot,
       packageVersion: version,
-    });
+    };
+    if (kind === 'profile') {
+      if (positional.length !== 2) throw new Error('Usage: showdar add profile <profile> [--ai <target>] [--scope <project|global>]');
+      const profileName = positional[1];
+      const selected = resolveProfile(profileName);
+      const result = await addSkills({ ...options, skills: selected });
+      if (isDeprecatedProfile(profileName)) console.warn(`Warning: profile "${profileName}" is deprecated; use "${canonicalProfile(profileName)}".`);
+      console.log(`Showdar profile added.\nAdded profile: ${canonicalProfile(profileName)}\nNew skills: ${result.added}\nAlready installed: ${result.alreadyInstalled}\nTotal requested: ${result.skills.length}\nExisting profile preserved: ${result.profile ?? '(none)'}\nScope: ${result.scope}\nAI: ${result.ai}`);
+      return;
+    }
+    const installBuiltinWorkflow = async workflow => {
+      const result = await addSkills({ ...options, skills: [workflow.id, ...workflow.stages] });
+      console.log(`Showdar workflow added.\nWorkflow: ${workflow.id}\nNew skills: ${result.added}\nAlready installed: ${result.alreadyInstalled}\nRequired stage skills: ${workflow.stages.join(', ')}\nScope: ${result.scope}\nAI: ${result.ai}`);
+    };
+    if (kind === 'workflow') {
+      if (positional.length !== 2) throw new Error('Usage: showdar add workflow <builtin-name|local-json-path>');
+      const name = positional[1];
+      const builtin = getWorkflow(name.startsWith('showdar-') ? name : `showdar-${name}`);
+      if (builtin) return installBuiltinWorkflow(builtin);
+      if (!name.endsWith('.json')) throw new Error(`Unknown built-in workflow "${name}". For custom workflows provide a local JSON file.`);
+      if (hasAiFlag || (hasScopeFlag && scope !== 'project')) {
+        throw new Error('Custom workflow files support project scope only and do not accept --ai.');
+      }
+      const result = await addWorkflow({ cwd: projectRoot, source: name });
+      console.log(`Showdar custom workflow added.\nWorkflow: ${result.workflow}\nPath: ${result.path}`);
+      return;
+    }
+    if (positional.length !== 1) throw new Error('Usage: showdar add <skill> [--ai <target>] [--scope <project|global>]');
+    const workflow = getWorkflow(normalizeSkillName(kind));
+    if (workflow) return installBuiltinWorkflow(workflow);
+    const result = await addSkill({ ...options, skill: kind });
     console.log(`Showdar skill ${result.added ? 'added' : 'already installed'}.\nSkill: ${result.skill}\nScope: ${result.scope}\nAI: ${result.ai}\nPath: ${result.destination}`);
     return;
   }
@@ -377,7 +423,7 @@ async function main() {
 
 main().catch((error) => {
   const command = process.argv[2];
-  if (['route', 'git-start'].includes(command) && process.argv.slice(3).includes('--json')) {
+  if (['route', 'git-start', 'guard'].includes(command) && process.argv.slice(3).includes('--json')) {
     console.log(JSON.stringify({ schemaVersion: 1, command, ok: false, data: null, warnings: [], errors: [{ code: 'INVALID_REQUEST', message: error.message }] }, null, 2));
   } else console.error(`showdar: ${error.message}`);
   process.exitCode = 1;

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "showdar-skills",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Production-grade software engineering lifecycle skills for coding agents.",
   "type": "module",
-  "bin": { "showdar": "./bin/showdar.js" },
+  "bin": {
+    "showdar": "./bin/showdar.js"
+  },
   "scripts": {
     "test": "node --test",
     "validate": "node bin/showdar.js validate",
@@ -16,9 +18,38 @@
     "smoke": "node scripts/package-smoke.mjs",
     "release:check": "node scripts/check-release-version.mjs"
   },
-  "engines": { "node": ">=20" },
-  "files": ["bin", "src", "config", "skills", "commands", "router", "bundles", "profiles", "engine", "README.md", "LICENSE", "CHANGELOG.md", "MIGRATION.md"],
-  "keywords": ["agent-skills", "coding-agents", "codex", "opencode", "claude-code", "software-engineering", "developer-tools", "requirements", "qa", "security", "devops", "workflow"],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "src",
+    "config",
+    "skills",
+    "commands",
+    "router",
+    "bundles",
+    "profiles",
+    "engine",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "MIGRATION.md"
+  ],
+  "keywords": [
+    "agent-skills",
+    "coding-agents",
+    "codex",
+    "opencode",
+    "claude-code",
+    "software-engineering",
+    "developer-tools",
+    "requirements",
+    "qa",
+    "security",
+    "devops",
+    "workflow"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",

package/skills/showdar-bugfix/SKILL.md

@@ -5,6 +5,11 @@ description: Use when resolving an observed defect end-to-end, adaptively sequen
 
 # Showdar Bugfix
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Resolve an observed defect safely from evidence to verified fix.

package/skills/showdar-build/SKILL.md

@@ -5,6 +5,11 @@ description: Use when implementing or refactoring an agreed application change w
 
 # Showdar Build
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Convert an approved requirement/plan into maintainable production code.

package/skills/showdar-debug/SKILL.md

@@ -5,6 +5,11 @@ description: Use when observed behavior fails through crashes, regressions, buil
 
 # Showdar Debug
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Find and confirm root cause before modifying production behavior.

package/skills/showdar-design/SKILL.md

@@ -5,6 +5,11 @@ description: Use when product UI needs design direction, UX decisions, responsiv
 
 # Showdar Design
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Produce product-specific UI direction instead of generic component-library output.

package/skills/showdar-feature/SKILL.md

@@ -5,6 +5,11 @@ description: Use when implementing a complete feature end-to-end, adaptively seq
 
 # Showdar Feature
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Implement a complete feature end-to-end by sequencing primitive skills.

package/skills/showdar-git/SKILL.md

@@ -48,6 +48,12 @@ This skill owns repository state transitions, not source-code review or GitHub a
 
 ## Task branch isolation
 
+**Mandatory pre-write gate:** Installing `showdar-git` adds project-wide branch guidance. For every task-owned source/config/test/docs change, including tasks executed by another primitive, inspect current Git state, then run `showdar guard --mutation local-write --json` before file-writing tools. Require `ok=true` and `data.allowed=true`; if blocked, STOP without editing.
+
+On integration/default branches proactively run `showdar git-start --type <type> --name "<task>"` after repository/user convention inspection, then rerun guard. On an existing task branch, run guard without creating a nested branch. If the CLI is unavailable, use equivalent manual safe Git branch preparation and verify branch before editing. Explicit direct-work policy is a reviewed repo-local opt-in (`showdar.gitDirectWork=true`); never silently set it to bypass the gate.
+
+This gate is enforced by agent/tool instructions, not a filesystem interceptor; arbitrary writes outside Showdar remain possible. Neither guard nor git-start authorizes edits, commits, merges, or pushes.
+
 Before the first task-owned source edit for a local-write engineering task, inspect Git state (`git status --short`, current branch, branch history and repository policy). Direct develop/main edits are not the default: on develop, development, dev, main, master or the default/integration branch, prepare a dedicated task branch before source mutation.
 
 Priority: repository instructions/documented branching convention; explicit current user instruction; clearly detected existing convention; Showdar safe default. Explicit trunk-based/direct-work policy wins: do not impose GitFlow. Branch preparation does not authorize source mutation.

package/skills/showdar-incident/SKILL.md

@@ -5,6 +5,11 @@ description: Use when investigating and recovering from an active operational in
 
 # Showdar Incident
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Handle an active operational failure or service-impacting incident.

package/skills/showdar-ops/SKILL.md

@@ -5,6 +5,11 @@ description: Use when inspecting or changing CI/CD, containers, environments, de
 
 # Showdar Ops
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Analyze and perform tightly scoped operational engineering across CI/CD, containers, environments, runtime configuration, deployment, observability, rollback, and release operations.

package/skills/showdar-plan/SKILL.md

@@ -5,6 +5,11 @@ description: Use when agreed behavior needs a bounded implementation plan, chang
 
 # Showdar Plan
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Turn an idea, bug requirement, migration, or design decision into executable engineering work.

package/skills/showdar-recover/SKILL.md

@@ -5,6 +5,11 @@ description: Use when interrupted or partial engineering work must be reconstruc
 
 # Showdar Recover
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Recover context after session interruption, compaction, agent failure, crash, or handoff.

package/skills/showdar-release/SKILL.md

@@ -5,6 +5,11 @@ description: Use when preparing, validating, or executing a release lifecycle, a
 
 # Showdar Release
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Prepare and execute a software release through existing primitive boundaries.

package/skills/showdar-requirements/SKILL.md

@@ -5,6 +5,11 @@ description: Use when product or business input needs explicit behavior, rules,
 
 # Showdar Requirements
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Convert tickets, briefs, conversations, API notes, and observed repository behavior into implementation-ready requirements.

package/skills/showdar-test/SKILL.md

@@ -5,6 +5,11 @@ description: Use when choosing or implementing automated tests for behavior, reg
 
 # Showdar Test
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Match test level to the boundary/risk being proven.

package/skills/showdar-upgrade/SKILL.md

@@ -5,6 +5,11 @@ description: Use when upgrading dependencies, frameworks, runtimes, or native pl
 
 # Showdar Upgrade
 
+## Mandatory Git preflight for task-owned writes
+
+Before any task-owned source/config/test/docs write, apply `showdar-git` branch policy: on develop/main/integration, inspect repository conventions and EXECUTE `showdar git-start --type <type> --name "<task>"` to prepare the task branch before editing. Then run `showdar guard --mutation local-write --json` and require `ok=true` and `data.allowed=true` before ANY file-writing tool. If blocked, STOP before editing. On an existing task branch run guard without creating a new branch. Recheck when a read-only stage turns into a write. If CLI is missing, manually prepare and verify safe Git branch state; do not silently write on develop/main. Explicit documented direct-work policy wins; never infer stash, reset, commit, merge, or push.
+
+
 ## Purpose
 
 - Make upgrades controlled engineering changes rather than version-number edits.

package/src/adapter-renderers.js

@@ -3,7 +3,7 @@ import { ALL_SKILLS } from './catalog.js';
 const RUNTIME_GUIDANCE = `Automatic Showdar selection: route the current request through \`showdar route --stdin --json\` when the Showdar CLI is available. Supply the prompt as literal stdin data, never as interpolated shell syntax. Honor the canonical lifecycle primary; do not substitute another installed skill when it is missing. Report missing skills and suggest \`showdar add <name>\`; never auto-install. Include installed domain matches only as specialized context overlays; load returned advisors only when installed. Domain discovery does not grant authority or replace the lifecycle route.
 Explicit named-skill requests may load that installed skill directly without automatic routing. Workflow skills remain native discoverable choices; the router does not select workflows. If the CLI is unavailable, use native skill discovery/static descriptions below. Do not fetch a CLI through npx or install dependencies automatically.
 Routing does not authorize mutation. Inspect the returned mutation class and current task authority before work. For local-write tasks, before the first task-owned source edit inspect Git state. On develop, development, dev, main, master or the repository default/integration branch, DO NOT begin source edits yet: prepare one branch per coherent task first. Follow repository instructions/documented convention, explicit current user instruction, clearly detected convention, then the Showdar safe default. Explicit trunk/direct-work policy wins.
-Use \`showdar git-start --dry-run --type <type> --name <task>\`, then \`showdar git-start --type <type> --name <task>\`, or equivalent repository-specific preparation. Confirm the task branch before mutating skill execution. Reuse that branch across plan/build/test/review; do not nest branches per skill. Dirty ownership or branch collisions require inspection; never infer stash, reset, restore or clean. Git-start does not authorize source mutation, commit, merge or push. Completion defaults to verify and report on the task branch; merge and push require their own explicit authority.`;
+Before ANY task-owned source/config/test/docs write, execute Git preflight even if the router selected build directly. On integration/default branches inspect repository policy and EXECUTE \`showdar git-start --type <type> --name <task>\` (not just --dry-run), or equivalent repository-safe branch preparation. Then EXECUTE \`showdar guard --mutation local-write --json\` and require ok=true AND data.allowed=true BEFORE invoking any file-writing tool. If blocked, STOP before editing. On a matching task branch run guard without creating a new branch. Recheck before each later mutating stage. Do not infer permission from \`showdar route\`. If the CLI is unavailable, manually inspect Git and confirm the appropriate task branch or documented direct-work policy; never silently write on develop/main. Dirty ownership/branch collisions require inspection; never infer stash/reset/restore/clean. Guard and git-start do not authorize source edits, commit, merge or push. Completion means verify and report.`;
 
 const CANONICAL_ROUTE_ORDER = [
   ['map repository architecture, dependencies, or impact', 'showdar-understand'],
@@ -76,7 +76,7 @@ export function renderCursorRuleBody(skillIds) {
   const body = renderShowdarInstruction(skillIds).trimEnd();
   return `---
 description: Showdar skill and workflow routing guidance for software-engineering tasks
-alwaysApply: false
+alwaysApply: true
 ---
 
 ${body}

package/src/git-guard.js

@@ -0,0 +1,62 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+function git(cwd, args, optional = false) {
+  try {
+    return execFileSync('git', ['--no-optional-locks', ...args], {
+      cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10000,
+    }).trim();
+  } catch (error) {
+    if (optional && error.status === 1) return null;
+    throw new Error(`Git inspection failed (${args[0]}): ${error.stderr?.toString().trim() || error.message}`);
+  }
+}
+
+/**
+ * Read-only agent preflight. This reports whether a local-write task has
+ * branch isolation; it cannot intercept file writes made by other tools.
+ */
+export function guardMutation({ cwd, mutation }) {
+  if (!['read-only', 'local-write'].includes(mutation)) {
+    throw new Error('guard --mutation must be read-only or local-write.');
+  }
+  if (mutation === 'read-only') {
+    return { allowed: true, code: 'read-only', mutation, currentBranch: null, integrationBranch: null, directWork: false };
+  }
+
+  const root = git(cwd, ['rev-parse', '--show-toplevel']);
+  const currentBranch = git(root, ['symbolic-ref', '--quiet', '--short', 'HEAD'], true);
+  const config = key => git(root, ['config', '--local', '--get', key], true);
+  const directWork = config('showdar.gitDirectWork');
+  if (directWork !== null && !['true', 'false'].includes(directWork)) {
+    throw new Error('showdar.gitDirectWork must be true or false.');
+  }
+  const configuredBase = config('showdar.gitBase');
+  const defaultRef = git(root, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], true)?.replace(/^origin\//, '') ?? null;
+  const integrationNames = new Set(['develop', 'development', 'dev', 'main', 'master', configuredBase, defaultRef].filter(Boolean));
+  const context = {
+    mutation, currentBranch, integrationBranch: configuredBase ?? defaultRef,
+    directWork: directWork === 'true',
+  };
+
+  for (const marker of ['MERGE_HEAD', 'CHERRY_PICK_HEAD', 'REVERT_HEAD', 'rebase-merge', 'rebase-apply', 'BISECT_LOG', 'sequencer']) {
+    const location = git(root, ['rev-parse', '--git-path', marker]);
+    if (existsSync(path.resolve(root, location))) {
+      return { allowed: false, code: 'git-operation-active', ...context };
+    }
+  }
+  if (!currentBranch) return { allowed: false, code: 'detached-head', ...context };
+
+  const isIntegration = integrationNames.has(currentBranch);
+  const allowed = !isIntegration || directWork === 'true';
+  const code = !allowed ? 'task-branch-required'
+    : isIntegration ? 'direct-work-configured' : 'task-branch-ready';
+  return { allowed, code, ...context };
+}
+
+export function formatMutationGuard(data) {
+  return `${data.allowed ? 'ALLOWED' : 'BLOCKED'}: ${data.code}
+Mutation: ${data.mutation}
+Branch: ${data.currentBranch ?? '(detached or not inspected)'}${data.allowed ? '' : '\nPrepare a safe task branch with showdar git-start, then rerun guard. Do not write source while blocked.'}`;
+}

package/src/project.js

@@ -584,12 +584,38 @@ export async function addSkill({ cwd, skill, ai = null, scope = null, home = hom
 
   const effectiveAi = ai ?? existingManifest?.ai ?? 'universal';
   const effectiveScope = scope ?? existingManifest?.scope ?? 'project';
-  if (!NATIVE_TARGETS.includes(effectiveAi)) throw new Error(`Unknown AI target "${effectiveAi}".`);
+  if (effectiveAi !== 'all' && !NATIVE_TARGETS.includes(effectiveAi)) throw new Error(`Unknown AI target "${effectiveAi}".`);
   if (effectiveScope !== 'project' && effectiveScope !== 'global') throw new Error(`Unknown scope "${effectiveScope}".`);
 
   if (existingManifest?.skills?.includes(skillId)) {
     const refreshedFiles = [];
     const priorOwned = ownedPathSet(existingManifest);
+    const source = path.join(packageRoot, 'skills', skillId);
+    if (!(await exists(path.join(source, 'SKILL.md')))) throw new Error(`Packaged skill source missing: ${skillId}`);
+
+    // Refresh all still-managed native copies, not only generated instructions.
+    // Preflight every destination before changing any of them.
+    const roots = [...new Set((existingManifest.targets ?? [effectiveAi]).map(target =>
+      effectiveScope === 'global'
+        ? globalSkillRootFor(target, { homeRoot: home })
+        : skillRootFor(target, cwd)))];
+    const destinations = [];
+    for (const root of roots) {
+      const destination = path.join(root, skillId);
+      const relative = manifestPathFor(baseRoot, destination);
+      const recorded = (existingManifest.files ?? []).find(file => file.path === relative);
+      if (!recorded) continue; // A skill satisfied by global does not own a project copy.
+      await assertSafeManagedPath(baseRoot, destination);
+      if (!(await exists(destination))) throw new Error(`Managed skill missing; refusing partial refresh: ${relative}`);
+      if (await hashTree(destination) !== recorded.hash) {
+        throw new Error(`Modified Showdar-owned skill; refusing to overwrite user changes: ${relative}`);
+      }
+      destinations.push(destination);
+    }
+
+    for (const destination of destinations) {
+      await copyOwned({ baseRoot, source, destination, priorOwned, newFiles: refreshedFiles });
+    }
     for (const target of existingManifest.commandHarness ?? []) {
       const commandRoot = effectiveScope === 'global' ? globalCommandRootForTarget(target, { homeRoot: home }) : commandRootFor(target, cwd);
       if (commandRoot) await generateCommandFiles({ baseRoot, skillIds: existingManifest.skills, target, commandRoot, priorOwned, newFiles: refreshedFiles });
@@ -600,18 +626,14 @@ export async function addSkill({ cwd, skill, ai = null, scope = null, home = hom
       if (instruction.kind === 'block') await writeManagedBlock(file, existingManifest.skills);
       else if (instruction.kind === 'file') await writeCursorRule(file, existingManifest.skills);
     }
-    if (refreshedFiles.length) {
-      const files = new Map(existingManifest.files.map(f => [f.path, f]));
-      for (const f of refreshedFiles) files.set(f.path, f);
-      await writeJsonAtomic(effectiveScope === 'global' ? globalManifestPath(home) : path.join(cwd, PROJECT_MANIFEST), { ...existingManifest, files: [...files.values()] });
-    }
+    const files = new Map((existingManifest.files ?? []).map(f => [f.path, f]));
+    for (const f of refreshedFiles) files.set(f.path, f);
+    await writeJsonAtomic(effectiveScope === 'global' ? globalManifestPath(home) : path.join(cwd, PROJECT_MANIFEST),
+      { ...existingManifest, packageVersion, files: [...files.values()] });
     return { skill: skillId, root: '', destination: '', added: false, scope: effectiveScope, ai: effectiveAi, profile: existingManifest.profile };
   }
 
-  const root = effectiveScope === 'global'
-    ? globalSkillRootFor(effectiveAi, { homeRoot: home })
-    : skillRootFor(effectiveAi, cwd);
-  const destination = path.join(root, skillId);
+  const targets = resolveTargets(effectiveAi);
   const managedRoots = effectiveScope === 'global'
     ? [...new Set([
         ...NATIVE_TARGETS.map((t) => globalSkillRootFor(t, { homeRoot: home })),
@@ -619,30 +641,38 @@ export async function addSkill({ cwd, skill, ai = null, scope = null, home = hom
       ])]
     : [];
   const manifestPath = effectiveScope === 'global' ? globalManifestPath(home) : path.join(cwd, PROJECT_MANIFEST);
-
   const source = path.join(packageRoot, 'skills', skillId);
   if (!(await exists(path.join(source, 'SKILL.md')))) throw new Error(`Packaged skill source missing: ${skillId}`);
 
   await mkdir(baseRoot, { recursive: true });
   const priorOwned = ownedPathSet(existingManifest);
-  const relative = manifestPathFor(baseRoot, destination);
-  const existed = await exists(destination);
-  const alreadyTracked = priorOwned.has(relative);
-
   const files = [];
-  await copyOwned({ baseRoot, source, destination, priorOwned, newFiles: files, managedRoots });
+  const destinations = [...new Set(targets.map(target => effectiveScope === 'global'
+    ? globalSkillRootFor(target, { homeRoot: home })
+    : skillRootFor(target, cwd)))].map(root => path.join(root, skillId));
+  const alreadyInstalled = destinations.every(destination =>
+    priorOwned.has(manifestPathFor(baseRoot, destination)));
+
+  // Inspect every target before copying anything. Never overwrite foreign skills.
+  for (const destination of destinations) {
+    await assertSafeManagedPath(baseRoot, destination, managedRoots);
+    const relative = manifestPathFor(baseRoot, destination);
+    if ((await exists(destination)) && !priorOwned.has(relative)) {
+      throw new Error(`Refusing to overwrite existing non-Showdar-managed skill or command: ${destination}`);
+    }
+  }
+  for (const destination of destinations) {
+    await copyOwned({ baseRoot, source, destination, priorOwned, newFiles: files, managedRoots });
+  }
 
-  const targets = [effectiveAi];
   const commandHarnesses = [];
   for (const target of targets) {
     const adapter = ADAPTERS[target];
     if (adapter?.commands?.destination) {
-      if (effectiveScope === 'project') {
-        commandHarnesses.push({ target, root: commandRootFor(target, cwd) });
-      } else {
-        const globalRoot = globalCommandRootForTarget(target, { homeRoot: home });
-        if (globalRoot) commandHarnesses.push({ target, root: globalRoot });
-      }
+      const root = effectiveScope === 'project'
+        ? commandRootFor(target, cwd)
+        : globalCommandRootForTarget(target, { homeRoot: home });
+      if (root) commandHarnesses.push({ target, root });
     }
   }
 
@@ -659,10 +689,11 @@ export async function addSkill({ cwd, skill, ai = null, scope = null, home = hom
   const merged = new Map((existingManifest?.files ?? []).map((e) => [e.path, e]));
   for (const f of files) merged.set(f.path, f);
 
-  const instructionFile = existingManifest?.instructions ?? (effectiveScope === 'project' ? instructionSurfaceFor(effectiveAi, cwd) : null);
+  const instructionFile = existingManifest?.instructions ?? (effectiveScope === 'project' ? instructionSurfaceFor(effectiveAi === 'all' ? 'universal' : effectiveAi, cwd) : null);
   const commandHarness = [...new Set([...(existingManifest?.commandHarness ?? []), ...commandHarnesses.map((c) => c.target)])];
 
   const manifest = {
+    ...(existingManifest ?? {}),
     version: existingManifest?.version ?? 2,
     scope: effectiveScope,
     packageVersion,
@@ -688,7 +719,55 @@ export async function addSkill({ cwd, skill, ai = null, scope = null, home = hom
     }
   }
 
-  return { skill: skillId, root, destination, added: !alreadyTracked || !existed, scope: effectiveScope, ai: effectiveAi, profile: manifest.profile };
+  return { skill: skillId, root: path.dirname(destinations[0]), destination: destinations[0], added: !alreadyInstalled, scope: effectiveScope, ai: effectiveAi, profile: manifest.profile };
+}
+
+
+/**
+ * Additive profile/workflow member install. Existing project profile and any
+ * extra extension metadata are preserved. Requested members are deduplicated.
+ * Each member uses the standard single-skill installer and remains rerunnable.
+ */
+export async function addSkills({ cwd, skills, ai = null, scope = null, home = homedir(), packageRoot, packageVersion = '0.2.0' }) {
+  if (!Array.isArray(skills) || !skills.length) throw new Error('At least one skill is required.');
+  const skillIds = [...new Set(skills.map(normalizeSkillName))];
+  const baseRoot = scope === 'global' ? home : cwd;
+  const manifestPath = scope === 'global' ? globalManifestPath(home) : path.join(cwd, PROJECT_MANIFEST);
+  const existing = await readManifest(manifestPath, baseRoot);
+  const effectiveAi = ai ?? existing?.ai ?? 'universal';
+  const targets = resolveTargets(effectiveAi);
+  const owned = ownedPathSet(existing);
+  const managedRoots = scope === 'global'
+    ? [...new Set(NATIVE_TARGETS.map(target => globalSkillRootFor(target, { homeRoot: home })))]
+    : [];
+  // Preflight packaged inputs and all requested target paths before writing.
+  for (const skillId of skillIds) {
+    const source = path.join(packageRoot, 'skills', skillId, 'SKILL.md');
+    if (!(await exists(source))) throw new Error(`Packaged skill source missing: ${skillId}`);
+    for (const target of targets) {
+      const skillRoot = scope === 'global'
+        ? globalSkillRootFor(target, { homeRoot: home })
+        : skillRootFor(target, cwd);
+      const destination = path.join(skillRoot, skillId);
+      await assertSafeManagedPath(baseRoot, destination, managedRoots);
+      const relative = manifestPathFor(baseRoot, destination);
+      if ((await exists(destination)) && !owned.has(relative)) {
+        throw new Error(`Refusing to overwrite existing non-Showdar-managed skill or command: ${destination}`);
+      }
+    }
+  }
+  const installed = [];
+  for (const skill of skillIds) {
+    installed.push(await addSkill({ cwd, skill, ai, scope, home, packageRoot, packageVersion }));
+  }
+  return {
+    skills: skillIds,
+    added: installed.filter(entry => entry.added).length,
+    alreadyInstalled: installed.filter(entry => !entry.added).length,
+    profile: installed.at(-1)?.profile ?? existing?.profile ?? null,
+    ai: installed.at(-1)?.ai ?? effectiveAi,
+    scope: installed.at(-1)?.scope ?? scope ?? existing?.scope ?? 'project',
+  };
 }
 
 export async function removeProject(projectRoot) {

package/src/validate.js

@@ -455,8 +455,8 @@ export async function validateRepository(packageRoot) {
   if (!claudeBlock.includes('showdar-skills:start') || !claudeBlock.includes('showdar-skills:end')) {
     errors.push('CLAUDE managed block is missing markers');
   }
-  if (!cursorRule.includes('alwaysApply: false')) errors.push('Cursor rule must use Apply Intelligently metadata');
-  if (cursorRule.includes('alwaysApply: true')) errors.push('Cursor rule must not use alwaysApply:true');
+  if (!cursorRule.includes('alwaysApply: true')) errors.push('Cursor rule must always apply for Git pre-write safety guidance');
+  if (!cursorRule.includes('showdar guard --mutation local-write --json')) errors.push('Cursor rule must include Git pre-write guard');
 
   const commandDir = path.join(packageRoot, 'commands', 'opencode', 'showdar');
   if (await exists(commandDir)) {