cyber-sdd 0.7.0 → 0.7.1

package/skills/combat-log-governance/SKILL.md

@@ -242,7 +242,7 @@ plan/log-surfaced candidate against **current code** (a persisted plan or log is
   closed candidate.
 
 ```jsonl
-{"seq": 3, "handle": "sdd-scanner", "kind": "strategy", "disposition": "resolved", "recommendation": "no action — coverage-gap mechanism already shipped", "evidence": ["current-code: checkReferencedArtifacts + checkUseCaseCoverage live in spec-gate/scripts/check-spec-state.mts"], "ratified": false}
+{"seq": 3, "handle": "sdd-scanner", "kind": "strategy", "disposition": "resolved", "recommendation": "no action — coverage-gap mechanism already shipped", "evidence": ["current-code: checkReferencedArtifacts + checkUseCaseCoverage live in spec-gate/scripts/check-spec-state.mjs"], "ratified": false}
 ```
 
 `disposition` is set **once at write** and never flipped (the append-only invariant) — the Scanner's

package/skills/concept-index/SKILL.md

@@ -12,7 +12,7 @@ The concrete engine for the **concept-index** step. It scans
 one project-spec for every node's `concept:` frontmatter and renders the **by-concept view** —
 `concept → {its nodes across every folder}` — that re-unifies a cross-cutting concern the capability
 folder tree scatters (the concept axis: one concern enacted across several capability folders). It
-carries a self-contained `.mts` script (the repo's node-≥23.6 / no-deps convention).
+carries a self-contained `.mjs` script (compiled from `src/`; no runtime deps, Node ≥22.11).
 
 ## Run it
 

package/skills/concept-index/scripts/concept-index.mjs

@@ -1,12 +1,183 @@
-// 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/concept-index/concept-index.mts. Edit the source, not this file.
+globalThis.__SKILL_SCRIPT__ = {"package":null,"bin":null,"version":"0.7.1","entry":"skills/concept-index/scripts/concept-index.mjs","commands":{}};
+import { existsSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/concept-index/concept-index.mts
+const BEGIN_MARKER = "<!-- BEGIN generated: by-concept (project-spec/concept-index) -->";
+const END_MARKER = "<!-- END generated: by-concept -->";
+const ANCHOR_HEADING = "## Invariants";
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	".turbo",
+	".next",
+	"coverage"
+]);
+function parseFrontmatter(text) {
+	const m = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(text);
+	if (!m) return null;
+	const fm = {
+		concepts: [],
+		model: false
+	};
+	const lines = m[1].split("\n").map((l) => l.replace(/\r$/, ""));
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.trim() === "" || line.trim().startsWith("#")) continue;
+		if (line.length - line.trimStart().length !== 0) continue;
+		const [key, ...rest] = line.trim().split(":");
+		const value = rest.join(":").trim();
+		if (key === "spec-type") fm.specType = unquote(value);
+		else if (key === "model") fm.model = unquote(value) === "true";
+		else if (key === "concept") {
+			if (value === "" || value === "|" || value === ">") for (let j = i + 1; j < lines.length; j++) {
+				const item = lines[j];
+				if (item.trim() === "") continue;
+				if (item.length - item.trimStart().length === 0) break;
+				const dash = /^\s*-\s+(.*)$/.exec(item);
+				if (dash) fm.concepts.push(unquote(dash[1].trim()));
+			}
+			else fm.concepts.push(...parseScalarOrFlow(value));
+		}
+	}
+	return fm;
+}
+function parseScalarOrFlow(value) {
+	const v = value.trim();
+	if (v.startsWith("[") && v.endsWith("]")) return v.slice(1, -1).split(",").map((s) => unquote(s.trim())).filter((s) => s.length > 0);
+	const single = unquote(v);
+	return single.length > 0 ? [single] : [];
+}
+function unquote(v) {
+	return v.replace(/^["']|["']$/g, "");
+}
+function facetKind(relPath, specType) {
+	const p = relPath.replace(/\\/g, "/");
+	if (p.startsWith("design/")) return "rule";
+	if (p.startsWith("workflows/")) return "workflow";
+	if (specType === "reference") return "reference";
+	if (specType === "behavioral") return "behavior";
+	return "index";
+}
+function displayPath(relPath) {
+	const p = relPath.replace(/\\/g, "/");
+	return p.endsWith("/README.md") ? p.slice(0, -9) : p;
+}
+function scanProjectSpec(specDir) {
+	const records = [];
+	walk(specDir, specDir, records);
+	return records;
+}
+function walk(dir, specDir, out) {
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name)) continue;
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) walk(full, specDir, out);
+		else if (entry.name.endsWith(".md")) {
+			const fm = parseFrontmatter(readFileSync(full, "utf8"));
+			if (!fm || fm.concepts.length === 0) continue;
+			const relPath = relative(specDir, full).replace(/\\/g, "/");
+			out.push({
+				relPath,
+				display: displayPath(relPath),
+				concepts: fm.concepts,
+				facet: facetKind(relPath, fm.specType)
+			});
+		}
+	}
+}
+function groupByConcept(records) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const rec of records) for (const concept of rec.concepts) {
+		const list = grouped.get(concept) ?? [];
+		list.push(rec);
+		grouped.set(concept, list);
+	}
+	return new Map([...grouped.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, [...v].sort((x, y) => x.display.localeCompare(y.display))]));
+}
+function renderTable(grouped) {
+	return [
+		"| Concept | Facets |",
+		"|---|---|",
+		...[...grouped.entries()].map(([concept, nodes]) => {
+			return `| \`${concept}\` | ${nodes.map((n) => `\`${n.display}\` (${n.facet})`).join(" · ")} |`;
+		})
+	].join("\n");
+}
+function renderSection(grouped) {
+	return [
+		BEGIN_MARKER,
+		"",
+		"## By concept",
+		"",
+		"> Generated from `concept:` frontmatter by `project-spec/concept-index` — do not edit by hand.",
+		"",
+		renderTable(grouped),
+		"",
+		END_MARKER
+	].join("\n");
+}
+function applySection(specText, section) {
+	const begin = specText.indexOf(BEGIN_MARKER);
+	const end = specText.indexOf(END_MARKER);
+	if (begin !== -1 && end !== -1 && end > begin) {
+		const before = specText.slice(0, begin);
+		const after = specText.slice(end + 34);
+		return before + section + after;
+	}
+	const anchor = specText.indexOf(ANCHOR_HEADING);
+	if (anchor !== -1) return specText.slice(0, anchor) + section + "\n\n" + specText.slice(anchor);
+	return `${specText.replace(/\s*$/, "")}\n\n${section}\n`;
+}
+function extractSection(specText) {
+	const begin = specText.indexOf(BEGIN_MARKER);
+	const end = specText.indexOf(END_MARKER);
+	if (begin === -1 || end === -1 || end < begin) return null;
+	return specText.slice(begin, end + 34);
+}
+function parseArgs(argv) {
+	let specDir = ".";
+	let mode = "print";
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a === "--spec-dir") specDir = argv[++i] ?? ".";
+		else if (a === "--write") mode = "write";
+		else if (a === "--check") mode = "check";
+	}
+	return {
+		specDir,
+		mode
+	};
+}
+function main(argv) {
+	const { specDir, mode } = parseArgs(argv);
+	const section = renderSection(groupByConcept(scanProjectSpec(specDir)));
+	const specPath = join(specDir, "spec.md");
+	if (mode === "print") {
+		process.stdout.write(`${section}\n`);
+		return 0;
+	}
+	if (!existsSync(specPath)) {
+		process.stderr.write(`concept-index: no spec.md at ${specPath}\n`);
+		return 2;
+	}
+	const specText = readFileSync(specPath, "utf8");
+	if (mode === "check") {
+		if (extractSection(specText) === section) {
+			process.stdout.write("concept-index: no drift\n");
+			return 0;
+		}
+		process.stderr.write("concept-index: drift — spec.md by-concept block is stale; run --write\n");
+		return 1;
+	}
+	const next = applySection(specText, section);
+	if (next !== specText) writeFileSync(specPath, next);
+	process.stdout.write(`concept-index: ${next === specText ? "unchanged" : "updated"} ${specPath}\n`);
+	return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) process.exit(main(process.argv.slice(2)));
+//#endregion
+export { BEGIN_MARKER, END_MARKER, applySection, extractSection, facetKind, groupByConcept, main, parseFrontmatter, parseScalarOrFlow, renderSection, renderTable, scanProjectSpec };

package/skills/discover-plans/README.md

@@ -1,14 +1,14 @@
 # discover-plans
 
 The concrete engine for SDD **plan discovery**. A non-user-invocable skill carrying a self-contained
-`.mts` script that scans `.agents/plans` for `*.plan.md` mission briefs, treats each present brief as
+`.mjs` script that scans `.agents/plans` for `*.plan.md` mission briefs, treats each present brief as
 an unretired/resumable mission, tallies its todos, reads its top-level `status` dispatch flag
 (`active` when unset) and its `## NEXT` resume lead, and emits a TOON list. The plan sibling of
 [`discover-specs`](../discover-specs/README.md).
 
 - **Skill contract:** [`SKILL.md`](./SKILL.md)
-- **Script:** [`scripts/discover-plans.mts`](./scripts/discover-plans.mts)
-- **Tests:** [`scripts/discover-plans.test.mts`](./scripts/discover-plans.test.mts) (`node:test`)
+- **Script:** [`scripts/discover-plans.mjs`](./scripts/discover-plans.mjs)
+- **Tests:** [`src/discover-plans/discover-plans.test.mts`](../../src/discover-plans/discover-plans.test.mts) (`node:test`)
 
 ```bash
 node scripts/discover-plans.mjs --root . --format toon

package/skills/discover-plans/SKILL.md

@@ -12,7 +12,7 @@ The concrete engine for SDD **plan discovery**. It
 locates the **resumable missions** in a repo — the mission **plan briefs** under `.agents/plans` —
 and returns each one's CR ref, name, todo tally, and `## NEXT` resume lead, **without reading the
 rest of the body**, so a consumer (the **gateway**, on entry) can offer resume cheaply. It carries a
-self-contained `.mts` script (the repo's node-≥23.6 / no-deps convention). It is the **plan** sibling
+self-contained `.mjs` script (compiled from `src/`; no runtime deps, Node ≥22.11). It is the **plan** sibling
 of `discover-specs`: that engine finds **specs** by status shape; this one finds **missions** by
 their briefs.
 

package/skills/discover-plans/scripts/discover-plans.mjs

@@ -1,12 +1,137 @@
-// 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/discover-plans/discover-plans.mts. Edit the source, not this file.
+globalThis.__SKILL_SCRIPT__ = {"package":null,"bin":null,"version":"0.7.1","entry":"skills/discover-plans/scripts/discover-plans.mjs","commands":{}};
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/discover-plans/discover-plans.mts
+const TODO_STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"in_progress",
+	"completed"
+]);
+/** The default mission dispatch status — the meaning of an absent top-level `status`. */
+const DEFAULT_PLAN_STATUS = "active";
+function parsePlanFrontmatter(text) {
+	const m = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(text);
+	if (!m) return null;
+	const fm = {
+		name: "",
+		status: DEFAULT_PLAN_STATUS,
+		total: 0,
+		completed: 0,
+		inProgress: 0,
+		pending: 0
+	};
+	let inTodos = false;
+	for (const raw of m[1].split("\n")) {
+		const line = raw.replace(/\r$/, "");
+		if (line.trim() === "" || line.trim().startsWith("#")) continue;
+		const indent = line.length - line.trimStart().length;
+		const trimmed = line.trim();
+		if (indent === 0) {
+			inTodos = false;
+			const [key, ...rest] = trimmed.split(":");
+			const value = rest.join(":").trim();
+			if (key === "name") fm.name = unquote(value);
+			else if (key === "status") {
+				const v = unquote(value);
+				if (v !== "") fm.status = v;
+			} else if (key === "todos") inTodos = true;
+			continue;
+		}
+		if (inTodos) {
+			const sm = /^(?:-\s+)?status:\s*(.+)$/.exec(trimmed);
+			if (sm) {
+				const status = unquote(sm[1].trim());
+				fm.total++;
+				if (status === "completed") fm.completed++;
+				else if (status === "in_progress") fm.inProgress++;
+				else if (status === "pending") fm.pending++;
+			}
+		}
+	}
+	return fm;
+}
+function unquote(v) {
+	return v.replace(/^["']|["']$/g, "");
+}
+function nextLead(text) {
+	const lines = text.split("\n");
+	let i = lines.findIndex((l) => /^##\s+NEXT\b/i.test(l.trim()));
+	if (i === -1) return "";
+	for (i += 1; i < lines.length; i++) {
+		const l = lines[i].replace(/\r$/, "").trim();
+		if (l === "") continue;
+		if (l.startsWith("#")) return "";
+		const cleaned = l.replace(/^[-*]\s+/, "").replace(/\*\*/g, "").trim();
+		return cleaned.length > 200 ? `${cleaned.slice(0, 197)}...` : cleaned;
+	}
+	return "";
+}
+function discoverPlanFiles(root) {
+	const dir = join(root, ".agents", "plans");
+	if (!existsSync(dir)) return [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	return entries.filter((e) => e.isFile() && e.name.endsWith(".plan.md")).map((e) => e.name).sort();
+}
+function collectPlans(root) {
+	const out = [];
+	for (const name of discoverPlanFiles(root)) {
+		let text;
+		try {
+			text = readFileSync(join(root, ".agents", "plans", name), "utf8");
+		} catch {
+			continue;
+		}
+		const fm = parsePlanFrontmatter(text);
+		if (!fm) continue;
+		out.push({
+			cr: name.replace(/\.plan\.md$/, ""),
+			name: fm.name,
+			total: fm.total,
+			completed: fm.completed,
+			inProgress: fm.inProgress,
+			status: fm.status,
+			next: nextLead(text)
+		});
+	}
+	return out.sort((a, b) => a.cr < b.cr ? -1 : a.cr > b.cr ? 1 : 0);
+}
+function filterByStatus(plans, status) {
+	return plans.filter((p) => p.status === status);
+}
+const COLUMNS = [
+	"cr",
+	"name",
+	"total",
+	"completed",
+	"inProgress",
+	"status",
+	"next"
+];
+function toonField(v) {
+	if (v === "" || /[",]/.test(v) || v !== v.trim()) return `"${v.replace(/"/g, "\"\"")}"`;
+	return v;
+}
+function toToon(plans) {
+	return [`plans[${plans.length}]{${COLUMNS.join(",")}}:`, ...plans.map((p) => `  ${COLUMNS.map((c) => toonField(String(p[c]))).join(",")}`)].join("\n");
+}
+function main(argv) {
+	const root = argv.includes("--root") ? argv[argv.indexOf("--root") + 1] ?? "." : ".";
+	const format = argv.includes("--format") ? argv[argv.indexOf("--format") + 1] : "toon";
+	const statusFilter = argv.includes("--status") ? argv[argv.indexOf("--status") + 1] : void 0;
+	let plans = collectPlans(root);
+	if (statusFilter !== void 0) plans = filterByStatus(plans, statusFilter);
+	const out = format === "json" ? JSON.stringify(plans, null, 2) : toToon(plans);
+	process.stdout.write(`${out}\n`);
+	return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) process.exit(main(process.argv.slice(2)));
+//#endregion
+export { DEFAULT_PLAN_STATUS, TODO_STATUSES, collectPlans, filterByStatus, main, nextLead, parsePlanFrontmatter, toToon };

package/skills/discover-specs/README.md

@@ -1,14 +1,14 @@
 # discover-specs
 
-The concrete engine for SDD **spec discovery**. A non-user-invocable skill carrying a self-contained `.mts`
+The concrete engine for SDD **spec discovery**. A non-user-invocable skill carrying a self-contained `.mjs`
 script that scans the three fixed SDD spec locations — plus any opt-in extra anchors declared in
 `.agents/sdd/spec-anchors.toml` (ADR-0019, curated via `manage-spec-anchors`) — filters candidates by
 the lifecycle `status` shape, parses each `spec.md`'s frontmatter only, and emits a TOON list of the
 specs found.
 
 - **Skill contract:** [`SKILL.md`](./SKILL.md)
-- **Script:** [`scripts/discover-specs.mts`](./scripts/discover-specs.mts)
-- **Tests:** [`scripts/discover-specs.test.mts`](./scripts/discover-specs.test.mts) (`node:test`)
+- **Script:** [`scripts/discover-specs.mjs`](./scripts/discover-specs.mjs)
+- **Tests:** [`src/discover-specs/discover-specs.test.mts`](../../src/discover-specs/discover-specs.test.mts) (`node:test`)
 
 ```bash
 node scripts/discover-specs.mjs --root . --format toon

package/skills/discover-specs/SKILL.md

@@ -11,7 +11,7 @@ metadata:
 The concrete engine for SDD **spec discovery**. It locates the
 project specs in a repo and returns each one's frontmatter — **without reading any spec body** — so a
 consumer (the **gateway**, corpus tooling) can route on `status` / `project-path` / `approval`
-cheaply. It carries a self-contained `.mts` script (the repo's node-≥23.6 / no-deps convention).
+cheaply. It carries a self-contained `.mjs` script (compiled from `src/`; no runtime deps, Node ≥22.11).
 
 ## Recognition — location-bounded and shape-confirmed