muse-crew 0.11.0 → 0.11.1

package/docs/state-boundary-spec.md

@@ -141,3 +141,44 @@ New `tests/gitignore.test.js` and `tests/repo-orchestration.test.js`:
   no approval to change).
 - Does not add new API endpoints.
 - Does not change Room #12 or any existing crew's behavior.
+
+## 8. Setup commits its scaffold (0.11.1)
+
+**Defect (room #13, 2026-09-17):** 0.11.0's setup wrote `.orchestration/`
+(and the consented `.gitignore` update) but never committed them. The
+first task's Integrate then refused to merge onto the dirty main — twice,
+deterministically. An uncommitted scaffold deterministically breaks the
+first task after setup.
+
+**Contract:** setup leaves the repo's main checkout clean. After the
+scaffold + `.gitignore` steps, `lib/commit-scaffold.js` commits exactly
+the crew's paths (`.orchestration/`, plus `.gitignore` when the setup step
+changed it under consent). The commit message names what was staged,
+computed from the index.
+
+**Rules:**
+- Only the crew's paths are ever staged. The user's unrelated changes
+  (tracked modifications, untracked files) are never swept in.
+- Idempotent: nothing new staged → no commit, `{ committed: false,
+  reason: "nothing-to-commit" }`. Never an empty commit.
+- Missing `.orchestration/` → throw (the scaffold step did not run).
+- Commit failures (e.g. no git identity) throw loudly with git's stderr.
+  No identity is ever invented — the commit belongs to the user; the
+  caller configures identity and re-runs.
+- With `--consent`, `.gitignore` must be clean before setup touches it:
+  a pre-existing dirty `.gitignore` fails setup loudly (refuse — never
+  sweep the user's edits into the setup commit). `.orchestration/` is
+  crew-owned: pre-existing uncommitted content there is committed, not
+  refused (this also repairs 0.11.0 rooms).
+- `lib/setup-project-repo.js` (the composer) runs all three steps and
+  exits non-zero on any failure. crew-init's dashboard mode calls the
+  composer (one agent call, replacing the old two-call shape); a failed
+  commit is logged loudly and surfaced as `repoSetupWarning` in the init
+  summary, since the first task will fail Integrate until the scaffold
+  is committed.
+
+**Tests:** `tests/commit-scaffold.test.js` (behavioral: clean tree after
+setup, accurate message, idempotency, non-repo no-op, missing scaffold
+throws, missing identity throws, composer refusal on dirty `.gitignore`,
+declined consent leaves `.gitignore` untouched; structural: crew-init
+calls the composer).

package/lib/AGENTS.md

@@ -29,5 +29,6 @@ Shell scripts for the crew's infrastructure. Called by workflow scripts, cron, a
 - `update-watch.js` — deterministic automatic update watcher (2026-09-16, zero deps): `node update-watch.js --crew-home <path>` (missing arg → usage, exit 2; every other path exits 0). Watches the public npm registry (`npm view muse-crew version` pinned to `https://registry.npmjs.org/`) vs `crew-release.sh current` and files a `workflow: "upgrade"` task with `source: npm@<version>` when policy (`auto_update_crew`, `update_channel`) and channel gating allow; watches `git ls-remote origin HEAD` on the first `deploy_type=artifact` project vs `$CREW_HOME/.update-watch.json` and files a `workflow: "chore"` task carrying the mechanical dashboard-upgrade journey. Reads the `.crew-version` compatibility anchor at the new ref via `git fetch` + `git show <sha>:.crew-version` (never the working tree) and orders dashboard-led: a declared newer crew files the crew upgrade task FIRST and the dashboard task notes it follows the crew upgrade (declaration bypasses `update_channel`, not the `auto_update_crew=false` opt-out); a declared older crew skips the dashboard leg entirely as a human decision; a missing/invalid/unfetchable anchor fails open to the dashboard leg as today. Idempotency via the same state file (records at file time); check failures log to `$CREW_HOME/update-watch.log` and are never thrown. Safety: only files tasks — never deploys, never touches the artifact/config/scheduler. Run by the daily `crew-update-watch` cron through the `current` symlink (latest release); deliberately NOT in the lib-pinning `PIN_BASENAMES`.
 - `gitignore.js` — deterministic .gitignore management for crew-owned paths (2026-09-17): the crew touches exactly one user-owned file outside `.orchestration/` — the repo's `.gitignore`. `ensureGitignoreEntries(repoPath, entries)` creates the file when missing, appends missing entries (exact line match, no duplicates), preserves existing content byte-for-byte, and is idempotent. `describeGitignoreChange(repoPath, entries)` renders the exact diff for the setup consent conversation. Crew-owned entries: `.worktrees/`, `.orchestration/user/`. CLI: `--repo <path> [--dry-run]`.
 - `repo-orchestration.js` — repository-local `.orchestration/` scaffold (2026-09-17): `scaffoldRepoOrchestration(repoPath, crewRepoPath)` creates `$REPO/.orchestration/{workflows,identities,phases,user}/`, seeds workflows/identities/phases from the crew repo's platform defaults with no-clobber semantics (existing project customizations never overwritten), and writes a README in `user/` explaining it's for local config. Idempotent. CLI: `--repo <path> --crew-repo <path>`.
-- `setup-project-repo.js` — repo-local setup composer for a registered project (2026-09-17): runs the `.orchestration/` scaffold plus the `.gitignore` update (only with explicit `--consent`). The CLI-path equivalent of crew-init's dashboard-mode repo setup; the dashboard calls the same script. No new API endpoint — composition of existing deterministic modules. CLI: `--repo <path> --crew-repo <path> [--consent]`.
+- `setup-project-repo.js` — repo-local setup composer for a registered project (2026-09-17, setup-commit 2026-09-18): runs the `.orchestration/` scaffold plus the `.gitignore` update (only with explicit `--consent`), then COMMITS both via `commit-scaffold.js` so the repo's main checkout is clean when setup finishes (room #13: an uncommitted scaffold deterministically broke the first task's Integrate). Refuses loudly when `.gitignore` has pre-existing uncommitted changes (never sweeps the user's edits into the setup commit); `.orchestration/` is crew-owned so pre-existing content there is committed, not refused. The CLI-path equivalent of crew-init's dashboard-mode repo setup; the dashboard calls the same script. No new API endpoint — composition of existing deterministic modules. CLI: `--repo <path> --crew-repo <path> [--consent]`; prints `{ orchestration, gitignore, commit }`, exits non-zero on any failure.
+- `commit-scaffold.js` — deterministic setup-scaffold commit (2026-09-18): stages only `.orchestration/` (+ `.gitignore` with `--gitignore`) and commits with a message naming exactly what was staged. Idempotent (`nothing-to-commit`, never an empty commit); not-a-git-repo is a clean no-op; missing `.orchestration/` and commit failures (e.g. no git identity) throw loudly — the commit belongs to the user, so no identity is ever invented here. Exports `isPathDirty` (porcelain check for one path) for the composer's pre-mutation guard. CLI: `--repo <path> [--gitignore]`.
 - `sample-project.js` — optional sample-project setup (2026-09-17): extracts `seed/sample-project.tar.gz` (stripping the `sample-project/` prefix), `git init`, initial commit. No remote required. Registration happens via the existing `create-project` action — no sample-specific endpoint. CLI: `--tarball <path> --dest <dir> --name <project-name>`.

package/lib/commit-scaffold.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+// lib/commit-scaffold.js — commit the crew's setup scaffold files.
+//
+// After project setup writes $REPO/.orchestration/ (and, with the user's
+// consent, updates .gitignore), this module commits exactly those paths so
+// the repo's main checkout is clean when setup finishes.
+//
+// Why this exists (room #13, 2026-09-17): 0.11.0's setup wrote the scaffold
+// but never committed it. The first task's Integrate then refused to merge
+// onto the dirty main — twice in a row, deterministically. An uncommitted
+// scaffold deterministically breaks the first task after setup. Setup must
+// leave main clean; this is the mechanical half of that contract.
+//
+// Contract:
+//   - Only ever stages `.orchestration/` and (with --gitignore) `.gitignore`.
+//     The user's unrelated changes are never swept into the setup commit.
+//   - Idempotent: nothing new staged → { committed: false, reason:
+//     "nothing-to-commit" }; never creates an empty commit.
+//   - Not a git repo → { committed: false, reason: "not-a-git-repo" }.
+//     There is no main to keep clean, so there is nothing to do.
+//   - Missing `.orchestration/` → throws. The scaffold step did not run;
+//     fail loudly, never silently skip.
+//   - Commit failures (e.g. no git identity configured) throw with git's
+//     stderr. The caller configures identity and re-runs; never invent an
+//     identity here — the commit belongs to the user, not the crew.
+//   - The commit message names exactly what was staged (computed from the
+//     index, not from flags).
+//
+// Usage:
+//   node lib/commit-scaffold.js --repo <path> [--gitignore]
+//     --gitignore: the setup step modified .gitignore (consent was given);
+//                  include it in the commit.
+// Prints JSON: { committed, sha, reason }
+
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+function git(repoPath, args, env) {
+  try {
+    // No .trim(): callers that parse fixed-width output (porcelain) need
+    // the raw lines; scalar callers trim themselves.
+    return execFileSync("git", args, {
+      cwd: repoPath,
+      encoding: "utf8",
+      env: env || process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (e) {
+    const stderr = e.stderr ? String(e.stderr).trim() : "";
+    throw new Error("git " + args.join(" ") + " failed: " + (stderr || e.message));
+  }
+}
+
+// Porcelain status lines touching exactly relPath (e.g. ".gitignore").
+// Used by the composer as a pre-mutation guard; exported for tests.
+function isPathDirty(repoPath, relPath) {
+  const out = git(repoPath, ["status", "--porcelain", "--", relPath]);
+  return out.split("\n").some(function (line) {
+    if (line.length < 4) return false;
+    const p = line.slice(3).replace(/^"|"$/g, "");
+    return p === relPath;
+  });
+}
+
+function commitScaffold(repoPath, opts) {
+  opts = opts || {};
+  const includeGitignore = opts.includeGitignore === true;
+
+  if (!fs.existsSync(path.join(repoPath, ".git"))) {
+    return { committed: false, sha: null, reason: "not-a-git-repo" };
+  }
+  if (!fs.existsSync(path.join(repoPath, ".orchestration"))) {
+    throw new Error(
+      "no .orchestration/ scaffold found in " + repoPath + " — run the scaffold step before committing"
+    );
+  }
+
+  const paths = [".orchestration"];
+  if (includeGitignore) paths.push(".gitignore");
+  git(repoPath, ["add", "--"].concat(paths));
+
+  const staged = git(repoPath, ["diff", "--cached", "--name-only"]).trim();
+  if (!staged) {
+    return { committed: false, sha: null, reason: "nothing-to-commit" };
+  }
+
+  const stagedFiles = staged.split("\n");
+  const subject = stagedFiles.indexOf(".gitignore") !== -1
+    ? "Muse Crew setup: commit .orchestration scaffold and crew .gitignore entries"
+    : "Muse Crew setup: commit .orchestration scaffold";
+  const body =
+    "Setup leaves the repo's main checkout clean: these are the crew-owned\n" +
+    "files written during project setup. Integrate refuses to merge onto a\n" +
+    "dirty main, so they are committed here instead of left uncommitted.";
+  git(repoPath, ["commit", "-m", subject, "-m", body, "--quiet"]);
+  const sha = git(repoPath, ["rev-parse", "HEAD"]).trim();
+
+  return { committed: true, sha: sha, reason: null };
+}
+
+module.exports = { commitScaffold, isPathDirty };
+
+if (require.main === module) {
+  const argv = process.argv.slice(2);
+  const get = (flag) => {
+    const i = argv.indexOf(flag);
+    return i >= 0 ? argv[i + 1] : null;
+  };
+  const repoPath = get("--repo");
+  if (!repoPath) {
+    console.error("Usage: node lib/commit-scaffold.js --repo <path> [--gitignore]");
+    process.exit(2);
+  }
+  try {
+    console.log(JSON.stringify(commitScaffold(repoPath, { includeGitignore: argv.includes("--gitignore") })));
+  } catch (e) {
+    console.error("commit-scaffold failed: " + (e.message || e));
+    process.exit(1);
+  }
+}

package/lib/setup-project-repo.js

@@ -4,17 +4,37 @@
 // Composes the deterministic building blocks after create-project:
 //   1. Scaffold $REPO/.orchestration/ (workflows/identities/phases versioned, user/ ignored)
 //   2. Optionally update .gitignore (only with explicit --consent)
+//   3. Commit the scaffold (and the .gitignore update when consented) so
+//      the repo's main checkout is clean when setup finishes.
+//
+// Step 3 is the 2026-09-18 fix for the room #13 defect: 0.11.0 wrote the
+// scaffold but never committed it, and the first task's Integrate then
+// refused to merge onto the dirty main — twice, deterministically. Setup
+// must leave main clean; the commit is mechanical, not agent judgment.
 //
 // This is the CLI path equivalent of what crew-init's dashboard mode does.
 // The dashboard calls the same script. No new API endpoint — composition.
 //
+// Guards:
+//   - With --consent, .gitignore must be clean before we touch it. The
+//     commit only ever stages .orchestration/ (+ .gitignore when we changed
+//     it), but a pre-existing dirty .gitignore would be swept into our
+//     commit by `git add` — so refuse loudly instead. Commit or stash it,
+//     then re-run.
+//   - .orchestration/ is crew-owned: pre-existing uncommitted content there
+//     (e.g. left dirty by 0.11.0) is committed, not refused.
+//
 // Usage:
 //   node lib/setup-project-repo.js --repo <path> --crew-repo <path> [--consent]
 //     --consent: user approved the .gitignore change (from the setup conversation)
-// Prints JSON: { orchestration: {...}, gitignore: {...} | { declined: true } }
+// Prints JSON: { orchestration: {...}, gitignore: {...} | { declined: true }, commit: {...} }
+// Exits non-zero on any failure (fail closed, loud).
 
+const fs = require("fs");
+const path = require("path");
 const { scaffoldRepoOrchestration } = require("./repo-orchestration");
 const { ensureGitignoreEntries, describeGitignoreChange } = require("./gitignore");
+const { commitScaffold, isPathDirty } = require("./commit-scaffold");
 
 function main() {
   const argv = process.argv.slice(2);
@@ -31,18 +51,44 @@ function main() {
     process.exit(2);
   }
 
-  const orchestration = scaffoldRepoOrchestration(repoPath, crewRepoPath);
+  try {
+    // Guard: never sweep the user's own .gitignore edits into our commit.
+    if (consent && fs.existsSync(path.join(repoPath, ".git")) && isPathDirty(repoPath, ".gitignore")) {
+      throw new Error(
+        "setup refused: .gitignore has uncommitted changes not made by setup — " +
+          "commit or stash them, then re-run setup"
+      );
+    }
 
-  let gitignore;
-  if (consent) {
-    gitignore = ensureGitignoreEntries(repoPath);
-  } else {
-    // Declined (or non-interactive default): report what WOULD change.
-    const preview = describeGitignoreChange(repoPath);
-    gitignore = { declined: true, wouldChange: preview };
-  }
+    const orchestration = scaffoldRepoOrchestration(repoPath, crewRepoPath);
 
-  console.log(JSON.stringify({ orchestration, gitignore }, null, 2));
+    let gitignore;
+    if (consent) {
+      gitignore = ensureGitignoreEntries(repoPath);
+    } else {
+      // Declined (or non-interactive default): report what WOULD change.
+      const preview = describeGitignoreChange(repoPath);
+      gitignore = { declined: true, wouldChange: preview };
+    }
+
+    let commit;
+    try {
+      commit = commitScaffold(repoPath, { includeGitignore: consent });
+    } catch (commitErr) {
+      throw new Error(
+        "commit failed: " +
+          commitErr.message +
+          " — the repo has uncommitted crew files; configure git identity and run: " +
+          "node lib/commit-scaffold.js --repo <path>" +
+          (consent ? " --gitignore" : "")
+      );
+    }
+
+    console.log(JSON.stringify({ orchestration, gitignore, commit }, null, 2));
+  } catch (e) {
+    console.error("setup-project-repo failed: " + (e.message || e));
+    process.exit(1);
+  }
 }
 
 if (require.main === module) main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Opinionated orchestration for Muse \u2014 workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,

package/workflows/crew-init.js

@@ -337,47 +337,6 @@ var scaffoldCreated = scaffoldResult.created ? scaffoldResult.created.length : 0
 var scaffoldSkipped = scaffoldResult.skipped ? scaffoldResult.skipped.length : 0;
 log("Scaffold: " + scaffoldCreated + " created, " + scaffoldSkipped + " skipped");
 
-// ── Gitignore consent execution ─────────────────────────────────────
-// If the user approved during the setup conversation (gitignoreConsent=true)
-// and we have a repo (dashboard mode), append crew-owned paths to .gitignore
-// via the deterministic lib/gitignore.js (no agent judgment — the agent
-// just runs the fixed command; all merge logic is in the tested JS module).
-// This is the ONLY user file outside .orchestration/ that the crew modifies.
-if (gitignoreConsent && dashboardRepoPath) {
-  var gitignoreResult;
-  try {
-    gitignoreResult = await agent(
-      "Run the deterministic gitignore updater. Do not decide anything — just run the command and return its JSON output.\n\n" +
-      "Command:\n" +
-      "node " + crewHome + "/current/lib/gitignore.js --repo \"" + gateFacts.dashboardRepoExpanded + "\"\n\n" +
-      "The script prints one JSON line: { created, appended[], skipped[] }.\n" +
-      "Return that JSON verbatim.",
-      {
-        key: "scaffold-gitignore",
-        label: "Update .gitignore for crew paths",
-        schema: {
-          type: "object",
-          properties: {
-            created: { type: "boolean" },
-            appended: { type: "array", items: { type: "string" } },
-            skipped: { type: "array", items: { type: "string" } }
-          },
-          required: ["created", "appended", "skipped"]
-        }
-      }
-    );
-    log("Gitignore: " + (gitignoreResult.created ? "created" : "updated") +
-        " — appended [" + (gitignoreResult.appended || []).join(", ") + "]" +
-        ", already present [" + (gitignoreResult.skipped || []).join(", ") + "]");
-  } catch (e) {
-    log("Gitignore update failed (non-fatal): " + String(e.message || e));
-  }
-} else if (dashboardRepoPath) {
-  log("Gitignore: user declined — add '.worktrees/' and '.orchestration/user/' to " + dashboardRepoPath + "/.gitignore manually.");
-} else {
-  log("Gitignore: no repo (CLI-only mode) — skipping.");
-}
-
 // ── Phase 3: Project registration ─────────────────────────────────────
 // Registers the first project in crew-state.db via the Crew API. In
 // dashboard mode, the dashboard becomes the crew's first project (so the
@@ -455,37 +414,82 @@ try {
 log("Project: " + dashboardSlug + " " + projectResult.action + " (repo_path=" + gateFacts.dashboardRepoExpanded + ")");
 } // end dashboard-mode project registration
 
-// ── Repo-local .orchestration/ scaffold ─────────────────────────────
-// Scaffold $REPO/.orchestration/ in the dashboard repo (version-controlled
-// workflows/identities/phases + ignored user/). Deterministic — the agent
-// runs the fixed command; all logic is in the tested lib module.
+// ── Project repo setup (2026-09-18) ─────────────────────────────────
+// One deterministic composer — lib/setup-project-repo.js — scaffolds
+// $REPO/.orchestration/, applies the consented .gitignore update, and COMMITS
+// both so the repo's main checkout is clean when setup finishes.
+// Room #13 (2026-09-17): the old two-call shape wrote the scaffold but never
+// committed it, and the first task's Integrate then refused to merge onto the
+// dirty main — twice, deterministically. This replaces both calls; the agent
+// still runs one fixed command and all logic stays in the tested lib modules.
+// Best-effort as before (a failed setup never blocks init), but a failed
+// COMMIT is logged loudly: the repo is dirty and the first task will fail
+// Integrate until the scaffold is committed.
+var setupRepoWarning = null;
+var setupRepoResult = null;
 if (dashboardRepoPath) {
-  var repoOrchResult;
   try {
-    repoOrchResult = await agent(
-      "Scaffold the repository-local .orchestration/ directory. Do not decide anything — just run the command and return its JSON output.\n\n" +
+    setupRepoResult = await agent(
+      "Run the deterministic project-repo setup composer. Do not decide anything — just run the command and return its JSON output.\n\n" +
       "Command:\n" +
-      "node " + crewHome + "/current/lib/repo-orchestration.js --repo \"" + gateFacts.dashboardRepoExpanded + "\" --crew-repo \"" + crewRepoPath + "\"\n\n" +
-      "The script prints JSON with dirsCreated, workflows, identities, phases.\n" +
+      "node " + crewHome + "/current/lib/setup-project-repo.js --repo \"" + gateFacts.dashboardRepoExpanded + "\" --crew-repo \"" + crewRepoPath + "\"" + (gitignoreConsent ? " --consent" : "") + "\n\n" +
+      "The script prints one JSON object: { orchestration, gitignore, commit }.\n" +
+      "orchestration carries orchDir, dirsCreated, and per-area created/skipped arrays;\n" +
+      "gitignore carries created/appended/skipped (or declined:true with a wouldChange preview);\n" +
+      "commit carries { committed, sha, reason }.\n" +
       "Return that JSON verbatim.",
       {
-        key: "scaffold-repo-orch",
-        label: "Scaffold repo-local .orchestration",
+        key: "scaffold-repo-setup",
+        label: "Set up project repo (scaffold + gitignore + commit)",
         schema: {
           type: "object",
           properties: {
-            orchDir: { type: "string" },
-            dirsCreated: { type: "array", items: { type: "string" } }
+            orchestration: {
+              type: "object",
+              properties: {
+                orchDir: { type: "string" },
+                dirsCreated: { type: "array", items: { type: "string" } }
+              },
+              required: ["orchDir", "dirsCreated"]
+            },
+            gitignore: { type: "object" },
+            commit: {
+              type: "object",
+              properties: {
+                committed: { type: "boolean" },
+                sha: { type: ["string", "null"] },
+                reason: { type: ["string", "null"] }
+              },
+              required: ["committed"]
+            }
           },
-          required: ["orchDir", "dirsCreated"]
+          required: ["orchestration", "gitignore", "commit"]
         }
       }
     );
-    log("Repo-orchestration: scaffolded " + repoOrchResult.orchDir +
-        " (dirs: [" + (repoOrchResult.dirsCreated || []).join(", ") + "])");
+    var orchDirs = (setupRepoResult.orchestration.dirsCreated || []).join(", ");
+    var commitMsg = setupRepoResult.commit.committed
+      ? "committed " + setupRepoResult.commit.sha
+      : "not committed (" + setupRepoResult.commit.reason + ")";
+    log("Repo setup: scaffolded " + setupRepoResult.orchestration.orchDir +
+        " (dirs: [" + orchDirs + "]); gitignore " +
+        (gitignoreConsent ? "update consented" : "declined by user — add '.worktrees/' and '.orchestration/user/' manually") +
+        "; scaffold " + commitMsg);
+    if (!setupRepoResult.commit.committed && setupRepoResult.commit.reason !== "nothing-to-commit") {
+      setupRepoWarning = "Project repo setup left the scaffold uncommitted (" +
+        setupRepoResult.commit.reason + ") — the first task's Integrate will refuse to merge until it is committed.";
+      log("WARNING: " + setupRepoWarning);
+    }
   } catch (e) {
-    log("Repo-orchestration scaffold failed (non-fatal): " + String(e.message || e));
+    var setupErr = String(e.message || e);
+    setupRepoWarning = "Project repo setup failed: " + setupErr + " — continuing without the repo scaffold.";
+    if (/commit failed/i.test(setupErr)) {
+      setupRepoWarning += " The repo has uncommitted crew files; the first task's Integrate will refuse to merge until they are committed.";
+    }
+    log(setupRepoWarning + " (non-fatal)");
   }
+} else {
+  log("Repo setup: no repo (CLI-only mode) — skipping.");
 }
 
 // ── Scheduler identity (2026-09-16) ──────────────────────────────────
@@ -746,6 +750,7 @@ return {
   releaseHash: releaseResult.hash,
   scaffold: { created: scaffoldCreated, skipped: scaffoldSkipped },
   project: projectResult.action,
+  repoSetupWarning: setupRepoWarning,
   crons: cronsResult.summary.crons,
   registry: cronsResult.summary.registry,
   autoUpdate: {