claude-dev-env 8.38.0 → 8.38.2

package/bin/install.mjs

@@ -1319,7 +1319,9 @@ function managedPackageSourceRoots() {
  * @param {Set<string>} managedHookRelativePaths Managed script paths under hooks/.
  * @returns {boolean} True when the command references a managed script.
  */
-export function commandReferencesManagedHook(commandString, managedHookRelativePaths) {
+export function commandReferencesManagedHook(
+    commandString, managedHookRelativePaths, sharedSettingsRealPath = null,
+) {
     if (typeof commandString !== 'string') return false;
     const normalizedCommand = commandString.replace(/\\/g, '/');
     if (commandIsInlineManagedValidatorRunner(normalizedCommand)) {
@@ -1329,6 +1331,51 @@ export function commandReferencesManagedHook(commandString, managedHookRelativeP
         if (commandTailEndsAtManagedHook(normalizedCommand, relativePath)) {
             return true;
         }
+        if (
+            sharedSettingsRealPath
+            && commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, sharedSettingsRealPath)
+        ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Report whether a command runs `<root>/hooks/<relative>` for a root whose
+ * settings.json resolves to the given settings file.
+ *
+ * Two install roots can share one settings.json through a symlink. Each install
+ * writes its own hooks directory into that one file, so the merge treats the
+ * hooks of every root that shares the file as managed and keeps one entry per
+ * script.
+ *
+ * @param {string} normalizedCommand Forward-slash-normalized hook command.
+ * @param {string} relativePath The managed script path under hooks/.
+ * @param {string} sharedSettingsRealPath The resolved path of the settings file being merged.
+ * @returns {boolean} True when the command runs that script under a sharing root.
+ */
+function commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, sharedSettingsRealPath) {
+    const commandArgumentBoundary = /[\s'";]/;
+    const hookPathTail = `/${MANAGED_HOOKS_DIRECTORY_NAME}/${relativePath}`;
+    const sharedSettingsKey = comparisonKeyForPath(sharedSettingsRealPath);
+    let tailStart = normalizedCommand.indexOf(hookPathTail);
+    while (tailStart !== -1) {
+        const characterAfterPath = normalizedCommand[tailStart + hookPathTail.length];
+        if (characterAfterPath === undefined || commandArgumentBoundary.test(characterAfterPath)) {
+            let rootStart = tailStart;
+            while (rootStart > 0 && !commandArgumentBoundary.test(normalizedCommand[rootStart - 1])) {
+                rootStart--;
+            }
+            const rootPath = normalizedCommand.slice(rootStart, tailStart);
+            const rootSettingsRealPath = rootPath
+                ? realPathOrNull(join(rootPath, SETTINGS_FILE_NAME))
+                : null;
+            if (rootSettingsRealPath && comparisonKeyForPath(rootSettingsRealPath) === sharedSettingsKey) {
+                return true;
+            }
+        }
+        tailStart = normalizedCommand.indexOf(hookPathTail, tailStart + 1);
     }
     return false;
 }
@@ -1399,14 +1446,17 @@ export function commandIsInlineManagedValidatorRunner(normalizedCommand) {
  * @param {object} settings The parsed settings.json object (mutated in place).
  * @param {string} eventType The lifecycle event whose groups are pruned.
  * @param {Set<string>} managedHookRelativePaths Managed script paths under hooks/.
+ * @param {string|null} sharedSettingsRealPath Resolved path of the settings file, or null.
  * @returns {void}
  */
-function pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths) {
+function pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths, sharedSettingsRealPath) {
     const existingGroups = settings.hooks[eventType];
     if (!Array.isArray(existingGroups)) return;
     settings.hooks[eventType] = retainedMatcherGroups(
         existingGroups,
-        commandString => commandReferencesManagedHook(commandString, managedHookRelativePaths),
+        commandString => commandReferencesManagedHook(
+            commandString, managedHookRelativePaths, sharedSettingsRealPath,
+        ),
     ).keptGroups;
 }
 
@@ -1457,9 +1507,14 @@ function startEventFromHookGroupList(settings, eventType) {
  * @param {string} pluginRootDir Directory ${CLAUDE_PLUGIN_ROOT} resolves to
  *   (the installer's `~/.claude` root; home is its parent directory).
  * @param {string} pythonCommand Interpreter command that replaces python3.
+ * @param {string|null} [sharedSettingsRealPath] Resolved path of the settings
+ *   file being merged. Hooks of every root whose settings.json resolves to it
+ *   count as managed, so roots sharing one file keep one entry per script.
  * @returns {number} Count of matcher groups merged.
  */
-export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand) {
+export function mergeHooksIntoSettings(
+    settings, hooksConfig, pluginRootDir, pythonCommand, sharedSettingsRealPath = null,
+) {
     const managedHookRelativePaths = managedHookScriptRelativePaths(hooksConfig);
     const pluginRootForward = pluginRootDir.replace(/\\/g, '/');
     const encodedPluginHooksPath = Buffer.from(`${pluginRootForward}/hooks`, 'utf8').toString('base64');
@@ -1467,7 +1522,7 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
     let groupCount = 0;
     for (const [eventType, matcherGroups] of Object.entries(hooksConfig.hooks)) {
         startEventFromHookGroupList(settings, eventType);
-        pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths);
+        pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths, sharedSettingsRealPath);
         for (const sourceGroup of matcherGroups) {
             const rewrittenHooks = sourceGroup.hooks.map(hook => {
                 let command = hook.command;
@@ -1492,7 +1547,9 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
             if (existingIndex >= 0) {
                 const existing = settings.hooks[eventType][existingIndex];
                 const userHooks = (groupHookEntries(existing) || []).filter(
-                    hook => !commandReferencesManagedHook(hook?.command, managedHookRelativePaths)
+                    hook => !commandReferencesManagedHook(
+                        hook?.command, managedHookRelativePaths, sharedSettingsRealPath,
+                    )
                 );
                 settings.hooks[eventType][existingIndex] = {
                     ...existing,
@@ -2079,7 +2136,9 @@ function mergeHooksAtPath(
         pruneManagedHooksFromSettings(settings, new Set());
     }
     const hooksConfig = selectHooksConfig(sourceHooksConfig);
-    const groupCount = mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand);
+    const groupCount = mergeHooksIntoSettings(
+        settings, hooksConfig, pluginRootDir, pythonCommand, realPathOrNull(settingsPath),
+    );
     writeFileSync(settingsPath, JSON.stringify(settings, null, indentation) + '\n');
     return groupCount;
 }

package/bin/install.shared-settings.test.mjs

@@ -0,0 +1,202 @@
+/**
+ * Two install roots that share one settings.json through a symlink keep one
+ * hook entry per managed script, whatever order the roots install in.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { join } from 'node:path';
+import {
+    mkdtempSync,
+    mkdirSync,
+    readFileSync,
+    rmSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { managedHookScriptRelativePaths, mergeHooksIntoSettings } from './install.mjs';
+
+const INSTALLER_PATH = fileURLToPath(new URL('./install.mjs', import.meta.url));
+const PACKAGE_HOOKS_JSON_PATH = fileURLToPath(new URL('../hooks/hooks.json', import.meta.url));
+
+function installEnvironment(homeDirectory) {
+    return {
+        ...process.env,
+        HOME: homeDirectory,
+        USERPROFILE: homeDirectory,
+        CLAUDE_CONFIG_DIR: '',
+        GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_USAGE_WRAPUP: '0',
+    };
+}
+
+function runCoreInstall(homeDirectory, extraArguments) {
+    const installRun = spawnSync(
+        process.execPath,
+        [INSTALLER_PATH, '--only', 'core', ...extraArguments],
+        { encoding: 'utf8', env: installEnvironment(homeDirectory) },
+    );
+    assert.equal(installRun.status, 0, installRun.stdout + installRun.stderr);
+}
+
+function allHookCommands(settingsPath) {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const allCommands = [];
+    for (const matcherGroups of Object.values(settings.hooks ?? {})) {
+        for (const group of matcherGroups) {
+            for (const hook of group.hooks ?? []) {
+                if (typeof hook.command === 'string') allCommands.push(hook.command.replace(/\\/g, '/'));
+            }
+        }
+    }
+    return allCommands;
+}
+
+function entryCountByScript(settingsPath) {
+    const hooksConfig = JSON.parse(readFileSync(PACKAGE_HOOKS_JSON_PATH, 'utf8'));
+    const allCommands = allHookCommands(settingsPath);
+    const countByScript = new Map();
+    for (const relativePath of managedHookScriptRelativePaths(hooksConfig)) {
+        const scriptPattern = new RegExp(`/hooks/${relativePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=$|[\\s'";])`, 'g');
+        const occurrences = allCommands.reduce(
+            (total, command) => total + (command.match(scriptPattern) ?? []).length,
+            0,
+        );
+        countByScript.set(relativePath, occurrences);
+    }
+    return countByScript;
+}
+
+function expectedCountByScript(hooksConfig) {
+    const countByScript = new Map();
+    for (const matcherGroups of Object.values(hooksConfig.hooks)) {
+        for (const group of matcherGroups) {
+            for (const hook of group.hooks) {
+                for (const match of hook.command.matchAll(/\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\/(\S+?\.(?:py|mjs))/g)) {
+                    countByScript.set(match[1], (countByScript.get(match[1]) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    return countByScript;
+}
+
+function assertOneEntryPerHookRegistration(settingsPath, stageName) {
+    const hooksConfig = JSON.parse(readFileSync(PACKAGE_HOOKS_JSON_PATH, 'utf8'));
+    const expectedCounts = expectedCountByScript(hooksConfig);
+    const actualCounts = entryCountByScript(settingsPath);
+    assert.ok(expectedCounts.size > 0, 'the package ships managed hook scripts');
+    for (const [relativePath, expectedCount] of expectedCounts) {
+        assert.equal(
+            actualCounts.get(relativePath),
+            expectedCount,
+            `${stageName}: ${relativePath} is registered once per hooks.json entry`,
+        );
+    }
+}
+
+function withSharedSettingsHome(runScenario) {
+    return t => {
+        const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-'));
+        try {
+            writeFileSync(join(homeDirectory, '.gitconfig'), '');
+            const mainRoot = join(homeDirectory, '.claude');
+            const profileRoot = join(homeDirectory, 'profiles', 'second');
+            mkdirSync(mainRoot, { recursive: true });
+            mkdirSync(profileRoot, { recursive: true });
+            const mainSettingsPath = join(mainRoot, 'settings.json');
+            writeFileSync(mainSettingsPath, '{}\n');
+            try {
+                symlinkSync(mainSettingsPath, join(profileRoot, 'settings.json'), 'file');
+            } catch (linkError) {
+                t.skip(`this host cannot create a file symlink (${linkError.code})`);
+                return;
+            }
+            runScenario({ homeDirectory, profileRoot, mainSettingsPath });
+        } finally {
+            rmSync(homeDirectory, { recursive: true, force: true });
+        }
+    };
+}
+
+test(
+    'main then profile then main keeps one entry per hook in the shared settings file',
+    withSharedSettingsHome(({ homeDirectory, profileRoot, mainSettingsPath }) => {
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main install');
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile install');
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main rerun');
+    }),
+);
+
+test(
+    'profile then main then profile keeps one entry per hook in the shared settings file',
+    withSharedSettingsHome(({ homeDirectory, profileRoot, mainSettingsPath }) => {
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile install');
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main install');
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile rerun');
+    }),
+);
+
+test('the merge prunes a hook of a root sharing the settings file and keeps one with its own file', t => {
+    const sandboxRoot = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-unit-'));
+    try {
+        const installRoot = join(sandboxRoot, 'install-root');
+        const sharingRoot = join(sandboxRoot, 'sharing-root');
+        const separateRoot = join(sandboxRoot, 'separate-root');
+        for (const eachRoot of [installRoot, sharingRoot, separateRoot]) mkdirSync(eachRoot, { recursive: true });
+        const settingsPath = join(installRoot, 'settings.json');
+        writeFileSync(settingsPath, '{}\n');
+        writeFileSync(join(separateRoot, 'settings.json'), '{}\n');
+        try {
+            symlinkSync(settingsPath, join(sharingRoot, 'settings.json'), 'file');
+        } catch (linkError) {
+            t.skip(`this host cannot create a file symlink (${linkError.code})`);
+            return;
+        }
+        const hooksConfig = {
+            hooks: {
+                SessionStart: [{
+                    matcher: '',
+                    hooks: [{ type: 'command', command: 'python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/start.py' }],
+                }],
+            },
+        };
+        const forwardSlashed = rootPath => rootPath.replace(/\\/g, '/');
+        const sharingCommand = `python3 "${forwardSlashed(sharingRoot)}/hooks/session/start.py"`;
+        const separateCommand = `python3 "${forwardSlashed(separateRoot)}/hooks/session/start.py"`;
+        const settings = {
+            hooks: {
+                SessionStart: [{
+                    matcher: '',
+                    hooks: [
+                        { type: 'command', command: sharingCommand },
+                        { type: 'command', command: separateCommand },
+                    ],
+                }],
+            },
+        };
+
+        mergeHooksIntoSettings(settings, hooksConfig, forwardSlashed(installRoot), 'python3', settingsPath);
+
+        const allCommands = settings.hooks.SessionStart.flatMap(group => group.hooks.map(hook => hook.command));
+        assert.ok(!allCommands.includes(sharingCommand), 'the sharing root entry is pruned');
+        assert.ok(allCommands.includes(separateCommand), 'the separate root entry stays');
+        assert.equal(
+            allCommands.filter(command => command.includes(`${forwardSlashed(installRoot)}/hooks/session/start.py`)).length,
+            1,
+            'the install root entry is written once',
+        );
+    } finally {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+    }
+});

package/docs/account-broker.md

@@ -18,7 +18,7 @@ python scripts/account_broker.py run --product claude --report report.json -- cl
 
 `check` prints nothing and exits 3 while every account is below its floor. `run` sets only `CLAUDE_CONFIG_DIR` or `CODEX_HOME` for each attempt. It replays the same stdin bytes when a usage limit or start failure leads to another account. It writes the command's stdout to stdout and diagnostics to stderr. A resumed Claude session uses the account bound to its session when that account has room.
 
-The broker stores cached meters, spent marks, and Claude session bindings in one JSON file under `~/.claude/account-broker`. State writes use a sibling temporary file and `os.replace`.
+The broker stores cached meters, spent marks, and Claude session bindings in one JSON file under `~/.claude/account-broker`. Every broker process for the same user reads that file, so a spent mark pauses that account for every job. A write holds an exclusive lock on the sibling `state.json.lock`, re-reads the file, merges, and swaps in a sibling temporary file with `os.replace`. The merge keeps the latest reset for each spent mark and the newest meter read for each account.
 
 ## Exit codes and report
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.38.0",
+    "version": "8.38.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/account_broker_support.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import sys
 import tempfile
 import threading
 from contextlib import contextmanager
@@ -12,6 +13,11 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Iterator, Sequence
 
+if sys.platform == "win32":
+    import msvcrt
+else:
+    import fcntl
+
 import codex_account_choice
 import codex_account_meters
 from claude_account_profile import default_profile_home, validate_profile_name
@@ -19,6 +25,7 @@ from claude_chain_usage import WeeklyUtilizationProbeError, probe_account_meters
 from dev_env_scripts_constants.account_broker_constants import (
     BROKER_STATE_DIRECTORY_NAME,
     BROKER_STATE_FILE_NAME,
+    BROKER_STATE_LOCK_SUFFIX,
     BROKER_STATE_TEMP_SUFFIX,
     Account,
     BrokerConfigurationError,
@@ -222,18 +229,79 @@ def _load_state(path: Path) -> dict[str, object]:
     return {key: parsed_state.get(key) if isinstance(parsed_state.get(key), dict) else {} for key in ("meters", "spent", "affinity")}
 
 
-def _save_state(path: Path, all_state: dict[str, object]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary_name: str | None = None
+if sys.platform == "win32":
+
+    def _acquire_state_lock(lock_descriptor: int) -> None:
+        os.lseek(lock_descriptor, 0, os.SEEK_SET)
+        msvcrt.locking(lock_descriptor, msvcrt.LK_LOCK, 1)
+
+    def _release_state_lock(lock_descriptor: int) -> None:
+        os.lseek(lock_descriptor, 0, os.SEEK_SET)
+        msvcrt.locking(lock_descriptor, msvcrt.LK_UNLCK, 1)
+
+else:
+
+    def _acquire_state_lock(lock_descriptor: int) -> None:
+        fcntl.flock(lock_descriptor, fcntl.LOCK_EX)
+
+    def _release_state_lock(lock_descriptor: int) -> None:
+        fcntl.flock(lock_descriptor, fcntl.LOCK_UN)
+
+
+@contextmanager
+def _state_lock(path: Path) -> Iterator[None]:
+    """Hold an exclusive operating-system lock on the state file's sibling lock file."""
+    lock_descriptor = os.open(path.with_name(path.name + BROKER_STATE_LOCK_SUFFIX), os.O_CREAT | os.O_RDWR)
     try:
-        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent, prefix="state-", suffix=BROKER_STATE_TEMP_SUFFIX, delete=False, newline="\n") as stream:
-            temporary_name = stream.name
-            json.dump(all_state, stream, indent=REPORT_INDENT_SPACES, sort_keys=True)
-            stream.write("\n")
-        os.replace(temporary_name, path)
+        _acquire_state_lock(lock_descriptor)
+        try:
+            yield
+        finally:
+            _release_state_lock(lock_descriptor)
     finally:
-        if temporary_name is not None and os.path.exists(temporary_name):
-            os.unlink(temporary_name)
+        os.close(lock_descriptor)
+
+
+def _read_at(entry: object) -> float:
+    if not isinstance(entry, dict):
+        return float("-inf")
+    read_at = entry.get("read_at")
+    return float(read_at) if isinstance(read_at, (int, float)) else float("-inf")
+
+
+def _merged_state(all_saved_state: dict[str, object], all_unsaved_state: dict[str, object]) -> dict[str, object]:
+    """Combine two state documents so each writer keeps the other writer's entries.
+
+    A spent mark keeps its latest reset, a meter entry keeps its newest read,
+    and the unsaved session bindings take their keys.
+    """
+    all_meters = dict(all_saved_state["meters"])
+    for each_key, each_entry in all_unsaved_state["meters"].items():
+        if _read_at(each_entry) >= _read_at(all_meters.get(each_key)):
+            all_meters[each_key] = each_entry
+    all_spent = dict(all_saved_state["spent"])
+    for each_key, each_reset in all_unsaved_state["spent"].items():
+        saved_reset = all_spent.get(each_key)
+        if not isinstance(saved_reset, (int, float)) or (isinstance(each_reset, (int, float)) and each_reset > saved_reset):
+            all_spent[each_key] = each_reset
+    return {"meters": all_meters, "spent": all_spent, "affinity": {**all_saved_state["affinity"], **all_unsaved_state["affinity"]}}
+
+
+def _save_state(path: Path, all_state: dict[str, object]) -> None:
+    """Merge the caller's state into the saved file under a lock, then refresh the caller's copy."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with _state_lock(path):
+        all_state.update(_merged_state(_load_state(path), all_state))
+        temporary_name: str | None = None
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent, prefix="state-", suffix=BROKER_STATE_TEMP_SUFFIX, delete=False, newline="\n") as stream:
+                temporary_name = stream.name
+                json.dump(all_state, stream, indent=REPORT_INDENT_SPACES, sort_keys=True)
+                stream.write("\n")
+            os.replace(temporary_name, path)
+        finally:
+            if temporary_name is not None and os.path.exists(temporary_name):
+                os.unlink(temporary_name)
 
 
 def _state_key(account: Account) -> str:

package/scripts/dev_env_scripts_constants/account_broker_constants.py

@@ -49,6 +49,7 @@ REPORT_INDENT_SPACES = 2
 BROKER_STATE_DIRECTORY_NAME = "account-broker"
 BROKER_STATE_FILE_NAME = "state.json"
 BROKER_STATE_TEMP_SUFFIX = ".json"
+BROKER_STATE_LOCK_SUFFIX = ".lock"
 SECONDS_PER_HOUR = 3600
 
 

package/scripts/test_account_broker_support.py

@@ -105,3 +105,23 @@ def test_should_extract_session_id_and_restore_runner() -> None:
         assert support.subprocess_runner is runner
     assert support.subprocess_runner is original
     assert support.extract_session_id_from_stdout('{"session_id":"one"}') == "one"
+
+
+def test_should_keep_every_concurrent_spent_mark_and_newest_meter_reading(tmp_path: Path) -> None:
+    state_path = tmp_path / "broker" / "state.json"
+    first_worker = support._load_state(state_path)
+    second_worker = support._load_state(state_path)
+    first_worker["spent"]["codex:one"] = 2000.0
+    first_worker["meters"]["codex:one"] = {"read_at": 500.0, "meters": None}
+    support._save_state(state_path, first_worker)
+    second_worker["spent"]["codex:two"] = 3000.0
+    second_worker["meters"]["codex:one"] = {"read_at": 100.0, "meters": None}
+    support._save_state(state_path, second_worker)
+    stale_worker = {"meters": {}, "spent": {"codex:one": 1000.0}, "affinity": {"session": "one"}}
+    support._save_state(state_path, stale_worker)
+
+    saved = support._load_state(state_path)
+
+    assert saved["spent"] == {"codex:one": 2000.0, "codex:two": 3000.0}
+    assert saved["meters"]["codex:one"]["read_at"] == 500.0
+    assert saved["affinity"] == {"session": "one"}