deweyou-cli 0.3.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 0.5.0 - 2026-05-17
+
+### Added
+
+- add deweyou-cli help and version flags
+## 0.4.0 - 2026-05-17
+
+### Added
+
+- add interactive rule install prompts
+- wire rule installs into init
+- add rule install adapters
+- parse rule install init flags
+
+### Fixed
+
+- refuse agents symlink writes
+- harden rule install safety
+- preserve explicit init mode
+- preserve init flags in wizard
+- omit claude preview without rules
+- include agents preview for claude installs
+- read inline project rules from cache
+- forward init rule install flags
+- handle Claude rule install validation
+- preserve only AGENTS Claude symlink
+- document rule install init flags
+
+### Changed
+
+- share managed markdown sections
+
+### Documentation
+
+- document rule install targets
 ## 0.3.1 - 2026-05-17
 
 ### Changed

package/README.md

@@ -37,6 +37,8 @@ cd /path/to/your/repo
 deweyou-cli agent init
 deweyou-cli agent doctor
 deweyou-cli agent context --format markdown
+deweyou-cli agent -h
+deweyou-cli -v
 ```
 
 For a non-interactive setup that selects everything:
@@ -59,6 +61,13 @@ skills and rules; a writing or design repo can select different ones.
 
 ## Commands
 
+General options:
+
+| Option | Meaning |
+|--------|---------|
+| `-h`, `--help` | Show help. Supports nested help such as `deweyou-cli agent -h` and `deweyou-cli agent init -h`. |
+| `-v`, `--version` | Show the installed CLI version. |
+
 ### `deweyou-cli agent update`
 
 Refreshes the local Dewey asset cache from the default `deweyou/agents` source
@@ -91,6 +100,12 @@ Initializes the current repository with selected skills and rules.
 deweyou-cli agent init
 ```
 
+Usage:
+
+```text
+deweyou-cli agent init [--all] [--skills a,b] [--rules a,b] [--mode link|copy|pointer] [--scope project|global] [--tools codex,claude|all] [--rule-wiring reference|inline] [--yes] [--dry-run] [--force]
+```
+
 Without selection flags, this opens an interactive setup where you choose:
 
 - install mode
@@ -102,6 +117,8 @@ Scripted examples:
 ```bash
 deweyou-cli agent init --all --mode link --yes
 deweyou-cli agent init --skills repo-memory,spec-driven-coding,git-delivery --rules code-style
+deweyou-cli agent init --scope project --tools codex,claude --rules code-style --mode link
+deweyou-cli agent init --scope global --tools all --rules code-style --rule-wiring reference --yes
 deweyou-cli agent init --dry-run
 ```
 
@@ -182,6 +199,10 @@ AGENTS.md
 `AGENTS.md` receives a managed Dewey section that points agents at the selected
 workflow context. Existing content outside that managed section is preserved.
 
+Project installs write repository instruction files such as `AGENTS.md` and
+`CLAUDE.md`. Global installs write user-level instruction files such as
+`~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md`.
+
 ## Safety Notes
 
 - Run `deweyou-cli agent update` before `deweyou-cli agent init`.

package/dist/deweyou.mjs

@@ -11,7 +11,10 @@ const VALUE_FLAGS = new Set([
 	"mode",
 	"skills",
 	"rules",
-	"format"
+	"format",
+	"scope",
+	"tools",
+	"rule-wiring"
 ]);
 const FLAGS_BY_COMMAND = {
 	init: new Set([
@@ -19,6 +22,9 @@ const FLAGS_BY_COMMAND = {
 		"skills",
 		"rules",
 		"mode",
+		"scope",
+		"tools",
+		"rule-wiring",
 		"yes",
 		"dry-run",
 		"force"
@@ -69,19 +75,37 @@ function isAllowedForCommand(command, name) {
 	return FLAGS_BY_COMMAND[command]?.has(name) ?? false;
 }
 function parseValue(name, value) {
-	if (name === "skills" || name === "rules") return value.split(",").map((item) => item.trim()).filter(Boolean);
+	if (name === "skills" || name === "rules" || name === "tools") return value.split(",").map((item) => item.trim()).filter(Boolean);
 	return value;
 }
 function toCamel(value) {
 	return value.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
 //#endregion
+//#region package.json
+var version = "0.5.0";
+//#endregion
 //#region src/cli/main.ts
+const COMMANDS = [
+	"init",
+	"update",
+	"context",
+	"doctor"
+];
 async function main(argv) {
+	const help = helpFor(argv);
+	if (help) {
+		console.log(help);
+		return;
+	}
+	if (isVersionRequest(argv)) {
+		console.log(version);
+		return;
+	}
 	const parsed = parseArgs(argv);
 	if (parsed.topic !== "agent") printUsageAndThrow();
 	if (parsed.command === "init") {
-		const { runInit } = await import("./init-g2D-URoL.mjs");
+		const { runInit } = await import("./init-6406tZjR.mjs");
 		await runInit(parsed.flags);
 		return;
 	}
@@ -103,16 +127,87 @@ async function main(argv) {
 	printUsageAndThrow();
 }
 function usage() {
+	return rootUsage();
+}
+function rootUsage() {
+	return `Usage:
+  deweyou-cli agent <command> [options]
+
+Commands:
+  agent init      Initialize the current repository with Dewey assets.
+  agent update    Refresh the local Dewey asset cache.
+  agent context   Print the active Dewey agent context.
+  agent doctor    Check whether the repository and cache are healthy.
+
+Options:
+  -h, --help      Show help.
+  -v, --version   Show the CLI version.`;
+}
+function agentUsage() {
 	return `Usage:
-  deweyou-cli agent init [--all] [--skills a,b] [--rules a,b] [--mode link|copy|pointer] [--yes] [--dry-run] [--force]
+  deweyou-cli agent init [--all] [--skills a,b] [--rules a,b] [--mode link|copy|pointer] [--scope project|global] [--tools codex,claude|all] [--rule-wiring reference|inline] [--yes] [--dry-run] [--force]
   deweyou-cli agent update
   deweyou-cli agent context [--format markdown|json]
-  deweyou-cli agent doctor`;
+  deweyou-cli agent doctor
+
+Run \`deweyou-cli agent <command> -h\` for command-specific help.`;
+}
+function commandUsage(command) {
+	if (command === "init") return `Usage:
+  deweyou-cli agent init [--all] [--skills a,b] [--rules a,b] [--mode link|copy|pointer] [--scope project|global] [--tools codex,claude|all] [--rule-wiring reference|inline] [--yes] [--dry-run] [--force]
+
+Options:
+  --all                         Select every skill and rule.
+  --skills a,b                  Select comma-separated skill ids.
+  --rules a,b                   Select comma-separated rule ids.
+  --mode link|copy|pointer      Choose how assets are referenced.
+  --scope project|global        Write project or user-level instructions.
+  --tools codex,claude|all      Select target agent tools.
+  --rule-wiring reference|inline
+                                Choose how rules are written into instructions.
+  --yes                         Run without prompts for scripted selections.
+  --dry-run                     Print the plan without writing files.
+  --force                       Replace existing Dewey-managed destinations.
+  -h, --help                    Show help.`;
+	if (command === "context") return `Usage:
+  deweyou-cli agent context [--format markdown|json]
+
+Options:
+  --format markdown|json   Choose human-readable or structured output.
+  -h, --help               Show help.`;
+	if (command === "update") return `Usage:
+  deweyou-cli agent update
+
+Options:
+  -h, --help   Show help.`;
+	return `Usage:
+  deweyou-cli agent doctor
+
+Options:
+  -h, --help   Show help.`;
 }
 function printUsageAndThrow() {
 	console.log(usage());
 	throw usageError("", { silent: true });
 }
+function helpFor(argv) {
+	if (!argv.some(isHelpFlag)) return null;
+	if (isHelpFlag(argv[0])) return rootUsage();
+	if (argv[0] !== "agent") return rootUsage();
+	const command = argv[1];
+	if (!command || isHelpFlag(command)) return agentUsage();
+	if (isAgentCommand(command)) return commandUsage(command);
+	return agentUsage();
+}
+function isVersionRequest(argv) {
+	return argv.length === 1 && (argv[0] === "-v" || argv[0] === "--version");
+}
+function isHelpFlag(value) {
+	return value === "-h" || value === "--help";
+}
+function isAgentCommand(value) {
+	return COMMANDS.includes(value);
+}
 //#endregion
 //#region src/bin/deweyou.ts
 main(process.argv.slice(2)).catch((error) => {

package/dist/{init-g2D-URoL.mjs → init-6406tZjR.mjs}

@@ -1,18 +1,37 @@
 import { cachePaths, n as writeJson, t as readJson } from "./cache-rbXm6Wyh.mjs";
-import { cp, lstat, mkdir, readFile, realpath, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { cp, lstat, mkdir, readFile, readlink, realpath, rename, rm, symlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+//#region src/cli/managed-section.ts
+function upsertManagedSection(contents, { start, end, body }) {
+	const section = `${start}\n${body.trimEnd()}\n${end}`;
+	const markedSection = new RegExp(`${escapeRegex(start)}[\\s\\S]*?${escapeRegex(end)}`);
+	if (markedSection.test(contents)) return ensureTrailingNewline(contents.replace(markedSection, section));
+	const trimmed = contents.trimEnd();
+	if (!trimmed) return `${section}\n`;
+	return `${trimmed}\n\n${section}\n`;
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function ensureTrailingNewline(value) {
+	return value.endsWith("\n") ? value : `${value}\n`;
+}
+//#endregion
 //#region src/cli/agents-md.ts
 const DEWEYOU_SECTION_START = "<!-- deweyou-agent:start -->";
 const DEWEYOU_SECTION_END = "<!-- deweyou-agent:end -->";
-const DEWEY_SECTION = `${DEWEYOU_SECTION_START}
-## Dewey Workflow
+const DEWEY_SECTION_BODY = `## Dewey Workflow
 
-This repository uses Dewey's personal agent workflow. Inspect \`.agents/\` before making changes, then run \`deweyou-cli agent context --format markdown\` and follow the returned rules, skill index, asset paths, and runtime notices.
-${DEWEYOU_SECTION_END}`;
+This repository uses Dewey's personal agent workflow. Inspect \`.agents/\` before making changes, then run \`deweyou-cli agent context --format markdown\` and follow the returned rules, skill index, asset paths, and runtime notices.`;
 async function upsertAgentsSection(repoRoot) {
 	const path = join(repoRoot, "AGENTS.md");
-	const next = upsertSection(await readAgentsFile(path));
+	await validateAgentsWritePath(path);
+	const next = upsertManagedSection(await readAgentsFile(path), {
+		start: DEWEYOU_SECTION_START,
+		end: DEWEYOU_SECTION_END,
+		body: DEWEY_SECTION_BODY
+	});
 	await writeFile(path, next);
 	return next;
 }
@@ -25,18 +44,160 @@ async function readAgentsFile(path) {
 		throw error;
 	}
 }
-function upsertSection(contents) {
-	const markedSection = new RegExp(`${escapeRegex(DEWEYOU_SECTION_START)}[\\s\\S]*?${escapeRegex(DEWEYOU_SECTION_END)}`);
-	if (markedSection.test(contents)) return ensureTrailingNewline(contents.replace(markedSection, DEWEY_SECTION));
-	const trimmed = contents.trimEnd();
-	if (!trimmed) return `${DEWEY_SECTION}\n`;
-	return `${trimmed}\n\n${DEWEY_SECTION}\n`;
+async function validateAgentsWritePath(path) {
+	try {
+		if ((await lstat(path)).isSymbolicLink()) throw new Error(`Refusing to write Dewey workflow through symlink: ${path}`);
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
 }
-function escapeRegex(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+//#endregion
+//#region src/cli/rule-install.ts
+const CODEX_START = "<!-- deweyou-codex-rules:start -->";
+const CODEX_END = "<!-- deweyou-codex-rules:end -->";
+const CLAUDE_START = "<!-- deweyou-claude-rules:start -->";
+const CLAUDE_END = "<!-- deweyou-claude-rules:end -->";
+async function planRuleInstall(input) {
+	validateRuleInstallInput(input);
+	if (input.selectedRules.length === 0) return {
+		files: [],
+		operations: []
+	};
+	const operations = [];
+	if (input.tools.includes("codex")) operations.push(await codexOperation(input));
+	if (input.tools.includes("claude")) {
+		const operation = await claudeOperation(input);
+		if (operation) operations.push(operation);
+	}
+	return {
+		files: operations.map((operation) => operation.path),
+		operations
+	};
 }
-function ensureTrailingNewline(value) {
-	return value.endsWith("\n") ? value : `${value}\n`;
+async function applyRuleInstall(plan) {
+	for (const operation of plan.operations) {
+		await mkdir(dirname(operation.path), { recursive: true });
+		await validateInstructionWritePath(operation.path);
+		const next = upsertManagedSection(await readTextIfPresent(operation.path), operation);
+		await writeFile(operation.path, next);
+	}
+}
+async function codexOperation(input) {
+	return {
+		path: input.scope === "project" ? join(input.repoRoot, "AGENTS.md") : join(input.homeDir, ".codex", "AGENTS.md"),
+		start: CODEX_START,
+		end: CODEX_END,
+		body: await renderRuleSection(input, "Codex")
+	};
+}
+async function claudeOperation(input) {
+	if (input.scope === "project") {
+		const claudePath = join(input.repoRoot, "CLAUDE.md");
+		if (await isSymlinkToAgentsMd(claudePath, input.repoRoot)) {
+			if (input.tools.includes("codex")) return null;
+			return {
+				path: join(input.repoRoot, "AGENTS.md"),
+				start: CLAUDE_START,
+				end: CLAUDE_END,
+				body: await renderRuleSection(input, "Claude Code")
+			};
+		}
+		if (input.tools.includes("codex") && !await exists(claudePath)) return {
+			path: claudePath,
+			start: CLAUDE_START,
+			end: CLAUDE_END,
+			body: "@AGENTS.md"
+		};
+		return {
+			path: claudePath,
+			start: CLAUDE_START,
+			end: CLAUDE_END,
+			body: await renderRuleSection(input, "Claude Code")
+		};
+	}
+	return {
+		path: join(input.homeDir, ".claude", "CLAUDE.md"),
+		start: CLAUDE_START,
+		end: CLAUDE_END,
+		body: await renderRuleSection(input, "Claude Code")
+	};
+}
+function validateRuleInstallInput(input) {
+	if (input.scope !== "project" && input.scope !== "global") throw new Error(`Invalid rule install scope: ${input.scope}`);
+	for (const tool of input.tools) if (tool !== "codex" && tool !== "claude") throw new Error(`Invalid rule install tool: ${tool}`);
+	if (input.ruleWiring !== "reference" && input.ruleWiring !== "inline") throw new Error(`Invalid rule wiring: ${input.ruleWiring}`);
+	if (input.scope === "global") for (const rule of input.selectedRules) {
+		const path = requireRulePath(input, rule);
+		if (!isPathInside(input.cacheRoot, path)) throw new Error(`Global Dewey rule path must be inside cacheRoot for ${rule}: ${path}`);
+	}
+}
+async function renderRuleSection(input, toolLabel) {
+	if (input.ruleWiring === "inline") return `## Dewey Rules for ${toolLabel}
+
+Follow these selected Dewey rules:
+
+${(await Promise.all(input.selectedRules.map(async (rule) => {
+		return `### ${rule}\n\n${await readFile(requireRulePath(input, rule), "utf8")}`;
+	}))).join("\n\n")}`;
+	return `## Dewey Rules for ${toolLabel}
+
+Follow these selected Dewey rules. Read the referenced files before applying a rule:
+
+${input.selectedRules.map((rule) => `- ${rule}: ${displayPath(input, requireRulePath(input, rule))}`).join("\n")}`;
+}
+function requireRulePath(input, rule) {
+	const path = input.rulePaths.get(rule);
+	if (!path) throw new Error(`Missing path for Dewey rule: ${rule}`);
+	return path;
+}
+function displayPath(input, path) {
+	if (input.scope === "project") return relative(input.repoRoot, path);
+	return path;
+}
+function isPathInside(root, path) {
+	const pathFromRoot = relative(resolve(root), resolve(path));
+	return pathFromRoot === "" || !pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot);
+}
+async function readTextIfPresent(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return "";
+		throw error;
+	}
+}
+async function validateInstructionWritePath(path) {
+	try {
+		if ((await lstat(path)).isSymbolicLink()) throw new Error(`Refusing to write Dewey rules through symlink: ${path}`);
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function exists(path) {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function isSymlinkToAgentsMd(path, repoRoot) {
+	try {
+		if (!(await lstat(path)).isSymbolicLink()) return false;
+		const target = await readlink(path);
+		return target === "AGENTS.md" || resolve(dirname(path), target) === resolve(repoRoot, "AGENTS.md");
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
 }
 //#endregion
 //#region src/cli/init.ts
@@ -45,9 +206,23 @@ const VALID_MODES = new Set([
 	"copy",
 	"pointer"
 ]);
+const VALID_SCOPES = new Set(["project", "global"]);
+const VALID_TOOLS = new Set(["codex", "claude"]);
+const VALID_TOOL_SELECTIONS = new Set([
+	"all",
+	"codex",
+	"claude"
+]);
+const VALID_RULE_WIRING = new Set(["reference", "inline"]);
 const SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-async function initRepo({ repoRoot = process.cwd(), homeDir = homedir(), mode = "link", selected, force = false, dryRun = false } = {}) {
+async function initRepo(options = {}) {
+	const { repoRoot = process.cwd(), homeDir = homedir(), mode = "link", selected, force = false, dryRun = false } = options;
 	if (!selected) throw new Error("selected assets are required");
+	const scope = options.scope ?? "project";
+	const ruleWiring = options.ruleWiring ?? "reference";
+	validateScope(scope);
+	validateRuleWiring(ruleWiring);
+	const tools = normalizeTools(options.tools);
 	validateMode(mode);
 	const paths = cachePaths({ homeDir });
 	const registry = await readCachedRegistry(paths.assetsRoot);
@@ -55,6 +230,17 @@ async function initRepo({ repoRoot = process.cwd(), homeDir = homedir(), mode =
 	const assets = normalizeSelected(selected);
 	const agentsRoot = join(repoRoot, ".agents");
 	validateSelectedAssets(registry, assets);
+	if (scope === "global") return await initGlobal({
+		homeDir,
+		repoRoot,
+		paths,
+		registry,
+		cacheManifest,
+		assets,
+		tools,
+		ruleWiring,
+		dryRun
+	});
 	const plan = await buildInitPlan({
 		repoRoot,
 		agentsRoot,
@@ -75,21 +261,62 @@ async function initRepo({ repoRoot = process.cwd(), homeDir = homedir(), mode =
 		cacheRoot: paths.assetsRoot,
 		assets,
 		assetSnapshot: snapshotSelectedAssetMetadata(registry, assets),
+		scope,
+		tools,
+		ruleWiring,
 		initializedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
+	const rulePlan = await planRuleInstall({
+		repoRoot,
+		homeDir,
+		cacheRoot: paths.assetsRoot,
+		scope: "project",
+		tools,
+		ruleWiring,
+		selectedRules: assets.rules,
+		rulePaths: projectRulePathMap(repoRoot, paths.assetsRoot, registry, assets, mode, ruleWiring)
+	});
 	if (dryRun) return {
+		...manifest,
 		dryRun: true,
-		mode,
-		source: cacheManifest.source,
-		cacheRoot: paths.assetsRoot,
-		assets,
-		assetSnapshot: snapshotSelectedAssetMetadata(registry, assets),
-		files: plan.files
+		files: uniqueFiles([...plan.files, ...rulePlan.files])
 	};
 	await mkdir(agentsRoot, { recursive: true });
 	if (mode !== "pointer") await installAssets(plan.assets);
 	await writeJson(join(agentsRoot, "manifest.json"), manifest);
 	await upsertAgentsSection(repoRoot);
+	await applyRuleInstall(rulePlan);
+	return manifest;
+}
+async function initGlobal({ homeDir, repoRoot, paths, registry, cacheManifest, assets, tools, ruleWiring, dryRun }) {
+	if (assets.skills.length > 0) throw new Error("Global installs currently support rules only");
+	const rulePlan = await planRuleInstall({
+		repoRoot,
+		homeDir,
+		cacheRoot: paths.assetsRoot,
+		scope: "global",
+		tools,
+		ruleWiring,
+		selectedRules: assets.rules,
+		rulePaths: rulePathMap(paths.assetsRoot, registry, assets.rules)
+	});
+	const manifest = {
+		scope: "global",
+		source: cacheManifest.source,
+		cacheRoot: paths.assetsRoot,
+		assets,
+		assetSnapshot: snapshotSelectedAssetMetadata(registry, assets),
+		tools,
+		ruleWiring,
+		initializedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (dryRun) return {
+		...manifest,
+		dryRun: true,
+		files: uniqueFiles([...rulePlan.files, join(homeDir, ".deweyou/agents/global-manifest.json")])
+	};
+	await applyRuleInstall(rulePlan);
+	await writeJson(join(homeDir, ".deweyou/agents/global-manifest.json"), manifest);
 	return manifest;
 }
 async function runInit(flags = {}, { promptForInit } = {}) {
@@ -98,6 +325,9 @@ async function runInit(flags = {}, { promptForInit } = {}) {
 	const registry = await readCachedRegistry(cachePaths({ homeDir }).assetsRoot);
 	const scripted = hasScriptedSelectionFlags(flags);
 	let mode = flags.mode ?? "link";
+	let scope = flags.scope;
+	let tools = flags.tools;
+	let ruleWiring = flags.ruleWiring;
 	let selected;
 	validateMode(mode);
 	if (flags.yes && !scripted) throw new Error("--yes requires --all, --skills, or --rules");
@@ -109,15 +339,25 @@ async function runInit(flags = {}, { promptForInit } = {}) {
 		const prompted = await (promptForInit ?? await loadPromptForInit())({
 			registry,
 			repoRoot,
-			mode: flags.mode
+			mode: flags.mode,
+			scope: flags.scope,
+			tools: flags.tools,
+			ruleWiring: flags.ruleWiring
 		});
-		mode = prompted.mode;
+		mode = flags.mode ?? prompted.mode;
+		scope = flags.scope ?? prompted.scope;
+		tools = flags.tools ?? prompted.tools;
+		ruleWiring = flags.ruleWiring ?? prompted.ruleWiring;
 		selected = prompted.selected;
 	}
 	if (!hasSelectedAssets(selected)) throw new Error("No assets selected. Pass --all, --skills, or --rules, or run interactive setup.");
+	if (scripted && scope === "global" && !flags.yes && !flags.dryRun) throw new Error("--scope global with scripted selections requires --yes or --dry-run");
 	const manifest = await initRepo({
 		repoRoot,
 		mode,
+		scope,
+		tools,
+		ruleWiring,
 		selected,
 		force: flags.force ?? false,
 		dryRun: flags.dryRun ?? false,
@@ -130,7 +370,7 @@ async function runInit(flags = {}, { promptForInit } = {}) {
 	return manifest;
 }
 async function loadPromptForInit() {
-	const { promptForInit } = await import("./prompts-DVRcV560.mjs");
+	const { promptForInit } = await import("./prompts-DdaeRkBa.mjs");
 	return promptForInit;
 }
 async function readCachedRegistry(assetsRoot) {
@@ -175,6 +415,22 @@ function validateMode(mode) {
 	if (typeof mode !== "string") throw new Error("mode must be one of link, copy, or pointer");
 	if (!VALID_MODES.has(mode)) throw new Error("mode must be one of link, copy, or pointer");
 }
+function validateScope(scope) {
+	if (typeof scope !== "string") throw new Error("scope must be one of project or global");
+	if (!VALID_SCOPES.has(scope)) throw new Error("scope must be one of project or global");
+}
+function normalizeTools(tools) {
+	if (tools) {
+		for (const tool of tools) if (typeof tool !== "string" || !VALID_TOOL_SELECTIONS.has(tool)) throw new Error(`tool must be one of codex or claude: ${tool}`);
+	}
+	const selected = !tools || tools.includes("all") ? ["codex", "claude"] : [...tools];
+	for (const tool of selected) if (typeof tool !== "string" || !VALID_TOOLS.has(tool)) throw new Error(`tool must be one of codex or claude: ${tool}`);
+	return [...new Set(selected)];
+}
+function validateRuleWiring(ruleWiring) {
+	if (typeof ruleWiring !== "string") throw new Error("ruleWiring must be one of reference or inline");
+	if (!VALID_RULE_WIRING.has(ruleWiring)) throw new Error("ruleWiring must be one of reference or inline");
+}
 function validateSelectedAssets(registry, selected) {
 	for (const skill of selected.skills) {
 		if (!registry.assets.skills[skill]) throw new Error(`Unknown Dewey skill: ${skill}`);
@@ -206,6 +462,16 @@ function pickAssetMetadata(asset) {
 		hash: asset.hash
 	};
 }
+function uniqueFiles(files) {
+	return [...new Set(files)];
+}
+function rulePathMap(assetsRoot, registry, rules) {
+	return new Map(rules.map((rule) => [rule, join(assetsRoot, registry.assets.rules[rule].path)]));
+}
+function projectRulePathMap(repoRoot, assetsRoot, registry, assets, mode, ruleWiring) {
+	if (mode === "pointer" || ruleWiring === "inline") return rulePathMap(assetsRoot, registry, assets.rules);
+	return new Map(assets.rules.map((rule) => [rule, join(repoRoot, ".agents", "rules", `${rule}.md`)]));
+}
 async function buildInitPlan({ repoRoot, agentsRoot, assetsRoot, registry, assets, mode }) {
 	const assetPlans = mode === "pointer" ? [] : await Promise.all([...assets.skills.map((id) => buildAssetPlan({
 		kind: "skill",

package/dist/prompts-DdaeRkBa.mjs

@@ -0,0 +1,189 @@
+import { cancel, confirm, intro, isCancel, multiselect, note, select } from "@clack/prompts";
+//#region src/cli/prompts.ts
+const SETUP_SCOPES = [{
+	value: "project",
+	label: "project",
+	hint: "Install into this repository."
+}, {
+	value: "global",
+	label: "global",
+	hint: "Install into Codex and Claude user homes."
+}];
+const TOOL_OPTIONS = [
+	{
+		value: "both",
+		label: "both",
+		hint: "Wire Codex and Claude Code."
+	},
+	{
+		value: "codex",
+		label: "codex",
+		hint: "Wire AGENTS.md only."
+	},
+	{
+		value: "claude",
+		label: "claude",
+		hint: "Wire CLAUDE.md only."
+	}
+];
+const SETUP_MODES = [
+	{
+		value: "link",
+		label: "link",
+		hint: "Symlink assets from the Dewey cache."
+	},
+	{
+		value: "copy",
+		label: "copy",
+		hint: "Copy asset files into this repository."
+	},
+	{
+		value: "pointer",
+		label: "pointer",
+		hint: "Write only the manifest and AGENTS.md pointers."
+	}
+];
+const RULE_WIRING_OPTIONS = [{
+	value: "reference",
+	label: "reference",
+	hint: "Reference selected rule files."
+}, {
+	value: "inline",
+	label: "inline",
+	hint: "Inline selected rule bodies."
+}];
+const ASSET_SCOPES = [
+	{
+		value: "all",
+		label: "all",
+		hint: "Enable every cached skill and rule."
+	},
+	{
+		value: "custom",
+		label: "custom",
+		hint: "Choose skills and rules individually."
+	},
+	{
+		value: "skills",
+		label: "skills only",
+		hint: "Choose skills without installing rules."
+	},
+	{
+		value: "rules",
+		label: "rules only",
+		hint: "Choose rules without installing skills."
+	}
+];
+const GLOBAL_ASSET_SCOPES = [{
+	value: "all",
+	label: "all rules",
+	hint: "Enable every cached rule."
+}, {
+	value: "rules",
+	label: "choose rules",
+	hint: "Choose rules individually."
+}];
+async function promptForInit({ registry, repoRoot, mode, scope, tools, ruleWiring }) {
+	intro("Dewey Agent Setup");
+	note(repoRoot, "Repository");
+	const selectedScope = scope ?? await promptOrExit(select({
+		message: "Select install scope",
+		options: SETUP_SCOPES
+	}));
+	const selectedTools = tools === void 0 ? normalizePromptTools(await promptOrExit(select({
+		message: "Select tools",
+		options: TOOL_OPTIONS
+	}))) : normalizeToolSelection(tools);
+	const selectedMode = selectedScope === "global" ? "pointer" : mode ?? await promptOrExit(select({
+		message: "Select setup mode",
+		options: SETUP_MODES
+	}));
+	const selected = await selectAssets({
+		registry,
+		scope: await promptOrExit(select({
+			message: "Select asset scope",
+			options: selectedScope === "global" ? GLOBAL_ASSET_SCOPES : ASSET_SCOPES
+		})),
+		installScope: selectedScope
+	});
+	const selectedRuleWiring = ruleWiring ?? (selected.rules.length > 0 ? await promptOrExit(select({
+		message: "Select rule wiring",
+		options: RULE_WIRING_OPTIONS
+	})) : "reference");
+	note(plannedFiles({
+		repoRoot,
+		scope: selectedScope,
+		tools: selectedTools,
+		selected
+	}), "Dewey will update");
+	if (!await promptOrExit(confirm({ message: `Enable ${selected.skills.length} skill(s) and ${selected.rules.length} rule(s) using ${selectedMode} mode?` }))) exitCancelled();
+	return {
+		mode: selectedMode,
+		scope: selectedScope,
+		tools: selectedTools,
+		ruleWiring: selectedRuleWiring,
+		selected
+	};
+}
+async function selectAssets({ registry, scope, installScope }) {
+	if (scope === "all") return {
+		skills: installScope === "global" ? [] : Object.keys(registry.assets.skills),
+		rules: Object.keys(registry.assets.rules)
+	};
+	const selected = {
+		skills: [],
+		rules: []
+	};
+	if (installScope === "project" && (scope === "custom" || scope === "skills")) selected.skills = await promptOrExit(multiselect({
+		message: "Select skills",
+		options: assetOptions(registry.assets.skills),
+		required: false
+	}));
+	if (scope === "custom" || scope === "rules") selected.rules = await promptOrExit(multiselect({
+		message: "Select rules",
+		options: assetOptions(registry.assets.rules),
+		required: false
+	}));
+	return selected;
+}
+function assetOptions(assets) {
+	return Object.entries(assets).map(([name, asset]) => ({
+		value: name,
+		label: name,
+		hint: asset.description
+	}));
+}
+function normalizePromptTools(selectedTools) {
+	if (selectedTools === "both") return ["codex", "claude"];
+	return [selectedTools];
+}
+function normalizeToolSelection(tools) {
+	if (tools.includes("all")) return ["codex", "claude"];
+	return [...new Set(tools)];
+}
+function plannedFiles({ repoRoot, scope, tools, selected }) {
+	const files = [];
+	if (scope === "global") {
+		if (tools.includes("codex")) files.push("~/.codex/AGENTS.md");
+		if (tools.includes("claude")) files.push("~/.claude/CLAUDE.md");
+		files.push("~/.deweyou/agents/global-manifest.json");
+		return files.join("\n");
+	}
+	files.push("AGENTS.md");
+	if (tools.includes("claude") && selected.rules.length > 0) files.push("CLAUDE.md");
+	files.push(".agents/manifest.json");
+	if (selected.skills.length > 0) files.push(".agents/skills/<skill>/SKILL.md");
+	if (selected.rules.length > 0) files.push(".agents/rules/<rule>.md");
+	return `${repoRoot}\n\n${files.join("\n")}`;
+}
+async function promptOrExit(prompt) {
+	const value = await prompt;
+	if (isCancel(value)) exitCancelled();
+	return value;
+}
+function exitCancelled() {
+	cancel("Dewey agent setup cancelled.");
+	process.exit(0);
+}
+//#endregion
+export { promptForInit };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deweyou-cli",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "type": "module",
   "description": "Dewey's personal agent workflow bootstrapper",
   "files": [

package/dist/prompts-DVRcV560.mjs

@@ -1,100 +0,0 @@
-import { cancel, confirm, intro, isCancel, multiselect, note, select } from "@clack/prompts";
-//#region src/cli/prompts.ts
-const SETUP_MODES = [
-	{
-		value: "link",
-		label: "link",
-		hint: "Symlink assets from the Dewey cache."
-	},
-	{
-		value: "copy",
-		label: "copy",
-		hint: "Copy asset files into this repository."
-	},
-	{
-		value: "pointer",
-		label: "pointer",
-		hint: "Write only the manifest and AGENTS.md pointers."
-	}
-];
-const ASSET_SCOPES = [
-	{
-		value: "all",
-		label: "all",
-		hint: "Enable every cached skill and rule."
-	},
-	{
-		value: "custom",
-		label: "custom",
-		hint: "Choose skills and rules individually."
-	},
-	{
-		value: "skills",
-		label: "skills only",
-		hint: "Choose skills without installing rules."
-	},
-	{
-		value: "rules",
-		label: "rules only",
-		hint: "Choose rules without installing skills."
-	}
-];
-async function promptForInit({ registry, repoRoot, mode }) {
-	intro("Dewey Agent Setup");
-	note(repoRoot, "Repository");
-	const selectedMode = mode ?? await promptOrExit(select({
-		message: "Select setup mode",
-		options: SETUP_MODES
-	}));
-	const selected = await selectAssets({
-		registry,
-		scope: await promptOrExit(select({
-			message: "Select asset scope",
-			options: ASSET_SCOPES
-		}))
-	});
-	if (!await promptOrExit(confirm({ message: `Enable ${selected.skills.length} skill(s) and ${selected.rules.length} rule(s) using ${selectedMode} mode?` }))) exitCancelled();
-	return {
-		mode: selectedMode,
-		selected
-	};
-}
-async function selectAssets({ registry, scope }) {
-	if (scope === "all") return {
-		skills: Object.keys(registry.assets.skills),
-		rules: Object.keys(registry.assets.rules)
-	};
-	const selected = {
-		skills: [],
-		rules: []
-	};
-	if (scope === "custom" || scope === "skills") selected.skills = await promptOrExit(multiselect({
-		message: "Select skills",
-		options: assetOptions(registry.assets.skills),
-		required: false
-	}));
-	if (scope === "custom" || scope === "rules") selected.rules = await promptOrExit(multiselect({
-		message: "Select rules",
-		options: assetOptions(registry.assets.rules),
-		required: false
-	}));
-	return selected;
-}
-function assetOptions(assets) {
-	return Object.entries(assets).map(([name, asset]) => ({
-		value: name,
-		label: name,
-		hint: asset.description
-	}));
-}
-async function promptOrExit(prompt) {
-	const value = await prompt;
-	if (isCancel(value)) exitCancelled();
-	return value;
-}
-function exitCancelled() {
-	cancel("Dewey agent setup cancelled.");
-	process.exit(0);
-}
-//#endregion
-export { promptForInit };