brainclaw 0.19.2

package/dist/core/events.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveEventSessionId } from './identity.js';
+import { RuntimeEventSchema } from './schema.js';
+import { readFileSync, resolveEntityDir } from './io.js';
+import { logger } from './logger.js';
+function runtimeDir(cwd) {
+    return resolveEntityDir('runtime', cwd ?? process.cwd(), 'read');
+}
+function collectJsonFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir))
+        return files;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectJsonFiles(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.json')) {
+            files.push(full);
+        }
+    }
+    return files;
+}
+export function listRuntimeEvents(cwd) {
+    const base = runtimeDir(cwd);
+    if (!fs.existsSync(base))
+        return [];
+    const events = [];
+    for (const file of collectJsonFiles(base)) {
+        try {
+            const parsed = JSON.parse(readFileSync(file));
+            if (Array.isArray(parsed)) {
+                for (const item of parsed) {
+                    events.push(RuntimeEventSchema.parse(item));
+                }
+            }
+            else if (parsed && typeof parsed === 'object' && Array.isArray(parsed.events)) {
+                for (const item of parsed.events) {
+                    events.push(RuntimeEventSchema.parse(item));
+                }
+            }
+            else {
+                events.push(RuntimeEventSchema.parse(parsed));
+            }
+        }
+        catch (err) {
+            logger.debug('Ignoring malformed runtime event file:', file, err);
+        }
+    }
+    return events.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+export function listRuntimeEventsBySession(session, cwd) {
+    return listRuntimeEvents(cwd).filter((event) => resolveEventSessionId(event) === session);
+}
+//# sourceMappingURL=events.js.map

package/dist/core/execution-context.js

@@ -0,0 +1,204 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+const TOOLCHAINS = [
+    { name: 'node', command: 'node', args: ['--version'] },
+    { name: 'npm', command: 'npm', args: ['--version'] },
+    { name: 'pnpm', command: 'pnpm', args: ['--version'] },
+    { name: 'python', command: 'python', args: ['--version'] },
+    { name: 'pip', command: 'pip', args: ['--version'] },
+    { name: 'cargo', command: 'cargo', args: ['--version'] },
+    { name: 'go', command: 'go', args: ['version'] },
+];
+const ENV_WHITELIST = [
+    'BRAINCLAW_AGENT',
+    'BRAINCLAW_HOST_ID',
+    'BRAINCLAW_SESSION_ID',
+    'OPENCLAW_AGENT',
+    'OPENCLAW_SESSION_ID',
+    'CI',
+    'NODE_ENV',
+    'VIRTUAL_ENV',
+    'CONDA_DEFAULT_ENV',
+    'npm_config_user_agent',
+];
+let cachedToolchains;
+export function buildExecutionContext(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const runner = options.runner ?? defaultRunner;
+    const workspaceRoot = detectWorkspaceRoot(cwd, runner);
+    const branch = detectGitBranch(cwd, runner);
+    const gitStatus = detectGitStatus(cwd, runner);
+    const hasRemote = detectGitRemote(cwd, runner);
+    return {
+        platform: process.platform,
+        shell: detectShell(env),
+        cwd,
+        workspace_root: workspaceRoot,
+        branch,
+        git_status: gitStatus,
+        has_remote: hasRemote,
+        toolchains: detectToolchains(cwd, runner),
+        env_signals: captureEnvSignals(env),
+    };
+}
+export function compactExecutionContext(snapshot) {
+    return {
+        platform: snapshot.platform,
+        shell: snapshot.shell,
+        workspace_root: snapshot.workspace_root,
+        branch: snapshot.branch,
+        git_status: snapshot.git_status,
+        has_remote: snapshot.has_remote,
+        toolchains: snapshot.toolchains.filter((tool) => tool.available),
+    };
+}
+export function renderExecutionContextSummary(snapshot, includeEnvSignals = false) {
+    const lines = [];
+    lines.push(`Platform: ${snapshot.platform}`);
+    if (snapshot.shell) {
+        lines.push(`Shell: ${snapshot.shell}`);
+    }
+    lines.push(`Workspace: ${snapshot.workspace_root}`);
+    if (snapshot.branch) {
+        lines.push(`Git branch: ${snapshot.branch}`);
+    }
+    lines.push(`Git status: ${snapshot.git_status}`);
+    lines.push(`Git remote: ${snapshot.has_remote ? 'configured' : 'none'}`);
+    const availableToolchains = snapshot.toolchains.filter((tool) => tool.available);
+    if (availableToolchains.length > 0) {
+        lines.push(`Toolchains: ${availableToolchains.map((tool) => `${tool.name}${tool.version ? ` ${tool.version}` : ''}`).join(', ')}`);
+    }
+    else {
+        lines.push('Toolchains: none detected');
+    }
+    if (includeEnvSignals && 'env_signals' in snapshot && snapshot.env_signals.length > 0) {
+        lines.push('Environment signals:');
+        for (const signal of snapshot.env_signals) {
+            lines.push(`- ${signal.name}=${signal.value}`);
+        }
+    }
+    return lines.join('\n');
+}
+function detectWorkspaceRoot(cwd, runner) {
+    const result = runner('git', ['rev-parse', '--show-toplevel'], cwd);
+    if (result.status === 0) {
+        return result.stdout.trim();
+    }
+    return cwd;
+}
+function detectGitBranch(cwd, runner) {
+    const result = runner('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    if (result.status !== 0) {
+        return undefined;
+    }
+    const branch = result.stdout.trim();
+    return branch && branch !== 'HEAD' ? branch : undefined;
+}
+function detectGitStatus(cwd, runner) {
+    const result = runner('git', ['status', '--porcelain'], cwd);
+    if (result.status !== 0) {
+        return 'unavailable';
+    }
+    return result.stdout.trim().length > 0 ? 'dirty' : 'clean';
+}
+function detectGitRemote(cwd, runner) {
+    const result = runner('git', ['remote'], cwd);
+    if (result.status !== 0) {
+        return false;
+    }
+    return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).length > 0;
+}
+function detectToolchains(cwd, runner) {
+    if (runner === defaultRunner && cachedToolchains) {
+        return cachedToolchains;
+    }
+    const detected = TOOLCHAINS.map((tool) => {
+        const result = runner(tool.command, tool.args, cwd);
+        if (result.status !== 0) {
+            return { name: tool.name, available: false };
+        }
+        const version = firstNonEmptyLine(result.stdout || result.stderr);
+        return {
+            name: tool.name,
+            available: true,
+            version,
+        };
+    });
+    if (runner === defaultRunner) {
+        cachedToolchains = detected;
+    }
+    return detected;
+}
+function captureEnvSignals(env) {
+    const signals = [];
+    for (const name of ENV_WHITELIST) {
+        const raw = env[name]?.trim();
+        if (!raw) {
+            continue;
+        }
+        signals.push({
+            name,
+            value: normalizeEnvValue(name, raw),
+            redacted: isRedactedEnv(name),
+        });
+    }
+    return signals;
+}
+function normalizeEnvValue(name, value) {
+    if (name === 'CI') {
+        return value.toLowerCase() === 'true' ? 'true' : 'set';
+    }
+    if (name === 'VIRTUAL_ENV') {
+        return path.basename(value);
+    }
+    if (name === 'BRAINCLAW_SESSION_ID' || name === 'OPENCLAW_SESSION_ID') {
+        return redactValue(value);
+    }
+    if (name === 'npm_config_user_agent') {
+        return value.split(' ')[0] ?? value;
+    }
+    return value;
+}
+function isRedactedEnv(name) {
+    return name === 'BRAINCLAW_SESSION_ID' || name === 'OPENCLAW_SESSION_ID';
+}
+function redactValue(value) {
+    if (value.length <= 10) {
+        return 'set';
+    }
+    return `${value.slice(0, 5)}...${value.slice(-3)}`;
+}
+function detectShell(env) {
+    const shell = env.SHELL?.trim();
+    if (shell) {
+        return path.basename(shell).replace(/\.exe$/i, '');
+    }
+    if (env.PSModulePath) {
+        return 'powershell';
+    }
+    const comspec = env.ComSpec?.trim() ?? env.COMSPEC?.trim();
+    if (comspec) {
+        return path.basename(comspec).replace(/\.exe$/i, '');
+    }
+    return process.platform === 'win32' ? 'unknown-windows-shell' : 'unknown-shell';
+}
+function firstNonEmptyLine(value) {
+    return value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+}
+function defaultRunner(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 5000,
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+    };
+}
+//# sourceMappingURL=execution-context.js.map

package/dist/core/freshness.js

@@ -0,0 +1,87 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveCurrentHostId } from './host.js';
+import { memoryPath, readFileSync, writeFileAtomic, resolveEntityDir } from './io.js';
+import { logger } from './logger.js';
+const SHARED_PATHS = [
+    'config.yaml',
+    'project.md',
+    'constraints',
+    'decisions',
+    'traps',
+    'handoffs',
+    'plans',
+    'instructions',
+    'claims',
+    'runtime',
+    'inbox',
+];
+export function getVisibleMemoryVersion(options = {}) {
+    const entries = [];
+    const cwd = options.cwd ?? process.cwd();
+    // Scan entity-aligned paths (with legacy fallback via resolveEntityDir)
+    for (const relativePath of SHARED_PATHS) {
+        const resolved = relativePath.includes('.') ? memoryPath(relativePath, cwd) : resolveEntityDir(relativePath, cwd, 'read');
+        collectFileStats(resolved, relativePath, entries);
+    }
+    if (options.allHosts) {
+        collectFileStats(resolveEntityDir('runtime-hosts', cwd, 'read'), 'runtime-hosts', entries);
+        collectFileStats(resolveEntityDir('runtime-private', cwd, 'read'), 'runtime-private', entries);
+        collectFileStats(resolveEntityDir('traps-hosts', cwd, 'read'), 'traps-hosts', entries);
+        collectFileStats(resolveEntityDir('traps-private', cwd, 'read'), 'traps-private', entries);
+    }
+    else {
+        const hostId = options.hostId ?? resolveCurrentHostId();
+        collectFileStats(path.join(resolveEntityDir('runtime-hosts', cwd, 'read'), hostId), path.join('runtime-hosts', hostId), entries);
+        collectFileStats(path.join(resolveEntityDir('runtime-private', cwd, 'read'), hostId), path.join('runtime-private', hostId), entries);
+        collectFileStats(path.join(resolveEntityDir('traps-hosts', cwd, 'read'), hostId), path.join('traps-hosts', hostId), entries);
+        collectFileStats(path.join(resolveEntityDir('traps-private', cwd, 'read'), hostId), path.join('traps-private', hostId), entries);
+    }
+    const hash = crypto.createHash('sha1');
+    for (const entry of entries.sort()) {
+        hash.update(entry);
+        hash.update('\n');
+    }
+    return hash.digest('hex');
+}
+export function readContextMarker(cwd) {
+    const markerPath = memoryPath('.last-context', cwd);
+    if (!fs.existsSync(markerPath)) {
+        return undefined;
+    }
+    const raw = readFileSync(markerPath).trim();
+    if (!raw) {
+        return undefined;
+    }
+    if (raw.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed.read_at === 'string') {
+                return parsed;
+            }
+        }
+        catch (err) {
+            logger.debug('Failed to parse context marker:', err);
+            return undefined;
+        }
+    }
+    return { read_at: raw };
+}
+export function writeContextMarker(marker, cwd) {
+    writeFileAtomic(memoryPath('.last-context', cwd), JSON.stringify(marker, null, 2) + '\n');
+}
+function collectFileStats(absolutePath, relativePath, entries) {
+    if (!fs.existsSync(absolutePath)) {
+        return;
+    }
+    const stat = fs.statSync(absolutePath);
+    if (stat.isDirectory()) {
+        for (const child of fs.readdirSync(absolutePath).sort()) {
+            collectFileStats(path.join(absolutePath, child), `${relativePath}/${child}`, entries);
+        }
+        return;
+    }
+    entries.push(`${relativePath}:${stat.size}:${stat.mtimeMs}`);
+}
+//# sourceMappingURL=freshness.js.map

package/dist/core/global-registry.js

@@ -0,0 +1,182 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import yaml from 'yaml';
+import { MEMORY_DIR } from './io.js';
+// ── Helpers ────────────────────────────────────────────────────────────────────
+function runGit(args, cwd) {
+    try {
+        const r = spawnSync('git', args, { encoding: 'utf-8', timeout: 5000, cwd, windowsHide: true });
+        return r.status === 0 ? r.stdout.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function readYamlSafe(filePath) {
+    try {
+        return yaml.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+// ── Scan a project directory ───────────────────────────────────────────────────
+/**
+ * Extract registry metadata from a single brainclaw-initialized project.
+ */
+export function scanProject(projectPath) {
+    const brainclawDir = path.join(projectPath, MEMORY_DIR);
+    if (!fs.existsSync(brainclawDir))
+        return undefined;
+    const identity = readJsonSafe(path.join(brainclawDir, 'project.identity.json'));
+    const config = readYamlSafe(path.join(brainclawDir, 'config.yaml'));
+    if (!identity && !config)
+        return undefined;
+    const projectId = (identity?.project_id ?? config?.project_id ?? 'unknown');
+    const projectName = (identity?.project_name ?? config?.project_name ?? path.basename(projectPath));
+    // Git remote
+    const gitRemote = runGit(['remote', 'get-url', 'origin'], projectPath);
+    // Git user for this repo
+    const gitUsers = [];
+    const userName = runGit(['config', 'user.name'], projectPath);
+    const userEmail = runGit(['config', 'user.email'], projectPath);
+    if (userName && userEmail) {
+        gitUsers.push({ name: userName, email: userEmail });
+    }
+    // Agents seen
+    const agentsSeen = [];
+    const agentsDir = path.join(brainclawDir, 'agents');
+    if (fs.existsSync(agentsDir)) {
+        try {
+            for (const f of fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'))) {
+                const agent = readJsonSafe(path.join(agentsDir, f));
+                const name = agent?.agent_name;
+                if (name && !agentsSeen.includes(name))
+                    agentsSeen.push(name);
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    // Last activity from audit.log mtime
+    let lastActivity;
+    try {
+        const auditLog = path.join(brainclawDir, 'audit.log');
+        if (fs.existsSync(auditLog)) {
+            lastActivity = fs.statSync(auditLog).mtime.toISOString();
+        }
+    }
+    catch { /* non-fatal */ }
+    return { project_id: projectId, project_name: projectName, path: projectPath, git_remote: gitRemote, git_users: gitUsers, last_activity: lastActivity, agents_seen: agentsSeen };
+}
+// ── Registry CRUD ──────────────────────────────────────────────────────────────
+export function globalRegistryPath() {
+    return path.join(os.homedir(), MEMORY_DIR, 'projects.yaml');
+}
+export function loadGlobalRegistry() {
+    const filePath = globalRegistryPath();
+    if (!fs.existsSync(filePath))
+        return undefined;
+    try {
+        return yaml.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveGlobalRegistry(registry) {
+    const filePath = globalRegistryPath();
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, yaml.stringify(registry, { lineWidth: 120 }), 'utf-8');
+    return filePath;
+}
+/**
+ * Register or update a single project in the global registry (upsert by project_id).
+ */
+export function upsertProject(entry) {
+    const registry = loadGlobalRegistry() ?? { schema_version: 1, updated_at: new Date().toISOString(), projects: [] };
+    const idx = registry.projects.findIndex(p => p.project_id === entry.project_id);
+    if (idx >= 0) {
+        registry.projects[idx] = entry;
+    }
+    else {
+        registry.projects.push(entry);
+    }
+    registry.updated_at = new Date().toISOString();
+    saveGlobalRegistry(registry);
+    return registry;
+}
+/**
+ * Scan directories for brainclaw projects and update the global registry.
+ */
+export function scanAndRegister(roots) {
+    const registry = loadGlobalRegistry() ?? { schema_version: 1, updated_at: new Date().toISOString(), projects: [] };
+    for (const root of roots) {
+        const resolved = path.resolve(root);
+        // Check root itself
+        const rootEntry = scanProject(resolved);
+        if (rootEntry) {
+            const idx = registry.projects.findIndex(p => p.project_id === rootEntry.project_id);
+            if (idx >= 0)
+                registry.projects[idx] = rootEntry;
+            else
+                registry.projects.push(rootEntry);
+        }
+        // Scan immediate subdirectories
+        if (!fs.existsSync(resolved))
+            continue;
+        try {
+            for (const e of fs.readdirSync(resolved, { withFileTypes: true })) {
+                if (!e.isDirectory() || e.name.startsWith('.') || e.name === 'node_modules')
+                    continue;
+                const entry = scanProject(path.join(resolved, e.name));
+                if (entry) {
+                    const idx = registry.projects.findIndex(p => p.project_id === entry.project_id);
+                    if (idx >= 0)
+                        registry.projects[idx] = entry;
+                    else
+                        registry.projects.push(entry);
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    registry.updated_at = new Date().toISOString();
+    saveGlobalRegistry(registry);
+    return registry;
+}
+/**
+ * Render human-readable summary of the global project registry.
+ */
+export function renderGlobalRegistrySummary(registry) {
+    const lines = [];
+    lines.push(`Projects registered: ${registry.projects.length}`);
+    lines.push('');
+    for (const p of registry.projects) {
+        lines.push(`● ${p.project_name} (${p.project_id})`);
+        lines.push(`  Path: ${p.path}`);
+        if (p.git_remote)
+            lines.push(`  Remote: ${p.git_remote}`);
+        if (p.git_users.length > 0)
+            lines.push(`  Git user: ${p.git_users.map(u => `${u.name} <${u.email}>`).join(', ')}`);
+        if (p.agents_seen.length > 0)
+            lines.push(`  Agents: ${p.agents_seen.join(', ')}`);
+        if (p.last_activity)
+            lines.push(`  Last activity: ${p.last_activity}`);
+        lines.push('');
+    }
+    lines.push(`Registry updated: ${registry.updated_at}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=global-registry.js.map

package/dist/core/host.js

@@ -0,0 +1,10 @@
+import os from 'node:os';
+const HOST_ID_PATTERN = /[^a-z0-9._-]+/g;
+export function sanitizeHostId(value) {
+    const normalized = value.trim().toLowerCase().replace(HOST_ID_PATTERN, '-').replace(/-+/g, '-');
+    return normalized.replace(/^-|-$/g, '') || 'unknown-host';
+}
+export function resolveCurrentHostId(explicitHostId) {
+    return sanitizeHostId(explicitHostId ?? process.env.BRAINCLAW_HOST_ID ?? os.hostname());
+}
+//# sourceMappingURL=host.js.map

package/dist/core/identity.js

@@ -0,0 +1,151 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { requireRegisteredAgentIdentity } from './agent-registry.js';
+import { loadConfig } from './config.js';
+import { resolveCurrentHostId } from './host.js';
+import { memoryDir } from './io.js';
+import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
+import { CurrentSessionStateSchema } from './schema.js';
+const CURRENT_SESSION_FILE = '.current-session';
+export function resolveCurrentSessionId(env = process.env, cwd, options = {}) {
+    const value = env.BRAINCLAW_SESSION_ID?.trim()
+        || env.OPENCLAW_SESSION_ID?.trim()
+        || env.CLAUDE_SESSION_ID?.trim()
+        || env.COPILOT_SESSION_ID?.trim();
+    if (value && value.length > 0) {
+        return value;
+    }
+    const agentName = options.agentName?.trim();
+    const agentId = options.agentId?.trim();
+    const hostId = options.hostId?.trim();
+    if (!agentName || !agentId || !hostId) {
+        return undefined;
+    }
+    const implicit = resolveImplicitSession(cwd, {
+        agentName,
+        agentId,
+        hostId,
+        preferredSessionId: options.preferredSessionId,
+        persistImplicit: options.persistImplicit,
+    });
+    return implicit?.session_id;
+}
+export function buildOperationalIdentity(agentName, cwd, options = {}) {
+    const actor = requireRegisteredAgentIdentity({
+        agentName,
+        agentId: options.agentId,
+        cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    const config = loadConfig(cwd);
+    const hostId = resolveCurrentHostId();
+    return {
+        agent: actor.agent_name,
+        agent_id: actor.agent_id,
+        project_id: config.project_id,
+        host_id: hostId,
+        session_id: resolveCurrentSessionId(process.env, cwd, {
+            agentName: actor.agent_name,
+            agentId: actor.agent_id,
+            hostId,
+            preferredSessionId: options.sessionId,
+            persistImplicit: options.persistImplicitSession,
+        }),
+    };
+}
+export function resolveEventSessionId(event) {
+    if (typeof event.session_id === 'string' && event.session_id.trim().length > 0) {
+        return event.session_id;
+    }
+    const metadataSession = event.metadata?.session;
+    return typeof metadataSession === 'string' && metadataSession.trim().length > 0
+        ? metadataSession
+        : undefined;
+}
+export function loadCurrentSession(cwd) {
+    const filepath = currentSessionPath(cwd);
+    if (!fs.existsSync(filepath)) {
+        return undefined;
+    }
+    try {
+        return CurrentSessionStateSchema.parse(loadVersionedJsonFile('current_session', filepath).document);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveCurrentSession(session, cwd) {
+    saveVersionedJsonFile('current_session', currentSessionPath(cwd), CurrentSessionStateSchema.parse(session));
+}
+export function clearCurrentSession(cwd, sessionId) {
+    const filepath = currentSessionPath(cwd);
+    if (!fs.existsSync(filepath)) {
+        return;
+    }
+    if (sessionId) {
+        const current = loadCurrentSession(cwd);
+        if (!current || current.session_id !== sessionId) {
+            return;
+        }
+    }
+    try {
+        fs.unlinkSync(filepath);
+    }
+    catch {
+        // Ignore cleanup races.
+    }
+}
+function currentSessionPath(cwd) {
+    return path.join(memoryDir(cwd), CURRENT_SESSION_FILE);
+}
+function resolveImplicitSession(cwd, options) {
+    const current = loadCurrentSession(cwd);
+    const persistImplicit = options.persistImplicit ?? true;
+    const ttlMs = parseDurationToMs(loadConfig(cwd).implicit_session_ttl ?? '4h');
+    const now = new Date();
+    if (current
+        && current.agent === options.agentName
+        && current.agent_id === options.agentId
+        && current.host_id === options.hostId
+        && now.getTime() - Date.parse(current.last_seen_at) <= ttlMs) {
+        const refreshed = {
+            ...current,
+            last_seen_at: now.toISOString(),
+        };
+        if (persistImplicit) {
+            saveCurrentSession(refreshed, cwd);
+        }
+        return refreshed;
+    }
+    const created = {
+        session_id: options.preferredSessionId ?? generateImplicitSessionId(),
+        started_at: now.toISOString(),
+        last_seen_at: now.toISOString(),
+        agent: options.agentName,
+        agent_id: options.agentId,
+        host_id: options.hostId,
+    };
+    if (persistImplicit) {
+        saveCurrentSession(created, cwd);
+    }
+    return created;
+}
+function parseDurationToMs(value) {
+    const match = /^(\d+)([mhd])$/i.exec(value.trim());
+    if (!match) {
+        return 4 * 60 * 60 * 1000;
+    }
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (unit === 'm')
+        return amount * 60_000;
+    if (unit === 'h')
+        return amount * 3_600_000;
+    return amount * 86_400_000;
+}
+function generateImplicitSessionId() {
+    return `sess_${crypto.randomBytes(4).toString('hex')}`;
+}
+//# sourceMappingURL=identity.js.map