@tea-agent/loop-agent 0.13.0-alpha.0 → 0.13.0-beta.0

package/scripts/kb-graph-incremental-prepare.mjs

@@ -1,372 +1,386 @@
-#!/usr/bin/env node
-/**
- * Prepare narrowed scope/status for incremental knowledge-graph updates.
- * Reuses knowledge-graph-bootstrap DAG; does not call an LLM.
- */
-import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-
-function usage(code = 2) {
-	const text = `Usage: node scripts/kb-graph-incremental-prepare.mjs --root <dir> [options]
-
-Prepare an incremental graph-update run (same DAG as bootstrap, narrowed scope).
-
-  --root DIR              Repository root (required)
-  --feature F-id          Seed feature (repeatable)
-  --service NAME          Seed service (repeatable)
-  --domain NAME           Seed domain (repeatable)
-  --include GLOB          include_paths entry (repeatable)
-  --reset-staging         Clear knowledge/bootstrap/staging/**
-  --force-scope           Rewrite scope.yaml from seeds (default: merge seeds)
-  --product-name NAME     Used when creating missing B1 skeleton
-  -h, --help
-`;
-	if (code === 0) console.log(text);
-	else console.error(text);
-	process.exit(code);
-}
-
-function parseArgs(argv) {
-	const out = {
-		root: null,
-		features: [],
-		services: [],
-		domains: [],
-		includes: [],
-		resetStaging: false,
-		forceScope: false,
-		productName: null,
-	};
-	for (let i = 0; i < argv.length; i++) {
-		const a = argv[i];
-		const next = () => {
-			const v = argv[++i];
-			if (v === undefined) throw new Error(`missing value for ${a}`);
-			return v;
-		};
-		switch (a) {
-			case "--root":
-				out.root = path.resolve(next());
-				break;
-			case "--feature":
-				out.features.push(next());
-				break;
-			case "--service":
-				out.services.push(next());
-				break;
-			case "--domain":
-				out.domains.push(next());
-				break;
-			case "--include":
-				out.includes.push(next());
-				break;
-			case "--reset-staging":
-				out.resetStaging = true;
-				break;
-			case "--force-scope":
-				out.forceScope = true;
-				break;
-			case "--product-name":
-				out.productName = next();
-				break;
-			case "-h":
-			case "--help":
-				usage(0);
-				break;
-			default:
-				throw new Error(`unknown argument: ${a}`);
-		}
-	}
-	return out;
-}
-
-function ensureSkeleton(root, productName) {
-	const scope = path.join(root, "knowledge/bootstrap/scope.yaml");
-	const status = path.join(root, "knowledge/bootstrap/status.yaml");
-	if (fs.existsSync(scope) && fs.existsSync(status)) return;
-	const skeleton = path.join(scriptDir, "kb-bootstrap-init-skeleton.sh");
-	const args = ["bash", skeleton, "--root", root];
-	if (productName) args.push("--product-name", productName);
-	const r = spawnSync(args[0], args.slice(1), { encoding: "utf8" });
-	if (r.status !== 0) {
-		throw new Error(
-			`failed to init B1 skeleton: ${r.stderr || r.stdout || r.status}`,
-		);
-	}
-}
-
-function dumpYaml(obj, indent = 0) {
-	const sp = "  ".repeat(indent);
-	if (Array.isArray(obj)) {
-		if (obj.length === 0) return "[]";
-		return obj.map((item) => `${sp}- ${formatScalar(item)}`).join("\n");
-	}
-	if (obj && typeof obj === "object") {
-		return Object.entries(obj)
-			.map(([k, v]) => {
-				if (Array.isArray(v)) {
-					if (v.length === 0) return `${sp}${k}: []`;
-					return `${sp}${k}:\n${v.map((item) => `${sp}  - ${formatScalar(item)}`).join("\n")}`;
-				}
-				if (v && typeof v === "object") {
-					return `${sp}${k}:\n${dumpYaml(v, indent + 1)}`;
-				}
-				return `${sp}${k}: ${formatScalar(v)}`;
-			})
-			.join("\n");
-	}
-	return `${sp}${formatScalar(obj)}`;
-}
-
-function formatScalar(v) {
-	if (v === null || v === undefined) return "null";
-	if (typeof v === "boolean" || typeof v === "number") return String(v);
-	const s = String(v);
-	if (/[:#{}[\],&*?|>!%@`]/.test(s) || s === "" || /\s/.test(s)) {
-		return JSON.stringify(s);
-	}
-	return s;
-}
-
-function unique(list) {
-	return [...new Set(list.filter(Boolean))];
-}
-
-function buildIncludes(args) {
-	if (args.includes.length) return unique(args.includes);
-	const includes = ["features/**", "docs/**", "README.md"];
-	for (const f of args.features) includes.push(`features/${f}/**`);
-	for (const s of args.services) {
-		includes.push(
-			`services/${s}/**`,
-			`apps/${s}/**`,
-			`packages/${s}/**`,
-			"src/**",
-		);
-	}
-	return unique(includes);
-}
-
-function mergeSeedsIntoScopeText(text, args) {
-	let next = text;
-	if (!/update_mode:\s*incremental/.test(next)) {
-		if (/update_mode:\s*\S+/.test(next)) {
-			next = next.replace(/update_mode:\s*\S+/, "update_mode: incremental");
-		} else {
-			next = next.replace(
-				/(schema_version:\s*\d+)/,
-				"$1\nupdate_mode: incremental",
-			);
-		}
-	}
-	const upsert = (label, items) => {
-		if (!items.length) return;
-		const re = new RegExp(
-			`${label}:\\s*(\\[\\]|\\n(?:\\s+-\\s+[^\\n]+\\n)*)`,
-		);
-		const m = next.match(re);
-		const existing = new Set();
-		if (m) {
-			for (const line of m[1].split("\n")) {
-				const mm = line.match(/-\s+(\S+)/);
-				if (mm) existing.add(mm[1].replace(/^["']|["']$/g, ""));
-			}
-		}
-		for (const it of items) existing.add(it);
-		const body = [...existing].map((i) => `  - ${i}`).join("\n");
-		const block = `${label}:\n${body}\n`;
-		if (m) next = next.replace(re, block);
-		else next += `\n${block}`;
-	};
-	upsert("seed_features", args.features);
-	upsert("seed_services", args.services);
-	upsert("seed_domains", args.domains);
-	return next.endsWith("\n") ? next : `${next}\n`;
-}
-
-function resetStaging(root, bootstrapId) {
-	const staging = path.join(root, "knowledge/bootstrap/staging");
-	if (!fs.existsSync(staging)) {
-		fs.mkdirSync(staging, { recursive: true });
-	}
-	for (const ent of fs.readdirSync(staging, { withFileTypes: true })) {
-		if (ent.name === ".gitkeep") continue;
-		fs.rmSync(path.join(staging, ent.name), { recursive: true, force: true });
-	}
-	for (const d of [
-		"domains",
-		"services",
-		"modules",
-		"features-links.proposed",
-	]) {
-		fs.mkdirSync(path.join(staging, d), { recursive: true });
-	}
-	fs.writeFileSync(
-		path.join(staging, "notes.md"),
-		`# staging cleared for incremental run ${bootstrapId}\n`,
-	);
-	fs.writeFileSync(
-		path.join(staging, "edges.proposed.yaml"),
-		"schema_version: 1\nedges: []\n",
-	);
-	fs.writeFileSync(
-		path.join(staging, "coverage-notes.md"),
-		"# coverage notes (incremental)\n",
-	);
-}
-
-function main() {
-	let args;
-	try {
-		args = parseArgs(process.argv.slice(2));
-	} catch (e) {
-		console.error(String(e?.message || e));
-		usage(2);
-	}
-	if (!args.root) {
-		console.error("--root is required");
-		usage(2);
-	}
-	if (
-		!args.features.length &&
-		!args.services.length &&
-		!args.domains.length &&
-		!args.includes.length
-	) {
-		console.error(
-			"at least one of --feature / --service / --domain / --include is required",
-		);
-		process.exit(2);
-	}
-
-	ensureSkeleton(args.root, args.productName);
-	const ts = new Date().toISOString();
-	const bootstrapId = `BR-INC-${ts.replace(/[-:TZ.]/g, "").slice(0, 14)}`;
-	const scopePath = path.join(args.root, "knowledge/bootstrap/scope.yaml");
-	const statusPath = path.join(args.root, "knowledge/bootstrap/status.yaml");
-	const backupDir = path.join(
-		args.root,
-		"knowledge/bootstrap/runs",
-		bootstrapId,
-	);
-	fs.mkdirSync(backupDir, { recursive: true });
-	fs.copyFileSync(scopePath, path.join(backupDir, "scope.before.yaml"));
-	fs.copyFileSync(statusPath, path.join(backupDir, "status.before.yaml"));
-
-	const includes = buildIncludes(args);
-	const product =
-		args.productName || path.basename(args.root);
-
-	if (args.forceScope || !fs.existsSync(scopePath)) {
-		const data = {
-			schema_version: 1,
-			product_name: product,
-			primary_language: "zh-CN",
-			repo_kind: "single-service",
-			update_mode: "incremental",
-			include_paths: includes,
-			exclude_paths: ["node_modules/**", "dist/**", ".harness/**"],
-			id_namespace: {
-				domain_prefix: "DOM",
-				service_prefix: "SVC",
-				api_prefix: "API",
-			},
-			seed_domains: args.domains,
-			seed_services: args.services,
-			seed_features: args.features,
-			assumptions: [
-				"Incremental update: do not rebuild unrelated domains/services",
-			],
-			out_of_scope: ["full-repo bootstrap"],
-			human_owners: { architect: "", qa: "" },
-		};
-		fs.writeFileSync(
-			scopePath,
-			`# Incremental graph scope\n${dumpYaml(data)}\n`,
-		);
-	} else {
-		const merged = mergeSeedsIntoScopeText(
-			fs.readFileSync(scopePath, "utf8"),
-			args,
-		);
-		fs.writeFileSync(scopePath, merged);
-	}
-
-	const status = {
-		schema_version: 1,
-		bootstrap_id: bootstrapId,
-		repo_root: ".",
-		phase: "B2",
-		update_mode: "incremental",
-		updated_at: ts,
-		scope_ref: "knowledge/bootstrap/scope.yaml",
-		inventory_ref: "knowledge/bootstrap/inventory.json",
-		last_run_dir: `knowledge/bootstrap/runs/${bootstrapId}/`,
-		stats: {
-			entities_proposed: 0,
-			entities_asserted: 0,
-			edges_proposed: 0,
-			edges_asserted: 0,
-			features_linked: 0,
-		},
-		blockers: [],
-		next_actions: [
-			"Review knowledge/bootstrap/scope.yaml (update_mode: incremental)",
-			"Run knowledge-graph-bootstrap DAG (propose limited to scope seeds/includes)",
-			"Promote merge-new-only; materialize indexes",
-		],
-	};
-	fs.writeFileSync(
-		statusPath,
-		`# Incremental bootstrap status\n${dumpYaml(status)}\n`,
-	);
-
-	if (args.resetStaging) resetStaging(args.root, bootstrapId);
-
-	fs.writeFileSync(
-		path.join(backupDir, "README.md"),
-		[
-			`# Incremental prepare ${bootstrapId}`,
-			"",
-			`- update_mode: incremental`,
-			`- features: ${args.features.join(", ") || "(none)"}`,
-			`- services: ${args.services.join(", ") || "(none)"}`,
-			`- domains: ${args.domains.join(", ") || "(none)"}`,
-			"",
-			"Next:",
-			"```bash",
-			"loop-agent dag run-task <task-id> --profile knowledge-graph-bootstrap",
-			`bash scripts/kb-graph-materialize.sh --root ${args.root}`,
-			"```",
-			"",
-		].join("\n"),
-	);
-
-	console.log(
-		JSON.stringify(
-			{
-				ok: true,
-				bootstrap_id: bootstrapId,
-				update_mode: "incremental",
-				scope: "knowledge/bootstrap/scope.yaml",
-				status: "knowledge/bootstrap/status.yaml",
-				backup: `knowledge/bootstrap/runs/${bootstrapId}/`,
-				seeds: {
-					features: args.features,
-					services: args.services,
-					domains: args.domains,
-				},
-				next: "dag run-task --profile knowledge-graph-bootstrap",
-			},
-			null,
-			2,
-		),
-	);
-}
-
-main();
+#!/usr/bin/env node
+/**
+ * Prepare narrowed scope/status for incremental knowledge-graph updates.
+ * Reuses knowledge-graph-bootstrap DAG; does not call an LLM.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+
+function usage(code = 2) {
+	const text = `Usage: node scripts/kb-graph-incremental-prepare.mjs --root <dir> [options]
+
+Prepare an incremental graph-update run (same DAG as bootstrap, narrowed scope).
+
+  --root DIR              Repository root (required)
+  --feature F-id          Seed feature (repeatable)
+  --service NAME          Seed service (repeatable)
+  --domain NAME           Seed domain (repeatable)
+  --include GLOB          include_paths entry (repeatable)
+  --reset-staging         Clear knowledge/bootstrap/staging/**
+  --force-scope           Rewrite scope.yaml from seeds (default: merge seeds)
+  --product-name NAME     Used when creating missing B1 skeleton
+  -h, --help
+`;
+	if (code === 0) console.log(text);
+	else console.error(text);
+	process.exit(code);
+}
+
+function parseArgs(argv) {
+	const out = {
+		root: null,
+		features: [],
+		services: [],
+		domains: [],
+		includes: [],
+		resetStaging: false,
+		forceScope: false,
+		productName: null,
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		const next = () => {
+			const v = argv[++i];
+			if (v === undefined) throw new Error(`missing value for ${a}`);
+			return v;
+		};
+		switch (a) {
+			case "--root":
+				out.root = path.resolve(next());
+				break;
+			case "--feature":
+				out.features.push(next());
+				break;
+			case "--service":
+				out.services.push(next());
+				break;
+			case "--domain":
+				out.domains.push(next());
+				break;
+			case "--include":
+				out.includes.push(next());
+				break;
+			case "--reset-staging":
+				out.resetStaging = true;
+				break;
+			case "--force-scope":
+				out.forceScope = true;
+				break;
+			case "--product-name":
+				out.productName = next();
+				break;
+			case "-h":
+			case "--help":
+				usage(0);
+				break;
+			default:
+				throw new Error(`unknown argument: ${a}`);
+		}
+	}
+	return out;
+}
+
+function ensureSkeleton(root, productName) {
+	const scope = path.join(root, "knowledge/bootstrap/scope.yaml");
+	const status = path.join(root, "knowledge/bootstrap/status.yaml");
+	if (fs.existsSync(scope) && fs.existsSync(status)) return;
+	const skeleton = path.join(scriptDir, "kb-bootstrap-init-skeleton.sh");
+	const args = ["bash", skeleton, "--root", root];
+	if (productName) args.push("--product-name", productName);
+	const r = spawnSync(args[0], args.slice(1), { encoding: "utf8" });
+	if (r.status !== 0) {
+		throw new Error(
+			`failed to init B1 skeleton: ${r.stderr || r.stdout || r.status}`,
+		);
+	}
+}
+
+function dumpYaml(obj, indent = 0) {
+	const sp = "  ".repeat(indent);
+	if (Array.isArray(obj)) {
+		if (obj.length === 0) return "[]";
+		return obj.map((item) => `${sp}- ${formatScalar(item)}`).join("\n");
+	}
+	if (obj && typeof obj === "object") {
+		return Object.entries(obj)
+			.map(([k, v]) => {
+				if (Array.isArray(v)) {
+					if (v.length === 0) return `${sp}${k}: []`;
+					return `${sp}${k}:\n${v.map((item) => `${sp}  - ${formatScalar(item)}`).join("\n")}`;
+				}
+				if (v && typeof v === "object") {
+					return `${sp}${k}:\n${dumpYaml(v, indent + 1)}`;
+				}
+				return `${sp}${k}: ${formatScalar(v)}`;
+			})
+			.join("\n");
+	}
+	return `${sp}${formatScalar(obj)}`;
+}
+
+function formatScalar(v) {
+	if (v === null || v === undefined) return "null";
+	if (typeof v === "boolean" || typeof v === "number") return String(v);
+	const s = String(v);
+	if (/[:#{}[\],&*?|>!%@`]/.test(s) || s === "" || /\s/.test(s)) {
+		return JSON.stringify(s);
+	}
+	return s;
+}
+
+function unique(list) {
+	return [...new Set(list.filter(Boolean))];
+}
+
+function buildIncludes(args) {
+	if (args.includes.length) return unique(args.includes);
+	const includes = ["features/**", "docs/**", "README.md"];
+	for (const f of args.features) includes.push(`features/${f}/**`);
+	for (const s of args.services) {
+		includes.push(
+			`services/${s}/**`,
+			`apps/${s}/**`,
+			`packages/${s}/**`,
+			"src/**",
+		);
+	}
+	return unique(includes);
+}
+
+function mergeSeedsIntoScopeText(text, args) {
+	let next = text;
+	if (!/update_mode:\s*incremental/.test(next)) {
+		if (/update_mode:\s*\S+/.test(next)) {
+			next = next.replace(/update_mode:\s*\S+/, "update_mode: incremental");
+		} else {
+			next = next.replace(
+				/(schema_version:\s*\d+)/,
+				"$1\nupdate_mode: incremental",
+			);
+		}
+	}
+	const upsert = (label, items) => {
+		if (!items.length) return;
+		const re = new RegExp(
+			`${label}:\\s*(\\[\\]|\\n(?:\\s+-\\s+[^\\n]+\\n)*)`,
+		);
+		const m = next.match(re);
+		const existing = new Set();
+		if (m) {
+			for (const line of m[1].split("\n")) {
+				const mm = line.match(/-\s+(.+?)\s*$/);
+				if (!mm) continue;
+				const scalar = mm[1];
+				if (scalar.startsWith('"')) {
+					try {
+						existing.add(JSON.parse(scalar));
+						continue;
+					} catch {
+						// Fall through to conservative quote trimming.
+					}
+				}
+				existing.add(scalar.replace(/^["']|["']$/g, ""));
+			}
+		}
+		for (const it of items) existing.add(it);
+		const body = [...existing]
+			.map((i) => `  - ${formatScalar(i)}`)
+			.join("\n");
+		const block = `${label}:\n${body}\n`;
+		if (m) next = next.replace(re, block);
+		else next += `\n${block}`;
+	};
+	upsert("seed_features", args.features);
+	upsert("seed_services", args.services);
+	upsert("seed_domains", args.domains);
+	upsert("include_paths", args.includes);
+	return next.endsWith("\n") ? next : `${next}\n`;
+}
+
+function resetStaging(root, bootstrapId) {
+	const staging = path.join(root, "knowledge/bootstrap/staging");
+	if (!fs.existsSync(staging)) {
+		fs.mkdirSync(staging, { recursive: true });
+	}
+	for (const ent of fs.readdirSync(staging, { withFileTypes: true })) {
+		if (ent.name === ".gitkeep") continue;
+		fs.rmSync(path.join(staging, ent.name), { recursive: true, force: true });
+	}
+	for (const d of [
+		"domains",
+		"services",
+		"modules",
+		"features-links.proposed",
+	]) {
+		fs.mkdirSync(path.join(staging, d), { recursive: true });
+	}
+	fs.writeFileSync(
+		path.join(staging, "notes.md"),
+		`# staging cleared for incremental run ${bootstrapId}\n`,
+	);
+	fs.writeFileSync(
+		path.join(staging, "edges.proposed.yaml"),
+		"schema_version: 1\nedges: []\n",
+	);
+	fs.writeFileSync(
+		path.join(staging, "coverage-notes.md"),
+		"# coverage notes (incremental)\n",
+	);
+}
+
+function main() {
+	let args;
+	try {
+		args = parseArgs(process.argv.slice(2));
+	} catch (e) {
+		console.error(String(e?.message || e));
+		usage(2);
+	}
+	if (!args.root) {
+		console.error("--root is required");
+		usage(2);
+	}
+	if (
+		!args.features.length &&
+		!args.services.length &&
+		!args.domains.length &&
+		!args.includes.length
+	) {
+		console.error(
+			"at least one of --feature / --service / --domain / --include is required",
+		);
+		process.exit(2);
+	}
+
+	ensureSkeleton(args.root, args.productName);
+	const ts = new Date().toISOString();
+	const bootstrapId = `BR-INC-${ts.replace(/[-:TZ.]/g, "").slice(0, 14)}`;
+	const scopePath = path.join(args.root, "knowledge/bootstrap/scope.yaml");
+	const statusPath = path.join(args.root, "knowledge/bootstrap/status.yaml");
+	const backupDir = path.join(
+		args.root,
+		"knowledge/bootstrap/runs",
+		bootstrapId,
+	);
+	fs.mkdirSync(backupDir, { recursive: true });
+	fs.copyFileSync(scopePath, path.join(backupDir, "scope.before.yaml"));
+	fs.copyFileSync(statusPath, path.join(backupDir, "status.before.yaml"));
+
+	const includes = buildIncludes(args);
+	const product =
+		args.productName || path.basename(args.root);
+
+	if (args.forceScope || !fs.existsSync(scopePath)) {
+		const data = {
+			schema_version: 1,
+			product_name: product,
+			primary_language: "zh-CN",
+			repo_kind: "single-service",
+			update_mode: "incremental",
+			include_paths: includes,
+			exclude_paths: ["node_modules/**", "dist/**", ".harness/**"],
+			id_namespace: {
+				domain_prefix: "DOM",
+				service_prefix: "SVC",
+				api_prefix: "API",
+			},
+			seed_domains: args.domains,
+			seed_services: args.services,
+			seed_features: args.features,
+			assumptions: [
+				"Incremental update: do not rebuild unrelated domains/services",
+			],
+			out_of_scope: ["full-repo bootstrap"],
+			human_owners: { architect: "", qa: "" },
+		};
+		fs.writeFileSync(
+			scopePath,
+			`# Incremental graph scope\n${dumpYaml(data)}\n`,
+		);
+	} else {
+		const merged = mergeSeedsIntoScopeText(
+			fs.readFileSync(scopePath, "utf8"),
+			args,
+		);
+		fs.writeFileSync(scopePath, merged);
+	}
+
+	const status = {
+		schema_version: 1,
+		bootstrap_id: bootstrapId,
+		repo_root: ".",
+		phase: "B2",
+		update_mode: "incremental",
+		updated_at: ts,
+		scope_ref: "knowledge/bootstrap/scope.yaml",
+		inventory_ref: "knowledge/bootstrap/inventory.json",
+		last_run_dir: `knowledge/bootstrap/runs/${bootstrapId}/`,
+		stats: {
+			entities_proposed: 0,
+			entities_asserted: 0,
+			edges_proposed: 0,
+			edges_asserted: 0,
+			features_linked: 0,
+		},
+		blockers: [],
+		next_actions: [
+			"Review knowledge/bootstrap/scope.yaml (update_mode: incremental)",
+			"Run knowledge-graph-bootstrap DAG (propose limited to scope seeds/includes)",
+			"Promote merge-new-only; materialize indexes",
+		],
+	};
+	fs.writeFileSync(
+		statusPath,
+		`# Incremental bootstrap status\n${dumpYaml(status)}\n`,
+	);
+
+	if (args.resetStaging) resetStaging(args.root, bootstrapId);
+
+	fs.writeFileSync(
+		path.join(backupDir, "README.md"),
+		[
+			`# Incremental prepare ${bootstrapId}`,
+			"",
+			`- update_mode: incremental`,
+			`- features: ${args.features.join(", ") || "(none)"}`,
+			`- services: ${args.services.join(", ") || "(none)"}`,
+			`- domains: ${args.domains.join(", ") || "(none)"}`,
+			"",
+			"Next:",
+			"```bash",
+			"# task.json: { \"taskKind\": \"knowledge-graph-bootstrap\", ... }",
+			"loop-agent dag run-task <task-id> --execute --cwd .",
+			`bash scripts/kb-graph-materialize.sh --root ${args.root}`,
+			"```",
+			"",
+		].join("\n"),
+	);
+
+	console.log(
+		JSON.stringify(
+			{
+				ok: true,
+				bootstrap_id: bootstrapId,
+				update_mode: "incremental",
+				scope: "knowledge/bootstrap/scope.yaml",
+				status: "knowledge/bootstrap/status.yaml",
+				backup: `knowledge/bootstrap/runs/${bootstrapId}/`,
+				seeds: {
+					features: args.features,
+					services: args.services,
+					domains: args.domains,
+				},
+				next: "set task.json.taskKind=knowledge-graph-bootstrap; dag run-task --execute",
+			},
+			null,
+			2,
+		),
+	);
+}
+
+main();