@thinkrun/cli 0.1.27

package/dist/src/working-location.js

@@ -0,0 +1,651 @@
+/**
+ * Working location and per-tab lock file management for CLI agent isolation.
+ *
+ * Each agent process that calls `thinkrun attach` or `thinkrun new-window`
+ * acquires an exclusive lock on the target Chrome tab so that two agents running
+ * simultaneously cannot clash on the same tab.
+ *
+ * Files written under `~/.thinkrun/` (or THINKRUN_LOCK_DIR in tests):
+ *   locks/{tabId}.lock      — who currently owns this tab (persists across commands)
+ *   working-location.json   — which tab this agent is currently using (shared, stable)
+ *   groups/{name}.lock      — named group pointing to a tab
+ *
+ * The working-location file uses a stable name (not PID-scoped) so that separate
+ * CLI command invocations (each a new process) can share the same attachment
+ * context.  It is written by `attach`/`new-window` and removed only by an explicit
+ * `thinkrun release`.  The lock files follow the same lease semantics: they
+ * persist until explicitly released or stale-lock detection overwrites them.
+ *
+ * During the internal rebrand pass, we still fall back to legacy
+ * `THINKBROWSE_LOCK_DIR` / `~/.thinkbrowse/` state if the new dir is not
+ * established yet.
+ */
+import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync, openSync, writeSync, closeSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveAgentId } from './session/agent-identity.js';
+// ─── Directory resolution ────────────────────────────────────────────────────
+function getLockDir() {
+    const configuredDir = process.env['THINKRUN_LOCK_DIR'] ?? process.env['THINKBROWSE_LOCK_DIR'];
+    if (configuredDir)
+        return configuredDir;
+    const thinkrunDir = join(homedir(), '.thinkrun');
+    const thinkbrowseDir = join(homedir(), '.thinkbrowse');
+    if (!existsSync(thinkrunDir) && existsSync(thinkbrowseDir)) {
+        return thinkbrowseDir;
+    }
+    return thinkrunDir;
+}
+function lockFilePath(tabId) {
+    return join(getLockDir(), 'locks', `${tabId}.lock`);
+}
+function workingLocationFilePath() {
+    // Agent-scoped stable filename so one agent's attach does not overwrite
+    // another agent's working location in a shared ~/.thinkrun directory.
+    const safeAgentId = resolveAgentId().replace(/[^a-zA-Z0-9_-]/g, '_') || 'default';
+    return join(getLockDir(), 'working-locations', `${safeAgentId}.json`);
+}
+function legacyWorkingLocationFilePath() {
+    return join(getLockDir(), 'working-location.json');
+}
+/** Path to the per-tab CLI session persistence file.
+ *  Stored alongside other lock files so THINKRUN_LOCK_DIR / THINKBROWSE_LOCK_DIR
+ *  test isolation applies.
+ *  tabId is sanitized (alphanumeric + hyphens/underscores only) to prevent path traversal. */
+export function getCliSessionFilePath(tabId) {
+    const safe = String(tabId).replace(/[^a-zA-Z0-9_-]/g, '_') || 'unknown';
+    return join(getLockDir(), `local-session-${safe}.json`);
+}
+function groupFilePath(group) {
+    // Sanitize to alphanumeric + hyphens/underscores to prevent path traversal.
+    // e.g. --group "../../etc/evil" → "______etc_evil"
+    // Empty or all-special input falls back to "default" to avoid a hidden ".lock" file.
+    const safe = group.replace(/[^a-zA-Z0-9_-]/g, '_') || 'default';
+    return join(getLockDir(), 'groups', `${safe}.lock`);
+}
+function reclaimAuditFilePath() {
+    const safeAgentId = resolveAgentId().replace(/[^a-zA-Z0-9_-]/g, '_') || 'default';
+    return join(getLockDir(), 'reclaim-audits', `${safeAgentId}.json`);
+}
+function reclaimClaimFilePath(tabId) {
+    return join(getLockDir(), 'reclaim-claims', `${tabId}.claim`);
+}
+function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+}
+let _atomicSeq = 0;
+/**
+ * Write `content` to `destPath` via a unique temp file + rename.
+ * rename(2) prevents partial/torn writes (atomic replace), but does NOT provide
+ * mutual exclusion when two processes race on the same dest — the last writer wins.
+ * For the stale-lock overwrite path this is an accepted residual risk; the window
+ * is narrow (both processes must see a dead PID at the same instant).
+ * The per-call sequence suffix prevents temp-file collisions inside this process.
+ */
+function atomicWrite(destPath, content) {
+    const tmp = `${destPath}.${process.pid}.${_atomicSeq++}.tmp`;
+    try {
+        writeFileSync(tmp, content, 'utf-8');
+        renameSync(tmp, destPath);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch { /* best-effort */ }
+        throw err;
+    }
+}
+function migrateLegacyWorkingLocation(legacy, lock) {
+    const currentAgentId = resolveAgentId();
+    const migrated = {
+        ...legacy,
+        agentId: legacy.agentId ?? lock?.agentId ?? currentAgentId,
+        ownerShellPid: legacy.ownerShellPid ?? lock?.ownerShellPid ?? process.ppid,
+        ...(legacy.controlSessionId || !lock?.controlSessionId ? {} : { controlSessionId: lock.controlSessionId }),
+    };
+    ensureDir(join(getLockDir(), 'working-locations'));
+    atomicWrite(workingLocationFilePath(), JSON.stringify(migrated));
+    try {
+        rmSync(legacyWorkingLocationFilePath(), { force: true });
+    }
+    catch {
+        // best-effort cleanup; the migrated agent-scoped copy is authoritative
+    }
+    return migrated;
+}
+function writeReclaimAudit(entry) {
+    ensureDir(join(getLockDir(), 'reclaim-audits'));
+    atomicWrite(reclaimAuditFilePath(), JSON.stringify(entry));
+}
+export function getLastReclaimAudit() {
+    const path = reclaimAuditFilePath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (typeof parsed.tabId !== 'number'
+            || typeof parsed.reclaimedAt !== 'string'
+            || typeof parsed.reclaimedByAgentId !== 'string'
+            || typeof parsed.reason !== 'string') {
+            return null;
+        }
+        return {
+            tabId: parsed.tabId,
+            reclaimedAt: parsed.reclaimedAt,
+            reclaimedByAgentId: parsed.reclaimedByAgentId,
+            reason: parsed.reason,
+            ...(typeof parsed.previousAgentId === 'string' ? { previousAgentId: parsed.previousAgentId } : {}),
+            ...(typeof parsed.previousPid === 'number' ? { previousPid: parsed.previousPid } : {}),
+            ...(typeof parsed.previousOwnerShellPid === 'number' ? { previousOwnerShellPid: parsed.previousOwnerShellPid } : {}),
+            ...(typeof parsed.previousControlSessionId === 'string' ? { previousControlSessionId: parsed.previousControlSessionId } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── In-process state ────────────────────────────────────────────────────────
+let _currentLocation = null;
+/** When the configured lock dir changes (e.g. tests), drop cache so we re-read the correct file. */
+let _cachedLocationLockDir = null;
+function ensureLocationCacheForCurrentLockDir() {
+    const lockDir = getLockDir();
+    if (_cachedLocationLockDir !== lockDir) {
+        _currentLocation = null;
+        _cachedLocationLockDir = lockDir;
+    }
+}
+// ─── PID liveness check ──────────────────────────────────────────────────────
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM means the process exists but we lack permission to signal it — still alive.
+        // ESRCH means the process does not exist — dead.
+        if (err.code === 'EPERM')
+            return true;
+        return false;
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Acquire an exclusive lock on `tabId`. Throws with message starting
+ * `TAB_LOCKED:` if the tab is already locked by a live agent or PID.
+ * If the existing lock is stale (owner dead), it is silently overwritten.
+ *
+ * Ownership logic:
+ *   1. Same agentId → re-acquire (same agent, different invocation)
+ *   2. Different agentId → check ownerShellPid liveness
+ *        alive  → BLOCK: TAB_LOCKED with agent info
+ *        dead   → stale → overwrite
+ *   3. No agentId in existing lock → fall back to PID-based logic (backward compat)
+ */
+export function acquireLock(tabId, group) {
+    const path = lockFilePath(tabId);
+    ensureDir(join(getLockDir(), 'locks'));
+    const currentAgentId = resolveAgentId();
+    const lockData = {
+        tabId,
+        pid: process.pid,
+        agentId: currentAgentId,
+        ownerShellPid: process.ppid,
+        setAt: new Date().toISOString(),
+        ...(group != null ? { group } : {}),
+    };
+    const lockJson = JSON.stringify(lockData);
+    const withReclaimClaim = (fn) => {
+        const claimPath = reclaimClaimFilePath(tabId);
+        ensureDir(join(getLockDir(), 'reclaim-claims'));
+        const claim = {
+            tabId,
+            pid: process.pid,
+            agentId: currentAgentId,
+            claimedAt: new Date().toISOString(),
+        };
+        const claimJson = JSON.stringify(claim);
+        const claimExclusive = () => {
+            const fd = openSync(claimPath, 'wx');
+            try {
+                writeSync(fd, claimJson);
+            }
+            finally {
+                closeSync(fd);
+            }
+        };
+        try {
+            claimExclusive();
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+            try {
+                const existing = JSON.parse(readFileSync(claimPath, 'utf-8'));
+                if (typeof existing.pid === 'number' && isPidAlive(existing.pid)) {
+                    const claimant = typeof existing.agentId === 'string' ? `agent ${existing.agentId}` : `PID ${existing.pid}`;
+                    throw new Error(`TAB_LOCKED: stale lock reclaim for tab ${tabId} is already in progress by ${claimant}`);
+                }
+            }
+            catch (claimErr) {
+                if (claimErr?.message?.startsWith('TAB_LOCKED'))
+                    throw claimErr;
+            }
+            try {
+                rmSync(claimPath, { force: true });
+            }
+            catch { /* best-effort */ }
+            claimExclusive();
+        }
+        try {
+            fn();
+        }
+        finally {
+            try {
+                rmSync(claimPath, { force: true });
+            }
+            catch { /* best-effort */ }
+        }
+    };
+    // Try atomic create-exclusive first (O_CREAT|O_EXCL — fails with EEXIST if already exists)
+    try {
+        const fd = openSync(path, 'wx');
+        try {
+            writeSync(fd, lockJson);
+        }
+        finally {
+            closeSync(fd);
+        }
+        return; // acquired cleanly
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST')
+            throw err; // unexpected error
+        // EEXIST: file exists — fall through to check ownership
+    }
+    // File exists — read it and decide
+    try {
+        const existing = JSON.parse(readFileSync(path, 'utf-8'));
+        // ── Agent-aware ownership check ─────────────────────────────────────────
+        if (existing.agentId) {
+            if (existing.agentId === currentAgentId) {
+                // Same agent, new invocation — re-acquire idempotently
+                atomicWrite(path, lockJson);
+                return;
+            }
+            // Different agent — check whether the owning shell is still alive
+            const ownerPid = existing.ownerShellPid ?? existing.pid;
+            if (isPidAlive(ownerPid)) {
+                throw new Error(`TAB_LOCKED: tab ${tabId} is owned by agent ${existing.agentId} (shell PID ${ownerPid})`);
+            }
+            // Owner shell is dead — stale lock, overwrite via an exclusive reclaim claim.
+            withReclaimClaim(() => {
+                const latest = JSON.parse(readFileSync(path, 'utf-8'));
+                if (latest.agentId === currentAgentId) {
+                    atomicWrite(path, lockJson);
+                    return;
+                }
+                const latestOwnerPid = latest.ownerShellPid ?? latest.pid;
+                if (!latest.agentId || isPidAlive(latestOwnerPid)) {
+                    throw new Error(latest.agentId
+                        ? `TAB_LOCKED: tab ${tabId} is owned by agent ${latest.agentId} (shell PID ${latestOwnerPid})`
+                        : `TAB_LOCKED: tab ${tabId} is in use by PID ${latest.pid}`);
+                }
+                writeReclaimAudit({
+                    tabId,
+                    reclaimedAt: new Date().toISOString(),
+                    reclaimedByAgentId: currentAgentId,
+                    reason: 'stale_owner_shell',
+                    previousAgentId: latest.agentId,
+                    previousPid: latest.pid,
+                    previousOwnerShellPid: latestOwnerPid,
+                    ...(latest.controlSessionId ? { previousControlSessionId: latest.controlSessionId } : {}),
+                });
+                atomicWrite(path, lockJson);
+            });
+            return;
+        }
+        // ── Legacy PID-based fallback (no agentId in existing lock) ─────────────
+        if (existing.pid === process.pid) {
+            atomicWrite(path, lockJson);
+            return;
+        }
+        if (isPidAlive(existing.pid)) {
+            throw new Error(`TAB_LOCKED: tab ${tabId} is in use by PID ${existing.pid}`);
+        }
+        withReclaimClaim(() => {
+            const latest = JSON.parse(readFileSync(path, 'utf-8'));
+            if (latest.agentId) {
+                const latestOwnerPid = latest.ownerShellPid ?? latest.pid;
+                if (latest.agentId === currentAgentId) {
+                    atomicWrite(path, lockJson);
+                    return;
+                }
+                if (isPidAlive(latestOwnerPid)) {
+                    throw new Error(`TAB_LOCKED: tab ${tabId} is owned by agent ${latest.agentId} (shell PID ${latestOwnerPid})`);
+                }
+                writeReclaimAudit({
+                    tabId,
+                    reclaimedAt: new Date().toISOString(),
+                    reclaimedByAgentId: currentAgentId,
+                    reason: 'stale_owner_shell',
+                    previousAgentId: latest.agentId,
+                    previousPid: latest.pid,
+                    previousOwnerShellPid: latestOwnerPid,
+                    ...(latest.controlSessionId ? { previousControlSessionId: latest.controlSessionId } : {}),
+                });
+                atomicWrite(path, lockJson);
+                return;
+            }
+            if (isPidAlive(latest.pid)) {
+                throw new Error(`TAB_LOCKED: tab ${tabId} is in use by PID ${latest.pid}`);
+            }
+            writeReclaimAudit({
+                tabId,
+                reclaimedAt: new Date().toISOString(),
+                reclaimedByAgentId: currentAgentId,
+                reason: 'stale_pid_legacy',
+                previousPid: latest.pid,
+            });
+            atomicWrite(path, lockJson);
+        });
+    }
+    catch (err) {
+        if (err.message?.startsWith('TAB_LOCKED'))
+            throw err;
+        // JSON parse error or other — treat as stale, overwrite
+        withReclaimClaim(() => {
+            writeReclaimAudit({
+                tabId,
+                reclaimedAt: new Date().toISOString(),
+                reclaimedByAgentId: currentAgentId,
+                reason: 'corrupt_existing_lock',
+            });
+            atomicWrite(path, lockJson);
+        });
+    }
+}
+/**
+ * Release the lock for `tabId`. No-op if the file doesn't exist.
+ *
+ * A lock can be released when:
+ *   - This process's PID matches the lock's pid, OR
+ *   - This process's agentId matches the lock's agentId (same agent, different invocation)
+ */
+export function releaseLock(tabId) {
+    const path = lockFilePath(tabId);
+    if (!existsSync(path))
+        return;
+    try {
+        const lock = JSON.parse(readFileSync(path, 'utf-8'));
+        const currentAgentId = resolveAgentId();
+        const ownedByPid = lock.pid === process.pid;
+        const ownedByAgent = !!lock.agentId && lock.agentId === currentAgentId;
+        if (!ownedByPid && !ownedByAgent) {
+            // Neither PID nor agentId matches — do not delete
+            return;
+        }
+        rmSync(path, { force: true });
+    }
+    catch {
+        // JSON parse error — file is corrupt/stale; best-effort remove
+        try {
+            rmSync(path, { force: true });
+        }
+        catch { /* best-effort */ }
+    }
+}
+/**
+ * Returns true when no live process holds the lock for `tabId`
+ * (either no lock file exists, or the locking PID is dead).
+ */
+export function isLockStale(tabId) {
+    const path = lockFilePath(tabId);
+    if (!existsSync(path))
+        return true;
+    try {
+        const lock = JSON.parse(readFileSync(path, 'utf-8'));
+        // Use ownerShellPid when available (agent-aware locks) so that a live shell session
+        // is not incorrectly marked stale just because its short-lived CLI command exited.
+        const ownerPid = lock.ownerShellPid ?? lock.pid;
+        return !isPidAlive(ownerPid);
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Returns the WorkingLocation stored in the lock file for `tabId`, or null.
+ * Does not check whether the locking PID is alive.
+ */
+export function getLockedBy(tabId) {
+    const path = lockFilePath(tabId);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Set the working location for this process.
+ * Acquires a lock on `tabId` (throws TAB_LOCKED if another live PID owns it)
+ * and writes the stable working-location file for cross-command persistence.
+ */
+export function setWorkingLocation(loc) {
+    ensureLocationCacheForCurrentLockDir();
+    const { tabId, windowId, group, controlSessionId } = loc;
+    // Snapshot previous group BEFORE acquiring the new lock so we can clean up
+    // the old group file after a successful switch.
+    const prevGroup = _currentLocation?.group;
+    // Acquire the new lock BEFORE releasing the old one.
+    // If acquireLock throws TAB_LOCKED the previous lock is still held and
+    // _currentLocation remains valid — no orphaned state.
+    const prevTabId = (_currentLocation && _currentLocation.tabId !== tabId)
+        ? _currentLocation.tabId
+        : undefined;
+    acquireLock(tabId, group);
+    if (prevTabId !== undefined) {
+        releaseLock(prevTabId);
+    }
+    const full = {
+        tabId,
+        pid: process.pid,
+        agentId: resolveAgentId(),
+        ownerShellPid: process.ppid,
+        setAt: new Date().toISOString(),
+        ...(windowId !== undefined ? { windowId } : {}),
+        ...(group != null ? { group } : {}),
+        ...(controlSessionId ? { controlSessionId } : {}),
+    };
+    // Write working-location file atomically (stable path — persists for cross-command use).
+    // atomicWrite (temp + rename) ensures the file is never partially written if the
+    // process crashes between the lock acquisition and the writeFileSync completing.
+    ensureDir(join(getLockDir(), 'working-locations'));
+    atomicWrite(workingLocationFilePath(), JSON.stringify(full));
+    // Write named group file if requested (group may be empty string — sanitized in groupFilePath).
+    // Use != null to guard against both undefined and null at JS runtime boundaries.
+    if (group != null) {
+        ensureDir(join(getLockDir(), 'groups'));
+        writeFileSync(groupFilePath(group), JSON.stringify(full), 'utf-8');
+    }
+    // Delete the previous group file if the agent switched to a different group
+    // (or dropped the group entirely).  Do this AFTER writing the new files so
+    // we never leave the directory in an inconsistent state.
+    if (prevGroup != null && prevGroup !== group) {
+        try {
+            rmSync(groupFilePath(prevGroup), { force: true });
+        }
+        catch (err) {
+            // Suppress ENOENT (file already gone) but warn on permission or other errors
+            // so callers know the stale group pointer was not cleaned up.
+            if (err.code !== 'ENOENT') {
+                process.stderr.write(`[thinkrun] warn: could not remove old group file for '${prevGroup}': ${err.message}\n`);
+            }
+        }
+    }
+    _currentLocation = full;
+}
+/**
+ * Update the control-session identifier for the currently owned working location.
+ * Best-effort: no-op when no working location exists.
+ */
+export function updateWorkingLocationControlSession(controlSessionId) {
+    ensureLocationCacheForCurrentLockDir();
+    const current = getWorkingLocation();
+    if (!current)
+        return;
+    const next = {
+        ...current,
+        controlSessionId,
+    };
+    atomicWrite(lockFilePath(current.tabId), JSON.stringify(next));
+    atomicWrite(workingLocationFilePath(), JSON.stringify(next));
+    if (current.group != null) {
+        ensureDir(join(getLockDir(), 'groups'));
+        writeFileSync(groupFilePath(current.group), JSON.stringify(next), 'utf-8');
+    }
+    _currentLocation = next;
+}
+/**
+ * Return the working location for this process.
+ * Checks in-process memory first, then falls back to the on-disk file.
+ */
+export function getWorkingLocation() {
+    ensureLocationCacheForCurrentLockDir();
+    if (_currentLocation)
+        return _currentLocation;
+    const path = workingLocationFilePath();
+    const readLoc = (candidatePath) => {
+        if (!existsSync(candidatePath))
+            return null;
+        try {
+            return JSON.parse(readFileSync(candidatePath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    };
+    const current = readLoc(path);
+    if (current) {
+        _currentLocation = current;
+        return current;
+    }
+    // Backward compatibility: if an older CLI wrote the global file, only adopt it
+    // when it clearly points at our own lock (or a stale legacy lock), never when it
+    // belongs to a different live agent.
+    const legacy = readLoc(legacyWorkingLocationFilePath());
+    if (!legacy)
+        return null;
+    const currentAgentId = resolveAgentId();
+    if (legacy.agentId) {
+        if (legacy.agentId !== currentAgentId)
+            return null;
+        const migrated = migrateLegacyWorkingLocation(legacy);
+        _currentLocation = migrated;
+        return migrated;
+    }
+    const lockedBy = getLockedBy(legacy.tabId);
+    if (lockedBy?.agentId) {
+        if (lockedBy.agentId !== currentAgentId)
+            return null;
+        const migrated = migrateLegacyWorkingLocation(legacy, lockedBy);
+        _currentLocation = migrated;
+        return migrated;
+    }
+    if (lockedBy && lockedBy.pid !== process.pid && isPidAlive(lockedBy.pid)) {
+        return null;
+    }
+    if (legacy.pid !== process.pid) {
+        return null;
+    }
+    const migrated = migrateLegacyWorkingLocation(legacy, lockedBy);
+    _currentLocation = migrated;
+    return migrated;
+}
+/**
+ * Release the working location for this process (and optionally a named group).
+ * Deletes the lock file for the current tab and the working-location file.
+ *
+ * When `group` is provided and working-location.json is absent (e.g. after a
+ * crash or on a different machine), the group file itself is used to look up
+ * the tabId so the lock can be released by group name alone.
+ */
+export function releaseWorkingLocation(group) {
+    // Attempt to resolve location from the working-location file first.
+    // Fall back to the group file when group is provided and the wl file is absent.
+    let loc = getWorkingLocation();
+    let groupFallback = false; // tracks whether we resolved via the group file
+    if (!loc && group != null) {
+        const gPath = groupFilePath(group);
+        if (existsSync(gPath)) {
+            try {
+                const groupLoc = JSON.parse(readFileSync(gPath, 'utf-8'));
+                // Only use the group file if the owning PID is us or is dead (stale).
+                // If a live foreign PID owns it, we must not forcibly release it.
+                if (groupLoc.pid === process.pid || !isPidAlive(groupLoc.pid)) {
+                    loc = groupLoc;
+                    groupFallback = true;
+                }
+                else {
+                    process.stderr.write(`[thinkrun] warn: group '${group}' is held by live PID ${groupLoc.pid} — cannot release\n`);
+                }
+            }
+            catch { /* corrupt group file — skip */ }
+        }
+    }
+    if (loc) {
+        // releaseLock() guards against deleting locks owned by other PIDs. When the
+        // group-file fallback resolved a stale lock (dead PID), bypass the PID check
+        // and remove the lock file directly — we already verified staleness above.
+        if (groupFallback && loc.pid !== process.pid) {
+            try {
+                rmSync(lockFilePath(loc.tabId), { force: true });
+            }
+            catch { /* best-effort */ }
+        }
+        else {
+            releaseLock(loc.tabId);
+        }
+        const currentWlPath = workingLocationFilePath();
+        if (existsSync(currentWlPath)) {
+            try {
+                rmSync(currentWlPath, { force: true });
+            }
+            catch { /* best-effort */ }
+        }
+        const legacyPath = legacyWorkingLocationFilePath();
+        if (existsSync(legacyPath)) {
+            try {
+                const legacy = JSON.parse(readFileSync(legacyPath, 'utf-8'));
+                const currentAgentId = resolveAgentId();
+                const ownedByAgent = !!legacy.agentId && legacy.agentId === currentAgentId;
+                const staleLegacy = !legacy.agentId && !isPidAlive(legacy.pid);
+                if (ownedByAgent || staleLegacy) {
+                    rmSync(legacyPath, { force: true });
+                }
+            }
+            catch {
+                // Leave malformed legacy files in place. Unconditionally deleting them
+                // would violate the ownership-conservative behavior above.
+            }
+        }
+        // Delete named group file — prefer the explicitly provided group name, fall
+        // back to the one stored in the working location.
+        const groupName = group ?? loc.group;
+        if (groupName != null) {
+            const gPath = groupFilePath(groupName);
+            if (existsSync(gPath)) {
+                try {
+                    rmSync(gPath, { force: true });
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    _currentLocation = null;
+}
+//# sourceMappingURL=working-location.js.map