@technomoron/agent-run 0.99.25 → 0.99.27

package/CHANGES

@@ -1,6 +1,24 @@
 CHANGES
 =======
 
+Version 0.99.27 (2026-08-11)
+----------------------------
+* Rename the unattended-run option from `--danger` to `--yolo` for Codex and
+  Claude.
+* Add `agent-run setup [config-root]` to create the packaged starter agent
+  configuration files without overwriting local edits.
+* Resolve plain directories without Git metadata or a package name as
+  `[parent]/[current]` profiles.
+
+Version 0.99.26 (2026-07-31)
+----------------------------
+* Add `--danger` support for Claude so unattended runs pass
+  `--dangerously-skip-permissions`.
+* Remove Claude's generated `.claude/settings.local.json` after guarded runs,
+  while preserving project-local settings when `--local` is used.
+* Keep nested command-guard tests independent of an outer agent-run session's
+  executable search path.
+
 Version 0.99.25 (2026-07-11)
 ----------------------------
 * Add config-root `agent-run.defaults.jsonc` inheritance so project manifests

package/README.md

@@ -97,6 +97,7 @@ 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]`
 
 Examples:
 
@@ -104,11 +105,13 @@ Examples:
 - `AGENT_RUN_PROFILE=unrelated/hello` -> `unrelated/hello`
 - `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`
 
 `AGENT_RUN_PROFILE` is relative to the config root. It is not a filesystem
 path, so values like `/tmp/foo`, `C:/tmp/foo`, or `../foo` are rejected.
 
-If neither exists, `agent-run` fails instead of guessing.
+The path fallback lets plain directories work without a Git repository or a
+`package.json`. The explicit profile sources above always take precedence.
 
 ## Overrides
 
@@ -154,9 +157,8 @@ Codex defaults to `-a on-request -s workspace-write`. `agent-run` sets
 `CODEX_HOME` under the private agent directory, where Codex discovers the
 generated `AGENTS.md`, `config.toml`, and skills natively. It starts Codex from
 that private directory, passes the project root with `-C`, and keeps generated
-guard shims on `PATH`. Use `--danger` explicitly for
-`-a never -s danger-full-access`; use `--network` to enable network access in
-the workspace-write sandbox.
+guard shims on `PATH`. Use `--network` to enable network access in the
+workspace-write sandbox.
 When `~/.codex/auth.json` exists, profile-specific Codex homes link their
 `auth.json` to that shared login cache so changing profiles does not require a
 new ChatGPT login.
@@ -165,7 +167,16 @@ Claude Code currently has no `--cd` equivalent. `agent-run` keeps Claude's
 process cwd at the project root, appends the generated `CLAUDE.md` with
 `--append-system-prompt-file`, passes generated settings with `--settings`, and
 loads generated skills from a local plugin with `--plugin-dir`. It does not
-replace the user's normal `CLAUDE_CONFIG_DIR`.
+replace the user's normal `CLAUDE_CONFIG_DIR`. If Claude writes remembered
+permissions to `.claude/settings.local.json`, `agent-run` removes that file
+after the session unless `--local` was used.
+
+`--yolo` runs either tool unattended, with no approval prompts: Codex with
+`-a never -s danger-full-access`, Claude with `--dangerously-skip-permissions`.
+Only use it when the agent may change or delete anything it can reach. Claude
+refuses `--dangerously-skip-permissions` when it runs as root, so run it as a
+normal user. `--sandboxed` and `--network` stay Codex-only because Claude has no
+matching sandbox.
 
 By default, `agent-run codex` and `agent-run claude` fail when local AI files
 such as `AGENTS.md`, `CLAUDE.md`, `CLAUDE.local.md`, `.mcp.json`, `.agents`,
@@ -242,16 +253,16 @@ snippets, profile-local templates, skill templates, a personal memory skill,
 profile skill overrides, tool config overrides, guardrails, checks, and
 generated runtime paths.
 
-To copy the packaged starter config root into your default config location:
+To create the packaged starter agent files in your resolved config root:
 
 ```sh
-agent-run --init
+agent-run setup
 ```
 
 Or choose a destination:
 
 ```sh
-agent-run --init ~/.agent-config
+agent-run setup ~/.agent-config
 ```
 
 The copy skips files that already exist, so local edits are preserved.

package/dist/cli.js

@@ -10,15 +10,6 @@ function parseInvocation(invokedTool, argv) {
     let command = normalizeCommandName(invokedTool);
     const options = extractGlobalOptions(argv);
     applyGlobalOptions(options);
-    if (options.initConfig) {
-        if (options.args.length > 0) {
-            (0, utils_1.fail)('--init cannot be combined with a command');
-        }
-        return {
-            command: 'init-config',
-            targetPath: path.resolve(options.initConfigTargetPath ?? (0, project_1.defaultConfigRoot)())
-        };
-    }
     if (command === null) {
         command = extractCommand(options.args);
     }
@@ -59,6 +50,8 @@ function parseCommand(command, args) {
             return parseCheckCommand(args);
         case 'init':
             return parseInitCommand(args);
+        case 'setup':
+            return parseSetupCommand(args);
         case 'edit':
             return parseEditCommand(args);
         case 'update':
@@ -73,8 +66,6 @@ function extractGlobalOptions(argv) {
     const options = {
         args: [],
         configRootOverride: null,
-        initConfig: false,
-        initConfigTargetPath: null,
         verbose: false
     };
     let passthrough = false;
@@ -94,14 +85,6 @@ function extractGlobalOptions(argv) {
         else if (arg === '-v' || arg === '--verbose') {
             options.verbose = true;
         }
-        else if (arg === '--init') {
-            options.initConfig = true;
-            const nextArg = argv[index + 1];
-            if (nextArg !== undefined && !nextArg.startsWith('-')) {
-                options.initConfigTargetPath = nextArg;
-                index += 1;
-            }
-        }
         else if (arg === '--config-root') {
             const nextArg = argv[index + 1];
             if (nextArg === undefined) {
@@ -130,7 +113,7 @@ function parseRunCommand(command, inputArgs) {
         local: false,
         show: false,
         generate: false,
-        codexSandboxMode: null,
+        sandboxMode: null,
         codexNetwork: false
     };
     const args = [];
@@ -148,13 +131,13 @@ function parseRunCommand(command, inputArgs) {
         if (applyCommonRunOption(arg, wrapperArgs)) {
             continue;
         }
-        if (applyCodexRunOption(command, arg, wrapperArgs)) {
+        if (applySandboxRunOption(command, arg, wrapperArgs)) {
             continue;
         }
         args.push(arg);
     }
-    if (wrapperArgs.codexNetwork && wrapperArgs.codexSandboxMode === 'danger') {
-        (0, utils_1.fail)('--network cannot be combined with agent-run codex --danger');
+    if (wrapperArgs.codexNetwork && wrapperArgs.sandboxMode === 'danger') {
+        (0, utils_1.fail)('--network cannot be combined with agent-run codex --yolo');
     }
     return { args, command, wrapperArgs };
 }
@@ -173,22 +156,22 @@ function applyCommonRunOption(arg, options) {
     options[field] = true;
     return true;
 }
-function applyCodexRunOption(command, arg, options) {
-    if (!['--danger', '--sandboxed', '--network'].includes(arg)) {
+function applySandboxRunOption(command, arg, options) {
+    if (!['--yolo', '--sandboxed', '--network'].includes(arg)) {
         return false;
     }
-    if (command !== 'codex') {
+    if (arg !== '--yolo' && command !== 'codex') {
         (0, utils_1.fail)(`${arg} is only supported for agent-run codex`);
     }
     if (arg === '--network') {
         options.codexNetwork = true;
         return true;
     }
-    const mode = arg === '--danger' ? 'danger' : 'sandboxed';
-    if (options.codexSandboxMode !== null && options.codexSandboxMode !== mode) {
-        (0, utils_1.fail)('cannot combine --danger and --sandboxed');
+    const mode = arg === '--yolo' ? 'danger' : 'sandboxed';
+    if (options.sandboxMode !== null && options.sandboxMode !== mode) {
+        (0, utils_1.fail)('cannot combine --yolo and --sandboxed');
     }
-    options.codexSandboxMode = mode;
+    options.sandboxMode = mode;
     return true;
 }
 function parseCheckCommand(inputArgs) {
@@ -213,11 +196,14 @@ function parseCheckCommand(inputArgs) {
 function parseInitCommand(inputArgs) {
     return { command: 'init', targetPath: parseSinglePath(inputArgs, 'init') };
 }
+function parseSetupCommand(inputArgs) {
+    return { command: 'setup', targetPath: parseSinglePath(inputArgs, 'setup', (0, project_1.defaultConfigRoot)()) };
+}
 function parseEditCommand(inputArgs) {
     return { command: 'edit', targetPath: parseSinglePath(inputArgs, 'edit') };
 }
-function parseSinglePath(inputArgs, command) {
-    let targetPath = process.cwd();
+function parseSinglePath(inputArgs, command, defaultPath = process.cwd()) {
+    let targetPath = defaultPath;
     for (const arg of inputArgs) {
         if (isHelpFlag(arg)) {
             printHelp(command);
@@ -289,6 +275,7 @@ function renderHelp(topic) {
             ''
         ],
         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.', ''],
         edit: ['Usage:', '  agent-run edit [path]', '', 'Create or open the editable local profile template.', ''],
         update: [
             'Usage:',
@@ -313,14 +300,14 @@ function renderHelp(topic) {
         `agent-run ${agentRunVersion()}`,
         '',
         'Usage:',
-        '  agent-run <codex|claude|check|init|edit|update> [options]',
-        '  agent-run --init [config-root]',
+        '  agent-run <codex|claude|check|setup|init|edit|update> [options]',
         '',
         'Commands:',
-        '  codex [--none] [--create] [--local] [--show] [--generate] [--danger|--sandboxed] [--network] [args...]',
+        '  codex [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [--network] [args...]',
         '                                           Run codex with generated private config',
-        '  claude [--none] [--create] [--local] [--show] [--generate] [args...]',
+        '  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',
         '  check [--all] [path]                  Validate generated profile output',
         '  init [path]                           Create a sparse profile marker and render output',
         '  edit [path]                           Create or open local.md.njk',
@@ -332,15 +319,16 @@ function renderHelp(topic) {
         '  -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)',
         '',
         'Run wrapper options:',
         '  --local            Warn about local AI files instead of failing',
         '  --show             Show read/include and generated files without running the tool',
         '  --generate         Generate files without running the tool',
+        '  --yolo             Run unattended without approval prompts:',
+        '                     Codex with -a never -s danger-full-access,',
+        '                     Claude with --dangerously-skip-permissions',
         '',
         'Codex wrapper options:',
-        '  --danger           Run Codex with no sandbox: -a never -s danger-full-access',
         '  --sandboxed        Run Codex with workspace-write sandbox (default)',
         '  --network          Enable network for the workspace-write sandbox',
         ''
@@ -363,7 +351,7 @@ function normalizeCommandName(value) {
     if (base === 'agent-run') {
         return null;
     }
-    return ['codex', 'claude', 'check', 'init', 'edit', 'update', 'migrate-config'].includes(base)
+    return ['codex', 'claude', 'check', 'setup', 'init', 'edit', 'update', 'migrate-config'].includes(base)
         ? base
         : null;
 }

package/dist/commands.js

@@ -24,8 +24,8 @@ function dispatch(command) {
         case 'init':
             runInit(command);
             return;
-        case 'init-config':
-            runInitConfig(command);
+        case 'setup':
+            runSetup(command);
             return;
         case 'edit':
             runEdit(command);
@@ -47,7 +47,8 @@ function runTool(parsed) {
     validateRunModes(parsed, projectRoot);
     if (wrapperArgs.none || (0, project_1.isIgnoredDir)(projectRoot)) {
         (0, utils_1.verbose)(`wrapper bypassed for ${command}${wrapperArgs.none ? ' via --none' : ' because project is ignored'}`);
-        (0, process_1.execTool)((0, process_1.findRealBinary)(command), [...(0, tools_1.getPermissionArgs)(command), ...args]);
+        const runtimeArgs = wrapperArgs.sandboxMode === 'danger' ? (0, tools_1.getDangerArgs)(command) : (0, tools_1.getPermissionArgs)(command);
+        (0, process_1.execTool)((0, process_1.findRealBinary)(command), [...runtimeArgs, ...args]);
         return;
     }
     const profileResult = (0, project_1.resolveProfileResult)(projectRoot);
@@ -153,13 +154,13 @@ function runInit(parsed) {
     const agentDir = initializeProfileSource(projectRoot, true);
     printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
 }
-function runInitConfig(parsed) {
+function runSetup(parsed) {
     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 copied starter config to ${path.resolve(parsed.targetPath)}\n`);
+    process.stdout.write(`OK created starter agent config in ${path.resolve(parsed.targetPath)}\n`);
 }
 function runEdit(parsed) {
     const projectRoot = activeProject(parsed.targetPath, 'edit');

package/dist/project.js

@@ -173,10 +173,15 @@ function profileFromPackage(projectRoot) {
             return { profile: null, reason: `cannot parse package.json: ${packagePath}` };
         }
     }
-    return {
-        profile: null,
-        reason: `cannot resolve agent profile for ${projectRoot}; add ${constants_1.ENV_FILE_NAME} with AGENT_RUN_PROFILE=<org/project>, add a GitHub origin remote, or set package.json.name`
-    };
+    const current = path.basename(projectRoot);
+    const parentDir = path.dirname(projectRoot);
+    const parent = path.basename(parentDir);
+    if (current && parent && parentDir !== projectRoot) {
+        const inferredProfile = `${parent}/${current}`;
+        (0, utils_1.verbose)(`using project path profile=${inferredProfile}`);
+        return parseProfile(inferredProfile, 'project parent and directory name');
+    }
+    return { profile: null, reason: `cannot resolve agent profile from project path: ${projectRoot}` };
 }
 function resolveGitHubProfile(projectRoot) {
     const result = childProcess.spawnSync('git', ['-C', projectRoot, 'config', '--get', 'remote.origin.url'], {

package/dist/tools.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCodex = runCodex;
 exports.runClaude = runClaude;
+exports.getDangerArgs = getDangerArgs;
 exports.getPermissionArgs = getPermissionArgs;
 const fs = require("fs");
 const path = require("path");
@@ -25,15 +26,13 @@ function runCodex(realBinary, permissionArgs, context, args, wrapperArgs) {
         AGENT_RUN_REAL_PATH: realPath,
         PATH: `${path.join(liveDir, 'bin')}${path.delimiter}${realPath}`
     };
-    const runtimeArgs = wrapperArgs.codexSandboxMode === 'danger'
-        ? ['-a', 'never', '-s', 'danger-full-access']
-        : ['-a', 'on-request', '-s', 'workspace-write'];
+    const runtimeArgs = wrapperArgs.sandboxMode === 'danger' ? getDangerArgs('codex') : ['-a', 'on-request', '-s', 'workspace-write'];
     (0, process_1.execCommand)(realBinary, [
         ...permissionArgs,
         ...runtimeArgs,
         '-C',
         projectRoot,
-        ...(wrapperArgs.codexSandboxMode !== 'danger' && wrapperArgs.codexNetwork
+        ...(wrapperArgs.sandboxMode !== 'danger' && wrapperArgs.codexNetwork
             ? ['--config', 'sandbox_workspace_write.network_access=true']
             : []),
         ...args
@@ -55,8 +54,9 @@ function runClaude(realBinary, permissionArgs, context, args, wrapperArgs) {
         AGENT_RUN_REAL_PATH: realPath,
         PATH: `${path.join(liveDir, 'bin')}${path.delimiter}${realPath}`
     };
+    const runtimeArgs = wrapperArgs.sandboxMode === 'danger' ? getDangerArgs('claude') : permissionArgs;
     (0, process_1.execCommand)(realBinary, [
-        ...permissionArgs,
+        ...runtimeArgs,
         '--append-system-prompt-file',
         claudePath,
         '--settings',
@@ -70,6 +70,9 @@ function postflightProjectCheck(context, allowLocal, code) {
     if (!context.guardrails.forbidRepoAiFiles) {
         return code;
     }
+    if (!allowLocal) {
+        removeClaudeLocalSettings(context.projectRoot);
+    }
     const localAiFiles = (0, project_1.findLocalAiFiles)(context.projectRoot, context.profileDir);
     if (localAiFiles.length === 0) {
         return code;
@@ -77,11 +80,34 @@ function postflightProjectCheck(context, allowLocal, code) {
     (0, project_1.warnForLocalAiFiles)(null, context.projectRoot, localAiFiles);
     return allowLocal ? code : 1;
 }
+function removeClaudeLocalSettings(projectRoot) {
+    const claudeDir = path.join(projectRoot, '.claude');
+    const localSettingsPath = path.join(claudeDir, 'settings.local.json');
+    if (!fs.existsSync(localSettingsPath)) {
+        return;
+    }
+    fs.rmSync(localSettingsPath);
+    try {
+        fs.rmdirSync(claudeDir);
+    }
+    catch (error) {
+        if (!isDirectoryNotEmptyError(error)) {
+            throw error;
+        }
+    }
+    process.stderr.write(`agent-run: removed Claude's project-local settings: ${localSettingsPath}\n`);
+}
+function isDirectoryNotEmptyError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOTEMPTY';
+}
 function failMissingConfig(tool, agentDir) {
     process.stderr.write(`agent-run: no ${tool} config found for this project: ${agentDir}\n`);
     process.stderr.write(`agent-run: run \`agent-run ${tool} --none\` to bypass agent setup, or \`agent-run ${tool} --create\` to create profile files.\n`);
     process.exit(1);
 }
+function getDangerArgs(tool) {
+    return tool === 'codex' ? ['-a', 'never', '-s', 'danger-full-access'] : ['--dangerously-skip-permissions'];
+}
 function getPermissionArgs(tool) {
     if (process.env.AGENT_WRAPPER_FORCE_PERMISSIVE !== '1') {
         return [];

package/package.json

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