@technomoron/agent-run 0.99.10 → 0.99.12

package/CHANGES

@@ -4,6 +4,16 @@ CHANGES
 Unreleased (2026-04-24)
 -----------------------
 
+Version 0.99.12 (2026-04-27)
+----------------------------
+* Add `--local` for Codex and Claude runs to warn about local AI files instead of failing.
+* Limit generated Claude permission allow entries to configured checks instead of broad blocked command families.
+* Write agent-run's Claude settings to `.claude/agent-run-settings.json` and remove only exact legacy generated `.claude/settings.json` files.
+
+Version 0.99.11 (2026-04-27)
+----------------------------
+* Show the package version in `agent-run --help` and add `agent-run --version`.
+
 Version 0.99.10 (2026-04-27)
 ----------------------------
 * Add `paths.globalMemoryDir` to render context and expose it from default Codex, Claude, AGENTS, and CLAUDE templates.

package/README.md

@@ -118,10 +118,15 @@ generated guard shims on `PATH`. Use `--sandboxed` to request Codex
 `sandbox_workspace_write.network_access=true`.
 
 Claude Code currently has no `--cd` equivalent. `agent-run` keeps Claude's
-process cwd at the project root, passes the generated `.claude/settings.json`
+process cwd at the project root, passes the generated `.claude/agent-run-settings.json`
 with `--settings`, and allows both the project root and private agent directory
 with `--add-dir`.
 
+By default, `agent-run codex` and `agent-run claude` fail when local AI files
+such as `AGENTS.md`, `CLAUDE.md`, `.agents`, `.claude`, or `.codex` are present
+inside the project repository. Use `--local` to warn and continue for a specific
+invocation.
+
 Initialize mapped files for the current repo:
 
 ```sh

package/dist/agent-run.js

@@ -22,6 +22,7 @@ const CONFIG_DIR_ENV = 'AGENT_CONFIG_DIR';
 const VERBOSE_ENV = 'AGENT_RUN_VERBOSE';
 const MANIFEST_FILE_NAME = 'agent-run.jsonc';
 const LOCAL_TEMPLATE_FILE_NAME = 'local.md.njk';
+const PACKAGE_VERSION = '0.99.10';
 const UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
 const agentRunEnvCache = new Map();
 const GENERATED_GITIGNORE_ENTRIES = [
@@ -114,6 +115,9 @@ function parseInvocation(invokedTool, argv) {
         if (isHelpFlag(firstArg)) {
             printHelp('general');
         }
+        if (isVersionFlag(firstArg)) {
+            printVersion();
+        }
         const commandIndex = findCommandArgIndex(inputArgs);
         if (commandIndex === -1) {
             fail(`unknown command: ${firstArg ?? ''} (run with --help for usage)`);
@@ -212,6 +216,7 @@ function parseRunCommand(command, inputArgs) {
     const wrapperArgs = {
         none: false,
         create: false,
+        local: false,
         codexSandboxMode: null,
         codexNetwork: false
     };
@@ -234,6 +239,10 @@ function parseRunCommand(command, inputArgs) {
             wrapperArgs.create = true;
             continue;
         }
+        if (arg === '--local') {
+            wrapperArgs.local = true;
+            continue;
+        }
         if (arg === '--danger') {
             if (command !== 'codex') {
                 fail('--danger is only supported for agent-run codex');
@@ -341,6 +350,13 @@ function parseMigrateConfigCommand(inputArgs) {
 function isHelpFlag(value) {
     return value === '-h' || value === '--help';
 }
+function isVersionFlag(value) {
+    return value === '-V' || value === '--version';
+}
+function printVersion() {
+    process.stdout.write(`agent-run ${agentRunVersion()}\n`);
+    process.exit(0);
+}
 function printHelp(topic) {
     process.stdout.write(renderHelp(topic));
     process.exit(0);
@@ -394,14 +410,17 @@ function renderHelp(topic) {
         case 'general':
         default:
             return [
+                `agent-run ${agentRunVersion()}`,
+                '',
                 'Usage:',
                 '  agent-run <codex|claude|check|init|edit|update> [options]',
                 '  agent-run --init [config-root]',
                 '',
                 'Commands:',
-                '  codex [--none] [--create] [--danger|--sandboxed] [--network] [args...]',
+                '  codex [--none] [--create] [--local] [--danger|--sandboxed] [--network] [args...]',
                 '                                           Run codex with generated private config',
-                '  claude [--none] [--create] [args...]  Run claude with generated private config',
+                '  claude [--none] [--create] [--local] [args...]',
+                '                                           Run claude with generated private config',
                 '  check [--all] [path]                  Validate generated profile output',
                 '  init [path]                           Create profile source files and render output',
                 '  edit [path]                           Open local.md.njk or legacy AGENTS-MODS.md',
@@ -410,11 +429,13 @@ function renderHelp(topic) {
                 '',
                 'Global options:',
                 '  -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',
                 '  --init [DIR]       Copy the packaged starter config root to DIR (default ~/.agent-config)',
                 '',
                 'Codex wrapper options:',
+                '  --local            Warn about local AI files instead of failing',
                 '  --danger           Run Codex with no sandbox: -a never -s danger-full-access (default)',
                 '  --sandboxed        Run Codex with workspace-write sandbox',
                 '  --network          Enable network for --sandboxed via config override',
@@ -422,6 +443,19 @@ function renderHelp(topic) {
             ].join('\n');
     }
 }
+function agentRunVersion() {
+    const packagePath = path.resolve(__dirname, '..', 'package.json');
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        if (typeof pkg.version === 'string' && pkg.version.length > 0) {
+            return pkg.version;
+        }
+    }
+    catch {
+        return PACKAGE_VERSION;
+    }
+    return PACKAGE_VERSION;
+}
 function normalizeCommandName(value) {
     if (!value) {
         return null;
@@ -468,7 +502,10 @@ function runTool(parsed) {
     const excludedDir = profileResult.profile === null ? null : resolveAgentDir(projectRoot);
     const localAiFiles = findLocalAiFiles(projectRoot, excludedDir);
     if (localAiFiles.length > 0) {
-        failForLocalAiFiles(command, projectRoot, localAiFiles);
+        if (!wrapperArgs.local) {
+            failForLocalAiFiles(command, projectRoot, localAiFiles);
+        }
+        warnForLocalAiFiles(command, projectRoot, localAiFiles);
     }
     if (profileResult.profile === null) {
         fail(profileResult.reason);
@@ -485,7 +522,7 @@ function runTool(parsed) {
         runCodex(realBinary, permissionArgs, agentDir, configRoot, args, projectRoot, wrapperArgs);
         return;
     }
-    runClaude(realBinary, permissionArgs, agentDir, configRoot, args, projectRoot);
+    runClaude(realBinary, permissionArgs, agentDir, configRoot, args, projectRoot, wrapperArgs);
 }
 function runInit(parsed) {
     const projectRoot = findProjectRoot(parsed.targetPath);
@@ -982,10 +1019,21 @@ function buildRenderContext(projectRoot, agentDir, configRoot, manifest, env) {
     return {
         ...baseContext,
         paths,
+        permissionsAllow: buildPermissionsAllow(manifest),
         skills: [],
         renderedAgentSections: []
     };
 }
+function buildPermissionsAllow(manifest) {
+    const allow = new Set();
+    for (const check of manifest.checks) {
+        const normalizedCheck = check.trim();
+        if (normalizedCheck) {
+            allow.add(`Bash(${normalizedCheck})`);
+        }
+    }
+    return [...allow];
+}
 function resolveConfigPath(configRoot, relativePath, context) {
     const env = createNunjucksEnv(configRoot);
     const rendered = renderInlineTemplate(env, relativePath, context);
@@ -1091,7 +1139,7 @@ function renderProfile(projectRoot, agentDir, checkOnly = false) {
     files.push({ path: path.join(agentDir, 'CLAUDE.md'), content: claudeContent });
     files.push({ path: path.join(agentDir, '.claude', 'CLAUDE.md'), content: claudeContent });
     files.push({ path: path.join(agentDir, 'config.toml'), content: renderCodexConfig(env, configRoot, context) });
-    files.push({ path: path.join(agentDir, '.claude', 'settings.json'), content: renderClaudeSettings(env, configRoot, context) });
+    files.push({ path: path.join(agentDir, '.claude', 'agent-run-settings.json'), content: renderClaudeSettings(env, configRoot, context) });
     files.push(...renderNativeSkillFiles(context));
     files.push(...renderGuardShims(context));
     return {
@@ -1109,8 +1157,21 @@ function syncAgentProfile(projectRoot, agentDir) {
     for (const file of rendered.files) {
         writeGeneratedFile(file.path, file.content, file.executable ?? false);
     }
+    removeLegacyGeneratedClaudeSettings(rendered.context);
     return rendered;
 }
+function removeLegacyGeneratedClaudeSettings(context) {
+    const legacyPath = path.join(context.agentDir, '.claude', 'settings.json');
+    if (!fs.existsSync(legacyPath)) {
+        return;
+    }
+    const actual = fs.readFileSync(legacyPath, 'utf8').replace(/\r\n/g, '\n');
+    const legacyGeneratedContent = legacyDefaultClaudeSettingsContent(context);
+    if (actual === legacyGeneratedContent) {
+        fs.rmSync(legacyPath);
+        verbose(`removed legacy generated Claude settings ${legacyPath}`);
+    }
+}
 function checkRenderedProfile(projectRoot, agentDir) {
     const findings = [];
     const configRoot = defaultConfigRoot(projectRoot);
@@ -1490,7 +1551,7 @@ function runCodex(realBinary, permissionArgs, agentDir, configRoot, args, projec
             ? ['--config', 'sandbox_workspace_write.network_access=true']
             : []),
         ...args
-    ], shouldUseShell(realBinary), env, codexHomeDir, (code) => postflightProjectCheck(projectRoot, agentDir, code));
+    ], shouldUseShell(realBinary), env, codexHomeDir, (code) => postflightProjectCheck(projectRoot, agentDir, wrapperArgs.local, code));
 }
 function buildCodexRuntimeArgs(wrapperArgs) {
     const mode = wrapperArgs.codexSandboxMode ?? 'danger';
@@ -1499,7 +1560,7 @@ function buildCodexRuntimeArgs(wrapperArgs) {
     }
     return ['-a', 'never', '-s', 'danger-full-access'];
 }
-function runClaude(realBinary, permissionArgs, agentDir, configRoot, args, projectRoot) {
+function runClaude(realBinary, permissionArgs, agentDir, configRoot, args, projectRoot, wrapperArgs) {
     const claudePath = path.join(agentDir, 'CLAUDE.md');
     if (!fs.existsSync(claudePath)) {
         failMissingConfig('claude', agentDir);
@@ -1516,14 +1577,14 @@ function runClaude(realBinary, permissionArgs, agentDir, configRoot, args, proje
     execCommand(realBinary, [
         ...permissionArgs,
         '--settings',
-        path.join(claudeConfigDir, 'settings.json'),
+        path.join(claudeConfigDir, 'agent-run-settings.json'),
         '--add-dir',
         projectRoot,
         '--add-dir',
         agentDir,
         ...globalMemoryArgs(configRoot),
         ...args
-    ], shouldUseShell(realBinary), env, projectRoot, (code) => postflightProjectCheck(projectRoot, agentDir, code));
+    ], shouldUseShell(realBinary), env, projectRoot, (code) => postflightProjectCheck(projectRoot, agentDir, wrapperArgs.local, code));
 }
 function globalMemoryArgs(configRoot) {
     const memoryDir = globalMemoryDir(configRoot);
@@ -1532,16 +1593,15 @@ function globalMemoryArgs(configRoot) {
 function globalMemoryDir(configRoot) {
     return path.join(configRoot, 'notes', 'memory');
 }
-function postflightProjectCheck(projectRoot, agentDir, code) {
+function postflightProjectCheck(projectRoot, agentDir, allowLocal, code) {
     const localAiFiles = findLocalAiFiles(projectRoot, agentDir);
-    if (localAiFiles.length === 0) {
-        return code;
-    }
-    process.stderr.write(`agent-run: postflight found local AI files in project root ${projectRoot}\n`);
-    for (const file of localAiFiles) {
-        process.stderr.write(`agent-run:   ${file}\n`);
+    if (localAiFiles.length > 0) {
+        warnForLocalAiFiles(null, projectRoot, localAiFiles);
+        if (!allowLocal) {
+            return 1;
+        }
     }
-    return 1;
+    return code;
 }
 function failMissingConfig(tool, agentDir) {
     process.stderr.write(`agent-run: no ${tool} config found for this project: ${agentDir}\n`);
@@ -1621,6 +1681,7 @@ function isSamePathOrDescendant(candidatePath, parentPath) {
 function shouldPruneProjectEntry(entry) {
     return (entry.isDirectory() &&
         (entry.name === '.git' ||
+            entry.name === '.claude' ||
             entry.name === 'node_modules' ||
             entry.name === '.pnpm-store' ||
             entry.name === 'dist' ||
@@ -1639,13 +1700,21 @@ function isIgnoredDir(dir) {
     const env = readAgentRunEnv(dir);
     return parseBooleanEnv(env.AGENT_RUN_IGNORE);
 }
+function warnForLocalAiFiles(tool, projectRoot, localAiFiles) {
+    process.stderr.write(`WARNING: local AI files found in project root ${projectRoot}\n`);
+    for (const file of localAiFiles) {
+        process.stderr.write(`WARNING:   ${path.relative(projectRoot, file)}\n`);
+    }
+    if (tool !== null) {
+        process.stderr.write(`WARNING: consider moving these files out of the project, or run \`agent-run ${tool} --none\` to bypass the wrapper.\n`);
+    }
+}
 function failForLocalAiFiles(tool, projectRoot, localAiFiles) {
     process.stderr.write(`agent-run: found local AI files in project root ${projectRoot}\n`);
     for (const file of localAiFiles) {
         process.stderr.write(`agent-run:   ${file}\n`);
     }
-    process.stderr.write(`agent-run: move these files manually out of the project, or run \`${tool}\` directly if you want to use the local files.\n`);
-    process.stderr.write(`agent-run: run \`agent-run ${tool} --none\` to bypass the wrapper for this invocation.\n`);
+    process.stderr.write(`agent-run: move these files manually out of the project, run \`agent-run ${tool} --local\` to warn and continue, or run \`agent-run ${tool} --none\` to bypass the wrapper for this invocation.\n`);
     process.exit(1);
 }
 function findProjectRoot(cwd) {
@@ -2269,15 +2338,26 @@ function defaultCodexConfigTemplate() {
     ].join('\n');
 }
 function defaultClaudeSettingsTemplate() {
-    return [
-        '{',
+    const envBlock = [
         '  "env": {',
         '    "AGENT_DIR": "{{ agentDir }}",',
         '    "AGENT_RUN_PROJECT_ROOT": "{{ projectRoot }}",',
         '    "AGENT_GLOBAL_MEMORY_DIR": "{{ paths.globalMemoryDir }}"',
+        '  }'
+    ].join('\n');
+    return [
+        '{% if permissionsAllow.length %}{',
+        envBlock + ',',
+        '  "permissions": {',
+        '    "allow": [',
+        '      "{{ permissionsAllow | join(\'",\\n      "\') }}"',
+        '    ]',
         '  }',
         '}',
-        ''
+        '{% else %}{',
+        envBlock,
+        '}',
+        '{% endif %}'
     ].join('\n');
 }
 function defaultCodexConfigContent(context) {
@@ -2298,6 +2378,19 @@ function defaultCodexConfigContent(context) {
     ].join('\n');
 }
 function defaultClaudeSettingsContent(context) {
+    const settings = {
+        env: {
+            AGENT_DIR: context.agentDir,
+            AGENT_RUN_PROJECT_ROOT: context.projectRoot,
+            AGENT_GLOBAL_MEMORY_DIR: context.paths.globalMemoryDir
+        }
+    };
+    if (context.permissionsAllow.length > 0) {
+        settings.permissions = { allow: context.permissionsAllow };
+    }
+    return `${JSON.stringify(settings, null, 2)}\n`;
+}
+function legacyDefaultClaudeSettingsContent(context) {
     return `${JSON.stringify({
         env: {
             AGENT_DIR: context.agentDir,

package/examples/basic-config/agent-config/global/tool-templates/claude-settings.json.njk

@@ -1,8 +1,22 @@
-{
+{% if permissionsAllow.length %}{
   "env": {
     "AGENT_DIR": "{{ agentDir }}",
     "AGENT_RUN_PROJECT_ROOT": "{{ projectRoot }}",
     "AGENT_GLOBAL_MEMORY_DIR": "{{ paths.globalMemoryDir }}",
     "STARTER_PROFILE": "{{ profile }}"
+  },
+  "permissions": {
+    "allow": [
+      "{{ permissionsAllow | join('",\n      "') }}"
+    ]
   }
 }
+{% else %}{
+  "env": {
+    "AGENT_DIR": "{{ agentDir }}",
+    "AGENT_RUN_PROJECT_ROOT": "{{ projectRoot }}",
+    "AGENT_GLOBAL_MEMORY_DIR": "{{ paths.globalMemoryDir }}",
+    "STARTER_PROFILE": "{{ profile }}"
+  }
+}
+{% endif %}

package/examples/basic-config/agent-config/starter/basic-project/overrides/claude-settings.json.njk

@@ -1,9 +1,24 @@
-{
+{% if permissionsAllow.length %}{
   "env": {
     "AGENT_DIR": "{{ agentDir }}",
     "AGENT_RUN_PROJECT_ROOT": "{{ projectRoot }}",
     "AGENT_GLOBAL_MEMORY_DIR": "{{ paths.globalMemoryDir }}",
     "STARTER_PROFILE": "{{ profile }}",
     "STARTER_OVERRIDE": "true"
+  },
+  "permissions": {
+    "allow": [
+      "{{ permissionsAllow | join('",\n      "') }}"
+    ]
   }
 }
+{% else %}{
+  "env": {
+    "AGENT_DIR": "{{ agentDir }}",
+    "AGENT_RUN_PROJECT_ROOT": "{{ projectRoot }}",
+    "AGENT_GLOBAL_MEMORY_DIR": "{{ paths.globalMemoryDir }}",
+    "STARTER_PROFILE": "{{ profile }}",
+    "STARTER_OVERRIDE": "true"
+  }
+}
+{% endif %}

package/package.json

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