@rasensio/aidlc 1.12.0 → 1.13.1

package/dist/core/project-root.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Project-root discovery — the one source of truth for "which `.aidlc/` tree is
+ * this?" (cwd-project-root/AC-1 … AC-7).
+ *
+ * Every command previously read `process.cwd()` and treated it as the project
+ * root. Run from a subdirectory that is silently wrong: `cost record` reported
+ * success while writing into a freshly-created `.aidlc/state/.aidlc/` tree no
+ * report reads, and `status`/`metrics` rendered zeroes as if measured. The
+ * failure had no error path because nothing was checking.
+ *
+ * This lives in `core/` for the reason `tty.ts` records: `commands/`, `doctor/`
+ * and `events/` all need it, and `menu/index.ts` imports the command registrars,
+ * so siting it anywhere those import from would close a cycle.
+ *
+ * ## Nearest wins, not primary
+ *
+ * `roadmap/paths.ts` resolves the **primary checkout** via `git rev-parse
+ * --git-common-dir`, deliberately: a backlog written inside a feature worktree is
+ * stranded on that branch until it merges. That is the correct rule for the
+ * roadmap and the wrong one here. Instance state and cost belong to the worktree
+ * that produced them, so this walks to the *nearest enclosing* `.aidlc/`
+ * (AC-5, AC-19). The two rules coexist on purpose; neither is a fallback for the
+ * other.
+ *
+ * ## Two commands must not use this
+ *
+ * `init` and `discover` keep reading `process.cwd()` (AC-16). `init` creates a
+ * project — searching upward would make `aidlc init` inside an existing project
+ * silently reconfigure the ancestor instead of initializing where the user is
+ * standing. `discover` scans a codebase for the same reason. `test/project-root-
+ * call-sites.test.ts` names both as expected exemptions, so a *new* unrouted
+ * `process.cwd()` fails the suite rather than being found later by a user.
+ *
+ * @module
+ */
+/** The directory whose presence marks a project root. */
+export declare const PROJECT_MARKER = ".aidlc";
+/**
+ * The nearest ancestor of `from` (including `from`) containing a `.aidlc/`
+ * directory, or `from` itself when there is none.
+ *
+ * Falling back to `from` keeps behaviour outside a project byte-identical to
+ * today (AC-2) — that is what makes this a safe change to route ~20 call sites
+ * through at once. A caller that needs to distinguish "found" from "fell back"
+ * should use {@link findProjectRoot}.
+ *
+ * No subprocess and no `git` (AC-6): a project need not be a repository, and
+ * spawning `git` once per command to answer a question `statSync` answers would
+ * be slower and would fail differently outside a repo.
+ */
+export declare function resolveProjectRoot(from?: string): string;
+/**
+ * As {@link resolveProjectRoot}, but null when no ancestor holds the marker.
+ *
+ * Exists for the callers that must *report* rather than assume — a command can
+ * say "not in an AIDLC project" instead of inventing a root and then finding it
+ * empty, which is the shape of the original defect.
+ */
+export declare function findProjectRoot(from?: string): string | null;
+//# sourceMappingURL=project-root.d.ts.map

package/dist/core/project-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root.d.ts","sourceRoot":"","sources":["../../src/core/project-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAKH,yDAAyD;AACzD,eAAO,MAAM,cAAc,WAAW,CAAC;AAuBvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,MAAsB,GAAG,MAAM,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAW3E"}

package/dist/core/project-root.js

@@ -0,0 +1,98 @@
+/**
+ * Project-root discovery — the one source of truth for "which `.aidlc/` tree is
+ * this?" (cwd-project-root/AC-1 … AC-7).
+ *
+ * Every command previously read `process.cwd()` and treated it as the project
+ * root. Run from a subdirectory that is silently wrong: `cost record` reported
+ * success while writing into a freshly-created `.aidlc/state/.aidlc/` tree no
+ * report reads, and `status`/`metrics` rendered zeroes as if measured. The
+ * failure had no error path because nothing was checking.
+ *
+ * This lives in `core/` for the reason `tty.ts` records: `commands/`, `doctor/`
+ * and `events/` all need it, and `menu/index.ts` imports the command registrars,
+ * so siting it anywhere those import from would close a cycle.
+ *
+ * ## Nearest wins, not primary
+ *
+ * `roadmap/paths.ts` resolves the **primary checkout** via `git rev-parse
+ * --git-common-dir`, deliberately: a backlog written inside a feature worktree is
+ * stranded on that branch until it merges. That is the correct rule for the
+ * roadmap and the wrong one here. Instance state and cost belong to the worktree
+ * that produced them, so this walks to the *nearest enclosing* `.aidlc/`
+ * (AC-5, AC-19). The two rules coexist on purpose; neither is a fallback for the
+ * other.
+ *
+ * ## Two commands must not use this
+ *
+ * `init` and `discover` keep reading `process.cwd()` (AC-16). `init` creates a
+ * project — searching upward would make `aidlc init` inside an existing project
+ * silently reconfigure the ancestor instead of initializing where the user is
+ * standing. `discover` scans a codebase for the same reason. `test/project-root-
+ * call-sites.test.ts` names both as expected exemptions, so a *new* unrouted
+ * `process.cwd()` fails the suite rather than being found later by a user.
+ *
+ * @module
+ */
+import { statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+/** The directory whose presence marks a project root. */
+export const PROJECT_MARKER = '.aidlc';
+/**
+ * True when `dir` contains a `.aidlc/` **directory**.
+ *
+ * The directory check is not incidental (AC-4): a *file* named `.aidlc` is not a
+ * project, and treating it as one would resolve a root whose every subsequent
+ * `join(root, '.aidlc', …)` fails on a path component that is not a directory —
+ * an error far from its cause. `statSync` rather than `existsSync` because
+ * `existsSync` cannot tell the two apart.
+ *
+ * Any error — unreadable ancestor, permission denied, path vanished mid-walk — is
+ * "no marker here" rather than a throw (AC-3). A directory we cannot inspect is
+ * not a project root we could have used.
+ */
+function hasMarker(dir) {
+    try {
+        return statSync(join(dir, PROJECT_MARKER)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The nearest ancestor of `from` (including `from`) containing a `.aidlc/`
+ * directory, or `from` itself when there is none.
+ *
+ * Falling back to `from` keeps behaviour outside a project byte-identical to
+ * today (AC-2) — that is what makes this a safe change to route ~20 call sites
+ * through at once. A caller that needs to distinguish "found" from "fell back"
+ * should use {@link findProjectRoot}.
+ *
+ * No subprocess and no `git` (AC-6): a project need not be a repository, and
+ * spawning `git` once per command to answer a question `statSync` answers would
+ * be slower and would fail differently outside a repo.
+ */
+export function resolveProjectRoot(from = process.cwd()) {
+    return findProjectRoot(from) ?? resolve(from);
+}
+/**
+ * As {@link resolveProjectRoot}, but null when no ancestor holds the marker.
+ *
+ * Exists for the callers that must *report* rather than assume — a command can
+ * say "not in an AIDLC project" instead of inventing a root and then finding it
+ * empty, which is the shape of the original defect.
+ */
+export function findProjectRoot(from = process.cwd()) {
+    let dir = resolve(from);
+    // `dirname('/')` is `/`, so compare against the previous value rather than
+    // testing for a specific root — this terminates identically on POSIX roots and
+    // Windows drive roots (AC-3).
+    for (;;) {
+        if (hasMarker(dir))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+//# sourceMappingURL=project-root.js.map

package/dist/core/project-root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root.js","sourceRoot":"","sources":["../../src/core/project-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEnD,yDAAyD;AACzD,MAAM,CAAC,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,SAAS,SAAS,CAAC,GAAW;IAC5B,IAAI,CAAC;QACH,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAC3D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe,OAAO,CAAC,GAAG,EAAE;IAC7D,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,OAAe,OAAO,CAAC,GAAG,EAAE;IAC1D,IAAI,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,2EAA2E;IAC3E,+EAA+E;IAC/E,8BAA8B;IAC9B,SAAS,CAAC;QACR,IAAI,SAAS,CAAC,GAAG,CAAC;YAAE,OAAO,GAAG,CAAC;QAC/B,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAC5B,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,IAAI,CAAC;QAChC,GAAG,GAAG,MAAM,CAAC;IACf,CAAC;AACH,CAAC"}

package/dist/core/version.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The package's own version and name — read once, from one place
+ * (roadmap-revamp/AC-18).
+ *
+ * Two call sites resolved `package.json` independently before this module
+ * existed, at *different* relative depths because each computed the path from
+ * its own compiled location: `cli.ts` builds to `dist/cli.js` so the package
+ * root is `..`, while `commands/update.ts` builds to `dist/commands/update.js`
+ * so it is `../..`. Both were correct and neither was copyable. A third reader
+ * at a third depth — roadmap-revamp added one — is a third chance to get it
+ * wrong, and the failure mode is silent: a bad path throws, the catch returns
+ * `0.0.0`, and the CLI reports a version it is not.
+ *
+ * Resolving here once removes the choice. This module compiles to
+ * `dist/core/version.js`, so the package root is `../..`.
+ *
+ * The values are module constants rather than functions because the manifest
+ * cannot change while the process runs, and a constant is what a template
+ * emitter can interpolate without threading a call through its signature.
+ *
+ * Deliberately NOT a literal: `scripts/check-docs-drift.mjs` fails the build on
+ * a hardcoded version in `cli.ts` because v1.1.0 shipped reporting `0.1.0`. The
+ * same check now covers the roadmap authoring skill's source template
+ * (roadmap-revamp/AC-17).
+ *
+ * @module
+ */
+/**
+ * Absolute path to this package's root — the directory holding `package.json`.
+ *
+ * Exported because `commands/update.ts` needs the root itself, not only the
+ * two fields read from the manifest inside it.
+ */
+export declare function cliPackageRoot(): string;
+/** This package's version, e.g. `1.12.0`. */
+export declare const VERSION: string;
+/** This package's npm name, e.g. `@rasensio/aidlc`. */
+export declare const PACKAGE_NAME: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/core/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/core/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAUH;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAyBD,6CAA6C;AAC7C,eAAO,MAAM,OAAO,EAAE,MAAyB,CAAC;AAEhD,uDAAuD;AACvD,eAAO,MAAM,YAAY,EAAE,MAAsB,CAAC"}

package/dist/core/version.js

@@ -0,0 +1,69 @@
+/**
+ * The package's own version and name — read once, from one place
+ * (roadmap-revamp/AC-18).
+ *
+ * Two call sites resolved `package.json` independently before this module
+ * existed, at *different* relative depths because each computed the path from
+ * its own compiled location: `cli.ts` builds to `dist/cli.js` so the package
+ * root is `..`, while `commands/update.ts` builds to `dist/commands/update.js`
+ * so it is `../..`. Both were correct and neither was copyable. A third reader
+ * at a third depth — roadmap-revamp added one — is a third chance to get it
+ * wrong, and the failure mode is silent: a bad path throws, the catch returns
+ * `0.0.0`, and the CLI reports a version it is not.
+ *
+ * Resolving here once removes the choice. This module compiles to
+ * `dist/core/version.js`, so the package root is `../..`.
+ *
+ * The values are module constants rather than functions because the manifest
+ * cannot change while the process runs, and a constant is what a template
+ * emitter can interpolate without threading a call through its signature.
+ *
+ * Deliberately NOT a literal: `scripts/check-docs-drift.mjs` fails the build on
+ * a hardcoded version in `cli.ts` because v1.1.0 shipped reporting `0.1.0`. The
+ * same check now covers the roadmap authoring skill's source template
+ * (roadmap-revamp/AC-17).
+ *
+ * @module
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Fallbacks match the ones the previous private readers used. */
+const FALLBACK_VERSION = '0.0.0';
+const FALLBACK_NAME = '@rasensio/aidlc';
+/**
+ * Absolute path to this package's root — the directory holding `package.json`.
+ *
+ * Exported because `commands/update.ts` needs the root itself, not only the
+ * two fields read from the manifest inside it.
+ */
+export function cliPackageRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+}
+/**
+ * Read the manifest once at module load.
+ *
+ * A throw here is not fatal: an unreadable manifest means a broken install, and
+ * every previous reader degraded to a placeholder rather than refusing to run.
+ * That behaviour is preserved so this refactor cannot change what a damaged
+ * install does.
+ */
+function readManifest() {
+    try {
+        const raw = readFileSync(join(cliPackageRoot(), 'package.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            version: typeof parsed.version === 'string' ? parsed.version : FALLBACK_VERSION,
+            name: typeof parsed.name === 'string' ? parsed.name : FALLBACK_NAME,
+        };
+    }
+    catch {
+        return { version: FALLBACK_VERSION, name: FALLBACK_NAME };
+    }
+}
+const manifest = readManifest();
+/** This package's version, e.g. `1.12.0`. */
+export const VERSION = manifest.version;
+/** This package's npm name, e.g. `@rasensio/aidlc`. */
+export const PACKAGE_NAME = manifest.name;
+//# sourceMappingURL=version.js.map

package/dist/core/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/core/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,kEAAkE;AAClE,MAAM,gBAAgB,GAAG,OAAO,CAAC;AACjC,MAAM,aAAa,GAAG,iBAAiB,CAAC;AAExC;;;;;GAKG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,YAAY;IACnB,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CAAC;QACzE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAA0C,CAAC;QACxE,OAAO;YACL,OAAO,EAAE,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,gBAAgB;YAC/E,IAAI,EAAE,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa;SACpE,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;IAC5D,CAAC;AACH,CAAC;AAED,MAAM,QAAQ,GAAG,YAAY,EAAE,CAAC;AAEhC,6CAA6C;AAC7C,MAAM,CAAC,MAAM,OAAO,GAAW,QAAQ,CAAC,OAAO,CAAC;AAEhD,uDAAuD;AACvD,MAAM,CAAC,MAAM,YAAY,GAAW,QAAQ,CAAC,IAAI,CAAC"}

package/dist/doctor/migrations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/doctor/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAe7C,eAAO,MAAM,UAAU,EAAE,SAAS,EAiBjC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/doctor/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAiB7C,eAAO,MAAM,UAAU,EAAE,SAAS,EAsBjC,CAAC"}

package/dist/doctor/migrations/index.js

@@ -18,12 +18,19 @@ import { unknownAgentClaims } from './unknown-agent-claims.js';
 import { legacyCostHooks } from './legacy-cost-hooks.js';
 import { missingCostShim } from './missing-cost-shim.js';
 import { installGuidance } from './install-guidance.js';
+import { staleIdeaSkill } from './stale-idea-skill.js';
+import { roadmapLayout } from './roadmap-layout.js';
 export const MIGRATIONS = [
     costGitignore,
     knowledgeGitignore,
     gitattributes,
     shippedActions,
     installGuidance,
+    // Ordered before roadmap-layout: the orphaned skill still describes the old
+    // ideas directory, so clearing it first means a single run never leaves an
+    // instruction on disk that contradicts the layout the next migration creates.
+    staleIdeaSkill,
+    roadmapLayout,
     untrackCostEphemera,
     pruneSessionStash,
     pruneCostLocks,

package/dist/doctor/migrations/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/doctor/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,CAAC,MAAM,UAAU,GAAgB;IACrC,aAAa;IACb,kBAAkB;IAClB,aAAa;IACb,cAAc;IACd,eAAe;IACf,mBAAmB;IACnB,iBAAiB;IACjB,cAAc;IACd,wBAAwB;IACxB,aAAa;IACb,kBAAkB;IAClB,6EAA6E;IAC7E,6EAA6E;IAC7E,4EAA4E;IAC5E,eAAe;IACf,eAAe;CAChB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/doctor/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,CAAC,MAAM,UAAU,GAAgB;IACrC,aAAa;IACb,kBAAkB;IAClB,aAAa;IACb,cAAc;IACd,eAAe;IACf,4EAA4E;IAC5E,2EAA2E;IAC3E,8EAA8E;IAC9E,cAAc;IACd,aAAa;IACb,mBAAmB;IACnB,iBAAiB;IACjB,cAAc;IACd,wBAAwB;IACxB,aAAa;IACb,kBAAkB;IAClB,6EAA6E;IAC7E,6EAA6E;IAC7E,4EAA4E;IAC5E,eAAe;IACf,eAAe;CAChB,CAAC"}

package/dist/doctor/migrations/roadmap-layout.d.ts

@@ -0,0 +1,73 @@
+/**
+ * roadmap-layout migration (roadmap-revamp/AC-23..AC-27, AC-38, confirm tier):
+ * move a legacy `.aidlc/ideas/` backlog into `.aidlc/roadmap/<status>/` and
+ * rewrite each item's frontmatter to the new schema.
+ *
+ * This is the first migration in this project that moves the *user's own*
+ * content rather than regenerating a framework artifact, which is why it is
+ * confirm tier and why every move goes through `git mv` when the file is
+ * tracked: a mistake stays one `git checkout` away from undone.
+ *
+ * `check` and `apply` both derive everything from `planRoadmapMoves` and nothing
+ * else computes pending-ness — the rule stated in `../types.ts`, so a dry run and
+ * a real run cannot disagree about what will happen.
+ *
+ * Old status maps to new directory: `raw` → `inbox`, `dropped` → `hold`,
+ * `promoted` → `done` or `in-progress` depending on whether the named instance
+ * actually finished. Raw items land in `inbox` rather than `backlog` because the
+ * old format has no field recording whether anything was ever triaged, and
+ * mapping to `backlog` would manufacture that signal (DD-8).
+ *
+ * Whether an instance finished is answered by `completionInfo` from the metrics
+ * module, not by a local "is the last phase complete?" test — that naive form is
+ * wrong for maintenance-terminal templates, which complete on maintenance entry.
+ */
+import type { Migration } from '../types.js';
+import type { DoctorContext } from '../types.js';
+import { type RoadmapStatus } from '../../roadmap/paths.js';
+/** One planned relocation, with everything `apply` needs to carry it out. */
+export interface RoadmapMove {
+    /** Absolute source path. */
+    from: string;
+    /** Absolute target path. */
+    to: string;
+    /** Repo-relative source, for the printed command list. */
+    fromRel: string;
+    /** Repo-relative target, for the printed command list. */
+    toRel: string;
+    status: RoadmapStatus;
+    /** Rewritten file contents. */
+    contents: string;
+    /** Tracked by git, so the move can preserve history. */
+    tracked: boolean;
+}
+export interface RoadmapPlan {
+    moves: RoadmapMove[];
+    /** Repo-relative paths the planner could not classify; left in place. */
+    unclassified: string[];
+}
+/**
+ * Rewrite a legacy idea's frontmatter to the roadmap schema.
+ *
+ * Key order is fixed by AC-4, so the block is rebuilt rather than edited: the
+ * legacy shape shares only `promoted_to` and `depends_on` with the new one.
+ * The body below the frontmatter is copied through untouched apart from being
+ * read for its title.
+ *
+ * `author` is deliberately omitted rather than guessed. The legacy format never
+ * recorded one, and `created_by` from an unrelated instance is not the author of
+ * an idea.
+ */
+export declare function rewriteFrontmatter(raw: string, filename: string, status: RoadmapStatus): {
+    contents: string;
+    id: string;
+} | null;
+/**
+ * Everything the migration would do, computed without writing.
+ *
+ * The single source of pending-ness. Sorted by source path so the plan never
+ * depends on directory read order.
+ */
+export declare function planRoadmapMoves(ctx: DoctorContext): RoadmapPlan;
+export declare const roadmapLayout: Migration;
+//# sourceMappingURL=roadmap-layout.d.ts.map

package/dist/doctor/migrations/roadmap-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roadmap-layout.d.ts","sourceRoot":"","sources":["../../../src/doctor/migrations/roadmap-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,wBAAwB,CAAC;AAEhC,6EAA6E;AAC7E,MAAM,WAAW,WAAW;IAC1B,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,CAAC;IACtB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,yEAAyE;IACzE,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAsBD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,GACpB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA8CzC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,GAAG,WAAW,CAmEhE;AASD,eAAO,MAAM,aAAa,EAAE,SA8G3B,CAAC"}