tunestra 0.2.0 → 0.3.0

package/README.md

@@ -13,7 +13,8 @@
 > before v1.0.
 
 tunestra gives Claude Code, Codex and other AI coding agents **one shared source** of rules,
-skills, commands and MCP servers, and generates each agent's native configuration from it.
+skills, commands, MCP servers and environment variables, and generates each agent's native
+configuration from it.
 
 The source is a chain of **presets**, from general to specific:
 
@@ -44,8 +45,9 @@ extends:
 agents: [claude]            # add codex: [claude, codex]
 ```
 
-Commit `tunestra.yaml`, `.tunestra/`, `AGENTS.md` and `CLAUDE.md`. Everything else that
-tunestra generates is listed in `.gitignore` automatically.
+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`
+automatically.
 
 ## Principles
 
@@ -86,6 +88,8 @@ overrides:                  # optional: patch inherited MCP servers
     tracker:
       env:
         QUEUE: TEAM
+env:                        # optional: environment variables of the agents
+  MCP_TIMEOUT: 120000
 ```
 
 ### Project: `tunestra.yaml`
@@ -136,6 +140,7 @@ chain once, before both of them.
 | Skill | `name` from `SKILL.md`, otherwise the folder name | replaces it | `exclude.skills` |
 | 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` |
 
 `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.
@@ -149,7 +154,10 @@ are merged by key (the specific value wins); `command`, `args` and `url` are rep
 - two levels have the same name;
 - a manifest has an unknown field or a missing required field;
 - `exclude` or `overrides` refers to a key that is not inherited;
-- after a patch, an MCP server has both `command` and `url`, or neither.
+- 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).
 
 All problems are reported at once, in the order of the files, so you can fix them in one pass.
 
@@ -174,6 +182,20 @@ 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` 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
+fresh clone where `.tunestra/state/` does not exist yet.
+
+Claude Code applies project `env` after you trust the folder. 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
+on them, because they would not work; set them in managed settings, `~/.claude/settings.json`
+or your shell. Values that turn telemetry off, like `OTEL_LOGS_EXPORTER: none`, are allowed.
 
 ### Codex
 
@@ -182,10 +204,12 @@ 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, and `[mcp_servers]` | no |
+| `.codex/config.toml` | `developer_instructions` with every rule, from specific to general, `[shell_environment_policy] set` with `env`, and `[mcp_servers]` | 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 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`.
@@ -240,7 +264,7 @@ and tells you where to move their text.
 |---|---|
 | v0.1 | Inheritance for Claude Code |
 | v0.2 | Codex (this document) |
-| v0.3 | Subagents, a personal `local` level, `env` and permissions |
+| v0.3 | `env`, then permissions, 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-jfoAZbqo.mjs";
+import { t as VERSION } from "./src-BNeh64fK.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";
@@ -303,12 +303,48 @@ function isKeyValueMap(value) {
 //#region src/shared/schemas/preset.ts
 const keys = z.array(z.string().min(1)).readonly();
 const stringMap = z.record(z.string(), z.string());
-const skillName = z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Use lowercase letters, digits and single hyphens").max(64);
+/**
+* Agent Skills naming rule; the name also becomes a directory name.
+*
+* Valid:   "code-review", "storybook", "v2"
+* Invalid: "Code-Review" (uppercase), "code--review" or "-review" (wrong hyphens), "../../etc"
+*/
+const SKILL_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/**
+* A name of an environment variable.
+*
+* Valid:   "MCP_TIMEOUT", "http_proxy", "_PRIVATE"
+* Invalid: "1PASSWORD" (starts with a digit), "MY-VAR" (hyphen), "" (empty)
+*/
+const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* A reference to another variable, which agents do not expand in their settings.
+*
+* Matches:        "${TOKEN}", "Bearer ${TOKEN}"
+* Does not match: "$TOKEN", "price: 5$", "{TOKEN}"
+*/
+const ENV_REFERENCE_PATTERN = /\$\{[^}]*\}/;
+/** YAML reads `MCP_TIMEOUT: 120000` as a number; agents need every value as text. */
+const envValue = z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+]).transform(String).refine((value) => ENV_REFERENCE_PATTERN.test(value) === false, { message: `Agents do not expand \${…} in their settings: write the value itself, and keep secrets out of presets` });
+const envSchema = z.record(z.string(), envValue).superRefine((env, context) => {
+	const names = Object.keys(env);
+	for (const name of names) if (ENV_NAME_PATTERN.test(name) === false) context.addIssue({
+		code: "custom",
+		message: `"${name}" is not a variable name: use letters, digits and "_", and do not start with a digit`,
+		path: [name]
+	});
+});
+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()
+	mcp: keys.optional(),
+	env: keys.optional()
 });
 const mcpPatchSchema = z.strictObject({
 	command: z.string().optional(),
@@ -324,14 +360,16 @@ const presetManifestSchema = z.strictObject({
 	description: z.string().optional(),
 	extends: z.array(z.string().min(1)).readonly().default([]),
 	exclude: excludeSchema.default({}),
-	overrides: overridesSchema.default({})
+	overrides: overridesSchema.default({}),
+	env: envSchema.default({})
 });
 const projectConfigSchema = z.strictObject({
 	name: z.string().min(1).optional(),
 	extends: z.array(z.string().min(1)).readonly().default([]),
 	agents: z.array(z.enum(Agent)).min(1).readonly().default([Agent.Claude]),
 	exclude: excludeSchema.default({}),
-	overrides: overridesSchema.default({})
+	overrides: overridesSchema.default({}),
+	env: envSchema.default({})
 });
 const mcpServerSchema = z.strictObject({
 	description: z.string().optional(),
@@ -577,6 +615,26 @@ async function loadArtifacts(dir, presetName) {
 	};
 }
 //#endregion
+//#region src/shared/utils/paths.ts
+/** Generated files always use `/`, so they are the same on every system. */
+function toPosixPath(path) {
+	return path.split(sep).join("/");
+}
+function relativePosix(from, to) {
+	return toPosixPath(relative(from, to));
+}
+//#endregion
+//#region src/presets/env.ts
+/** The `env` map of a manifest as artifacts, in the order of the file. */
+function createEnvVariables(env, manifestPath, artifactsDir) {
+	const source = relativePosix(artifactsDir, manifestPath);
+	return Object.entries(env).map(([key, value]) => ({
+		key,
+		source,
+		value
+	}));
+}
+//#endregion
 //#region src/presets/load-project.ts
 async function loadProject(dir) {
 	const root = resolve(dir);
@@ -587,6 +645,7 @@ async function loadProject(dir) {
 	const name = config.name ?? folderName;
 	const artifactsDir = join(root, PROJECT_DIR);
 	const artifacts = await loadArtifacts(artifactsDir, name);
+	const env = createEnvVariables(config.env, configPath, artifactsDir);
 	return {
 		...config,
 		name,
@@ -595,19 +654,11 @@ async function loadProject(dir) {
 		dir: root,
 		artifactsDir,
 		remote: void 0,
-		...artifacts
+		...artifacts,
+		env
 	};
 }
 //#endregion
-//#region src/shared/utils/paths.ts
-/** Generated files always use `/`, so they are the same on every system. */
-function toPosixPath(path) {
-	return path.split(sep).join("/");
-}
-function relativePosix(from, to) {
-	return toPosixPath(relative(from, to));
-}
-//#endregion
 //#region src/sources/parse-git-source.ts
 /**
 * A reference to a preset in a git repository.
@@ -809,13 +860,15 @@ async function loadPreset(dir) {
 	if (await checkExists(manifestPath) === false) throw new TunestraError(`${root} is not a preset: ${PRESET_MANIFEST} is missing`);
 	const manifest = await readYaml(manifestPath, presetManifestSchema, "preset manifest");
 	const artifacts = await loadArtifacts(root, manifest.name);
+	const env = createEnvVariables(manifest.env, manifestPath, root);
 	return {
 		...manifest,
 		description: manifest.description,
 		dir: root,
 		artifactsDir: root,
 		remote: void 0,
-		...artifacts
+		...artifacts,
+		env
 	};
 }
 //#endregion
@@ -896,6 +949,87 @@ function createFileOutput(path, content, source) {
 	};
 }
 //#endregion
+//#region src/agents/claude/ignored-env.ts
+/**
+* Variables that Claude Code drops from project settings, because a repository should not
+* control them: https://code.claude.com/docs/en/settings-reference#variables-claude-code-ignores-in-env
+*/
+const IGNORED_NAMES = /* @__PURE__ */ new Set([
+	"CLAUDE_CONFIG_DIR",
+	"CLAUDE_CODE_TMPDIR",
+	"HOME",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"SystemRoot",
+	"ComSpec",
+	"ProgramData",
+	"LOCALAPPDATA",
+	"PATHEXT",
+	"PSModulePath",
+	"OTEL_LOG_RAW_API_BODIES",
+	"ENABLE_BETA_TRACING_DETAILED",
+	"BETA_TRACING_ENDPOINT",
+	"CLAUDE_CODE_ENABLE_TELEMETRY",
+	"CLAUDE_CODE_ENHANCED_TELEMETRY_BETA",
+	"ENABLE_ENHANCED_TELEMETRY_BETA",
+	"OTEL_LOGS_EXPORTER",
+	"OTEL_METRICS_EXPORTER",
+	"OTEL_TRACES_EXPORTER",
+	"OTEL_LOG_USER_PROMPTS",
+	"OTEL_LOG_ASSISTANT_RESPONSES",
+	"OTEL_LOG_TOOL_CONTENT",
+	"OTEL_LOG_TOOL_DETAILS",
+	"OTEL_EXPORTER_PROMETHEUS_HOST",
+	"OTEL_EXPORTER_PROMETHEUS_PORT",
+	"CLAUDE_CODE_PROCESS_WRAPPER",
+	"CLAUDE_CODE_SYNC_SKILLS",
+	"CLAUDE_CODE_SYNC_PLUGINS",
+	"CLAUDE_CODE_PLUGIN_CACHE_DIR",
+	"CLAUDE_CODE_PLUGIN_SEED_DIR",
+	"CLAUDE_CODE_OAUTH_TOKEN",
+	"CLAUDE_CODE_OAUTH_REFRESH_TOKEN",
+	"CLAUDE_CODE_OAUTH_SCOPES",
+	"CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS",
+	"CLAUDE_CODE_DISABLE_ATTACHMENTS",
+	"CLAUDE_CODE_DISABLE_FILE_MENTIONS",
+	"CLAUDE_CODE_REMOTE",
+	"CLAUDE_CODE_ACCOUNT_UUID",
+	"CLAUDE_CODE_MESSAGING_SOCKET",
+	"CLAUDE_CODE_MESSAGING_TOKEN",
+	"CLAUDE_CODE_PROJECT_DIR_NAME",
+	"CLAUDE_CODE_RESTRICTED",
+	"CLAUDE_CODE_DISABLE_POWERSHELL_CMD_RM_DENY",
+	"CLAUDE_CODE_DISABLE_DANGEROUS_RM_TIMEOUT",
+	"CLAUDE_CODE_DISABLE_SUBSTITUTION_RM_PROMPT",
+	"CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT",
+	"CLAUDE_CODE_DISABLE_MOUNTED_DRIVE_RM_PROMPT",
+	"CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS",
+	"CLAUDE_CODE_WARN_DISK_FREE_GIB",
+	"CLAUDE_CODE_WARN_MEMORY_FREE_GIB"
+]);
+/**
+* Families of ignored variables.
+*
+* Matches:        "XDG_CONFIG_HOME", "ProgramFiles(x86)", "CLAUDE_AX_SCREEN_READER",
+*                 "OTEL_EXPORTER_OTLP_ENDPOINT", "OTEL_EXPORTER_OTLP_METRICS_HEADERS"
+* Does not match: "MCP_TIMEOUT", "OTEL_EXPORTER_OTLP_TIMEOUT", "OTEL_SERVICE_NAME"
+*/
+const IGNORED_NAME_PATTERN = /^(XDG_|ProgramFiles|CLAUDE_AX_|OTEL_EXPORTER_OTLP_(\w+_)?(ENDPOINT|HEADERS|PROTOCOL|CERTIFICATE|CLIENT_KEY|INSECURE)$)/;
+/** Values that turn telemetry off: Claude Code applies them even from project settings. */
+const OFF_VALUES = {
+	OTEL_LOGS_EXPORTER: ["none"],
+	OTEL_METRICS_EXPORTER: ["none"],
+	OTEL_TRACES_EXPORTER: ["none"],
+	OTEL_LOG_USER_PROMPTS: ["0", "false"],
+	OTEL_LOG_TOOL_CONTENT: ["0", "false"],
+	OTEL_LOG_TOOL_DETAILS: ["0", "false"]
+};
+function isIgnoredByClaude(name, value) {
+	if ((OFF_VALUES[name] ?? []).includes(value)) return false;
+	return IGNORED_NAMES.has(name) || IGNORED_NAME_PATTERN.test(name);
+}
+//#endregion
 //#region src/agents/claude/mcp-json.ts
 /** `.mcp.json` in the shape Claude Code reads: `{ "mcpServers": { "<key>": config } }`. */
 function renderMcpJson(servers) {
@@ -904,6 +1038,32 @@ function renderMcpJson(servers) {
 	return `${JSON.stringify(content, null, 2)}\n`;
 }
 //#endregion
+//#region src/shared/utils/env.ts
+/**
+* The variables as a plain map, sorted by name so that the generated file and its diff stay
+* the same on every machine.
+*/
+function buildEnvMap(env) {
+	const sortedEntries = env.map((variable) => [variable.artifact.key, variable.artifact.value]).toSorted(compareByName);
+	return Object.fromEntries(sortedEntries);
+}
+/** By code points, not by locale; names are unique, so two entries are never equal. */
+function compareByName([a], [b]) {
+	return a < b ? -1 : 1;
+}
+//#endregion
+//#region src/agents/claude/settings-json.ts
+const SETTINGS_SCHEMA = "https://json.schemastore.org/claude-code-settings.json";
+/** 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`;
+}
+//#endregion
 //#region src/agents/claude/claude-adapter.ts
 const CLAUDE_FILE = "CLAUDE.md";
 const RULES_DIR = ".claude/rules/tunestra";
@@ -911,10 +1071,15 @@ const SKILLS_DIR = ".claude/skills";
 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 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`.
+* 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.
 */
 const claudeAdapter = {
 	agent: Agent.Claude,
@@ -943,6 +1108,12 @@ function planClaude(context) {
 		const mcpFile = createFileOutput(MCP_FILE, mcpJson, MCP_SOURCE);
 		outputs.push(mcpFile);
 	}
+	const protectedPaths = [CLAUDE_FILE];
+	if (resolution.env.length > 0) {
+		const settingsFile = planSettingsFile(resolution.env);
+		outputs.push(settingsFile);
+		protectedPaths.push(SETTINGS_FILE);
+	}
 	return {
 		outputs,
 		ignoredPaths: [
@@ -951,10 +1122,25 @@ function planClaude(context) {
 			`${COMMANDS_DIR}/`,
 			MCP_FILE
 		],
-		protectedPaths: [CLAUDE_FILE],
+		protectedPaths,
 		notes: []
 	};
 }
+/** Claude Code drops some variables from project settings; setup says so instead. */
+function planSettingsFile(env) {
+	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 file = createFileOutput(SETTINGS_FILE, content, SETTINGS_SOURCE);
+	const ownership = {
+		keys: SETTINGS_KEYS,
+		otherKeysTarget: `${LOCAL_SETTINGS_FILE} or ~/.claude/settings.json`
+	};
+	return {
+		...file,
+		ownership
+	};
+}
 function copyRule(ruleFile) {
 	const fileName = posix.basename(ruleFile.path);
 	return createFileOutput(`${RULES_DIR}/${fileName}`, ruleFile.content, ruleFile.source);
@@ -1012,22 +1198,29 @@ const LITERAL_DELIMITER = "'''";
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/;
 /**
 * `.codex/config.toml`: the rules as `developer_instructions`, which Codex adds to every
-* session, and the MCP servers. The rules are a literal string, so that people can read them.
+* session, the environment of the commands that Codex runs, and the MCP servers. The rules
+* are a literal string, so that people can read them.
 */
-function renderConfigToml(instructions, servers) {
+function renderConfigToml(config) {
 	const parts = [GENERATED_HASH_NOTICE];
-	if (typeof instructions === "string") {
-		const line = renderInstructions$1(instructions);
+	if (typeof config.instructions === "string") {
+		const line = renderInstructions$1(config.instructions);
 		parts.push(line);
 	}
-	if (servers.length > 0) {
-		const entries = servers.map((server) => {
-			const config = convertMcpConfig(server.artifact.config);
-			return [server.artifact.key, config];
+	const tables = {};
+	const hasEnv = config.env.length > 0;
+	const hasServers = config.servers.length > 0;
+	if (hasEnv) tables.shell_environment_policy = { set: buildEnvMap(config.env) };
+	if (hasServers) {
+		const entries = config.servers.map((server) => {
+			const serverConfig = convertMcpConfig(server.artifact.config);
+			return [server.artifact.key, serverConfig];
 		});
-		const content = { mcp_servers: Object.fromEntries(entries) };
-		const tables = stringify$1(content).trimEnd();
-		parts.push(tables);
+		tables.mcp_servers = Object.fromEntries(entries);
+	}
+	if (hasEnv || hasServers) {
+		const text = stringify$1(tables).trimEnd();
+		parts.push(text);
 	}
 	return `${parts.join("\n\n")}\n`;
 }
@@ -1049,9 +1242,9 @@ function convertMcpConfig(config) {
 //#endregion
 //#region src/agents/codex/codex-adapter.ts
 const CONFIG_FILE = ".codex/config.toml";
-const CONFIG_SOURCE = "the rules/ and mcp/ folders of tunestra.yaml and its presets";
+const CONFIG_SOURCE = "the rules/ and mcp/ folders and env of 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 rules and MCP servers from .codex/config.toml only in a trusted project: trust the project when Codex asks.";
+const TRUST_NOTE = "Codex reads .codex/config.toml 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
@@ -1078,7 +1271,7 @@ function planCodex(context) {
 			return false;
 		}
 		return true;
-	}));
+	}), resolution.env);
 	if (configFile === void 0) return {
 		outputs,
 		ignoredPaths: [],
@@ -1094,11 +1287,16 @@ function planCodex(context) {
 		notes
 	};
 }
-function planConfigFile(ruleFiles, servers) {
+function planConfigFile(ruleFiles, servers, env) {
 	const hasRules = ruleFiles.length > 0;
 	const hasServers = servers.length > 0;
-	if (hasRules === false && hasServers === false) return;
-	const content = renderConfigToml(hasRules ? renderInstructions(ruleFiles) : void 0, servers);
+	const hasEnv = env.length > 0;
+	if (hasRules === false && hasServers === false && hasEnv === false) return;
+	const content = renderConfigToml({
+		instructions: hasRules ? renderInstructions(ruleFiles) : void 0,
+		servers,
+		env
+	});
 	return createFileOutput(CONFIG_FILE, content, CONFIG_SOURCE);
 }
 /** The rule files as they are, with the header that names the source of each. */
@@ -1200,6 +1398,7 @@ function renderLevelLine(rule) {
 const HIERARCHY_INTRO = "Instructions are ordered from specific to general. When two instructions conflict, follow the one from the higher level in this list.";
 const RULES_INTRO = "Always follow these rules. Claude Code and Codex load them automatically; other agents should read them before starting work.";
 const SKILLS_INTRO = "Use a skill when the task matches its description.";
+const ENV_INTRO = "Agents set these variables in every session, also for the commands they run. The values are in the presets.";
 const CHANGING_SECTION = [
 	"## Changing this setup",
 	"",
@@ -1301,6 +1500,13 @@ function renderMcpServers(servers) {
 		];
 	})));
 }
+function renderEnv(env) {
+	const table = renderTable(["Variable", "Level"], env.map((variable) => {
+		const origin = describeOrigin(variable);
+		return [variable.artifact.key, origin];
+	}));
+	return renderSection("Environment", ENV_INTRO, table);
+}
 /** The project shows its config file; a preset shows its git reference or its path. */
 function describeLevelSource(chain, level) {
 	if (level.dir === chain.project.dir) return PROJECT_CONFIG;
@@ -1340,6 +1546,7 @@ function renderAgentsIndex(resolution) {
 	const hasSkills = resolution.skills.length > 0;
 	const hasCommands = resolution.commands.length > 0;
 	const hasMcpServers = resolution.mcp.length > 0;
+	const hasEnv = resolution.env.length > 0;
 	if (hasRules) {
 		const rules = renderRules(resolution.rules);
 		sections.push(rules);
@@ -1356,6 +1563,10 @@ function renderAgentsIndex(resolution) {
 		const servers = renderMcpServers(resolution.mcp);
 		sections.push(servers);
 	}
+	if (hasEnv) {
+		const env = renderEnv(resolution.env);
+		sections.push(env);
+	}
 	sections.push(CHANGING_SECTION);
 	return `${sections.join("\n\n")}\n`;
 }
@@ -1432,12 +1643,16 @@ function findPathConflicts(outputs) {
 }
 //#endregion
 //#region src/shared/constants/artifacts.ts
-/** Kinds of artifacts; the values match the folder-based fields of a preset and of `exclude`. */
+/**
+* Kinds of artifacts; the values match the fields of a preset and of `exclude`. Environment
+* variables come from the manifest, the other kinds from folders.
+*/
 const ArtifactKind = {
 	Rules: "rules",
 	Skills: "skills",
 	Commands: "commands",
-	Mcp: "mcp"
+	Mcp: "mcp",
+	Env: "env"
 };
 //#endregion
 //#region src/inheritance/inherit-artifacts.ts
@@ -1575,11 +1790,13 @@ function applyInheritance(chain) {
 	const skills = inheritArtifacts(chain.levels, ArtifactKind.Skills, (level) => level.skills);
 	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 problems = [
 		...rules.problems,
 		...skills.problems,
 		...commands.problems,
-		...mcp.problems
+		...mcp.problems,
+		...env.problems
 	];
 	if (problems.length > 0) throw createProblemsError(problems);
 	return {
@@ -1587,7 +1804,8 @@ function applyInheritance(chain) {
 		rules: rules.artifacts,
 		skills: skills.artifacts,
 		commands: commands.artifacts,
-		mcp: mcp.artifacts
+		mcp: mcp.artifacts,
+		env: env.artifacts
 	};
 }
 //#endregion
@@ -1605,7 +1823,7 @@ async function readState(projectDir) {
 	const file = join(projectDir, STATE_FILE);
 	const content = await readFileIfExists(file);
 	if (content === void 0) return createEmptyState();
-	return validate(parseJson(content, file), stateSchema, `state file ${file}. Delete it and run tunestra setup again`);
+	return validate(parseJson$1(content, file), stateSchema, `state file ${file}. Delete it and run tunestra setup again`);
 }
 function createEmptyState() {
 	return {
@@ -1613,7 +1831,7 @@ function createEmptyState() {
 		outputs: {}
 	};
 }
-function parseJson(content, file) {
+function parseJson$1(content, file) {
 	try {
 		return JSON.parse(content);
 	} catch (error) {
@@ -1727,6 +1945,24 @@ async function createRecord(output) {
 	}
 }
 //#endregion
+//#region src/sync/find-foreign-keys.ts
+/**
+* The top-level keys of a JSON file that are not in `ownedKeys`. A file that is not a JSON
+* object has no keys that tunestra could own, so the result is `undefined`.
+*/
+async function findForeignKeys(path, ownedKeys) {
+	const data = parseJson(await readFile(path, "utf8"));
+	if (isKeyValueMap(data)) return Object.keys(data).filter((key) => ownedKeys.includes(key) === false);
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		if (error instanceof SyntaxError) return;
+		throw error;
+	}
+}
+//#endregion
 //#region src/sync/inspect-path.ts
 async function inspectPath(path) {
 	const type = await getPathType(path);
@@ -1770,9 +2006,21 @@ async function checkOutput(output, context) {
 	const isRecorded = typeof previousRecord === "object";
 	const isReplaceable = disk.type === PathType.File || disk.type === PathType.Symlink;
 	if (isRecorded && isReplaceable) return createCheck(output, record, `${output.path} was edited by hand; tunestra replaced it. Edit ${output.source} instead`);
+	const ownership = output.kind === OutputKind.File ? output.ownership : void 0;
+	if (typeof ownership === "object" && disk.type === PathType.File) return createCheck(output, record, await checkOwnedJson(path, output, ownership));
 	if (context.protectedPaths.includes(output.path)) throw new TunestraError(`${output.path} was written by hand, and setup would overwrite it. Move its text to .tunestra/AGENTS.md or to a rule in .tunestra/rules/, then delete ${output.path} and run tunestra setup again`);
 	throw new TunestraError(`${output.path} already exists, and tunestra did not create it. Move it away and run tunestra setup again`);
 }
+/** Takes over a JSON file with only the keys that tunestra writes; other keys stop setup. */
+async function checkOwnedJson(path, output, ownership) {
+	const foreignKeys = await findForeignKeys(path, ownership.keys);
+	if (foreignKeys === void 0) throw new TunestraError(`${output.path} is not a JSON object, and setup would overwrite it. Fix or delete it and run tunestra setup again`);
+	if (foreignKeys.length > 0) {
+		const keys = foreignKeys.join(", ");
+		throw new TunestraError(`${output.path} has settings that tunestra does not write: ${keys}. Move them to ${ownership.otherKeysTarget}, then run tunestra setup again`);
+	}
+	return `${output.path} had only the settings that tunestra writes; tunestra replaced it. Edit ${output.source} instead`;
+}
 /**
 * Nothing to lose: the path is empty, already has the new content, still has what tunestra
 * wrote last time, or is a generated markdown file whose record was lost.
@@ -1913,7 +2161,8 @@ function describeResolution(resolution) {
 		describeSection("Rules", resolution.rules, projectDir),
 		describeSection("Skills", resolution.skills, projectDir),
 		describeSection("Commands", resolution.commands, projectDir),
-		describeSection("MCP servers", resolution.mcp, projectDir)
+		describeSection("MCP servers", resolution.mcp, projectDir),
+		describeSection("Environment", resolution.env, projectDir)
 	].filter((section) => section.length > 0).join("\n\n");
 }
 function describeSection(title, artifacts, projectDir) {
@@ -1961,12 +2210,19 @@ function describeSync(plan, sync, options) {
 		return lines.join("\n");
 	}
 	const check = pc.green("✔");
-	const committedFiles = plan.protectedPaths.join(" and ");
+	const committedFiles = joinList(plan.protectedPaths);
 	lines.push(`${check} Generated ${writeCount} files, removed ${removeCount} stale files.`);
 	lines.push(...notes);
 	lines.push(`Commit ${committedFiles}; the rest is in .gitignore.`);
 	return lines.join("\n");
 }
+/** For example `AGENTS.md, CLAUDE.md and .claude/settings.json`. */
+function joinList(items) {
+	const last = items.at(-1) ?? "";
+	const rest = items.slice(0, -1);
+	if (rest.length === 0) return last;
+	return `${rest.join(", ")} and ${last}`;
+}
 //#endregion
 //#region src/uninstall/remove-gitignore-block.ts
 /** A .gitignore that had only the tunestra block is removed, because tunestra created it. */

package/dist/index.mjs

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tunestra",
-  "version": "0.2.0",
+  "version": "0.3.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",