devflow-kit 3.2.0 → 3.4.0

package/dist/core/fs-atomic.js

@@ -28,15 +28,20 @@ import { promises as fs } from 'fs';
  *
  * @param filePath - Absolute path to the target file.
  * @param data - UTF-8 encoded content to write.
+ * @param createMode - Permission bits the temp file is CREATED with (masked by the
+ *   umask), so a file that must be owner-only is never readable by others, not even
+ *   between the write and the rename. Omitted, the umask default applies. Either way
+ *   an existing target's mode wins (below).
  */
-export async function writeFileAtomicExclusive(filePath, data) {
+export async function writeFileAtomicExclusive(filePath, data, createMode) {
     // PID-scope the tmp name so concurrent writers from different processes
     // (e.g., two Claude Code sessions) never collide on the same .tmp path.
     // mirrors proxy-log.ts rotation at src/core/proxy-log.ts which PID-scopes
     // for the same reason.
     const tmp = `${filePath}.tmp.${process.pid}`;
+    const options = { encoding: 'utf-8', flag: 'wx', ...(createMode === undefined ? {} : { mode: createMode }) };
     try {
-        await fs.writeFile(tmp, data, { encoding: 'utf-8', flag: 'wx' });
+        await fs.writeFile(tmp, data, options);
     }
     catch (err) {
         if (err.code !== 'EEXIST')
@@ -48,7 +53,7 @@ export async function writeFileAtomicExclusive(filePath, data) {
             await fs.unlink(tmp);
         }
         catch { /* race — already removed */ }
-        await fs.writeFile(tmp, data, { encoding: 'utf-8', flag: 'wx' });
+        await fs.writeFile(tmp, data, options);
     }
     // Preserve the target's permission mode across the atomic replace.
     // A user who hardened the target (e.g. settings.json → 0600 to protect

package/dist/core/learning-tuning-config.js

@@ -6,6 +6,14 @@ const VALID_MODELS = new Set(['opus', 'sonnet', 'haiku']);
 function isValidModel(value) {
     return typeof value === 'string' && VALID_MODELS.has(value);
 }
+/**
+ * D-LEARNING-SHIPPED-ROW: the default model is the model the Learning agent ships
+ * with, the `model:` line of src/assets/agents/learning.md. With no layer
+ * configuring a model, the spawn directive names none and that line decides, so a
+ * different default here would describe a run that never happens.
+ * tests/decisions/config.test.ts holds this value equal to the Learning row of the
+ * agent-config table, which a change of the shipped tier edits with the frontmatter.
+ */
 const DEFAULTS = {
     model: 'opus',
     debug: false,

package/dist/core/learning-variants.js

@@ -0,0 +1,213 @@
+/**
+ * Learning-variant splitter: one compiled prompt body in, its learning-on and
+ * learning-off variants out.
+ *
+ * Pure module, zero I/O. Every refusal is a Result; the exiting shell is
+ * scripts/build-mds.ts, which renders these errors into the build's single exit.
+ *
+ * D-LEARNING-VARIANTS: when learning is off on a machine, the decisions text is
+ * ABSENT from every prompt it would have reached, not merely gated at run time.
+ * The build therefore emits two variants of a prompt that carries learning text:
+ * the learning-on variant at today's path (dist/commands/x.md, dist/agents/x.md)
+ * and the learning-off variant at dist/learning-off/{commands,agents}/x.md, only
+ * for a host that has an arm. A prompt with no arm has one variant and no
+ * learning-off file.
+ *
+ * The arms are whole-line markers in the host or in a partial it expands:
+ *
+ *   <!-- learning:on -->     opens an arm that only the learning-on variant keeps
+ *   <!-- learning:off -->    opens an arm that only the learning-off variant keeps;
+ *                            directly after an on arm it is that arm's else
+ *   <!-- learning:end -->    closes the arm
+ *
+ * A marker line matches LEARNING_MARKER_RE. It may be indented and may sit inside
+ * a fenced block, a list, a define body or an agent's second frontmatter block,
+ * because MDS passes an HTML comment through untouched. The splitter runs on the
+ * COMPILED body, after the MDS compile, so it adds no compileFile call, no import
+ * into an MDS module and nothing against the per-module compile-time guard. A
+ * marker line is removed whole, with its newline. Every other line is kept byte
+ * for byte, so a blank line is content: put the blank line a paragraph needs
+ * inside the arm that owns the paragraph, and the other variant gets none of it.
+ *
+ * The markers are INTERIM. MDS 0.4.4 emits an `@if` inside a code fence or on an
+ * indented line as literal text (its lexer requires column 0), and the arms have
+ * to sit exactly there: inside fenced spawn blocks, scripts, list items and
+ * frontmatter. They are replaced by native conditionals once mdscript ships
+ * fence- and indent-aware `@if` (dean0x/mdscript#452). That swap, with the
+ * @mdscript/mds upgrade it rides on proven byte-identical in dist/ and this module
+ * deleted, is dean0x/devflow#439. The mapping is one to one: `on` becomes
+ * `@if learning:`, `off` becomes `@else:` and `end` becomes `@end`. A standalone
+ * `off` arm, with no on arm before it, becomes an `@if learning:` with an empty
+ * body followed by `@else:`.
+ *
+ * What the splitter refuses, each as a LearningSplitError with the source line:
+ *   - nesting: an `on` marker while an arm is open, or a second `off` in one arm;
+ *   - an `end` with no open arm;
+ *   - an arm still open at the end of the body;
+ *   - an empty arm (no line with content between its marker and the next);
+ *   - a stray marker: a line that names `<!-- learning:` but is not a whole-line
+ *     marker, which would otherwise ship as prompt text.
+ *
+ * Scope guarantee: this module answers one question (what are the two variants of
+ * this body?) and one cheap one for the build to ask of a body that must carry no
+ * arms (containsLearningMarker). It decides nothing about WHICH text belongs in an
+ * arm: that is authoring, and the guards over the built trees hold it.
+ */
+function Ok(value) {
+    return { ok: true, value };
+}
+function Err(error) {
+    return { ok: false, error };
+}
+/**
+ * Repo-relative root of the learning-off variants.
+ *
+ * Exported because the build's orphan prune names this directory even when no
+ * host carries an arm, which is exactly the case where every file in it is an
+ * orphan, so it cannot be derived from the plan.
+ */
+export const LEARNING_OFF_OUTPUT_DIR = 'dist/learning-off';
+/**
+ * POSIX repo-relative path of the learning-off variant of an output file.
+ *
+ * `fileName` is the already-validated basename the learning-on variant is written
+ * under (`implement.md`), so the two variants of one host always share a name.
+ */
+export function learningOffRelPath(kind, fileName) {
+    return `${LEARNING_OFF_OUTPUT_DIR}/${kind}/${fileName}`;
+}
+// ---------------------------------------------------------------------------
+// Markers
+// ---------------------------------------------------------------------------
+/**
+ * A whole-line learning marker. The group captures `on`, `off` or `end`.
+ *
+ * Anchored at both ends with no nested quantifier, so a match is linear in the
+ * line length. Leading and trailing space or tab is allowed; anything else on the
+ * line is not a marker.
+ */
+export const LEARNING_MARKER_RE = /^[ \t]*<!-- learning:(on|off|end) -->[ \t]*$/;
+/**
+ * The fragment that makes a line a marker ATTEMPT: loose on spacing and case so a
+ * malformed marker is caught rather than shipped. Every valid marker contains it.
+ */
+const MARKER_FRAGMENT_RE = /<!--\s*learning\s*:/i;
+/** True when the text names a learning marker anywhere, valid or not. */
+export function containsLearningMarker(text) {
+    return MARKER_FRAGMENT_RE.test(text);
+}
+function markerOf(line) {
+    // A CRLF body carries the carriage return on the line; it is not part of the marker.
+    const bare = line.endsWith('\r') ? line.slice(0, -1) : line;
+    const match = LEARNING_MARKER_RE.exec(bare);
+    return match === null ? null : match[1];
+}
+/** The longest stretch of a stray line a refusal quotes. */
+const STRAY_QUOTE_MAX = 80;
+/**
+ * Split a compiled body into its learning-on and learning-off variants.
+ *
+ * Total and pure: the same input gives the same output, and a refusal is a
+ * Result. The loop is one pass over the body's lines, so its bound is the body's
+ * own length.
+ *
+ * An arm needs a line with content in it. An arm that holds only blank lines is
+ * refused as empty, because it would add blank lines to one variant and nothing to
+ * the other, which is a mistake rather than a design.
+ */
+export function splitLearningVariants(body) {
+    const lines = body.split('\n');
+    const on = [];
+    const off = [];
+    let hasArms = false;
+    // The open arm, if any: which one, the line of the marker that opened it, and
+    // whether it has held a line with content yet.
+    let arm = null;
+    let armOpenedAt = 0;
+    let armHasContent = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const lineNo = index + 1;
+        const marker = markerOf(line);
+        if (marker === null) {
+            if (MARKER_FRAGMENT_RE.test(line)) {
+                return Err({ kind: 'stray-marker', line: lineNo, text: line.trim().slice(0, STRAY_QUOTE_MAX) });
+            }
+            if (arm !== 'off')
+                on.push(line);
+            if (arm !== 'on')
+                off.push(line);
+            if (arm !== null && line.trim() !== '')
+                armHasContent = true;
+            continue;
+        }
+        hasArms = true;
+        switch (marker) {
+            case 'on':
+                if (arm !== null)
+                    return Err({ kind: 'nested-arm', line: lineNo, arm, openedAt: armOpenedAt });
+                arm = 'on';
+                armOpenedAt = lineNo;
+                armHasContent = false;
+                break;
+            case 'off':
+                if (arm === 'off')
+                    return Err({ kind: 'repeated-off', line: lineNo, openedAt: armOpenedAt });
+                // Directly after an on arm this is its else: the on arm ends here.
+                if (arm === 'on' && !armHasContent) {
+                    return Err({ kind: 'empty-arm', arm, openedAt: armOpenedAt, closedAt: lineNo });
+                }
+                arm = 'off';
+                armOpenedAt = lineNo;
+                armHasContent = false;
+                break;
+            case 'end':
+                if (arm === null)
+                    return Err({ kind: 'unopened-end', line: lineNo });
+                if (!armHasContent) {
+                    return Err({ kind: 'empty-arm', arm, openedAt: armOpenedAt, closedAt: lineNo });
+                }
+                arm = null;
+                break;
+            default: {
+                const unhandled = marker;
+                return Err({ kind: 'stray-marker', line: lineNo, text: String(unhandled) });
+            }
+        }
+    }
+    if (arm !== null)
+        return Err({ kind: 'unclosed-arm', arm, openedAt: armOpenedAt });
+    return Ok({ on: on.join('\n'), off: off.join('\n'), hasArms });
+}
+/**
+ * Render a refusal as one line a person can act on.
+ *
+ * One arm per kind with a `never` default, so a kind added to the union cannot
+ * fall through into a message that does not describe it. Shared by the build and
+ * the tests, so the text asserted is the text shipped.
+ */
+export function describeLearningSplitError(error) {
+    switch (error.kind) {
+        case 'nested-arm':
+            return (`line ${error.line}: a learning:on marker inside the ${error.arm} arm opened at line ` +
+                `${error.openedAt} — arms do not nest; close it with learning:end first`);
+        case 'repeated-off':
+            return (`line ${error.line}: a second learning:off marker inside the off arm opened at line ` +
+                `${error.openedAt} — an arm has at most one else`);
+        case 'unopened-end':
+            return `line ${error.line}: a learning:end marker with no open arm`;
+        case 'unclosed-arm':
+            return `the ${error.arm} arm opened at line ${error.openedAt} is never closed with learning:end`;
+        case 'empty-arm':
+            return (`lines ${error.openedAt}-${error.closedAt}: the ${error.arm} arm holds no line with content — ` +
+                `delete the arm or put its text inside it`);
+        case 'stray-marker':
+            return (`line ${error.line}: "${error.text}" names a learning marker but is not one — a marker ` +
+                `is a whole line, exactly <!-- learning:on -->, <!-- learning:off --> or <!-- learning:end -->`);
+        default: {
+            const unhandled = error;
+            return `unhandled learning split error ${JSON.stringify(unhandled)}`;
+        }
+    }
+}
+//# sourceMappingURL=learning-variants.js.map

package/dist/core/manifest.js

@@ -213,6 +213,68 @@ export async function syncManifestFeature(devflowDir, key, value) {
     manifest.updatedAt = new Date().toISOString();
     await writeManifest(devflowDir, manifest);
 }
+/**
+ * Drop `names` from a RAW parsed manifest's `plugins` list. Pure — returns a new
+ * object and never mutates its input. Null when there is nothing to write: the
+ * value is not a manifest-shaped object, or none of `names` is listed.
+ *
+ * Only `plugins` and `updatedAt` change; every other key is carried verbatim,
+ * `knownPlugins` included. That snapshot records which registry plugins the last
+ * install knew, and init adopts a registry plugin that is in neither list as new
+ * (`resolveSeedPlugins`), so dropping a removed plugin from it would make the next
+ * re-init install it again. Going through readManifest()/writeManifest() instead
+ * would drop every key ManifestData does not model (one a newer devflow wrote,
+ * say) and persist that reader's unrelated heals as a side effect of a removal.
+ * Entries that are not strings are neither matched nor dropped.
+ */
+export function withoutManifestPlugins(rawManifest, names, now) {
+    if (typeof rawManifest !== 'object' || rawManifest === null || Array.isArray(rawManifest))
+        return null;
+    const record = rawManifest;
+    if (!Array.isArray(record.plugins))
+        return null;
+    const doomed = new Set(names);
+    const kept = record.plugins.filter(entry => !(typeof entry === 'string' && doomed.has(entry)));
+    if (kept.length === record.plugins.length)
+        return null;
+    return { ...record, plugins: kept, updatedAt: now };
+}
+/**
+ * D-UNINSTALL-DROPS-PLUGIN: record a selective uninstall in `<devflowDir>/manifest.json`.
+ *
+ * The manifest is the install record init seeds from (a re-init keeps the prior
+ * selection), so a plugin `devflow uninstall --plugin` removed but the manifest
+ * still lists would come back on the next plain `devflow init`. This is the one
+ * writer that takes a name off that list (atomic temp + rename).
+ *
+ * A quiet no-op, not an error, when there is nothing to record: no manifest (a
+ * pre-manifest install), one that is not valid JSON or not manifest-shaped, or
+ * none of `names` listed — the file is left byte-identical. Never throws: a failed
+ * write comes back as `{ ok: false }` for the caller to report.
+ */
+export async function removeManifestPlugins(devflowDir, names) {
+    const manifestPath = path.join(devflowDir, 'manifest.json');
+    let raw;
+    try {
+        raw = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
+    }
+    catch {
+        // ENOENT, EACCES or SyntaxError — no usable manifest, so nothing to record.
+        return { ok: true, removed: [] };
+    }
+    const next = withoutManifestPlugins(raw, names, new Date().toISOString());
+    if (next === null)
+        return { ok: true, removed: [] };
+    try {
+        await writeFileAtomicExclusive(manifestPath, JSON.stringify(next, null, 2) + '\n');
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    const doomed = new Set(names);
+    const before = raw.plugins;
+    return { ok: true, removed: before.filter((entry) => typeof entry === 'string' && doomed.has(entry)) };
+}
 /**
  * Merge new plugins into existing plugin list (union, no duplicates).
  * Preserves order: existing plugins first, then new ones appended.

package/dist/core/mds-variants.js

@@ -120,6 +120,13 @@ export function validateContractOutputName(name) {
  * from here keeps the table below the only place a destination is spelled.
  */
 export const AGENTS_OUTPUT_DIR = 'dist/agents';
+/**
+ * Repo-relative destination for `commands` hosts.
+ *
+ * Exported for the same reason as AGENTS_OUTPUT_DIR: the orphan prune names the
+ * directory even when no command host is planned.
+ */
+export const COMMANDS_OUTPUT_DIR = 'dist/commands';
 /**
  * The bare (unprefixed) skill that OWNS the generated references.
  *
@@ -153,7 +160,7 @@ export const SKILL_REFS_SKILL_NAME = 'git';
  */
 export const SKILL_REFS_OUTPUT_DIR = `dist/skills/${SKILL_REFS_SKILL_NAME}/references`;
 const ALLOWED_OUTPUT_DIRS = [
-    { dir: 'dist/commands', variant: 'commands' },
+    { dir: COMMANDS_OUTPUT_DIR, variant: 'commands' },
     { dir: AGENTS_OUTPUT_DIR, variant: 'agents' },
     { dir: SKILL_REFS_OUTPUT_DIR, variant: 'skill-refs' },
 ];
@@ -363,6 +370,30 @@ export const GIT_CROSS_CUTTING_DOCS = [
  * Registering a provider whose `subdir` is one of MCP_BACKED_PROVIDER_SUBDIRS is
  * also what opens the generation gate on the tool-call contract; see
  * {@link mcpContractIsGenerated}. There is no second edit and no flag.
+ *
+ * D-TRACKER-CONTRACT-ON-DEMAND. The last entry, `_contract.mds`, is the first
+ * UNGATED `kind: 'contract'` module (the tool-call contract of
+ * {@link MCP_CONTRACT_MODULE} is gated, so it is not in this array). It emits
+ * `tracker/_contract.md`: the provider resolution and the tracker input contract
+ * that used to sit in the always-loaded Git agent, where every spawn paid for
+ * them although most spawns run a PR-host operation that never touches the
+ * issue tracker. A spawn now reads the file once, only when it runs a tracker
+ * operation, before its first tracker step. The agent's retained
+ * `## Loading the mechanics` section is the one line that names it; it keeps
+ * the PR-mechanics load rule and the merged step order, which a PR-only spawn
+ * needs and which this file cannot instruct a spawn to load. It is ungated for
+ * the reason the registry's other provider-independent files are: every install
+ * carries every provider, GitHub included, so no registered provider is the
+ * condition it depends on.
+ *
+ * The budget clause: the file is a per-SPAWN term of each tracker row (GitHub,
+ * Jira, Linear), charged the way the tool-call contract is (`contractTerm` in
+ * tests/tracker/budget-model.ts) and added in `providerLoadedSet`. It is not part
+ * of `ownLoadForProvider`, of the PR-host row or of the per-operation PR-host
+ * cap. ensure-pr-ready is both a PR-host and a tracker operation, so charging it
+ * the contract there would put it over a lower-only cap; its full cost,
+ * contract included, is priced through the tracker rows, where it is already a
+ * candidate.
  */
 export const VARIANT_MODULES = [
     {
@@ -395,6 +426,12 @@ export const VARIANT_MODULES = [
         kind: 'named',
         ops: GIT_CROSS_CUTTING_DOCS,
     },
+    {
+        source: 'src/assets/mds/tracker/_contract.mds',
+        subdir: 'tracker',
+        kind: 'contract',
+        ops: ['_contract'],
+    },
 ];
 // ---------------------------------------------------------------------------
 // The tool-call contract module, and the gate on its generation

package/dist/core/plugins.js

@@ -64,7 +64,13 @@ export const DEVFLOW_PLUGINS = [
             'security',
             'worktree-support',
         ],
-        rules: ['security', 'engineering', 'quality', 'reliability'],
+        // D-CONTEXT-ECONOMY-RULE: reading discipline is a core rule, not a skill, because it
+        // must reach every session and every spawned agent without an activation step. It
+        // tells the model to list a large file's headings and read ranges, and to count
+        // search matches before printing them. Its body stays near 400 characters (ceiling
+        // 450) and names no search binary, since the rule is loaded into every session;
+        // tests/rules.test.ts enforces the length, the directives and this registration.
+        rules: ['security', 'engineering', 'quality', 'reliability', 'context-economy'],
     },
     {
         name: 'devflow-plan',
@@ -244,7 +250,10 @@ export const DEVFLOW_PLUGINS = [
         commands: ['/release'],
         agents: ['git', 'validate'],
         skills: ['git', 'worktree-support'],
-        requires: ['testing'],
+        // D-PRELOAD-TRIM: nothing in this plugin's corpus reads `testing` (Validate
+        // preloads only `worktree-support`), so the closure guard's reverse arm holds
+        // this list empty.
+        requires: [],
         rules: [],
     },
     {
@@ -253,7 +262,9 @@ export const DEVFLOW_PLUGINS = [
         commands: ['/self-review'],
         agents: ['simplify', 'scrutinize', 'validate', 'knowledge'],
         skills: ['quality-gates', 'software-design', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
-        requires: ['apply-decisions', 'testing'],
+        // D-PRELOAD-TRIM: no agent, command or skill in this plugin's corpus names
+        // `testing` (Validate preloads only `worktree-support`), so it is not required here.
+        requires: ['apply-decisions'],
         rules: [],
     },
     {
@@ -490,19 +501,52 @@ export const FEATURE_OWNED_SKILLS = ['compliance'];
  * (guarded by plugins.test.ts FEATURE_OWNED constants describe block).
  */
 export const FEATURE_OWNED_RULES = ['compliance'];
+/**
+ * Skills a learning-off machine does not install.
+ *
+ * D-LEARNING-VARIANT-INSTALL: the learning-off variants of the commands and
+ * agents (D-LEARNING-VARIANTS) carry no decisions text and preload no
+ * apply-decisions, so the skill has no reader on a machine with learning off. It
+ * stays OWNED and REQUIRED by its plugins in the registry — the closure guard
+ * reasons over the learning-on variant, the superset — and the install drops it
+ * on top of the selection: `installViaFileCopy` skips it when `learning` is false
+ * and `convergeLearningVariants` installs or removes it when the switch flips.
+ *
+ * This is a machine-switch condition, not a deselection: the plan
+ * ({@link resolveSkillInstallPlan}) is untouched, so a learning-off machine never
+ * reports the skill as "removed because no selected plugin requires it" nor its
+ * shadow as inactive for a plugin that is not selected.
+ *
+ * Used by:
+ *   - installer.ts installViaFileCopy: omits these from the install loop when learning is off
+ *   - learning-install.ts convergeLearningVariants: installs or removes the directory
+ *   - tests: independent literal ['apply-decisions'] (avoids the EXCLUDED-as-oracle trap)
+ */
+export const LEARNING_GATED_SKILLS = ['apply-decisions'];
+/**
+ * A skills map with the learning-gated skills left out when learning is off.
+ *
+ * Pure: the same map instance comes back when learning is on, a copy otherwise.
+ */
+export function omitLearningGatedSkills(skillsMap, learning) {
+    if (learning)
+        return skillsMap;
+    const gated = LEARNING_GATED_SKILLS;
+    return new Map([...skillsMap].filter(([skill]) => !gated.includes(skill)));
+}
 // ── Skill-closure boundaries ──────────────────────────────────────────────────
 /**
  * Skills that are REFERENCED but never REQUIRED — the presence-gated set.
  *
  * D-PRESENCE-GATED: every language/ecosystem skill ships with an optional,
  * command-less plugin, so a reference to one is a reference to something the
- * user may deliberately not have. The referencing prompts are written to probe
- * first and proceed without it — `/code-review` checks
- * `skills/devflow:{focus}/SKILL.md` under Claude Code's directory (`CLAUDE_CONFIG_DIR`
- * when absolute, else `~/.claude` — D-CLAUDE-DIR-PROMPTS) before spawning that focus, the
- * Review and Code agents continue when the Skill invocation fails. Putting them
- * in a `requires` would reinstate the universal install for exactly the eight
- * skills the selection prompt exists to let a user decline (AC-25).
+ * user may deliberately not have. The referencing prompts are written to
+ * proceed without it: `/code-review` spawns a language focus only when the
+ * installer stamped it into the command (D-LANGUAGE-FOCUS-STAMP,
+ * {@link installedLanguageFocuses}), and the Review and Code agents continue
+ * when the Skill invocation fails. Putting them in a `requires` would reinstate
+ * the universal install for exactly the eight skills the selection prompt
+ * exists to let a user decline (AC-25).
  *
  * DERIVED from the registry rather than hand-listed: a ninth language plugin is
  * presence-gated by being declared, with no second roster to remember. Guarded
@@ -540,7 +584,7 @@ export const TEMPLATE_SKILL_REFS = [
     },
     {
         literal: 'devflow:{FOCUS}',
-        site: 'src/assets/agents/review.md (the Review agent loading its own focus skill)',
+        site: 'src/assets/agents/review.mds (the Review agent loading its own focus skill)',
         why: 'receiving half of the same substitution — the agent is told which focus it is, not which skill exists',
     },
 ];
@@ -728,6 +772,29 @@ export function buildScopedSkillsMap(plugins) {
     }
     return skillsMap;
 }
+/**
+ * The language focuses an install selection makes available — the list the
+ * installer stamps into the installed /code-review command.
+ *
+ * D-LANGUAGE-FOCUS-STAMP: the language gate moved from a run-time `test -f`
+ * probe of Claude Code's directory to this list, computed once at install time.
+ * Pure plumbing and nothing more: the registry's {@link PRESENCE_GATED_SKILLS}
+ * filtered to the skills the selection's closure installs
+ * ({@link buildScopedSkillsMap}), in registry order. Which focuses a diff gets
+ * stays a prompt rule that the orchestrator executes; no code here, or anywhere
+ * in the installer, classifies a diff or chooses a focus.
+ *
+ * The selection is the EFFECTIVE one (`FileCopyOptions.effectivePlugins`), never
+ * the plugins one run copies: `--plugin=X` installs X alone while the machine's
+ * selection is the manifest's plugins plus X, and the stamp has to describe what
+ * is on disk. Selective uninstall passes the plugins that remain.
+ *
+ * @param effectivePlugins - The plugins whose skill closure is, or stays, installed.
+ */
+export function installedLanguageFocuses(effectivePlugins) {
+    const installed = buildScopedSkillsMap(effectivePlugins);
+    return PRESENCE_GATED_SKILLS.filter(skill => installed.has(skill));
+}
 /**
  * Build a skills map over the WHOLE registry.
  *