tunestra 0.4.0 → 0.5.0

package/README.md

@@ -70,9 +70,26 @@ the manifest only holds metadata and overrides.
   rules/<key>.md            # rules, one topic per file
   skills/<key>/SKILL.md     # skills (Agent Skills format)
   commands/<key>.md         # slash commands
+  agents/<key>.md           # subagents
   mcp/<key>.yaml            # MCP servers
 ```
 
+A subagent is a markdown file with frontmatter; the text after it is the instructions:
+
+```md
+---
+description: Reviews a diff for bugs and missing tests   # required: when to use it
+model:                      # optional: the model for each agent
+  claude: sonnet            #   otherwise the agent uses the model of the main session
+  codex: gpt-5.5
+effort: medium              # optional: low | medium | high | xhigh
+readOnly: true              # optional: the subagent must not change files
+---
+Review the diff. Report each finding with a file and a line.
+```
+
+The file name is the name of the subagent: lowercase letters, digits and single hyphens.
+
 ### Manifest: `tunestra.preset.yaml`
 
 ```yaml
@@ -143,6 +160,7 @@ chain once, before both of them.
 | Level instructions (`AGENTS.md`) | `instructions@<preset name>` | never collides: every level keeps its own | `exclude.rules` |
 | Skill | `name` from `SKILL.md`, otherwise the folder name | replaces it | `exclude.skills` |
 | Command | file name without `.md` | replaces it | `exclude.commands` |
+| Subagent | file name without `.md` | replaces it | `exclude.subagents` |
 | 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` |
@@ -166,7 +184,9 @@ are merged by key (the specific value wins); `command`, `args` and `url` are rep
 - 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);
-- `exclude.permissions` tries to remove a `deny` rule.
+- `exclude.permissions` tries to remove a `deny` rule;
+- a subagent has no `description` or no instructions, an unknown field, or a file name that
+  cannot be a subagent name.
 
 All problems are reported at once, in the order of the files, so you can fix them in one pass.
 
@@ -176,7 +196,7 @@ For every agent:
 
 | Path | Content | Committed |
 |---|---|---|
-| `AGENTS.md` | Index: hierarchy, rules, skills, commands, MCP servers | yes |
+| `AGENTS.md` | Index: hierarchy, rules, skills, commands, MCP servers, subagents | yes |
 | `.agents/rules/<NN>-<level>-<key>.md` | Rule texts, ordered from specific to general | no |
 | `.agents/skills/<key>/` | Skills | no |
 | `.tunestra/state/` | What tunestra generated last time | no |
@@ -190,6 +210,7 @@ For every agent:
 | `.claude/rules/tunestra/<NN>-<level>-<key>.md` | Copies of the rules; Claude Code loads them in every session | no |
 | `.claude/skills/<key>` | Symlinks to `.agents/skills/<key>` | no |
 | `.claude/commands/<key>.md` | Commands | no |
+| `.claude/agents/<key>.md` | Subagents | no |
 | `.mcp.json` | MCP servers | no |
 | `.claude/settings.json` | `env` and `permissions`, when presets set them | yes |
 
@@ -207,6 +228,9 @@ the ones that choose its own directories (`HOME`, `XDG_*`, `CLAUDE_CONFIG_DIR`).
 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.
 
+A read-only subagent of Claude Code loses the tools that change files: `Write`, `Edit`,
+`NotebookEdit` and `Bash`. It keeps the tools that read and search, and MCP tools.
+
 ### Codex
 
 Codex reads `AGENTS.md` and `.agents/skills/` by itself. It does not follow the links in
@@ -217,6 +241,7 @@ Codex reads `AGENTS.md` and `.agents/skills/` by itself. It does not follow the
 | `.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/agents/<key>.toml` | Subagents | 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
@@ -232,6 +257,11 @@ Codex has no `type` for MCP servers and does not support SSE: an SSE server is s
 note, and `headers` become `http_headers`. tunestra owns the whole `.codex/config.toml`; keep
 your personal Codex settings in `~/.codex/config.toml`.
 
+A Codex subagent gets the sandbox, the permissions and the MCP servers of the main session; its
+file can change only the model and the instructions. So Codex cannot make a subagent
+read-only: tunestra turns off its shell (`features.shell_tool = false`) and asks it not to
+edit files in the instructions, and setup says so in a note.
+
 `<NN>` orders rules from specific to general: `10` project, `20` team, `30` domain, `40` base.
 Level instructions get the key `instructions`, and the preset name when it differs from the
 level: `20-team-instructions.md`, but `20-team-instructions-frontend.md` for a `team` preset

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as VERSION } from "./src-Bh7d7ERC.mjs";
+import { t as VERSION } from "./src-CZK2Ixbt.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";
@@ -350,6 +350,7 @@ const excludeSchema = z.strictObject({
 	skills: keys.optional(),
 	commands: keys.optional(),
 	mcp: keys.optional(),
+	subagents: keys.optional(),
 	env: keys.optional(),
 	/** Inherited `allow` and `ask` rules; a `deny` rule cannot be removed. */
 	permissions: keys.optional()
@@ -463,6 +464,15 @@ async function mapSettled(items, map) {
 	throw buildResultsError(results);
 }
 //#endregion
+//#region src/shared/constants/subagents.ts
+/** Reasoning effort of a subagent: the levels that both Claude Code and Codex accept. */
+const SubagentEffort = {
+	Low: "low",
+	Medium: "medium",
+	High: "high",
+	ExtraHigh: "xhigh"
+};
+//#endregion
 //#region src/shared/schemas/frontmatter.ts
 const ruleFrontmatterSchema = z.looseObject({ description: z.string().optional() });
 const skillFrontmatterSchema = z.looseObject({
@@ -470,6 +480,15 @@ const skillFrontmatterSchema = z.looseObject({
 	description: z.string().min(1)
 });
 const commandFrontmatterSchema = z.looseObject({ description: z.string().optional() });
+/** The model names differ between agents, so a subagent sets one for each agent. */
+const subagentModelSchema = z.partialRecord(z.enum(Agent), z.string().min(1));
+/** tunestra writes the files of the agents itself, so it knows every field here. */
+const subagentFrontmatterSchema = z.strictObject({
+	description: z.string().min(1),
+	model: subagentModelSchema.default({}),
+	effort: z.enum(SubagentEffort).optional(),
+	readOnly: z.boolean().default(false)
+});
 //#endregion
 //#region src/presets/frontmatter.ts
 /**
@@ -602,6 +621,28 @@ function findDuplicateSkills(skills, dir) {
 	return problems;
 }
 //#endregion
+//#region src/presets/artifacts/subagents.ts
+/** Subagents live in `agents/`, like in Claude Code and Codex. */
+async function loadSubagents(dir) {
+	return mapSettled(await listFiles(dir, "agents/*.md"), (source) => loadSubagent(dir, source));
+}
+async function loadSubagent(dir, source) {
+	const file = join(dir, source);
+	const { data, body } = parseFrontmatter(await readFile(file, "utf8"), file);
+	const frontmatter = validate(data, subagentFrontmatterSchema, `frontmatter in ${file}`);
+	const key = validate(basename(source, ".md"), skillName, `subagent file ${source}`);
+	if (body.trim().length > 0 === false) throw new TunestraError(`${file} has no instructions: write them after the frontmatter`);
+	return {
+		key,
+		source,
+		description: frontmatter.description,
+		model: frontmatter.model,
+		effort: frontmatter.effort,
+		readOnly: frontmatter.readOnly,
+		body
+	};
+}
+//#endregion
 //#region src/presets/artifacts/load-artifacts.ts
 /** Loads every kind of artifact at the same time and reports the problems of all of them. */
 async function loadArtifacts(dir, presetName) {
@@ -609,19 +650,22 @@ async function loadArtifacts(dir, presetName) {
 	const skillsLoading = loadSkills(dir);
 	const commandsLoading = loadCommands(dir);
 	const mcpLoading = loadMcpServers(dir);
+	const subagentsLoading = loadSubagents(dir);
 	const results = await Promise.allSettled([
 		rulesLoading,
 		skillsLoading,
 		commandsLoading,
-		mcpLoading
+		mcpLoading,
+		subagentsLoading
 	]);
 	if (isEveryFulfilled(results) === false) throw buildResultsError(results);
-	const [rulesResult, skillsResult, commandsResult, mcpResult] = results;
+	const [rulesResult, skillsResult, commandsResult, mcpResult, subagentsResult] = results;
 	return {
 		rules: rulesResult.value,
 		skills: skillsResult.value,
 		commands: commandsResult.value,
-		mcp: mcpResult.value
+		mcp: mcpResult.value,
+		subagents: subagentsResult.value
 	};
 }
 //#endregion
@@ -1123,11 +1167,33 @@ function buildPermissionLists(permissions) {
 	return lists;
 }
 //#endregion
+//#region src/agents/claude/subagent-md.ts
+/** Tools that change files; a read-only subagent keeps the tools that read and search. */
+const WRITING_TOOLS = [
+	"Write",
+	"Edit",
+	"NotebookEdit",
+	"Bash"
+];
+/** `.claude/agents/<name>.md`: the frontmatter of Claude Code and the instructions. */
+function renderSubagentMd(subagent) {
+	const { key, description, model, effort, readOnly, body } = subagent;
+	const frontmatter = {
+		name: key,
+		description
+	};
+	if (typeof model.claude === "string") frontmatter.model = model.claude;
+	if (typeof effort === "string") frontmatter.effort = effort;
+	if (readOnly) frontmatter.disallowedTools = WRITING_TOOLS;
+	return `---\n${stringify(frontmatter)}---\n${body}`;
+}
+//#endregion
 //#region src/agents/claude/claude-adapter.ts
 const CLAUDE_FILE = "CLAUDE.md";
 const RULES_DIR = ".claude/rules/tunestra";
 const SKILLS_DIR = ".claude/skills";
 const COMMANDS_DIR = ".claude/commands";
+const SUBAGENTS_DIR$1 = ".claude/agents";
 const MCP_FILE = ".mcp.json";
 const MCP_SOURCE = "the mcp/ folders of tunestra.yaml and its presets";
 const SETTINGS_FILE = ".claude/settings.json";
@@ -1156,11 +1222,15 @@ function planClaude(context) {
 		const source = describeArtifactSource(projectDir, command.origin, command.artifact.source);
 		return createFileOutput(path, command.artifact.content, source);
 	});
+	const subagentFiles = resolution.subagents.map((subagent) => {
+		return createFileOutput(`${SUBAGENTS_DIR$1}/${subagent.artifact.key}.md`, renderSubagentMd(subagent.artifact), describeArtifactSource(projectDir, subagent.origin, subagent.artifact.source));
+	});
 	const outputs = [
 		claudeFile,
 		...ruleCopies,
 		...skillLinks,
-		...commandFiles
+		...commandFiles,
+		...subagentFiles
 	];
 	if (resolution.mcp.length > 0) {
 		const mcpJson = renderMcpJson(resolution.mcp);
@@ -1179,6 +1249,7 @@ function planClaude(context) {
 			`${RULES_DIR}/`,
 			`${SKILLS_DIR}/`,
 			`${COMMANDS_DIR}/`,
+			`${SUBAGENTS_DIR$1}/`,
 			MCP_FILE
 		],
 		protectedPaths,
@@ -1247,7 +1318,7 @@ function planCommandSkill(projectDir, command) {
 	return [createFileOutput(skillPath, skill, source), createFileOutput(policyPath, OPENAI_YAML, source)];
 }
 //#endregion
-//#region src/agents/codex/config-toml.ts
+//#region src/agents/codex/toml-text.ts
 /** Starts and ends a multi-line literal string, where TOML escapes nothing. */
 const LITERAL_DELIMITER = "'''";
 /**
@@ -1259,6 +1330,18 @@ const LITERAL_DELIMITER = "'''";
 */
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/;
 /**
+* A key with a long text, like `developer_instructions`. The text is a literal string, so
+* that people can read it; a text that a literal string cannot hold is escaped.
+*/
+function renderTomlText(key, text) {
+	const hasDelimiter = text.includes(LITERAL_DELIMITER);
+	const hasControlCharacter = CONTROL_CHARACTER_PATTERN.test(text);
+	if (hasDelimiter || hasControlCharacter) return stringify$1({ [key]: text });
+	return `${key} = ${LITERAL_DELIMITER}\n${text}${LITERAL_DELIMITER}`;
+}
+//#endregion
+//#region src/agents/codex/config-toml.ts
+/**
 * `.codex/config.toml`: the rules as `developer_instructions`, which Codex adds to every
 * 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.
@@ -1266,7 +1349,7 @@ const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/;
 function renderConfigToml(config) {
 	const parts = [GENERATED_HASH_NOTICE];
 	if (typeof config.instructions === "string") {
-		const line = renderInstructions$1(config.instructions);
+		const line = renderTomlText("developer_instructions", config.instructions);
 		parts.push(line);
 	}
 	const tables = {};
@@ -1286,12 +1369,6 @@ function renderConfigToml(config) {
 	}
 	return `${parts.join("\n\n")}\n`;
 }
-function renderInstructions$1(text) {
-	const hasDelimiter = text.includes(LITERAL_DELIMITER);
-	const hasControlCharacter = CONTROL_CHARACTER_PATTERN.test(text);
-	if (hasDelimiter || hasControlCharacter) return stringify$1({ developer_instructions: text });
-	return `developer_instructions = ${LITERAL_DELIMITER}\n${text}${LITERAL_DELIMITER}`;
-}
 /** Codex picks the transport by `command` or `url` and has no `type`. */
 function convertMcpConfig(config) {
 	const { type: _type, headers, ...server } = config;
@@ -1366,18 +1443,48 @@ function renderExecRule(rule) {
 	].join("\n");
 }
 //#endregion
+//#region src/agents/codex/subagent-toml.ts
+/**
+* Codex has no read-only mode for a subagent: it can turn off the shell, but the subagent
+* still edits files with patches. So the instructions ask it not to.
+*/
+const READ_ONLY_INSTRUCTION = "Do not create, edit or delete files.";
+/**
+* `.codex/agents/<name>.toml`. Codex gives a subagent the sandbox, the permissions and the
+* MCP servers of the main session, so the file has only the model and the instructions.
+*/
+function renderSubagentToml(subagent) {
+	const { key, description, model, effort, readOnly, body } = subagent;
+	const fields = {
+		name: key,
+		description
+	};
+	if (typeof model.codex === "string") fields.model = model.codex;
+	if (typeof effort === "string") fields.model_reasoning_effort = effort;
+	const instructions = readOnly ? `${READ_ONLY_INSTRUCTION}\n\n${body}` : body;
+	const parts = [
+		GENERATED_HASH_NOTICE,
+		stringify$1(fields).trimEnd(),
+		renderTomlText("developer_instructions", instructions)
+	];
+	if (readOnly) parts.push(stringify$1({ features: { shell_tool: false } }).trimEnd());
+	return `${parts.join("\n\n")}\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 SUBAGENTS_DIR = ".codex/agents";
 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/ 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 and env go to the same file. Commands become skills, and
-* permission rules for shell commands become `.codex/rules/tunestra.rules`.
+* permission rules for shell commands become `.codex/rules/tunestra.rules`. Subagents go
+* to `.codex/agents`.
 */
 const codexAdapter = {
 	agent: Agent.Codex,
@@ -1394,13 +1501,24 @@ function planCodex(context) {
 		return false;
 	}).flatMap((command) => planCommandSkill(projectDir, command));
 	outputs.push(...commandSkills);
-	const configFile = planConfigFile(ruleFiles, resolution.mcp.filter((server) => {
+	const servers = resolution.mcp.filter((server) => {
 		if (server.artifact.config.type === "sse") {
 			notes.push(`Codex skips the MCP server "${server.artifact.key}": Codex does not support SSE.`);
 			return false;
 		}
 		return true;
-	}), resolution.env);
+	});
+	const subagentFiles = resolution.subagents.map((subagent) => {
+		return createFileOutput(`${SUBAGENTS_DIR}/${subagent.artifact.key}.toml`, renderSubagentToml(subagent.artifact), describeArtifactSource(projectDir, subagent.origin, subagent.artifact.source));
+	});
+	const readOnlySubagents = resolution.subagents.filter((subagent) => subagent.artifact.readOnly).map((subagent) => subagent.artifact.key);
+	const hasReadOnlySubagents = readOnlySubagents.length > 0;
+	outputs.push(...subagentFiles);
+	if (hasReadOnlySubagents) {
+		const names = readOnlySubagents.join(", ");
+		notes.push(`Codex cannot make subagents read-only: ${names}. It turns off their shell and asks them not to edit files.`);
+	}
+	const configFile = planConfigFile(ruleFiles, servers, resolution.env);
 	const execRules = planExecRules(resolution.permissions);
 	const ignoredPaths = [];
 	notes.push(...execRules.notes);
@@ -1412,6 +1530,7 @@ function planCodex(context) {
 		outputs.push(execRules.file);
 		ignoredPaths.push(EXEC_RULES_FILE);
 	}
+	if (subagentFiles.length > 0) ignoredPaths.push(`${SUBAGENTS_DIR}/`);
 	if (ignoredPaths.length > 0) notes.push(TRUST_NOTE);
 	return {
 		outputs,
@@ -1576,6 +1695,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 SUBAGENTS_INTRO = "Hand a task to a subagent 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",
@@ -1678,6 +1798,21 @@ function renderMcpServers(servers) {
 		];
 	})));
 }
+function renderSubagents(subagents) {
+	const table = renderTable([
+		"Subagent",
+		"Level",
+		"When to use"
+	], subagents.map((subagent) => {
+		const origin = describeOrigin(subagent);
+		return [
+			subagent.artifact.key,
+			origin,
+			subagent.artifact.description
+		];
+	}));
+	return renderSection("Subagents", SUBAGENTS_INTRO, table);
+}
 function renderEnv(env) {
 	const table = renderTable(["Variable", "Level"], env.map((variable) => {
 		const origin = describeOrigin(variable);
@@ -1710,7 +1845,7 @@ function renderSection(title, intro, table) {
 //#region src/generate/agents-index.ts
 /**
 * AGENTS.md: an index of the setup, not the rules themselves. It lists the levels, every
-* rule, skill, command and MCP server, where each comes from and where its file is.
+* rule, skill, command, MCP server and subagent, where each comes from and where its file is.
 */
 function renderAgentsIndex(resolution) {
 	const title = `# AI agent context: ${resolution.chain.project.name}`;
@@ -1724,6 +1859,7 @@ function renderAgentsIndex(resolution) {
 	const hasSkills = resolution.skills.length > 0;
 	const hasCommands = resolution.commands.length > 0;
 	const hasMcpServers = resolution.mcp.length > 0;
+	const hasSubagents = resolution.subagents.length > 0;
 	const hasEnv = resolution.env.length > 0;
 	if (hasRules) {
 		const rules = renderRules(resolution.rules);
@@ -1741,6 +1877,10 @@ function renderAgentsIndex(resolution) {
 		const servers = renderMcpServers(resolution.mcp);
 		sections.push(servers);
 	}
+	if (hasSubagents) {
+		const subagents = renderSubagents(resolution.subagents);
+		sections.push(subagents);
+	}
 	if (hasEnv) {
 		const env = renderEnv(resolution.env);
 		sections.push(env);
@@ -1830,6 +1970,7 @@ const ArtifactKind = {
 	Skills: "skills",
 	Commands: "commands",
 	Mcp: "mcp",
+	Subagents: "subagents",
 	Env: "env"
 };
 //#endregion
@@ -2024,6 +2165,7 @@ 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 subagents = inheritArtifacts(chain.levels, ArtifactKind.Subagents, (level) => level.subagents);
 	const env = inheritArtifacts(chain.levels, ArtifactKind.Env, (level) => level.env);
 	const permissions = inheritPermissions(chain.levels);
 	const problems = [
@@ -2031,6 +2173,7 @@ function applyInheritance(chain) {
 		...skills.problems,
 		...commands.problems,
 		...mcp.problems,
+		...subagents.problems,
 		...env.problems,
 		...permissions.problems
 	];
@@ -2041,6 +2184,7 @@ function applyInheritance(chain) {
 		skills: skills.artifacts,
 		commands: commands.artifacts,
 		mcp: mcp.artifacts,
+		subagents: subagents.artifacts,
 		env: env.artifacts,
 		permissions: permissions.artifacts
 	};
@@ -2400,6 +2544,7 @@ function describeResolution(resolution) {
 		describeSection("Skills", resolution.skills, projectDir),
 		describeSection("Commands", resolution.commands, projectDir),
 		describeSection("MCP servers", resolution.mcp, projectDir),
+		describeSection("Subagents", resolution.subagents, projectDir),
 		describeSection("Environment", resolution.env, projectDir),
 		describeSection("Permissions", permissions, projectDir)
 	].filter((section) => section.length > 0).join("\n\n");

package/dist/index.mjs

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

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

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

package/package.json

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