@technomoron/agent-run 0.99.27 → 0.99.28

package/CHANGES

@@ -1,6 +1,15 @@
 CHANGES
 =======
 
+Version 0.99.28 (2026-08-30)
+----------------------------
+* Add interactive `agent-run setup [org/repo]`, make `agent-run generate` the
+  profile-initialization command, and retain `init` as a deprecated alias.
+* Use `~/.agent-run` as the single default config directory, overridable with
+  `--configdir`, `AGENT_CONFIG_DIR`, or a project-local `.agent-run.env`.
+* Resolve profiles from `package.json.repository` and avoid rewriting unchanged
+  generated files.
+
 Version 0.99.27 (2026-08-11)
 ----------------------------
 * Rename the unattended-run option from `--danger` to `--yolo` for Codex and

package/README.md

@@ -3,8 +3,7 @@
 Small wrapper for AI coding CLIs like Codex and Claude.
 
 It keeps agent files out of normal repos and stores them in a separate
-agent config tree. By default, that tree lives beside owner/repo checkouts
-under the same code root.
+agent config tree. By default, that tree lives at `~/.agent-run`.
 
 ## Model
 
@@ -17,31 +16,29 @@ There are three things:
 Example:
 
 ```text
-~/source/
-  agent-config/
-    agent-run.defaults.jsonc
-    org/
-      my-api/
-        agent-run.jsonc
-        local.md.njk       # optional
-        overrides/         # optional
-        live/
-          CLAUDE.md
-          .claude/
-          bin/
-          memories/
-            codex-home/
-              AGENTS.md
-              config.toml
-              skills/
+~/.agent-run/
+  agent-run.defaults.jsonc
   org/
     my-api/
+      agent-run.jsonc
+      local.md.njk       # optional
+      overrides/         # optional
+      live/
+        CLAUDE.md
+        .claude/
+        bin/
+        memories/
+          codex-home/
+            AGENTS.md
+            config.toml
+            skills/
+~/source/org/my-api/
 ```
 
 If your source repo is `~/source/org/my-api`, `agent-run` maps it to:
 
 ```text
-~/source/agent-config/org/my-api
+~/.agent-run/org/my-api
 ```
 
 The source repo stays clean. The agent files live in the matching path under
@@ -96,13 +93,15 @@ The mapped path is:
 
 1. `AGENT_RUN_PROFILE` in `.agent-run.env`
 2. GitHub `origin` remote
-3. `package.json.name`
-4. the project path as `[parent]/[current]`
+3. `package.json.repository` (string or object `url`)
+4. `package.json.name`
+5. the project path as `[parent]/[current]`
 
 Examples:
 
 - `AGENT_RUN_PROFILE=org/my-api` -> `org/my-api`
 - `AGENT_RUN_PROFILE=unrelated/hello` -> `unrelated/hello`
+- `package.json.repository = "github:org/my-api"` -> `org/my-api`
 - `package.json.name = "@org/my-api"` -> `org/my-api`
 - `package.json.name = "my-api"` -> `my-api`
 - `/work/org/my-api` with none of the above -> `org/my-api`
@@ -124,20 +123,10 @@ AGENT_RUN_PROFILE=org/my-api
 
 Config root:
 
-- default for a project at `[code]/owner/repo`: `[code]/agent-config`
-- override with `--config-root /path/to/agent-configs`
+- default: `~/.agent-run`
+- override with `--configdir=/path/to/agent-configs`
 - override with `AGENT_CONFIG_DIR=/path/to/agent-configs`
-- override with `AGENT_CONFIG_ROOT=/path/to/agent-configs`
-- or set `AGENT_CONFIG_DIR=/path/to/agent-configs` or `AGENT_CONFIG_ROOT=/path/to/agent-configs` in `.agent-run.env`
-
-For commands without a project root, `agent-run` looks for an existing config
-root in these locations:
-
-- Windows: `~/Documents/code/agent-config`, `~/Documents/code/agent-configs`,
-  `~/Desktop/code/agent-config`, `~/Desktop/code/agent-configs`,
-  `C:\code\agent-config`, `C:\code\agent-configs`
-- Unix: `~/code/agent-config`, `~/code/agent-configs`, `~/agent-config`,
-  `~/agent-configs`, `~/.agent-config`, `~/.agent-configs`
+- or set `AGENT_CONFIG_DIR=/path/to/agent-configs` in `.agent-run.env`
 
 ## Commands
 
@@ -186,12 +175,12 @@ to warn and continue for a specific invocation.
 Initialize mapped files for the current repo:
 
 ```sh
-agent-run init
+agent-run generate
 ```
 
 This creates `<config-root>/agent-run.defaults.jsonc` when needed and a minimal
 `agent-run.jsonc` marker for the mapped profile. It does not create empty local
-instruction or override files.
+instruction or override files. `agent-run init` remains as a deprecated alias.
 
 Edit the source file for the current repo:
 
@@ -209,19 +198,18 @@ agent-run update
 ```
 
 `update` requires an existing profile marker or local/legacy instruction file;
-it does not silently scaffold an unconfigured project. Use `agent-run init` or
+it does not silently scaffold an unconfigured project. Use `agent-run generate` or
 the tool command's `--create` option first.
 
 Regenerate every profile under the config root without requiring matching code
 checkouts:
 
 ```sh
-agent-run update --all ~/.agent-config
+agent-run update --all ~/.agent-run
 ```
 
 If the config root argument is omitted, `update --all` uses the normal configured
-root. Without a project path, that falls back to `$HOME/.agent-config`; for
-project commands, the default is `[code]/agent-config`.
+root. Without an override, the root is `$HOME/.agent-run`.
 
 You can also generate from a tool command and stop before launch:
 
@@ -245,27 +233,28 @@ Per-profile override templates can be placed in:
 - `overrides/codex-config.toml.njk`
 - `overrides/claude-settings.json.njk`
 
-## Starter Config
+## Default Config Tree
 
-A complete starter lives in `examples/basic-config`. It includes a minimal
+A complete default tree lives in `examples/basic-config`. It includes a minimal
 project, `.agent-run.env`, root manifest defaults, global templates and
 snippets, profile-local templates, skill templates, a personal memory skill,
 profile skill overrides, tool config overrides, guardrails, checks, and
 generated runtime paths.
 
-To create the packaged starter agent files in your resolved config root:
+To install the default tree and detected profile in your resolved config root:
 
 ```sh
 agent-run setup
 ```
 
-Or choose a destination:
+Or select a profile non-interactively:
 
 ```sh
-agent-run setup ~/.agent-config
+agent-run setup myorg/myrepo
 ```
 
-The copy skips files that already exist, so local edits are preserved.
+Use `--configdir=DIR` to choose a different destination. The copy skips files
+that already exist, so local edits are preserved.
 
 Try it from a checkout:
 
@@ -298,7 +287,7 @@ agent-run check --all ~/source
 Migrate an existing config tree to the manifest/template layout:
 
 ```sh
-agent-run migrate-config ~/.agent-config
+agent-run migrate-config ~/.agent-run
 ```
 
 This preserves `AGENTS-MODS.md`, creates `local.md.njk` and a sparse

package/dist/cli.js

@@ -25,7 +25,7 @@ function applyGlobalOptions(options) {
 }
 function extractCommand(args) {
     if (args.length === 0) {
-        (0, utils_1.fail)('usage: agent-run <codex|claude|check|init|edit|update> [options] (run with --help for details)');
+        (0, utils_1.fail)('usage: agent-run <codex|claude|check|setup|generate|edit|update> [options] (run with --help for details)');
     }
     if (isHelpFlag(args[0])) {
         printHelp('general');
@@ -50,6 +50,8 @@ function parseCommand(command, args) {
             return parseCheckCommand(args);
         case 'init':
             return parseInitCommand(args);
+        case 'generate':
+            return parseGenerateCommand(args);
         case 'setup':
             return parseSetupCommand(args);
         case 'edit':
@@ -85,18 +87,18 @@ function extractGlobalOptions(argv) {
         else if (arg === '-v' || arg === '--verbose') {
             options.verbose = true;
         }
-        else if (arg === '--config-root') {
+        else if (arg === '--configdir') {
             const nextArg = argv[index + 1];
             if (nextArg === undefined) {
-                (0, utils_1.fail)('missing value for --config-root');
+                (0, utils_1.fail)('missing value for --configdir');
             }
             options.configRootOverride = path.resolve(nextArg);
             index += 1;
         }
-        else if (arg.startsWith('--config-root=')) {
-            const rootValue = arg.slice('--config-root='.length);
+        else if (arg.startsWith('--configdir=')) {
+            const rootValue = arg.slice('--configdir='.length);
             if (!rootValue) {
-                (0, utils_1.fail)('missing value for --config-root');
+                (0, utils_1.fail)('missing value for --configdir');
             }
             options.configRootOverride = path.resolve(rootValue);
         }
@@ -196,8 +198,24 @@ function parseCheckCommand(inputArgs) {
 function parseInitCommand(inputArgs) {
     return { command: 'init', targetPath: parseSinglePath(inputArgs, 'init') };
 }
+function parseGenerateCommand(inputArgs) {
+    return { command: 'generate', targetPath: parseSinglePath(inputArgs, 'generate') };
+}
 function parseSetupCommand(inputArgs) {
-    return { command: 'setup', targetPath: parseSinglePath(inputArgs, 'setup', (0, project_1.defaultConfigRoot)()) };
+    let profile = null;
+    for (const arg of inputArgs) {
+        if (isHelpFlag(arg)) {
+            printHelp('setup');
+        }
+        if (arg.startsWith('--')) {
+            (0, utils_1.fail)(`unknown setup option: ${arg}`);
+        }
+        if (profile !== null) {
+            (0, utils_1.fail)('setup accepts at most one profile argument');
+        }
+        profile = arg;
+    }
+    return { command: 'setup', profile };
 }
 function parseEditCommand(inputArgs) {
     return { command: 'edit', targetPath: parseSinglePath(inputArgs, 'edit') };
@@ -274,8 +292,9 @@ function renderHelp(topic) {
             '  --all       Check every repo under path',
             ''
         ],
-        init: ['Usage:', '  agent-run init [path]', '', 'Create a minimal mapped profile marker and render generated files.', ''],
-        setup: ['Usage:', '  agent-run setup [config-root]', '', 'Create starter agent configuration files in the config root.', ''],
+        init: ['Usage:', '  agent-run init [path]', '', 'Deprecated alias for `agent-run generate [path]`.', ''],
+        generate: ['Usage:', '  agent-run generate [path]', '', 'Create a minimal mapped profile marker and render generated files.', ''],
+        setup: ['Usage:', '  agent-run setup [org/repo]', '', 'Install the default config tree and selected profile.', ''],
         edit: ['Usage:', '  agent-run edit [path]', '', 'Create or open the editable local profile template.', ''],
         update: [
             'Usage:',
@@ -300,16 +319,16 @@ function renderHelp(topic) {
         `agent-run ${agentRunVersion()}`,
         '',
         'Usage:',
-        '  agent-run <codex|claude|check|setup|init|edit|update> [options]',
+        '  agent-run <codex|claude|check|setup|generate|edit|update> [options]',
         '',
         'Commands:',
         '  codex [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [--network] [args...]',
         '                                           Run codex with generated private config',
         '  claude [--none] [--create] [--local] [--show] [--generate] [--yolo] [args...]',
         '                                           Run claude with generated private config',
-        '  setup [config-root]                    Create starter files in the agent-config root',
+        '  setup [org/repo]                      Install the default tree and selected profile',
         '  check [--all] [path]                  Validate generated profile output',
-        '  init [path]                           Create a sparse profile marker and render output',
+        '  generate [path]                       Create a sparse profile marker and render output',
         '  edit [path]                           Create or open local.md.njk',
         '  update [--all] [path]                 Regenerate existing profile output',
         '  migrate-config [config-root]           Convert existing config tree layout',
@@ -318,7 +337,7 @@ function renderHelp(topic) {
         '  -h, --help         Show this help text',
         '  -V, --version      Show the agent-run version',
         '  -v, --verbose      Print path resolution and wrapper actions',
-        '  --config-root DIR  Override the agent-config root',
+        '  --configdir=DIR    Override the config directory',
         '',
         'Run wrapper options:',
         '  --local            Warn about local AI files instead of failing',
@@ -351,7 +370,7 @@ function normalizeCommandName(value) {
     if (base === 'agent-run') {
         return null;
     }
-    return ['codex', 'claude', 'check', 'setup', 'init', 'edit', 'update', 'migrate-config'].includes(base)
+    return ['codex', 'claude', 'check', 'setup', 'generate', 'init', 'edit', 'update', 'migrate-config'].includes(base)
         ? base
         : null;
 }

package/dist/commands.js

@@ -22,7 +22,10 @@ function dispatch(command) {
             runCheck(command);
             return;
         case 'init':
-            runInit(command);
+            runGenerate(command);
+            return;
+        case 'generate':
+            runGenerate(command);
             return;
         case 'setup':
             runSetup(command);
@@ -65,7 +68,7 @@ function runTool(parsed) {
         return;
     }
     if (wrapperArgs.create) {
-        runInit({ command: 'init', targetPath: projectRoot });
+        runGenerate({ command: 'generate', targetPath: projectRoot });
     }
     const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
     const agentDir = path.join(configRoot, profile);
@@ -110,7 +113,7 @@ function requireProfile(tool, agentDir) {
     }
     const label = tool ?? 'agent';
     process.stderr.write(`agent-run: no ${label} profile found for this project: ${agentDir}\n`);
-    process.stderr.write('agent-run: run `agent-run init` or use the tool with `--create`.\n');
+    process.stderr.write('agent-run: run `agent-run generate` or use the tool with `--create`.\n');
     process.exit(1);
 }
 function checkLocalAiFiles(command, projectRoot, agentDir, context, allowLocal) {
@@ -146,8 +149,11 @@ function ensureToolEnabled(context, command) {
         (0, utils_1.fail)(`${command} is disabled for agent-run profile ${context.profile}`);
     }
 }
-function runInit(parsed) {
-    const projectRoot = activeProject(parsed.targetPath, 'init');
+function runGenerate(parsed) {
+    if (parsed.command === 'init') {
+        process.stderr.write('agent-run: `init` is deprecated; use `agent-run generate [path]` instead.\n');
+    }
+    const projectRoot = activeProject(parsed.targetPath, 'generate');
     if (projectRoot === null) {
         return;
     }
@@ -155,12 +161,72 @@ function runInit(parsed) {
     printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
 }
 function runSetup(parsed) {
+    const projectRoot = (0, project_1.findProjectRoot)(process.cwd());
+    const detectedProfile = (0, project_1.resolveProfile)(projectRoot);
+    const profile = parsed.profile === null ? confirmProfile(detectedProfile) : requireValidProfile(parsed.profile);
+    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
     const sourcePath = (0, config_tree_1.starterConfigRootPath)();
     if (!fs.existsSync(sourcePath)) {
         (0, utils_1.fail)(`starter config skeleton not found: ${sourcePath}`);
     }
-    (0, config_tree_1.copySkeletonTree)(sourcePath, path.resolve(parsed.targetPath));
-    process.stdout.write(`OK created starter agent config in ${path.resolve(parsed.targetPath)}\n`);
+    (0, config_tree_1.copySkeletonTree)(sourcePath, configRoot, new Set(['starter']));
+    const agentDir = path.join(configRoot, profile);
+    (0, config_tree_1.copySkeletonTree)(path.join(sourcePath, 'starter', 'basic-project'), agentDir);
+    if (profile !== detectedProfile) {
+        writeProjectProfileMapping(projectRoot, profile);
+    }
+    printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir, { configRoot, profile }));
+    process.stdout.write(`OK installed default config tree at ${configRoot}\n`);
+}
+function requireValidProfile(value) {
+    const parsed = (0, project_1.parseProfile)(value, 'setup profile');
+    if (parsed.profile === null) {
+        (0, utils_1.fail)(parsed.reason);
+    }
+    return parsed.profile;
+}
+function confirmProfile(detectedProfile) {
+    process.stdout.write(`Detected profile: ${detectedProfile}\n`);
+    const confirmation = promptLine('Is this correct? [Y/n] ').trim().toLowerCase();
+    if (confirmation === '' || confirmation === 'y' || confirmation === 'yes') {
+        return detectedProfile;
+    }
+    return requireValidProfile(promptLine('Profile (org/repo): '));
+}
+function promptLine(prompt) {
+    if (!process.stdin.isTTY) {
+        (0, utils_1.fail)('setup requires a profile argument when input is not interactive');
+    }
+    process.stdout.write(prompt);
+    const bytes = [];
+    const buffer = Buffer.alloc(1);
+    while (fs.readSync(process.stdin.fd, buffer, 0, 1, null) === 1) {
+        if (buffer[0] === 10) {
+            break;
+        }
+        if (buffer[0] !== 13) {
+            bytes.push(buffer[0] ?? 0);
+        }
+    }
+    return Buffer.from(bytes).toString('utf8');
+}
+function writeProjectProfileMapping(projectRoot, profile) {
+    const envPath = path.join(projectRoot, constants_1.ENV_FILE_NAME);
+    const existing = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf8').replace(/\r\n/g, '\n') : '';
+    const lines = existing.length > 0 ? existing.replace(/\n+$/, '').split('\n') : [];
+    const profileLine = `AGENT_RUN_PROFILE=${profile}`;
+    const index = lines.findIndex((line) => /^\s*AGENT_RUN_PROFILE\s*=/.test(line));
+    if (index >= 0) {
+        lines[index] = profileLine;
+    }
+    else {
+        lines.push(profileLine);
+    }
+    const content = `${lines.join('\n')}\n`;
+    if (content !== existing) {
+        fs.writeFileSync(envPath, content, 'utf8');
+        (0, utils_1.verbose)(`write ${envPath}`);
+    }
 }
 function runEdit(parsed) {
     const projectRoot = activeProject(parsed.targetPath, 'edit');

package/dist/config-tree.js

@@ -153,14 +153,17 @@ function migrateLooseFiles(agentDir, pattern, targetDirName) {
 function starterConfigRootPath() {
     return path.resolve(__dirname, '..', 'examples', 'basic-config', 'agent-config');
 }
-function copySkeletonTree(sourceDir, targetDir) {
+function copySkeletonTree(sourceDir, targetDir, excludedNames = new Set()) {
     fs.mkdirSync(targetDir, { recursive: true });
     const entries = fs.readdirSync(sourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
+        if (excludedNames.has(entry.name)) {
+            continue;
+        }
         const sourcePath = path.join(sourceDir, entry.name);
         const targetPath = path.join(targetDir, entry.name === 'gitignore' ? '.gitignore' : entry.name);
         if (entry.isDirectory()) {
-            copySkeletonTree(sourcePath, targetPath);
+            copySkeletonTree(sourcePath, targetPath, excludedNames);
         }
         else if (entry.isFile() && !fs.existsSync(targetPath)) {
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });

package/dist/constants.js

@@ -11,7 +11,7 @@ exports.LIVE_DIR_NAME = 'live';
 exports.CONFIG_ROOT_OVERRIDE_ENV = 'AGENT_RUN_CONFIG_ROOT_OVERRIDE';
 exports.CONFIG_DIR_ENV = 'AGENT_CONFIG_DIR';
 exports.VERBOSE_ENV = 'AGENT_RUN_VERBOSE';
-exports.PACKAGE_VERSION = '0.99.25';
+exports.PACKAGE_VERSION = '0.99.28';
 exports.UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
 exports.LOCAL_AI_FILE_NAMES = new Set([
     'AGENTS.md',

package/dist/project.js

@@ -164,6 +164,11 @@ function profileFromPackage(projectRoot) {
     if (fs.existsSync(packagePath)) {
         try {
             const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+            const repositoryProfile = parsePackageRepositoryProfile(pkg.repository);
+            if (repositoryProfile !== null) {
+                (0, utils_1.verbose)(`using package.json repository profile=${repositoryProfile}`);
+                return parseProfile(repositoryProfile, `${packagePath} repository`);
+            }
             if (typeof pkg.name === 'string' && pkg.name.length > 0) {
                 (0, utils_1.verbose)(`using package.json name=${pkg.name}`);
                 return parseProfile(pkg.name.startsWith('@') ? pkg.name.slice(1) : pkg.name, `${packagePath} name`);
@@ -183,6 +188,28 @@ function profileFromPackage(projectRoot) {
     }
     return { profile: null, reason: `cannot resolve agent profile from project path: ${projectRoot}` };
 }
+function parsePackageRepositoryProfile(repository) {
+    let repositoryPath = null;
+    if (typeof repository === 'string') {
+        repositoryPath = repository;
+    }
+    else if (repository !== null && typeof repository === 'object' && 'url' in repository) {
+        const url = repository.url;
+        if (typeof url === 'string') {
+            repositoryPath = url;
+        }
+    }
+    if (repositoryPath === null) {
+        return null;
+    }
+    const value = repositoryPath.trim();
+    const githubProfile = parseGitHubRemoteProfile(value.replace(/^git\+/, ''));
+    if (githubProfile !== null) {
+        return githubProfile;
+    }
+    const shorthand = /^(?:github:)?([^/:\s]+)\/([^/\s]+?)(?:\.git)?$/.exec(value);
+    return shorthand?.[1] && shorthand[2] ? `${shorthand[1]}/${shorthand[2]}` : null;
+}
 function resolveGitHubProfile(projectRoot) {
     const result = childProcess.spawnSync('git', ['-C', projectRoot, 'config', '--get', 'remote.origin.url'], {
         encoding: 'utf8',
@@ -271,17 +298,11 @@ function defaultConfigRoot(projectRoot, options = {}) {
     if (explicit !== null) {
         return explicit;
     }
-    if (projectRoot) {
-        const projectConfigRoot = defaultCodeConfigRoot(projectRoot);
-        if (options.preferProjectRoot || fs.existsSync(projectConfigRoot)) {
-            return projectConfigRoot;
-        }
-        return findExistingConfigRoot(defaultConfigRootSearchCandidates()) ?? projectConfigRoot;
-    }
-    return findExistingConfigRoot(defaultConfigRootSearchCandidates()) ?? path.join(os.homedir(), '.agent-config');
+    void options;
+    return path.join(os.homedir(), '.agent-run');
 }
 function explicitConfigRoot(projectRoot) {
-    for (const value of [process.env[constants_1.CONFIG_ROOT_OVERRIDE_ENV], process.env[constants_1.CONFIG_DIR_ENV], process.env.AGENT_CONFIG_ROOT]) {
+    for (const value of [process.env[constants_1.CONFIG_ROOT_OVERRIDE_ENV], process.env[constants_1.CONFIG_DIR_ENV]]) {
         if (value) {
             return path.resolve(value);
         }
@@ -290,21 +311,9 @@ function explicitConfigRoot(projectRoot) {
         return null;
     }
     const env = readAgentRunEnv(projectRoot);
-    const localValue = env[constants_1.CONFIG_DIR_ENV]?.trim() || env.AGENT_CONFIG_ROOT?.trim();
+    const localValue = env[constants_1.CONFIG_DIR_ENV]?.trim();
     return localValue ? path.resolve(projectRoot, localValue) : null;
 }
-function defaultCodeConfigRoot(projectRoot) {
-    const resolvedProjectRoot = path.resolve(projectRoot);
-    const ownerDir = path.dirname(resolvedProjectRoot);
-    const codeRoot = path.dirname(ownerDir);
-    if (ownerDir === resolvedProjectRoot || codeRoot === ownerDir) {
-        return path.join(os.homedir(), '.agent-config');
-    }
-    return path.join(codeRoot, 'agent-config');
-}
-function findExistingConfigRoot(candidates) {
-    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
-}
 function defaultConfigRootSearchCandidates(_projectRoot, options = {}) {
     const platform = options.platform ?? process.platform;
     const pathApi = platform === 'win32' ? path.win32 : path.posix;

package/dist/renderer.js

@@ -101,11 +101,18 @@ function syncAgentProfile(projectRoot, agentDir, options) {
 }
 function writeGeneratedFile(filePath, content, executable) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content, 'utf8');
+    const unchanged = fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === content;
+    if (!unchanged) {
+        fs.writeFileSync(filePath, content, 'utf8');
+        (0, utils_1.verbose)(`write ${filePath}`);
+    }
     if (executable && !constants_1.IS_WINDOWS) {
-        fs.chmodSync(filePath, 0o755);
+        const currentMode = fs.statSync(filePath).mode & 0o777;
+        if (currentMode !== 0o755) {
+            fs.chmodSync(filePath, 0o755);
+            (0, utils_1.verbose)(`chmod 755 ${filePath}`);
+        }
     }
-    (0, utils_1.verbose)(`write ${filePath}`);
 }
 function removeStaleGeneratedEntries(rendered) {
     const expectedFiles = new Set(rendered.files.map((file) => path.resolve(file.path)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technomoron/agent-run",
-  "version": "0.99.27",
+  "version": "0.99.28",
   "packageManager": "pnpm@10.28.1",
   "bin": {
     "agent-run": "dist/agent-run.js"