tunestra 0.3.0 → 0.4.0

package/README.md

@@ -13,8 +13,8 @@
 > before v1.0.
 
 tunestra gives Claude Code, Codex and other AI coding agents **one shared source** of rules,
-skills, commands, MCP servers and environment variables, and generates each agent's native
-configuration from it.
+skills, commands, MCP servers, environment variables and permissions, and generates each
+agent's native configuration from it.
 
 The source is a chain of **presets**, from general to specific:
 
@@ -45,8 +45,8 @@ extends:
 agents: [claude]            # add codex: [claude, codex]
 ```
 
-Commit `tunestra.yaml`, `.tunestra/`, `AGENTS.md`, `CLAUDE.md` and, when presets set `env`,
-`.claude/settings.json`. Everything else that tunestra generates is listed in `.gitignore`
+Commit `tunestra.yaml`, `.tunestra/`, `AGENTS.md`, `CLAUDE.md` and, when presets set `env` or
+`permissions`, `.claude/settings.json`. Everything else that tunestra generates is listed in `.gitignore`
 automatically.
 
 ## Principles
@@ -90,6 +90,10 @@ overrides:                  # optional: patch inherited MCP servers
         QUEUE: TEAM
 env:                        # optional: environment variables of the agents
   MCP_TIMEOUT: 120000
+permissions:                # optional: rules in the syntax of Claude Code
+  allow: [Bash(npm test *)]
+  ask: [Bash(git push *)]
+  deny: [Read(./.env), Bash(rm -rf *)]
 ```
 
 ### Project: `tunestra.yaml`
@@ -141,6 +145,10 @@ chain once, before both of them.
 | Command | file name without `.md` | replaces it | `exclude.commands` |
 | MCP server | file name without `.yaml` | replaces it | `exclude.mcp` |
 | Environment variable | name in `env` | replaces it | `exclude.env` |
+| Permission rule | the rule, like `Bash(npm test *)` | lists are joined: every level adds its rules | `exclude.permissions`, only for `allow` and `ask` |
+
+A `deny` rule cannot be removed: the organization keeps a floor of what agents may never do.
+Agents check `deny` first, so a `deny` rule on any level wins over an `allow` rule.
 
 `overrides.mcp.<key>` patches an inherited server instead of replacing it: `env` and `headers`
 are merged by key (the specific value wins); `command`, `args` and `url` are replaced.
@@ -157,7 +165,8 @@ are merged by key (the specific value wins); `command`, `args` and `url` are rep
 - after a patch, an MCP server has both `command` and `url`, or neither;
 - an `env` value refers to another variable, like `${TOKEN}`: agents do not expand it in
   their settings, so write the value itself and keep secrets out of presets;
-- `env` sets a variable that Claude Code ignores in project settings (see below).
+- `env` sets a variable that Claude Code ignores in project settings (see below);
+- `exclude.permissions` tries to remove a `deny` rule.
 
 All problems are reported at once, in the order of the files, so you can fix them in one pass.
 
@@ -182,15 +191,16 @@ For every agent:
 | `.claude/skills/<key>` | Symlinks to `.agents/skills/<key>` | no |
 | `.claude/commands/<key>.md` | Commands | no |
 | `.mcp.json` | MCP servers | no |
-| `.claude/settings.json` | `env`, when presets set it | yes |
+| `.claude/settings.json` | `env` and `permissions`, when presets set them | yes |
 
 `.claude/settings.json` is shared by the team, so tunestra writes it and you commit it. Keep
 your personal settings in `.claude/settings.local.json` or `~/.claude/settings.json`. A
 `.claude/settings.json` with other keys, like `hooks` or `model`, stops setup and asks you to
-move them; a file with only `$schema` and `env` is replaced with a warning, for example in a
+move them; a file with only `$schema`, `env` and `permissions` is replaced with a warning, for example in a
 fresh clone where `.tunestra/state/` does not exist yet.
 
-Claude Code applies project `env` after you trust the folder. It ignores some variables in
+Claude Code applies project `env` and `allow` rules after you trust the folder; `deny` and
+`ask` rules apply right away. It ignores some variables in
 project settings: the ones that turn telemetry on or choose where it goes
 (`CLAUDE_CODE_ENABLE_TELEMETRY`, `OTEL_*_EXPORTER`, `OTEL_EXPORTER_OTLP_*` and others), and
 the ones that choose its own directories (`HOME`, `XDG_*`, `CLAUDE_CONFIG_DIR`). setup stops
@@ -205,11 +215,19 @@ Codex reads `AGENTS.md` and `.agents/skills/` by itself. It does not follow the
 | Path | Content | Committed |
 |---|---|---|
 | `.codex/config.toml` | `developer_instructions` with every rule, from specific to general, `[shell_environment_policy] set` with `env`, and `[mcp_servers]` | no |
+| `.codex/rules/tunestra.rules` | `deny` and `ask` rules for shell commands as `prefix_rule`: `forbidden` and `prompt` | no |
 | `.agents/skills/<command>/` | Each command as a skill that runs only when you call it: `$release-notes` | no |
 
 Codex reads `.codex/config.toml` only in a trusted project: trust the project when Codex asks.
 Codex gets `env` as the environment of the commands it runs; it does not change how Codex
 itself works, and Codex ignores telemetry settings in a project.
+
+Codex rules match only the start of a shell command, so tunestra converts only `Bash` rules
+like `Bash(git push *)` or `Bash(rm -rf)`. A rule without a wildcard also becomes a prefix,
+which is stricter for `deny` and `ask`. Other rules (`Read`, `Edit`, `WebFetch`, MCP tools, and
+`Bash` rules with wildcards in the middle or shell syntax) are skipped with a note. `allow`
+rules are skipped too: in Codex, an allowed command runs outside the sandbox without asking,
+which is more than an `allow` rule of Claude Code means.
 Codex has no `type` for MCP servers and does not support SSE: an SSE server is skipped with a
 note, and `headers` become `http_headers`. tunestra owns the whole `.codex/config.toml`; keep
 your personal Codex settings in `~/.codex/config.toml`.
@@ -264,7 +282,7 @@ and tells you where to move their text.
 |---|---|
 | v0.1 | Inheritance for Claude Code |
 | v0.2 | Codex (this document) |
-| v0.3 | `env`, then permissions, subagents and a personal `local` level |
+| v0.3 | `env` and permissions, then subagents and a personal `local` level |
 | v0.4 | Spaces, npm sources, lockfile |
 | v0.5 | `required` / `locked` policies, CI check |
 | v0.6 | Hooks |

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as VERSION } from "./src-BNeh64fK.mjs";
+import { t as VERSION } from "./src-Bh7d7ERC.mjs";
 import { Command } from "@commander-js/extra-typings";
 import pc from "picocolors";
 import { copyFile, lstat, mkdir, readFile, readdir, readlink, rename, rm, rmdir, stat, symlink, unlink, writeFile } from "node:fs/promises";
@@ -338,13 +338,21 @@ const envSchema = z.record(z.string(), envValue).superRefine((env, context) => {
 		path: [name]
 	});
 });
+const permissionRules = z.array(z.string().regex(/^[A-Za-z][\w*-]*(\(.+\))?$/, "Write a rule as Tool or Tool(specifier), like Bash(npm test *)")).readonly();
+const permissionsSchema = z.strictObject({
+	allow: permissionRules.optional(),
+	ask: permissionRules.optional(),
+	deny: permissionRules.optional()
+});
 const skillName = z.string().regex(SKILL_NAME_PATTERN, "Use lowercase letters, digits and single hyphens").max(64);
 const excludeSchema = z.strictObject({
 	rules: keys.optional(),
 	skills: keys.optional(),
 	commands: keys.optional(),
 	mcp: keys.optional(),
-	env: keys.optional()
+	env: keys.optional(),
+	/** Inherited `allow` and `ask` rules; a `deny` rule cannot be removed. */
+	permissions: keys.optional()
 });
 const mcpPatchSchema = z.strictObject({
 	command: z.string().optional(),
@@ -361,7 +369,8 @@ const presetManifestSchema = z.strictObject({
 	extends: z.array(z.string().min(1)).readonly().default([]),
 	exclude: excludeSchema.default({}),
 	overrides: overridesSchema.default({}),
-	env: envSchema.default({})
+	env: envSchema.default({}),
+	permissions: permissionsSchema.default({})
 });
 const projectConfigSchema = z.strictObject({
 	name: z.string().min(1).optional(),
@@ -369,7 +378,8 @@ const projectConfigSchema = z.strictObject({
 	agents: z.array(z.enum(Agent)).min(1).readonly().default([Agent.Claude]),
 	exclude: excludeSchema.default({}),
 	overrides: overridesSchema.default({}),
-	env: envSchema.default({})
+	env: envSchema.default({}),
+	permissions: permissionsSchema.default({})
 });
 const mcpServerSchema = z.strictObject({
 	description: z.string().optional(),
@@ -635,6 +645,34 @@ function createEnvVariables(env, manifestPath, artifactsDir) {
 	}));
 }
 //#endregion
+//#region src/shared/constants/permissions.ts
+/** What an agent does with a tool call that matches a permission rule. */
+const PermissionDecision = {
+	/** Run without asking. */
+	Allow: "allow",
+	/** Ask every time. */
+	Ask: "ask",
+	/** Never run. Agents check deny first, so a deny rule always wins. */
+	Deny: "deny"
+};
+//#endregion
+//#region src/presets/permissions.ts
+const DECISIONS$1 = Object.values(PermissionDecision);
+/** The `permissions` lists of a manifest as one list of rules, in the order of the file. */
+function createPermissionRules(permissions, manifestPath, artifactsDir) {
+	const source = relativePosix(artifactsDir, manifestPath);
+	const rules = [];
+	for (const decision of DECISIONS$1) {
+		const keys = permissions[decision] ?? [];
+		for (const key of keys) rules.push({
+			key,
+			decision,
+			source
+		});
+	}
+	return rules;
+}
+//#endregion
 //#region src/presets/load-project.ts
 async function loadProject(dir) {
 	const root = resolve(dir);
@@ -646,6 +684,7 @@ async function loadProject(dir) {
 	const artifactsDir = join(root, PROJECT_DIR);
 	const artifacts = await loadArtifacts(artifactsDir, name);
 	const env = createEnvVariables(config.env, configPath, artifactsDir);
+	const permissions = createPermissionRules(config.permissions, configPath, artifactsDir);
 	return {
 		...config,
 		name,
@@ -655,7 +694,8 @@ async function loadProject(dir) {
 		artifactsDir,
 		remote: void 0,
 		...artifacts,
-		env
+		env,
+		permissions
 	};
 }
 //#endregion
@@ -861,6 +901,7 @@ async function loadPreset(dir) {
 	const manifest = await readYaml(manifestPath, presetManifestSchema, "preset manifest");
 	const artifacts = await loadArtifacts(root, manifest.name);
 	const env = createEnvVariables(manifest.env, manifestPath, root);
+	const permissions = createPermissionRules(manifest.permissions, manifestPath, root);
 	return {
 		...manifest,
 		description: manifest.description,
@@ -868,7 +909,8 @@ async function loadPreset(dir) {
 		artifactsDir: root,
 		remote: void 0,
 		...artifacts,
-		env
+		env,
+		permissions
 	};
 }
 //#endregion
@@ -1054,14 +1096,31 @@ function compareByName([a], [b]) {
 //#endregion
 //#region src/agents/claude/settings-json.ts
 const SETTINGS_SCHEMA = "https://json.schemastore.org/claude-code-settings.json";
+const DECISIONS = Object.values(PermissionDecision);
 /** The keys that tunestra writes; a file with only these keys is a generated one. */
-const SETTINGS_KEYS = ["$schema", "env"];
-function renderSettingsJson(env) {
-	const variables = buildEnvMap(env);
-	return `${JSON.stringify({
-		$schema: SETTINGS_SCHEMA,
-		env: variables
-	}, null, 2)}\n`;
+const SETTINGS_KEYS = [
+	"$schema",
+	"env",
+	"permissions"
+];
+/** `.claude/settings.json` with sorted keys and lists, so that its diff stays small. */
+function renderSettingsJson(settings) {
+	const content = { $schema: SETTINGS_SCHEMA };
+	const hasEnv = settings.env.length > 0;
+	const hasPermissions = settings.permissions.length > 0;
+	if (hasEnv) content.env = buildEnvMap(settings.env);
+	if (hasPermissions) content.permissions = buildPermissionLists(settings.permissions);
+	return `${JSON.stringify(content, null, 2)}\n`;
+}
+/** Only the lists that have rules; a rule repeated on several levels is written once. */
+function buildPermissionLists(permissions) {
+	const lists = {};
+	for (const decision of DECISIONS) {
+		const keys = permissions.filter((resolved) => resolved.artifact.decision === decision).map((resolved) => resolved.artifact.key);
+		const sortedKeys = [...new Set(keys)].toSorted();
+		if (sortedKeys.length > 0) lists[decision] = sortedKeys;
+	}
+	return lists;
 }
 //#endregion
 //#region src/agents/claude/claude-adapter.ts
@@ -1072,14 +1131,14 @@ const COMMANDS_DIR = ".claude/commands";
 const MCP_FILE = ".mcp.json";
 const MCP_SOURCE = "the mcp/ folders of tunestra.yaml and its presets";
 const SETTINGS_FILE = ".claude/settings.json";
-const SETTINGS_SOURCE = "env in tunestra.yaml and its presets";
+const SETTINGS_SOURCE = "env and permissions in tunestra.yaml and its presets";
 const LOCAL_SETTINGS_FILE = ".claude/settings.local.json";
 /**
 * Claude Code reads CLAUDE.md, so it imports AGENTS.md. Rules are copied to `.claude/rules`,
 * which Claude Code loads in every session; a symlink to a directory outside `.claude`
 * would need an approval. Skills are symlinks to the shared `.agents/skills`. Environment
-* variables go to `.claude/settings.json`, which the team commits; `settings.local.json`
-* stays for personal settings.
+* variables and permissions go to `.claude/settings.json`, which the team commits;
+* `settings.local.json` stays for personal settings.
 */
 const claudeAdapter = {
 	agent: Agent.Claude,
@@ -1109,8 +1168,8 @@ function planClaude(context) {
 		outputs.push(mcpFile);
 	}
 	const protectedPaths = [CLAUDE_FILE];
-	if (resolution.env.length > 0) {
-		const settingsFile = planSettingsFile(resolution.env);
+	if (resolution.env.length > 0 || resolution.permissions.length > 0) {
+		const settingsFile = planSettingsFile(resolution.env, resolution.permissions);
 		outputs.push(settingsFile);
 		protectedPaths.push(SETTINGS_FILE);
 	}
@@ -1127,10 +1186,13 @@ function planClaude(context) {
 	};
 }
 /** Claude Code drops some variables from project settings; setup says so instead. */
-function planSettingsFile(env) {
+function planSettingsFile(env, permissions) {
 	const problems = env.filter((variable) => isIgnoredByClaude(variable.artifact.key, variable.artifact.value)).map((variable) => `${variable.origin.name}: env sets ${variable.artifact.key}, but Claude Code ignores it in project settings. Set it in managed settings, ~/.claude/settings.json or your shell`);
 	if (problems.length > 0) throw createProblemsError(problems);
-	const content = renderSettingsJson(env);
+	const content = renderSettingsJson({
+		env,
+		permissions
+	});
 	const file = createFileOutput(SETTINGS_FILE, content, SETTINGS_SOURCE);
 	const ownership = {
 		keys: SETTINGS_KEYS,
@@ -1240,15 +1302,82 @@ function convertMcpConfig(config) {
 	};
 }
 //#endregion
+//#region src/agents/codex/exec-rules.ts
+/** A Bash rule of Claude Code with a specifier: `Bash(npm test *)`. */
+const BASH_RULE_START = "Bash(";
+const BASH_RULE_END = ")";
+/**
+* Shell syntax and wildcards that a Codex prefix rule cannot express.
+*
+* Matches:        "npm test && rm", "echo $HOME", "git * --force", "ls > out", "say 'hi'"
+* Does not match: "npm test", "git push --force", "rm -rf"
+*/
+const SHELL_SYNTAX_PATTERN = /["'`$\\|&;<>(){}*?[\]~]/;
+const WHITESPACE_PATTERN = /\s+/;
+/** A trailing ` *` or the older `:*` means "this command with any arguments". */
+const ANY_ARGUMENTS_SUFFIXES = [" *", ":*"];
+/**
+* Codex names for the decisions it gets. `allow` stays out: in Codex it runs a command
+* outside the sandbox without asking, which is more than an `allow` rule of Claude Code means.
+*/
+const CODEX_DECISIONS = {
+	[PermissionDecision.Deny]: "forbidden",
+	[PermissionDecision.Ask]: "prompt"
+};
+/**
+* The words of a Bash rule that Codex can match by prefix, or `undefined` when it cannot.
+* A rule without a wildcard becomes a prefix too: for `deny` and `ask` this is stricter.
+*/
+function convertBashRule(rule) {
+	if ((rule.startsWith(BASH_RULE_START) && rule.endsWith(BASH_RULE_END)) === false) return;
+	const specifier = rule.slice(5, -1);
+	const suffix = ANY_ARGUMENTS_SUFFIXES.find((ending) => specifier.endsWith(ending));
+	const command = typeof suffix === "string" ? specifier.slice(0, -suffix.length) : specifier;
+	if (SHELL_SYNTAX_PATTERN.test(command)) return;
+	const words = command.trim().split(WHITESPACE_PATTERN);
+	if (words.every((word) => word.length > 0)) return words;
+}
+function hasCodexDecision(decision) {
+	return decision in CODEX_DECISIONS;
+}
+function createExecRule(resolved, decision, pattern) {
+	return {
+		pattern,
+		decision: CODEX_DECISIONS[decision],
+		justification: `${resolved.artifact.key}: ${decision} from ${resolved.origin.name}`
+	};
+}
+/** `.codex/rules/tunestra.rules` in the Starlark format of Codex. */
+function renderExecRules(rules) {
+	const blocks = rules.map(renderExecRule);
+	return `${[GENERATED_HASH_NOTICE, ...blocks].join("\n\n")}\n`;
+}
+/** JSON strings are valid Starlark strings. */
+function renderExecRule(rule) {
+	const pattern = rule.pattern.map((word) => JSON.stringify(word)).join(", ");
+	const decision = JSON.stringify(rule.decision);
+	const justification = JSON.stringify(rule.justification);
+	return [
+		"prefix_rule(",
+		`    pattern = [${pattern}],`,
+		`    decision = ${decision},`,
+		`    justification = ${justification},`,
+		")"
+	].join("\n");
+}
+//#endregion
 //#region src/agents/codex/codex-adapter.ts
 const CONFIG_FILE = ".codex/config.toml";
 const CONFIG_SOURCE = "the rules/ and mcp/ folders and env of tunestra.yaml and its presets";
+const EXEC_RULES_FILE = ".codex/rules/tunestra.rules";
+const EXEC_RULES_SOURCE = "permissions in tunestra.yaml and its presets";
 const INSTRUCTIONS_INTRO = "Rules of this project, ordered from specific to general. When two rules conflict, follow the one that comes first.";
-const TRUST_NOTE = "Codex reads .codex/config.toml only in a trusted project: trust the project when Codex asks.";
+const TRUST_NOTE = "Codex reads .codex/ only in a trusted project: trust the project when Codex asks.";
 /**
 * Codex reads AGENTS.md and the skills in `.agents/skills` by itself. Rules go to
 * `developer_instructions` in `.codex/config.toml`, because Codex does not follow the links
-* in AGENTS.md; MCP servers go to the same file. Commands become skills.
+* in AGENTS.md; MCP servers and env go to the same file. Commands become skills, and
+* permission rules for shell commands become `.codex/rules/tunestra.rules`.
 */
 const codexAdapter = {
 	agent: Agent.Codex,
@@ -1272,18 +1401,67 @@ function planCodex(context) {
 		}
 		return true;
 	}), resolution.env);
-	if (configFile === void 0) return {
+	const execRules = planExecRules(resolution.permissions);
+	const ignoredPaths = [];
+	notes.push(...execRules.notes);
+	if (typeof configFile === "object") {
+		outputs.push(configFile);
+		ignoredPaths.push(CONFIG_FILE);
+	}
+	if (typeof execRules.file === "object") {
+		outputs.push(execRules.file);
+		ignoredPaths.push(EXEC_RULES_FILE);
+	}
+	if (ignoredPaths.length > 0) notes.push(TRUST_NOTE);
+	return {
 		outputs,
-		ignoredPaths: [],
+		ignoredPaths,
 		protectedPaths: [],
 		notes
 	};
-	outputs.push(configFile);
-	notes.push(TRUST_NOTE);
+}
+/**
+* `deny` and `ask` rules for Bash commands become prefix rules of Codex. Codex has no rules
+* for files, the web or MCP tools, and `allow` would mean more in Codex, so those are skipped.
+*/
+function planExecRules(permissions) {
+	const execRules = [];
+	const skippedRules = [];
+	const allowRules = [];
+	for (const resolved of permissions) {
+		const { key, decision } = resolved.artifact;
+		if (hasCodexDecision(decision) === false) {
+			allowRules.push(key);
+			continue;
+		}
+		const pattern = convertBashRule(key);
+		if (pattern === void 0) {
+			skippedRules.push(key);
+			continue;
+		}
+		const execRule = createExecRule(resolved, decision, pattern);
+		execRules.push(execRule);
+	}
+	const notes = [];
+	const hasSkippedRules = skippedRules.length > 0;
+	const hasAllowRules = allowRules.length > 0;
+	if (hasSkippedRules) {
+		const rules = skippedRules.join(", ");
+		notes.push(`Codex skips permission rules that it cannot enforce: ${rules}. Codex rules match only the start of a shell command.`);
+	}
+	if (hasAllowRules) {
+		const rules = allowRules.join(", ");
+		notes.push(`Codex skips allow rules: ${rules}. In Codex, an allowed command runs outside the sandbox without asking.`);
+	}
+	if (execRules.length > 0) {
+		const content = renderExecRules(execRules);
+		return {
+			file: createFileOutput(EXEC_RULES_FILE, content, EXEC_RULES_SOURCE),
+			notes
+		};
+	}
 	return {
-		outputs,
-		ignoredPaths: [CONFIG_FILE],
-		protectedPaths: [],
+		file: void 0,
 		notes
 	};
 }
@@ -1722,6 +1900,62 @@ function orderFromSpecific(levels, inherited, selectArtifacts) {
 	return ordered;
 }
 //#endregion
+//#region src/inheritance/inherit-permissions.ts
+/**
+* Permission lists are joined along the chain: every level adds its rules. A more specific
+* level can remove inherited `allow` and `ask` rules with `exclude.permissions`, but not
+* `deny` rules, so that a general level keeps a floor of what is never allowed.
+*/
+function inheritPermissions(levels) {
+	const inherited = /* @__PURE__ */ new Map();
+	const problems = [];
+	for (const level of levels) {
+		const excludeProblems = excludeRules(inherited, level);
+		const origin = createOrigin(level);
+		problems.push(...excludeProblems);
+		for (const rule of level.permissions) {
+			const id = buildRuleId(rule);
+			const previous = inherited.get(id);
+			const overrides = previous === void 0 ? [] : [...previous.overrides, previous.origin];
+			inherited.set(id, {
+				artifact: rule,
+				origin,
+				overrides,
+				patchedBy: []
+			});
+		}
+	}
+	return {
+		artifacts: [...inherited.values()],
+		problems
+	};
+}
+/** The same rule can be in two lists, for example in `allow` on one level and `deny` on another. */
+function buildRuleId(rule) {
+	return `${rule.decision} ${rule.key}`;
+}
+function excludeRules(inherited, level) {
+	const keys = level.exclude.permissions ?? [];
+	const problems = [];
+	for (const key of keys) {
+		const matches = [...inherited.values()].filter((resolved) => resolved.artifact.key === key);
+		const deny = matches.find((resolved) => resolved.artifact.decision === PermissionDecision.Deny);
+		if (typeof deny === "object") {
+			problems.push(`${level.name}: exclude.permissions lists "${key}", but it is a deny rule of ${deny.origin.name}, and a deny rule cannot be removed`);
+			continue;
+		}
+		if (matches.length === 0) {
+			problems.push(`${level.name}: exclude.permissions lists "${key}", but no more general level has it`);
+			continue;
+		}
+		for (const match of matches) {
+			const id = buildRuleId(match.artifact);
+			inherited.delete(id);
+		}
+	}
+	return problems;
+}
+//#endregion
 //#region src/shared/utils/records.ts
 /** Merges two string maps; keys of `patch` win. Missing on both sides stays missing. */
 function mergeRecords(base, patch) {
@@ -1791,12 +2025,14 @@ function applyInheritance(chain) {
 	const commands = inheritArtifacts(chain.levels, ArtifactKind.Commands, (level) => level.commands);
 	const mcp = inheritArtifacts(chain.levels, ArtifactKind.Mcp, (level) => level.mcp, patchMcpServers);
 	const env = inheritArtifacts(chain.levels, ArtifactKind.Env, (level) => level.env);
+	const permissions = inheritPermissions(chain.levels);
 	const problems = [
 		...rules.problems,
 		...skills.problems,
 		...commands.problems,
 		...mcp.problems,
-		...env.problems
+		...env.problems,
+		...permissions.problems
 	];
 	if (problems.length > 0) throw createProblemsError(problems);
 	return {
@@ -1805,7 +2041,8 @@ function applyInheritance(chain) {
 		skills: skills.artifacts,
 		commands: commands.artifacts,
 		mcp: mcp.artifacts,
-		env: env.artifacts
+		env: env.artifacts,
+		permissions: permissions.artifacts
 	};
 }
 //#endregion
@@ -2157,14 +2394,28 @@ async function runSetup(projectDir, options) {
 /** For --verbose: every artifact, the level it comes from and the file to edit. */
 function describeResolution(resolution) {
 	const projectDir = resolution.chain.project.dir;
+	const permissions = resolution.permissions.map(labelPermission);
 	return [
 		describeSection("Rules", resolution.rules, projectDir),
 		describeSection("Skills", resolution.skills, projectDir),
 		describeSection("Commands", resolution.commands, projectDir),
 		describeSection("MCP servers", resolution.mcp, projectDir),
-		describeSection("Environment", resolution.env, projectDir)
+		describeSection("Environment", resolution.env, projectDir),
+		describeSection("Permissions", permissions, projectDir)
 	].filter((section) => section.length > 0).join("\n\n");
 }
+/** For example `deny Read(./.env)`: the same rule can be in two lists. */
+function labelPermission(resolved) {
+	const { decision, key } = resolved.artifact;
+	const artifact = {
+		...resolved.artifact,
+		key: `${decision} ${key}`
+	};
+	return {
+		...resolved,
+		artifact
+	};
+}
 function describeSection(title, artifacts, projectDir) {
 	if (artifacts.length === 0) return "";
 	const rows = artifacts.map((resolved) => {

package/dist/index.mjs

@@ -1 +1 @@
-export { t as VERSION } from "./src-BNeh64fK.mjs";
+export { t as VERSION } from "./src-Bh7d7ERC.mjs";

package/dist/{src-BNeh64fK.mjs → src-Bh7d7ERC.mjs}

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/index.ts
-const VERSION = "0.3.0";
+const VERSION = "0.4.0";
 //#endregion
 export { VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tunestra",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Tune your AI agents to play as one orchestra: one source of rules, skills, commands and MCP servers for Claude Code, Codex and more.",
   "keywords": [
     "ai",