@sdd-method/maintain-cli 0.0.0-stage → 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,17 @@
+sdd-cli
+Copyright 2026 Tom Foster
+
+This product includes software developed as part of the SDD method
+distribution (https://github.com/tomfosteruk/sdd-method).
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# @sdd-method/maintain-cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`sdd-maintain` brings an SDD repository current and rebuilds its derived model, and **cannot author specification content** (M-ADR 0218).
+
+Verbs: everything in `@sdd-method/verify-cli`, plus `sync`, `generate-briefing`, `context pull`, `catalogue build`, `catalogue aggregate`, `catalogue graph`, `catalogue diff`, `pack build`, `render screen`.
+
+Each writes only derived or method-managed content, and two runs on the same commit write the same bytes. Authoring verbs — `init`, `scaffold`, `plan`, `mcp`, `conformance` and the rest — are not present in it, and are in `@sdd-method/sdd-cli`. Invoking one fails with exit 1.

package/dist/lib/adr-origin.js

@@ -0,0 +1,59 @@
+// Single source of truth for ADR origin prefixes (M-ADR 0140 §4.1 / M-ADR 0186).
+//
+// The origin prefix is CANONICAL and marks the producer tier — method /
+// reference-architecture / adopter-platform / adopter-domain. It is derived two
+// ways, by design (M-ADR 0186 §4.3):
+//   - PRODUCER prefixes are a pure function of the NUMBER band, because
+//     `0xxx`/`9xxx` are globally-unique producer namespaces (disjoint ranges).
+//   - ADOPTER prefixes (`P-`/`D-`) are a function of SCOPE — where the ADR lives
+//     — because adopter numbers are a flat local sequence (`1000–8999`, M-ADR
+//     0140) that does not globally encode platform-vs-domain. A platform ADR is
+//     `P-ADR` and a domain ADR is `D-ADR` at whatever number it holds.
+//
+// Every ADR detection/parse point resolves by NUMBER and treats the prefix as an
+// interchangeable origin marker, so a bare `ADR NNNN` (legacy / unmigrated /
+// human) and any prefixed form map to the same `ADR-NNNN` identity during the
+// dual-resolution window. Adding a future tier is a one-line change here.
+/**
+ * The producer origin prefix for an ADR number, by globally-unique band:
+ *   `0000–0999` → `M-ADR`  (method)
+ *   `9000–9999` → `RA-ADR` (reference architecture)
+ * Adopter numbers (`1000–8999`) are NOT number-derivable — their prefix depends
+ * on scope; see `originPrefixForPath`. Returns `null` for them.
+ */
+export function originPrefixForNumber(num) {
+    if (/^0\d{3}$/.test(num))
+        return "M-ADR";
+    if (/^9\d{3}$/.test(num))
+        return "RA-ADR";
+    return null;
+}
+/**
+ * The canonical origin prefix for an ADR at a repo-relative path (M-ADR 0186):
+ * producer ADRs by number band; adopter ADRs by SCOPE (directory) — a domain
+ * ADR (`docs/domains/<d>/…/adr/`) is `D-ADR`, a platform ADR (`docs/platform/adr/`)
+ * is `P-ADR`. `docs/method/platform-adr/` holds method (`0xxx`) ADRs, resolved by
+ * number to `M-ADR` before the scope check. Returns `null` if undeterminable.
+ */
+export function originPrefixForPath(relPath, num) {
+    const byNum = originPrefixForNumber(num);
+    if (byNum)
+        return byNum;
+    if (/\/domains\/[^/]+\/(?:.*\/)?adr\//.test(relPath))
+        return "D-ADR";
+    if (/\/platform\/adr\//.test(relPath))
+        return "P-ADR";
+    return null;
+}
+/**
+ * Regex source matching the optional origin prefix that precedes `ADR` in a
+ * filename, heading, or reference — `M-`, `RA-`, `P-`, `D-`, or none (a bare or
+ * not-yet-migrated identifier). Non-capturing, so composing it does not shift a
+ * caller's group indices.
+ */
+export const ORIGIN_PREFIX_SRC = "(?:M-|RA-|P-|D-)?";
+/** Strip a leading origin prefix (`M-ADR 0044` → `ADR 0044`); a bare id is returned unchanged. */
+export function stripOriginPrefix(id) {
+    return id.replace(/^(?:M-|RA-|P-|D-)(?=ADR\b)/i, "");
+}
+//# sourceMappingURL=adr-origin.js.map

package/dist/lib/agent-harness.js

@@ -0,0 +1,28 @@
+/**
+ * Agent-harness identifiers — the value space of `--agent-harness` on
+ * `sdd-cli init` and `sdd-cli sync` per ADR 0141 §4.6.
+ *
+ * Claude Code is the reference implementation per ADR 0141 §4.4 and
+ * the default. GitHub Copilot CLI is the second reference per
+ * `docs/method/methods/hook-contracts.md`. Adopters using a different
+ * harness implement the portable contracts themselves per ADR 0141 §4.5.
+ */
+export const AGENT_HARNESSES = ["claude-code", "github-copilot-cli"];
+export const DEFAULT_AGENT_HARNESS = "claude-code";
+export function isAgentHarness(value) {
+    return AGENT_HARNESSES.includes(value);
+}
+/**
+ * Resolve an optional CLI input to a concrete harness, falling back to
+ * the reference default when unset. Throws on an unsupported value so
+ * the CLI can surface a clear error to the caller.
+ */
+export function resolveAgentHarness(input) {
+    if (input === undefined)
+        return DEFAULT_AGENT_HARNESS;
+    if (!isAgentHarness(input)) {
+        throw new Error(`Unsupported --agent-harness "${input}". Supported: ${AGENT_HARNESSES.join(", ")}.`);
+    }
+    return input;
+}
+//# sourceMappingURL=agent-harness.js.map

package/dist/lib/briefing/index.js

@@ -0,0 +1,13 @@
+/**
+ * Public facade for the briefing layer (ADR 0148).
+ *
+ * `agent-instructions.md` is the harness-neutral canonical briefing
+ * (fully method-managed; sync overwrites unconditionally). Harness
+ * wrappers (`CLAUDE.md`, `AGENTS.md`, …) are thin pointers with a
+ * `<!-- method-managed: begin/end -->` block at the top; adopter
+ * content below survives sync via the existing `writeMarkedBlockFile`
+ * machinery.
+ */
+export { AGENT_INSTRUCTIONS_REL_PATH, BRIEFING_TEMPLATE_ROOT, WRAPPER_BLOCK_BEGIN, WRAPPER_BLOCK_END, extractWrapperBlock, findUnresolvedPlaceholders, harnessWrapperOutputPath, renderAgentInstructions, renderHarnessWrapper, splitWrapperTemplate, substitute, } from "./render.js";
+export { resolveBriefingVariables } from "./variables.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/briefing/render.js

@@ -0,0 +1,123 @@
+/**
+ * Renderer for the briefing-layer templates per ADR 0148 + Phase 4 of
+ * `adopt-agent-instructions-briefing-layer.md`.
+ *
+ * Templates ship via the method baseline bundle and land at
+ * `<target>/orchestration/templates/briefing/...` after sync's
+ * `copyManagedFiles` step. Both `sdd-cli init` and `sdd-cli sync` read
+ * the on-disk templates and substitute the four canonical variables.
+ *
+ * Substitution is a deliberate Handlebars *subset* — `{{var}}` only,
+ * no helpers / conditionals / partials. Keeps the runtime-dep
+ * allowlist clean (no Handlebars package) and matches the template
+ * shapes shipped upstream.
+ */
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+export const BRIEFING_TEMPLATE_ROOT = "orchestration/templates/briefing";
+export const AGENT_INSTRUCTIONS_REL_PATH = "agent-instructions.md";
+const HARNESS_WRAPPER_TEMPLATE = {
+    "claude-code": {
+        templateRel: "claude-code/CLAUDE.md.hbs",
+        outputRel: "CLAUDE.md",
+    },
+    "github-copilot-cli": {
+        templateRel: "github-copilot-cli/AGENTS.md.hbs",
+        outputRel: "AGENTS.md",
+    },
+};
+/** Output filename per harness — e.g. `CLAUDE.md` or `AGENTS.md`. */
+export function harnessWrapperOutputPath(harness) {
+    return HARNESS_WRAPPER_TEMPLATE[harness].outputRel;
+}
+/**
+ * Marker pair the wrapper templates use to delimit the method-managed
+ * region. The wrapper sync path slices this region out of the freshly
+ * rendered template and hands it to `writeMarkedBlockFile`.
+ */
+export const WRAPPER_BLOCK_BEGIN = "<!-- method-managed: begin -->";
+export const WRAPPER_BLOCK_END = "<!-- method-managed: end -->";
+/**
+ * Substitute the four canonical variables into a template string. Any
+ * `{{var}}` placeholder whose name is not in the variable set is left
+ * verbatim — callers may pre-check for leftovers if strict rendering
+ * is desired.
+ */
+export function substitute(template, vars) {
+    const map = {
+        sdd_name: vars.sdd_name,
+        repo_kind: vars.repo_kind,
+        baseline_version: vars.baseline_version,
+        sync_date: vars.sync_date,
+    };
+    return template.replace(/\{\{\s*([a-z_][a-z0-9_]*)\s*\}\}/g, (full, key) => {
+        return key in map ? map[key] : full;
+    });
+}
+/**
+ * Find any unresolved `{{var}}` placeholders. Returns the set of
+ * placeholder names (de-duplicated). Callers use this to decide
+ * whether to warn or hard-fail on a stale template.
+ */
+export function findUnresolvedPlaceholders(rendered) {
+    const found = new Set();
+    for (const m of rendered.matchAll(/\{\{\s*([a-z_][a-z0-9_]*)\s*\}\}/g)) {
+        found.add(m[1]);
+    }
+    return [...found];
+}
+export async function renderAgentInstructions(targetRepo, vars) {
+    const templatePath = join(targetRepo, BRIEFING_TEMPLATE_ROOT, "agent-instructions.md.hbs");
+    return renderFromPath(templatePath, vars);
+}
+export async function renderHarnessWrapper(targetRepo, harness, vars) {
+    const { templateRel } = HARNESS_WRAPPER_TEMPLATE[harness];
+    const templatePath = join(targetRepo, BRIEFING_TEMPLATE_ROOT, templateRel);
+    return renderFromPath(templatePath, vars);
+}
+/**
+ * Split a fully-rendered wrapper template at the method-managed
+ * markers. The sync flow merges `block` into the existing wrapper and
+ * uses `pre`/`post` as scaffold-fill for blank regions around it.
+ *
+ * Throws when the markers aren't both found — that's a template-
+ * authoring bug, not an adopter-side issue.
+ */
+export function splitWrapperTemplate(rendered) {
+    const beginIdx = rendered.indexOf(WRAPPER_BLOCK_BEGIN);
+    const endIdx = rendered.indexOf(WRAPPER_BLOCK_END, beginIdx);
+    if (beginIdx === -1 || endIdx === -1) {
+        throw new Error("Wrapper template missing method-managed markers: " +
+            `expected ${WRAPPER_BLOCK_BEGIN} ... ${WRAPPER_BLOCK_END} (template-authoring bug)`);
+    }
+    const blockEnd = endIdx + WRAPPER_BLOCK_END.length;
+    return {
+        pre: rendered.slice(0, beginIdx),
+        block: rendered.slice(beginIdx, blockEnd),
+        post: rendered.slice(blockEnd),
+    };
+}
+/**
+ * Extract the method-managed slice (begin marker through end marker,
+ * inclusive) from a fully-rendered wrapper template.
+ */
+export function extractWrapperBlock(rendered) {
+    return splitWrapperTemplate(rendered).block;
+}
+async function renderFromPath(templatePath, vars) {
+    if (!(await fileExists(templatePath)))
+        return null;
+    const raw = await readFile(templatePath, "utf8");
+    const content = substitute(raw, vars);
+    return { content, unresolved: findUnresolvedPlaceholders(content) };
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=render.js.map

package/dist/lib/briefing/variables.js

@@ -0,0 +1,92 @@
+/**
+ * Variable resolution for the briefing layer per ADR 0148 §4.1 + the
+ * Phase 4 setup notes in `adopt-agent-instructions-briefing-layer.md`.
+ *
+ * The four variables are sourced from target-repo state:
+ *
+ *   sdd_name         basename(targetRepo) — overridden by
+ *                    `.sdd/sdd-manifest.yaml::sdd_id` when present.
+ *   repo_kind        `.sdd-repo-kind` content (platform-product /
+ *                    application-product / integration-product /
+ *                    reverse-corpus).
+ *   baseline_version forward-base bundle's `bundle_version` from
+ *                    `method-baseline.lock`.
+ *   sync_date        caller-supplied ISO date (today for init/sync).
+ *
+ * No new YAML parser added — the manifest is a single optional scalar
+ * read; existing scalar-line parser in src/lib/bundle.ts is the
+ * precedent for this style.
+ */
+import { access, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { readLockFile } from "../lock-file.js";
+import { readRepoKind } from "../repo-kind.js";
+export async function resolveBriefingVariables(opts) {
+    const sdd_name = await resolveSddName(opts.targetRepo);
+    const repo_kind = opts.repoKindOverride ?? (await requireRepoKind(opts.targetRepo));
+    const baseline_version = opts.baselineVersionOverride ??
+        (await resolveBaselineVersion(opts.targetRepo));
+    const sync_date = opts.syncDate ?? todayIso();
+    return { sdd_name, repo_kind, baseline_version, sync_date };
+}
+async function resolveSddName(targetRepo) {
+    const fromManifest = await tryReadSddManifestId(targetRepo);
+    if (fromManifest !== null)
+        return fromManifest;
+    return basename(targetRepo);
+}
+async function tryReadSddManifestId(targetRepo) {
+    const path = join(targetRepo, ".sdd", "sdd-manifest.yaml");
+    if (!(await fileExists(path)))
+        return null;
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    // Single-scalar line parse, matching bundle.ts style. The catalogue
+    // surface uses a full YAML loader elsewhere; here we only want one
+    // optional field, so this stays dependency-light.
+    for (const line of raw.split("\n")) {
+        const m = /^sdd_id: (.+)$/.exec(line.trim());
+        if (m) {
+            const value = m[1].trim().replace(/^["']|["']$/g, "");
+            if (value.length > 0)
+                return value;
+        }
+    }
+    return null;
+}
+async function requireRepoKind(targetRepo) {
+    const kind = await readRepoKind(targetRepo);
+    if (!kind) {
+        throw new Error(`Cannot resolve briefing variables: .sdd-repo-kind missing at ${targetRepo}`);
+    }
+    return kind;
+}
+async function resolveBaselineVersion(targetRepo) {
+    const lock = await readLockFile(targetRepo);
+    if (!lock) {
+        throw new Error(`Cannot resolve baseline_version: method-baseline.lock missing at ${targetRepo}`);
+    }
+    const forwardBase = lock.bundles.find((b) => b.isForwardBase);
+    if (!forwardBase) {
+        throw new Error(`Cannot resolve baseline_version: no forward-base bundle in method-baseline.lock at ${targetRepo}`);
+    }
+    return forwardBase.bundleVersion;
+}
+function todayIso() {
+    return new Date().toISOString().slice(0, 10);
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=variables.js.map

package/dist/lib/bundle.js

@@ -0,0 +1,123 @@
+import { execFile as execFileCb } from "node:child_process";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { parse as parseYaml } from "yaml";
+import { isBundleName, isForwardBase } from "./repo-kind.js";
+const execFile = promisify(execFileCb);
+export const MANIFEST_FILE = "BUNDLE_MANIFEST.yaml";
+export const MANAGED_PATHS_FILE = "MANAGED_PATHS.txt";
+export const PAYLOAD_DIR = "payload";
+export async function loadBundle(bundlePath) {
+    const extractionDir = await mkdtemp(join(tmpdir(), "sdd-cli-bundle-"));
+    let rootDir;
+    try {
+        await execFile("tar", ["-xzf", bundlePath, "-C", extractionDir]);
+        rootDir = await findBundleRoot(extractionDir);
+    }
+    catch (err) {
+        await rm(extractionDir, { recursive: true, force: true });
+        throw err;
+    }
+    const manifestPath = join(rootDir, MANIFEST_FILE);
+    const managedPathsPath = join(rootDir, MANAGED_PATHS_FILE);
+    const payloadDir = join(rootDir, PAYLOAD_DIR);
+    const manifestRaw = await readFile(manifestPath, "utf8");
+    const manifest = parseManifest(manifestRaw);
+    const managedPathsRaw = await readFile(managedPathsPath, "utf8");
+    const managedPaths = parseManagedPaths(managedPathsRaw);
+    return {
+        manifest,
+        managedPaths,
+        rootDir,
+        payloadDir,
+        cleanup: () => rm(extractionDir, { recursive: true, force: true }),
+    };
+}
+async function findBundleRoot(extractionDir) {
+    const entries = await readdir(extractionDir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory());
+    if (dirs.length !== 1) {
+        throw new Error(`Expected exactly one top-level directory in bundle; found ${dirs.length}`);
+    }
+    return join(extractionDir, dirs[0].name);
+}
+export function parseManifest(raw) {
+    const parsed = parseYaml(raw);
+    if (parsed === null || typeof parsed !== "object") {
+        throw new Error("BUNDLE_MANIFEST.yaml is not a YAML object");
+    }
+    const bundleName = asStringOrUndefined(parsed.bundle_name);
+    const bundleVersion = asStringOrUndefined(parsed.bundle_version);
+    const sourceCommit = asStringOrUndefined(parsed.source_commit);
+    if (!bundleName || !bundleVersion || sourceCommit === undefined) {
+        throw new Error(`BUNDLE_MANIFEST.yaml missing required keys (bundle_name, bundle_version, source_commit)`);
+    }
+    // Backward-compatible default: sdd-method bundles omit is_forward_base
+    // in their manifest; if absent, infer from the forward-base set. This
+    // MUST use isForwardBase (not isBundleName) — additive bundles like
+    // reverse-extension-baseline are known bundle names but are NOT forward
+    // bases, and inferring them as forward bases makes sync demand a profile
+    // mapping they don't have ("Forward-base bundle ... has no profile mapping").
+    const isForwardBaseRaw = parsed.is_forward_base === undefined ? null : Boolean(parsed.is_forward_base);
+    const isForwardBaseInferred = isForwardBaseRaw === null ? isForwardBase(bundleName) : isForwardBaseRaw;
+    // Forward bases must use a known bundle name; adopter packs may use
+    // any string. This enforces the closed enum where it matters and
+    // opens it where ADR 0151 requires.
+    if (isForwardBaseInferred && !isBundleName(bundleName)) {
+        throw new Error(`Unknown bundle_name in manifest for forward base: ${JSON.stringify(bundleName)}`);
+    }
+    const manifest = {
+        bundleName,
+        bundleVersion,
+        sourceCommit,
+        isForwardBase: isForwardBaseInferred,
+    };
+    const minVer = asStringOrUndefined(parsed.minimum_sdd_cli_version);
+    if (minVer)
+        manifest.minimumSddCliVersion = minVer;
+    if (parsed.requires_forward_base) {
+        const fb = parsed.requires_forward_base;
+        const bundle = asStringOrUndefined(fb.bundle);
+        const minimumVersion = asStringOrUndefined(fb.minimum_version);
+        const sourceRepo = asStringOrUndefined(fb.source_repo) ?? "sdd-method";
+        if (bundle && minimumVersion) {
+            manifest.requiresForwardBase = { bundle, minimumVersion, sourceRepo };
+        }
+    }
+    if (parsed.requires_pack) {
+        const rp = parsed.requires_pack;
+        const name = asStringOrUndefined(rp.name);
+        const version = asStringOrUndefined(rp.version);
+        if (name && version) {
+            manifest.requiresPack = { name, version };
+        }
+    }
+    const producer = asStringOrUndefined(parsed.produced_by_adopter);
+    if (producer)
+        manifest.producedByAdopter = producer;
+    const scope = asStringOrUndefined(parsed.scope);
+    if (scope)
+        manifest.scope = scope;
+    if (Array.isArray(parsed.scaffold_source_paths)) {
+        const ssp = parsed.scaffold_source_paths.filter((e) => typeof e === "string" && e.length > 0);
+        if (ssp.length > 0)
+            manifest.scaffoldSourcePaths = ssp;
+    }
+    return manifest;
+}
+export function parseManagedPaths(raw) {
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function asStringOrUndefined(value) {
+    if (typeof value !== "string")
+        return undefined;
+    if (value.length === 0)
+        return undefined;
+    return value;
+}
+//# sourceMappingURL=bundle.js.map