oh-my-copilot 4.13.21 → 4.13.45

package/dist/tools/state-tools.js

@@ -5,10 +5,12 @@
  * All paths are validated to stay within the worktree boundary.
  */
 import { z } from 'zod';
-import { existsSync, readFileSync, unlinkSync } from 'fs';
-import { resolveStatePath, ensureOmcDir, validateWorkingDirectory, resolveSessionStatePath, ensureSessionStateDir, listSessionIds, validateSessionId, } from '../lib/worktree-paths.js';
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { resolveStatePath, ensureOmcDir, validateWorkingDirectory, resolveSessionStatePath, ensureSessionStateDir, listSessionIds, validateSessionId, getOmcRoot, } from '../lib/worktree-paths.js';
 import { atomicWriteJsonSync } from '../lib/atomic-write.js';
 import { validatePayload } from '../lib/payload-limits.js';
+import { canClearStateForSession, findCompletedSessionStateFiles, findSessionOwnedStateFiles, } from '../lib/mode-state-io.js';
 import { isModeActive, getActiveModes, getAllModeStatuses, clearModeState, getStateFilePath, MODE_CONFIGS, getActiveSessionsForMode } from '../hooks/mode-registry/index.js';
 // Canonical execution modes from mode-registry (deep-interview and self-improve
 // are first-class modes with dedicated MODE_CONFIGS entries; ralplan remains an
@@ -25,6 +27,86 @@ const STATE_TOOL_MODES = [
 ];
 const EXTRA_STATE_ONLY_MODES = ['ralplan', 'omc-teams', 'skill-active'];
 const CANCEL_SIGNAL_TTL_MS = 30_000;
+function readTeamNamesFromStateFile(statePath) {
+    if (!existsSync(statePath))
+        return [];
+    try {
+        const raw = JSON.parse(readFileSync(statePath, 'utf-8'));
+        const teamName = typeof raw.team_name === 'string'
+            ? raw.team_name.trim()
+            : typeof raw.teamName === 'string'
+                ? raw.teamName.trim()
+                : '';
+        return teamName ? [teamName] : [];
+    }
+    catch {
+        return [];
+    }
+}
+function pruneMissionBoardTeams(root, teamNames) {
+    const missionStatePath = join(getOmcRoot(root), 'state', 'mission-state.json');
+    if (!existsSync(missionStatePath))
+        return 0;
+    try {
+        const parsed = JSON.parse(readFileSync(missionStatePath, 'utf-8'));
+        if (!Array.isArray(parsed.missions))
+            return 0;
+        const shouldRemoveAll = teamNames == null;
+        const teamNameSet = new Set(teamNames ?? []);
+        const remainingMissions = parsed.missions.filter((mission) => {
+            if (mission.source !== 'team')
+                return true;
+            if (shouldRemoveAll)
+                return false;
+            const missionTeamName = typeof mission.teamName === 'string'
+                ? mission.teamName.trim()
+                : typeof mission.name === 'string'
+                    ? mission.name.trim()
+                    : '';
+            return !missionTeamName || !teamNameSet.has(missionTeamName);
+        });
+        const removed = parsed.missions.length - remainingMissions.length;
+        if (removed > 0) {
+            writeFileSync(missionStatePath, JSON.stringify({
+                ...parsed,
+                updatedAt: new Date().toISOString(),
+                missions: remainingMissions,
+            }, null, 2));
+        }
+        return removed;
+    }
+    catch {
+        return 0;
+    }
+}
+function cleanupTeamRuntimeState(root, teamNames) {
+    const teamStateRoot = join(getOmcRoot(root), 'state', 'team');
+    if (!existsSync(teamStateRoot))
+        return 0;
+    const shouldRemoveAll = teamNames == null;
+    let removed = 0;
+    if (shouldRemoveAll) {
+        try {
+            rmSync(teamStateRoot, { recursive: true, force: true });
+            return 1;
+        }
+        catch {
+            return 0;
+        }
+    }
+    for (const teamName of teamNames ?? []) {
+        if (!teamName)
+            continue;
+        try {
+            rmSync(join(teamStateRoot, teamName), { recursive: true, force: true });
+            removed += 1;
+        }
+        catch {
+            // best effort
+        }
+    }
+    return removed;
+}
 /**
  * Get the state file path for any mode (including swarm and ralplan).
  *
@@ -40,6 +122,104 @@ function getStatePath(mode, root) {
     // Fallback for modes not in registry (e.g., ralplan)
     return resolveStatePath(mode, root);
 }
+function getLegacyStateFileCandidates(mode, root) {
+    const normalizedName = mode.endsWith('-state') ? mode : `${mode}-state`;
+    const candidates = [
+        getStatePath(mode, root),
+        join(getOmcRoot(root), `${normalizedName}.json`),
+    ];
+    return [...new Set(candidates)];
+}
+function clearLegacyStateCandidates(mode, root, sessionId) {
+    let cleared = 0;
+    let hadFailure = false;
+    for (const legacyPath of getLegacyStateFileCandidates(mode, root)) {
+        if (!existsSync(legacyPath)) {
+            continue;
+        }
+        try {
+            if (sessionId) {
+                const raw = JSON.parse(readFileSync(legacyPath, 'utf-8'));
+                if (!canClearStateForSession(raw, sessionId)) {
+                    continue;
+                }
+            }
+            unlinkSync(legacyPath);
+            cleared++;
+        }
+        catch {
+            hadFailure = true;
+        }
+    }
+    return { cleared, hadFailure };
+}
+function clearSessionOwnedStateCandidates(mode, root, sessionId) {
+    let cleared = 0;
+    let hadFailure = false;
+    const paths = findSessionOwnedStateFiles(mode, sessionId, root);
+    for (const statePath of paths) {
+        try {
+            unlinkSync(statePath);
+            cleared++;
+        }
+        catch {
+            hadFailure = true;
+        }
+    }
+    return { cleared, hadFailure, paths };
+}
+function clearCompletedSessionStateCandidates(mode, root, requesterSessionId) {
+    let cleared = 0;
+    let hadFailure = false;
+    const paths = findCompletedSessionStateFiles(mode, root, requesterSessionId);
+    for (const statePath of paths) {
+        try {
+            unlinkSync(statePath);
+            cleared++;
+        }
+        catch {
+            hadFailure = true;
+        }
+    }
+    return { cleared, hadFailure, paths };
+}
+function getModeRuntimeArtifactNames(mode) {
+    return [
+        `${mode}-stop-breaker.json`,
+        `${mode}-last-steer-at`,
+        `${mode}-continue-steer.lock`,
+    ];
+}
+function clearModeRuntimeArtifacts(mode, root, sessionId) {
+    let cleared = 0;
+    let hadFailure = false;
+    const stateRoot = join(getOmcRoot(root), 'state');
+    const candidateDirs = new Set([stateRoot]);
+    if (sessionId) {
+        candidateDirs.add(join(stateRoot, 'sessions', sessionId));
+    }
+    else {
+        for (const sid of listSessionIds(root)) {
+            candidateDirs.add(join(stateRoot, 'sessions', sid));
+        }
+    }
+    for (const dir of candidateDirs) {
+        for (const artifactName of getModeRuntimeArtifactNames(mode)) {
+            const artifactPath = join(dir, artifactName);
+            if (!existsSync(artifactPath)) {
+                continue;
+            }
+            try {
+                unlinkSync(artifactPath);
+                cleared++;
+            }
+            catch {
+                hadFailure = true;
+            }
+        }
+    }
+    return { cleared, hadFailure };
+}
 function writeSessionCancelSignal(root, sessionId, mode) {
     const now = Date.now();
     const cancelSignalPath = resolveSessionStatePath('cancel-signal', sessionId, root);
@@ -67,15 +247,6 @@ function isSessionModeActive(mode, root, sessionId) {
         return false;
     }
 }
-/**
- * Find a single other session that owns active state for the given mode.
- *
- * Resumed Ralph sessions can leave the only active state under a foreign
- * session directory. When the requester's session has no matching state,
- * this fallback lets `state_clear` reach the unambiguous single owner so
- * the stop-hook enforcement path clears cleanly. Returns undefined if there
- * are zero or multiple candidates — we never broad-clear across sessions.
- */
 function findSingleOwningSessionForMode(mode, root, requesterSessionId) {
     const owningSessions = listSessionIds(root).filter((sid) => (sid !== requesterSessionId && isSessionModeActive(mode, root, sid)));
     return owningSessions.length === 1 ? owningSessions[0] : undefined;
@@ -104,6 +275,26 @@ export const stateReadTool = {
                     ? getStateFilePath(root, mode, sessionId)
                     : resolveSessionStatePath(mode, sessionId, root);
                 if (!existsSync(statePath)) {
+                    const completedSessionPaths = findCompletedSessionStateFiles(mode, root, sessionId);
+                    if (completedSessionPaths.length > 0) {
+                        const orphanList = completedSessionPaths
+                            .map((orphanPath) => {
+                            const sessionMarker = `${join('state', 'sessions')}/`;
+                            const markerIndex = orphanPath.indexOf(sessionMarker);
+                            if (markerIndex === -1)
+                                return `- ${orphanPath}`;
+                            const rest = orphanPath.slice(markerIndex + sessionMarker.length);
+                            const orphanSessionId = rest.split(/[\\/]/)[0] || 'unknown';
+                            return `- session: ${orphanSessionId}\n  path: ${orphanPath}`;
+                        })
+                            .join('\n');
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `No state found for mode: ${mode} in session: ${sessionId}\nExpected path: ${statePath}\n\nDiscovered ${completedSessionPaths.length} completed-session orphan state file${completedSessionPaths.length === 1 ? '' : 's'} for this mode:\n${orphanList}\n\nRun state_clear(mode="${mode}", session_id="${sessionId}") to clear the current session plus these completed-session orphan files.`
+                                }]
+                        };
+                    }
                     return {
                         content: [{
                                 type: 'text',
@@ -314,56 +505,103 @@ export const stateClearTool = {
         session_id: z.string().optional().describe('Session ID for session-scoped state isolation. When provided, the tool operates only within that session. When omitted, the tool aggregates legacy state plus all session-scoped state (may include other sessions).'),
     },
     handler: async (args) => {
-        const { mode, workingDirectory, session_id } = args;
+        const { workingDirectory, session_id } = args;
+        // Zod 4 widens z.enum(tuple) value types; cast back to the runtime-validated mode.
+        const mode = args.mode;
         try {
             const root = validateWorkingDirectory(workingDirectory);
             const sessionId = session_id;
+            const cleanedTeamNames = new Set();
+            const collectTeamNamesForCleanup = (statePath) => {
+                if (mode !== 'team')
+                    return;
+                for (const teamName of readTeamNamesFromStateFile(statePath)) {
+                    cleanedTeamNames.add(teamName);
+                }
+            };
             // If session_id provided, clear only session-specific state
             if (sessionId) {
                 validateSessionId(sessionId);
+                const requestedSessionOwnedPaths = findSessionOwnedStateFiles(mode, sessionId, root);
+                for (const teamStatePath of findSessionOwnedStateFiles('team', sessionId, root)) {
+                    collectTeamNamesForCleanup(teamStatePath);
+                }
+                if (mode === 'team') {
+                    for (const teamStatePath of findCompletedSessionStateFiles('team', root, sessionId)) {
+                        collectTeamNamesForCleanup(teamStatePath);
+                    }
+                }
+                const completedSessionCleanup = clearCompletedSessionStateCandidates(mode, root, sessionId);
+                const runtimeCleanup = clearModeRuntimeArtifacts(mode, root, sessionId);
                 writeSessionCancelSignal(root, sessionId, mode);
                 if (MODE_CONFIGS[mode]) {
-                    const requesterStatePath = getStateFilePath(root, mode, sessionId);
-                    const hadRequesterState = existsSync(requesterStatePath);
                     const success = clearModeState(mode, root, sessionId);
-                    // Ghost-legacy cleanup: after clearing session file, also remove
-                    // any legacy file at .omcp/state/{mode}-state.json if it belongs
-                    // to this session (matching _meta.sessionId) or has no _meta block.
-                    let ghostCleaned = false;
-                    try {
-                        const legacyPath = getStateFilePath(root, mode);
-                        if (existsSync(legacyPath)) {
-                            const raw = JSON.parse(readFileSync(legacyPath, 'utf-8'));
-                            const meta = raw._meta;
-                            if (!meta || meta.sessionId === sessionId) {
-                                unlinkSync(legacyPath);
-                                ghostCleaned = true;
-                            }
-                        }
-                    }
-                    catch {
-                        // Best-effort ghost cleanup — ignore errors
-                    }
-                    // Cross-session fallback: if the requester had no local state and
-                    // no ghost legacy file, but exactly one other session owns active
-                    // state for this mode (e.g. a resumed Ralph whose state lives
-                    // under the original session), clear that owner too. Keep bounded
-                    // to the unambiguous single-owner case to avoid broad-clearing.
+                    const sessionCleanup = clearSessionOwnedStateCandidates(mode, root, sessionId);
+                    const legacyCleanup = clearLegacyStateCandidates(mode, root, sessionId);
                     let ownerSessionId;
-                    if (!hadRequesterState && !ghostCleaned) {
+                    let ownerSessionCleanup = { cleared: 0, hadFailure: false, paths: [] };
+                    let ownerLegacyCleanup = { cleared: 0, hadFailure: false };
+                    if (requestedSessionOwnedPaths.length === 0 &&
+                        completedSessionCleanup.cleared === 0 &&
+                        sessionCleanup.cleared === 0 &&
+                        legacyCleanup.cleared === 0) {
                         ownerSessionId = findSingleOwningSessionForMode(mode, root, sessionId);
                         if (ownerSessionId) {
+                            if (mode === 'team') {
+                                for (const teamStatePath of findSessionOwnedStateFiles('team', ownerSessionId, root)) {
+                                    collectTeamNamesForCleanup(teamStatePath);
+                                }
+                            }
                             writeSessionCancelSignal(root, ownerSessionId, mode);
+                            const ownerRuntimeCleanup = clearModeRuntimeArtifacts(mode, root, ownerSessionId);
+                            runtimeCleanup.cleared += ownerRuntimeCleanup.cleared;
+                            runtimeCleanup.hadFailure ||= ownerRuntimeCleanup.hadFailure;
                             clearModeState(mode, root, ownerSessionId);
+                            ownerSessionCleanup = clearSessionOwnedStateCandidates(mode, root, ownerSessionId);
+                            ownerLegacyCleanup = clearLegacyStateCandidates(mode, root, ownerSessionId);
                         }
                     }
-                    const ghostNote = ghostCleaned ? ' (ghost legacy file also removed)' : '';
-                    const ownerNote = ownerSessionId ? ` (cleared owning session: ${ownerSessionId})` : '';
-                    if (success || ownerSessionId) {
+                    const ghostNoteParts = [];
+                    if (legacyCleanup.cleared > 0) {
+                        ghostNoteParts.push('ghost legacy file also removed');
+                    }
+                    if (completedSessionCleanup.cleared > 0) {
+                        ghostNoteParts.push(`removed ${completedSessionCleanup.cleared} completed-session orphan file${completedSessionCleanup.cleared === 1 ? '' : 's'}`);
+                    }
+                    if (sessionCleanup.cleared > 0) {
+                        ghostNoteParts.push(`removed ${sessionCleanup.cleared} recovered session file${sessionCleanup.cleared === 1 ? '' : 's'}`);
+                    }
+                    if (runtimeCleanup.cleared > 0) {
+                        ghostNoteParts.push(`removed ${runtimeCleanup.cleared} runtime artifact${runtimeCleanup.cleared === 1 ? '' : 's'}`);
+                    }
+                    if (ownerSessionId) {
+                        ghostNoteParts.push(`cleared owning session: ${ownerSessionId}`);
+                    }
+                    const ghostNote = ghostNoteParts.length > 0 ? ` (${ghostNoteParts.join(', ')})` : '';
+                    const runtimeCleanupNote = (() => {
+                        if (mode !== 'team')
+                            return '';
+                        const teamNames = [...cleanedTeamNames];
+                        const removedRoots = cleanupTeamRuntimeState(root, teamNames);
+                        const prunedMissions = pruneMissionBoardTeams(root, teamNames);
+                        const details = [];
+                        if (removedRoots > 0)
+                            details.push(`removed ${removedRoots} team runtime root(s)`);
+                        if (prunedMissions > 0)
+                            details.push(`pruned ${prunedMissions} HUD mission entry(ies)`);
+                        return details.length > 0 ? ` (${details.join(', ')})` : '';
+                    })();
+                    if (success &&
+                        !legacyCleanup.hadFailure &&
+                        !sessionCleanup.hadFailure &&
+                        !completedSessionCleanup.hadFailure &&
+                        !ownerSessionCleanup.hadFailure &&
+                        !ownerLegacyCleanup.hadFailure &&
+                        !runtimeCleanup.hadFailure) {
                         return {
                             content: [{
                                     type: 'text',
-                                    text: `Successfully cleared state for mode: ${mode} in session: ${sessionId}${ghostNote}${ownerNote}`
+                                    text: `Successfully cleared state for mode: ${mode} in session: ${sessionId}${ghostNote}${runtimeCleanupNote}`
                                 }]
                         };
                     }
@@ -371,65 +609,111 @@ export const stateClearTool = {
                         return {
                             content: [{
                                     type: 'text',
-                                    text: `Warning: Some files could not be removed for mode: ${mode} in session: ${sessionId}${ghostNote}${ownerNote}`
+                                    text: `Warning: Some files could not be removed for mode: ${mode} in session: ${sessionId}${ghostNote}${runtimeCleanupNote}`
                                 }]
                         };
                     }
                 }
                 // Fallback for modes not in registry (e.g., ralplan)
-                const statePath = resolveSessionStatePath(mode, sessionId, root);
-                const hadRequesterState = existsSync(statePath);
-                if (hadRequesterState) {
-                    unlinkSync(statePath);
-                }
-                // Ghost-legacy cleanup for non-registry modes
-                let ghostCleaned = false;
-                try {
-                    const legacyPath = resolveStatePath(mode, root);
-                    if (existsSync(legacyPath)) {
-                        const raw = JSON.parse(readFileSync(legacyPath, 'utf-8'));
-                        const meta = raw._meta;
-                        if (!meta || meta.sessionId === sessionId) {
-                            unlinkSync(legacyPath);
-                            ghostCleaned = true;
-                        }
-                    }
-                }
-                catch {
-                    // Best-effort ghost cleanup
-                }
-                // Same cross-session fallback as the registry branch above.
+                const sessionCleanup = clearSessionOwnedStateCandidates(mode, root, sessionId);
+                const legacyCleanup = clearLegacyStateCandidates(mode, root, sessionId);
                 let ownerSessionId;
-                if (!hadRequesterState && !ghostCleaned) {
+                let ownerSessionCleanup = { cleared: 0, hadFailure: false, paths: [] };
+                let ownerLegacyCleanup = { cleared: 0, hadFailure: false };
+                if (requestedSessionOwnedPaths.length === 0 &&
+                    completedSessionCleanup.cleared === 0 &&
+                    sessionCleanup.cleared === 0 &&
+                    legacyCleanup.cleared === 0) {
                     ownerSessionId = findSingleOwningSessionForMode(mode, root, sessionId);
                     if (ownerSessionId) {
-                        writeSessionCancelSignal(root, ownerSessionId, mode);
-                        const ownerStatePath = resolveSessionStatePath(mode, ownerSessionId, root);
-                        if (existsSync(ownerStatePath)) {
-                            try {
-                                unlinkSync(ownerStatePath);
+                        if (mode === 'team') {
+                            for (const teamStatePath of findSessionOwnedStateFiles('team', ownerSessionId, root)) {
+                                collectTeamNamesForCleanup(teamStatePath);
                             }
-                            catch { /* best-effort */ }
                         }
+                        writeSessionCancelSignal(root, ownerSessionId, mode);
+                        const ownerRuntimeCleanup = clearModeRuntimeArtifacts(mode, root, ownerSessionId);
+                        runtimeCleanup.cleared += ownerRuntimeCleanup.cleared;
+                        runtimeCleanup.hadFailure ||= ownerRuntimeCleanup.hadFailure;
+                        ownerSessionCleanup = clearSessionOwnedStateCandidates(mode, root, ownerSessionId);
+                        ownerLegacyCleanup = clearLegacyStateCandidates(mode, root, ownerSessionId);
                     }
                 }
-                const ghostNote = ghostCleaned ? ' (ghost legacy file also removed)' : '';
-                const ownerNote = ownerSessionId ? ` (cleared owning session: ${ownerSessionId})` : '';
+                const ghostNoteParts = [];
+                if (legacyCleanup.cleared > 0) {
+                    ghostNoteParts.push('ghost legacy file also removed');
+                }
+                if (completedSessionCleanup.cleared > 0) {
+                    ghostNoteParts.push(`removed ${completedSessionCleanup.cleared} completed-session orphan file${completedSessionCleanup.cleared === 1 ? '' : 's'}`);
+                }
+                if (sessionCleanup.cleared > 0) {
+                    ghostNoteParts.push(`removed ${sessionCleanup.cleared} recovered session file${sessionCleanup.cleared === 1 ? '' : 's'}`);
+                }
+                if (runtimeCleanup.cleared > 0) {
+                    ghostNoteParts.push(`removed ${runtimeCleanup.cleared} runtime artifact${runtimeCleanup.cleared === 1 ? '' : 's'}`);
+                }
+                if (ownerSessionId) {
+                    ghostNoteParts.push(`cleared owning session: ${ownerSessionId}`);
+                }
+                const ghostNote = ghostNoteParts.length > 0 ? ` (${ghostNoteParts.join(', ')})` : '';
+                const runtimeCleanupNote = (() => {
+                    if (mode !== 'team')
+                        return '';
+                    const teamNames = [...cleanedTeamNames];
+                    const removedRoots = cleanupTeamRuntimeState(root, teamNames);
+                    const prunedMissions = pruneMissionBoardTeams(root, teamNames);
+                    const details = [];
+                    if (removedRoots > 0)
+                        details.push(`removed ${removedRoots} team runtime root(s)`);
+                    if (prunedMissions > 0)
+                        details.push(`pruned ${prunedMissions} HUD mission entry(ies)`);
+                    return details.length > 0 ? ` (${details.join(', ')})` : '';
+                })();
                 return {
                     content: [{
                             type: 'text',
-                            text: `Successfully cleared state for mode: ${mode} in session: ${sessionId}${ghostNote}${ownerNote}`
+                            text: `${legacyCleanup.hadFailure || sessionCleanup.hadFailure || completedSessionCleanup.hadFailure || ownerSessionCleanup.hadFailure || ownerLegacyCleanup.hadFailure || runtimeCleanup.hadFailure ? 'Warning: Some files could not be removed' : 'Successfully cleared state'} for mode: ${mode} in session: ${sessionId}${ghostNote}${runtimeCleanupNote}`
                         }]
                 };
             }
             // No session_id: clear from all locations (legacy + all sessions)
+            // Write cancel signals FIRST (before deleting files) so the stop hook's
+            // isSessionCancelInProgress check sees the signal during the deletion window.
+            // Mirrors the session_id path at line ~403. (patch: fix missing cancel signal)
+            {
+                const now = Date.now();
+                const cancelSignalPayload = {
+                    active: true,
+                    requested_at: new Date(now).toISOString(),
+                    expires_at: new Date(now + CANCEL_SIGNAL_TTL_MS).toISOString(),
+                    mode,
+                    source: 'state_clear',
+                };
+                // Write to legacy path (checked by stop hook fallback)
+                const legacySignalPath = join(getOmcRoot(root), 'state', 'cancel-signal-state.json');
+                try {
+                    atomicWriteJsonSync(legacySignalPath, cancelSignalPayload);
+                }
+                catch { /* best-effort */ }
+                // Write to each session path (checked by stop hook primary check)
+                for (const sid of listSessionIds(root)) {
+                    try {
+                        const sessionSignalPath = resolveSessionStatePath('cancel-signal', sid, root);
+                        atomicWriteJsonSync(sessionSignalPath, cancelSignalPayload);
+                    }
+                    catch { /* best-effort */ }
+                }
+            }
+            const runtimeCleanup = clearModeRuntimeArtifacts(mode, root);
             let clearedCount = 0;
             const errors = [];
+            if (mode === 'team') {
+                collectTeamNamesForCleanup(getStateFilePath(root, 'team'));
+            }
             // Clear legacy path
             if (MODE_CONFIGS[mode]) {
-                // Only clear if state file exists - avoid false counts for missing files
-                const legacyStatePath = getStateFilePath(root, mode);
-                if (existsSync(legacyStatePath)) {
+                const primaryLegacyStatePath = getStateFilePath(root, mode);
+                if (existsSync(primaryLegacyStatePath)) {
                     if (clearModeState(mode, root)) {
                         clearedCount++;
                     }
@@ -438,21 +722,21 @@ export const stateClearTool = {
                     }
                 }
             }
-            else {
-                const statePath = getStatePath(mode, root);
-                if (existsSync(statePath)) {
-                    try {
-                        unlinkSync(statePath);
-                        clearedCount++;
-                    }
-                    catch {
-                        errors.push('legacy path');
-                    }
-                }
+            const extraLegacyCleanup = clearLegacyStateCandidates(mode, root);
+            clearedCount += extraLegacyCleanup.cleared;
+            if (extraLegacyCleanup.hadFailure) {
+                errors.push('legacy path');
+            }
+            clearedCount += runtimeCleanup.cleared;
+            if (runtimeCleanup.hadFailure) {
+                errors.push('runtime artifacts');
             }
             // Clear all session-scoped state files
             const sessionIds = listSessionIds(root);
             for (const sid of sessionIds) {
+                if (mode === 'team') {
+                    collectTeamNamesForCleanup(resolveSessionStatePath('team', sid, root));
+                }
                 if (MODE_CONFIGS[mode]) {
                     // Only clear if state file exists - avoid false counts for missing files
                     const sessionStatePath = getStateFilePath(root, mode, sid);
@@ -478,7 +762,15 @@ export const stateClearTool = {
                     }
                 }
             }
-            if (clearedCount === 0 && errors.length === 0) {
+            let removedTeamRoots = 0;
+            let prunedMissionEntries = 0;
+            if (mode === 'team') {
+                const teamNames = [...cleanedTeamNames];
+                const removeSelector = teamNames.length > 0 ? teamNames : undefined;
+                removedTeamRoots = cleanupTeamRuntimeState(root, removeSelector);
+                prunedMissionEntries = pruneMissionBoardTeams(root, removeSelector);
+            }
+            if (clearedCount === 0 && errors.length === 0 && removedTeamRoots === 0 && prunedMissionEntries === 0) {
                 return {
                     content: [{
                             type: 'text',
@@ -490,6 +782,14 @@ export const stateClearTool = {
             if (errors.length > 0) {
                 message += `\n- Errors: ${errors.join(', ')}`;
             }
+            if (mode === 'team') {
+                if (removedTeamRoots > 0) {
+                    message += `\n- Team runtime roots removed: ${removedTeamRoots}`;
+                }
+                if (prunedMissionEntries > 0) {
+                    message += `\n- HUD mission entries pruned: ${prunedMissionEntries}`;
+                }
+            }
             message += '\nWARNING: No session_id provided. Cleared legacy plus all session-scoped state; this is a broad operation that may affect other sessions.';
             return {
                 content: [{
@@ -655,7 +955,9 @@ export const stateGetStatusTool = {
         session_id: z.string().optional().describe('Session ID for session-scoped state isolation. When provided, the tool operates only within that session. When omitted, the tool aggregates legacy state plus all session-scoped state (may include other sessions).'),
     },
     handler: async (args) => {
-        const { mode, workingDirectory, session_id } = args;
+        const { workingDirectory, session_id } = args;
+        // Zod 4 widens z.enum(tuple) value types; cast back to the runtime-validated mode.
+        const mode = args.mode;
         try {
             const root = validateWorkingDirectory(workingDirectory);
             const sessionId = session_id;