claude-dev-env 7.6.0 → 7.7.0

package/_shared/advisor/scripts/tests/test_codex_astra_advisor.py

@@ -1,12 +1,13 @@
 """Behavioral tests for the executable Codex Astra advisor path."""
-import io
 import importlib.util
+import io
 import json
 import subprocess
 import sys
 from collections.abc import Callable
 from pathlib import Path
 from types import ModuleType
+
 import pytest
 
 _ProcessRunner = Callable[..., subprocess.CompletedProcess[str]]
@@ -28,6 +29,7 @@ def _load_astra_module() -> ModuleType:
 
 
 astra_advisor = _load_astra_module()
+
 SCRIPTS_ROOT = Path(__file__).parent.parent
 USAGE_PROBE_PATH = (
     SCRIPTS_ROOT.parents[1] / "pr-loop" / "scripts" / "codex_usage_probe.py"
@@ -87,7 +89,37 @@ def test_astra_flag_rejects_legacy_sol_setting() -> None:
 
 def test_resolve_advisor_effort_uses_shared_setting_and_default() -> None:
     assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "HIGH"}) == "high"
-    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "unknown"}) == "low"
+    with pytest.raises(RuntimeError, match="effort is unknown"):
+        astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "unknown"})
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "Light"}) == "low"
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "XHIGH"}) == "medium"
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "MAX"}) == "medium"
+
+
+def test_advisor_route_uses_edited_policy_model_and_effort(tmp_path: Path) -> None:
+    policy = json.loads(
+        (SCRIPTS_ROOT.parents[2] / "rules" / "subagent-model-policy.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    for each_entry in policy["roleReplacements"]:
+        if (
+            each_entry["role"] == "advisor"
+            and each_entry["requested"] == {"model": "astra", "effort": "xhigh"}
+        ):
+            each_entry["selected"] = {"model": "luna", "effort": "high"}
+    policy_path = tmp_path / "subagent-model-policy.json"
+    policy_path.write_text(json.dumps(policy), encoding="utf-8")
+    assert astra_advisor.resolve_advisor_pair(
+        {"ADVISOR_EFFORT": "xhigh"}, policy_path
+    ) == ("gpt-5.6-luna", "high")
+
+
+def test_advisor_route_blocks_malformed_policy(tmp_path: Path) -> None:
+    policy_path = tmp_path / "subagent-model-policy.json"
+    policy_path.write_text('{"schemaVersion": 1}', encoding="utf-8")
+    with pytest.raises(RuntimeError, match="models must be an object"):
+        astra_advisor.resolve_advisor_pair({}, policy_path)
 
 
 def test_resolve_codex_executable_prefers_override_and_falls_back_to_path(
@@ -118,6 +150,7 @@ def test_argument_parser_accepts_astra_and_rejects_sol() -> None:
     parser = astra_advisor.build_argument_parser()
     parsed = parser.parse_args(["--bind", "--cwd", ".", "--enable-astra"])
     assert parsed.is_astra_requested
+    assert parser.parse_args(["--bind", "--cwd", ".", "--effort", "light"]).astra_effort == "light"
     with pytest.raises(SystemExit):
         parser.parse_args(["--bind", "--cwd", ".", "--enable-sol"])
 
@@ -190,6 +223,23 @@ def test_bind_runs_probe_then_codex() -> None:
     assert calls[1] == astra_advisor.build_codex_arguments("codex")
 
 
+def test_bind_routes_astra_xhigh_to_the_policy_effort() -> None:
+    calls: list[list[str]] = []
+    settings = {**ENABLED_SETTINGS, astra_advisor.ADVISOR_EFFORT_ENV_VAR: "xhigh"}
+    reply = astra_advisor.run_codex_astra_advisor(
+        "consult",
+        Path("."),
+        None,
+        USAGE_PROBE_PATH,
+        settings,
+        None,
+        _two_step_runner(calls),
+    )
+    assert reply.successful
+    config_index = calls[1].index("--config")
+    assert calls[1][config_index + 1] == 'model_reasoning_effort="medium"'
+
+
 def test_disabled_flag_returns_declined_fallback() -> None:
     reply = astra_advisor.run_codex_astra_advisor(
         "consult",

package/bin/install-constants.mjs

@@ -56,6 +56,7 @@ 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 SUBAGENT_MODEL_POLICY_FILE_NAME = 'subagent-model-policy.json';
 export const PSTACK_SEEDED_MODEL_PREFERENCES_FILE_NAMES = Object.freeze([
     'pstack-model-preferences.claude.json',
     'pstack-model-preferences.codex.json',
@@ -181,3 +182,5 @@ export const WINDOWS_PYTHON_LAUNCHER_COMMAND = 'py -3';
  * Maximum time each Python interpreter probe may run during detection.
  */
 export const PYTHON_PROBE_TIMEOUT_MILLISECONDS = 10_000;
+export const ADDITIONAL_SETTINGS_BLOB_PREFIX = 'settings-';
+export const CODEX_NATIVE_ROUTING_MATCHER = 'multi_agent_v1__spawn_agent';

package/bin/install-session-continuity.mjs

@@ -44,41 +44,84 @@ export function mergeContinuityHooks(existing, host, script) {
     return mergedConfiguration;
 }
 
-async function main() {
-    const requested = process.argv.slice(2);
-    const selected = requested.length ? requested : supportedHosts;
+export const CONTINUITY_SCRIPT_MARKER = '/session-continuity/continuity.mjs';
+
+export function isContinuityHookCommand(command) {
+    return typeof command === 'string' && command.includes(CONTINUITY_SCRIPT_MARKER);
+}
+
+export function continuityScriptPath(roots) {
+    return join(roots.skillsInstallDirectory, 'session-continuity', 'continuity.mjs');
+}
+
+export function continuityHostConfigurationPaths(roots) {
+    return {
+        claude: join(roots.managedRoot, 'settings.json'),
+        codex: join(dirname(roots.codexRulesInstallDirectory), 'hooks.json'),
+        cursor: join(roots.cursorInstallDirectory, 'hooks.json'),
+    };
+}
+
+export function removeContinuityHooks(configuration) {
+    let removedCount = 0;
+    for (const [event, entries] of Object.entries(configuration.hooks || {})) {
+        const kept = entries.flatMap(entry => {
+            if (!entry.hooks) {
+                if (!isContinuityHookCommand(entry.command)) return [entry];
+                removedCount += 1;
+                return [];
+            }
+            const hooks = entry.hooks.filter(hook => !isContinuityHookCommand(hook.command));
+            removedCount += entry.hooks.length - hooks.length;
+            return hooks.length ? [{ ...entry, hooks }] : [];
+        });
+        if (kept.length) configuration.hooks[event] = kept;
+        else delete configuration.hooks[event];
+    }
+    return removedCount;
+}
+
+function continuityConfigurationPlan(host, path, script) {
+    if (!existsSync(dirname(path))) throw new Error(`Host config directory is absent: ${dirname(path)}`);
+    const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
+    const merged = mergeContinuityHooks(existing ? JSON.parse(existing) : {}, host, script);
+    return { host, path, existing, content: JSON.stringify(merged, null, 2) + '\n' };
+}
+
+function applyContinuityConfigurationPlan(plan) {
+    if (plan.existing === plan.content) return { host: plan.host, path: plan.path, changed: false };
+    if (plan.existing !== null) {
+        const backup = `${plan.path}.before-session-continuity`;
+        if (!existsSync(backup)) writeFileSync(backup, plan.existing, { flag: 'wx', mode: 0o600 });
+    }
+    const current = existsSync(plan.path) ? readFileSync(plan.path, 'utf8') : null;
+    if (current !== plan.existing) throw new Error(`Config changed during setup: ${plan.path}. Rerun setup.`);
+    const temporary = `${plan.path}.continuity-${process.pid}.tmp`;
+    writeFileSync(temporary, plan.content, { flag: 'wx', mode: 0o600 });
+    renameSync(temporary, plan.path);
+    if (readFileSync(plan.path, 'utf8') !== plan.content) throw new Error(`Config read-back mismatch: ${plan.path}`);
+    return { host: plan.host, path: plan.path, changed: true };
+}
+
+export function configureContinuityHosts(roots, selected) {
     const unsupported = selected.find(host => !supportedHosts.includes(host));
     if (unsupported) throw new Error(`Unsupported host ${unsupported}`);
-    const { resolveInstallRoot } = await import('./resolve-install-root.mjs');
-    const roots = resolveInstallRoot();
-    const script = join(roots.skillsInstallDirectory, 'session-continuity', 'continuity.mjs');
+    const script = continuityScriptPath(roots);
     if (!existsSync(script) || !existsSync(join(dirname(script), 'SKILL.md'))) {
         throw new Error('Run the full claude-dev-env installer from this checkout first so the companion is in the canonical agents home.');
     }
-    const paths = {
-        claude: join(roots.managedRoot, 'settings.json'),
-        codex: join(dirname(roots.codexRulesInstallDirectory), 'hooks.json'),
-        cursor: join(roots.cursorInstallDirectory, 'hooks.json'),
-    };
-    const plans = selected.map(host => {
-        const path = paths[host];
-        if (!existsSync(dirname(path))) throw new Error(`Host config directory is absent: ${dirname(path)}`);
-        const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
-        return { path, existing, content: JSON.stringify(mergeContinuityHooks(existing ? JSON.parse(existing) : {}, host, script), null, 2) + '\n' };
-    });
-    for (const plan of plans) {
-        if (plan.existing === plan.content) { console.log(`Already configured: ${plan.path}`); continue; }
-        if (plan.existing !== null) {
-            const backup = `${plan.path}.before-session-continuity`;
-            if (!existsSync(backup)) writeFileSync(backup, plan.existing, { flag: 'wx', mode: 0o600 });
-        }
-        const current = existsSync(plan.path) ? readFileSync(plan.path, 'utf8') : null;
-        if (current !== plan.existing) throw new Error(`Config changed during setup: ${plan.path}. Rerun setup.`);
-        const temporary = `${plan.path}.continuity-${process.pid}.tmp`;
-        writeFileSync(temporary, plan.content, { flag: 'wx', mode: 0o600 });
-        renameSync(temporary, plan.path);
-        if (readFileSync(plan.path, 'utf8') !== plan.content) throw new Error(`Config read-back mismatch: ${plan.path}`);
-        console.log(`Configured and read back: ${plan.path}`);
+    const paths = continuityHostConfigurationPaths(roots);
+    return selected
+        .map(host => continuityConfigurationPlan(host, paths[host], script))
+        .map(applyContinuityConfigurationPlan);
+}
+
+async function main() {
+    const requested = process.argv.slice(2);
+    const selected = requested.length ? requested : supportedHosts;
+    const { resolveInstallRoot } = await import('./resolve-install-root.mjs');
+    for (const result of configureContinuityHosts(resolveInstallRoot(), selected)) {
+        console.log(`${result.changed ? 'Configured and read back' : 'Already configured'}: ${result.path}`);
     }
     console.log('Review and trust the new hooks in each host.');
 }

package/bin/install-session-continuity.test.mjs

@@ -1,6 +1,30 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { continuityHookConfiguration, mergeContinuityHooks } from './install-session-continuity.mjs';
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    configureContinuityHosts,
+    continuityHookConfiguration,
+    mergeContinuityHooks,
+    removeContinuityHooks,
+} from './install-session-continuity.mjs';
+
+function installRootFixture() {
+    const root = mkdtempSync(join(tmpdir(), 'continuity-roots-'));
+    const skillsInstallDirectory = join(root, 'agents', 'skills');
+    const companionDirectory = join(skillsInstallDirectory, 'session-continuity');
+    mkdirSync(companionDirectory, { recursive: true });
+    writeFileSync(join(companionDirectory, 'continuity.mjs'), 'export default null;\n');
+    writeFileSync(join(companionDirectory, 'SKILL.md'), '# companion\n');
+    const managedRoot = join(root, 'claude');
+    const codexRulesInstallDirectory = join(root, 'codex', 'rules');
+    const cursorInstallDirectory = join(root, 'cursor');
+    for (const directory of [managedRoot, codexRulesInstallDirectory, cursorInstallDirectory]) {
+        mkdirSync(directory, { recursive: true });
+    }
+    return { managedRoot, skillsInstallDirectory, codexRulesInstallDirectory, cursorInstallDirectory };
+}
 
 test('setup preserves other hooks and settings, is idempotent, and rejects competing profiles', () => {
     const existing = { permissions: { deny: ['secret'] }, hooks: { SessionStart: [{ hooks: [{ type: 'command', command: 'existing-hook' }] }] } };
@@ -53,3 +77,30 @@ for (const host of ['claude', 'codex']) {
         }
     });
 }
+
+test('configureContinuityHosts writes each host config, reads it back, and repeats without a change', () => {
+    const roots = installRootFixture();
+    const settingsPath = join(roots.managedRoot, 'settings.json');
+    writeFileSync(settingsPath, JSON.stringify({ permissions: { deny: ['secret'] } }, null, 2) + '\n');
+    const first = configureContinuityHosts(roots, ['claude', 'codex', 'cursor']);
+    assert.deepEqual(first.map(result => result.changed), [true, true, true]);
+    const written = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    assert.deepEqual(written.permissions.deny, ['secret']);
+    const command = written.hooks.SessionStart[0].hooks[0].command;
+    assert.equal(command.endsWith('session-continuity/continuity.mjs" hook claude'), true);
+    const second = configureContinuityHosts(roots, ['claude', 'codex', 'cursor']);
+    assert.deepEqual(second.map(result => result.changed), [false, false, false]);
+});
+
+test('removeContinuityHooks takes out only the companion registrations', () => {
+    const roots = installRootFixture();
+    configureContinuityHosts(roots, ['claude']);
+    const settingsPath = join(roots.managedRoot, 'settings.json');
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    settings.hooks.SessionStart.unshift({ hooks: [{ type: 'command', command: 'python other_hook.py' }] });
+    const removedCount = removeContinuityHooks(settings);
+    assert.equal(removedCount, 3);
+    assert.deepEqual(Object.keys(settings.hooks), ['SessionStart']);
+    assert.equal(settings.hooks.SessionStart.length, 1);
+    assert.equal(settings.hooks.SessionStart[0].hooks[0].command, 'python other_hook.py');
+});

package/bin/install-transaction.mjs

@@ -30,6 +30,7 @@ import {
 } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { ADDITIONAL_SETTINGS_BLOB_PREFIX } from './install-constants.mjs';
 
 /** Env var that forces a throw after a named mutation phase (tests only). */
 export const INSTALL_FAULT_ENV = 'CLAUDE_DEV_ENV_INSTALL_FAULT';
@@ -180,19 +181,6 @@ function classifyPath(absolutePath, io) {
     return { kind: ENTRY_KIND_MISSING };
 }
 
-/**
- * Capture prior settings, manifest, hooksPath, and package-owned files.
- *
- * @param {{
- *   managedRoot: string,
- *   manifestFilePath: string,
- *   settingsPath: string,
- *   priorManifestFiles?: string[]|null,
- *   journalParentDirectory?: string,
- *   io?: object,
- * }} input
- * @returns {object}
- */
 export function capturePriorInstallSnapshot(input) {
     const io = input.io || {};
     const exists = io.existsSync || existsSync;
@@ -208,10 +196,23 @@ export function capturePriorInstallSnapshot(input) {
     const filesDirectory = join(journalRoot, FILES_DIRECTORY_NAME);
     mkdir(filesDirectory, { recursive: true });
 
-    const settingsExisted = exists(input.settingsPath);
-    if (settingsExisted) {
-        copyFile(input.settingsPath, join(journalRoot, SETTINGS_BLOB_NAME));
-    }
+    const allSettingsPaths = [
+        input.settingsPath,
+        ...(Array.isArray(input.additionalSettingsPaths) ? input.additionalSettingsPaths : []),
+    ].filter((eachPath, index, allPaths) => (
+        typeof eachPath === 'string'
+        && eachPath !== ''
+        && allPaths.indexOf(eachPath) === index
+    ));
+    const settingsSnapshots = allSettingsPaths.map((settingsPath, index) => {
+        const settingsExisted = exists(settingsPath);
+        const blobName = index === 0
+            ? SETTINGS_BLOB_NAME
+            : `${ADDITIONAL_SETTINGS_BLOB_PREFIX}${index}.json`;
+        if (settingsExisted) copyFile(settingsPath, join(journalRoot, blobName));
+        return { path: settingsPath, existed: settingsExisted, blobName };
+    });
+    const primarySettingsSnapshot = settingsSnapshots[0];
 
     const manifestExisted = exists(input.manifestFilePath);
     if (manifestExisted) {
@@ -255,7 +256,8 @@ export function capturePriorInstallSnapshot(input) {
         managedRoot: input.managedRoot,
         settingsPath: input.settingsPath,
         manifestFilePath: input.manifestFilePath,
-        settingsExisted,
+        settingsSnapshots,
+        settingsExisted: primarySettingsSnapshot?.existed ?? false,
         manifestExisted,
         priorHooksPath,
         allFileEntries,
@@ -267,23 +269,14 @@ export function capturePriorInstallSnapshot(input) {
         managedRoot: input.managedRoot,
         settingsPath: input.settingsPath,
         manifestFilePath: input.manifestFilePath,
-        settingsExisted,
+        settingsSnapshots: Object.freeze(settingsSnapshots.map(eachSnapshot => Object.freeze(eachSnapshot))),
+        settingsExisted: primarySettingsSnapshot?.existed ?? false,
         manifestExisted,
         priorHooksPath,
         allFileEntries: Object.freeze(allFileEntries.map((eachEntry) => Object.freeze({ ...eachEntry }))),
     });
 }
 
-/**
- * Restore the captured prior installation and drop extra write-set paths.
- *
- * @param {ReturnType<typeof capturePriorInstallSnapshot>} snapshot
- * @param {{
- *   allWrittenPaths?: string[],
- *   io?: object,
- * }} [options]
- * @returns {void}
- */
 export function restorePriorInstallSnapshot(snapshot, options = {}) {
     const io = options.io || {};
     const exists = io.existsSync || existsSync;
@@ -294,6 +287,13 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
     const lstat = io.lstatSync || lstatSync;
 
     const filesDirectory = join(snapshot.journalRoot, FILES_DIRECTORY_NAME);
+    const settingsSnapshots = snapshot.settingsSnapshots?.length > 0
+        ? snapshot.settingsSnapshots
+        : [{
+            path: snapshot.settingsPath,
+            existed: snapshot.settingsExisted,
+            blobName: SETTINGS_BLOB_NAME,
+        }];
     for (const eachEntry of snapshot.allFileEntries) {
         try {
             if (exists(eachEntry.absolutePath)) {
@@ -302,9 +302,7 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
                     unlink(eachEntry.absolutePath);
                 }
             }
-        } catch {
-            // keep restoring remaining entries
-        }
+        } catch {}
         if (eachEntry.kind === ENTRY_KIND_FILE && eachEntry.blobName) {
             mkdir(dirname(eachEntry.absolutePath), { recursive: true });
             copyFile(join(filesDirectory, eachEntry.blobName), eachEntry.absolutePath);
@@ -324,7 +322,8 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
         if (priorPathSet.has(eachWrittenPath)) {
             continue;
         }
-        if (eachWrittenPath === snapshot.settingsPath || eachWrittenPath === snapshot.manifestFilePath) {
+        if (settingsSnapshots.some(eachSnapshot => eachSnapshot.path === eachWrittenPath)
+            || eachWrittenPath === snapshot.manifestFilePath) {
             continue;
         }
         try {
@@ -339,14 +338,14 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
         }
     }
 
-    if (snapshot.settingsExisted) {
-        mkdir(dirname(snapshot.settingsPath), { recursive: true });
-        copyFile(join(snapshot.journalRoot, SETTINGS_BLOB_NAME), snapshot.settingsPath);
-    } else if (exists(snapshot.settingsPath)) {
-        try {
-            unlink(snapshot.settingsPath);
-        } catch {
-            // leave in place when unlink fails
+    for (const eachSnapshot of settingsSnapshots) {
+        if (eachSnapshot.existed) {
+            mkdir(dirname(eachSnapshot.path), { recursive: true });
+            copyFile(join(snapshot.journalRoot, eachSnapshot.blobName), eachSnapshot.path);
+        } else if (exists(eachSnapshot.path)) {
+            try {
+                unlink(eachSnapshot.path);
+            } catch {}
         }
     }
 
@@ -356,9 +355,7 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
     } else if (exists(snapshot.manifestFilePath)) {
         try {
             unlink(snapshot.manifestFilePath);
-        } catch {
-            // leave in place when unlink fails
-        }
+        } catch {}
     }
 
     writeGlobalCoreHooksPath(snapshot.priorHooksPath, io);