@technomoron/agent-run 0.99.27 → 0.99.29

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);
@@ -56,22 +59,21 @@ 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);
         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);
     (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) {
@@ -110,7 +112,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,21 +148,87 @@ 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;
     }
     const agentDir = initializeProfileSource(projectRoot, true);
+    migrateProfileOnStart((0, project_1.defaultConfigRoot)(projectRoot), agentDir, false);
     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']));
+    (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);
+    }
+    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, nonInteractiveMessage = 'setup requires a profile argument when input is not interactive') {
+    if (!process.stdin.isTTY) {
+        (0, utils_1.fail)(nonInteractiveMessage);
+    }
+    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');
@@ -168,6 +236,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`);
@@ -188,6 +257,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) {
@@ -198,6 +268,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 });
@@ -215,15 +286,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;
         }
@@ -233,7 +305,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`);
@@ -243,6 +315,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);
@@ -262,6 +357,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-tree.js

@@ -3,14 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureConfigRootLayout = ensureConfigRootLayout;
 exports.ensureConfigRootGitignore = ensureConfigRootGitignore;
 exports.ensureDefaultGlobalTemplates = ensureDefaultGlobalTemplates;
+exports.ensurePortableSystemdFiles = ensurePortableSystemdFiles;
 exports.migrateOldTemplates = migrateOldTemplates;
 exports.findLegacyProfileDirs = findLegacyProfileDirs;
 exports.findProfileDirs = findProfileDirs;
 exports.convertLegacyTemplateVars = convertLegacyTemplateVars;
 exports.migrateCodexRuntimeFiles = migrateCodexRuntimeFiles;
 exports.migrateLooseFiles = migrateLooseFiles;
+exports.describeLegacyProfileLayout = describeLegacyProfileLayout;
+exports.migrateProfileLayout = migrateProfileLayout;
 exports.starterConfigRootPath = starterConfigRootPath;
 exports.copySkeletonTree = copySkeletonTree;
+const childProcess = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const constants_1 = require("./constants");
@@ -68,6 +72,25 @@ function ensureDefaultGlobalTemplates(configRoot) {
         }
     }
 }
+function ensurePortableSystemdFiles(configRoot) {
+    const packageRoot = path.resolve(__dirname, '..');
+    const files = new Map([
+        ['install-systemd-jobs.sh', { source: 'scripts/install-systemd-jobs.sh', mode: 0o755 }],
+        ['update-ai-tools.sh', { source: 'scripts/update-ai-tools.sh', mode: 0o755 }],
+        ['ai-tools-update.service', { source: 'ops/systemd/ai-tools-update.service', mode: 0o644 }],
+        ['ai-tools-update.timer', { source: 'ops/systemd/ai-tools-update.timer', mode: 0o644 }]
+    ]);
+    for (const [targetName, asset] of files) {
+        const sourcePath = path.join(packageRoot, asset.source);
+        const targetPath = path.join(configRoot, targetName);
+        if (!fs.existsSync(sourcePath)) {
+            continue;
+        }
+        fs.copyFileSync(sourcePath, targetPath);
+        fs.chmodSync(targetPath, asset.mode);
+        (0, utils_1.verbose)(`updated ${targetPath}`);
+    }
+}
 function migrateOldTemplates(configRoot) {
     const oldCodeTemplate = path.join(configRoot, 'templates', 'AGENTS-CODE.md');
     const newCodeTemplate = path.join(configRoot, 'global', 'agents', 'code.md.njk');
@@ -150,17 +173,246 @@ function migrateLooseFiles(agentDir, pattern, targetDirName) {
     }
     return moved;
 }
+function describeLegacyProfileLayout(profileDir) {
+    const paths = [];
+    const legacyMemoryDir = path.join(profileDir, 'memory');
+    if (fs.existsSync(legacyMemoryDir)) {
+        paths.push(legacyMemoryDir);
+    }
+    for (const filePath of legacyProjectMemoryFiles(profileDir)) {
+        paths.push(filePath);
+    }
+    const legacyCodexHome = path.join(profileDir, 'memories', 'codex-home');
+    if (fs.existsSync(legacyCodexHome) || (0, utils_1.isSymlink)(legacyCodexHome)) {
+        paths.push(legacyCodexHome);
+    }
+    return [...new Set(paths)].sort();
+}
+function migrateProfileLayout(configRoot, profileDir, confirmGitMoves) {
+    const projectMoves = planProjectMemoryMoves(profileDir);
+    validateMoveTargets(projectMoves);
+    const git = findGitWorktree(configRoot);
+    const trackedMoves = git === null ? [] : projectMoves.filter((move) => isTrackedByGit(git, move.source));
+    if (git !== null && trackedMoves.length > 0 && !confirmGitMoves({ gitRoot: git.root, moves: trackedMoves })) {
+        throw new Error('profile layout migration declined; no files were moved');
+    }
+    let gitMoves = 0;
+    for (const move of projectMoves) {
+        fs.mkdirSync(path.dirname(move.target), { recursive: true });
+        if (git !== null && trackedMoves.includes(move)) {
+            runGitMove(git, move);
+            gitMoves += 1;
+        }
+        else {
+            fs.renameSync(move.source, move.target);
+        }
+        removeEmptyParents(path.dirname(move.source), profileDir);
+        (0, utils_1.verbose)(`moved project memory ${move.source} -> ${move.target}`);
+    }
+    removeEmptyParents(path.join(profileDir, 'memory'), profileDir);
+    removeEmptyParents(path.join(profileDir, 'memories'), profileDir);
+    const runtimeMoves = migrateLegacyCodexHome(profileDir);
+    return { gitMoves, projectMemoryMoves: projectMoves.length, runtimeMoves };
+}
+function planProjectMemoryMoves(profileDir) {
+    const targetDir = path.join(profileDir, 'notes', 'memory');
+    const moves = [];
+    const legacyMemoryDir = path.join(profileDir, 'memory');
+    for (const source of listTreeFiles(legacyMemoryDir)) {
+        moves.push({ source, target: path.join(targetDir, path.relative(legacyMemoryDir, source)) });
+    }
+    for (const source of legacyProjectMemoryFiles(profileDir)) {
+        moves.push({ source, target: path.join(targetDir, path.basename(source)) });
+    }
+    return moves.sort((left, right) => left.source.localeCompare(right.source));
+}
+function legacyProjectMemoryFiles(profileDir) {
+    const files = [];
+    for (const entry of safeReadDir(profileDir)) {
+        if (entry.isFile() && /^memory.*\.md$/i.test(entry.name)) {
+            files.push(path.join(profileDir, entry.name));
+        }
+    }
+    const legacyMemoriesDir = path.join(profileDir, 'memories');
+    for (const entry of safeReadDir(legacyMemoriesDir)) {
+        if (entry.isFile() && /\.md$/i.test(entry.name)) {
+            files.push(path.join(legacyMemoriesDir, entry.name));
+        }
+    }
+    return files.sort();
+}
+function safeReadDir(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function listTreeFiles(root) {
+    const files = [];
+    for (const entry of safeReadDir(root)) {
+        const filePath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listTreeFiles(filePath));
+        }
+        else if (entry.isFile() || entry.isSymbolicLink()) {
+            files.push(filePath);
+        }
+    }
+    return files;
+}
+function validateMoveTargets(moves) {
+    const targets = new Set();
+    for (const move of moves) {
+        const target = path.resolve(move.target);
+        if (targets.has(target) || fs.existsSync(target) || (0, utils_1.isSymlink)(target)) {
+            throw new Error(`cannot migrate project memory because the destination already exists: ${move.target}`);
+        }
+        targets.add(target);
+    }
+}
+function findGitWorktree(configRoot) {
+    const searchPath = process.env.AGENT_RUN_REAL_PATH ?? process.env.PATH ?? '';
+    const gitCommand = findCommandOnPath('git', searchPath);
+    if (gitCommand === null) {
+        return null;
+    }
+    const env = { ...process.env, PATH: searchPath };
+    const result = childProcess.spawnSync(gitCommand, ['-C', configRoot, 'rev-parse', '--show-toplevel'], {
+        encoding: 'utf8',
+        env,
+        shell: false
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    const root = result.stdout.trim();
+    return root ? { command: gitCommand, env, root: path.resolve(root) } : null;
+}
+function findCommandOnPath(command, searchPath) {
+    const extensions = process.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const dir of searchPath.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = path.join(dir, `${command}${extension}`);
+            try {
+                fs.accessSync(candidate, process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+                return candidate;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+function isTrackedByGit(git, filePath) {
+    const relativePath = path.relative(git.root, filePath).replace(/\\/g, '/');
+    const result = childProcess.spawnSync(git.command, ['-C', git.root, '--literal-pathspecs', 'ls-files', '--error-unmatch', '--', relativePath], { encoding: 'utf8', env: git.env, shell: false });
+    return result.status === 0;
+}
+function runGitMove(git, move) {
+    const source = path.relative(git.root, move.source).replace(/\\/g, '/');
+    const target = path.relative(git.root, move.target).replace(/\\/g, '/');
+    const result = childProcess.spawnSync(git.command, ['-C', git.root, '--literal-pathspecs', 'mv', '--', source, target], {
+        encoding: 'utf8',
+        env: git.env,
+        shell: false
+    });
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`;
+        throw new Error(`cannot migrate tracked project memory ${move.source}: ${detail}`);
+    }
+}
+function migrateLegacyCodexHome(profileDir) {
+    const source = path.join(profileDir, 'memories', 'codex-home');
+    if (!fs.existsSync(source) && !(0, utils_1.isSymlink)(source)) {
+        return 0;
+    }
+    const target = path.join(profileDir, constants_1.LIVE_DIR_NAME, 'memories', 'codex-home');
+    if (!fs.existsSync(target) && !(0, utils_1.isSymlink)(target)) {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.renameSync(source, target);
+        removeEmptyParents(path.dirname(source), profileDir);
+        (0, utils_1.verbose)(`moved Codex runtime ${source} -> ${target}`);
+        return 1;
+    }
+    const sourceIsDirectory = !(0, utils_1.isSymlink)(source) && fs.statSync(source).isDirectory();
+    const targetIsDirectory = !(0, utils_1.isSymlink)(target) && fs.statSync(target).isDirectory();
+    if (!sourceIsDirectory || !targetIsDirectory) {
+        const backupTarget = (0, utils_1.nextBackupPath)(target);
+        fs.renameSync(source, backupTarget);
+        removeEmptyParents(path.dirname(source), profileDir);
+        (0, utils_1.verbose)(`moved Codex runtime ${source} -> ${backupTarget}`);
+        return 1;
+    }
+    const moved = mergeRuntimeTree(source, target);
+    removeEmptyParents(path.dirname(source), profileDir);
+    return moved;
+}
+function mergeRuntimeTree(sourceDir, targetDir) {
+    let moved = 0;
+    fs.mkdirSync(targetDir, { recursive: true });
+    for (const entry of safeReadDir(sourceDir)) {
+        const source = path.join(sourceDir, entry.name);
+        let target = path.join(targetDir, entry.name);
+        if (entry.isDirectory() && !entry.isSymbolicLink()) {
+            const targetIsDirectory = fs.existsSync(target) && !(0, utils_1.isSymlink)(target) && fs.statSync(target).isDirectory();
+            if ((fs.existsSync(target) || (0, utils_1.isSymlink)(target)) && !targetIsDirectory) {
+                target = (0, utils_1.nextBackupPath)(target);
+            }
+            moved += mergeRuntimeTree(source, target);
+            continue;
+        }
+        const resolvedTarget = fs.existsSync(target) || (0, utils_1.isSymlink)(target) ? (0, utils_1.nextBackupPath)(target) : target;
+        fs.mkdirSync(path.dirname(resolvedTarget), { recursive: true });
+        fs.renameSync(source, resolvedTarget);
+        (0, utils_1.verbose)(`moved Codex runtime ${source} -> ${resolvedTarget}`);
+        moved += 1;
+    }
+    try {
+        fs.rmdirSync(sourceDir);
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+    return moved;
+}
+function removeEmptyParents(startDir, stopDir) {
+    let dir = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (dir !== stop && (0, utils_1.isSamePathOrDescendant)(dir, stop)) {
+        try {
+            fs.rmdirSync(dir);
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && ['ENOENT', 'ENOTEMPTY'].includes(String(error.code))) {
+                return;
+            }
+            throw error;
+        }
+        dir = path.dirname(dir);
+    }
+}
 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.29';
 exports.UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
 exports.LOCAL_AI_FILE_NAMES = new Set([
     'AGENTS.md',

package/dist/defaults.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultManifest = defaultManifest;
 exports.stringifyRootDefaults = stringifyRootDefaults;
 exports.defaultLocalTemplate = defaultLocalTemplate;
+exports.defaultProjectMemoryIndex = defaultProjectMemoryIndex;
 exports.defaultGlobalTemplates = defaultGlobalTemplates;
 exports.defaultToolInstructionsTemplate = defaultToolInstructionsTemplate;
 exports.defaultCodexConfigContent = defaultCodexConfigContent;
@@ -34,7 +35,8 @@ function defaultManifest(profile) {
             changesFile: '{{ projectRoot }}/CHANGES',
             reviewDir: '{{ profileDir }}/reviews',
             reviewFile: '{{ profileDir }}/reviews/REVIEW-{{ date }}.md',
-            memoriesDir: '{{ agentDir }}/memories'
+            memoriesDir: '{{ agentDir }}/memories',
+            projectMemoryDir: '{{ profileDir }}/notes/memory'
         }
     };
 }
@@ -71,6 +73,19 @@ function defaultLocalTemplate() {
         ''
     ].join('\n');
 }
+function defaultProjectMemoryIndex() {
+    return [
+        '# Project memory',
+        '',
+        'This directory contains durable notes for this project across agent sessions and machines.',
+        'Keep the notes short, factual, and free of secrets. Link additional topic files from this index.',
+        '',
+        '## Files',
+        '',
+        '- Add project memory files here as they are needed.',
+        ''
+    ].join('\n');
+}
 function defaultGlobalTemplates() {
     return new Map([
         ['global/agents/code.md.njk', defaultCodeAgentTemplate()],
@@ -293,6 +308,18 @@ function defaultToolInstructionsTemplate(isClaude) {
         '{{ paths.memoriesDir }}',
         '```',
         '',
+        'Project memory directory:',
+        '',
+        '```text',
+        '{{ paths.projectMemoryDir }}',
+        '```',
+        '',
+        'Native Codex memory directory:',
+        '',
+        '```text',
+        '{{ paths.nativeMemoryDir }}',
+        '```',
+        '',
         'Global memory directory:',
         '',
         '```text',
@@ -337,7 +364,8 @@ function defaultCodexConfigTemplate() {
         'writable_roots = [',
         '  {{ projectRoot | dump }},',
         '  {{ paths.reviewDir | dump }},',
-        '  {{ paths.memoriesDir | dump }}',
+        '  {{ paths.memoriesDir | dump }},',
+        '  {{ paths.projectMemoryDir | dump }}',
         ']',
         'network_access = false',
         ''
@@ -349,6 +377,7 @@ function defaultClaudeSettingsTemplate() {
         '    "AGENT_DIR": {{ agentDir | dump }},',
         '    "AGENT_PROFILE_DIR": {{ profileDir | dump }},',
         '    "AGENT_RUN_PROJECT_ROOT": {{ projectRoot | dump }},',
+        '    "AGENT_PROJECT_MEMORY_DIR": {{ paths.projectMemoryDir | dump }},',
         '    "AGENT_GLOBAL_MEMORY_DIR": {{ paths.globalMemoryDir | dump }}',
         '  }'
     ].join('\n');
@@ -377,7 +406,8 @@ function defaultCodexConfigContent(context) {
         'writable_roots = [',
         `  ${JSON.stringify(context.projectRoot)},`,
         `  ${JSON.stringify(context.paths.reviewDir)},`,
-        `  ${JSON.stringify(context.paths.memoriesDir)}`,
+        `  ${JSON.stringify(context.paths.memoriesDir)},`,
+        `  ${JSON.stringify(context.paths.projectMemoryDir)}`,
         ']',
         'network_access = false',
         ''
@@ -389,6 +419,7 @@ function defaultClaudeSettingsContent(context) {
             AGENT_DIR: context.agentDir,
             AGENT_PROFILE_DIR: context.profileDir,
             AGENT_RUN_PROJECT_ROOT: context.projectRoot,
+            AGENT_PROJECT_MEMORY_DIR: context.paths.projectMemoryDir,
             AGENT_GLOBAL_MEMORY_DIR: context.paths.globalMemoryDir
         }
     };

package/dist/manifest.js

@@ -165,7 +165,8 @@ function normalizeManifest(manifest, profile) {
             reviewDir: normalizeLegacyReviewPath(paths.reviewDir ?? fallbackPaths.reviewDir ?? '{{ profileDir }}/reviews'),
             reviewFile: normalizeLegacyReviewPath(paths.reviewFile ?? fallbackPaths.reviewFile ?? '{{ profileDir }}/reviews/REVIEW-{{ date }}.md'),
             reviewConsolidatedFile: paths.reviewConsolidatedFile ?? fallbackPaths.reviewConsolidatedFile,
-            memoriesDir: paths.memoriesDir ?? fallbackPaths.memoriesDir ?? '{{ agentDir }}/memories'
+            memoriesDir: paths.memoriesDir ?? fallbackPaths.memoriesDir ?? '{{ agentDir }}/memories',
+            projectMemoryDir: paths.projectMemoryDir ?? fallbackPaths.projectMemoryDir ?? '{{ profileDir }}/notes/memory'
         }
     };
 }