@technomoron/agent-run 0.99.28 → 0.99.30

package/dist/agents/grok.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grokAdapter = void 0;
+const os = require("os");
+const path = require("path");
+const render_mcp_1 = require("../config/render-mcp");
+const render_settings_1 = require("../config/render-settings");
+const render_skills_1 = require("../config/render-skills");
+const defaults_1 = require("../defaults");
+const environment_1 = require("../runtime/environment");
+const shared_state_1 = require("../runtime/shared-state");
+const shared_1 = require("./shared");
+function layout(context) {
+    return {
+        dir: context.paths.grokRuntimeDir,
+        instructionFile: path.join(context.paths.grokRuntimeDir, 'AGENTS.md'),
+        configFiles: [path.join(context.paths.grokRuntimeDir, 'config.toml')],
+        skillsDir: context.paths.grokSkillsDir,
+        requiredDirs: [context.paths.grokRuntimeDir, context.paths.grokSkillsDir]
+    };
+}
+function generate(generation) {
+    const agentLayout = layout(generation.context);
+    const baseConfig = (0, render_settings_1.renderProfileConfig)(generation.env, generation.configRoot, generation.context, 'grok-config.toml.njk', 'global/tool-templates/grok-config.toml.njk', () => (0, defaults_1.defaultGrokConfigContent)(), 'Grok config.toml', generation.trace);
+    const mcp = (0, render_mcp_1.renderGrokMcp)(generation.context);
+    const files = [
+        { path: agentLayout.instructionFile, content: generation.agentsMd },
+        { path: agentLayout.configFiles[0] ?? '', content: `${baseConfig.trimEnd()}${mcp ? `\n\n${mcp}` : '\n'}` },
+        ...(0, render_skills_1.renderSkillFiles)(generation.context, agentLayout.skillsDir)
+    ];
+    return { ...agentLayout, id: 'grok', projectDir: generation.context.projectRoot, files, context: generation.context };
+}
+exports.grokAdapter = {
+    id: 'grok',
+    displayName: 'Grok',
+    capabilities: {
+        instructions: true,
+        skills: true,
+        mcp: true,
+        hooks: true,
+        subagents: true,
+        headless: true
+    },
+    wrapperOptions: { sandboxed: true, network: false },
+    layout,
+    generate,
+    prepare(runtime) {
+        for (const name of ['auth.json', 'mcp_credentials.json']) {
+            (0, shared_state_1.linkSharedEntry)(path.join(os.homedir(), '.grok', name), path.join(runtime.dir, name), `Grok ${name}`);
+        }
+    },
+    spawn(runtime, options) {
+        (0, shared_1.assertRuntimeFile)('grok', runtime.instructionFile, runtime.context.profileDir);
+        const modeArgs = options.wrapperArgs.sandboxMode === 'danger'
+            ? ['--always-approve']
+            : options.wrapperArgs.sandboxMode === 'sandboxed'
+                ? ['--sandbox', 'workspace']
+                : [];
+        return {
+            command: options.binary,
+            args: [...modeArgs, ...options.passthroughArgs],
+            cwd: runtime.projectDir,
+            env: { ...(0, environment_1.buildAgentEnvironment)(runtime.context), GROK_HOME: runtime.dir },
+            onExit: (0, shared_1.withPostflight)(runtime, options.wrapperArgs)
+        };
+    },
+    bypassArgs(wrapperArgs) {
+        if (wrapperArgs.sandboxMode === 'danger') {
+            return ['--always-approve'];
+        }
+        return wrapperArgs.sandboxMode === 'sandboxed' ? ['--sandbox', 'workspace'] : [];
+    }
+};

package/dist/agents/registry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentRegistry = void 0;
+exports.getAgentAdapter = getAgentAdapter;
+exports.listAgentAdapters = listAgentAdapters;
+exports.enabledAgentAdapters = enabledAgentAdapters;
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const gemini_1 = require("./gemini");
+const grok_1 = require("./grok");
+const types_1 = require("./types");
+exports.agentRegistry = {
+    codex: codex_1.codexAdapter,
+    claude: claude_1.claudeAdapter,
+    gemini: gemini_1.geminiAdapter,
+    grok: grok_1.grokAdapter
+};
+function getAgentAdapter(id) {
+    return exports.agentRegistry[id];
+}
+function listAgentAdapters() {
+    return types_1.AGENT_IDS.map((id) => exports.agentRegistry[id]);
+}
+function enabledAgentAdapters(context) {
+    return listAgentAdapters().filter((adapter) => context.tools[adapter.id]);
+}

package/dist/agents/shared.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRuntimeFile = assertRuntimeFile;
+exports.withPostflight = withPostflight;
+const fs = require("fs");
+const postflight_1 = require("../runtime/postflight");
+function assertRuntimeFile(tool, filePath, profileDir) {
+    if (fs.existsSync(filePath)) {
+        return;
+    }
+    process.stderr.write(`agent-run: no ${tool} config found for this project: ${profileDir}\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 withPostflight(runtime, wrapperArgs) {
+    return (code) => (0, postflight_1.postflightProjectCheck)(runtime.context, wrapperArgs.local, code);
+}

package/dist/agents/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_IDS = void 0;
+exports.AGENT_IDS = ['codex', 'claude', 'gemini', 'grok'];

package/dist/checks.js

@@ -8,6 +8,7 @@ exports.hasErrors = hasErrors;
 const fs = require("fs");
 const path = require("path");
 const constants_1 = require("./constants");
+const config_tree_1 = require("./config-tree");
 const manifest_1 = require("./manifest");
 const project_1 = require("./project");
 const renderer_1 = require("./renderer");
@@ -47,6 +48,9 @@ function checkAgentDirectory(projectRoot, agentDir) {
     if (!(0, manifest_1.isProfileConfigured)(agentDir)) {
         return [{ message: `missing manifest or legacy/local source file in ${agentDir}`, severity: 'ERROR' }];
     }
+    for (const legacyPath of (0, config_tree_1.describeLegacyProfileLayout)(agentDir)) {
+        findings.push({ message: `old profile layout needs migration: ${legacyPath}`, severity: 'ERROR' });
+    }
     for (const relativeTemplate of constants_1.REQUIRED_GLOBAL_TEMPLATES) {
         if (!fs.existsSync(path.join(configRoot, relativeTemplate))) {
             findings.push({

package/dist/cli.js

@@ -4,6 +4,8 @@ exports.parseInvocation = parseInvocation;
 const fs = require("fs");
 const path = require("path");
 const constants_1 = require("./constants");
+const registry_1 = require("./agents/registry");
+const types_1 = require("./agents/types");
 const project_1 = require("./project");
 const utils_1 = require("./utils");
 function parseInvocation(invokedTool, argv) {
@@ -25,7 +27,7 @@ function applyGlobalOptions(options) {
 }
 function extractCommand(args) {
     if (args.length === 0) {
-        (0, utils_1.fail)('usage: agent-run <codex|claude|check|setup|generate|edit|update> [options] (run with --help for details)');
+        (0, utils_1.fail)('usage: agent-run <codex|claude|gemini|grok|check|status|setup|generate|edit|update> [options] (run with --help for details)');
     }
     if (isHelpFlag(args[0])) {
         printHelp('general');
@@ -48,6 +50,8 @@ function parseCommand(command, args) {
     switch (command) {
         case 'check':
             return parseCheckCommand(args);
+        case 'status':
+            return parseStatusCommand(args);
         case 'init':
             return parseInitCommand(args);
         case 'generate':
@@ -162,7 +166,11 @@ function applySandboxRunOption(command, arg, options) {
     if (!['--yolo', '--sandboxed', '--network'].includes(arg)) {
         return false;
     }
-    if (arg !== '--yolo' && command !== 'codex') {
+    const adapter = (0, registry_1.getAgentAdapter)(command);
+    if (arg === '--sandboxed' && !adapter.wrapperOptions.sandboxed) {
+        (0, utils_1.fail)(`${arg} is not supported for agent-run ${command}`);
+    }
+    if (arg === '--network' && !adapter.wrapperOptions.network) {
         (0, utils_1.fail)(`${arg} is only supported for agent-run codex`);
     }
     if (arg === '--network') {
@@ -176,6 +184,15 @@ function applySandboxRunOption(command, arg, options) {
     options.sandboxMode = mode;
     return true;
 }
+function parseStatusCommand(inputArgs) {
+    for (const arg of inputArgs) {
+        if (isHelpFlag(arg)) {
+            printHelp('status');
+        }
+        (0, utils_1.fail)(`unknown status option: ${arg}`);
+    }
+    return { command: 'status' };
+}
 function parseCheckCommand(inputArgs) {
     let all = false;
     let targetPath = process.cwd();
@@ -254,16 +271,22 @@ function parseUpdateCommand(inputArgs) {
 }
 function parseMigrateConfigCommand(inputArgs) {
     let configRoot = (0, project_1.defaultConfigRoot)();
+    let yes = false;
     for (const arg of inputArgs) {
         if (isHelpFlag(arg)) {
             printHelp('migrate-config');
         }
-        if (arg.startsWith('--')) {
+        if (arg === '--yes') {
+            yes = true;
+        }
+        else if (arg.startsWith('--')) {
             (0, utils_1.fail)(`unknown migrate-config option: ${arg}`);
         }
-        configRoot = arg;
+        else {
+            configRoot = arg;
+        }
     }
-    return { command: 'migrate-config', configRoot: path.resolve(configRoot) };
+    return { command: 'migrate-config', configRoot: path.resolve(configRoot), yes };
 }
 function isHelpFlag(value) {
     return value === '-h' || value === '--help';
@@ -292,6 +315,7 @@ function renderHelp(topic) {
             '  --all       Check every repo under path',
             ''
         ],
+        status: ['Usage:', '  agent-run status', '', 'Show the native agent capability matrix.', ''],
         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.', ''],
@@ -306,9 +330,12 @@ function renderHelp(topic) {
         ],
         'migrate-config': [
             'Usage:',
-            '  agent-run migrate-config [config-root]',
+            '  agent-run migrate-config [--yes] [config-root]',
             '',
             'Convert an existing agent config tree to the current manifest and global-template layout.',
+            '',
+            'Options:',
+            '  --yes  Confirm tracked Git moves without prompting',
             ''
         ]
     };
@@ -319,19 +346,24 @@ function renderHelp(topic) {
         `agent-run ${agentRunVersion()}`,
         '',
         'Usage:',
-        '  agent-run <codex|claude|check|setup|generate|edit|update> [options]',
+        '  agent-run <codex|claude|gemini|grok|check|status|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',
+        '  gemini [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [args...]',
+        '                                           Run gemini with generated private config',
+        '  grok [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [args...]',
+        '                                           Run grok with generated private config',
         '  setup [org/repo]                      Install the default tree and selected profile',
         '  check [--all] [path]                  Validate generated profile output',
+        '  status                                Show native agent capabilities',
         '  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',
+        '  migrate-config [--yes] [config-root]   Convert existing config tree layout',
         '',
         'Global options:',
         '  -h, --help         Show this help text',
@@ -345,10 +377,11 @@ function renderHelp(topic) {
         '  --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',
+        '                     Claude with --dangerously-skip-permissions,',
+        '                     Gemini with --yolo, Grok with --always-approve',
         '',
-        'Codex wrapper options:',
-        '  --sandboxed        Run Codex with workspace-write sandbox (default)',
+        'Sandbox wrapper options:',
+        '  --sandboxed        Run Codex, Gemini, or Grok in its native workspace sandbox',
         '  --network          Enable network for the workspace-write sandbox',
         ''
     ].join('\n');
@@ -370,7 +403,7 @@ function normalizeCommandName(value) {
     if (base === 'agent-run') {
         return null;
     }
-    return ['codex', 'claude', 'check', 'setup', 'generate', 'init', 'edit', 'update', 'migrate-config'].includes(base)
+    return [...types_1.AGENT_IDS, 'check', 'status', 'setup', 'generate', 'init', 'edit', 'update', 'migrate-config'].includes(base)
         ? base
         : null;
 }

package/dist/commands.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const fs = require("fs");
 const path = require("path");
+const registry_1 = require("./agents/registry");
 const checks_1 = require("./checks");
 const cli_1 = require("./cli");
 const config_tree_1 = require("./config-tree");
@@ -11,7 +12,7 @@ const manifest_1 = require("./manifest");
 const process_1 = require("./process");
 const project_1 = require("./project");
 const renderer_1 = require("./renderer");
-const tools_1 = require("./tools");
+const spawn_agent_1 = require("./runtime/spawn-agent");
 const utils_1 = require("./utils");
 function main(invokedTool, argv) {
     dispatch((0, cli_1.parseInvocation)(invokedTool, argv));
@@ -21,6 +22,9 @@ function dispatch(command) {
         case 'check':
             runCheck(command);
             return;
+        case 'status':
+            runStatus(command);
+            return;
         case 'init':
             runGenerate(command);
             return;
@@ -45,13 +49,18 @@ function dispatch(command) {
 }
 function runTool(parsed) {
     const { args, command, wrapperArgs } = parsed;
+    const adapter = (0, registry_1.getAgentAdapter)(command);
     const projectRoot = (0, project_1.findProjectRoot)(process.cwd());
     (0, utils_1.verbose)(`run ${command}: cwd=${process.cwd()} projectRoot=${projectRoot}`);
     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'}`);
-        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]);
+        (0, spawn_agent_1.spawnAgent)({
+            command: (0, process_1.findRealBinary)(command),
+            args: [...adapter.bypassArgs(wrapperArgs), ...args],
+            cwd: process.cwd(),
+            env: { ...process.env }
+        });
         return;
     }
     const profileResult = (0, project_1.resolveProfileResult)(projectRoot);
@@ -59,9 +68,9 @@ function runTool(parsed) {
         (0, utils_1.fail)(profileResult.reason);
     }
     const profile = profileResult.profile;
+    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
+    const agentDir = path.join(configRoot, profile);
     if (wrapperArgs.show) {
-        const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
-        const agentDir = path.join(configRoot, profile);
         (0, utils_1.verbose)(`profile=${profile} configRoot=${configRoot} agentPath=${agentDir}`);
         requireProfile(command, agentDir);
         showToolProfile(command, projectRoot, agentDir);
@@ -70,11 +79,10 @@ function runTool(parsed) {
     if (wrapperArgs.create) {
         runGenerate({ command: 'generate', targetPath: projectRoot });
     }
-    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
-    const agentDir = path.join(configRoot, profile);
     (0, utils_1.verbose)(`profile=${profile} configRoot=${configRoot} agentPath=${agentDir}`);
     prepareConfigRoot(configRoot);
     requireProfile(command, agentDir);
+    migrateProfileOnStart(configRoot, agentDir, false);
     const preview = (0, renderer_1.renderProfile)(projectRoot, agentDir, true, command);
     ensureToolEnabled(preview.context, command);
     if (wrapperArgs.generate) {
@@ -83,14 +91,29 @@ function runTool(parsed) {
     }
     checkLocalAiFiles(command, projectRoot, agentDir, preview.context, wrapperArgs.local);
     const realBinary = (0, process_1.findRealBinary)(command);
-    const permissionArgs = (0, tools_1.getPermissionArgs)(command);
     const rendered = (0, renderer_1.syncAgentProfile)(projectRoot, agentDir);
-    if (command === 'codex') {
-        (0, tools_1.runCodex)(realBinary, permissionArgs, rendered.context, args, wrapperArgs);
-    }
-    else {
-        (0, tools_1.runClaude)(realBinary, permissionArgs, rendered.context, args, wrapperArgs);
+    const runtime = rendered.runtimes[command];
+    if (!runtime) {
+        (0, utils_1.fail)(`no generated ${command} runtime found for profile ${rendered.profile}`);
     }
+    (0, spawn_agent_1.spawnAgent)(adapter.spawn(runtime, { binary: realBinary, passthroughArgs: args, wrapperArgs }));
+}
+function runStatus(_parsed) {
+    const adapters = (0, registry_1.listAgentAdapters)();
+    const columns = adapters.map((adapter) => adapter.displayName);
+    const capabilityRows = [
+        ['Instructions', 'instructions'],
+        ['Skills', 'skills'],
+        ['MCP', 'mcp'],
+        ['Hooks', 'hooks'],
+        ['Subagents', 'subagents'],
+        ['Headless', 'headless']
+    ];
+    const firstWidth = Math.max(...capabilityRows.map(([label]) => label.length));
+    const widths = columns.map((label) => Math.max(label.length, 3));
+    const header = `${''.padEnd(firstWidth)}  ${columns.map((label, index) => label.padStart(widths[index] ?? 3)).join('  ')}`;
+    const rows = capabilityRows.map(([label, capability]) => `${label.padEnd(firstWidth)}  ${adapters.map((adapter, index) => (adapter.capabilities[capability] ? 'yes' : '-').padStart(widths[index] ?? 3)).join('  ')}`);
+    process.stdout.write(['Native agent capabilities', '', header, ...rows, ''].join('\n'));
 }
 function validateRunModes(parsed, projectRoot) {
     const { command, wrapperArgs } = parsed;
@@ -158,6 +181,7 @@ function runGenerate(parsed) {
         return;
     }
     const agentDir = initializeProfileSource(projectRoot, true);
+    migrateProfileOnStart((0, project_1.defaultConfigRoot)(projectRoot), agentDir, false);
     printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
 }
 function runSetup(parsed) {
@@ -170,7 +194,9 @@ function runSetup(parsed) {
         (0, utils_1.fail)(`starter config skeleton not found: ${sourcePath}`);
     }
     (0, config_tree_1.copySkeletonTree)(sourcePath, configRoot, new Set(['starter']));
+    (0, config_tree_1.ensurePortableSystemdFiles)(configRoot);
     const agentDir = path.join(configRoot, profile);
+    migrateProfileOnStart(configRoot, agentDir, false);
     (0, config_tree_1.copySkeletonTree)(path.join(sourcePath, 'starter', 'basic-project'), agentDir);
     if (profile !== detectedProfile) {
         writeProjectProfileMapping(projectRoot, profile);
@@ -193,9 +219,9 @@ function confirmProfile(detectedProfile) {
     }
     return requireValidProfile(promptLine('Profile (org/repo): '));
 }
-function promptLine(prompt) {
+function promptLine(prompt, nonInteractiveMessage = 'setup requires a profile argument when input is not interactive') {
     if (!process.stdin.isTTY) {
-        (0, utils_1.fail)('setup requires a profile argument when input is not interactive');
+        (0, utils_1.fail)(nonInteractiveMessage);
     }
     process.stdout.write(prompt);
     const bytes = [];
@@ -234,6 +260,7 @@ function runEdit(parsed) {
         return;
     }
     const agentDir = initializeProfileSource(projectRoot, false);
+    migrateProfileOnStart((0, project_1.defaultConfigRoot)(projectRoot), agentDir, false);
     const editPath = (0, manifest_1.createDefaultLocalFile)(agentDir);
     (0, renderer_1.syncAgentProfile)(projectRoot, agentDir);
     process.stdout.write(`Edit: ${editPath}\n`);
@@ -254,6 +281,7 @@ function runUpdate(parsed) {
     const agentDir = (0, project_1.resolveAgentDir)(projectRoot);
     prepareConfigRoot(configRoot);
     requireProfile(null, agentDir);
+    migrateProfileOnStart(configRoot, agentDir, false);
     printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
 }
 function runUpdateAll(targetPath) {
@@ -264,6 +292,7 @@ function runUpdateAll(targetPath) {
     prepareConfigRoot(configRoot);
     const profileDirs = (0, config_tree_1.findProfileDirs)(configRoot);
     for (const agentDir of profileDirs) {
+        migrateProfileOnStart(configRoot, agentDir, false);
         const profile = path.relative(configRoot, agentDir).replace(/\\/g, '/');
         const projectRoot = (0, project_1.projectRootForProfile)(profile, configRoot);
         (0, renderer_1.syncAgentProfile)(projectRoot, agentDir, { configRoot, profile });
@@ -281,15 +310,16 @@ function runMigrateConfig(parsed) {
     (0, config_tree_1.migrateOldTemplates)(configRoot);
     (0, config_tree_1.ensureDefaultGlobalTemplates)(configRoot);
     (0, manifest_1.ensureRootDefaultsFile)(configRoot);
-    const profileDirs = (0, config_tree_1.findLegacyProfileDirs)(configRoot);
+    const profileDirs = (0, utils_1.uniqueSorted)([...(0, config_tree_1.findLegacyProfileDirs)(configRoot), ...(0, config_tree_1.findProfileDirs)(configRoot)]);
     let createdManifestCount = 0;
     let createdLocalCount = 0;
     let movedRuntimeCount = 0;
     let movedReviewCount = 0;
     let movedMemoryCount = 0;
     for (const agentDir of profileDirs) {
+        const layout = migrateProfileOnStart(configRoot, agentDir, parsed.yes);
         const localPath = path.join(agentDir, constants_1.LOCAL_TEMPLATE_FILE_NAME);
-        if (!fs.existsSync(localPath)) {
+        if (!fs.existsSync(localPath) && fs.existsSync(path.join(agentDir, 'AGENTS-MODS.md'))) {
             fs.writeFileSync(localPath, (0, config_tree_1.convertLegacyTemplateVars)(fs.readFileSync(path.join(agentDir, 'AGENTS-MODS.md'), 'utf8')), 'utf8');
             createdLocalCount += 1;
         }
@@ -299,7 +329,7 @@ function runMigrateConfig(parsed) {
         }
         movedRuntimeCount += (0, config_tree_1.migrateCodexRuntimeFiles)(agentDir);
         movedReviewCount += (0, config_tree_1.migrateLooseFiles)(agentDir, /^REVIEW(?:-.+)?\.md$/, 'reviews');
-        movedMemoryCount += (0, config_tree_1.migrateLooseFiles)(agentDir, /^memory.*\.md$/i, 'memories');
+        movedMemoryCount += layout.projectMemoryMoves;
     }
     process.stdout.write(`OK migrated ${configRoot}\n`);
     process.stdout.write(`Profiles converted: ${profileDirs.length}\n`);
@@ -309,6 +339,29 @@ function runMigrateConfig(parsed) {
     process.stdout.write(`Moved review files: ${movedReviewCount}\n`);
     process.stdout.write(`Moved memory files: ${movedMemoryCount}\n`);
 }
+function migrateProfileOnStart(configRoot, profileDir, assumeYes) {
+    const result = (0, config_tree_1.migrateProfileLayout)(configRoot, profileDir, ({ gitRoot, moves }) => {
+        process.stdout.write('agent-run: this profile uses an older project-memory layout.\n');
+        process.stdout.write(`Git working tree: ${gitRoot}\n`);
+        for (const move of moves) {
+            process.stdout.write(`  ${path.relative(gitRoot, move.source)} -> ${path.relative(gitRoot, move.target)}\n`);
+        }
+        if (assumeYes) {
+            return true;
+        }
+        const migrateCommand = (0, utils_1.formatCommand)('agent-run', ['migrate-config', '--yes', configRoot]);
+        const message = `tracked project-memory files need migration; rerun interactively or run \`${migrateCommand}\``;
+        const answer = promptLine('Stage these moves with git mv? [Y/n] ', message).trim().toLowerCase();
+        return answer === '' || answer === 'y' || answer === 'yes';
+    });
+    if (result.gitMoves > 0) {
+        process.stdout.write(`Staged Git moves: ${result.gitMoves}\n`);
+    }
+    if (result.runtimeMoves > 0) {
+        process.stdout.write(`Moved local Codex runtime entries: ${result.runtimeMoves}\n`);
+    }
+    return result;
+}
 function runCheck(parsed) {
     if (parsed.all) {
         const report = (0, checks_1.checkSourceTree)(parsed.targetPath);
@@ -328,6 +381,7 @@ function prepareConfigRoot(configRoot) {
     (0, config_tree_1.ensureConfigRootLayout)(configRoot);
     (0, config_tree_1.ensureConfigRootGitignore)(configRoot);
     (0, config_tree_1.ensureDefaultGlobalTemplates)(configRoot);
+    (0, config_tree_1.ensurePortableSystemdFiles)(configRoot);
 }
 function activeProject(targetPath, action) {
     const projectRoot = (0, project_1.findProjectRoot)(targetPath);

package/dist/config/render-instructions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCanonicalInstructions = buildCanonicalInstructions;
+exports.writeAgentsMd = writeAgentsMd;
+exports.writeClaudeMd = writeClaudeMd;
+const fs = require("fs");
+const path = require("path");
+const constants_1 = require("../constants");
+const defaults_1 = require("../defaults");
+const templates_1 = require("../templates");
+function buildCanonicalInstructions(env, configRoot, manifest, context, trace) {
+    const sections = [(0, templates_1.renderTemplateFile)(env, configRoot, manifest.agent.base, context, trace)];
+    for (const include of manifest.agent.includes) {
+        const includePath = (0, templates_1.resolveConfigPath)(configRoot, include, context);
+        if (!fs.existsSync(includePath)) {
+            if (include.includes('AGENTS-MODS.md') || include.includes(constants_1.LOCAL_TEMPLATE_FILE_NAME)) {
+                continue;
+            }
+            throw new Error(`missing template: ${includePath}`);
+        }
+        sections.push((0, templates_1.renderTemplateFile)(env, configRoot, include, context, trace));
+    }
+    const renderedSections = sections.map((section, index) => {
+        const label = index === 0 ? manifest.agent.base : manifest.agent.includes[index - 1] ?? `section ${index}`;
+        (0, templates_1.assertNoUnexpandedTemplateVars)(label, section);
+        return section.trimEnd();
+    });
+    renderedSections.push(projectMemoryInstructions(context));
+    return { sections: renderedSections };
+}
+function writeAgentsMd(env, configRoot, context, trace) {
+    return renderInstructionFile('AGENTS.md', env, configRoot, context, false, trace);
+}
+function writeClaudeMd(env, configRoot, context, trace) {
+    return renderInstructionFile('CLAUDE.md', env, configRoot, context, true, trace);
+}
+function renderInstructionFile(templateName, env, configRoot, context, isClaude, trace) {
+    const templatePath = `global/tool-templates/${templateName}.njk`;
+    const content = fs.existsSync(path.join(configRoot, templatePath))
+        ? (0, templates_1.renderTemplateFile)(env, configRoot, templatePath, context, trace)
+        : env.renderString((0, defaults_1.defaultToolInstructionsTemplate)(isClaude), context);
+    (0, templates_1.assertNoUnexpandedTemplateVars)(templateName, content);
+    return content.replace(/\n*$/, '\n');
+}
+function projectMemoryInstructions(context) {
+    return [
+        '## Project Memory',
+        '',
+        `Project memory is stored in ${context.paths.projectMemoryDir}.`,
+        'Read README.md there before starting work when prior project context may matter, then read only the linked files relevant to the task.',
+        'Do not store secrets, raw chat transcripts, or temporary task state there.',
+        'Update project memory only when the user explicitly asks you to remember or update something for this project.'
+    ].join('\n');
+}

package/dist/config/render-mcp.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCodexMcp = renderCodexMcp;
+exports.renderGrokMcp = renderGrokMcp;
+exports.renderClaudeMcp = renderClaudeMcp;
+exports.renderGeminiMcp = renderGeminiMcp;
+function renderCodexMcp(context) {
+    return renderTomlMcp(context.mcpServers, 'codex');
+}
+function renderGrokMcp(context) {
+    return renderTomlMcp(context.mcpServers, 'grok');
+}
+function renderClaudeMcp(context) {
+    return { mcpServers: renderJsonMcp(context.mcpServers, 'claude') };
+}
+function renderGeminiMcp(context) {
+    return renderJsonMcp(context.mcpServers, 'gemini');
+}
+function renderJsonMcp(servers, target) {
+    const result = {};
+    for (const [name, server] of Object.entries(servers)) {
+        if (!server.enabled) {
+            continue;
+        }
+        if (server.transport === 'stdio') {
+            result[name] = compactObject({
+                ...(target === 'claude' ? { type: 'stdio' } : {}),
+                command: server.command,
+                args: server.args.length > 0 ? server.args : undefined,
+                cwd: server.cwd,
+                env: Object.keys(server.env).length > 0 ? server.env : undefined
+            });
+            continue;
+        }
+        result[name] = compactObject({
+            ...(target === 'claude' ? { type: server.transport } : {}),
+            ...(target === 'gemini' && server.transport === 'http'
+                ? { httpUrl: server.url }
+                : { url: server.url }),
+            headers: Object.keys(server.headers).length > 0 ? server.headers : undefined
+        });
+    }
+    return result;
+}
+function renderTomlMcp(servers, target) {
+    const sections = [];
+    for (const [name, server] of Object.entries(servers)) {
+        const lines = [`[mcp_servers.${tomlKey(name)}]`];
+        if (server.transport === 'stdio') {
+            lines.push(`command = ${tomlString(server.command ?? '')}`);
+            if (server.args.length > 0) {
+                lines.push(`args = ${tomlArray(server.args)}`);
+            }
+            if (server.cwd) {
+                lines.push(`cwd = ${tomlString(server.cwd)}`);
+            }
+            if (Object.keys(server.env).length > 0) {
+                lines.push(`env = ${tomlInlineTable(server.env)}`);
+            }
+        }
+        else {
+            lines.push(`url = ${tomlString(server.url ?? '')}`);
+            if (Object.keys(server.headers).length > 0) {
+                lines.push(`${target === 'codex' ? 'http_headers' : 'headers'} = ${tomlInlineTable(server.headers)}`);
+            }
+        }
+        if (!server.enabled) {
+            lines.push('enabled = false');
+        }
+        sections.push(lines.join('\n'));
+    }
+    return sections.length > 0 ? `${sections.join('\n\n')}\n` : '';
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function tomlKey(value) {
+    return /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function tomlArray(values) {
+    return `[${values.map(tomlString).join(', ')}]`;
+}
+function tomlInlineTable(values) {
+    return `{ ${Object.entries(values).map(([key, value]) => `${tomlKey(key)} = ${tomlString(value)}`).join(', ')} }`;
+}