devflow-kit 3.1.0 → 3.3.0

package/dist/cli/commands/agents.js

@@ -14,14 +14,19 @@
  *   devflow agents --list    → tabular list (safe in non-TTY)
  *   devflow agents --set <agent> --model <m> --effort <e>
  *   devflow agents --reset [--yes]
+ *
+ * D-WORKER-AGENTS: `memory` is a background worker, not an agent, and is
+ * settable here as `--set memory` and as a row after the agents in `--list` and
+ * the TUI. Its state is always 'worker'; its values are held to the worker
+ * domain (Claude models and effort levels only) by validateWorkerValue.
  */
 import { Command } from 'commander';
 import * as path from 'path';
 import * as p from '@clack/prompts';
 import color from 'picocolors';
-import { EFFORT_LEVELS, LEGACY_AGENT_KEYS, readAgentMapping, saveAgentMapping, reapplyAgentMapping, loadShippedDefaults, readInstalledAgentNames, } from '../../core/agent-models.js';
+import { EFFORT_INHERIT, EFFORT_LEVELS, LEGACY_AGENT_KEYS, WORKER_AGENTS, agentOnlyMapping, isEffortLevel, isWorkerAgent, readAgentMapping, saveAgentMapping, reapplyAgentMapping, loadShippedAgentDefaults, readInstalledAgentNames, validateWorkerValue, } from '../../core/agent-models.js';
 import { CLAUDE_MODEL_ALIASES, isDormantExternalModel, } from '../../core/external-models.js';
-import { classifyAgentState, AGENT_STATE_LABELS, } from '../../core/agent-state.js';
+import { classifyAgentState, formatEffortDisplay, AGENT_STATE_LABELS, } from '../../core/agent-state.js';
 import { isValidModelName } from '../../core/agent-frontmatter.js';
 import { isProxyEnabled } from '../../core/proxy-state.js';
 import { getAllAgentNames } from '../../core/plugins.js';
@@ -47,16 +52,28 @@ function Err(error) {
  *   This preserves the configure-first-then-enable provisioning flow and keeps
  *   `--set` at zero subprocess cost (AC-P9: cache-only, 0 spawns).
  *
+ * D-WORKER-AGENTS: when `agentName` is a worker (`memory`), model and effort are
+ * held to the worker value domain instead — validateWorkerValue, the function
+ * readAgentMapping applies on read — with no catalog lookup: a worker runs
+ * outside any session, so an external model, `inherit` as a model and `inherit`
+ * as an effort are all rejected.
+ *
+ * D-SHIPPED-EFFORT: for an agent, `--effort inherit` is accepted. It stores the
+ * sentinel that drops the agent's effort line; `--effort default` deletes the
+ * key so the shipped effort applies again.
+ *
  * Returns Err when:
  *  - neither model nor effort is provided
  *  - model is unknown AND catalog is known
- *  - effort is unknown (not in EFFORT_LEVELS ∪ 'default')
+ *  - effort is unknown (not in EFFORT_LEVELS ∪ 'default' ∪ 'inherit')
+ *  - agentName is a worker and a value is outside the worker domain
  */
-export function validateSetArgs(args, catalog = { known: false }) {
+export function validateSetArgs(args, catalog = { known: false }, agentName) {
     const { model, effort } = args;
     if (model === undefined && effort === undefined) {
         return Err('Specify at least one of --model or --effort');
     }
+    const worker = agentName !== undefined && isWorkerAgent(agentName);
     if (model !== undefined) {
         // Charset gate: applied at every trust boundary regardless of catalog state.
         // Rejects injection payloads (newlines, YAML metacharacters) before they can
@@ -66,7 +83,12 @@ export function validateSetArgs(args, catalog = { known: false }) {
             return Err(`Invalid model name "${model}". Model names must start with an alphanumeric character ` +
                 `and contain only alphanumeric, dot, underscore, or hyphen characters (max 64 chars).`);
         }
-        if (catalog.known) {
+        if (worker) {
+            const check = validateWorkerValue('model', model);
+            if (!check.ok)
+                return Err(check.error);
+        }
+        else if (catalog.known) {
             // Full validation against the discovered catalog.
             const valid = ['default', ...CLAUDE_MODEL_ALIASES, ...catalog.selectableNames];
             if (!valid.includes(model)) {
@@ -77,9 +99,16 @@ export function validateSetArgs(args, catalog = { known: false }) {
         // warning fires at agents.ts call site if the proxy is off.
     }
     if (effort !== undefined) {
-        const valid = ['default', ...EFFORT_LEVELS];
-        if (!valid.includes(effort)) {
-            return Err(`Unknown effort "${effort}". Valid: ${valid.join(', ')}`);
+        if (worker) {
+            const check = validateWorkerValue('effort', effort);
+            if (!check.ok)
+                return Err(check.error);
+        }
+        else {
+            const valid = ['default', ...EFFORT_LEVELS, EFFORT_INHERIT];
+            if (!valid.includes(effort)) {
+                return Err(`Unknown effort "${effort}". Valid: ${valid.join(', ')}`);
+            }
         }
     }
     return Ok(args);
@@ -106,10 +135,9 @@ export function applySetMapping(mapping, agentName, args) {
         if (args.effort === 'default') {
             delete existing.effort;
         }
-        else {
-            // Sound narrowing: validateSetArgs already confirmed args.effort is a valid
-            // EffortLevel before this function is called. SetArgs.effort is string to keep
-            // the CLI entry type permissive; the assertion here is not a compensating cast.
+        else if (isEffortLevel(args.effort) || args.effort === EFFORT_INHERIT) {
+            // SetArgs.effort is a string to keep the CLI entry type permissive;
+            // validateSetArgs has already confirmed it is a level or the inherit sentinel.
             existing.effort = args.effort;
         }
     }
@@ -133,23 +161,62 @@ export async function buildListRows(input) {
         const entry = mapping.agents[name];
         const configured = entry?.model ?? 'default';
         const effort = entry?.effort ?? 'default';
-        const defaultModel = shippedDefaults[name] ?? 'unknown';
+        const defaultModel = shippedDefaults[name]?.model ?? 'unknown';
+        const shippedEffort = shippedDefaults[name]?.effort;
         const installed = installedNames.has(name);
         // inRegistry is always true here — agentNames comes from the registry.
         const state = classifyAgentState({ configured, proxyEnabled, installed, inRegistry: true });
-        return { name, defaultModel, configured, effort, state };
+        return { name, defaultModel, configured, effort, shippedEffort, state };
     });
     return rows;
 }
+/**
+ * Build the list rows of the background workers (D-WORKER-AGENTS), which follow
+ * the agent rows in `--list`.
+ *
+ * A worker has no installed agent file, so its row never consults the install
+ * directory: its state is always 'worker', never classified (it can be neither
+ * not installed nor dormant — validateSetArgs rejects an external model for a
+ * worker). DEFAULT is the model WORKER_AGENTS ships and EFFORT shows the shipped
+ * effort while unconfigured, the same convention as an agent row.
+ *
+ * Pure function, no I/O.
+ */
+export function buildWorkerListRows(mapping) {
+    return Object.entries(WORKER_AGENTS).map(([name, shipped]) => {
+        const entry = mapping.agents[name];
+        return {
+            name,
+            defaultModel: shipped.model,
+            configured: entry?.model ?? 'default',
+            effort: entry?.effort ?? 'default',
+            shippedEffort: shipped.effort,
+            state: 'worker',
+        };
+    });
+}
 // ---------------------------------------------------------------------------
 // --list output formatting
 // ---------------------------------------------------------------------------
+/**
+ * Width of the EFFORT column: the longest `default (<level>)` an unconfigured row
+ * can show, derived from EFFORT_LEVELS so a new level cannot truncate the cell.
+ */
+const EFFORT_COLUMN_WIDTH = Math.max(...EFFORT_LEVELS.map(level => formatEffortDisplay('default', level).length), EFFORT_INHERIT.length);
+/** Narrowest the DEFAULT column of `--list` renders; it widens to fit a longer shipped default. */
+const DEFAULT_COLUMN_MIN_WIDTH = 10;
+/** Narrowest the CONFIGURED column of `--list` renders; it widens to fit a longer configured model. */
+const CONFIGURED_COLUMN_MIN_WIDTH = 16;
 export function formatListOutput(rows, proxyEnabled) {
     const lines = [];
     const AGENT_W = 20;
-    const DEFAULT_W = 10;
-    const CONFIGURED_W = 16;
-    const EFFORT_W = 12;
+    // DEFAULT and CONFIGURED grow to the longest value in their column, so a full
+    // model identifier (the memory worker ships claude-sonnet-5-5; a user maps
+    // claude-sonnet-4-6) is shown whole, not cut to a fixed width and read as a
+    // different model.
+    const DEFAULT_W = Math.max(DEFAULT_COLUMN_MIN_WIDTH, ...rows.map(row => stripAnsi(row.defaultModel).length));
+    const CONFIGURED_W = Math.max(CONFIGURED_COLUMN_MIN_WIDTH, ...rows.map(row => stripAnsi(row.configured).length));
+    const EFFORT_W = EFFORT_COLUMN_WIDTH;
     // Header
     lines.push([
         color.gray('AGENT'.padEnd(AGENT_W)),
@@ -176,6 +243,9 @@ export function formatListOutput(rows, proxyEnabled) {
             case 'unknown':
                 stateStr = color.dim(AGENT_STATE_LABELS['unknown']);
                 break;
+            case 'worker':
+                stateStr = color.dim(AGENT_STATE_LABELS['worker']);
+                break;
             default: {
                 const _ = row.state;
                 void _;
@@ -188,15 +258,18 @@ export function formatListOutput(rows, proxyEnabled) {
             stripAnsi(row.name).padEnd(AGENT_W).slice(0, AGENT_W),
             stripAnsi(row.defaultModel).padEnd(DEFAULT_W).slice(0, DEFAULT_W),
             stripAnsi(row.configured).padEnd(CONFIGURED_W).slice(0, CONFIGURED_W),
-            stripAnsi(row.effort).padEnd(EFFORT_W).slice(0, EFFORT_W),
+            stripAnsi(formatEffortDisplay(row.effort, row.shippedEffort)).padEnd(EFFORT_W).slice(0, EFFORT_W),
             stateStr,
         ].join('  '));
     }
-    const installed = rows.filter(r => r.state !== 'not-installed').length;
-    const configured = rows.filter(r => r.configured !== 'default' || r.effort !== 'default').length;
+    // The footer counts agent rows only: a worker row is neither installed nor
+    // not installed, and configuring it changes no agent (D-WORKER-AGENTS).
+    const agentRows = rows.filter(r => r.state !== 'worker');
+    const installed = agentRows.filter(r => r.state !== 'not-installed').length;
+    const configured = agentRows.filter(r => r.configured !== 'default' || r.effort !== 'default').length;
     const proxyLabel = proxyEnabled ? color.green('enabled') : color.yellow('disabled');
     lines.push('');
-    lines.push(`${installed}/${rows.length} installed · ${configured} configured · proxy: ${proxyLabel}`);
+    lines.push(`${installed}/${agentRows.length} installed · ${configured} configured · proxy: ${proxyLabel}`);
     return lines.join('\n');
 }
 // ---------------------------------------------------------------------------
@@ -241,7 +314,8 @@ async function buildTuiState(agentNames, mapping, shippedDefaults, proxyEnabled,
         const entry = mapping.agents[name];
         return buildRow({
             name,
-            shippedDefault: shippedDefaults[name] ?? 'unknown',
+            shippedDefault: shippedDefaults[name]?.model ?? 'unknown',
+            shippedEffort: shippedDefaults[name]?.effort,
             savedModel: entry?.model,
             savedEffort: entry?.effort,
             proxyEnabled,
@@ -251,12 +325,31 @@ async function buildTuiState(agentNames, mapping, shippedDefaults, proxyEnabled,
             inRegistry: true,
         });
     });
-    // Orphan rows: keys in agent-models.json not present in the registry.
+    // Worker rows (D-WORKER-AGENTS) follow the agents. A worker has no installed
+    // file and takes only the worker value domain, so it is built with its own
+    // shipped defaults and never classified as an orphan (state 'unknown').
+    for (const [workerName, shipped] of Object.entries(WORKER_AGENTS)) {
+        const entry = mapping.agents[workerName];
+        rows.push(buildRow({
+            name: workerName,
+            shippedDefault: shipped.model,
+            shippedEffort: shipped.effort,
+            savedModel: entry?.model,
+            savedEffort: entry?.effort,
+            proxyEnabled,
+            installed: false,
+            inRegistry: false,
+            worker: true,
+        }));
+    }
+    // Orphan rows: agent keys in agent-models.json not present in the registry.
     // Appended at the end so they are visually separated from known agents.
-    for (const orphanKey of Object.keys(mapping.agents)) {
+    // agentOnlyMapping leaves out the worker keys, which have their own rows above.
+    const agentEntries = agentOnlyMapping(mapping);
+    for (const orphanKey of Object.keys(agentEntries)) {
         if (registrySet.has(orphanKey))
             continue;
-        const entry = mapping.agents[orphanKey];
+        const entry = agentEntries[orphanKey];
         rows.push(buildRow({
             name: orphanKey,
             shippedDefault: 'unknown',
@@ -352,7 +445,8 @@ export const agentsCommand = new Command('agents')
     .option('--list', 'List all agents with their current configuration')
     .option('--set <agent>', 'Set model/effort for a specific agent')
     .option('--model <model>', 'Model to assign (use with --set)')
-    .option('--effort <level>', 'Effort level to assign (use with --set)')
+    .option('--effort <level>', `Effort level to assign (use with --set): ${EFFORT_LEVELS.join(', ')}, ` +
+    `default (use the shipped effort), or ${EFFORT_INHERIT} (drop the effort line, follow the session)`)
     .option('--reset', 'Clear all agent customisations and restore defaults')
     .option('--yes', 'Skip confirmation prompt (use with --reset)')
     .action(async (options) => {
@@ -376,20 +470,23 @@ export const agentsCommand = new Command('agents')
     // An agent with no shipped default renders a blank DEFAULT column and can
     // never be reverted off an external model; surface the gap rather than
     // letting the table imply the agent simply ships without one.
-    const shippedDefaults = await loadShippedDefaults(undefined, {
+    const shippedDefaults = await loadShippedAgentDefaults(undefined, {
         onWarning: (msg) => p.log.warn(msg),
     });
-    // ── --list ──────────────────────────────────────────────────────────────
-    if (options.list) {
-        const agentNames = getAllAgentNames().sort();
-        const rows = await buildListRows({
-            agentNames,
+    // Agent rows in registry order, then the worker rows (D-WORKER-AGENTS).
+    const loadListRows = async () => {
+        const agentRows = await buildListRows({
+            agentNames: getAllAgentNames().sort(),
             mapping,
             installDir,
             shippedDefaults,
             proxyEnabled,
         });
-        process.stdout.write(formatListOutput(rows, proxyEnabled) + '\n');
+        return [...agentRows, ...buildWorkerListRows(mapping)];
+    };
+    // ── --list ──────────────────────────────────────────────────────────────
+    if (options.list) {
+        process.stdout.write(formatListOutput(await loadListRows(), proxyEnabled) + '\n');
         return;
     }
     // ── --reset ─────────────────────────────────────────────────────────────
@@ -447,10 +544,11 @@ export const agentsCommand = new Command('agents')
             p.log.info(`Agent '${agentName}' has been renamed to '${canonical}' — using canonical name.`);
             agentName = canonical;
         }
-        // Validate agent name
+        // Validate agent name. D-WORKER-AGENTS: the workers are settable too, so a
+        // first `--set memory` is accepted although nothing in the mapping names it yet.
         const knownAgents = getAllAgentNames();
         const knownMapping = Object.keys(mapping.agents);
-        const allKnown = new Set([...knownAgents, ...knownMapping]);
+        const allKnown = new Set([...knownAgents, ...Object.keys(WORKER_AGENTS), ...knownMapping]);
         if (!allKnown.has(agentName)) {
             p.log.error(`Unknown agent "${agentName}". Valid: ${[...allKnown].sort().join(', ')}`);
             process.exitCode = 1;
@@ -461,7 +559,7 @@ export const agentsCommand = new Command('agents')
         // dormancy warning below fires if needed). This preserves the
         // configure-first-then-enable provisioning flow.
         const setCatalog = getExternalModelsCached(cacheDir);
-        const validation = validateSetArgs({ model: options.model, effort: options.effort }, setCatalog);
+        const validation = validateSetArgs({ model: options.model, effort: options.effort }, setCatalog, agentName);
         if (!validation.ok) {
             p.log.error(validation.error);
             process.exitCode = 1;
@@ -510,15 +608,7 @@ export const agentsCommand = new Command('agents')
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
     if (!isInteractive) {
         // Non-TTY: print list and exit 1 with note
-        const agentNames = getAllAgentNames().sort();
-        const rows = await buildListRows({
-            agentNames,
-            mapping,
-            installDir,
-            shippedDefaults,
-            proxyEnabled,
-        });
-        process.stdout.write(formatListOutput(rows, proxyEnabled) + '\n');
+        process.stdout.write(formatListOutput(await loadListRows(), proxyEnabled) + '\n');
         process.stderr.write('Note: interactive view requires a terminal. Use --list for non-TTY output.\n');
         process.exitCode = 1;
         return;

package/dist/cli/commands/init.js

@@ -12,7 +12,7 @@ import { getLedgerRoot } from '../../core/ledger-root.js';
 import { installViaFileCopy, composeScripts } from '../../targets/claude-code/installer.js';
 import { formatOverlaySummary, formatSkillScopeSummary, formatTrackerAssetSummary, isPluginListUnchanged } from './install-report.js';
 import { convergeTrackerArtifacts } from '../../targets/claude-code/tracker-install.js';
-import { installSettings, installManagedSettings, installClaudeignore, discoverProjectGitRoots, ensureDevflowGitignore, applyUserSecurityDenyList, detectDenyState, resolveSecurityAction, assertHistoricalDenySuperset, loadTemplateDenyEntries, stripUserSecurityDenyList, } from '../../targets/claude-code/post-install.js';
+import { installSettings, installManagedSettings, installClaudeignore, hasClaudeignore, discoverProjectGitRoots, ensureDevflowGitignore, applyUserSecurityDenyList, detectDenyState, resolveSecurityAction, assertHistoricalDenySuperset, loadTemplateDenyEntries, stripUserSecurityDenyList, } from '../../targets/claude-code/post-install.js';
 import { DEVFLOW_PLUGINS, LEGACY_COMMAND_NAMES, LEGACY_RULE_NAMES, buildAssetMaps, buildScopedSkillsMap, buildRulesMap, partitionSelectablePlugins, WORKFLOW_ORDER, parsePluginSelection, resolveFeatureRedirect } from '../../core/plugins.js';
 import { LEGACY_SKILL_NAMES } from '../../targets/claude-code/legacy.js';
 import { detectPlatform, detectShell, getProfilePath, getSafeDeleteInfo, hasSafeDelete } from '../../core/safe-delete.js';
@@ -22,7 +22,7 @@ import { convergeMemoryHooks, drainMemoryQueue } from './memory.js';
 import { addCaptureHooks, removeCaptureHooks } from './capture.js';
 import { removeDreamHook } from './legacy-hooks.js';
 import { addProxyHooks, removeProxyHooks, applyProxyEnv, stripProxyEnv, runProxyPreflight, buildRealPreflightDeps } from './proxy.js';
-import { reapplyAgentMapping, readAgentMapping } from '../../core/agent-models.js';
+import { reapplyAgentMapping, readAgentMapping, hasAgentMappingEntries } from '../../core/agent-models.js';
 import { readProxyState, writeProxyState, buildProxyState, buildRoutingConfigJson, DEFAULT_PROXY_PORT, proxyJsonExists } from '../../core/proxy-state.js';
 import { stripDevflowTeammateModeFromJson } from '../../core/teammate-mode-cleanup.js';
 // Settings/HookMatcher types used by hook utilities — each in their own module
@@ -34,6 +34,7 @@ import { addContextHook, removeContextHook, hasContextHook } from './context.js'
 import { writeSettingsFileAtomic } from '../../core/fs-atomic.js';
 import { writeManagedConfig, readConfigIfPresent, DEFAULT_CONFIG } from '../../core/feature-config.js';
 import { drainLearningQueue } from '../../core/learning-queue-cleanup.js';
+import { formatRefusedDrain } from '../../core/queue-drain.js';
 import { removeManagedDenyList, describeManagedDenyRemoval } from './security.js';
 import { resolveInitSeed, applyCliToggles, resolveResetGatedInputs, resolvePluginsToInstall } from './init-seed.js';
 import { parseFrameworkList, normalizeFrameworks } from '../../core/compliance.js';
@@ -55,7 +56,7 @@ import { getPackageRoot } from '../../core/paths.js';
 /**
  * D32/D35: Orchestrates the init-level migration-runner seam.
  *
- * Computes the project list with the D37 fallback rule:
+ * Computes the project list with the D37 fallback rule ({@link projectRoots}):
  *   1. Use discoveredProjects when non-empty.
  *   2. Fall back to [gitRoot] when discoveredProjects is empty and gitRoot is set.
  *   3. Run with no per-project targets when both are absent (global-only; per-project
@@ -70,8 +71,7 @@ import { getPackageRoot } from '../../core/paths.js';
  * this helper testable without real filesystem migration state.
  */
 export async function runMigrationsWithFallback(discoveredProjects, gitRoot, devflowDir, logger, verbose, runner) {
-    const projectsForMigration = discoveredProjects.length > 0 ? discoveredProjects : (gitRoot ? [gitRoot] : []);
-    const migrationResult = await runner({ devflowDir }, projectsForMigration);
+    const migrationResult = await runner({ devflowDir }, projectRoots(discoveredProjects, gitRoot));
     reportMigrationResult(migrationResult, logger, verbose);
     return migrationResult;
 }
@@ -119,6 +119,9 @@ export function formatSweepSummary(report) {
 function logSummaryLines(lines) {
     for (const line of lines) {
         switch (line.level) {
+            case 'success':
+                p.log.success(line.message);
+                break;
             case 'info':
                 p.log.info(line.message);
                 break;
@@ -144,6 +147,81 @@ export function classifySafeDeleteState(installedVersion, currentVersion) {
         return 'outdated';
     return 'missing';
 }
+/**
+ * The project roots init writes per-project files into and migrates (D37): every
+ * project discovered from Claude's history, else the current repository, else
+ * none. Pure.
+ */
+export function projectRoots(discoveredProjects, gitRoot) {
+    if (discoveredProjects.length > 0)
+        return [...discoveredProjects];
+    return gitRoot ? [gitRoot] : [];
+}
+/**
+ * The Recommended summary's `.claudeignore` row.
+ *
+ * D-INIT-REAL-OUTCOME: init's summary and status lines state what this run does,
+ * decided from the state it acts on rather than printed whatever happens, and
+ * point only at a step the user can still take. The summary prints before the
+ * install runs, so this row is decided from whether each targeted project
+ * already holds a `.claudeignore` (hasClaudeignore, which matches the install's
+ * exclusive create): one without it gets one, so the row says `created`; when
+ * all have one, `already present`; when the run targets no project, `skipped`.
+ * formatSafeDeleteStatus applies the same rule to safe-delete.
+ *
+ * Pure function.
+ *
+ * @param present - for each project the run targets, whether it already holds a
+ *   `.claudeignore`; empty when the run targets none.
+ */
+export function resolveClaudeignoreOutcome(present) {
+    if (present.length === 0)
+        return 'skipped';
+    return present.every(Boolean) ? 'already present' : 'created';
+}
+/** The Recommended summary's safe-delete row for what the run does to the block; a run that leaves it alone adds none. */
+const SAFE_DELETE_SUMMARY_ROW = {
+    install: 'Safe delete:     installed',
+    upgrade: 'Safe delete:     upgraded',
+    skip: '',
+};
+/**
+ * What init says about safe-delete once the install has run (D-INIT-REAL-OUTCOME).
+ *
+ * The outcome comes first: the block this run installed or upgraded, or the
+ * current block it found in place. Failing an outcome, the one step left to the
+ * user is installing the platform's trash command, which init cannot do for
+ * them. A non-interactive run always takes the Recommended path, which installs
+ * or upgrades the block itself, so its outcome is all there is to report.
+ *
+ * Pure function — returns lines, logs nothing.
+ *
+ * @param state - The profile's block before this run, or null when no profile was
+ *   checked (the trash command is missing, or the shell has no profile init writes).
+ */
+export function formatSafeDeleteStatus(input) {
+    const { profilePath, info } = input;
+    if (profilePath !== null) {
+        const restart = { level: 'info', message: 'Restart your shell or run: ' + color.cyan(`source ${profilePath}`) };
+        if (input.action === 'install')
+            return [{ level: 'success', message: `Safe-delete installed to ${color.dim(profilePath)}` }, restart];
+        if (input.action === 'upgrade')
+            return [{ level: 'success', message: `Safe-delete upgraded in ${color.dim(profilePath)}` }, restart];
+        if (input.state === 'current')
+            return [{ level: 'info', message: `Safe-delete already configured in ${color.dim(profilePath)}` }];
+    }
+    if (input.available || info.installHint === null)
+        return [];
+    if (!input.interactive) {
+        return [{ level: 'info', message: `Protect against accidental ${color.red('rm -rf')}: ${color.cyan(info.installHint)}` }];
+    }
+    if (profilePath === null)
+        return [];
+    return [
+        { level: 'info', message: `Install ${color.cyan(info.command ?? 'trash')} first: ${color.dim(info.installHint)}` },
+        { level: 'info', message: `Then re-run ${color.cyan('devflow init')} to auto-configure safe-delete.` },
+    ];
+}
 export { addContextHook, removeContextHook, hasContextHook };
 /**
  * Combine workflow and language selections into a single plugin list.
@@ -344,14 +422,25 @@ export async function persistManifestThenConvergeTracker(opts) {
  * D-LEDGER-MAIN-WORKTREE: each queue drains where the hooks write it — memory at
  * this checkout's toplevel (`gitRoot`), learning at the ledger root (`ledgerRoot`,
  * getLedgerRoot), which in a linked worktree is the main checkout.
+ *
+ * Returns one warning for each drain refused because a folder on the way to its
+ * queue is a symbolic link (D-CLI-NO-SYMLINK); the caller prints them.
  */
 export async function drainDisabledFeatureQueues(opts, io = { drainMemoryQueue, drainLearningQueue }) {
     if (!opts.manifestWritten)
-        return;
-    if (!opts.memoryEnabled && opts.gitRoot !== null)
-        await io.drainMemoryQueue(opts.gitRoot);
-    if (!opts.learningEnabled && opts.ledgerRoot !== null)
-        await io.drainLearningQueue(opts.ledgerRoot);
+        return [];
+    const refused = [];
+    if (!opts.memoryEnabled && opts.gitRoot !== null) {
+        const memory = await io.drainMemoryQueue(opts.gitRoot);
+        if (!memory.drained)
+            refused.push(formatRefusedDrain('memory', memory.linkedFolder));
+    }
+    if (!opts.learningEnabled && opts.ledgerRoot !== null) {
+        const learning = await io.drainLearningQueue(opts.ledgerRoot);
+        if (!learning.drained)
+            refused.push(formatRefusedDrain('learning', learning.linkedFolder));
+    }
+    return refused;
 }
 /**
  * The manifest `devflow init --hud-only` writes. Pure — never mutates `existing`.
@@ -822,6 +911,8 @@ export const initCommand = new Command('init')
     let claudeignoreEnabled = !!gitRoot;
     let discoveredProjects = [];
     let safeDeleteAction = 'skip';
+    // The profile's block before this run; null when no profile was checked.
+    let safeDeleteState = null;
     let safeDeleteBlock = null;
     // Security mode is resolved from flag + manifest + detected reality via resolveSecurityAction.
     // The final value is written to the manifest and consumed by the dedicated security step.
@@ -950,14 +1041,17 @@ export const initCommand = new Command('init')
         ]);
         discoveredProjects = discoveredResult;
         if (needsVersionCheck) {
-            const state = classifySafeDeleteState(installedVersionResult, SAFE_DELETE_BLOCK_VERSION);
-            if (state === 'current')
+            safeDeleteState = classifySafeDeleteState(installedVersionResult, SAFE_DELETE_BLOCK_VERSION);
+            if (safeDeleteState === 'current')
                 safeDeleteAction = 'skip';
-            else if (state === 'outdated')
+            else if (safeDeleteState === 'outdated')
                 safeDeleteAction = 'upgrade';
             else
                 safeDeleteAction = 'install';
         }
+        // D-INIT-REAL-OUTCOME: the summary prints before the install runs, so its
+        // .claudeignore row comes from what each project the install targets holds.
+        const claudeignorePresent = await Promise.all((claudeignoreEnabled ? projectRoots(discoveredProjects, gitRoot) : []).map(hasClaudeignore));
         // Print summary
         const defaultFlagCount = countActiveFlags(enabledFlags);
         const complianceSummary = formatComplianceSummary(complianceEnabled, complianceFrameworks);
@@ -976,8 +1070,8 @@ export const initCommand = new Command('init')
             `Tracker:         ${formatTrackerSummary(trackerProvider)}`,
             `View mode:       ${readViewMode(enabledFlags)}`,
             `Claude Code flags: ${defaultFlagCount} configured`,
-            `${claudeignoreEnabled ? '.claudeignore:   created' : ''}`,
-            `${safeDeleteAction !== 'skip' ? 'Safe delete:     installed' : ''}`,
+            `.claudeignore:   ${resolveClaudeignoreOutcome(claudeignorePresent)}`,
+            SAFE_DELETE_SUMMARY_ROW[safeDeleteAction],
         ].filter(l => l.trim()).join('\n');
         p.note(summaryLines + `\n\nCustomize later: ${color.cyan('devflow init --advanced')}`, 'Recommended settings applied');
     }
@@ -1271,11 +1365,11 @@ export const initCommand = new Command('init')
             safeDeleteBlock = generateSafeDeleteBlock(shell, process.platform, trashCmd);
             if (safeDeleteBlock) {
                 const installedVersion = await getInstalledVersion(profilePath);
-                const state = classifySafeDeleteState(installedVersion, SAFE_DELETE_BLOCK_VERSION);
-                if (state === 'current') {
+                safeDeleteState = classifySafeDeleteState(installedVersion, SAFE_DELETE_BLOCK_VERSION);
+                if (safeDeleteState === 'current') {
                     safeDeleteAction = 'skip';
                 }
-                else if (state === 'outdated') {
+                else if (safeDeleteState === 'outdated') {
                     safeDeleteAction = 'upgrade';
                 }
                 else {
@@ -1727,7 +1821,9 @@ export const initCommand = new Command('init')
     {
         const agentInstallDir = path.join(claudeDir, 'agents', 'devflow');
         const preCheckMapping = await readAgentMapping(devflowDir);
-        const hasMappingEntries = preCheckMapping.ok && Object.keys(preCheckMapping.value.agents).length > 0;
+        // hasAgentMappingEntries counts agent entries only: an agents.memory-only
+        // mapping names no installed file, so it keeps this gate closed (D-WORKER-AGENTS).
+        const hasMappingEntries = preCheckMapping.ok && hasAgentMappingEntries(preCheckMapping.value);
         if (hasMappingEntries || proxyEnabled) {
             const reapplyResult = await reapplyAgentMapping({
                 proxyEnabled,
@@ -1856,10 +1952,10 @@ export const initCommand = new Command('init')
     // Configure HUD
     const existingHud = loadHudConfig();
     saveHudConfig({ enabled: hudEnabled, detail: existingHud.detail });
-    // File extras
+    // File extras — into the projects the Recommended summary's .claudeignore row checked.
     if (claudeignoreEnabled) {
+        const results = await Promise.all(projectRoots(discoveredProjects, gitRoot).map(root => installClaudeignore(root, rootDir, verbose)));
         if (discoveredProjects.length > 0) {
-            const results = await Promise.all(discoveredProjects.map(root => installClaudeignore(root, rootDir, verbose)));
             const created = results.filter(Boolean).length;
             if (created > 0) {
                 p.log.success(`.claudeignore created in ${created} project(s)`);
@@ -1868,9 +1964,6 @@ export const initCommand = new Command('init')
                 p.log.info(`.claudeignore already exists in all ${discoveredProjects.length} project(s)`);
             }
         }
-        else if (gitRoot) {
-            await installClaudeignore(gitRoot, rootDir, verbose);
-        }
     }
     // Deterministically ensure .devflow/ is gitignored at the repo root — independent
     // of every feature toggle. The always-on ensure-root-gitignore
@@ -2062,34 +2155,14 @@ export const initCommand = new Command('init')
         p.note(commandsNote, 'Available commands');
     }
     // Safe-delete status messages (after spinner)
-    if (process.stdin.isTTY && profilePath) {
-        if (safeDeleteAction === 'install') {
-            p.log.success(`Safe-delete installed to ${color.dim(profilePath)}`);
-            p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
-        }
-        else if (safeDeleteAction === 'upgrade') {
-            p.log.success(`Safe-delete upgraded in ${color.dim(profilePath)}`);
-            p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
-        }
-        else if (safeDeleteAvailable && safeDeleteBlock) {
-            const installedVersion = await getInstalledVersion(profilePath);
-            if (classifySafeDeleteState(installedVersion, SAFE_DELETE_BLOCK_VERSION) === 'current') {
-                p.log.info(`Safe-delete already configured in ${color.dim(profilePath)}`);
-            }
-        }
-        else if (!safeDeleteAvailable && safeDeleteInfo.installHint) {
-            p.log.info(`Install ${color.cyan(safeDeleteInfo.command ?? 'trash')} first: ${color.dim(safeDeleteInfo.installHint)}`);
-            p.log.info(`Then re-run ${color.cyan('devflow init')} to auto-configure safe-delete.`);
-        }
-    }
-    else if (!process.stdin.isTTY) {
-        if (safeDeleteAvailable && safeDeleteInfo.command) {
-            p.log.info(`Safe-delete available (${safeDeleteInfo.command}). Run interactively to auto-install.`);
-        }
-        else if (safeDeleteInfo.installHint) {
-            p.log.info(`Protect against accidental ${color.red('rm -rf')}: ${color.cyan(safeDeleteInfo.installHint)}`);
-        }
-    }
+    logSummaryLines(formatSafeDeleteStatus({
+        interactive: process.stdin.isTTY === true,
+        action: safeDeleteAction,
+        state: safeDeleteState,
+        available: safeDeleteAvailable,
+        profilePath,
+        info: safeDeleteInfo,
+    }));
     // Verbose mode: show details
     if (verbose) {
         const pluginsList = pluginsToInstall
@@ -2157,13 +2230,15 @@ export const initCommand = new Command('init')
             p.log.info(msg.text);
     }
     // Only now that the machine-wide switch is on disk (D-INIT-DRAIN-AFTER-SWITCH).
-    await drainDisabledFeatureQueues({
+    const refusedDrains = await drainDisabledFeatureQueues({
         gitRoot,
         ledgerRoot: learningEnabled || gitRoot === null ? null : await getLedgerRoot(),
         memoryEnabled,
         learningEnabled,
         manifestWritten: trackerLifecycle.manifestWritten,
     });
+    for (const line of refusedDrains)
+        p.log.warn(line);
     // The hooks' per-directory log folders, capped (D-LOG-DIR-CAP): one pass
     // clears every folder it scans beyond the cap; only a backlog beyond the
     // scan bound (MAX_LOG_DIRS_SCANNED, 100,000) waits for the next init.