@phuc1403/musketeer 0.2.4 → 0.3.0

package/INSTALLATION.md

@@ -14,8 +14,18 @@ an elevation prompt is refused — it falls back to printing the exact manual co
 | git | core, code-review | `winget install Git.Git` | `brew install git` | `apt/dnf/pacman install git` |
 | Python 3.8+ | core (skill-creator) | `winget install Python.Python.3.12` | `brew install python@3.12` | `apt install python3 python3-pip` |
 | Java 8+ | architecture (context-map) | `winget install Microsoft.OpenJDK` | `brew install --cask temurin` | `apt install openjdk-17-jdk` |
+| adr-tools | architecture (adr-writer) | download the [release zip](https://github.com/npryce/adr-tools/releases), copy `src/*` into `C:\Program Files\Git\usr\bin` (Git Bash) | `brew install adr-tools` | `apt install adr-tools` · Arch: AUR `adr-tools` · Fedora/RHEL: clone + add `src/` to `PATH` |
 | gh | code-review (PR mode) | `winget install GitHub.cli` | `brew install gh` | `apt install gh` |
 
+> `adr-tools` is a set of bash scripts. On Windows it runs inside Git Bash (already required by
+> core), so the skill works — but `musketeer muster` cannot detect it from `cmd.exe` and will print
+> a manual-install line every run. Expected; ignore it once `adr config` works in Git Bash.
+>
+> Running `musketeer muster` non-interactively (CI, onboarding scripts)? The `apt`/`brew` install
+> commands can prompt for `sudo` or hang waiting for input. Pre-install the prereqs yourself, or
+> set `MUSKETEER_SKIP_INSTALL=1` to print the manual command instead of executing it (red team
+> finding 8).
+
 ## Secrets (never auto-installed)
 
 - `ANTHROPIC_API_KEY` — needed only by skill-creator's improve/loop scripts. You will be

package/README.md

@@ -38,7 +38,7 @@ musketeers are in this project; promote = upgrade the binary._
 | **architecture** | off | adr-writer, architecture-characteristic-writer, context-map · CML validation hook |
 | **hallmark** | off | hallmark, hallmark-explore, hallmark-loop · auditor/explorer agents |
 | **code-review** | off | code-review skill + code-reviewer agent |
-| **dotnet** | off | tdd, knowledge-crunching · EF migration guard hook |
+| **dotnet** | off | tdd, knowledge-crunching · EF migration guard hook · always merges 4 quality-gate props into root `Directory.Build.props` (`MUSKETEER_SKIP_DOTNET_PROPS=1` to skip) · scaffolds a generic `src`/`tests` Clean Architecture skeleton when the project is blank |
 | **design-docs** | off | inject-design-docs SessionStart hook |
 
 The muster starts every musketeer **unselected**, except ones you already installed (pre-checked from

package/manifest.json

@@ -66,7 +66,7 @@
           "order": 1
         }
       ],
-      "prereqs": ["java", "cm-cli"]
+      "prereqs": ["java", "cm-cli", "adr-tools"]
     },
     "hallmark": {
       "label": "hallmark",
@@ -97,7 +97,7 @@
     },
     "dotnet": {
       "label": "dotnet",
-      "description": ".NET extras: tdd, knowledge-crunching + EF migration-guard & CONTEXT auto-load hooks.",
+      "description": ".NET extras: tdd, knowledge-crunching + EF migration-guard & CONTEXT auto-load hooks. Muster also always merges 4 quality-gate MSBuild properties into root Directory.Build.props (any dotnet-selected project, set MUSKETEER_SKIP_DOTNET_PROPS=1 to skip) and scaffolds a generic src/tests Clean Architecture skeleton when the project is genuinely blank.",
       "locked": false,
       "deps": [],
       "files": [
@@ -217,6 +217,17 @@
       "kind": "note",
       "needs": ["java"]
     },
+    "adr-tools": {
+      "detect": "adr config",
+      "kind": "package",
+      "needs": ["git"],
+      "install": {
+        "mac": "brew install adr-tools",
+        "linux": {
+          "apt": "sudo apt-get install -y adr-tools"
+        }
+      }
+    },
     "gh": {
       "detect": "gh --version",
       "kind": "package",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phuc1403/musketeer",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Distributable custom Claude Code harness — one declarative command scaffolds a curated company of musketeers (skills/agents/hooks) into any project's .claude/.",
   "type": "commonjs",
   "bin": {

package/src/dotnet-build-props.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { findDotnetProjectFiles } = require('./dotnet-fs-scan');
+
+const QUALITY_GATE_PROPS = {
+  TreatWarningsAsErrors: 'true',
+  EnforceCodeStyleInBuild: 'true',
+  AnalysisLevel: 'latest-recommended',
+  AnalysisModeSecurity: 'All',
+};
+
+const PROPERTY_GROUP_OPEN_RE = /<PropertyGroup(\s[^>]*)?>/g;
+
+function presenceRegex(tag) {
+  return new RegExp('<' + tag + '[\\s>]');
+}
+
+function buildMinimalFile(props) {
+  const lines = Object.entries(props)
+    .map(([k, v]) => `    <${k}>${v}</${k}>`)
+    .join('\n');
+  return `<Project>\n\n  <PropertyGroup>\n${lines}\n  </PropertyGroup>\n\n</Project>\n`;
+}
+
+/**
+ * Find the first `<PropertyGroup>` opening tag with no `Condition=` attribute.
+ * Accepted limitation (same spirit as the `<Choose>/<When>` non-support): a
+ * self-closed `<PropertyGroup />` is matched as "unconditioned" and props get
+ * spliced in right after it as dangling siblings, not inside an element MSBuild
+ * would evaluate. Vanishingly rare in real Directory.Build.props files.
+ * @returns {{exists:boolean, index?:number}} index is the offset right after the opening tag
+ */
+function findUnconditionedInsertionPoint(content) {
+  PROPERTY_GROUP_OPEN_RE.lastIndex = 0;
+  let match;
+  while ((match = PROPERTY_GROUP_OPEN_RE.exec(content)) !== null) {
+    const attrs = match[1] || '';
+    if (!/Condition\s*=/.test(attrs)) {
+      return { exists: true, index: match.index + match[0].length };
+    }
+  }
+  return { exists: false };
+}
+
+function atomicWrite(filePath, content) {
+  const tmp = filePath + '.tmp';
+  fs.writeFileSync(tmp, content, 'utf8');
+  fs.renameSync(tmp, filePath);
+}
+
+/**
+ * Additive-only merge of MSBuild properties into a Directory.Build.props-shaped
+ * file. Never removes or alters an existing tag (any value, any attributes) —
+ * only adds tags that are entirely absent. Writes via temp-file + rename so an
+ * interrupted write never leaves a truncated/corrupted file, and skips writing
+ * entirely when there is nothing to add.
+ * @param {string} filePath
+ * @param {Record<string,string>} props ordered {tagName: value} map
+ * @param {string} [projectDir] containment root; `filePath` must resolve inside it or
+ *   mergeProps throws instead of writing. Defaults to `path.dirname(filePath)` when
+ *   omitted so containment is always enforced against SOME root — never silently skipped.
+ * @returns {{created:boolean, added:string[]}}
+ */
+function mergeProps(filePath, props, projectDir) {
+  const resolved = path.resolve(filePath);
+  const root = path.resolve(projectDir || path.dirname(filePath));
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+    throw new Error(`mergeProps: "${filePath}" resolves outside project root "${projectDir || path.dirname(filePath)}"`);
+  }
+
+  let existing;
+  try {
+    existing = fs.readFileSync(resolved, 'utf8');
+  } catch {
+    existing = null;
+  }
+
+  if (existing === null) {
+    atomicWrite(resolved, buildMinimalFile(props));
+    return { created: true, added: Object.keys(props) };
+  }
+
+  const added = Object.keys(props).filter((tag) => !presenceRegex(tag).test(existing));
+  if (added.length === 0) return { created: false, added: [] };
+
+  const missingLines = added.map((tag) => `    <${tag}>${props[tag]}</${tag}>`).join('\n');
+  const insertion = findUnconditionedInsertionPoint(existing);
+
+  let updated;
+  if (insertion.exists) {
+    updated = existing.slice(0, insertion.index) + '\n' + missingLines + existing.slice(insertion.index);
+  } else {
+    const insertBefore = existing.lastIndexOf('</Project>');
+    if (insertBefore === -1) {
+      throw new Error(`mergeProps: "${resolved}" has no </Project> closing tag`);
+    }
+    const block = `  <PropertyGroup>\n${missingLines}\n  </PropertyGroup>\n`;
+    updated = existing.slice(0, insertBefore) + block + existing.slice(insertBefore);
+  }
+
+  atomicWrite(resolved, updated);
+  return { created: false, added };
+}
+
+/**
+ * Ancestor directories of `fileDir`, starting at `fileDir` itself, up to (but
+ * excluding) `root`.
+ */
+function ancestorsUpTo(fileDir, root) {
+  const dirs = [];
+  let cur = path.resolve(fileDir);
+  while (cur !== root && cur.startsWith(root + path.sep)) {
+    dirs.push(cur);
+    cur = path.dirname(cur);
+  }
+  return dirs;
+}
+
+/**
+ * Merge the 4 quality-gate properties into `projectDir`'s root
+ * Directory.Build.props, always (for any dotnet-selected project — confirmed
+ * scope, see plan.md §Red Team Review). Detects and logs (but does not block
+ * on) nested projects that already have a closer Directory.Build.props between
+ * them and root — MSBuild's "nearest file wins" means the root write would be
+ * silently invisible to those projects otherwise.
+ * @param {string} projectDir
+ * @param {(msg:string)=>void} log
+ * @returns {{created:boolean, added:string[], shadowed:string[]}}
+ */
+function ensureDirectoryBuildProps(projectDir, log) {
+  const root = path.resolve(projectDir);
+  const filePath = path.join(root, 'Directory.Build.props');
+
+  const shadowed = [];
+  for (const file of findDotnetProjectFiles(root)) {
+    const shadow = ancestorsUpTo(path.dirname(file), root).some((dir) =>
+      fs.existsSync(path.join(dir, 'Directory.Build.props'))
+    );
+    if (shadow) shadowed.push(file);
+  }
+  if (shadowed.length > 0) {
+    log(
+      `dotnet: warning — ${shadowed.length} project(s) shadowed by a nearer Directory.Build.props, ` +
+        `won't see root quality gates: ${shadowed.join(', ')}`
+    );
+  }
+
+  const result = mergeProps(filePath, QUALITY_GATE_PROPS, root);
+
+  if (result.created) {
+    log(`dotnet: created Directory.Build.props with ${result.added.length} quality-gate props`);
+  } else if (result.added.length > 0) {
+    log(`dotnet: added ${result.added.length} quality-gate prop(s) to Directory.Build.props (${result.added.join(', ')})`);
+  } else {
+    log('dotnet: Directory.Build.props already up to date (additive-once, not force-updated)');
+  }
+
+  return { ...result, shadowed };
+}
+
+module.exports = { mergeProps, ensureDirectoryBuildProps, QUALITY_GATE_PROPS };

package/src/dotnet-fs-scan.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const EXCLUDED_DIR_NAMES = new Set(['.git', 'node_modules', 'bin', 'obj', '.claude']);
+const DOTNET_PROJECT_EXTENSIONS = new Set(['.sln', '.csproj', '.fsproj', '.vbproj']);
+
+/**
+ * Recursively find every .NET project/solution file under rootDir.
+ * Symlink-safe (never follows a symlinked entry, so no cycle risk) and tolerant
+ * of unreadable directories — this is a best-effort scan, not a security
+ * boundary, so a permission error on one subtree just skips it silently rather
+ * than aborting the whole scan.
+ * @param {string} rootDir
+ * @returns {string[]} absolute paths, one per matched file
+ */
+function findDotnetProjectFiles(rootDir) {
+  const results = [];
+  walk(rootDir, results);
+  return results;
+}
+
+function walk(dir, results) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    try {
+      if (entry.isSymbolicLink()) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (EXCLUDED_DIR_NAMES.has(entry.name)) continue;
+        walk(full, results);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (DOTNET_PROJECT_EXTENSIONS.has(ext)) results.push(path.resolve(full));
+      }
+    } catch {
+      // Unreadable entry (permission error, race with external deletion, etc.) — skip it.
+    }
+  }
+}
+
+module.exports = { findDotnetProjectFiles, DOTNET_PROJECT_EXTENSIONS, EXCLUDED_DIR_NAMES };

package/src/dotnet-scaffold-copier.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function containedPath(root, candidate) {
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(candidate);
+  if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) return null;
+  return resolved;
+}
+
+function substitute(text, token, replacement) {
+  return text.split(token).join(replacement);
+}
+
+/**
+ * Recursively copy every file under srcDir into stagingDir, substituting
+ * `token` with `replacement` in both path segments and file contents. Every
+ * computed destination path is validated to stay under `stagingDir` — rejects
+ * (throws) rather than writing outside it.
+ * @param {string} srcDir
+ * @param {string} stagingDir
+ * @param {string} token
+ * @param {string} replacement
+ */
+function copyTemplateWithTokenSubstitution(srcDir, stagingDir, token, replacement) {
+  walk(srcDir, stagingDir, stagingDir, token, replacement);
+}
+
+function walk(currentSrc, currentDest, stagingRoot, token, replacement) {
+  const entries = fs.readdirSync(currentSrc, { withFileTypes: true });
+  for (const entry of entries) {
+    const substitutedName = substitute(entry.name, token, replacement);
+    const srcPath = path.join(currentSrc, entry.name);
+    const destPath = containedPath(stagingRoot, path.join(currentDest, substitutedName));
+    if (!destPath) {
+      throw new Error(`copyTemplateWithTokenSubstitution: computed path escapes staging dir: "${substitutedName}"`);
+    }
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      walk(srcPath, destPath, stagingRoot, token, replacement);
+    } else if (entry.isFile()) {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      const content = fs.readFileSync(srcPath, 'utf8');
+      fs.writeFileSync(destPath, substitute(content, token, replacement), 'utf8');
+    }
+  }
+}
+
+/**
+ * Move every top-level entry from stagingDir into projectDir. Pre-checks all
+ * names for collisions before moving any of them, then moves each via
+ * fs.renameSync (atomic per entry on the same filesystem). Throws instead of
+ * silently overwriting if a destination name already exists.
+ * @param {string} stagingDir
+ * @param {string} projectDir
+ */
+function promoteStagedScaffold(stagingDir, projectDir) {
+  const entries = fs.readdirSync(stagingDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (fs.existsSync(path.join(projectDir, entry.name))) {
+      throw new Error(`promoteStagedScaffold: "${entry.name}" already exists at destination`);
+    }
+  }
+  for (const entry of entries) {
+    fs.renameSync(path.join(stagingDir, entry.name), path.join(projectDir, entry.name));
+  }
+}
+
+module.exports = { copyTemplateWithTokenSubstitution, promoteStagedScaffold };

package/src/dotnet-scaffold.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { findDotnetProjectFiles } = require('./dotnet-fs-scan');
+const { copyTemplateWithTokenSubstitution, promoteStagedScaffold } = require('./dotnet-scaffold-copier');
+
+const OTHER_STACK_MANIFESTS = ['package.json', 'go.mod', 'pom.xml', 'pyproject.toml', 'requirements.txt', 'Cargo.toml'];
+
+// Day-1 bootstrap artifacts that don't count as "this repo is occupied" —
+// broadened post-validation-interview so a repo with only initial tooling/IDE
+// config isn't wrongly treated as occupied. Directory.Build.props is here for
+// the same reason `.claude` is: reconcile.js's wiring always runs
+// ensureDirectoryBuildProps() before scaffoldDotnetProject(), so this file
+// already exists by the time this guard runs on every single dotnet muster —
+// including the very first one on a genuinely blank repo.
+const OCCUPANCY_ALLOWLIST = new Set([
+  '.git', '.claude', '.gitignore', '.gitattributes', '.editorconfig', '.musketeer.json',
+  'license', 'changelog.md', '.vscode', '.idea', '.github', 'directory.build.props',
+  '.ds_store', 'thumbs.db', 'desktop.ini',
+]);
+
+const STAGING_DIR_PREFIX = '.musketeer-dotnet-staging-';
+
+const SOLUTION_NAME_TOKEN = '__SolutionName__';
+const GUID_TOKEN_NAMES = [
+  '__SlnFolderGuid_Src__',
+  '__SlnFolderGuid_Tests__',
+  '__ProjectGuid_Domain__',
+  '__ProjectGuid_Application__',
+  '__ProjectGuid_Infrastructure__',
+  '__ProjectGuid_Api__',
+  '__ProjectGuid_DomainTests__',
+  '__ProjectGuid_ApplicationTests__',
+  '__ProjectGuid_InfrastructureTests__',
+  '__ProjectGuid_ApiTests__',
+];
+
+function isAllowlistedRootEntry(name) {
+  if (OCCUPANCY_ALLOWLIST.has(name.toLowerCase())) return true;
+  return /^readme(\..+)?$/i.test(name) || /^license(\..+)?$/i.test(name);
+}
+
+/**
+ * A genuinely empty directory holds no stack signal — it can't itself mean
+ * "this repo is occupied", so it doesn't count against the root listing
+ * (e.g. a leftover bare `src`/`tests` pair from an unrelated convention).
+ */
+function isEmptyDir(fullPath) {
+  try {
+    const st = fs.statSync(fullPath);
+    return st.isDirectory() && fs.readdirSync(fullPath).length === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Decide whether `projectDir` is genuinely blank enough to scaffold into.
+ * Bias toward skipping: a false-skip is safe (user scaffolds manually later),
+ * a false-scaffold corrupts a real project.
+ * @param {string} projectDir
+ * @returns {{scaffold:boolean, reason?:string}}
+ */
+function shouldScaffold(projectDir) {
+  const dotnetFiles = findDotnetProjectFiles(projectDir);
+  if (dotnetFiles.length > 0) {
+    return { scaffold: false, reason: `existing .NET project file(s) found (e.g. ${dotnetFiles[0]})` };
+  }
+
+  let rootEntries;
+  try {
+    rootEntries = fs.readdirSync(projectDir, { withFileTypes: true });
+  } catch (err) {
+    return { scaffold: false, reason: `cannot read project root: ${err.message}` };
+  }
+
+  const names = rootEntries.map((e) => e.name);
+  const lowerNames = new Set(names.map((n) => n.toLowerCase()));
+  const otherStackManifest = OTHER_STACK_MANIFESTS.find((m) => lowerNames.has(m.toLowerCase()));
+  if (otherStackManifest) {
+    return { scaffold: false, reason: `other-stack manifest found: ${otherStackManifest}` };
+  }
+
+  const unexpected = names.filter((n) => {
+    if (isAllowlistedRootEntry(n)) return false;
+    if (n.startsWith(STAGING_DIR_PREFIX)) return false; // leftover from a crashed prior scaffold attempt
+    return !isEmptyDir(path.join(projectDir, n));
+  });
+  if (unexpected.length > 0) {
+    return { scaffold: false, reason: `project root already occupied by: ${unexpected.join(', ')}` };
+  }
+
+  return { scaffold: true };
+}
+
+/**
+ * Derive a PascalCase solution name from a project directory's basename.
+ * Unicode-aware (splits on `\p{L}\p{N}` boundaries, not ASCII `\w`) so
+ * non-Latin-script folder names aren't collapsed to the generic fallback.
+ * @param {string} projectDir
+ * @returns {string}
+ */
+function deriveSolutionName(projectDir) {
+  const base = path.basename(path.resolve(projectDir));
+  const segments = base.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  const pascal = segments
+    .map((s) => {
+      const chars = Array.from(s);
+      return chars[0].toUpperCase() + chars.slice(1).join('');
+    })
+    .join('');
+
+  if (!pascal) return 'App';
+  if (/^\p{N}/u.test(pascal)) return `App${pascal}`;
+  return pascal;
+}
+
+function substituteFreshGuids(stagingDir, solutionName) {
+  const slnPath = path.join(stagingDir, `${solutionName}.sln`);
+  let content = fs.readFileSync(slnPath, 'utf8');
+  for (const tokenName of GUID_TOKEN_NAMES) {
+    content = content.split(tokenName).join(`{${crypto.randomUUID().toUpperCase()}}`);
+  }
+  fs.writeFileSync(slnPath, content, 'utf8');
+}
+
+/**
+ * Scaffold a generic src/tests Clean Architecture skeleton into `projectDir`,
+ * only when `shouldScaffold` confirms it's genuinely blank. No-op (not an
+ * error) when the guard trips. Stages the whole copy in a temp directory and
+ * only promotes it into `projectDir` on full success, so a mid-copy failure
+ * leaves the real project untouched.
+ * @param {string} projectDir
+ * @param {string} templateScaffoldDir
+ * @param {(msg:string)=>void} log
+ * @returns {{scaffolded:boolean, solutionName?:string, reason?:string}}
+ */
+function scaffoldDotnetProject(projectDir, templateScaffoldDir, log) {
+  const guard = shouldScaffold(projectDir);
+  if (!guard.scaffold) {
+    log(`dotnet: scaffold skipped (${guard.reason})`);
+    return { scaffolded: false, reason: guard.reason };
+  }
+
+  const solutionName = deriveSolutionName(projectDir);
+  // Stage under projectDir itself (not the OS temp dir) so promoteStagedScaffold's
+  // fs.renameSync is guaranteed same-filesystem — renaming across devices/volumes
+  // (common for OS temp dirs vs. a project on another drive, or in containers where
+  // /tmp is a separate overlay from the bind-mounted workspace) throws EXDEV and would
+  // silently defeat scaffolding forever on those topologies.
+  const stagingDir = fs.mkdtempSync(path.join(projectDir, STAGING_DIR_PREFIX));
+
+  try {
+    copyTemplateWithTokenSubstitution(templateScaffoldDir, stagingDir, SOLUTION_NAME_TOKEN, solutionName);
+    substituteFreshGuids(stagingDir, solutionName);
+    promoteStagedScaffold(stagingDir, projectDir);
+  } finally {
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+  }
+
+  log(`dotnet: scaffolded src/tests skeleton as "${solutionName}"`);
+  return { scaffolded: true, solutionName };
+}
+
+/**
+ * Absolute path to the packaged template/dotnet-scaffold directory.
+ * @returns {string}
+ */
+function defaultTemplateScaffoldDir() {
+  return path.join(__dirname, '..', 'template', 'dotnet-scaffold');
+}
+
+module.exports = { shouldScaffold, deriveSolutionName, scaffoldDotnetProject, defaultTemplateScaffoldDir };

package/src/reconcile.js

@@ -12,12 +12,16 @@ const provisioner = require('./provisioner');
  * templateDir, muster, provisioner, log, now) to stay hermetic.
  */
 function defaultDeps() {
+  const dotnetScaffold = require('./dotnet-scaffold');
   return {
     manifest: loadManifest(),
     templateDir: templateClaudeDir(),
     settingsMerger,
     provisioner,
     muster: require('./muster'),
+    dotnetBuildProps: require('./dotnet-build-props'),
+    dotnetScaffold,
+    dotnetScaffoldTemplateDir: dotnetScaffold.defaultTemplateScaffoldDir(),
     now: () => new Date().toISOString(),
     log: (m) => process.stdout.write(m + '\n'),
   };
@@ -55,6 +59,26 @@ async function run(opts, overrides = {}) {
   copier.apply(plan, d.templateDir, projectDir);
   d.settingsMerger.generate(desired, projectDir);
 
+  // Deliberate exception to the .claude/-only invariant (see copier.js's containedPath
+  // comment) — the dotnet company deterministically touches the project's real root,
+  // not just .claude/.
+  if (desired.ids.includes('dotnet')) {
+    if (process.env.MUSKETEER_SKIP_DOTNET_PROPS) {
+      d.log('dotnet: Directory.Build.props merge skipped (MUSKETEER_SKIP_DOTNET_PROPS set)');
+    } else {
+      try {
+        d.dotnetBuildProps.ensureDirectoryBuildProps(projectDir, d.log);
+      } catch (err) {
+        d.log(`dotnet: Directory.Build.props merge failed (${err.message}) — continuing`);
+      }
+    }
+    try {
+      d.dotnetScaffold.scaffoldDotnetProject(projectDir, d.dotnetScaffoldTemplateDir, d.log);
+    } catch (err) {
+      d.log(`dotnet: src/tests scaffold failed (${err.message}) — continuing`);
+    }
+  }
+
   await d.provisioner.ensure(desired.prereqs, manifest, {
     projectDir,
     templateDir: d.templateDir,