cyber-sdd 0.7.0 → 0.7.1

package/skills/manage-ignore/scripts/manage-ignore.mjs

@@ -1,12 +1,285 @@
-// Launcher for the engine of the same name. Run it as `node <skill>/scripts/<engine>.mjs`.
-// A checkout runs the .mts source. An npm install keeps the skill under node_modules, where Node
-// will not strip types, so it runs the self-contained bundle built for the package.
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-const self = fileURLToPath(import.meta.url)
-const installed = /[\\/]node_modules[\\/]/.test(self)
-const target = self.replace(/\.mjs$/, installed ? '.bundle.mjs' : '.mts')
-const run = spawnSync(process.execPath, [...process.execArgv, target, ...process.argv.slice(2)], { stdio: 'inherit' })
-if (run.error) throw run.error
-process.exitCode = run.status ?? 1
+#!/usr/bin/env node
+// Compiled by `universal-plugin plugin build` from src/manage-ignore/manage-ignore.mts. Edit the source, not this file.
+globalThis.__SKILL_SCRIPT__ = {"package":null,"bin":null,"version":"0.7.1","entry":"skills/manage-ignore/scripts/manage-ignore.mjs","commands":{}};
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/manage-ignore/manage-ignore.mts
+const IGNORE_FILE = ".agents/sdd/.sddignore";
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	".turbo",
+	".next",
+	"coverage"
+]);
+function splitLines(text) {
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+function readIgnoreLines(root) {
+	const file = join(root, IGNORE_FILE);
+	if (!existsSync(file)) return [];
+	try {
+		return splitLines(readFileSync(file, "utf8"));
+	} catch {
+		return [];
+	}
+}
+function writeIgnoreLines(root, lines) {
+	const file = join(root, IGNORE_FILE);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, lines.length === 0 ? "" : `${lines.join("\n")}\n`);
+}
+function isRuleLine(line) {
+	const t = line.trim();
+	return t !== "" && !t.startsWith("#");
+}
+function listRules(root) {
+	return readIgnoreLines(root).filter(isRuleLine).map((l) => l.trim());
+}
+function hasUnclosedBracket(s) {
+	let i = 0;
+	while (i < s.length) {
+		if (s[i] === "\\") {
+			i += 2;
+			continue;
+		}
+		if (s[i] === "[") {
+			const close = s.indexOf("]", i + 1);
+			if (close === -1) return true;
+			i = close + 1;
+			continue;
+		}
+		i++;
+	}
+	return false;
+}
+function isValidPattern(pattern) {
+	let s = pattern;
+	if (s.startsWith("!")) s = s.slice(1);
+	s = s.replace(/^\s+|\s+$/g, "");
+	if (s === "" || s.startsWith("#")) return false;
+	if (hasUnclosedBracket(s)) return false;
+	return true;
+}
+function addRule(root, pattern) {
+	const p = pattern.trim();
+	if (!isValidPattern(p)) return {
+		ok: false,
+		reason: "malformed gitignore pattern"
+	};
+	const lines = readIgnoreLines(root);
+	if (lines.some((l) => l.trim() === p)) return {
+		ok: true,
+		changed: false,
+		rules: listRules(root),
+		message: "already present"
+	};
+	const next = [...lines, p];
+	writeIgnoreLines(root, next);
+	return {
+		ok: true,
+		changed: true,
+		rules: next.filter(isRuleLine).map((l) => l.trim()),
+		message: `added ${p}`
+	};
+}
+function removeRule(root, pattern) {
+	const p = pattern.trim();
+	const lines = readIgnoreLines(root);
+	const next = lines.filter((l) => l.trim() !== p);
+	if (next.length === lines.length) return {
+		ok: true,
+		changed: false,
+		rules: listRules(root),
+		message: "nothing was removed"
+	};
+	writeIgnoreLines(root, next);
+	return {
+		ok: true,
+		changed: true,
+		rules: next.filter(isRuleLine).map((l) => l.trim()),
+		message: `removed ${p}`
+	};
+}
+function inducePatterns(_root, samplePath) {
+	const normalized = samplePath.trim().replace(/\\/g, "/");
+	if (normalized.startsWith("/")) return {
+		ok: false,
+		reason: "path is not repo-relative (absolute)"
+	};
+	const rel = normalized.replace(/\/+$/g, "");
+	if (rel === "" || /(^|\/)\.\.(\/|$)/.test(rel)) return {
+		ok: false,
+		reason: "path is not repo-relative"
+	};
+	const generalized = `**/${rel.split("/").pop() ?? rel}`;
+	return {
+		ok: true,
+		candidates: generalized === rel ? [rel] : [rel, generalized]
+	};
+}
+function tokenize(pat) {
+	const tokens = [];
+	for (let i = 0; i < pat.length; i++) {
+		const c = pat[i];
+		if (c === "*") {
+			if (pat[i + 1] === "*") {
+				i++;
+				if (pat[i + 1] === "/") {
+					i++;
+					tokens.push({ kind: "deepdir" });
+				} else tokens.push({ kind: "deep" });
+			} else tokens.push({ kind: "star" });
+		} else if (c === "?") tokens.push({ kind: "one" });
+		else if (c === "[") {
+			let j = i + 1;
+			const negated = pat[j] === "!";
+			if (negated) j++;
+			let chars = "";
+			while (j < pat.length && pat[j] !== "]") chars += pat[j++];
+			tokens.push({
+				kind: "class",
+				negated,
+				chars
+			});
+			i = j;
+		} else tokens.push({
+			kind: "lit",
+			ch: c
+		});
+	}
+	return tokens;
+}
+function classHas(chars, ch) {
+	for (let k = 0; k < chars.length; k++) if (chars[k + 1] === "-" && k + 2 < chars.length) {
+		if (ch >= chars[k] && ch <= chars[k + 2]) return true;
+		k += 2;
+	} else if (chars[k] === ch) return true;
+	return false;
+}
+function matchTokens(tokens, path, start) {
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (ti, pi) => {
+		const key = ti * (path.length + 1) + pi;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		if (ti === tokens.length) return pi === path.length || path[pi] === "/";
+		const t = tokens[ti];
+		switch (t.kind) {
+			case "lit": return path[pi] === t.ch && walk(ti + 1, pi + 1);
+			case "one": return pi < path.length && path[pi] !== "/" && walk(ti + 1, pi + 1);
+			case "class": return pi < path.length && classHas(t.chars, path[pi]) !== t.negated && walk(ti + 1, pi + 1);
+			case "star": for (let k = pi;; k++) {
+				if (walk(ti + 1, k)) return true;
+				if (k >= path.length || path[k] === "/") return false;
+			}
+			case "deep":
+				for (let k = pi; k <= path.length; k++) if (walk(ti + 1, k)) return true;
+				return false;
+			case "deepdir":
+				if (walk(ti + 1, pi)) return true;
+				for (let k = pi; k < path.length; k++) if (path[k] === "/" && walk(ti + 1, k + 1)) return true;
+				return false;
+		}
+	};
+	return walk(0, start);
+}
+function matchesPattern(pattern, path) {
+	let pat = pattern.startsWith("!") ? pattern.slice(1) : pattern;
+	if (pat.endsWith("/")) pat = pat.slice(0, -1);
+	let anchored = pat.startsWith("/");
+	if (anchored) pat = pat.slice(1);
+	if (pat.includes("/")) anchored = true;
+	const tokens = tokenize(pat);
+	if (matchTokens(tokens, path, 0)) return true;
+	if (anchored) return false;
+	for (let k = 0; k < path.length; k++) if (path[k] === "/" && matchTokens(tokens, path, k + 1)) return true;
+	return false;
+}
+function walkTree(root) {
+	const out = [];
+	const walk = (rel) => {
+		let entries;
+		try {
+			entries = readdirSync(join(root, rel), { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			if (SKIP_DIRS.has(e.name)) continue;
+			const child = rel ? `${rel}/${e.name}` : e.name;
+			out.push(child);
+			if (e.isDirectory()) walk(child);
+		}
+	};
+	walk("");
+	return out.sort();
+}
+function previewPattern(root, pattern) {
+	const p = pattern.trim();
+	if (!isValidPattern(p)) return {
+		ok: false,
+		reason: "malformed gitignore pattern"
+	};
+	return {
+		ok: true,
+		negated: p.startsWith("!"),
+		matches: walkTree(root).filter((path) => matchesPattern(p, path))
+	};
+}
+function flag(argv, name) {
+	const i = argv.indexOf(name);
+	return i === -1 ? void 0 : argv[i + 1];
+}
+function main(argv) {
+	const root = flag(argv, "--root") ?? ".";
+	const w = (s) => process.stdout.write(`${s}\n`);
+	if (argv.includes("--list")) {
+		for (const rule of listRules(root)) w(rule);
+		return 0;
+	}
+	if (argv.includes("--add")) {
+		const r = addRule(root, flag(argv, "--add") ?? "");
+		w(r.ok ? r.message : `refused: ${r.reason}`);
+		return r.ok ? 0 : 1;
+	}
+	if (argv.includes("--remove")) {
+		const r = removeRule(root, flag(argv, "--remove") ?? "");
+		w(r.ok ? r.message : `refused: ${r.reason}`);
+		return r.ok ? 0 : 1;
+	}
+	if (argv.includes("--induce")) {
+		const r = inducePatterns(root, flag(argv, "--induce") ?? "");
+		if (!r.ok) {
+			w(`unusable: ${r.reason}`);
+			return 1;
+		}
+		w("Candidate ignore patterns:");
+		for (const c of r.candidates) w(`  ${c}`);
+		return 0;
+	}
+	if (argv.includes("--preview")) {
+		const r = previewPattern(root, flag(argv, "--preview") ?? "");
+		if (!r.ok) {
+			w(`invalid: ${r.reason}`);
+			return 1;
+		}
+		const verb = r.negated ? "re-track" : "ignore";
+		if (r.matches.length === 0) {
+			w(`This pattern would ${verb} no path.`);
+			return 0;
+		}
+		w(`This pattern would ${verb}:`);
+		for (const m of r.matches) w(`  ${m}`);
+		return 0;
+	}
+	w("usage: manage-ignore --list | --add <p> | --remove <p> | --induce <path> | --preview <p>");
+	return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) process.exit(main(process.argv.slice(2)));
+//#endregion
+export { addRule, inducePatterns, isRuleLine, isValidPattern, listRules, main, matchesPattern, previewPattern, readIgnoreLines, removeRule, splitLines };

package/skills/manage-scenario-bridge/README.md

@@ -3,12 +3,12 @@
 The concrete engine for `<project-path>/.agents/sdd/scenario-bridge.toml` — the one-time
 per-project wiring the `verify-scenarios` bridge and the impl-judge step-0 consumption both read. A
 non-user-invocable skill, loaded in-session by the `manage` gateway (Setup & discovery), carrying a
-self-contained `.mts` script that lists / scaffolds / adds sources so users never hand-author the
+self-contained `.mjs` script that lists / scaffolds / adds sources so users never hand-author the
 config.
 
 - **Skill contract:** [`SKILL.md`](./SKILL.md)
-- **Script:** [`scripts/manage-scenario-bridge.mts`](./scripts/manage-scenario-bridge.mts)
-- **Tests:** [`scripts/manage-scenario-bridge.test.mts`](./scripts/manage-scenario-bridge.test.mts) (`node:test`)
+- **Script:** [`scripts/manage-scenario-bridge.mjs`](./scripts/manage-scenario-bridge.mjs)
+- **Tests:** [`src/manage-scenario-bridge/manage-scenario-bridge.test.mts`](../../src/manage-scenario-bridge/manage-scenario-bridge.test.mts) (`node:test`)
 
 ```bash
 node scripts/manage-scenario-bridge.mjs --project-path packages/cyberlegion --list

package/skills/manage-scenario-bridge/SKILL.md

@@ -13,7 +13,7 @@ per-project wiring the [`verify-scenarios`](../verify-scenarios/) bridge and the
 step-0 consumption both read. It is the **write** side of that config (`verify-scenarios` is the
 read side). It exists so a user wires a project's scenario bridge through a clean interface instead
 of hand-authoring the TOML. Loaded **in-session** by the `manage` gateway (Setup & discovery group);
-it carries a self-contained `.mts` script (the repo's node-≥23.6 / no-deps convention).
+it carries a self-contained `.mjs` script (compiled from `src/`; no runtime deps, Node ≥22.11).
 
 ## The file it curates
 

package/skills/manage-scenario-bridge/scripts/manage-scenario-bridge.mjs

@@ -1,12 +1,239 @@
-// Launcher for the engine of the same name. Run it as `node <skill>/scripts/<engine>.mjs`.
-// A checkout runs the .mts source. An npm install keeps the skill under node_modules, where Node
-// will not strip types, so it runs the self-contained bundle built for the package.
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-const self = fileURLToPath(import.meta.url)
-const installed = /[\\/]node_modules[\\/]/.test(self)
-const target = self.replace(/\.mjs$/, installed ? '.bundle.mjs' : '.mts')
-const run = spawnSync(process.execPath, [...process.execArgv, target, ...process.argv.slice(2)], { stdio: 'inherit' })
-if (run.error) throw run.error
-process.exitCode = run.status ?? 1
+#!/usr/bin/env node
+// Compiled by `universal-plugin plugin build` from src/manage-scenario-bridge/manage-scenario-bridge.mts. Edit the source, not this file.
+globalThis.__SKILL_SCRIPT__ = {"package":null,"bin":null,"version":"0.7.1","entry":"skills/manage-scenario-bridge/scripts/manage-scenario-bridge.mjs","commands":{}};
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/vendor/gherkin-cli.mjs
+var TokenType;
+(function(TokenType) {
+	TokenType[TokenType["None"] = 0] = "None";
+	TokenType[TokenType["EOF"] = 1] = "EOF";
+	TokenType[TokenType["Empty"] = 2] = "Empty";
+	TokenType[TokenType["Comment"] = 3] = "Comment";
+	TokenType[TokenType["TagLine"] = 4] = "TagLine";
+	TokenType[TokenType["FeatureLine"] = 5] = "FeatureLine";
+	TokenType[TokenType["RuleLine"] = 6] = "RuleLine";
+	TokenType[TokenType["BackgroundLine"] = 7] = "BackgroundLine";
+	TokenType[TokenType["ScenarioLine"] = 8] = "ScenarioLine";
+	TokenType[TokenType["ExamplesLine"] = 9] = "ExamplesLine";
+	TokenType[TokenType["StepLine"] = 10] = "StepLine";
+	TokenType[TokenType["DocStringSeparator"] = 11] = "DocStringSeparator";
+	TokenType[TokenType["TableRow"] = 12] = "TableRow";
+	TokenType[TokenType["Language"] = 13] = "Language";
+	TokenType[TokenType["Other"] = 14] = "Other";
+})(TokenType || (TokenType = {}));
+var RuleType;
+(function(RuleType) {
+	RuleType[RuleType["None"] = 0] = "None";
+	RuleType[RuleType["_EOF"] = 1] = "_EOF";
+	RuleType[RuleType["_Empty"] = 2] = "_Empty";
+	RuleType[RuleType["_Comment"] = 3] = "_Comment";
+	RuleType[RuleType["_TagLine"] = 4] = "_TagLine";
+	RuleType[RuleType["_FeatureLine"] = 5] = "_FeatureLine";
+	RuleType[RuleType["_RuleLine"] = 6] = "_RuleLine";
+	RuleType[RuleType["_BackgroundLine"] = 7] = "_BackgroundLine";
+	RuleType[RuleType["_ScenarioLine"] = 8] = "_ScenarioLine";
+	RuleType[RuleType["_ExamplesLine"] = 9] = "_ExamplesLine";
+	RuleType[RuleType["_StepLine"] = 10] = "_StepLine";
+	RuleType[RuleType["_DocStringSeparator"] = 11] = "_DocStringSeparator";
+	RuleType[RuleType["_TableRow"] = 12] = "_TableRow";
+	RuleType[RuleType["_Language"] = 13] = "_Language";
+	RuleType[RuleType["_Other"] = 14] = "_Other";
+	RuleType[RuleType["GherkinDocument"] = 15] = "GherkinDocument";
+	RuleType[RuleType["Feature"] = 16] = "Feature";
+	RuleType[RuleType["FeatureHeader"] = 17] = "FeatureHeader";
+	RuleType[RuleType["Rule"] = 18] = "Rule";
+	RuleType[RuleType["RuleHeader"] = 19] = "RuleHeader";
+	RuleType[RuleType["Background"] = 20] = "Background";
+	RuleType[RuleType["ScenarioDefinition"] = 21] = "ScenarioDefinition";
+	RuleType[RuleType["Scenario"] = 22] = "Scenario";
+	RuleType[RuleType["ExamplesDefinition"] = 23] = "ExamplesDefinition";
+	RuleType[RuleType["Examples"] = 24] = "Examples";
+	RuleType[RuleType["ExamplesTable"] = 25] = "ExamplesTable";
+	RuleType[RuleType["Step"] = 26] = "Step";
+	RuleType[RuleType["StepArg"] = 27] = "StepArg";
+	RuleType[RuleType["DataTable"] = 28] = "DataTable";
+	RuleType[RuleType["DocString"] = 29] = "DocString";
+	RuleType[RuleType["Tags"] = 30] = "Tags";
+	RuleType[RuleType["DescriptionHelper"] = 31] = "DescriptionHelper";
+	RuleType[RuleType["Description"] = 32] = "Description";
+})(RuleType || (RuleType = {}));
+var AttachmentContentEncoding;
+(function(AttachmentContentEncoding) {
+	AttachmentContentEncoding["IDENTITY"] = "IDENTITY";
+	AttachmentContentEncoding["BASE64"] = "BASE64";
+})(AttachmentContentEncoding || (AttachmentContentEncoding = {}));
+var HookType;
+(function(HookType) {
+	HookType["BEFORE_TEST_RUN"] = "BEFORE_TEST_RUN";
+	HookType["AFTER_TEST_RUN"] = "AFTER_TEST_RUN";
+	HookType["BEFORE_TEST_CASE"] = "BEFORE_TEST_CASE";
+	HookType["AFTER_TEST_CASE"] = "AFTER_TEST_CASE";
+	HookType["BEFORE_TEST_STEP"] = "BEFORE_TEST_STEP";
+	HookType["AFTER_TEST_STEP"] = "AFTER_TEST_STEP";
+})(HookType || (HookType = {}));
+var PickleStepType;
+(function(PickleStepType) {
+	PickleStepType["UNKNOWN"] = "Unknown";
+	PickleStepType["CONTEXT"] = "Context";
+	PickleStepType["ACTION"] = "Action";
+	PickleStepType["OUTCOME"] = "Outcome";
+})(PickleStepType || (PickleStepType = {}));
+var SourceMediaType;
+(function(SourceMediaType) {
+	SourceMediaType["TEXT_X_CUCUMBER_GHERKIN_PLAIN"] = "text/x.cucumber.gherkin+plain";
+	SourceMediaType["TEXT_X_CUCUMBER_GHERKIN_MARKDOWN"] = "text/x.cucumber.gherkin+markdown";
+})(SourceMediaType || (SourceMediaType = {}));
+var StepDefinitionPatternType;
+(function(StepDefinitionPatternType) {
+	StepDefinitionPatternType["CUCUMBER_EXPRESSION"] = "CUCUMBER_EXPRESSION";
+	StepDefinitionPatternType["REGULAR_EXPRESSION"] = "REGULAR_EXPRESSION";
+})(StepDefinitionPatternType || (StepDefinitionPatternType = {}));
+var StepKeywordType;
+(function(StepKeywordType) {
+	StepKeywordType["UNKNOWN"] = "Unknown";
+	StepKeywordType["CONTEXT"] = "Context";
+	StepKeywordType["ACTION"] = "Action";
+	StepKeywordType["OUTCOME"] = "Outcome";
+	StepKeywordType["CONJUNCTION"] = "Conjunction";
+})(StepKeywordType || (StepKeywordType = {}));
+var TestStepResultStatus;
+(function(TestStepResultStatus) {
+	TestStepResultStatus["UNKNOWN"] = "UNKNOWN";
+	TestStepResultStatus["PASSED"] = "PASSED";
+	TestStepResultStatus["SKIPPED"] = "SKIPPED";
+	TestStepResultStatus["PENDING"] = "PENDING";
+	TestStepResultStatus["UNDEFINED"] = "UNDEFINED";
+	TestStepResultStatus["AMBIGUOUS"] = "AMBIGUOUS";
+	TestStepResultStatus["FAILED"] = "FAILED";
+})(TestStepResultStatus || (TestStepResultStatus = {}));
+var KeywordPrefix;
+(function(KeywordPrefix) {
+	KeywordPrefix["BULLET"] = "^(\\s*[*+-]\\s*)";
+	KeywordPrefix["HEADER"] = "^(#{1,6}\\s)";
+})(KeywordPrefix || (KeywordPrefix = {}));
+StepKeywordType.UNKNOWN, PickleStepType.UNKNOWN, StepKeywordType.CONTEXT, PickleStepType.CONTEXT, StepKeywordType.ACTION, PickleStepType.ACTION, StepKeywordType.OUTCOME, PickleStepType.OUTCOME, StepKeywordType.CONJUNCTION;
+//#endregion
+//#region src/verify-scenarios/verify-scenarios.mts
+function parseSourcesToml(text) {
+	const out = [];
+	const blocks = text.split(/(?=^\s*\[\[source\]\]\s*$)/m).filter((b) => /^\s*\[\[source\]\]\s*$/m.test(b));
+	for (const block of blocks) {
+		const body = block.replace(/^\s*\[\[source\]\]\s*$/m, "");
+		const fields = {};
+		for (const m of body.matchAll(/^\s*([A-Za-z_][\w-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')\s*$/gm)) fields[m[1]] = m[2] ?? m[3] ?? "";
+		if (!fields.adapter || !fields.reportPath) continue;
+		out.push({
+			adapter: fields.adapter,
+			command: fields.command,
+			reportPath: fields.reportPath
+		});
+	}
+	return out;
+}
+if (process.argv[1] && false);
+//#endregion
+//#region src/manage-scenario-bridge/manage-scenario-bridge.mts
+const CONFIG_REL_PATH = ".agents/sdd/scenario-bridge.toml";
+function configPath(projectPath) {
+	return join(projectPath, CONFIG_REL_PATH);
+}
+function listSources(projectPath) {
+	const file = configPath(projectPath);
+	if (!existsSync(file)) return [];
+	try {
+		return parseSourcesToml(readFileSync(file, "utf8"));
+	} catch {
+		return [];
+	}
+}
+function renderBlock(source) {
+	return [
+		"[[source]]",
+		`adapter    = "${source.adapter}"`,
+		...source.command !== void 0 ? [`command    = "${source.command}"`] : [],
+		`reportPath = "${source.reportPath}"`
+	].join("\n");
+}
+function validateInput(input) {
+	if (!input.adapter || !input.reportPath) return {
+		ok: false,
+		reason: "a source needs both adapter and reportPath"
+	};
+	return {
+		ok: true,
+		adapter: input.adapter,
+		command: input.command,
+		reportPath: input.reportPath
+	};
+}
+function scaffoldSource(projectPath, input) {
+	const valid = validateInput(input);
+	if (!valid.ok) return valid;
+	const file = configPath(projectPath);
+	if (existsSync(file)) return {
+		ok: false,
+		reason: "scenario-bridge.toml already exists; use add to append a source"
+	};
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${renderBlock(valid)}\n`);
+	const sources = listSources(projectPath);
+	return {
+		ok: true,
+		message: `scaffolded ${file}`,
+		sources
+	};
+}
+function addSource(projectPath, input) {
+	const valid = validateInput(input);
+	if (!valid.ok) return valid;
+	const file = configPath(projectPath);
+	if (!existsSync(file)) return {
+		ok: false,
+		reason: "scenario-bridge.toml does not exist yet; use scaffold to create it first"
+	};
+	const existing = readFileSync(file, "utf8");
+	const sep = existing.endsWith("\n") ? "" : "\n";
+	writeFileSync(file, `${existing}${sep}\n${renderBlock(valid)}\n`);
+	const sources = listSources(projectPath);
+	return {
+		ok: true,
+		message: `added a source to ${file}`,
+		sources
+	};
+}
+function flag(argv, name) {
+	const i = argv.indexOf(name);
+	return i === -1 ? void 0 : argv[i + 1];
+}
+function inputFromArgv(argv) {
+	return {
+		adapter: flag(argv, "--adapter"),
+		command: flag(argv, "--command"),
+		reportPath: flag(argv, "--report-path")
+	};
+}
+function main(argv) {
+	const projectPath = flag(argv, "--project-path") ?? ".";
+	const w = (s) => process.stdout.write(`${s}\n`);
+	if (argv.includes("--list")) {
+		for (const s of listSources(projectPath)) w(`${s.adapter}${s.command ? ` (${s.command})` : ""} -> ${s.reportPath}`);
+		return 0;
+	}
+	if (argv.includes("--scaffold")) {
+		const r = scaffoldSource(projectPath, inputFromArgv(argv));
+		w(r.ok ? r.message : `refused: ${r.reason}`);
+		return r.ok ? 0 : 1;
+	}
+	if (argv.includes("--add")) {
+		const r = addSource(projectPath, inputFromArgv(argv));
+		w(r.ok ? r.message : `refused: ${r.reason}`);
+		return r.ok ? 0 : 1;
+	}
+	w("usage: manage-scenario-bridge --project-path <dir> --list | --scaffold --adapter <a> [--command <c>] --report-path <p> | --add --adapter <a> [--command <c>] --report-path <p>");
+	return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) process.exit(main(process.argv.slice(2)));
+//#endregion
+export { addSource, configPath, listSources, main, scaffoldSource };

package/skills/manage-spec-anchors/README.md

@@ -2,13 +2,13 @@
 
 The concrete engine for the SDD **spec-anchors** config — the opt-in registry of extra spec anchors
 `discover-specs` scans on top of the three fixed conventions (ADR-0019). A non-user-invocable skill,
-loaded in-session by the `manage` gateway (Housekeeping), carrying a self-contained `.mts` script
+loaded in-session by the `manage` gateway (Housekeeping), carrying a self-contained `.mjs` script
 that lists / CRUDs / induces / previews the anchors so users never hand-edit
 `.agents/sdd/spec-anchors.toml`.
 
 - **Skill contract:** [`SKILL.md`](./SKILL.md)
-- **Script:** [`scripts/manage-spec-anchors.mts`](./scripts/manage-spec-anchors.mts)
-- **Tests:** [`scripts/manage-spec-anchors.test.mts`](./scripts/manage-spec-anchors.test.mts) (`node:test`)
+- **Script:** [`scripts/manage-spec-anchors.mjs`](./scripts/manage-spec-anchors.mjs)
+- **Tests:** [`src/manage-spec-anchors/manage-spec-anchors.test.mts`](../../src/manage-spec-anchors/manage-spec-anchors.test.mts) (`node:test`)
 
 ```bash
 node scripts/manage-spec-anchors.mjs --list

package/skills/manage-spec-anchors/SKILL.md

@@ -12,7 +12,7 @@ The concrete engine for the SDD **spec-anchors** config — the opt-in registry
 anchors that `discover-specs` scans on top of the three fixed conventions (ADR-0019). It exists so a
 user curates those anchors through a clean interface instead of hand-editing
 `.agents/sdd/spec-anchors.toml`. Loaded **in-session** by the `manage` gateway (Housekeeping group);
-it carries a self-contained `.mts` script (the repo's node-≥23.6 / no-deps convention).
+it carries a self-contained `.mjs` script (compiled from `src/`; no runtime deps, Node ≥22.11).
 
 ## The config it curates