@sdd-method/author-cli 0.0.0-stage → 0.1.0

package/dist/lib/pack/schema.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+/**
+ * Zod schema for adopter pack seeds. Mirrors
+ * docs/method/foundations/schemas/context-pack-seed-schema.yaml.
+ *
+ * Used by `sdd-cli pack validate` for fast feedback during authoring.
+ * The structural parse in seed.ts already enforces presence of required
+ * fields; this schema layer adds value-shape checks (semver patterns,
+ * known forward-base bundle names, non-empty managed_paths).
+ */
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
+const VERSIONED_RANGE_PATTERN = /^(\^|~|>=)?v?\d+\.\d+\.\d+$/;
+// Exported so the canonical-schema conformance test can assert this vocabulary
+// matches context-pack-seed-schema.yaml's `forward_base.bundle` enum. The two had
+// drifted (canonical carried three values, this four) with nothing to detect it.
+export const KNOWN_FORWARD_BASES = [
+    "app-baseline",
+    "integration-baseline",
+    "platform-baseline",
+    "reverse-baseline",
+];
+export const PackSeedSchema = z.object({
+    version: z
+        .string()
+        .regex(SEMVER_PATTERN, "version must be semver (X.Y.Z)"),
+    scope: z
+        .string()
+        .regex(/^[a-z0-9-]+$/, "scope must be lower-kebab-case slug"),
+    // Optional per ADR 0176 §4.6: absent = profile-agnostic pack.
+    forwardBase: z
+        .object({
+        bundle: z.enum(KNOWN_FORWARD_BASES),
+        minimumVersion: z
+            .string()
+            .regex(/^v\d+\.\d+\.\d+$/, "forward_base.minimum_version must be vX.Y.Z"),
+        sourceRepo: z.string().min(1),
+    })
+        .optional(),
+    // Vendor-base pack pin (M-ADR 0175, seed schema 1.2.0). Present only on a
+    // vendor-base pack: names the vendor and the vendor version whose documented
+    // truth this pack's content encodes.
+    //
+    // The point of a PACK-LEVEL pin is that a consuming SDD does not restate it. A
+    // consumer pins the pack exactly (its bundles-list entry + sha256) and the
+    // vendor version it inherits is DERIVED from here. Recording it consumer-side
+    // as well would be a second source of truth that can silently disagree, and the
+    // pack is authoritative for its own vendor pin.
+    //
+    // `vendorVersion` is free-form by design: it carries either a formal vendor
+    // version or the anchor schema's `<vendor>-docs@YYYY-MM-DD` snapshot form, and
+    // vendors' own version strings are not the method's to constrain.
+    vendorBase: z
+        .object({
+        vendor: z
+            .string()
+            .regex(/^[a-z][a-z0-9-]*$/, "vendor_base.vendor must be a lower-kebab-case slug"),
+        vendorVersion: z.string().min(1, "vendor_base.vendor_version must be non-empty"),
+    })
+        .optional(),
+    minimumSddCliVersion: z
+        .string()
+        .regex(SEMVER_PATTERN, "minimum_sdd_cli_version must be semver (X.Y.Z)"),
+    description: z.string().min(1),
+    include: z.array(z.string()).optional(),
+    managedPaths: z
+        .array(z.string().min(1))
+        .min(1, "managed_paths must have at least one entry"),
+    forbiddenPaths: z.array(z.string()).optional(),
+    // ADR 0176 §4.3: scaffold-source path prefixes; each must cover at
+    // least one managed_paths entry (checked in the superRefine below).
+    scaffoldSourcePaths: z.array(z.string().min(1)).optional(),
+    requiresPack: z
+        .object({
+        name: z.string().min(1),
+        version: z
+            .string()
+            .regex(VERSIONED_RANGE_PATTERN, "requires_pack.version must be a semver range (e.g. ^v1.2.0)"),
+    })
+        .optional(),
+    sourcePath: z.string(),
+});
+const PackSeedSchemaRefined = PackSeedSchema.superRefine((seed, ctx) => {
+    // A vendor-base pack is PROFILE-AGNOSTIC (M-ADR 0176 §4.6, M-ADR 0175): its
+    // content is vendor-defined, so it layers over any baseline and must not pin
+    // one. Declaring both is a contradiction the producer should hear at validate
+    // time rather than discover when a consumer on a different baseline cannot
+    // apply it.
+    if (seed.vendorBase && seed.forwardBase) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["forwardBase"],
+            message: "a vendor_base pack is profile-agnostic and must omit forward_base " +
+                "(M-ADR 0176 §4.6); remove forward_base, or remove vendor_base if this " +
+                "is not a vendor-base pack",
+        });
+    }
+    if (!seed.scaffoldSourcePaths)
+        return;
+    for (const [i, prefix] of seed.scaffoldSourcePaths.entries()) {
+        const covers = seed.managedPaths.some((mp) => mp.startsWith(prefix));
+        if (!covers) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["scaffoldSourcePaths", i],
+                message: `scaffold_source_paths entry "${prefix}" matches no managed_paths entry`,
+            });
+        }
+    }
+});
+export function validateSeed(seed) {
+    const result = PackSeedSchemaRefined.safeParse(seed);
+    if (result.success) {
+        return { ok: true, errors: [] };
+    }
+    const errors = result.error.issues.map((issue) => ({
+        field: issue.path.join("."),
+        message: issue.message,
+    }));
+    return { ok: false, errors };
+}
+//# sourceMappingURL=schema.js.map

package/dist/lib/pack/seed.js

@@ -0,0 +1,182 @@
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+/**
+ * Adopter pack seed file. Per ADR 0151 + context-pack-seed-schema.yaml.
+ *
+ * Loaded by `sdd-cli pack build` and `sdd-cli pack validate` from
+ * `orchestration/distribution/{pack-name}-seed.yaml` in adopter repos.
+ *
+ * Includes are resolved before validation: the merged seed presents
+ * all `include`'d managed_paths + forbidden_paths concatenated with
+ * the host seed's own.
+ */
+/**
+ * Authored seed keys, snake_case → the camelCase field they map to.
+ *
+ * THE SINGLE SOURCE OF TRUTH for "what may appear in a seed file". It lived only
+ * inside the canonical-conformance test, which meant the loader had no idea what a
+ * valid key set was — so an unrecognised key was dropped by the hand-mapping below
+ * without a word. An adopter following a schema that documents a field their sdd-cli
+ * predates got a clean validation and a silent no-op: the same failure M-ADR 0175's
+ * history records for `packaging`, and the same one fixed for `.sdd/sdd-manifest.yaml`
+ * in 0.110.1 — but by a different mechanism, which is why that fix did not cover this.
+ *
+ * The conformance test now imports this rather than declaring its own copy. Two
+ * hand-maintained lists of the same facts is how the lifecycle expectation drifted.
+ */
+export const SEED_KEY_TO_FIELD = {
+    version: "version",
+    scope: "scope",
+    forward_base: "forwardBase",
+    vendor_base: "vendorBase",
+    minimum_sdd_cli_version: "minimumSddCliVersion",
+    description: "description",
+    include: "include",
+    managed_paths: "managedPaths",
+    forbidden_paths: "forbiddenPaths",
+    scaffold_source_paths: "scaffoldSourcePaths",
+    requires_pack: "requiresPack",
+};
+/**
+ * Top-level keys in a seed file that this build does not recognise.
+ *
+ * Deliberately TOP-LEVEL only, stated as a limit rather than left implied: nested
+ * blocks (`forward_base`, `vendor_base`, `requires_pack`) are hand-mapped field by
+ * field too, so an unknown key inside one is still dropped silently today.
+ */
+export function unknownSeedKeys(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return [];
+    return Object.keys(raw)
+        .filter((k) => !(k in SEED_KEY_TO_FIELD))
+        .sort();
+}
+/**
+ * Load a seed file from disk, resolve its `include:` directives,
+ * and return a merged PackSeed. Throws if any include cannot be read
+ * or if circular includes are detected.
+ *
+ * NOTE: This does not validate the seed structure — only parses YAML
+ * and assembles the typed shape. Use `validateSeed` (separate module)
+ * for schema enforcement.
+ */
+export async function loadSeed(seedPath) {
+    const absPath = isAbsolute(seedPath) ? seedPath : resolve(seedPath);
+    const visited = new Set();
+    return loadSeedRecursive(absPath, visited);
+}
+async function loadSeedRecursive(absPath, visited) {
+    if (visited.has(absPath)) {
+        throw new Error(`Circular include detected at ${absPath}`);
+    }
+    visited.add(absPath);
+    let raw;
+    try {
+        raw = await readFile(absPath, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Cannot read seed file ${absPath}: ${err.message}`);
+    }
+    const parsed = parseYaml(raw);
+    if (parsed === null || typeof parsed !== "object") {
+        throw new Error(`Seed file ${absPath} is not a YAML object`);
+    }
+    const baseDir = dirname(absPath);
+    const includes = Array.isArray(parsed.include) ? parsed.include : [];
+    const includedManaged = [];
+    const includedForbidden = [];
+    const includedUnknown = [];
+    for (const inc of includes) {
+        if (typeof inc !== "string") {
+            throw new Error(`Non-string include entry in ${absPath}: ${String(inc)}`);
+        }
+        const incPath = isAbsolute(inc) ? inc : resolve(baseDir, inc);
+        const includedSeed = await loadSeedRecursive(incPath, visited);
+        includedManaged.push(...includedSeed.managedPaths);
+        if (includedSeed.forbiddenPaths) {
+            includedForbidden.push(...includedSeed.forbiddenPaths);
+        }
+        if (includedSeed.unknownKeys)
+            includedUnknown.push(...includedSeed.unknownKeys);
+    }
+    // Unknown keys from this file, plus everything its includes reported. An included
+    // seed's stray key is as silently dropped as the root's, so the queue is unioned.
+    const ownUnknown = unknownSeedKeys(parsed);
+    const own = parsed;
+    const managedPaths = [
+        ...includedManaged,
+        ...asStringArray(own.managed_paths, "managed_paths", absPath),
+    ];
+    const forbiddenPaths = includedForbidden.length > 0 || Array.isArray(own.forbidden_paths)
+        ? [
+            ...includedForbidden,
+            ...asStringArray(own.forbidden_paths, "forbidden_paths", absPath, true),
+        ]
+        : undefined;
+    const scaffoldSourcePaths = Array.isArray(own.scaffold_source_paths)
+        ? asStringArray(own.scaffold_source_paths, "scaffold_source_paths", absPath, true)
+        : undefined;
+    const seed = {
+        version: asString(own.version, "version", absPath),
+        scope: asString(own.scope, "scope", absPath),
+        // forward_base optional per ADR 0176 §4.6 (profile-agnostic packs omit it)
+        ...(own.forward_base && {
+            forwardBase: {
+                bundle: asString(own.forward_base.bundle, "forward_base.bundle", absPath),
+                minimumVersion: asString(own.forward_base.minimum_version, "forward_base.minimum_version", absPath),
+                sourceRepo: own.forward_base.source_repo
+                    ? asString(own.forward_base.source_repo, "forward_base.source_repo", absPath)
+                    : "sdd-method",
+            },
+        }),
+        // vendor_base present only on a vendor-base pack (M-ADR 0175); the
+        // profile-agnostic/forward_base contradiction is caught in validateSeed.
+        ...(own.vendor_base && {
+            vendorBase: {
+                vendor: asString(own.vendor_base.vendor, "vendor_base.vendor", absPath),
+                vendorVersion: asString(own.vendor_base.vendor_version, "vendor_base.vendor_version", absPath),
+            },
+        }),
+        minimumSddCliVersion: asString(own.minimum_sdd_cli_version, "minimum_sdd_cli_version", absPath),
+        description: asString(own.description, "description", absPath),
+        managedPaths,
+        sourcePath: absPath,
+        ...(ownUnknown.length + includedUnknown.length > 0
+            ? { unknownKeys: [...new Set([...includedUnknown, ...ownUnknown])].sort() }
+            : {}),
+        ...(includes.length > 0 && { include: includes }),
+        ...(forbiddenPaths && { forbiddenPaths }),
+        ...(scaffoldSourcePaths && scaffoldSourcePaths.length > 0 && { scaffoldSourcePaths }),
+        ...(own.requires_pack && {
+            requiresPack: {
+                name: asString(own.requires_pack.name, "requires_pack.name", absPath),
+                version: asString(own.requires_pack.version, "requires_pack.version", absPath),
+            },
+        }),
+    };
+    return seed;
+}
+function asString(value, field, file) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Seed field "${field}" must be a non-empty string in ${file}`);
+    }
+    return value;
+}
+function asStringArray(value, field, file, allowEmpty = false) {
+    if (value === undefined || value === null) {
+        if (allowEmpty)
+            return [];
+        throw new Error(`Seed field "${field}" is required in ${file}`);
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Seed field "${field}" must be a list in ${file}`);
+    }
+    for (const entry of value) {
+        if (typeof entry !== "string") {
+            throw new Error(`Seed field "${field}" entries must be strings in ${file}`);
+        }
+    }
+    return value;
+}
+//# sourceMappingURL=seed.js.map

package/dist/lib/pack/validate.js

@@ -0,0 +1,49 @@
+// `pack validate` — reads and checks a context-pack seed; writes nothing.
+// Kept free of any import that reaches `./builder.js`, so that importing it
+// cannot drag pack-building code into a package that must not author
+// (M-ADR 0212 §4.3b). `index.ts` re-exports it, so existing imports are unchanged.
+import { validateSeed } from "./schema.js";
+import { loadSeed } from "./seed.js";
+import { getSddCliVersion } from "../package-version.js";
+import { fail, info, pass, section } from "./log.js";
+export async function runPackValidate(opts, stdout = (s) => process.stdout.write(s)) {
+    stdout(section("Pack validate"));
+    let seed;
+    try {
+        seed = await loadSeed(opts.seedPath);
+    }
+    catch (err) {
+        stdout(fail(`Seed load failed: ${err.message}`));
+        return { exitCode: 1, errors: [{ field: "(load)", message: err.message }] };
+    }
+    // A seed key this build does not know is REPORTED rather than dropped in silence.
+    // Not fatal: an older sdd-cli must still build a seed that declares something newer
+    // than itself, exactly as for `.sdd/sdd-manifest.yaml`. Silence here is what let an
+    // adopter follow the schema and get a clean validation with no effect.
+    if (seed.unknownKeys && seed.unknownKeys.length > 0) {
+        stdout(info(`${seed.unknownKeys.length} seed key(s) not understood by sdd-cli ${getSddCliVersion()} ` +
+            `and therefore IGNORED: ${seed.unknownKeys.join(", ")}. If the seed follows a newer ` +
+            `context-pack-seed-schema than this build, upgrade sdd-cli; otherwise remove or correct the key.`));
+    }
+    const validation = validateSeed(seed);
+    if (!validation.ok) {
+        stdout(fail("Seed validation failed:"));
+        for (const e of validation.errors) {
+            stdout(fail(`  ${e.field}: ${e.message}`));
+        }
+        return { exitCode: 1, errors: validation.errors };
+    }
+    stdout(pass(`Seed valid: ${seed.scope} v${seed.version}`));
+    stdout(info(seed.forwardBase
+        ? `Forward base: ${seed.forwardBase.bundle} >= ${seed.forwardBase.minimumVersion}`
+        : "Forward base: none (profile-agnostic pack, ADR 0176 §4.6)"));
+    if (seed.scaffoldSourcePaths) {
+        stdout(info(`Scaffold-source prefixes: ${seed.scaffoldSourcePaths.join(", ")}`));
+    }
+    stdout(info(`Managed paths: ${seed.managedPaths.length}`));
+    if (seed.requiresPack) {
+        stdout(info(`requires_pack: ${seed.requiresPack.name} ${seed.requiresPack.version}`));
+    }
+    return { exitCode: 0, errors: [] };
+}
+//# sourceMappingURL=validate.js.map

package/dist/lib/package-version.js

@@ -0,0 +1,92 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Read the package version from package.json at runtime so the various
+ * version-string consumers (CLI --version, MCP server identity,
+ * catalogue error messages) cannot drift from the published version.
+ *
+ * Resolves relative to this module's compiled location:
+ *   - In source layout: src/lib/package-version.ts → package.json (../../)
+ *   - In dist layout:   dist/lib/package-version.js → package.json (../../)
+ *
+ * Cached on first call.
+ */
+let cached;
+let cachedEngine;
+/**
+ * The version of the sdd-cli ENGINE this code is. In @sdd-method/sdd-cli it is the package
+ * version. In a persona package (verify-cli, maintain-cli) the package version is the
+ * persona's own (0.1.0, 1.0.0), while every check and stamp that means "which sdd-cli is
+ * this" (a bundle's minimum_sdd_cli_version, the CLI version stamped into catalogues, the
+ * MCP server identity) must see the engine it was built from. The persona build writes that
+ * as `sddCliVersion` in the package's package.json. Found by maintain-cli's acceptance run:
+ * its sync refused every bundle because 0.1.0 < 1.41.0.
+ */
+export function getSddCliVersion() {
+    if (cachedEngine !== undefined)
+        return cachedEngine;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(resolve(here, "..", "..", "package.json"), "utf8"));
+    cachedEngine = pkg.sddCliVersion ?? pkg.version;
+    return cachedEngine;
+}
+/** The package's own version: what `--version` prints. For the engine version, use getSddCliVersion. */
+export function getPackageVersion() {
+    if (cached !== undefined)
+        return cached;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(here, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    cached = pkg.version;
+    return cached;
+}
+/**
+ * The @sdd-method/verify-cli version released WITH this sdd-cli (M-ADR 0212
+ * §6.1 Phase 1). The method-managed CI workflow installs exactly this version,
+ * so the CLI that syncs a repository decides which verifier judges it.
+ *
+ * Read from dist/verify-version.json, which the build copies from
+ * scripts/verify-version.json. Never from scripts/ in a built layout: the global
+ * `sdd-cli` on the method's machines is a link into the checkout, so reading the
+ * committed file live would render a version bumped in source but not yet
+ * published into every workflow synced that day, while dist/ still lagged.
+ * Source layout (tests) has no copy and reads scripts/ directly.
+ *
+ * Throws rather than defaults: a missing version must not render a floating install.
+ */
+const cachedPersona = {};
+/**
+ * One exact npm version: X.Y.Z, optionally with a prerelease tag (1.1.0-rc.0), which a release
+ * candidate published under the `next` dist-tag needs so hosted CI can run it before the release.
+ * Never a range, a tag name or a wildcard.
+ */
+export const EXACT_VERSION = /^\d+\.\d+\.\d+(-[0-9A-Za-z]+(\.[0-9A-Za-z]+)*)?$/;
+function personaVersion(persona) {
+    const hit = cachedPersona[persona];
+    if (hit !== undefined)
+        return hit;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const fromSource = here.endsWith(`${sep}src${sep}lib`);
+    const file = fromSource
+        ? resolve(here, "..", "..", "scripts", `${persona}-version.json`)
+        : resolve(here, "..", `${persona}-version.json`);
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof parsed.version !== "string" || !EXACT_VERSION.test(parsed.version)) {
+        throw new Error(`${file} has no semver \`version\`; refusing to render an unpinned ${persona}-cli install`);
+    }
+    cachedPersona[persona] = parsed.version;
+    return parsed.version;
+}
+export function getVerifyCliVersion() {
+    return personaVersion("verify");
+}
+/**
+ * The @sdd-method/maintain-cli version released WITH this sdd-cli. The managed CI workflow's
+ * catalogue freshness step installs exactly this version (M-ADR 0218 §5; ruled 2026-10-15, sdm-jts.6).
+ * Read the same way as the verify version, for the same reason (dist/ copy, never scripts/ live).
+ */
+export function getMaintainCliVersion() {
+    return personaVersion("maintain");
+}
+//# sourceMappingURL=package-version.js.map

package/dist/lib/plan/index.js

@@ -0,0 +1,69 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { readSdd } from "./read-sdd.js";
+import { PILOT_TEMPLATE_REL_PATHS, renderPilotKickoff, resolvePilotTemplate } from "./render-template.js";
+export async function runPlanPilot(inputs, write) {
+    const templatePath = await resolvePilotTemplate(inputs.sddRoot);
+    if (templatePath === undefined) {
+        const msg = `[FAIL] pilot-kickoff template not found at ${join(inputs.sddRoot, PILOT_TEMPLATE_REL_PATHS[0])}. Sync the method baseline first.\n`;
+        write(msg);
+        return {
+            exitCode: 1,
+            outputPath: inputs.outputPath ?? defaultOutputPath(inputs),
+            rendered: "",
+            dryRun: inputs.dryRun === true,
+        };
+    }
+    const snapshot = await readSdd({
+        sddRoot: inputs.sddRoot,
+        service: inputs.service,
+        capability: inputs.capability,
+        domain: inputs.domain,
+    });
+    const rendered = await renderPilotKickoff({
+        snapshot,
+        platformCliVersionHint: inputs.platformCliVersionHint ?? "0.5.0",
+        today: inputs.today ?? new Date().toISOString().slice(0, 10),
+    });
+    const outputPath = inputs.outputPath ?? defaultOutputPath(inputs);
+    const dryRun = inputs.dryRun === true;
+    if (dryRun) {
+        write(rendered);
+        write(`\n[INFO] dry-run: would write to ${outputPath}\n`);
+        return { exitCode: 0, outputPath, rendered, dryRun: true };
+    }
+    const outputAbs = resolveOutputAbs(inputs.sddRoot, outputPath);
+    if (await fileExists(outputAbs)) {
+        write(`[FAIL] refusing to overwrite existing file at ${outputAbs}. Move or rename, or re-run with --dry-run.\n`);
+        return { exitCode: 1, outputPath: outputAbs, rendered, dryRun: false };
+    }
+    await mkdir(dirname(outputAbs), { recursive: true });
+    await writeFile(outputAbs, rendered, "utf8");
+    write(`[PASS] pilot-kickoff scaffolded at ${outputAbs}\n` +
+        `  aggregates: ${snapshot.repoConfig.aggregates.length}\n` +
+        `  feature specs: ${snapshot.featureSpecCount}\n` +
+        `  capability spec: ${snapshot.capabilitySpecPresent ? "present" : "MISSING"}\n` +
+        `  traceability manifest: ${snapshot.traceabilityManifestPresent ? "present" : "MISSING"}\n`);
+    return { exitCode: 0, outputPath: outputAbs, rendered, dryRun: false };
+}
+function defaultOutputPath(inputs) {
+    return join("content/product/plans", `${inputs.service}-pilot-kickoff.md`);
+}
+function resolveOutputAbs(sddRoot, outputPath) {
+    if (outputPath.startsWith("/"))
+        return outputPath;
+    return join(sddRoot, outputPath);
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Keep readFile import in use; some test harness entry points trigger module
+// tree-shake warnings otherwise.
+void readFile;
+//# sourceMappingURL=index.js.map

package/dist/lib/plan/read-sdd.js

@@ -0,0 +1,102 @@
+import { access, readdir, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { liveReader } from "../sdd-reader.js";
+import { parseRepoConfigFile } from "../sdd-index/repo-config.js";
+/**
+ * Read everything `plan --pilot` needs from the SDD filesystem: the service's
+ * repo-config manifest (domain, service_type, aggregates, dependencies,
+ * contracts), the count of feature spec files under the capability, and
+ * presence of the capability spec + traceability manifest.
+ *
+ * Repo-config parsing delegates to the shared sdd-index module so the
+ * `plan --pilot` path and the MCP dependency-graph tools see the same
+ * view. The richer ADR 0110 shape (package/version/stability) is
+ * flattened back to path-strings here to preserve the legacy
+ * `RepoConfig` contract.
+ */
+export async function readSdd(inputs) {
+    const { sddRoot, service, capability, domain } = inputs;
+    const manifestAbsPath = join(sddRoot, "orchestration/repo-config", domain, `${service}.yaml`);
+    const repoConfig = await readRepoConfigFor(sddRoot, manifestAbsPath);
+    const featuresDir = join(sddRoot, "docs/domains", domain, "product/features", capability);
+    const featureSpecs = await listFeatureSpecs(featuresDir);
+    const featureSpecRelativePaths = featureSpecs.map((p) => join("docs/domains", domain, "product/features", capability, p));
+    const capabilitySpecPath = join("docs/domains", domain, "product", `${capability}.md`);
+    const capabilitySpecPresent = await fileExists(join(sddRoot, capabilitySpecPath));
+    const traceabilityManifestPath = join("docs/domains", domain, "product", `${capability}.traceability.yaml`);
+    const traceabilityManifestPresent = await fileExists(join(sddRoot, traceabilityManifestPath));
+    return {
+        sddRoot,
+        service,
+        capability,
+        domain,
+        repoConfig,
+        featureSpecCount: featureSpecs.length,
+        featureSpecRelativePaths,
+        capabilitySpecPresent,
+        capabilitySpecPath,
+        traceabilityManifestPresent,
+        traceabilityManifestPath,
+    };
+}
+async function readRepoConfigFor(sddRoot, manifestAbsPath) {
+    const empty = {
+        path: manifestAbsPath,
+        aggregates: [],
+        internalDependencies: [],
+        contracts: { openapi: [], proto: [], avro: [], spicedb: [], graphql: [] },
+    };
+    if (!(await fileExists(manifestAbsPath)))
+        return empty;
+    const reader = liveReader(sddRoot);
+    const relPath = relative(sddRoot, manifestAbsPath);
+    const warnings = [];
+    const node = parseRepoConfigFile(reader, relPath, warnings);
+    if (!node)
+        return empty;
+    return legacyShape(node, manifestAbsPath);
+}
+function legacyShape(node, sourcePath) {
+    const byKind = {
+        openapi: [],
+        proto: [],
+        avro: [],
+        spicedb: [],
+    };
+    for (const ref of node.contracts)
+        byKind[ref.kind].push(ref.path);
+    return {
+        path: sourcePath,
+        ...(node.description !== undefined ? { description: node.description } : {}),
+        ...(node.serviceType !== undefined ? { serviceType: node.serviceType } : {}),
+        aggregates: Array.from(node.aggregates),
+        internalDependencies: Array.from(node.internalDependencies),
+        contracts: byKind,
+    };
+}
+async function listFeatureSpecs(featuresDir) {
+    if (!(await fileExists(featuresDir)))
+        return [];
+    const entries = await readdir(featuresDir);
+    const specs = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const full = join(featuresDir, entry);
+        const s = await stat(full);
+        if (s.isFile())
+            specs.push(entry);
+    }
+    specs.sort();
+    return specs;
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=read-sdd.js.map