brainclaw 0.19.2

package/dist/commands/watch.js

@@ -0,0 +1,215 @@
+import fs from 'node:fs';
+import { memoryExists, memoryPath } from '../core/io.js';
+import { loadState } from '../core/state.js';
+import { listRuntimeNotes } from '../core/runtime.js';
+import { listCandidates } from '../core/candidates.js';
+import { readAuditLog } from '../core/audit.js';
+import { listClaims, saveClaim, generateClaimId, ensureClaimsDir } from '../core/claims.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+function emit(event) {
+    process.stdout.write(JSON.stringify(event) + '\n');
+}
+export function runWatch(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const intervalMs = (options.interval ?? 2) * 1000;
+    const dir = memoryPath('');
+    emit({
+        event: 'watch_started',
+        section: 'system',
+        timestamp: new Date().toISOString(),
+    });
+    // Track known item counts per section for change detection
+    const last = {
+        constraints: 0,
+        decisions: 0,
+        traps: 0,
+        handoffs: 0,
+        plans: 0,
+        notes: 0,
+        candidates: 0,
+        audit: 0,
+    };
+    // Initialise baseline without emitting
+    try {
+        const state = loadState();
+        last.constraints = state.active_constraints.length;
+        last.decisions = state.recent_decisions.length;
+        last.traps = state.known_traps.length;
+        last.handoffs = state.open_handoffs.length;
+        last.plans = state.plan_items.length;
+    }
+    catch { /* ignore */ }
+    try {
+        last.notes = listRuntimeNotes().length;
+    }
+    catch { /* ignore */ }
+    try {
+        last.candidates = listCandidates().length;
+    }
+    catch { /* ignore */ }
+    try {
+        last.audit = readAuditLog().length;
+    }
+    catch { /* ignore */ }
+    const tick = () => {
+        try {
+            const state = loadState();
+            if (state.active_constraints.length !== last.constraints) {
+                const delta = state.active_constraints.length - last.constraints;
+                last.constraints = state.active_constraints.length;
+                if (delta > 0) {
+                    const added = state.active_constraints.slice(-delta);
+                    for (const c of added) {
+                        emit({ event: 'added', section: 'constraint', item_id: c.id, text: c.text, author: c.author, timestamp: c.created_at });
+                    }
+                }
+                else {
+                    emit({ event: 'removed', section: 'constraint', timestamp: new Date().toISOString() });
+                }
+            }
+            if (state.recent_decisions.length !== last.decisions) {
+                const delta = state.recent_decisions.length - last.decisions;
+                last.decisions = state.recent_decisions.length;
+                if (delta > 0) {
+                    const added = state.recent_decisions.slice(-delta);
+                    for (const d of added) {
+                        emit({ event: 'added', section: 'decision', item_id: d.id, text: d.text, author: d.author, timestamp: d.created_at });
+                    }
+                }
+            }
+            if (state.known_traps.length !== last.traps) {
+                const delta = state.known_traps.length - last.traps;
+                last.traps = state.known_traps.length;
+                if (delta > 0) {
+                    const added = state.known_traps.slice(-delta);
+                    for (const t of added) {
+                        emit({ event: 'added', section: 'trap', item_id: t.id, text: t.text, author: t.author, timestamp: t.created_at });
+                    }
+                }
+            }
+            if (state.open_handoffs.length !== last.handoffs) {
+                last.handoffs = state.open_handoffs.length;
+                emit({ event: 'changed', section: 'handoffs', timestamp: new Date().toISOString() });
+            }
+            if (state.plan_items.length !== last.plans) {
+                last.plans = state.plan_items.length;
+                emit({ event: 'changed', section: 'plans', timestamp: new Date().toISOString() });
+            }
+        }
+        catch { /* state not available yet */ }
+        try {
+            const notes = listRuntimeNotes();
+            if (notes.length !== last.notes) {
+                const delta = notes.length - last.notes;
+                last.notes = notes.length;
+                if (delta > 0) {
+                    const added = notes.slice(-delta);
+                    for (const n of added) {
+                        emit({ event: 'added', section: 'runtime_note', item_id: n.id, text: n.text, author: n.agent, timestamp: n.created_at });
+                    }
+                }
+            }
+        }
+        catch { /* ignore */ }
+        try {
+            const candidates = listCandidates();
+            if (candidates.length !== last.candidates) {
+                const delta = candidates.length - last.candidates;
+                last.candidates = candidates.length;
+                if (delta > 0) {
+                    const added = candidates.slice(-delta);
+                    for (const c of added) {
+                        emit({ event: 'added', section: 'candidate', item_id: c.id, text: c.text, author: c.author, timestamp: c.created_at });
+                    }
+                }
+            }
+        }
+        catch { /* ignore */ }
+        try {
+            const auditEntries = readAuditLog();
+            if (auditEntries.length !== last.audit) {
+                const delta = auditEntries.length - last.audit;
+                last.audit = auditEntries.length;
+                if (delta > 0) {
+                    const added = auditEntries.slice(-delta);
+                    for (const e of added) {
+                        emit({ event: 'audit', section: 'audit', item_id: e.item_id, timestamp: e.timestamp });
+                    }
+                }
+            }
+        }
+        catch { /* ignore */ }
+    };
+    // Watch loop — poll on interval
+    setInterval(tick, intervalMs);
+    // Also watch the memory dir for any file changes
+    try {
+        fs.watch(dir, { recursive: true }, (_eventType, filename) => {
+            if (filename && !filename.endsWith('.lock')) {
+                // Just emit a raw file-change event; tick() will handle the details on next poll
+                emit({
+                    event: 'file_changed',
+                    section: 'fs',
+                    text: filename,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        });
+    }
+    catch {
+        // fs.watch not available (e.g. some Docker environments) — poll only is fine
+    }
+    // Auto-claim mode: watch workspace for first write on each file
+    if (options.autoClaim) {
+        const cwd = process.cwd();
+        const agentName = options.agent ?? resolveCurrentAgentName();
+        const claimedFiles = new Set();
+        const IGNORED = new Set(['.brainclaw', '.git', 'node_modules', 'dist', 'dist-test']);
+        ensureClaimsDir();
+        try {
+            fs.watch(cwd, { recursive: true }, (eventType, filename) => {
+                if (eventType !== 'change' || !filename)
+                    return;
+                const parts = filename.replace(/\\/g, '/').split('/');
+                if (IGNORED.has(parts[0]))
+                    return;
+                if (claimedFiles.has(filename))
+                    return;
+                // Check if this agent already has an active claim covering this file
+                const existing = listClaims().filter((c) => c.status === 'active' && c.agent === agentName);
+                const alreadyClaimed = existing.some((c) => c.scope.split(/\s+/).some((s) => {
+                    const sp = s.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '');
+                    const f = filename.replace(/\\/g, '/').replace(/^\.\//, '');
+                    return f === sp || f.startsWith(sp + '/');
+                }));
+                if (alreadyClaimed) {
+                    claimedFiles.add(filename);
+                    return;
+                }
+                claimedFiles.add(filename);
+                const claim = {
+                    id: generateClaimId(),
+                    agent: agentName,
+                    scope: filename,
+                    description: `auto-claim: ${filename}`,
+                    created_at: new Date().toISOString(),
+                    status: 'active',
+                };
+                try {
+                    saveClaim(claim);
+                    emit({ event: 'auto_claim_created', section: 'claim', item_id: claim.id, text: filename, timestamp: new Date().toISOString() });
+                }
+                catch { /* skip if concurrent write fails */ }
+            });
+        }
+        catch { /* fs.watch unavailable */ }
+    }
+    process.on('SIGINT', () => {
+        emit({ event: 'watch_stopped', section: 'system', timestamp: new Date().toISOString() });
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=watch.js.map

package/dist/commands/whoami.js

@@ -0,0 +1,104 @@
+import { memoryExists } from '../core/io.js';
+import { resolveCurrentAgentIdentity, resolveCurrentModel } from '../core/agent-registry.js';
+import { loadConfig } from '../core/config.js';
+import { resolveCurrentHostId } from '../core/host.js';
+import { buildOperationalIdentity } from '../core/identity.js';
+import { assessAgentIntegrationReadiness } from '../core/agent-integrations.js';
+import { assessBrainclawVersion } from '../core/brainclaw-version.js';
+import { buildExecutionContext, compactExecutionContext } from '../core/execution-context.js';
+import { buildAgentToolingContext } from '../core/agent-context.js';
+export function runWhoami(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const config = loadConfig(cwd);
+    const hostId = resolveCurrentHostId();
+    const executionContext = compactExecutionContext(buildExecutionContext({ cwd }));
+    const integrationReadiness = assessAgentIntegrationReadiness(config, cwd);
+    const brainclawVersion = assessBrainclawVersion(config);
+    const agentTooling = buildAgentToolingContext({ cwd });
+    let identity;
+    try {
+        identity = buildOperationalIdentity(undefined, cwd);
+    }
+    catch { /* no agent configured */ }
+    const agent = identity
+        ? resolveCurrentAgentIdentity(cwd)
+        : undefined;
+    const model = resolveCurrentModel(cwd);
+    const result = {
+        resolved_agent: identity?.agent ?? null,
+        agent_id: identity?.agent_id ?? null,
+        model: model ?? null,
+        host_id: hostId,
+        session_id: identity?.session_id ?? null,
+        project_id: identity?.project_id ?? null,
+        project_name: config.project_name,
+        storage_dir: config.storage_dir,
+        trust_level: agent?.trust_level ?? 'contributor',
+        capabilities: agent?.capabilities ?? [],
+        kind: agent?.kind ?? 'unknown',
+        identity_key: agent?.identity_key ?? null,
+        env_agent: process.env.BRAINCLAW_AGENT ?? null,
+        env_session: process.env.BRAINCLAW_SESSION_ID ?? null,
+        env_host: process.env.BRAINCLAW_HOST_ID ?? null,
+        brainclaw_version: brainclawVersion,
+        declared_agent_integrations: config.agent_integrations,
+        integration_readiness: integrationReadiness,
+        execution_context: executionContext,
+        agent_tooling: {
+            agents_md_present: agentTooling.agents_md_present,
+            agents_md_title: agentTooling.agents_md_title,
+            agents_rules: agentTooling.agents_rules,
+            skills: agentTooling.skills,
+            mcp_servers: agentTooling.mcp_servers,
+        },
+    };
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`Identity resolved for: ${result.resolved_agent ?? '(no agent)'}`);
+    if (result.agent_id)
+        console.log(`  Agent ID   : ${result.agent_id}`);
+    if (result.model)
+        console.log(`  Model      : ${result.model}`);
+    console.log(`  Trust level: ${result.trust_level}`);
+    if (result.capabilities.length > 0)
+        console.log(`  Capabilities: ${result.capabilities.join(', ')}`);
+    if (result.identity_key?.fingerprint)
+        console.log(`  Fingerprint: ${result.identity_key.fingerprint}`);
+    console.log(`  Kind       : ${result.kind}`);
+    console.log(`  Host ID    : ${result.host_id}`);
+    if (result.session_id)
+        console.log(`  Session ID : ${result.session_id}`);
+    console.log(`  Project    : ${result.project_name} (${result.project_id ?? 'n/a'})`);
+    console.log(`  Storage    : ${result.storage_dir}`);
+    console.log(`  Brainclaw  : ${result.brainclaw_version.cli_version}`);
+    if (result.brainclaw_version.status !== 'ok') {
+        console.log(`  Version    : ${result.brainclaw_version.message}`);
+    }
+    console.log(`  Declared integrations: ${result.declared_agent_integrations.declarations.length}`);
+    const missingIntegrations = result.integration_readiness.filter((entry) => !entry.ready);
+    if (missingIntegrations.length > 0) {
+        console.log(`  Missing activation: ${missingIntegrations.length}`);
+    }
+    console.log(`  Branch     : ${result.execution_context.branch ?? '(none)'}`);
+    console.log(`  Git status : ${result.execution_context.git_status}`);
+    if (result.execution_context.toolchains.length > 0) {
+        const primary = result.execution_context.toolchains[0];
+        console.log(`  Toolchain  : ${primary.name}${primary.version ? ` ${primary.version}` : ''}`);
+    }
+    if (result.agent_tooling.agents_rules.length > 0) {
+        console.log(`  Agent rule : ${result.agent_tooling.agents_rules[0]}`);
+    }
+    console.log(`  Skills     : ${result.agent_tooling.skills.length}`);
+    console.log(`  MCP servers: ${result.agent_tooling.mcp_servers.length}`);
+    const missingServer = result.agent_tooling.mcp_servers.find((server) => server.availability === 'missing_command');
+    if (missingServer) {
+        console.log(`  MCP issue  : ${missingServer.name} missing ${missingServer.command ?? 'command'}`);
+    }
+}
+//# sourceMappingURL=whoami.js.map

package/dist/core/agent-context.js

@@ -0,0 +1,340 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const MAX_AGENT_RULES = 5;
+const MAX_SKILLS = 25;
+const skillsCache = new Map();
+const mcpCache = new Map();
+export function buildAgentToolingContext(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const agents = readAgentsMarkdown(cwd);
+    return {
+        agents_md_present: agents.present,
+        agents_md_title: agents.title,
+        agents_rules: agents.rules,
+        skills: listSkills(cwd, env),
+        mcp_servers: listMcpServers(cwd, env),
+    };
+}
+export function renderAgentToolingSummary(snapshot) {
+    const lines = [];
+    lines.push(`AGENTS.md: ${snapshot.agents_md_present ? 'present' : 'absent'}`);
+    if (snapshot.agents_md_title) {
+        lines.push(`AGENTS title: ${snapshot.agents_md_title}`);
+    }
+    if (snapshot.agents_rules.length > 0) {
+        lines.push('Agent rules:');
+        for (const rule of snapshot.agents_rules) {
+            lines.push(`- ${rule}`);
+        }
+    }
+    lines.push(`Skills: ${snapshot.skills.length}`);
+    for (const skill of snapshot.skills.slice(0, 10)) {
+        const markers = [];
+        if (skill.scripts_present)
+            markers.push('scripts');
+        if (skill.references_present)
+            markers.push('references');
+        if (skill.assets_present)
+            markers.push('assets');
+        const suffix = markers.length > 0 ? ` [${markers.join(', ')}]` : '';
+        lines.push(`- ${skill.name}${skill.description ? `: ${skill.description}` : ''}${suffix}`);
+    }
+    lines.push(`MCP servers: ${snapshot.mcp_servers.length}`);
+    for (const server of snapshot.mcp_servers.slice(0, 10)) {
+        const availability = server.availability === 'available'
+            ? 'available'
+            : server.availability === 'missing_command'
+                ? 'missing command'
+                : server.availability;
+        lines.push(`- ${server.name} (${server.transport}, ${availability})${server.command ? ` via ${server.command}` : ''}`);
+    }
+    return lines.join('\n');
+}
+function readAgentsMarkdown(cwd) {
+    const filepath = path.join(cwd, 'AGENTS.md');
+    if (!fs.existsSync(filepath)) {
+        return { present: false, rules: [] };
+    }
+    const raw = fs.readFileSync(filepath, 'utf-8');
+    const lines = raw.split(/\r?\n/);
+    const title = lines.find((line) => line.trim().startsWith('#'))?.replace(/^#+\s*/, '').trim();
+    const rules = lines
+        .map((line) => line.trim())
+        .filter((line) => /^([-*]|\d+\.)\s+/.test(line))
+        .map((line) => line.replace(/^([-*]|\d+\.)\s+/, '').trim())
+        .filter(Boolean)
+        .slice(0, MAX_AGENT_RULES);
+    return {
+        present: true,
+        title,
+        rules,
+    };
+}
+function listSkills(cwd, env) {
+    const cacheKey = skillCacheKey(cwd, env);
+    const cached = skillsCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const items = [];
+    const seen = new Set();
+    for (const skillsDir of skillDirectories(cwd, env)) {
+        if (!fs.existsSync(skillsDir)) {
+            continue;
+        }
+        for (const filepath of findSkillFiles(skillsDir)) {
+            if (seen.has(filepath)) {
+                continue;
+            }
+            seen.add(filepath);
+            const skill = readSkill(filepath);
+            if (skill) {
+                items.push(skill);
+            }
+        }
+    }
+    const result = items
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .slice(0, MAX_SKILLS);
+    skillsCache.set(cacheKey, result);
+    return result;
+}
+function listMcpServers(cwd, env) {
+    const cacheKey = mcpCacheKey(cwd, env);
+    const cached = mcpCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const items = [];
+    const seen = new Set();
+    for (const configPath of configFiles(cwd, env)) {
+        if (!fs.existsSync(configPath) || seen.has(configPath)) {
+            continue;
+        }
+        seen.add(configPath);
+        items.push(...readMcpConfig(configPath, cwd, env));
+    }
+    const result = items.sort((left, right) => left.name.localeCompare(right.name));
+    mcpCache.set(cacheKey, result);
+    return result;
+}
+function readSkill(filepath) {
+    try {
+        const raw = fs.readFileSync(filepath, 'utf-8');
+        const lines = raw.split(/\r?\n/).map((line) => line.trim());
+        const description = lines.find((line) => isUsefulDescriptionLine(line));
+        const skillDir = path.dirname(filepath);
+        return {
+            name: path.basename(path.dirname(filepath)),
+            description: description && description.length <= 160 ? description : undefined,
+            source_path: filepath,
+            scripts_present: fs.existsSync(path.join(skillDir, 'scripts')),
+            references_present: fs.existsSync(path.join(skillDir, 'references')),
+            assets_present: fs.existsSync(path.join(skillDir, 'assets')),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function findSkillFiles(root) {
+    const files = [];
+    walkSkillDir(root, files);
+    return files;
+}
+function walkSkillDir(dir, files) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkSkillDir(fullPath, files);
+            continue;
+        }
+        if (entry.isFile() && entry.name === 'SKILL.md') {
+            files.push(fullPath);
+        }
+    }
+}
+function readMcpConfig(configPath, cwd, env) {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    const lines = raw.split(/\r?\n/);
+    const items = [];
+    let current;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const sectionMatch = /^\[mcp_servers\.([A-Za-z0-9_.-]+)\]$/.exec(trimmed);
+        if (sectionMatch) {
+            if (current) {
+                items.push(toMcpServerItem(current, configPath, cwd, env));
+            }
+            current = { name: sectionMatch[1] };
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        if (trimmed.startsWith('[')) {
+            items.push(toMcpServerItem(current, configPath, cwd, env));
+            current = undefined;
+            continue;
+        }
+        const commandMatch = /^command\s*=\s*"([^"]+)"/.exec(trimmed);
+        if (commandMatch) {
+            current.command = commandMatch[1];
+            continue;
+        }
+        const urlMatch = /^url\s*=\s*"([^"]+)"/.exec(trimmed);
+        if (urlMatch) {
+            current.url = urlMatch[1];
+            continue;
+        }
+        const argsMatch = /^args\s*=\s*\[(.+)\]/.exec(trimmed);
+        if (argsMatch) {
+            current.args = argsMatch[1];
+        }
+    }
+    if (current) {
+        items.push(toMcpServerItem(current, configPath, cwd, env));
+    }
+    return items;
+}
+function toMcpServerItem(record, configPath, cwd, env) {
+    const combined = `${record.url ?? ''} ${record.args ?? ''}`.toLowerCase();
+    const transport = record.url || combined.includes('http://') || combined.includes('https://')
+        ? 'remote'
+        : record.command
+            ? 'stdio'
+            : 'unknown';
+    const availability = transport === 'remote'
+        ? 'remote'
+        : transport === 'stdio'
+            ? (commandExists(record.command ?? '', cwd, env) ? 'available' : 'missing_command')
+            : 'unknown';
+    return {
+        name: record.name,
+        transport,
+        command: record.command,
+        config_path: configPath,
+        availability,
+        source: resolveConfigSource(configPath, cwd, env),
+    };
+}
+function skillDirectories(cwd, env) {
+    const roots = codexHomes(cwd, env);
+    return roots.map((root) => path.join(root, 'skills'));
+}
+function configFiles(cwd, env) {
+    return codexHomes(cwd, env).map((root) => path.join(root, 'config.toml'));
+}
+function codexHomes(cwd, env) {
+    const explicit = env.CODEX_HOME?.trim();
+    if (explicit) {
+        return [...new Set([
+                explicit,
+                path.join(cwd, '.codex'),
+            ])];
+    }
+    return [...new Set([
+            path.join(cwd, '.codex'),
+            path.join(os.homedir(), '.codex'),
+        ])];
+}
+function isUsefulDescriptionLine(line) {
+    if (!line) {
+        return false;
+    }
+    if (line.startsWith('#')) {
+        return false;
+    }
+    if (line === '---') {
+        return false;
+    }
+    if (/^[A-Za-z0-9_-]+:\s*$/.test(line)) {
+        return false;
+    }
+    return true;
+}
+function resolveConfigSource(configPath, cwd, env) {
+    const normalized = path.normalize(configPath);
+    const workspaceCodex = path.normalize(path.join(cwd, '.codex'));
+    const explicitCodexHome = env.CODEX_HOME?.trim();
+    if (isWithinPath(normalized, workspaceCodex)) {
+        return 'workspace';
+    }
+    if (explicitCodexHome && isWithinPath(normalized, path.normalize(explicitCodexHome))) {
+        return 'codex_home';
+    }
+    return 'home';
+}
+function commandExists(command, cwd, env) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (trimmed.includes(path.sep) || trimmed.includes('/')) {
+        const candidate = path.isAbsolute(trimmed) ? trimmed : path.resolve(cwd, trimmed);
+        return fileExists(candidate);
+    }
+    const pathValue = env.PATH ?? env.Path ?? '';
+    if (!pathValue) {
+        return false;
+    }
+    const extensions = process.platform === 'win32'
+        ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+        : [''];
+    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+        if (process.platform === 'win32') {
+            const hasKnownExt = /\.[A-Za-z0-9]+$/.test(trimmed);
+            const candidates = hasKnownExt ? [trimmed] : extensions.map((ext) => `${trimmed}${ext}`);
+            for (const candidate of candidates) {
+                if (fileExists(path.join(dir, candidate))) {
+                    return true;
+                }
+            }
+            continue;
+        }
+        if (fileExists(path.join(dir, trimmed))) {
+            return true;
+        }
+    }
+    return false;
+}
+function fileExists(filepath) {
+    try {
+        return fs.existsSync(filepath) && fs.statSync(filepath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function skillCacheKey(cwd, env) {
+    const parts = [];
+    for (const skillsDir of skillDirectories(cwd, env)) {
+        parts.push(skillsDir);
+        if (!fs.existsSync(skillsDir)) {
+            continue;
+        }
+        for (const filepath of findSkillFiles(skillsDir)) {
+            parts.push(`${filepath}:${safeMtime(filepath)}`);
+        }
+    }
+    return parts.join('|');
+}
+function mcpCacheKey(cwd, env) {
+    const parts = configFiles(cwd, env).map((configPath) => `${configPath}:${safeMtime(configPath)}`);
+    parts.push(env.PATH ?? '', env.Path ?? '', env.PATHEXT ?? '');
+    return parts.join('|');
+}
+function safeMtime(filepath) {
+    try {
+        return fs.statSync(filepath).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+function isWithinPath(filepath, root) {
+    return filepath === root || filepath.startsWith(`${root}${path.sep}`);
+}
+//# sourceMappingURL=agent-context.js.map