cyber-sdd 0.6.1 → 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/README.md

@@ -5,8 +5,8 @@ every node's `concept:` frontmatter and renders the **by-concept view** into the
 re-unifying a cross-cutting concern the capability folder tree scatters.
 
 ```bash
-node scripts/concept-index.mts --spec-dir <spec> --write   # refresh the block
-node scripts/concept-index.mts --spec-dir <spec> --check   # no-drift guard
+node scripts/concept-index.mjs --spec-dir <spec> --write   # refresh the block
+node scripts/concept-index.mjs --spec-dir <spec> --check   # no-drift guard
 ```
 
 Pure derivation, frontmatter only; the write touches only the delimited generated block. See

package/skills/concept-index/SKILL.md

@@ -12,12 +12,12 @@ 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
 
 ```bash
-node "<skill>/scripts/concept-index.mts" --spec-dir <spec> [--write | --check]
+node "<skill>/scripts/concept-index.mjs" --spec-dir <spec> [--write | --check]
 ```
 
 - default (no mode) — print the rendered "By concept" section to stdout (dry run).

package/{dist/concept-index/scripts/concept-index.js → skills/concept-index/scripts/concept-index.mjs}

@@ -1,8 +1,10 @@
 #!/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 skills/concept-index/scripts/concept-index.mts
+//#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";

package/skills/discover-plans/README.md

@@ -1,16 +1,16 @@
 # 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.mts --root . --format toon
-node scripts/discover-plans.mts --root . --status approved   # the dispatch queue: approved briefs only
+node scripts/discover-plans.mjs --root . --format toon
+node scripts/discover-plans.mjs --root . --status approved   # the dispatch queue: approved briefs only
 ```

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.
 
@@ -42,7 +42,7 @@ the flag; it never interprets or writes it.
 ## Run the scan
 
 ```bash
-node "<skill>/scripts/discover-plans.mts" [--root .] [--format toon|json] [--status <value>]
+node "<skill>/scripts/discover-plans.mjs" [--root .] [--format toon|json] [--status <value>]
 ```
 
 - Default `--root` is the current directory; default `--format` is **TOON** (the token-efficient

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

@@ -0,0 +1,137 @@
+#!/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,15 +1,15 @@
 # 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.mts --root . --format toon
+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
 
@@ -37,7 +37,7 @@ A `spec.md` is a spec only when **both** hold (ADR-0017, narrowed; extra anchors
 ## Run the scan
 
 ```bash
-node "<skill>/scripts/discover-specs.mts" [--root .] [--format toon|json] [--resolve <name>]
+node "<skill>/scripts/discover-specs.mjs" [--root .] [--format toon|json] [--resolve <name>]
 ```
 
 - Default `--root` is the current directory; default `--format` is **TOON** (the token-efficient

package/{dist/discover-specs/scripts/discover-specs.js → skills/discover-specs/scripts/discover-specs.mjs}

@@ -1,7 +1,10 @@
+#!/usr/bin/env node
+// Compiled by `universal-plugin plugin build` from src/discover-specs/discover-specs.mts. Edit the source, not this file.
+globalThis.__SKILL_SCRIPT__ = {"package":null,"bin":null,"version":"0.7.1","entry":"skills/discover-specs/scripts/discover-specs.mjs","commands":{}};
 import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-//#region skills/discover-specs/scripts/discover-specs.mts
+//#region src/discover-specs/discover-specs.mts
 const LIFECYCLE_STATUSES = /* @__PURE__ */ new Set([
 	"draft",
 	"approved",

package/skills/doctrine-loop/SKILL.md

@@ -58,11 +58,11 @@ recorded as distilled).
 **Determine distilled-ness by a structured JSONL parse, never a substring or regex text match.**
 The ledger shards are JSONL (one JSON object per line). **Reuse the existing parse contract** rather
 than hand-rolling one: run the exported **`distilledCrRefs`** engine from
-`../plan-retirement/scripts/retire-plans.mts` over the project `ledger/` directory and membership-test
+`../plan-retirement/scripts/retire-plans.mjs` (its `--distilled` flag) over the project `ledger/` directory and membership-test
 the mission's `<cr-ref>` against the set it returns, e.g.
 
 ```
-node -e 'import("../plan-retirement/scripts/retire-plans.mts").then(m => console.log([...m.distilledCrRefs(process.argv[1])].join("\n")))' <ledger-dir>
+node "<plan-retirement skill>/scripts/retire-plans.mjs" --distilled <ledger-dir>
 ```
 
 `distilledCrRefs` parses **each line** with `JSON.parse` (keying only on `kind === "strategy"` with a

package/skills/formation-loop/SKILL.md

@@ -58,6 +58,16 @@ misplaced only when it **neither** follows the declared strategy **nor** matches
 — judging on the strategy alone raises false findings against placements a human already adjudicated. A declared layout settles *where a node goes*; it never licenses a capability to
 scatter across nodes. (Strategy is policy — read it; homes are data — derive them.)
 
+**Depth on capability nodes; `design/` by its own shape** (`sdd:spec-structure-governance`). The
+two-level cap covers capability nodes: one three levels deep is a depth finding naming it, its
+sub-grouping owed to a `concept:` tag. `design/` is judged by its own shape instead — current design
+at the top, one file per perspective, the `decisions/` ADR log, and at most one version folder
+holding the next design. The placement map names that version folder and its cut trigger; the named
+folder and its files raise no finding, any other `design/` sub-folder besides `decisions/` is a
+perspective-folder finding, a named version with no cut trigger is a finding, and so is a named
+version whose folder does not exist (a stale record the cut left behind). Tell the two
+apart by the map, never by the folder's contents.
+
 ## The intra-spec structural acts
 
 It acts on each spec's **structure**, not its content — one project is **one spec**, so structural

package/skills/gate-validation-governance/SKILL.md

@@ -13,8 +13,8 @@ conductor's autonomy bar (baked into `start-mission`), a hard floor + a three-di
 
 ## Legal-state tuples
 
-The mechanical authority is `spec-gate/scripts/check-spec-state.mts` — run it
-(`node <skill>/scripts/check-spec-state.mts`) to enforce; if `node` is unavailable, apply the same
+The mechanical authority is `spec-gate/scripts/check-spec-state.mjs` — run it
+(`node <skill>/scripts/check-spec-state.mjs`) to enforce; if `node` is unavailable, apply the same
 rules by reading frontmatter. The `(status, markers, .feature, approval)` tuple of the root
 `spec.md` — plus the durable gate lines globbed from its sibling `ledger/` shards (a legacy `ledger.jsonl` still counts) — is **illegal** when:
 

package/skills/init/README.md

@@ -7,13 +7,13 @@ mission runs. A user-invocable setup skill (sibling to `start-mission` / `manage
 and invokes no gate.
 
 - **Skill contract:** [`SKILL.md`](./SKILL.md)
-- **Script:** [`scripts/wire-statusline.mts`](./scripts/wire-statusline.mts)
-- **Tests:** [`scripts/wire-statusline.test.mts`](./scripts/wire-statusline.test.mts) (`node:test`)
+- **Script:** [`scripts/wire-statusline.mjs`](./scripts/wire-statusline.mjs)
+- **Tests:** [`src/init/wire-statusline.test.mts`](../../src/init/wire-statusline.test.mts) (`node:test`)
 
 ```bash
-node scripts/wire-statusline.mts --root . --detect
-node scripts/wire-statusline.mts --root . --wire --mode own-line
-node scripts/wire-statusline.mts --root . --wire --mode same-line   # --no-global-base to shadow deliberately
+node scripts/wire-statusline.mjs --root . --detect
+node scripts/wire-statusline.mjs --root . --wire --mode own-line
+node scripts/wire-statusline.mjs --root . --wire --mode same-line   # --no-global-base to shadow deliberately
 ```
 
 The engine writes only project `.claude/settings.json` (never the global settings file) and, in a

package/skills/init/SKILL.md

@@ -29,7 +29,7 @@ On enable, ask whether the mission status should render:
 Before wiring, run the read-only detection — Claude Code's project `statusLine` **replaces** the global one (no merge), so a fresh project wiring would silently shadow a status line living in `~/.claude/settings.json`:
 
 ```bash
-node "<skill>/scripts/wire-statusline.mts" --root . --detect
+node "<skill>/scripts/wire-statusline.mjs" --root . --detect
 ```
 
 It reports the project statusLine (absent | wired | foreign), the global statusLine (present | absent), and the shadow risk. On a shadow risk (project absent, global present), tell the user wiring will shadow their global status line and ask:
@@ -44,8 +44,8 @@ No shadow risk → proceed straight to wiring.
 Run the engine to compose the reader into project settings and (in a git repo) gitignore the status file:
 
 ```bash
-node "<skill>/scripts/wire-statusline.mts" --root . --wire --mode own-line
-node "<skill>/scripts/wire-statusline.mts" --root . --wire --mode same-line   # add --no-global-base to shadow deliberately
+node "<skill>/scripts/wire-statusline.mjs" --root . --wire --mode own-line
+node "<skill>/scripts/wire-statusline.mjs" --root . --wire --mode same-line   # add --no-global-base to shadow deliberately
 ```
 
 The engine:

package/skills/init/scripts/wire-statusline.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+// Compiled by `universal-plugin plugin build` from src/init/wire-statusline.mts. Edit the source, not this file.
+globalThis.__SKILL_SCRIPT__ = {"package":null,"bin":null,"version":"0.7.1","entry":"skills/init/scripts/wire-statusline.mjs","commands":{}};
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/init/wire-statusline.mts
+const STATUS_FILE = ".agents/sdd/statusline";
+const SETTINGS_FILE = ".claude/settings.json";
+const GITIGNORE_FILE = ".gitignore";
+const GLOBAL_SETTINGS_FILE = join(homedir(), ".claude", "settings.json");
+const MARKER_BEGIN = "# sdd-statusline:begin";
+const MARKER_END = "# sdd-statusline:end";
+const MODE_PREFIX = "# sdd-statusline:mode:";
+const ORIG_OPEN = "__sdd_orig() {";
+const ORIG_CLOSE = "}";
+const NO_BASE = ":";
+function buildCommand(base, mode) {
+	const origBody = base && base.trim() !== "" ? base : NO_BASE;
+	const render = mode === "own-line" ? `if [ -s "$__sdd_file" ]; then\n  __sdd_val="$(cat "$__sdd_file")"\n  printf '%s\\n%s\\n' "$__sdd_base" "$__sdd_val"\nelse\n  printf '%s\\n' "$__sdd_base"\nfi` : `if [ -s "$__sdd_file" ]; then\n  __sdd_val="$(cat "$__sdd_file")"\n  printf '%s | %s\\n' "$__sdd_base" "$__sdd_val"\nelse\n  printf '%s\\n' "$__sdd_base"\nfi`;
+	return [
+		MARKER_BEGIN,
+		`${MODE_PREFIX}${mode}`,
+		ORIG_OPEN,
+		origBody,
+		ORIG_CLOSE,
+		"__sdd_base=\"$(__sdd_orig 2>/dev/null)\"",
+		`__sdd_file="${STATUS_FILE}"`,
+		render,
+		MARKER_END
+	].join("\n");
+}
+function parseCommand(command) {
+	if (!command?.includes(MARKER_BEGIN)) return { wired: false };
+	const modeMatch = new RegExp(`${MODE_PREFIX}(own-line|same-line)`).exec(command);
+	const origMatch = /__sdd_orig\(\) \{\n([\s\S]*?)\n\}/.exec(command);
+	const mode = modeMatch?.[1] ?? "own-line";
+	const origBody = origMatch?.[1] ?? NO_BASE;
+	return {
+		wired: true,
+		base: origBody === NO_BASE ? void 0 : origBody,
+		mode
+	};
+}
+function baseToWrap(existingCommand) {
+	const parsed = parseCommand(existingCommand);
+	return parsed.wired ? parsed.base : existingCommand;
+}
+function readSettingsFile(file) {
+	if (!existsSync(file)) return {};
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return {};
+	}
+}
+function readSettings(root) {
+	return readSettingsFile(join(root, SETTINGS_FILE));
+}
+function readStatusLineCommand(file) {
+	const command = readSettingsFile(file).statusLine?.command;
+	if (typeof command !== "string" || command.trim() === "") return void 0;
+	return command;
+}
+function writeSettings(root, settings) {
+	const file = join(root, SETTINGS_FILE);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${JSON.stringify(settings, null, 2)}\n`);
+}
+function composeStatusLine(root, mode, globalCommand) {
+	const settings = readSettings(root);
+	const existing = settings.statusLine?.command;
+	const hasProjectStatusLine = typeof existing === "string" && existing.trim() !== "";
+	const globalBaseComposed = !hasProjectStatusLine && globalCommand !== void 0;
+	const command = buildCommand(hasProjectStatusLine ? baseToWrap(existing) : globalCommand, mode);
+	if (existing === command) return {
+		changed: false,
+		command,
+		globalBaseComposed: false
+	};
+	settings.statusLine = {
+		...settings.statusLine,
+		type: "command",
+		command
+	};
+	writeSettings(root, settings);
+	return {
+		changed: true,
+		command,
+		globalBaseComposed
+	};
+}
+function isGitRepo(root) {
+	return existsSync(join(root, ".git"));
+}
+function splitLines(text) {
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+function addGitignoreEntry(root) {
+	const file = join(root, GITIGNORE_FILE);
+	const lines = existsSync(file) ? splitLines(readFileSync(file, "utf8")) : [];
+	if (lines.some((l) => l.trim() === ".agents/sdd/statusline")) return { changed: false };
+	const next = [...lines, STATUS_FILE];
+	writeFileSync(file, `${next.join("\n")}\n`);
+	return { changed: true };
+}
+function detectStatusLines(root, globalSettingsFile) {
+	const projectCommand = readStatusLineCommand(join(root, SETTINGS_FILE));
+	const project = projectCommand === void 0 ? "absent" : parseCommand(projectCommand).wired ? "wired" : "foreign";
+	const global = readStatusLineCommand(globalSettingsFile ?? GLOBAL_SETTINGS_FILE) !== void 0 ? "present" : "absent";
+	return {
+		project,
+		global,
+		shadow: project === "absent" && global === "present"
+	};
+}
+function wireStatusline(root, mode, opts) {
+	return {
+		settings: composeStatusLine(root, mode, opts?.globalBase ?? true ? readStatusLineCommand(opts?.globalSettingsFile ?? GLOBAL_SETTINGS_FILE) : void 0),
+		gitignore: isGitRepo(root) ? {
+			...addGitignoreEntry(root),
+			skipped: false
+		} : {
+			changed: false,
+			skipped: true
+		}
+	};
+}
+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 globalSettingsFile = flag(argv, "--global-settings");
+	const w = (s) => process.stdout.write(`${s}\n`);
+	if (argv.includes("--detect")) {
+		const result = detectStatusLines(root, globalSettingsFile);
+		w(`project statusLine: ${result.project}`);
+		w(`global statusLine: ${result.global}`);
+		w(result.shadow ? "shadow risk: yes — wiring would shadow the global statusline; compose it as the base (default) or pass --no-global-base to shadow deliberately" : "shadow risk: no");
+		return 0;
+	}
+	if (argv.includes("--wire")) {
+		const mode = flag(argv, "--mode");
+		if (mode !== "own-line" && mode !== "same-line") {
+			w("refused: --mode must be own-line or same-line");
+			return 1;
+		}
+		const result = wireStatusline(root, mode, {
+			globalSettingsFile,
+			globalBase: !argv.includes("--no-global-base")
+		});
+		w(result.settings.changed ? `wired statusLine (${mode})` : "statusLine already wired (unchanged)");
+		if (result.settings.globalBaseComposed) w("composed the global statusLine command as the wrapped base");
+		if (result.gitignore.skipped) w("not a git repo — gitignore skipped");
+		else w(result.gitignore.changed ? `added ${STATUS_FILE} to .gitignore` : ".gitignore already up to date");
+		return 0;
+	}
+	w("usage: wire-statusline --root <dir> --wire --mode own-line|same-line [--global-settings <file>] [--no-global-base]\n       wire-statusline --root <dir> --detect [--global-settings <file>]");
+	return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) process.exit(main(process.argv.slice(2)));
+//#endregion
+export { GITIGNORE_FILE, GLOBAL_SETTINGS_FILE, SETTINGS_FILE, STATUS_FILE, addGitignoreEntry, buildCommand, composeStatusLine, detectStatusLines, isGitRepo, main, parseCommand, readStatusLineCommand, wireStatusline };

package/skills/manage-ignore/README.md

@@ -2,18 +2,18 @@
 
 The concrete engine for `.agents/sdd/.sddignore` — the optional gitignore-syntax file
 `resolve-tracking` reads to decide whether an artifact is tracked or ignored. A non-user-invocable
-skill, loaded in-session by the `manage` gateway (Housekeeping), carrying a self-contained `.mts`
+skill, loaded in-session by the `manage` gateway (Housekeeping), carrying a self-contained `.mjs`
 script that lists / adds / removes / induces / previews the ignore rules so users never hand-edit the
 file. Order is meaningful (last-match-wins), so rules are never re-sorted.
 
 - **Skill contract:** [`SKILL.md`](./SKILL.md)
-- **Script:** [`scripts/manage-ignore.mts`](./scripts/manage-ignore.mts)
-- **Tests:** [`scripts/manage-ignore.test.mts`](./scripts/manage-ignore.test.mts) (`node:test`)
+- **Script:** [`scripts/manage-ignore.mjs`](./scripts/manage-ignore.mjs)
+- **Tests:** [`src/manage-ignore/manage-ignore.test.mts`](../../src/manage-ignore/manage-ignore.test.mts) (`node:test`)
 
 ```bash
-node scripts/manage-ignore.mts --list
-node scripts/manage-ignore.mts --induce build/output/app.log
-node scripts/manage-ignore.mts --preview '*.log'
-node scripts/manage-ignore.mts --preview '!keep.log'
-node scripts/manage-ignore.mts --add '*.log'
+node scripts/manage-ignore.mjs --list
+node scripts/manage-ignore.mjs --induce build/output/app.log
+node scripts/manage-ignore.mjs --preview '*.log'
+node scripts/manage-ignore.mjs --preview '!keep.log'
+node scripts/manage-ignore.mjs --add '*.log'
 ```

package/skills/manage-ignore/SKILL.md

@@ -12,8 +12,7 @@ The concrete engine for `.agents/sdd/.sddignore` — the optional gitignore-synt
 `resolve-tracking` consults to decide whether an artifact is **tracked** or **ignored**. It is the
 **write** side of the ignore file (`resolve-tracking` is the read side). It exists so a user curates
 the ignore rules through a clean interface instead of hand-editing the file. 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).
+the `manage` gateway (Housekeeping group); it carries a self-contained `.mjs` script (compiled from `src/`; no runtime deps, Node ≥22.11).
 
 ## The file it curates
 
@@ -25,7 +24,7 @@ engine therefore **never re-sorts**: `--add` appends, `--remove` preserves the o
 ## Run an operation
 
 ```bash
-node "<skill>/scripts/manage-ignore.mts" [--root .] <operation>
+node "<skill>/scripts/manage-ignore.mjs" [--root .] <operation>
 ```
 
 | Operation | Effect |