oh-my-copilot 4.13.1 → 4.13.21

package/scripts/persistent-mode.cjs

@@ -572,6 +572,32 @@ function readStateFileWithSession(stateDir, filename, sessionId) {
   return readStateFile(stateDir, filename);
 }
 
+const WORKFLOW_SLOT_TOMBSTONE_TTL_MS = 24 * 60 * 60 * 1000;
+
+function isWorkflowSlotTombstonedForMode(stateDir, mode, sessionId) {
+  const safeSessionId = sessionId && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(sessionId) ? sessionId : "";
+  const ledgerPath = safeSessionId
+    ? join(stateDir, "sessions", safeSessionId, "skill-active-state.json")
+    : join(stateDir, "skill-active-state.json");
+  const ledger = readJsonFile(ledgerPath);
+  const slot = ledger?.active_skills?.[mode];
+  if (!slot || typeof slot !== "object") return false;
+  if (typeof slot.completed_at !== "string" || !slot.completed_at) return false;
+  const completedAt = new Date(slot.completed_at).getTime();
+  if (!Number.isFinite(completedAt)) return true;
+  return Date.now() - completedAt < WORKFLOW_SLOT_TOMBSTONE_TTL_MS;
+}
+
+function isAuthoritativeModeActive(stateDir, mode, loaded, sessionId) {
+  const state = loaded?.state;
+  if (!state?.active) return false;
+  if (isWorkflowSlotTombstonedForMode(stateDir, mode, sessionId)) return false;
+  const safeSessionId = sessionId && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(sessionId) ? sessionId : "";
+  if (safeSessionId && state.session_id && state.session_id !== safeSessionId) return false;
+  return true;
+}
+
+
 function getActiveSubagentCount(stateDir) {
   try {
     const tracking = readJsonFile(join(stateDir, "subagent-tracking.json"));
@@ -891,7 +917,7 @@ async function main() {
 
     // Priority 1: Ralph Loop (explicit persistence mode)
     // Skip if state is stale (older than 2 hours) - prevents blocking new sessions
-    if (ralph.state?.active && !isAwaitingConfirmation(ralph.state) && !isStaleState(ralph.state) && isSessionMatch(ralph.state, sessionId)) {
+    if (isAuthoritativeModeActive(stateDir, "ralph", ralph, sessionId) && !isAwaitingConfirmation(ralph.state) && !isStaleState(ralph.state) && isSessionMatch(ralph.state, sessionId)) {
       const iteration = ralph.state.iteration || 1;
       const maxIter = ralph.state.max_iterations || 100;
 
@@ -1212,7 +1238,7 @@ async function main() {
     // Session isolation: only block if state belongs to this session (issue #311)
     // Project isolation: only block if state belongs to this project
     if (
-      ultrawork.state?.active && !isAwaitingConfirmation(ultrawork.state) &&
+      isAuthoritativeModeActive(stateDir, "ultrawork", ultrawork, sessionId) && !isAwaitingConfirmation(ultrawork.state) &&
       !isStaleState(ultrawork.state) &&
       isSessionMatch(ultrawork.state, sessionId) &&
       isStateForCurrentProject(ultrawork.state, directory, ultrawork.isGlobal)

package/scripts/persistent-mode.mjs

@@ -370,6 +370,32 @@ function readStateFileWithSession(stateDir, globalStateDir, filename, sessionId)
   return readStateFile(stateDir, globalStateDir, filename);
 }
 
+const WORKFLOW_SLOT_TOMBSTONE_TTL_MS = 24 * 60 * 60 * 1000;
+
+function isWorkflowSlotTombstonedForMode(stateDir, mode, sessionId) {
+  const safeSessionId = sanitizeSessionId(sessionId);
+  const ledgerPath = safeSessionId
+    ? join(stateDir, "sessions", safeSessionId, "skill-active-state.json")
+    : join(stateDir, "skill-active-state.json");
+  const ledger = readJsonFile(ledgerPath);
+  const slot = ledger?.active_skills?.[mode];
+  if (!slot || typeof slot !== "object") return false;
+  if (typeof slot.completed_at !== "string" || !slot.completed_at) return false;
+  const completedAt = new Date(slot.completed_at).getTime();
+  if (!Number.isFinite(completedAt)) return true;
+  return Date.now() - completedAt < WORKFLOW_SLOT_TOMBSTONE_TTL_MS;
+}
+
+function isAuthoritativeModeActive(stateDir, mode, loaded, sessionId) {
+  const state = loaded?.state;
+  if (!state?.active) return false;
+  if (isWorkflowSlotTombstonedForMode(stateDir, mode, sessionId)) return false;
+  const safeSessionId = sanitizeSessionId(sessionId);
+  if (safeSessionId && state.session_id && state.session_id !== safeSessionId) return false;
+  return true;
+}
+
+
 function isSessionCancelInProgress(stateDir, sessionId) {
   const isActiveSignal = (signalPath) => {
     const signal = readJsonFile(signalPath);
@@ -762,7 +788,7 @@ async function main() {
     // Priority 1: Ralph Loop (explicit persistence mode)
     // Skip if state is stale (older than 2 hours) - prevents blocking new sessions
     if (
-      ralph.state?.active && !isAwaitingConfirmation(ralph.state) &&
+      isAuthoritativeModeActive(stateDir, "ralph", ralph, sessionId) && !isAwaitingConfirmation(ralph.state) &&
       !isStaleState(ralph.state) &&
       isStateForCurrentProject(ralph.state, directory, ralph.isGlobal)
     ) {
@@ -1102,7 +1128,7 @@ async function main() {
     // If state has session_id, it must match. If no session_id (legacy), allow.
     // Project isolation: only block if state belongs to this project
     if (
-      ultrawork.state?.active && !isAwaitingConfirmation(ultrawork.state) &&
+      isAuthoritativeModeActive(stateDir, "ultrawork", ultrawork, sessionId) && !isAwaitingConfirmation(ultrawork.state) &&
       !isStaleState(ultrawork.state) &&
       (hasValidSessionId
         ? ultrawork.state.session_id === sessionId

package/scripts/plugin-setup.mjs

@@ -35,6 +35,11 @@ if (!existsSync(HUD_LIB_DIR)) {
   mkdirSync(HUD_LIB_DIR, { recursive: true });
 }
 copyFileSync(join(__dirname, 'lib', 'config-dir.mjs'), join(HUD_LIB_DIR, 'config-dir.mjs'));
+copyFileSync(join(__dirname, 'lib', 'config-dir.sh'), join(HUD_LIB_DIR, 'config-dir.sh'));
+copyFileSync(join(__dirname, 'find-node.sh'), join(HUD_DIR, 'find-node.sh'));
+copyFileSync(join(__dirname, 'lib', 'hud-cache-wrapper.sh'), join(HUD_DIR, 'omcp-hud-cache.sh'));
+try { chmodSync(join(HUD_DIR, 'find-node.sh'), 0o755); } catch { /* Windows doesn't need this */ }
+try { chmodSync(join(HUD_DIR, 'omcp-hud-cache.sh'), 0o755); } catch { /* Windows doesn't need this */ }
 
 // 2. Create HUD wrapper script
 const hudScriptPath = join(HUD_DIR, 'omcp-hud.mjs').replace(/\\/g, '/');
@@ -238,9 +243,13 @@ try {
     settings = JSON.parse(readFileSync(SETTINGS_FILE, 'utf-8'));
   }
 
+  const statusLineCommand = process.platform === 'win32'
+    ? `"${nodeBin}" "${hudScriptPath.replace(/\\/g, "/")}"`
+    : `sh "${join(HUD_DIR, 'omcp-hud-cache.sh').replace(/\\/g, "/")}" "${hudScriptPath.replace(/\\/g, "/")}"`;
+
   settings.statusLine = {
     type: 'command',
-    command: `"${nodeBin}" "${hudScriptPath.replace(/\\/g, "/")}"`
+    command: statusLineCommand
   };
   writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
   console.log('[OMC] Configured HUD statusLine in settings.json');

package/scripts/post-tool-verifier.mjs

@@ -718,6 +718,145 @@ export function isCopilotCliWriteSuccess(output) {
   return successPatterns.some(pattern => pattern.test(cleaned));
 }
 
+function extractTextFromKnownToolResponseField(value, depth = 0) {
+  if (typeof value === 'string') return [value];
+  if (!value || depth > 4) return [];
+
+  if (Array.isArray(value)) {
+    return value.flatMap(item => extractTextFromKnownToolResponseField(item, depth + 1));
+  }
+
+  if (typeof value !== 'object') return [];
+
+  const textFields = ['text', 'message', 'result', 'output', 'stdout'];
+  const texts = [];
+  for (const field of textFields) {
+    if (typeof value[field] === 'string') {
+      texts.push(value[field]);
+    }
+  }
+
+  if (
+    'content' in value &&
+    value.content &&
+    (Array.isArray(value.content) || typeof value.content === 'object')
+  ) {
+    texts.push(...extractTextFromKnownToolResponseField(value.content, depth + 1));
+  }
+
+  return texts;
+}
+
+function isStructuredEnvelopePayloadField(fieldName) {
+  return new Set([
+    'content',
+    'oldstring',
+    'newstring',
+    'originalfile',
+    'structuredpatch',
+    'patch',
+    'diff',
+    'lines',
+    'line',
+  ]).has(fieldName.toLowerCase());
+}
+
+function isStructuredEnvelopeStatusTextField(fieldName) {
+  return new Set(['message', 'output', 'stdout', 'stderr', 'text', 'result'])
+    .has(fieldName.toLowerCase());
+}
+
+function hasExplicitStructuredFailureIndicator(value, depth = 0, fieldName = '') {
+  if (!value || typeof value === 'string' || depth > 4) return false;
+  if (fieldName && isStructuredEnvelopePayloadField(fieldName)) return false;
+
+  if (Array.isArray(value)) {
+    return value.some(item => hasExplicitStructuredFailureIndicator(item, depth + 1, fieldName));
+  }
+
+  if (typeof value !== 'object') return false;
+
+  for (const [key, fieldValue] of Object.entries(value)) {
+    const normalizedKey = key.toLowerCase();
+    if (
+      typeof fieldValue === 'string' &&
+      isStructuredEnvelopeStatusTextField(key) &&
+      detectWriteFailure(fieldValue)
+    ) {
+      return true;
+    }
+
+    if (
+      (normalizedKey.includes('error') || normalizedKey.includes('fail')) &&
+      fieldValue !== false &&
+      fieldValue !== 0 &&
+      fieldValue !== null &&
+      fieldValue !== undefined &&
+      !(typeof fieldValue === 'string' && fieldValue.trim() === '') &&
+      !(Array.isArray(fieldValue) && fieldValue.length === 0)
+    ) {
+      return true;
+    }
+
+    if (hasExplicitStructuredFailureIndicator(fieldValue, depth + 1, key)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function hasEditEnvelopeSuccess(value, depth = 0) {
+  if (!value || typeof value === 'string' || depth > 4) return false;
+
+  if (Array.isArray(value)) {
+    return value.some(item => hasEditEnvelopeSuccess(item, depth + 1));
+  }
+
+  if (typeof value !== 'object') return false;
+
+  if (hasExplicitStructuredFailureIndicator(value, depth)) return false;
+
+  if (typeof value.filePath === 'string' && Array.isArray(value.structuredPatch)) {
+    return true;
+  }
+
+  return Object.values(value).some(item => hasEditEnvelopeSuccess(item, depth + 1));
+}
+
+function hasWriteEnvelopeSuccess(value, depth = 0) {
+  if (!value || typeof value === 'string' || depth > 4) return false;
+
+  if (Array.isArray(value)) {
+    return value.some(item => hasWriteEnvelopeSuccess(item, depth + 1));
+  }
+
+  if (typeof value !== 'object') return false;
+
+  if (hasExplicitStructuredFailureIndicator(value, depth)) return false;
+
+  if (
+    typeof value.filePath === 'string' &&
+    (value.type === 'create' || value.type === 'update')
+  ) {
+    return true;
+  }
+
+  return Object.values(value).some(item => hasWriteEnvelopeSuccess(item, depth + 1));
+}
+
+function hasStructuredWriteSuccess(rawResponse, toolName = '') {
+  if (!rawResponse || typeof rawResponse === 'string') return false;
+  if (toolName === 'Edit' && hasEditEnvelopeSuccess(rawResponse)) return true;
+  if (toolName === 'Write' && hasWriteEnvelopeSuccess(rawResponse)) return true;
+  return extractTextFromKnownToolResponseField(rawResponse).some(isCopilotCliWriteSuccess);
+}
+
+function hasStructuredWriteFailure(rawResponse) {
+  if (!rawResponse || typeof rawResponse === 'string') return false;
+  return hasExplicitStructuredFailureIndicator(rawResponse);
+}
+
 // Get agent completion summary from tracking state
 function getAgentCompletionSummary(directory, quietLevel = QUIET_LEVEL) {
   const trackingFile = join(directory, '.omcp', 'state', 'subagent-tracking.json');
@@ -746,7 +885,12 @@ function getAgentCompletionSummary(directory, quietLevel = QUIET_LEVEL) {
 
 // Generate contextual message
 function generateMessage(toolName, toolOutput, sessionId, toolCount, directory, options = {}) {
-  const { wasTruncated = false, rawLength = 0 } = options;
+  const {
+    wasTruncated = false,
+    rawLength = 0,
+    structuredWriteSuccess = false,
+    structuredWriteFailure = false,
+  } = options;
   let message = '';
 
   switch (toolName) {
@@ -797,7 +941,7 @@ function generateMessage(toolName, toolOutput, sessionId, toolCount, directory,
     }
 
     case 'Edit':
-      if (!isCopilotCliWriteSuccess(toolOutput) && detectWriteFailure(toolOutput)) {
+      if (structuredWriteFailure || (!structuredWriteSuccess && !isCopilotCliWriteSuccess(toolOutput) && detectWriteFailure(toolOutput))) {
         message = 'Edit operation failed. Verify file exists and content matches exactly.';
       } else if (QUIET_LEVEL === 0) {
         message = 'Code modified. Verify changes work as expected before marking complete.';
@@ -805,7 +949,7 @@ function generateMessage(toolName, toolOutput, sessionId, toolCount, directory,
       break;
 
     case 'Write':
-      if (!isCopilotCliWriteSuccess(toolOutput) && detectWriteFailure(toolOutput)) {
+      if (structuredWriteFailure || (!structuredWriteSuccess && !isCopilotCliWriteSuccess(toolOutput) && detectWriteFailure(toolOutput))) {
         message = 'Write operation failed. Check file permissions and directory existence.';
       } else if (QUIET_LEVEL === 0) {
         message = 'File written. Test the changes to ensure they work correctly.';
@@ -862,6 +1006,10 @@ async function main() {
 
     const toolName = data.tool_name || data.toolName || '';
     const rawResponse = data.tool_response || data.toolOutput || '';
+    const structuredWriteSuccess =
+      (toolName === 'Write' || toolName === 'Edit') && hasStructuredWriteSuccess(rawResponse, toolName);
+    const structuredWriteFailure =
+      (toolName === 'Write' || toolName === 'Edit') && hasStructuredWriteFailure(rawResponse);
     const toolOutput = typeof rawResponse === 'string' ? rawResponse : JSON.stringify(rawResponse);
     const { clipped: clippedToolOutput, wasTruncated } = clipToolOutputForAnalysis(toolName, toolOutput);
     const sessionId = data.session_id || data.sessionId || 'unknown';
@@ -907,6 +1055,8 @@ async function main() {
       generateMessage(toolName, clippedToolOutput, sessionId, toolCount, directory, {
         wasTruncated,
         rawLength: toolOutput.length,
+        structuredWriteSuccess,
+        structuredWriteFailure,
       }),
       maybeBuildPreemptiveCompactionMessage(toolName, data, directory),
     );

package/scripts/pre-tool-enforcer.mjs

@@ -10,7 +10,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFile
 import { dirname, join, resolve } from 'path';
 import { execSync } from 'child_process';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { getClaudeConfigDir } from './lib/config-dir.mjs';
+import { getCopilotConfigDir } from './lib/config-dir.mjs';
 import { evaluateAgentHeavyPreflight } from './lib/pre-tool-enforcer-preflight.mjs';
 import { resolveOmcStateRoot } from './lib/state-root.mjs';
 import { readStdin } from './lib/stdin.mjs';
@@ -29,6 +29,53 @@ function hasExtendedContextSuffix(modelId) {
 function isSubagentSafeModelId(modelId) {
   return isProviderSpecificModelId(modelId) && !hasExtendedContextSuffix(modelId);
 }
+function isBedrockProviderEnv() {
+  if (process.env.CLAUDE_CODE_USE_BEDROCK === '1') return true;
+  const modelId = process.env.CLAUDE_MODEL || process.env.ANTHROPIC_MODEL || '';
+  if (/^((us|eu|ap|global)\.anthropic\.|anthropic\.claude)/i.test(modelId)) return true;
+  if (
+    /^arn:aws(-[^:]+)?:bedrock:/i.test(modelId)
+    && /:(inference-profile|application-inference-profile)\//i.test(modelId)
+    && modelId.toLowerCase().includes('claude')
+  ) {
+    return true;
+  }
+  return false;
+}
+function isVertexProviderEnv() {
+  if (process.env.CLAUDE_CODE_USE_VERTEX === '1') return true;
+  const modelId = process.env.CLAUDE_MODEL || process.env.ANTHROPIC_MODEL || '';
+  return !!modelId && modelId.toLowerCase().startsWith('vertex_ai/');
+}
+function getActiveModelIds() {
+  return [process.env.CLAUDE_MODEL || '', process.env.ANTHROPIC_MODEL || ''].filter(Boolean);
+}
+function isNormalClaudeModelId(modelId) {
+  const lower = (modelId || '').toLowerCase();
+  return Boolean(lower) && lower.includes('claude') && !isProviderSpecificModelId(modelId);
+}
+function hasNormalClaudeActiveModel() {
+  return getActiveModelIds().some(isNormalClaudeModelId);
+}
+function isConfigForceInheritProxyEnv() {
+  const config = loadOmcConfig();
+  return config.routing?.forceInherit === true && !hasNormalClaudeActiveModel();
+}
+function isNonClaudeProviderEnv() {
+  if (isBedrockProviderEnv() || isVertexProviderEnv()) return true;
+  const modelId = process.env.CLAUDE_MODEL || process.env.ANTHROPIC_MODEL || '';
+  if (modelId && !modelId.toLowerCase().includes('claude')) return true;
+  const baseUrl = process.env.ANTHROPIC_BASE_URL || '';
+  if (baseUrl && !baseUrl.includes('anthropic.com')) return true;
+  return isConfigForceInheritProxyEnv();
+}
+function acceptsProxyAnthropicDefaultTierValue(key, value) {
+  return key.startsWith('ANTHROPIC_DEFAULT_')
+    && Boolean(value)
+    && isNonClaudeProviderEnv()
+    && !isBedrockProviderEnv()
+    && !isVertexProviderEnv();
+}
 const TIER_ALIASES = new Set(['sonnet', 'opus', 'haiku']);
 function isTierAlias(modelId) {
   return TIER_ALIASES.has((modelId || '').toLowerCase());
@@ -55,9 +102,10 @@ function resolveTierAliasToSafeModel(tierAlias) {
     // model resolution, which handles [1m] suffixes correctly for explicit model= calls.
     // OMC-internal vars (OMC_SUBAGENT_MODEL, OMC_MODEL_*) are not read by CC, so a [1m]
     // value there is not a valid routing proof — keep the stricter isSubagentSafeModelId check.
-    const isNativeCcVar = key.startsWith('ANTHROPIC_DEFAULT_') || key.startsWith('CLAUDE_CODE_BEDROCK_');
+    const isAnthropicDefaultTierVar = key.startsWith('ANTHROPIC_DEFAULT_');
+    const isNativeCcVar = isAnthropicDefaultTierVar || key.startsWith('CLAUDE_CODE_BEDROCK_');
     const validator = isNativeCcVar ? isProviderSpecificModelId : isSubagentSafeModelId;
-    if (value && validator(value)) return value;
+    if (value && (validator(value) || acceptsProxyAnthropicDefaultTierValue(key, value))) return value;
   }
   return '';
 }
@@ -167,7 +215,7 @@ function resolveTranscriptPath(transcriptPath, cwd) {
       const lastSep = transcriptPath.lastIndexOf('/');
       const sessionFile = lastSep !== -1 ? transcriptPath.substring(lastSep + 1) : '';
       if (sessionFile) {
-        const configDir = getClaudeConfigDir();
+        const configDir = getCopilotConfigDir();
         const projectsDir = join(configDir, 'projects');
         if (existsSync(projectsDir)) {
           const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
@@ -518,8 +566,8 @@ function getSkillProtectionLevel(skillName, rawSkillName) {
 // Load OMC config to check forceInherit setting (issues #1135, #1201)
 function loadOmcConfig() {
   const configPaths = [
-    join(getClaudeConfigDir(), '.omc-config.json'),
-    join(process.cwd(), '.omc', 'config.json'),
+    join(getCopilotConfigDir(), '.omc-config.json'),
+    join(process.cwd(), '.omcp', 'config.json'),
   ];
   for (const configPath of configPaths) {
     try {

package/scripts/session-start.mjs

@@ -48,6 +48,180 @@ function readJsonFile(path) {
   }
 }
 
+const WORKFLOW_SLOT_TOMBSTONE_TTL_MS = 24 * 60 * 60 * 1000;
+
+function isWorkflowSlotTombstonedForMode(omcRoot, mode, sessionId) {
+  const safeSessionId = typeof sessionId === 'string' && SAFE_SESSION_ID_PATTERN.test(sessionId) ? sessionId : '';
+  const ledgerPath = safeSessionId
+    ? join(omcRoot, 'state', 'sessions', safeSessionId, 'skill-active-state.json')
+    : join(omcRoot, 'state', 'skill-active-state.json');
+  const ledger = readJsonFile(ledgerPath);
+  const slot = ledger?.active_skills?.[mode];
+  if (!slot || typeof slot !== 'object') return false;
+  if (typeof slot.completed_at !== 'string' || !slot.completed_at) return false;
+  const completedAt = new Date(slot.completed_at).getTime();
+  if (!Number.isFinite(completedAt)) return true;
+  return Date.now() - completedAt < WORKFLOW_SLOT_TOMBSTONE_TTL_MS;
+}
+
+function shouldRestoreModeState(omcRoot, mode, state, sessionId) {
+  if (!state?.active) return false;
+  if (isWorkflowSlotTombstonedForMode(omcRoot, mode, sessionId)) return false;
+  return true;
+}
+
+function readLinuxBootId() {
+  try {
+    if (!existsSync(LINUX_BOOT_ID_PATH)) return undefined;
+    const bootId = readFileSync(LINUX_BOOT_ID_PATH, 'utf-8').trim();
+    return bootId || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function sessionStateDir(omcRoot, sessionId) {
+  return join(omcRoot, 'state', 'sessions', sessionId);
+}
+
+function sessionStartedMarkerPath(omcRoot, sessionId) {
+  return join(sessionStateDir(omcRoot, sessionId), SESSION_STARTED_MARKER_FILE);
+}
+
+function writeSessionStartedMarker(omcRoot, directory, sessionId) {
+  if (!sessionId || !SAFE_SESSION_ID_PATTERN.test(sessionId)) return;
+  try {
+    const dir = sessionStateDir(omcRoot, sessionId);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      sessionStartedMarkerPath(omcRoot, sessionId),
+      JSON.stringify({
+        session_id: sessionId,
+        started_at: new Date().toISOString(),
+        cwd: directory,
+        pid: process.pid,
+        // Do not persist process.ppid here: installed hooks run through
+        // scripts/run.cjs, whose short-lived process exits as soon as this
+        // hook returns. Treating that runner PID as owner liveness caused
+        // later SessionStart hooks to falsely clean live session state.
+        boot_id: readLinuxBootId(),
+      }, null, 2),
+      { encoding: 'utf-8', mode: 0o600 },
+    );
+  } catch {
+    // Best-effort only; SessionStart must remain non-blocking.
+  }
+}
+
+function removeSessionStartedMarker(omcRoot, sessionId) {
+  if (!sessionId || !SAFE_SESSION_ID_PATTERN.test(sessionId)) return;
+  try {
+    const markerPath = sessionStartedMarkerPath(omcRoot, sessionId);
+    if (existsSync(markerPath)) unlinkSync(markerPath);
+  } catch {
+    // Best-effort only.
+  }
+}
+
+/**
+ * Return true only when SessionStart has durable abandonment evidence.
+ *
+ * Claude Code SessionStart input currently provides session metadata such as
+ * session_id, transcript_path, cwd, source, model, and agent_type, but no
+ * stable owner process for the interactive session. In installed OMC hooks the
+ * immediate hook parent belongs to scripts/run.cjs and is intentionally
+ * short-lived, so same-boot PID liveness checks are not reliable here. SessionEnd
+ * remains the primary same-boot cleanup path; SessionStart only reconciles
+ * durable leftovers, such as markers from a previous OS boot.
+ */
+function hasDurableAbandonmentEvidence(marker) {
+  const storedBootId = typeof marker?.boot_id === 'string' ? marker.boot_id : undefined;
+  const currentBootId = readLinuxBootId();
+  if (storedBootId && currentBootId && storedBootId !== currentBootId) {
+    return true;
+  }
+
+  // Same-boot hard-kill cleanup requires a durable owner signal. Claude Code
+  // does not currently provide one to hooks, so keep active state rather than
+  // guessing from hook-runner process ancestry or transcript metadata.
+  return false;
+}
+
+function cleanupSessionModeState(omcRoot, sessionId) {
+  const sessionDir = sessionStateDir(omcRoot, sessionId);
+  for (const file of SESSION_END_MODE_STATE_FILES) {
+    try {
+      const filePath = join(sessionDir, file);
+      const state = readJsonFile(filePath);
+      if (state?.active === true || file === 'skill-active-state.json') {
+        unlinkSync(filePath);
+      }
+    } catch {
+      // Leave ambiguous/unreadable state untouched.
+    }
+  }
+}
+
+function cleanupMissionStateForSession(omcRoot, sessionId) {
+  const missionStatePath = join(omcRoot, 'state', 'mission-state.json');
+  const parsed = readJsonFile(missionStatePath);
+  if (!Array.isArray(parsed?.missions)) return;
+
+  const before = parsed.missions.length;
+  parsed.missions = parsed.missions.filter((mission) => {
+    if (mission?.source !== 'session') return true;
+    const missionId = typeof mission.id === 'string' ? mission.id : '';
+    return !missionId.includes(sessionId);
+  });
+  if (parsed.missions.length !== before) {
+    parsed.updatedAt = new Date().toISOString();
+    try {
+      writeFileSync(missionStatePath, JSON.stringify(parsed, null, 2));
+    } catch {
+      // Best-effort only.
+    }
+  }
+}
+
+function reconcileAbandonedSessionStarts(omcRoot, currentSessionId) {
+  const sessionsDir = join(omcRoot, 'state', 'sessions');
+  if (!existsSync(sessionsDir)) return;
+
+  let entries = [];
+  try {
+    entries = readdirSync(sessionsDir);
+  } catch {
+    return;
+  }
+
+  for (const sessionId of entries) {
+    if (!SAFE_SESSION_ID_PATTERN.test(sessionId) || sessionId === currentSessionId) continue;
+
+    const marker = readJsonFile(sessionStartedMarkerPath(omcRoot, sessionId));
+    if (!marker || marker.session_id !== sessionId) continue;
+
+    if (existsSync(join(omcRoot, 'sessions', `${sessionId}.json`))) {
+      removeSessionStartedMarker(omcRoot, sessionId);
+      continue;
+    }
+
+    if (!hasDurableAbandonmentEvidence(marker)) continue;
+
+    cleanupSessionModeState(omcRoot, sessionId);
+    cleanupMissionStateForSession(omcRoot, sessionId);
+    removeSessionStartedMarker(omcRoot, sessionId);
+
+    try {
+      const sessionDir = sessionStateDir(omcRoot, sessionId);
+      if (readdirSync(sessionDir).length === 0) {
+        rmSync(sessionDir, { recursive: false, force: true });
+      }
+    } catch {
+      // Leave non-empty/unreadable directories untouched.
+    }
+  }
+}
+
 function getRuntimeBaseDir() {
   return process.env.PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT || join(__dirname, '..');
 }
@@ -145,6 +319,21 @@ function semverCompare(a, b) {
 
 const SESSION_START_CONTEXT_BUDGET = 6000;
 const SESSION_START_OMISSION_NOTICE = '[Additional SessionStart context omitted to preserve the 6000-character aggregate budget.]';
+const SESSION_STARTED_MARKER_FILE = 'session-started.json';
+const SAFE_SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
+const LINUX_BOOT_ID_PATH = '/proc/sys/kernel/random/boot_id';
+const SESSION_END_MODE_STATE_FILES = [
+  'autopilot-state.json',
+  'autoresearch-state.json',
+  'team-state.json',
+  'ralph-state.json',
+  'ultrawork-state.json',
+  'ultraqa-state.json',
+  'ralplan-state.json',
+  'deep-interview-state.json',
+  'self-improve-state.json',
+  'skill-active-state.json',
+];
 
 function compactBudgetedText(text, maxChars) {
   const notice = '\n...[truncated to preserve SessionStart context budget]';
@@ -432,6 +621,9 @@ async function main() {
     const messages = [];
     const projectMemoryModules = await loadProjectMemoryModules();
 
+    writeSessionStartedMarker(omcRoot, directory, sessionId);
+    reconcileAbandonedSessionStarts(omcRoot, sessionId);
+
     // Check for version drift between components
     const driftInfo = detectVersionDrift();
     if (driftInfo && shouldNotifyDrift(driftInfo)) {
@@ -489,7 +681,7 @@ async function main() {
       ultraworkState = readJsonFile(join(omcRoot, 'state', 'ultrawork-state.json'));
     }
 
-    if (ultraworkState?.active) {
+    if (shouldRestoreModeState(omcRoot, 'ultrawork', ultraworkState, sessionId)) {
       messages.push(`<session-restore>
 
 [ULTRAWORK MODE RESTORED]
@@ -522,7 +714,7 @@ Treat this as prior-session context only. Prioritize the user's newest request,
         ralphState = readJsonFile(join(omcRoot, 'ralph-state.json'));
       }
     }
-    if (ralphState?.active) {
+    if (shouldRestoreModeState(omcRoot, 'ralph', ralphState, sessionId)) {
       messages.push(`<session-restore>
 
 [RALPH LOOP RESTORED]