claude-dev-env 2.35.0 → 4.0.0

package/bin/cde.test.mjs

@@ -0,0 +1,222 @@
+import { EventEmitter } from "node:events";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+
+import {
+    buildLintCommand,
+    createHelpText,
+    findPython,
+    main,
+    pythonInterpreterNames,
+    runLintCommand,
+} from "./cde.mjs";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const lintScriptPath = path.join(packageRoot, "scripts", "cde_lint.py");
+const packageManifest = JSON.parse(
+    readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+
+function createFakeChild() {
+    const childProcess = new EventEmitter();
+    childProcess.kill = (signalName) => {
+        childProcess.lastSignalName = signalName;
+    };
+    return childProcess;
+}
+
+
+test("package exposes cde through its bin map", () => {
+    assert.equal(packageManifest.bin.cde, "bin/cde.mjs");
+});
+
+
+test("help describes lint source modes", () => {
+    const helpText = createHelpText();
+    assert.match(helpText, /cde lint/);
+    assert.match(helpText, /--files/);
+    assert.match(helpText, /--staged/);
+    assert.match(helpText, /--base/);
+    assert.match(helpText, /--repository/);
+    assert.match(helpText, /--text-as/);
+});
+
+
+test("prefers py then python on Windows and python3 then python on POSIX", () => {
+    assert.deepEqual(pythonInterpreterNames("win32"), ["py", "python"]);
+    assert.deepEqual(pythonInterpreterNames("linux"), ["python3", "python"]);
+    assert.deepEqual(pythonInterpreterNames("darwin"), ["python3", "python"]);
+});
+
+
+test("falls back to the next interpreter when the first cannot run", () => {
+    const selectedName = findPython(["py", "python"], (commandName) => commandName === "python");
+    assert.equal(selectedName, "python");
+});
+
+
+test("forwards lint arguments to the python command without a shell", () => {
+    const command = buildLintCommand("python-test", ["--files", "a.py", "--format", "json"]);
+    assert.equal(command.executable, "python-test");
+    assert.equal(command.arguments[0], lintScriptPath);
+    assert.deepEqual(command.arguments.slice(1), ["--files", "a.py", "--format", "json"]);
+});
+
+
+test("strips the launcher python override from forwarded arguments", async () => {
+    let receivedCommand;
+    const exitCode = await main(["lint", "--python", "python-test", "--staged"], {
+        findPython: async () => "unused-python",
+        runCommand: async (command) => {
+            receivedCommand = command;
+            return 0;
+        },
+    });
+    assert.equal(exitCode, 0);
+    assert.equal(receivedCommand.executable, "python-test");
+    assert.deepEqual(receivedCommand.arguments, [lintScriptPath, "--staged"]);
+});
+
+
+test("unknown command returns invalid input without spawning", async () => {
+    let wasRun = false;
+    const messages = [];
+    const originalWrite = process.stderr.write;
+    process.stderr.write = (message) => messages.push(message);
+    try {
+        const exitCode = await main(["not-lint"], {
+            findPython: async () => "python",
+            runCommand: async () => {
+                wasRun = true;
+                return 0;
+            },
+        });
+        assert.equal(exitCode, 2);
+    } finally {
+        process.stderr.write = originalWrite;
+    }
+    assert.equal(wasRun, false);
+    assert.match(messages.join(""), /lint/);
+});
+
+
+test("missing python override value returns invalid input without spawning", async () => {
+    let wasRun = false;
+    const exitCode = await main(["lint", "--python"], {
+        findPython: async () => "python",
+        runCommand: async () => {
+            wasRun = true;
+            return 0;
+        },
+    });
+    assert.equal(exitCode, 2);
+    assert.equal(wasRun, false);
+});
+
+
+test("missing interpreter returns invalid input without spawning", async () => {
+    let wasRun = false;
+    const originalWrite = process.stderr.write;
+    process.stderr.write = () => true;
+    try {
+        const exitCode = await main(["lint", "--staged"], {
+            findPython: async () => undefined,
+            runCommand: async () => {
+                wasRun = true;
+                return 0;
+            },
+        });
+        assert.equal(exitCode, 2);
+    } finally {
+        process.stderr.write = originalWrite;
+    }
+    assert.equal(wasRun, false);
+});
+
+
+test("forwards child exit status", async () => {
+    const childProcess = createFakeChild();
+    const exitPromise = runLintCommand(
+        { executable: "python", arguments: [lintScriptPath] },
+        {
+            runChild: () => childProcess,
+        },
+    );
+    childProcess.emit("close", 3, null);
+    assert.equal(await exitPromise, 3);
+});
+
+
+test("forwards SIGINT to the child and never enables a shell", async () => {
+    const childProcess = createFakeChild();
+    const processEmitter = new EventEmitter();
+    let spawnOptions;
+    const exitPromise = runLintCommand(
+        { executable: "python", arguments: [lintScriptPath, "--staged"] },
+        {
+            processEmitter,
+            runChild: (_executable, _allArguments, options) => {
+                spawnOptions = options;
+                return childProcess;
+            },
+        },
+    );
+    processEmitter.emit("SIGINT");
+    childProcess.emit("close", 0, null);
+    assert.equal(await exitPromise, 0);
+    assert.equal(childProcess.lastSignalName, "SIGINT");
+    assert.equal(spawnOptions.shell, false);
+});
+
+
+test("tolerates forwarding a signal to a dead child", async () => {
+    const childProcess = createFakeChild();
+    childProcess.kill = () => {
+        throw new Error("child already exited");
+    };
+    const processEmitter = new EventEmitter();
+    const exitPromise = runLintCommand(
+        { executable: "python", arguments: [lintScriptPath] },
+        { processEmitter, runChild: () => childProcess },
+    );
+    processEmitter.emit("SIGTERM");
+    childProcess.emit("close", 0, null);
+    assert.equal(await exitPromise, 0);
+});
+
+
+test("reports a child start failure as invalid input", async () => {
+    const childProcess = createFakeChild();
+    const processEmitter = new EventEmitter();
+    const messages = [];
+    processEmitter.stderr = { write: (message) => messages.push(message) };
+    const exitPromise = runLintCommand(
+        { executable: "missing-python", arguments: [lintScriptPath] },
+        { processEmitter, runChild: () => childProcess },
+    );
+    childProcess.emit("error", new Error("not found"));
+    assert.equal(await exitPromise, 2);
+    assert.deepEqual(messages, ["Unable to start the policy linter.\n"]);
+});
+
+
+test("reports a synchronous child start failure as invalid input", async () => {
+    const processEmitter = new EventEmitter();
+    const messages = [];
+    processEmitter.stderr = { write: (message) => messages.push(message) };
+    const exitCode = await runLintCommand(
+        { executable: "missing-python", arguments: [lintScriptPath] },
+        {
+            processEmitter,
+            runChild: () => {
+                throw new Error("not found");
+            },
+        },
+    );
+    assert.equal(exitCode, 2);
+    assert.deepEqual(messages, ["Unable to start the policy linter.\n"]);
+});

package/bin/install-constants.mjs

@@ -55,6 +55,10 @@ export const RUN_BACKUP_DIRECTORY_NAME_PATTERN =
  */
 export const PACKAGE_AGENTS_HOME_DIRECTORY_NAME = '.agents';
 
+export const PSTACK_MODEL_RULE_FILE_NAME = 'pstack-models.mdc';
+export const PSTACK_CODEX_MODEL_PREFERENCES_FILE_NAME =
+    'pstack-model-preferences.codex.json';
+
 /**
  * The directory name skill directories carry in a package source and under
  * the agents home.

package/bin/install.cursor-rules.test.mjs

@@ -1,6 +1,13 @@
 import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import {
+    mkdtempSync,
+    mkdirSync,
+    writeFileSync,
+    readFileSync,
+    existsSync,
+    rmSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -18,7 +25,7 @@ const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
 const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
 const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
 
-function runInstaller(homeDirectory, extraArguments) {
+function runInstaller(homeDirectory, extraArguments, environmentOverrides = {}) {
     return execFileSync('node', [INSTALLER_PATH, ...extraArguments], {
         cwd: PACKAGE_DIRECTORY,
         encoding: 'utf8',
@@ -26,11 +33,21 @@ function runInstaller(homeDirectory, extraArguments) {
             ...process.env,
             HOME: homeDirectory,
             USERPROFILE: homeDirectory,
+            CODEX_HOME: join(homeDirectory, '.codex'),
+            CLAUDE_CONFIG_DIR: join(homeDirectory, '.claude'),
             GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+            ...environmentOverrides,
         },
     });
 }
 
+function runSelector(selectorPath, selectionInput) {
+    return JSON.parse(execFileSync('node', [selectorPath], {
+        encoding: 'utf8',
+        input: JSON.stringify(selectionInput),
+    }));
+}
+
 test('resolveInstallRoot names ~/.cursor/rules and allows generated mdc files under it', () => {
     const homeDirectory = join(tmpdir(), 'cdev-cursor-rules-home');
     const resolution = resolveInstallRoot({
@@ -92,11 +109,225 @@ test('--only journal skips Cursor rule generation; --only core writes them', ()
             CURSOR_RULES_DIRECTORY_NAME,
             'asd-ste100-language.mdc',
         );
+        const preferencePath = join(
+            homeDirectory,
+            '.agents',
+            'rules',
+            'pstack-model-preferences.codex.json',
+        );
         runInstaller(homeDirectory, ['--only', 'journal']);
         assert.equal(existsSync(generatedPath), false);
+        assert.equal(existsSync(preferencePath), false);
 
         runInstaller(homeDirectory, ['--only', 'core']);
         assert.equal(existsSync(generatedPath), true);
+        assert.equal(existsSync(preferencePath), true);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+for (const targetName of [null, 'profile']) {
+    test('pstack rules survive reinstall and sync for ' + (targetName ?? 'main'), () => {
+        const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-'));
+        try {
+            const targetArguments = targetName
+                ? ['--target', join(homeDirectory, targetName)]
+                : [];
+            const resolution = resolveInstallRoot({
+                homeDirectory,
+                environment: {},
+                explicitTarget: targetName ? join(homeDirectory, targetName) : null,
+            });
+            const sharedPath = join(resolution.agentsHome, 'rules', 'pstack-models.mdc');
+            const cursorPath = join(resolution.cursorRulesInstallDirectory, 'pstack-models.mdc');
+            const preferencesPath = join(
+                resolution.agentsHome,
+                'rules',
+                'pstack-model-preferences.codex.json',
+            );
+            const selectorPath = join(
+                resolution.agentsHome,
+                'scripts',
+                'select_pstack_models.mjs',
+            );
+            const managedSelectorPath = join(
+                resolution.managedRoot,
+                'scripts',
+                'select_pstack_models.mjs',
+            );
+            runInstaller(homeDirectory, [...targetArguments, '--only', 'core']);
+
+            const installedText = readFileSync(sharedPath, 'utf8');
+            assert.doesNotMatch(installedText, /gpt-|claude-|grok-/i);
+            assert.match(installedText, /feature, refactoring: reliable code execution/);
+            assert.match(installedText, /interrogate reviewers: independent adversarial review/);
+            assert.match(installedText, /alwaysApply: true/);
+            assert.match(installedText, /replaces the fixed model defaults in pstack skills/);
+            assert.match(installedText, /Run the installed selector once for each agent/);
+            assert.equal(readFileSync(cursorPath, 'utf8'), installedText);
+            assert.equal(isAllowedInstallDestination(sharedPath, resolution), true);
+            assert.equal(existsSync(selectorPath), true);
+
+            const savedPreferences = JSON.parse(readFileSync(preferencesPath, 'utf8'));
+            assert.deepEqual(savedPreferences, {
+                host: 'codex',
+                modelsByRole: {
+                    'feature, refactoring': ['gpt-5.6-sol'],
+                    'bug-fix': ['gpt-5.6-sol'],
+                    'perf-issue': ['gpt-6-astra'],
+                    hillclimb: ['gpt-6-astra'],
+                    'judgment and prose': ['gpt-6-astra'],
+                    'hardest tasks': ['gpt-6-astra'],
+                    'how explorer': ['gpt-5.6-terra'],
+                    'how explainer': ['gpt-5.6-sol'],
+                    'how critics': ['gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-6-astra'],
+                    'why investigators': ['gpt-5.6-terra'],
+                    'why synthesizer': ['gpt-6-astra'],
+                    'reflect tooling': ['gpt-5.6-sol'],
+                    'reflect judgment, divergent, synthesizer': ['gpt-6-astra'],
+                    'arena runners': ['gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-6-astra'],
+                    'arena cross-judge pool': ['gpt-5.6-sol', 'gpt-6-astra'],
+                    'swarm workers': ['gpt-5.6-luna'],
+                    'architect runners': ['gpt-5.6-sol', 'gpt-6-astra'],
+                    'interrogate reviewers': [
+                        'gpt-5.6-terra',
+                        'gpt-5.6-sol',
+                        'gpt-6-astra',
+                    ],
+                },
+            });
+            for (const role of Object.keys(savedPreferences.modelsByRole)) {
+                assert.equal(installedText.includes(role + ':'), true);
+            }
+            const codexSelection = runSelector(selectorPath, {
+                host: 'codex',
+                inventoryHost: 'codex',
+                role: 'feature, refactoring',
+                delegationIndex: 0,
+                availableModelIds: ['gpt-5.6-sol'],
+                confirmedSuitableModelIds: [],
+                parentFallback: {
+                    isAllowed: false,
+                    hasMaterialCapabilityLoss: false,
+                },
+            });
+            assert.deepEqual(codexSelection.nativeSpawnArguments, {
+                model: 'gpt-5.6-sol',
+            });
+
+            const foreignPreferencesPath = join(
+                resolution.agentsHome,
+                'rules',
+                'pstack-model-preferences.claude.json',
+            );
+            writeFileSync(foreignPreferencesPath, JSON.stringify({
+                host: 'claude',
+                modelsByRole: {
+                    'feature, refactoring': ['confirmed-claude-model'],
+                },
+            }));
+            const foreignSelection = runSelector(selectorPath, {
+                host: 'claude',
+                inventoryHost: 'claude',
+                role: 'feature, refactoring',
+                delegationIndex: 0,
+                availableModelIds: ['confirmed-claude-model'],
+                confirmedSuitableModelIds: [],
+                parentFallback: {
+                    isAllowed: false,
+                    hasMaterialCapabilityLoss: false,
+                },
+            });
+            assert.deepEqual(foreignSelection.nativeSpawnArguments, {
+                model: 'confirmed-claude-model',
+            });
+
+            const manifest = JSON.parse(readFileSync(resolution.manifestFilePath, 'utf8'));
+            assert.equal(manifest.files.includes(sharedPath), true);
+            assert.equal(manifest.files.includes(managedSelectorPath), true);
+            assert.equal(manifest.files.includes(preferencesPath), false);
+            assert.equal(manifest.files.includes(foreignPreferencesPath), false);
+
+            writeFileSync(sharedPath, 'stale');
+            writeFileSync(preferencesPath, JSON.stringify({
+                host: 'codex',
+                modelsByRole: {
+                    'feature, refactoring': ['user-edited-codex-model'],
+                },
+            }));
+            runInstaller(homeDirectory, [...targetArguments, '--only', 'core']);
+            assert.equal(readFileSync(sharedPath, 'utf8'), installedText);
+            assert.deepEqual(
+                JSON.parse(readFileSync(preferencesPath, 'utf8'))
+                    .modelsByRole['feature, refactoring'],
+                ['user-edited-codex-model'],
+            );
+            assert.deepEqual(
+                JSON.parse(readFileSync(foreignPreferencesPath, 'utf8'))
+                    .modelsByRole['feature, refactoring'],
+                ['confirmed-claude-model'],
+            );
+
+            const syncArguments = [
+                join(resolution.managedRoot, 'scripts', 'sync_to_cursor.py'),
+                '--claude-root', resolution.managedRoot,
+                '--cursor-root', resolution.cursorInstallDirectory,
+                '--quiet',
+            ];
+            execFileSync('python', syncArguments);
+            execFileSync('python', [...syncArguments, '--check']);
+            assert.equal(readFileSync(cursorPath, 'utf8'), installedText);
+            assert.equal(readFileSync(sharedPath, 'utf8'), installedText);
+            if (targetName) {
+                assert.equal(
+                    existsSync(join(homeDirectory, '.agents', 'rules', 'pstack-models.mdc')),
+                    false,
+                );
+            }
+
+            runInstaller(homeDirectory, [...targetArguments, '--uninstall']);
+            assert.equal(existsSync(sharedPath), false);
+            assert.equal(existsSync(cursorPath), false);
+            assert.equal(existsSync(selectorPath), false);
+            assert.equal(existsSync(preferencesPath), true);
+            assert.equal(existsSync(foreignPreferencesPath), true);
+        } finally {
+            rmSync(homeDirectory, { recursive: true, force: true });
+        }
+    });
+}
+
+test('a blocked shared rule destination rolls back generated Cursor files', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-rollback-'));
+    try {
+        const sharedRulesPath = join(homeDirectory, '.agents', 'rules');
+        mkdirSync(dirname(sharedRulesPath), { recursive: true });
+        writeFileSync(sharedRulesPath, 'keep-existing-file');
+        assert.throws(() => runInstaller(homeDirectory, ['--only', 'core']));
+        assert.equal(readFileSync(sharedRulesPath, 'utf8'), 'keep-existing-file');
+        assert.equal(existsSync(join(homeDirectory, '.cursor', 'rules', 'pstack-models.mdc')), false);
+        assert.equal(existsSync(join(homeDirectory, '.cursor', '.sync-manifest.json')), false);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a failed install rolls back a newly seeded Codex preference file', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-seed-rollback-'));
+    try {
+        const preferencesPath = join(
+            homeDirectory,
+            '.agents',
+            'rules',
+            'pstack-model-preferences.codex.json',
+        );
+        assert.throws(() => runInstaller(
+            homeDirectory,
+            ['--only', 'core'],
+            { CLAUDE_DEV_ENV_INSTALL_FAULT: 'after_file_staging' },
+        ));
+        assert.equal(existsSync(preferencesPath), false);
     } finally {
         rmSync(homeDirectory, { recursive: true, force: true });
     }

package/bin/install.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmSync, rmdirSync, renameSync, realpathSync, lstatSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmSync, rmdirSync, renameSync, realpathSync, lstatSync, constants as filesystemConstants } from 'node:fs';
 import { join, dirname, resolve, relative, basename, isAbsolute, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync, execFileSync, spawnSync } from 'node:child_process';
@@ -26,6 +26,9 @@ import {
     SETTINGS_FILE_NAME,
     CODEX_RULES_PACKAGE_DIRECTORY_NAME,
     CURSOR_SYNC_SCRIPT_FILE_NAME,
+    CURSOR_RULES_DIRECTORY_NAME,
+    PSTACK_MODEL_RULE_FILE_NAME,
+    PSTACK_CODEX_MODEL_PREFERENCES_FILE_NAME,
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
 } from './install-constants.mjs';
@@ -422,6 +425,31 @@ export function runCursorRuleSync(pythonCommand, scriptPath, claudeRoot, cursorR
     );
 }
 
+function seedCodexPstackPreferences() {
+    const preferenceDirectory = join(AGENTS_HOME, CURSOR_RULES_DIRECTORY_NAME);
+    const preferencePath = join(
+        preferenceDirectory,
+        PSTACK_CODEX_MODEL_PREFERENCES_FILE_NAME,
+    );
+    const preferenceSource = join(
+        PACKAGE_ROOT,
+        'bin',
+        PSTACK_CODEX_MODEL_PREFERENCES_FILE_NAME,
+    );
+    mkdirSync(preferenceDirectory, { recursive: true });
+    try {
+        copyFileSync(
+            preferenceSource,
+            preferencePath,
+            filesystemConstants.COPYFILE_EXCL,
+        );
+        return preferencePath;
+    } catch (copyError) {
+        if (copyError.code === 'EEXIST') return null;
+        throw copyError;
+    }
+}
+
 /**
  * Formats an absolute interpreter path as a settings.json hook command prefix:
  * forward-slash separators, double-quoted when the path contains a space so the
@@ -2130,6 +2158,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     ];
 
     const allInstalledFiles = [];
+    const allUserOwnedPreferencePaths = new Set();
     const summary = {};
     for (const directory of CONTENT_DIRECTORIES) {
         const hasFullAccess = !allowedDirectories || allowedDirectories.has(directory);
@@ -2237,6 +2266,20 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         const generatedCursorPaths = collectManagedCursorSyncPaths(cursorRoot);
         allInstalledFiles.push(...generatedCursorPaths);
         summary.cursorRules = { created: generatedCursorPaths.length, updated: 0, paths: generatedCursorPaths };
+        syncWrittenPaths(allInstalledFiles);
+        const pstackRuleSource = join(INSTALL_ROOT_RESOLUTION.cursorRulesInstallDirectory, PSTACK_MODEL_RULE_FILE_NAME);
+        const sharedRuleDirectory = join(AGENTS_HOME, CURSOR_RULES_DIRECTORY_NAME);
+        const sharedRulePath = join(sharedRuleDirectory, PSTACK_MODEL_RULE_FILE_NAME);
+        mkdirSync(sharedRuleDirectory, { recursive: true });
+        copyFileSync(pstackRuleSource, sharedRulePath);
+        allInstalledFiles.push(sharedRulePath);
+        syncWrittenPaths(allInstalledFiles);
+        const seededPreferencePath = seedCodexPstackPreferences();
+        if (seededPreferencePath) {
+            allInstalledFiles.push(seededPreferencePath);
+            allUserOwnedPreferencePaths.add(seededPreferencePath);
+        }
+        syncWrittenPaths(allInstalledFiles);
     }
     let skillsCreated = 0;
     let skillsUpdated = 0;
@@ -2420,9 +2463,12 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     const manifestSkillNames = didPruneFinish
         ? [...installedSkillNames].sort()
         : unionOfSkillNames(priorManifestSkills || [], [...installedSkillNames]).sort();
+    const allManagedInstalledFiles = allInstalledFiles.filter(
+        eachPath => !allUserOwnedPreferencePaths.has(eachPath),
+    );
     const manifestFiles = didPruneFinish
-        ? manifestFilesWithFailedPrunes(allInstalledFiles, failedPrunePaths)
-        : unionOnComparisonKey(priorManifestFiles || [], allInstalledFiles);
+        ? manifestFilesWithFailedPrunes(allManagedInstalledFiles, failedPrunePaths)
+        : unionOnComparisonKey(priorManifestFiles || [], allManagedInstalledFiles);
     const managedPermissionDenyEntries = summary.managedPermissions.managedDenyEntries;
     writeManifest(
         manifestFiles,

package/bin/pstack-model-preferences.codex.json

@@ -0,0 +1,23 @@
+{
+    "host": "codex",
+    "modelsByRole": {
+        "feature, refactoring": ["gpt-5.6-sol"],
+        "bug-fix": ["gpt-5.6-sol"],
+        "perf-issue": ["gpt-6-astra"],
+        "hillclimb": ["gpt-6-astra"],
+        "judgment and prose": ["gpt-6-astra"],
+        "hardest tasks": ["gpt-6-astra"],
+        "how explorer": ["gpt-5.6-terra"],
+        "how explainer": ["gpt-5.6-sol"],
+        "how critics": ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-6-astra"],
+        "why investigators": ["gpt-5.6-terra"],
+        "why synthesizer": ["gpt-6-astra"],
+        "reflect tooling": ["gpt-5.6-sol"],
+        "reflect judgment, divergent, synthesizer": ["gpt-6-astra"],
+        "arena runners": ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-6-astra"],
+        "arena cross-judge pool": ["gpt-5.6-sol", "gpt-6-astra"],
+        "swarm workers": ["gpt-5.6-luna"],
+        "architect runners": ["gpt-5.6-sol", "gpt-6-astra"],
+        "interrogate reviewers": ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-6-astra"]
+    }
+}