devflow-kit 2.4.0 → 3.0.0

package/dist/core/migrations.js

@@ -10,10 +10,10 @@
  */
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import * as os from 'os';
 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';
 /**
  * D31: Registry pattern over scattered `if (!applied.includes(...))` conditionals.
  *
@@ -94,23 +94,48 @@ export const MIGRATIONS = [
             return { infos, warnings };
         },
     },
+    {
+        id: 'tracker-conventions-per-provider-v1',
+        description: 'Move ~/.devflow/tracker.md to ~/.devflow/tracker/{provider}.md, the provider its frontmatter names',
+        scope: 'global',
+        // D-TRACKER-PER-PROVIDER-CONVENTIONS: conventions became per provider, so the
+        // single machine-wide file moves to the file of the provider it was learned
+        // for. The move and every refusal to move are migrateLegacyTrackerConventions'
+        // (src/core/tracker.ts); this entry maps its outcome onto the runner's
+        // contract. A file it leaves in place is REPORTED, once, and the migration is
+        // marked applied — the file is user content and nothing a re-run could do
+        // differently. An I/O failure THROWS instead: a throwing migration is not
+        // marked applied, so the runner retries it on the next `devflow init` rather
+        // than recording a move that never happened (the retry-forever path the
+        // KNOWN ISSUE above describes is bounded here by what can fail — a rename and
+        // an rm inside ~/.devflow).
+        async run(ctx) {
+            const outcome = await migrateLegacyTrackerConventions(ctx.devflowDir);
+            switch (outcome.kind) {
+                case 'none':
+                    return { infos: [], warnings: [] };
+                case 'moved':
+                    return { infos: [`Moved the ${outcome.provider} tracker conventions to ${outcome.to}`], warnings: [] };
+                case 'kept':
+                    return { infos: [], warnings: [`tracker-conventions-per-provider-v1: ${outcome.reason}`] };
+                case 'failed':
+                    throw new Error(outcome.error);
+                default: {
+                    const _exhaustive = outcome;
+                    return _exhaustive;
+                }
+            }
+        },
+    },
 ];
 const MIGRATIONS_FILE = 'migrations.json';
 /**
- * D30: State lives at `~/.devflow/migrations.json` (scope-independent) rather
- * than the install manifest because:
- *
- * - The install manifest is scope-specific: user-scope manifests live at
- *   `~/.devflow/manifest.json` while local-scope manifests live at
- *   `.devflow/manifest.json` inside the repo. A migration that runs on user-scope
- *   init wouldn't be recorded in a local-scope manifest, so the migration would
- *   re-run on the next local-scope init.
- * - Migration state is machine-wide: once a global migration runs on a machine it
- *   should never re-run regardless of which project or scope triggered devflow init.
- * - `~/.devflow/migrations.json` is always writable (home-dir location), whereas
- *   local-scope devflowDir may be inside a read-only checkout.
+ * D30: State lives at `~/.devflow/migrations.json` rather than in the install
+ * manifest because migration state is machine-wide: once a global migration runs
+ * on a machine it should never re-run regardless of which project triggered
+ * devflow init.
  *
- * @param devflowDir - absolute path to `~/.devflow` (always the home-dir location)
+ * @param devflowDir - absolute path to the resolved machine root (`~/.devflow`)
  */
 export async function readAppliedMigrations(devflowDir) {
     const filePath = path.join(devflowDir, MIGRATIONS_FILE);
@@ -227,7 +252,7 @@ async function runGlobalMigration(migration, ctx) {
  * additional projects) can retry the failed projects.
  *
  * D37: runPerProjectMigration is unreachable in production — MIGRATIONS holds
- * only a global migration (`canonicalise-agent-keys-v1`). The vacuous-truth
+ * only global migrations. The vacuous-truth
  * analysis is preserved for correctness: if a per-project migration is ever
  * added, an empty discoveredProjects list marks it applied (empty-discovery-marks-applied
  * intended); the applied-set write is skipped only when newlyApplied is empty,
@@ -267,19 +292,20 @@ async function runPerProjectMigration(migration, ctx, discoveredProjects) {
  * Run all unapplied migrations from MIGRATIONS.
  *
  * D32: Always-run-unapplied semantics (no fresh-vs-upgrade branch).
- * MIGRATIONS currently holds one global migration (`canonicalise-agent-keys-v1`);
- * on a fresh machine the loop executes once and writes migrations.json. On
- * subsequent runs the ID is already in the applied set and the loop is a no-op.
+ * MIGRATIONS currently holds only global migrations; on a fresh machine each
+ * executes once and the applied set is written to migrations.json. On subsequent
+ * runs every ID is already in the applied set and the loop is a no-op.
  *
- * @param ctx - devflowDir (memoryDir and projectRoot filled per-project)
+ * @param ctx - devflowDir, the resolved machine root (`~/.devflow`) that also holds
+ *   migrations.json; memoryDir and projectRoot are filled per-project
  * @param discoveredProjects - absolute paths to discovered Claude-enabled project roots
  * @param registryOverride - override MIGRATIONS for testing (defaults to module-level MIGRATIONS)
  */
 export async function runMigrations(ctx, discoveredProjects, registryOverride) {
     const registry = registryOverride ?? MIGRATIONS;
-    // Always read from home-dir devflow location so state is machine-wide
-    const homeDevflowDir = path.join(os.homedir(), '.devflow');
-    const appliedArray = await readAppliedMigrations(homeDevflowDir);
+    // D-ONE-HOME: state lives in the caller's resolved machine root, never a
+    // second, independently derived home path (D30: machine-wide state).
+    const appliedArray = await readAppliedMigrations(ctx.devflowDir);
     // Convert to Set once for O(1) lookups throughout the loop (issue #9)
     const applied = new Set(appliedArray);
     const newlyApplied = [];
@@ -323,7 +349,7 @@ export async function runMigrations(ctx, discoveredProjects, registryOverride) {
     }
     // Write state once at end, accumulating all newly applied IDs (issue #5 — O(N²) → O(1))
     if (newlyApplied.length > 0) {
-        await writeAppliedMigrations(homeDevflowDir, [...appliedArray, ...newlyApplied]);
+        await writeAppliedMigrations(ctx.devflowDir, [...appliedArray, ...newlyApplied]);
     }
     return { newlyApplied, failures, infos, warnings };
 }

package/dist/core/model-discovery.js

@@ -552,7 +552,18 @@ async function _discoverInternal(cacheDir, logPath, deps) {
     // completes during the spawn's SPAWN_TIMEOUT_MS window).
     const staleRawP = findStaleFallback(cacheDir, currentKey);
     // --- Live spawn ---
-    const env = { ...scrubChildEnv(), NO_COLOR: '1' };
+    // @D-EFR-6 Discovery reads the runtime's built-in registry, never a user config.
+    //   Since 0.5.0 every implicit config load merges the runtime's user-level file
+    //   ($XDG_CONFIG_HOME/subswitch/config.json, else ~/.config/subswitch/config.json)
+    //   under the cwd project file. Devflow's relay never sees that file — it is always
+    //   started with an explicit SUBSWITCH_CONFIG, which bypasses the merge — so a user
+    //   alias leaking into discovery would be offered in the picker yet never routed,
+    //   and a malformed file would fail every live discovery. The cache key also
+    //   assumes the catalog depends on the runtime version alone. Pointing
+    //   XDG_CONFIG_HOME at devflow's own cache directory, which never holds a
+    //   `subswitch/config.json`, makes the lookup a clean ENOENT. SUBSWITCH_CONFIG
+    //   stays unset (T2): an explicit path that is missing is a hard error.
+    const env = { ...scrubChildEnv(), NO_COLOR: '1', XDG_CONFIG_HOME: cacheDir };
     const spawnFn = deps?.spawnAndCollect ?? buildRealSpawnAndCollect(logPath);
     let spawnResult;
     try {