devflow-kit 3.4.0 → 3.6.0

package/dist/core/mds-variants.js

@@ -271,32 +271,38 @@ export const TRACKER_OPS = [
  */
 export const TRACKER_GITHUB_OPS = TRACKER_OPS;
 /**
- * The 9 PR/review operations whose mechanics are generated once, for every
+ * The 8 PR/review operations whose references are generated once, for every
  * provider, under `pr/`.
  *
  * A PR-HOST roster, not a tracker roster, and the distinction is the whole
  * reason this list exists separately from {@link TRACKER_OPS}: pull requests, PR
  * reviews and PR checks stay on GitHub under every issue-tracker provider, so
- * these steps are the SAME file whatever `TRACKER_PROVIDER` resolves to. Filing
- * them under `tracker/github/` would make a jira user's PR mechanics read as
- * their tracker's, and fanning them across the three provider directories would
- * ship three identical trees.
- *
- * `ensure-pr-ready` is a member of BOTH rosters by design, and the two halves do
- * not overlap: the PR skeleton (branch/commit/push, create, retitle, and step
- * 4b's open-PR lookup and body edit) is a PR-host fact and lives here; step 4b
- * itself — the issue-number lookup and the link line it renders — is a tracker
- * fact and lives in `tracker/{provider}/ensure-pr-ready.md`. The operation
- * carries one pointer to each.
- *
- * 9 entries, one above {@link MIN_VARIANT_PAIRS}, which is a floor and not a
+ * these operations are the SAME file whatever `TRACKER_PROVIDER` resolves to.
+ * Filing them under `tracker/github/` would make a jira user's PR mechanics read
+ * as their tracker's, and fanning them across the three provider directories
+ * would ship three identical trees.
+ *
+ * D-OP-ONE-REF. Each file is the WHOLE operation: its contract (description,
+ * `**Input:**`, degradation notes, `**Output:**` template, written once in
+ * `src/assets/mds/git/_ops.mds`) and then its steps. The operation loads this one
+ * file and no other operation reference.
+ *
+ * `ensure-pr-ready` is deliberately NOT a member. It is a tracker operation: step
+ * 4b, the issue-number lookup and the link line it renders, is a tracker fact and
+ * differs per provider, so the operation is one file per provider under
+ * `tracker/{provider}/ensure-pr-ready.md`. That file carries the PR skeleton
+ * (branch/commit/push, create, retitle, and step 4b's open-PR lookup and body edit)
+ * as well, written once in `_ops.mds` and expanded into all three, so the PR-host
+ * half is the same bytes under every provider and the operation still loads one
+ * file.
+ *
+ * 8 entries, exactly {@link MIN_VARIANT_PAIRS}, which is a floor and not a
  * target: a shorter roster makes every parity assertion over it vacuous (GAP-42)
- * and `expandVariants` refuses the build, so the roster can grow
- * but never drop below 8. `update-pr-evidence` (#363) is the ninth — it edits the
- * PR body and comments on the PR, both GitHub whatever the tracker is.
+ * and `expandVariants` refuses the build, so the roster can grow but never drop
+ * below 8. `update-pr-evidence` (#363) is the newest member: it edits the PR body
+ * and comments on the PR, both GitHub whatever the tracker is.
  */
 export const PR_HOST_OPS = [
-    'ensure-pr-ready',
     'validate-branch',
     'post-review-summary',
     'check-ci-status',
@@ -354,6 +360,44 @@ export const GIT_CROSS_CUTTING_DOCS = [
     'publication-gate',
     'trust-rule',
 ];
+/**
+ * The Git operations whose one operation reference is a cross-cutting document
+ * rather than a per-op file in `pr/` or `tracker/{provider}/` (D-OP-ONE-REF).
+ *
+ * `learn-conventions` is the only one: it has no PR-host half and no provider half,
+ * so its reference is the named document {@link GIT_CROSS_CUTTING_DOCS} already emits
+ * at the references root. Its contract is compiled into that document like every
+ * other operation's (D-OP-CONTRACT-ONCE).
+ */
+export const DOC_BACKED_OPS = ['learn-conventions'];
+/**
+ * Every operation the Git agent routes, derived from the three rosters that emit its
+ * reference — never retyped. Each one loads exactly one operation reference
+ * ({@link operationReferenceRel}).
+ */
+export const GIT_OPERATIONS = [...PR_HOST_OPS, ...TRACKER_OPS, ...DOC_BACKED_OPS];
+/**
+ * The skill-relative path (under `references/`) of the one reference an operation
+ * loads, or `null` for a name that is not a Git operation.
+ *
+ * D-OP-ONE-REF. A PR-host operation is `pr/{op}.md`, the same file under every
+ * provider; a tracker operation is `tracker/{provider}/{op}.md` for the resolved
+ * provider; a doc-backed operation is its named document. The Git agent's
+ * `## Loading the mechanics` table states these paths in prose, and
+ * `tests/tracker/reference-reachability.test.ts` holds the table to this function.
+ *
+ * Total and pure: an unknown operation is `null`, never a throw. `ensure-pr-ready` is
+ * a tracker operation, so it resolves per provider even though its PR half is shared.
+ */
+export function operationReferenceRel(op, provider) {
+    if (TRACKER_OPS.includes(op))
+        return `${TRACKER_DESTINATION_ROOT}/${provider}/${op}.md`;
+    if (PR_HOST_OPS.includes(op))
+        return `${PR_HOST_DESTINATION_ROOT}/${op}.md`;
+    if (DOC_BACKED_OPS.includes(op))
+        return `${op}.md`;
+    return null;
+}
 /**
  * Every reference module the build knows about — a closed registry, read the
  * same way ALLOWED_OUTPUT_DIRS is read.
@@ -378,9 +422,9 @@ export const GIT_CROSS_CUTTING_DOCS = [
  * 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
+ * operation, before its first tracker step. The agent's `## Loading the mechanics`
+ * section is the one line that names it; it keeps the one-reference rule and the
+ * table naming every non-tracker operation's reference, 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
@@ -389,11 +433,9 @@ export const GIT_CROSS_CUTTING_DOCS = [
  * 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.
+ * of `ownLoadForProvider`, of the PR-host row or of the per-operation load cap
+ * (D-OP-LOAD-CAP): the cap prices one operation's own reference, which is the same
+ * whichever tracker row it is read through.
  */
 export const VARIANT_MODULES = [
     {

package/dist/core/migrations.js

@@ -14,6 +14,55 @@ import { writeFileAtomicExclusive } from './fs-atomic.js';
 import { getMemoryDir } from './project-paths.js';
 import { LEGACY_AGENT_KEYS, canonicaliseAgentKeys, parseAgentMappingEnvelope } from './agent-models.js';
 import { migrateLegacyTrackerConventions } from './tracker.js';
+/**
+ * The body of every canonicalise-agent-keys-vN migration: read agent-models.json raw,
+ * apply LEGACY_AGENT_KEYS once, and write the result back atomically when a key changed.
+ * Each migration id passes its own id so that its warnings name it. Idempotent, and a
+ * file with no legacy key is left untouched.
+ */
+function canonicaliseAgentKeysRun(migrationId) {
+    return async (ctx) => {
+        const infos = [];
+        const warnings = [];
+        // Fast path: no legacy keys defined — skip without touching the file.
+        if (Object.keys(LEGACY_AGENT_KEYS).length === 0)
+            return { infos, warnings };
+        const filePath = path.join(ctx.devflowDir, 'agent-models.json');
+        // parseAgentMappingEnvelope handles IO, BOM-strip, JSON parse, and shape validation.
+        // Raw read intentionally avoids readAgentMapping (which would drop unknown fields).
+        const envelope = await parseAgentMappingEnvelope(filePath);
+        if (envelope.kind === 'skip')
+            return { infos, warnings };
+        if (envelope.kind === 'warn') {
+            warnings.push(`${migrationId}: ${envelope.message}`);
+            return { infos, warnings };
+        }
+        const onWarning = (msg) => warnings.push(msg);
+        const { agents: migrated, didMutate, renamed, dropped, guardDropped } = canonicaliseAgentKeys(envelope.rawAgents, onWarning);
+        if (!didMutate)
+            return { infos, warnings };
+        // Write back with the canonical keys, preserving the rest of the envelope.
+        // Idempotent under concurrent execution (no lock needed; see D31 comment above).
+        const updated = { ...envelope.envelope, agents: migrated };
+        try {
+            await writeFileAtomicExclusive(filePath, JSON.stringify(updated, null, 2) + '\n');
+        }
+        catch (err) {
+            warnings.push(`${migrationId}: failed to write ${filePath}: ${err.message}`);
+            return { infos, warnings };
+        }
+        if (renamed.length > 0) {
+            infos.push(`Migrated agent-models.json: renamed ${renamed.map(k => `'${k}' → '${LEGACY_AGENT_KEYS[k]}'`).join(', ')}`);
+        }
+        if (dropped.length > 0) {
+            warnings.push(`${migrationId}: dropped legacy key(s) ${dropped.map(k => `'${k}'`).join(', ')} — the replacement key already holds a value, existing value kept`);
+        }
+        if (guardDropped.length > 0) {
+            warnings.push(`${migrationId}: dropped legacy key(s) ${guardDropped.map(k => `'${k}'`).join(', ')} — skipped due to prototype-pollution guard`);
+        }
+        return { infos, warnings };
+    };
+}
 /**
  * D31: Registry pattern over scattered `if (!applied.includes(...))` conditionals.
  *
@@ -33,9 +82,9 @@ import { migrateLegacyTrackerConventions } from './tracker.js';
  * This was acceptable with an empty MIGRATIONS registry (D37: the vacuous-truth
  * case); this registry's first real entry is added below. Fix deferred.
  *
- * Note how that interacts with `canonicalise-agent-keys-v1`: runGlobalMigration
- * marks a migration applied for ANY non-throwing return, and that entry never
- * throws — it catches every I/O and parse failure and returns it as a *warning*.
+ * Note how that interacts with the `canonicalise-agent-keys-vN` entries: runGlobalMigration
+ * marks a migration applied for ANY non-throwing return, and those entries never
+ * throw — it catches every I/O and parse failure and returns it as a *warning*.
  * So it does NOT hit the unbounded-retry path. It hits the opposite one: a
  * transient EACCES or a failed write records the migration as applied and it
  * never runs again, leaving legacy keys on disk permanently.
@@ -52,47 +101,17 @@ export const MIGRATIONS = [
         id: 'canonicalise-agent-keys-v1',
         description: 'Rename legacy agent keys in ~/.devflow/agent-models.json to their canonical names',
         scope: 'global',
-        async run(ctx) {
-            const infos = [];
-            const warnings = [];
-            // Fast path: no legacy keys defined — skip without touching the file.
-            if (Object.keys(LEGACY_AGENT_KEYS).length === 0)
-                return { infos, warnings };
-            const filePath = path.join(ctx.devflowDir, 'agent-models.json');
-            // parseAgentMappingEnvelope handles IO, BOM-strip, JSON parse, and shape validation.
-            // Raw read intentionally avoids readAgentMapping (which would drop unknown fields).
-            const envelope = await parseAgentMappingEnvelope(filePath);
-            if (envelope.kind === 'skip')
-                return { infos, warnings };
-            if (envelope.kind === 'warn') {
-                warnings.push(`canonicalise-agent-keys-v1: ${envelope.message}`);
-                return { infos, warnings };
-            }
-            const onWarning = (msg) => warnings.push(msg);
-            const { agents: migrated, didMutate, renamed, dropped, guardDropped } = canonicaliseAgentKeys(envelope.rawAgents, onWarning);
-            if (!didMutate)
-                return { infos, warnings };
-            // Write back with the canonical keys, preserving the rest of the envelope.
-            // Idempotent under concurrent execution (no lock needed; see D31 comment above).
-            const updated = { ...envelope.envelope, agents: migrated };
-            try {
-                await writeFileAtomicExclusive(filePath, JSON.stringify(updated, null, 2) + '\n');
-            }
-            catch (err) {
-                warnings.push(`canonicalise-agent-keys-v1: failed to write ${filePath}: ${err.message}`);
-                return { infos, warnings };
-            }
-            if (renamed.length > 0) {
-                infos.push(`Migrated agent-models.json: renamed ${renamed.map(k => `'${k}' → '${LEGACY_AGENT_KEYS[k]}'`).join(', ')}`);
-            }
-            if (dropped.length > 0) {
-                warnings.push(`canonicalise-agent-keys-v1: dropped legacy key(s) ${dropped.map(k => `'${k}'`).join(', ')} — canonical key already present, existing value kept`);
-            }
-            if (guardDropped.length > 0) {
-                warnings.push(`canonicalise-agent-keys-v1: dropped legacy key(s) ${guardDropped.map(k => `'${k}'`).join(', ')} — skipped due to prototype-pollution guard`);
-            }
-            return { infos, warnings };
-        },
+        run: canonicaliseAgentKeysRun('canonicalise-agent-keys-v1'),
+    },
+    {
+        // v1 is already recorded as applied on every machine that upgraded through 2.x, so the
+        // six-agent rename needs an id of its own. Both ids run the same body. On a 1.x machine
+        // v1 runs first and, with the single-hop LEGACY_AGENT_KEYS, already lands every key on its
+        // final slug, so v2 finds nothing to rewrite and makes no write.
+        id: 'canonicalise-agent-keys-v2',
+        description: 'Rename the keys of the six renamed agents in ~/.devflow/agent-models.json to their new names',
+        scope: 'global',
+        run: canonicaliseAgentKeysRun('canonicalise-agent-keys-v2'),
     },
     {
         id: 'tracker-conventions-per-provider-v1',

package/dist/core/plugins.js

@@ -34,7 +34,7 @@ export const DEVFLOW_PLUGINS = [
          *
          * Guard 5 reverse (registry-integrity.test.ts, "declared agents are spawned")
          * skips a plugin whose commands spawn nothing — `if (spawned.size === 0)
-         * continue` — and this plugin ships no commands at all. So `learning` and
+         * continue` — and this plugin ships no commands at all. So `curate` and
          * `tracker`, which are spawned by a SessionStart directive rather than by any
          * command, satisfy the reverse check STRUCTURALLY.
          *
@@ -48,8 +48,17 @@ export const DEVFLOW_PLUGINS = [
          * set-equal, both directions, against the `agentType` values present in
          * dist/commands/, and a hook-spawned agent appears in none of them.
          */
-        agents: ['learning', 'tracker'],
-        skills: ['apply-decisions', 'apply-feature-knowledge', 'software-design', 'docs-framework', 'git', 'boundary-validation', 'test-driven-development', 'testing', 'dependency-research'],
+        agents: ['curate', 'tracker'],
+        /**
+         * D-AGENT-REFS: `agent-references` is a reference-only skill. It holds the Synthesize mode
+         * templates and the Curate maintain step, which those two agents read by explicit path, and
+         * the command branches that D-CMD-REF-HAND moves out of a command (`references/commands/`),
+         * which a command reads by explicit path, so it sits here (core-skills is always installed)
+         * and no other plugin lists or requires it.
+         * It is never preloaded: tests/guards/agent-references.test.ts holds that, and the one
+         * exception to the repo-wide ban on `disable-model-invocation` names this skill alone.
+         */
+        skills: ['apply-decisions', 'apply-feature-knowledge', 'software-design', 'docs-framework', 'git', 'boundary-validation', 'test-driven-development', 'testing', 'dependency-research', 'agent-references'],
         requires: [
             'architecture',
             'complexity',
@@ -76,28 +85,18 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-plan',
         description: 'Unified design planning with gap analysis and design review',
         commands: ['/plan'],
-        agents: ['git', 'skim', 'synthesize', 'design'],
+        agents: ['git', 'skim', 'synthesize', 'design', 'explore'],
         skills: ['gap-analysis', 'design-review', 'patterns', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
         // D-CHARTER-BOUNDED-INLINE: /plan's main thread orchestrates and loads no
         // companion skills, so `requires:` lists only skills this plugin's command,
         // agents and skills reference. `software-design` and `test-driven-development`
         // have no reader here; the closure guard's reverse arm rejects an unread entry.
+        // `docs-framework` is read: Phase 14 loads it at the step that names the
+        // design document (D-DOCS-NAMES-AUTHORITY).
         requires: [
             'apply-decisions',
-            'architecture',
-            'complexity',
-            'consistency',
-            'database',
-            'dependencies',
             'docs-framework',
-            'documentation',
             'git',
-            'performance',
-            'regression',
-            'reliability',
-            'review-methodology',
-            'security',
-            'testing',
         ],
         rules: [],
     },
@@ -105,17 +104,15 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-implement',
         description: 'Complete task implementation workflow - accepts plan documents, issues, or task descriptions',
         commands: ['/implement'],
-        agents: ['git', 'code', 'simplify', 'scrutinize', 'evaluate', 'test', 'validate', 'knowledge'],
+        agents: ['git', 'code', 'fix', 'polish', 'harden', 'evaluate', 'test', 'validate', 'knowledge'],
         skills: ['patterns', 'qa', 'quality-gates', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
         requires: [
             'apply-decisions',
             'architecture',
-            'boundary-validation',
             'complexity',
             'consistency',
             'database',
             'dependencies',
-            'dependency-research',
             'documentation',
             'git',
             'performance',
@@ -139,23 +136,21 @@ export const DEVFLOW_PLUGINS = [
         // no companion skills, so `requires:` lists only skills this plugin's command,
         // agents and skills reference. `quality-gates` and `software-design` have no
         // reader here; the closure guard's reverse arm rejects an unread entry.
-        requires: ['apply-decisions', 'docs-framework', 'git'],
+        requires: ['apply-decisions', 'git'],
         rules: [],
     },
     {
         name: 'devflow-resolve',
         description: 'Process and fix code review issues with blast-radius triage, Code agent fixes, and Validate agent verification',
         commands: ['/resolve'],
-        agents: ['git', 'triage', 'code', 'simplify', 'validate', 'test', 'knowledge'],
-        skills: ['patterns', 'security', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge', 'apply-decisions'],
+        agents: ['git', 'triage', 'code', 'fix', 'polish', 'validate', 'test', 'knowledge'],
+        skills: ['patterns', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge', 'apply-decisions'],
         requires: [
             'architecture',
-            'boundary-validation',
             'complexity',
             'consistency',
             'database',
             'dependencies',
-            'dependency-research',
             'documentation',
             'git',
             'performance',
@@ -163,6 +158,7 @@ export const DEVFLOW_PLUGINS = [
             'regression',
             'reliability',
             'review-methodology',
+            'security',
             'software-design',
             'test-driven-development',
             'testing',
@@ -173,8 +169,11 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-debug',
         description: 'Debugging workflows with competing hypothesis investigation via parallel subagents',
         commands: ['/debug'],
-        agents: ['git', 'synthesize', 'simplify', 'knowledge'],
+        agents: ['git', 'synthesize', 'polish', 'knowledge', 'explore', 'code'],
         skills: ['git', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
+        // D-DEBUG-FIX-VIA-CODE: the fix is a Code spawn. Code loads no skill by language or mode
+        // (D-NO-RUNTIME-SKILLS), so `requires:` lists only the skills this command, its agents and the
+        // skills they preload reference; the closure guard rejects an entry nothing reads.
         requires: [
             'apply-decisions',
             'architecture',
@@ -182,9 +181,7 @@ export const DEVFLOW_PLUGINS = [
             'consistency',
             'database',
             'dependencies',
-            'docs-framework',
             'documentation',
-            'patterns',
             'performance',
             'regression',
             'reliability',
@@ -200,23 +197,12 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-explore',
         description: 'Codebase exploration with structured analysis and optional knowledge base creation',
         commands: ['/explore'],
-        agents: ['skim', 'synthesize', 'knowledge'],
+        // 'explore' is devflow's override of Claude Code's built-in Explore agent, spawned by
+        // type name (D-EXPLORE-OVERRIDE and D-EXPLORE-NO-CLOBBER, targets/claude-code/agent-type-owner.ts).
+        agents: ['skim', 'synthesize', 'knowledge', 'explore'],
         skills: ['worktree-support', 'apply-feature-knowledge', 'feature-knowledge'],
         requires: [
             'apply-decisions',
-            'architecture',
-            'complexity',
-            'consistency',
-            'database',
-            'dependencies',
-            'docs-framework',
-            'documentation',
-            'performance',
-            'regression',
-            'reliability',
-            'review-methodology',
-            'security',
-            'testing',
         ],
         rules: [],
     },
@@ -226,21 +212,11 @@ export const DEVFLOW_PLUGINS = [
         commands: ['/research'],
         agents: ['research', 'skim', 'synthesize', 'knowledge'],
         skills: ['worktree-support', 'apply-feature-knowledge', 'feature-knowledge', 'research-codebase', 'research-external', 'research-market', 'research-competitor', 'research-technology'],
+        // `docs-framework` is read: Phase 2 loads it at the step that names the
+        // research directory (D-DOCS-NAMES-AUTHORITY).
         requires: [
             'apply-decisions',
-            'architecture',
-            'complexity',
-            'consistency',
-            'database',
-            'dependencies',
             'docs-framework',
-            'documentation',
-            'performance',
-            'regression',
-            'reliability',
-            'review-methodology',
-            'security',
-            'testing',
         ],
         rules: [],
     },
@@ -258,9 +234,9 @@ export const DEVFLOW_PLUGINS = [
     },
     {
         name: 'devflow-self-review',
-        description: 'Self-review workflow: Simplify agent + Scrutinize agent for code quality',
+        description: 'Self-review workflow: Polish agent + Harden agent for code quality',
         commands: ['/self-review'],
-        agents: ['simplify', 'scrutinize', 'validate', 'knowledge'],
+        agents: ['polish', 'harden', 'validate', 'knowledge'],
         skills: ['quality-gates', 'software-design', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
         // 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.
@@ -271,7 +247,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-bug-analysis',
         description: 'Proactive bug finding with static and semantic analysis',
         commands: ['/bug-analysis'],
-        agents: ['git', 'diagnose', 'synthesize'],
+        agents: ['git', 'debug', 'synthesize'],
         skills: [
             'apply-decisions',
             'apply-feature-knowledge',
@@ -286,7 +262,6 @@ export const DEVFLOW_PLUGINS = [
             'architecture',
             'database',
             'dependencies',
-            'docs-framework',
             'documentation',
             'git',
             'performance',
@@ -299,7 +274,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-ambient',
         description: 'Orchestrator ambient mode — session charter, per-prompt reminder, plan handoff',
         commands: [],
-        agents: ['code', 'validate', 'simplify', 'scrutinize', 'evaluate', 'test', 'skim', 'review', 'git', 'synthesize', 'triage', 'design', 'knowledge', 'research', 'learning'],
+        agents: ['code', 'refactor', 'validate', 'polish', 'harden', 'evaluate', 'test', 'skim', 'review', 'git', 'synthesize', 'triage', 'design', 'knowledge', 'research', 'curate', 'explore'],
         skills: [
             'review-methodology',
             'security',
@@ -323,9 +298,6 @@ export const DEVFLOW_PLUGINS = [
         ],
         requires: [
             'apply-decisions',
-            'boundary-validation',
-            'dependency-research',
-            'docs-framework',
             'git',
             'quality-gates',
             'research-codebase',
@@ -343,22 +315,19 @@ export const DEVFLOW_PLUGINS = [
         description: 'Dynamic workflow recipes - dependency-aware tickets→plan→build delivery pipeline',
         // Commands compiled from commands/*.mds at build time (build:mds).
         commands: ['/dynamic-tickets', '/dynamic-plan', '/dynamic-build', '/dynamic-profile'],
-        agents: ['code', 'validate', 'simplify', 'scrutinize', 'evaluate', 'test', 'review', 'git', 'synthesize', 'knowledge', 'design'],
+        agents: ['code', 'fix', 'validate', 'polish', 'harden', 'evaluate', 'test', 'review', 'git', 'synthesize', 'knowledge', 'design'],
         skills: ['apply-decisions', 'apply-feature-knowledge', 'worktree-support', 'docs-framework'],
         requires: [
             'architecture',
-            'boundary-validation',
             'complexity',
             'consistency',
             'database',
             'dependencies',
-            'dependency-research',
             'design-review',
             'documentation',
             'feature-knowledge',
             'gap-analysis',
             'git',
-            'patterns',
             'performance',
             'qa',
             'quality-gates',
@@ -491,16 +460,26 @@ export const FEATURE_OWNED_SKILLS = ['compliance'];
 /**
  * Rules owned by the feature system — not any plugin in DEVFLOW_PLUGINS.
  * The compliance rule (src/assets/rules/compliance.md) is stamped and installed
- * by convergeComplianceArtifacts, not by the plugin installer.
+ * by convergeComplianceArtifacts, not by the plugin installer. The behavior rule
+ * (src/assets/rules/behavior.md) is installed and removed by convergeBehaviorRule.
+ *
+ * D-BEHAVIOR-OPT-IN: the behavior rule is OPT-IN and default off. How agents reply and
+ * act is a taste, so no install carries it until the user asks: `features.behavior` in
+ * the machine manifest (`devflow init --behavior`, `devflow behavior --enable`). That is
+ * why it sits here and in no plugin's `rules` array: a plugin's rules install for every
+ * install that selects the plugin, with no switch, and the core plugin is always
+ * selected. The rule is one bullet per behavior and stays small, because every session
+ * and every subagent that loads the rules pays for it; tests/rules.test.ts pins the
+ * shape, the length and this registration.
  *
  * Used by:
  *   - rules.ts: union into allRules for shadow/unshadow/list
- *   - tests: independent literal ['compliance'] (avoids EXCLUDED-as-oracle trap)
+ *   - tests: independent literal ['compliance', 'behavior'] (avoids EXCLUDED-as-oracle trap)
  *
  * D-FO-2: FEATURE_OWNED_RULES must be disjoint from getAllRuleNames()
  * (guarded by plugins.test.ts FEATURE_OWNED constants describe block).
  */
-export const FEATURE_OWNED_RULES = ['compliance'];
+export const FEATURE_OWNED_RULES = ['compliance', 'behavior'];
 /**
  * Skills a learning-off machine does not install.
  *
@@ -543,8 +522,8 @@ export function omitLearningGatedSkills(skillsMap, learning) {
  * 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
+ * {@link installedLanguageFocuses}), and the Review agent continues 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).
  *

package/dist/core/project-paths.js

@@ -46,7 +46,7 @@ export function getFeatureConfigPath(projectRoot) {
 export function getLearningPendingTurnsPath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', '.pending-turns.jsonl');
 }
-/** .devflow/learning/.pending-turns.processing — the claimed batch a Learning run holds while it processes it */
+/** .devflow/learning/.pending-turns.processing — the claimed batch a Curate run holds while it processes it */
 export function getLearningPendingTurnsProcessingPath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', '.pending-turns.processing');
 }
@@ -65,8 +65,8 @@ export function getDecisionsFilePath(projectRoot) {
 export function getPitfallsFilePath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', 'pitfalls.md');
 }
-/** .devflow/learning/learning.json — project-level learning agent tuning config */
-export function getLearningTuningConfigPath(projectRoot) {
+/** .devflow/learning/learning.json — project-level curate agent tuning config */
+export function getCurateTuningConfigPath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', 'learning.json');
 }
 /** .devflow/learning/decisions-ledger.jsonl — anchored ledger rows (single source of truth for rendering) */
@@ -131,8 +131,4 @@ export function getDesignDir(projectRoot) {
 export function getResearchDir(projectRoot) {
     return path.join(projectRoot, '.devflow', 'docs', 'research');
 }
-/** .devflow/docs/handoff-{branchSlug}.md — Code agent phase handoff artifact */
-export function getHandoffPath(projectRoot, branchSlug) {
-    return path.join(projectRoot, '.devflow', 'docs', `handoff-${branchSlug}.md`);
-}
 //# sourceMappingURL=project-paths.js.map

package/dist/core/proxy-log.js

@@ -34,7 +34,7 @@ export const PROXY_LOG_TAIL_BYTES = 1_048_576;
  * XDG_CONFIG_HOME (user-config lookup, reached only on an implicit config load —
  * see D-EFR-6 in model-discovery.ts). CI is read only by `init`; CODEX_HOME and
  * CLAUDE_CONFIG_DIR only by the Codex ingress, `init` and the Codex doctor, none of
- * which devflow enables or invokes. Verified by whole-dist grep of the 0.5.0
+ * which devflow enables or invokes. Verified by whole-dist grep of the 0.6.0
  * package. An allowlist is the correct shape: 61 inherited vars → 6.
  *
  * HOME is retained: the runtime's loadConfig resolves ~ paths via homedir().

package/dist/core/proxy-state.js

@@ -91,7 +91,7 @@ export async function writeProxyState(devflowDir, state) {
  * Top-level keys devflow carries into the routing config. Unknown top-level keys
  * cause a hard relay startup error — never emit them.
  *
- * @D-EFR-4 Subswitch 0.5.0 routing config contract:
+ * @D-EFR-4 Subswitch 0.6.0 routing config contract:
  *   FileConfigSchema is a z.strictObject with exactly 6 accepted top-level keys:
  *   port, logLevel, anthropic, providers, limits, codexIngress. Unknown keys cause a
  *   hard startup error — the relay refuses to start. anthropic and limits are