claudecode-omc 4.4.4 → 4.4.6

package/dist/lib/mode-names.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Mode Names - Single source of truth for all execution mode name constants.
+ *
+ * Every module that references mode names by string should import from here
+ * instead of hardcoding literals. This prevents drift when modes are added,
+ * renamed, or removed.
+ */
+/** All supported execution mode identifiers. */
+export declare const MODE_NAMES: {
+    readonly AUTOPILOT: "autopilot";
+    readonly ULTRAPILOT: "ultrapilot";
+    readonly SWARM: "swarm";
+    readonly PIPELINE: "pipeline";
+    readonly TEAM: "team";
+    readonly RALPH: "ralph";
+    readonly ULTRAWORK: "ultrawork";
+    readonly ULTRAQA: "ultraqa";
+};
+/** Union type derived from the constant map. */
+export type ModeName = typeof MODE_NAMES[keyof typeof MODE_NAMES];
+/**
+ * All mode names as an array (useful for iteration).
+ * Order matches the canonical ExecutionMode union in mode-registry/types.ts.
+ */
+export declare const ALL_MODE_NAMES: readonly ModeName[];
+/**
+ * Mode state file mapping — the canonical filename for each mode's state file
+ * relative to `.omc/state/`.
+ */
+export declare const MODE_STATE_FILE_MAP: Readonly<Record<ModeName, string>>;
+/**
+ * Mode state files used by session-end cleanup.
+ * Includes marker files for modes that use them.
+ */
+export declare const SESSION_END_MODE_STATE_FILES: readonly {
+    file: string;
+    mode: string;
+}[];
+/**
+ * Modes detected by session-end for metrics reporting.
+ */
+export declare const SESSION_METRICS_MODE_FILES: readonly {
+    file: string;
+    mode: string;
+}[];
+//# sourceMappingURL=mode-names.d.ts.map

package/dist/lib/mode-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-names.d.ts","sourceRoot":"","sources":["../../src/lib/mode-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,gDAAgD;AAChD,eAAO,MAAM,UAAU;;;;;;;;;CASb,CAAC;AAEX,gDAAgD;AAChD,MAAM,MAAM,QAAQ,GAAG,OAAO,UAAU,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,QAAQ,EASpC,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CASlE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAUjF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAO/E,CAAC"}

package/dist/lib/mode-names.js

@@ -0,0 +1,73 @@
+/**
+ * Mode Names - Single source of truth for all execution mode name constants.
+ *
+ * Every module that references mode names by string should import from here
+ * instead of hardcoding literals. This prevents drift when modes are added,
+ * renamed, or removed.
+ */
+/** All supported execution mode identifiers. */
+export const MODE_NAMES = {
+    AUTOPILOT: 'autopilot',
+    ULTRAPILOT: 'ultrapilot',
+    SWARM: 'swarm',
+    PIPELINE: 'pipeline',
+    TEAM: 'team',
+    RALPH: 'ralph',
+    ULTRAWORK: 'ultrawork',
+    ULTRAQA: 'ultraqa',
+};
+/**
+ * All mode names as an array (useful for iteration).
+ * Order matches the canonical ExecutionMode union in mode-registry/types.ts.
+ */
+export const ALL_MODE_NAMES = [
+    MODE_NAMES.AUTOPILOT,
+    MODE_NAMES.ULTRAPILOT,
+    MODE_NAMES.SWARM,
+    MODE_NAMES.PIPELINE,
+    MODE_NAMES.TEAM,
+    MODE_NAMES.RALPH,
+    MODE_NAMES.ULTRAWORK,
+    MODE_NAMES.ULTRAQA,
+];
+/**
+ * Mode state file mapping — the canonical filename for each mode's state file
+ * relative to `.omc/state/`.
+ */
+export const MODE_STATE_FILE_MAP = {
+    [MODE_NAMES.AUTOPILOT]: 'autopilot-state.json',
+    [MODE_NAMES.ULTRAPILOT]: 'ultrapilot-state.json',
+    [MODE_NAMES.SWARM]: 'swarm.db',
+    [MODE_NAMES.PIPELINE]: 'pipeline-state.json',
+    [MODE_NAMES.TEAM]: 'team-state.json',
+    [MODE_NAMES.RALPH]: 'ralph-state.json',
+    [MODE_NAMES.ULTRAWORK]: 'ultrawork-state.json',
+    [MODE_NAMES.ULTRAQA]: 'ultraqa-state.json',
+};
+/**
+ * Mode state files used by session-end cleanup.
+ * Includes marker files for modes that use them.
+ */
+export const SESSION_END_MODE_STATE_FILES = [
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.AUTOPILOT], mode: MODE_NAMES.AUTOPILOT },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.ULTRAPILOT], mode: MODE_NAMES.ULTRAPILOT },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.RALPH], mode: MODE_NAMES.RALPH },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.ULTRAWORK], mode: MODE_NAMES.ULTRAWORK },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.ULTRAQA], mode: MODE_NAMES.ULTRAQA },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.PIPELINE], mode: MODE_NAMES.PIPELINE },
+    // Swarm uses marker file + SQLite
+    { file: 'swarm-active.marker', mode: MODE_NAMES.SWARM },
+    { file: 'swarm-summary.json', mode: MODE_NAMES.SWARM },
+];
+/**
+ * Modes detected by session-end for metrics reporting.
+ */
+export const SESSION_METRICS_MODE_FILES = [
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.AUTOPILOT], mode: MODE_NAMES.AUTOPILOT },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.ULTRAPILOT], mode: MODE_NAMES.ULTRAPILOT },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.RALPH], mode: MODE_NAMES.RALPH },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.ULTRAWORK], mode: MODE_NAMES.ULTRAWORK },
+    { file: 'swarm-state.json', mode: MODE_NAMES.SWARM },
+    { file: MODE_STATE_FILE_MAP[MODE_NAMES.PIPELINE], mode: MODE_NAMES.PIPELINE },
+];
+//# sourceMappingURL=mode-names.js.map

package/dist/lib/mode-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-names.js","sourceRoot":"","sources":["../../src/lib/mode-names.ts"],"names":[],"mappings":"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"}

package/dist/lib/session-isolation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Session Isolation - Shared utility for consistent session-scoped state guards.
+ *
+ * The codebase has historically used three different patterns for checking
+ * whether a state object belongs to the current session:
+ *
+ *   1. Lenient:  `state.session_id && state.session_id !== sessionId` (skip only if mismatch)
+ *   2. Strict:   `state.session_id !== sessionId` (skip if missing OR mismatch)
+ *   3. Guarded:  `!state.session_id || !sessionId || state.session_id !== sessionId`
+ *
+ * This module provides a single canonical function so all callers behave the same.
+ */
+/**
+ * Check whether a state object belongs to the given session.
+ *
+ * Semantics (strict by default):
+ * - If `sessionId` is not provided, returns `true` (no session to check against — allow).
+ * - If the state has no `stateSessionId`, returns `false` (legacy/ownerless state — reject
+ *   when a session is active, to prevent cross-session leakage).
+ * - Otherwise, returns `stateSessionId === sessionId`.
+ *
+ * Use `lenient: true` for backward-compatible code paths where legacy ownerless
+ * state should still be accepted.
+ *
+ * @param stateSessionId - The session_id stored in the state object (may be undefined).
+ * @param sessionId - The current request's session ID (may be undefined).
+ * @param options.lenient - When true, ownerless state (no stateSessionId) is accepted.
+ */
+export declare function isStateForSession(stateSessionId: string | undefined | null, sessionId: string | undefined | null, options?: {
+    lenient?: boolean;
+}): boolean;
+//# sourceMappingURL=session-isolation.d.ts.map

package/dist/lib/session-isolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-isolation.d.ts","sourceRoot":"","sources":["../../src/lib/session-isolation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EACzC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EACpC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9B,OAAO,CAUT"}

package/dist/lib/session-isolation.js

@@ -0,0 +1,39 @@
+/**
+ * Session Isolation - Shared utility for consistent session-scoped state guards.
+ *
+ * The codebase has historically used three different patterns for checking
+ * whether a state object belongs to the current session:
+ *
+ *   1. Lenient:  `state.session_id && state.session_id !== sessionId` (skip only if mismatch)
+ *   2. Strict:   `state.session_id !== sessionId` (skip if missing OR mismatch)
+ *   3. Guarded:  `!state.session_id || !sessionId || state.session_id !== sessionId`
+ *
+ * This module provides a single canonical function so all callers behave the same.
+ */
+/**
+ * Check whether a state object belongs to the given session.
+ *
+ * Semantics (strict by default):
+ * - If `sessionId` is not provided, returns `true` (no session to check against — allow).
+ * - If the state has no `stateSessionId`, returns `false` (legacy/ownerless state — reject
+ *   when a session is active, to prevent cross-session leakage).
+ * - Otherwise, returns `stateSessionId === sessionId`.
+ *
+ * Use `lenient: true` for backward-compatible code paths where legacy ownerless
+ * state should still be accepted.
+ *
+ * @param stateSessionId - The session_id stored in the state object (may be undefined).
+ * @param sessionId - The current request's session ID (may be undefined).
+ * @param options.lenient - When true, ownerless state (no stateSessionId) is accepted.
+ */
+export function isStateForSession(stateSessionId, sessionId, options) {
+    // No session context — cannot filter, allow everything.
+    if (!sessionId)
+        return true;
+    // State has no owner.
+    if (!stateSessionId) {
+        return options?.lenient === true;
+    }
+    return stateSessionId === sessionId;
+}
+//# sourceMappingURL=session-isolation.js.map

package/dist/lib/session-isolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-isolation.js","sourceRoot":"","sources":["../../src/lib/session-isolation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC/B,cAAyC,EACzC,SAAoC,EACpC,OAA+B;IAE/B,wDAAwD;IACxD,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAE5B,sBAAsB;IACtB,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,CAAC;IAED,OAAO,cAAc,KAAK,SAAS,CAAC;AACtC,CAAC"}

package/dist/lib/worktree-paths.d.ts

@@ -3,6 +3,10 @@
  *
  * Provides strict path validation and resolution for .omc/ paths,
  * ensuring all operations stay within the worktree boundary.
+ *
+ * Supports OMC_STATE_DIR environment variable for centralized state storage.
+ * When set, state is stored at $OMC_STATE_DIR/{project-identifier}/ instead
+ * of {worktree}/.omc/. This preserves state across worktree deletions.
  */
 /** Standard .omc subdirectories */
 export declare const OmcPaths: {
@@ -31,14 +35,44 @@ export declare function getWorktreeRoot(cwd?: string): string | null;
  * @throws Error if path contains traversal sequences
  */
 export declare function validatePath(inputPath: string): void;
+/**
+ * Clear the dual-directory warning cache (useful for testing).
+ * @internal
+ */
+export declare function clearDualDirWarnings(): void;
+/**
+ * Get a stable project identifier for centralized state storage.
+ *
+ * Uses a hybrid strategy:
+ * 1. Git remote URL hash (stable across worktrees and clones of the same repo)
+ * 2. Fallback to worktree root path hash (for local-only repos without remotes)
+ *
+ * Format: `{dirName}-{hash}` where hash is first 16 chars of SHA-256.
+ * Example: `my-project-a1b2c3d4e5f6g7h8`
+ *
+ * @param worktreeRoot - Optional worktree root path
+ * @returns A stable project identifier string
+ */
+export declare function getProjectIdentifier(worktreeRoot?: string): string;
+/**
+ * Get the .omc root directory path.
+ *
+ * When OMC_STATE_DIR is set, returns $OMC_STATE_DIR/{project-identifier}/
+ * instead of {worktree}/.omc/. This allows centralized state storage that
+ * survives worktree deletion.
+ *
+ * @param worktreeRoot - Optional worktree root
+ * @returns Absolute path to the omc root directory
+ */
+export declare function getOmcRoot(worktreeRoot?: string): string;
 /**
  * Resolve a relative path under .omc/ to an absolute path.
- * Validates the path is within the worktree boundary.
+ * Validates the path is within the omc boundary.
  *
  * @param relativePath - Path relative to .omc/ (e.g., "state/ralph.json")
  * @param worktreeRoot - Optional worktree root (auto-detected if not provided)
  * @returns Absolute path
- * @throws Error if path would escape worktree
+ * @throws Error if path would escape omc boundary
  */
 export declare function resolveOmcPath(relativePath: string, worktreeRoot?: string): string;
 /**
@@ -74,10 +108,6 @@ export declare function getWorktreeNotepadPath(worktreeRoot?: string): string;
  * Get the absolute path to the project memory file.
  */
 export declare function getWorktreeProjectMemoryPath(worktreeRoot?: string): string;
-/**
- * Get the .omc root directory path.
- */
-export declare function getOmcRoot(worktreeRoot?: string): string;
 /**
  * Resolve a plan file path.
  * @param planName - Plan name (without .md extension)
@@ -137,7 +167,7 @@ export declare function resetProcessSessionId(): void;
 export declare function validateSessionId(sessionId: string): void;
 /**
  * Resolve a session-scoped state file path.
- * Path: .omc/state/sessions/{sessionId}/{mode}-state.json
+ * Path: {omcRoot}/state/sessions/{sessionId}/{mode}-state.json
  *
  * @param stateName - State name (e.g., "ralph", "ultrawork")
  * @param sessionId - Session identifier
@@ -147,7 +177,7 @@ export declare function validateSessionId(sessionId: string): void;
 export declare function resolveSessionStatePath(stateName: string, sessionId: string, worktreeRoot?: string): string;
 /**
  * Get the session state directory path.
- * Path: .omc/state/sessions/{sessionId}/
+ * Path: {omcRoot}/state/sessions/{sessionId}/
  *
  * @param sessionId - Session identifier
  * @param worktreeRoot - Optional worktree root

package/dist/lib/worktree-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worktree-paths.d.ts","sourceRoot":"","sources":["../../src/lib/worktree-paths.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,mCAAmC;AACnC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;CAcX,CAAC;AAKX;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuB3D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAWpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAclF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CASjF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAQhF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAI/E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAI/E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAMnF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAiB5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAoBD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAS5C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAU3G;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAInF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAgB9D;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAQtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAYhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,CA2D1E"}
+{"version":3,"file":"worktree-paths.d.ts","sourceRoot":"","sources":["../../src/lib/worktree-paths.ts"],"names":[],"mappings":"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"}

package/dist/lib/worktree-paths.js

@@ -3,10 +3,15 @@
  *
  * Provides strict path validation and resolution for .omc/ paths,
  * ensuring all operations stay within the worktree boundary.
+ *
+ * Supports OMC_STATE_DIR environment variable for centralized state storage.
+ * When set, state is stored at $OMC_STATE_DIR/{project-identifier}/ instead
+ * of {worktree}/.omc/. This preserves state across worktree deletions.
  */
+import { createHash } from 'crypto';
 import { execSync } from 'child_process';
 import { existsSync, mkdirSync, realpathSync, readdirSync } from 'fs';
-import { resolve, normalize, relative, sep, join, isAbsolute } from 'path';
+import { resolve, normalize, relative, sep, join, isAbsolute, basename } from 'path';
 /** Standard .omc subdirectories */
 export const OmcPaths = {
     ROOT: '.omc',
@@ -23,17 +28,26 @@ export const OmcPaths = {
     AUTOPILOT: '.omc/autopilot',
     SKILLS: '.omc/skills',
 };
-/** Cache for worktree root to avoid repeated git calls */
-let worktreeCache = null;
+/**
+ * LRU cache for worktree root lookups to avoid repeated git subprocess calls.
+ * Bounded to MAX_WORKTREE_CACHE_SIZE entries to prevent memory growth when
+ * alternating between many different cwds (cache thrashing).
+ */
+const MAX_WORKTREE_CACHE_SIZE = 8;
+const worktreeCacheMap = new Map();
 /**
  * Get the git worktree root for the current or specified directory.
  * Returns null if not in a git repository.
  */
 export function getWorktreeRoot(cwd) {
     const effectiveCwd = cwd || process.cwd();
-    // Return cached value if cwd matches
-    if (worktreeCache && worktreeCache.cwd === effectiveCwd) {
-        return worktreeCache.root || null;
+    // Return cached value if present (LRU: move to end on access)
+    if (worktreeCacheMap.has(effectiveCwd)) {
+        const root = worktreeCacheMap.get(effectiveCwd);
+        // Refresh insertion order for LRU eviction
+        worktreeCacheMap.delete(effectiveCwd);
+        worktreeCacheMap.set(effectiveCwd, root);
+        return root || null;
     }
     try {
         const root = execSync('git rev-parse --show-toplevel', {
@@ -41,8 +55,14 @@ export function getWorktreeRoot(cwd) {
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
-        // Only cache actual git worktree roots
-        worktreeCache = { cwd: effectiveCwd, root };
+        // Evict oldest entry when at capacity
+        if (worktreeCacheMap.size >= MAX_WORKTREE_CACHE_SIZE) {
+            const oldest = worktreeCacheMap.keys().next().value;
+            if (oldest !== undefined) {
+                worktreeCacheMap.delete(oldest);
+            }
+        }
+        worktreeCacheMap.set(effectiveCwd, root);
         return root;
     }
     catch {
@@ -67,24 +87,96 @@ export function validatePath(inputPath) {
         throw new Error(`Invalid path: absolute paths not allowed (${inputPath})`);
     }
 }
+// ============================================================================
+// OMC_STATE_DIR SUPPORT (Issue #1014)
+// ============================================================================
+/** Track which dual-dir warnings have been logged to avoid repeated warnings */
+const dualDirWarnings = new Set();
+/**
+ * Clear the dual-directory warning cache (useful for testing).
+ * @internal
+ */
+export function clearDualDirWarnings() {
+    dualDirWarnings.clear();
+}
+/**
+ * Get a stable project identifier for centralized state storage.
+ *
+ * Uses a hybrid strategy:
+ * 1. Git remote URL hash (stable across worktrees and clones of the same repo)
+ * 2. Fallback to worktree root path hash (for local-only repos without remotes)
+ *
+ * Format: `{dirName}-{hash}` where hash is first 16 chars of SHA-256.
+ * Example: `my-project-a1b2c3d4e5f6g7h8`
+ *
+ * @param worktreeRoot - Optional worktree root path
+ * @returns A stable project identifier string
+ */
+export function getProjectIdentifier(worktreeRoot) {
+    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+    let source;
+    try {
+        const remoteUrl = execSync('git remote get-url origin', {
+            cwd: root,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        source = remoteUrl || root;
+    }
+    catch {
+        // No git remote (local-only repo or not a git repo) — use path
+        source = root;
+    }
+    const hash = createHash('sha256').update(source).digest('hex').slice(0, 16);
+    const dirName = basename(root).replace(/[^a-zA-Z0-9_-]/g, '_');
+    return `${dirName}-${hash}`;
+}
+/**
+ * Get the .omc root directory path.
+ *
+ * When OMC_STATE_DIR is set, returns $OMC_STATE_DIR/{project-identifier}/
+ * instead of {worktree}/.omc/. This allows centralized state storage that
+ * survives worktree deletion.
+ *
+ * @param worktreeRoot - Optional worktree root
+ * @returns Absolute path to the omc root directory
+ */
+export function getOmcRoot(worktreeRoot) {
+    const customDir = process.env.OMC_STATE_DIR;
+    if (customDir) {
+        const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+        const projectId = getProjectIdentifier(root);
+        const centralizedPath = join(customDir, projectId);
+        // Log notice if both legacy .omc/ and new centralized dir exist
+        const legacyPath = join(root, OmcPaths.ROOT);
+        const warningKey = `${legacyPath}:${centralizedPath}`;
+        if (!dualDirWarnings.has(warningKey) && existsSync(legacyPath) && existsSync(centralizedPath)) {
+            dualDirWarnings.add(warningKey);
+            console.warn(`[omc] Both legacy state dir (${legacyPath}) and centralized state dir (${centralizedPath}) exist. ` +
+                `Using centralized dir. Consider migrating data from the legacy dir and removing it.`);
+        }
+        return centralizedPath;
+    }
+    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+    return join(root, OmcPaths.ROOT);
+}
 /**
  * Resolve a relative path under .omc/ to an absolute path.
- * Validates the path is within the worktree boundary.
+ * Validates the path is within the omc boundary.
  *
  * @param relativePath - Path relative to .omc/ (e.g., "state/ralph.json")
  * @param worktreeRoot - Optional worktree root (auto-detected if not provided)
  * @returns Absolute path
- * @throws Error if path would escape worktree
+ * @throws Error if path would escape omc boundary
  */
 export function resolveOmcPath(relativePath, worktreeRoot) {
     validatePath(relativePath);
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    const omcDir = join(root, OmcPaths.ROOT);
+    const omcDir = getOmcRoot(worktreeRoot);
     const fullPath = normalize(resolve(omcDir, relativePath));
-    // Verify resolved path is still under worktree
-    const relativeToRoot = relative(root, fullPath);
-    if (relativeToRoot.startsWith('..') || relativeToRoot.startsWith(sep + '..')) {
-        throw new Error(`Path escapes worktree boundary: ${relativePath}`);
+    // Verify resolved path is still under omc directory
+    const relativeToOmc = relative(omcDir, fullPath);
+    if (relativeToOmc.startsWith('..') || relativeToOmc.startsWith(sep + '..')) {
+        throw new Error(`Path escapes omc boundary: ${relativePath}`);
     }
     return fullPath;
 }
@@ -131,22 +223,13 @@ export function ensureOmcDir(relativePath, worktreeRoot) {
  * This version auto-detects worktree root.
  */
 export function getWorktreeNotepadPath(worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.NOTEPAD);
+    return join(getOmcRoot(worktreeRoot), 'notepad.md');
 }
 /**
  * Get the absolute path to the project memory file.
  */
 export function getWorktreeProjectMemoryPath(worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.PROJECT_MEMORY);
-}
-/**
- * Get the .omc root directory path.
- */
-export function getOmcRoot(worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.ROOT);
+    return join(getOmcRoot(worktreeRoot), 'project-memory.json');
 }
 /**
  * Resolve a plan file path.
@@ -154,8 +237,7 @@ export function getOmcRoot(worktreeRoot) {
  */
 export function resolvePlanPath(planName, worktreeRoot) {
     validatePath(planName);
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.PLANS, `${planName}.md`);
+    return join(getOmcRoot(worktreeRoot), 'plans', `${planName}.md`);
 }
 /**
  * Resolve a research directory path.
@@ -163,15 +245,13 @@ export function resolvePlanPath(planName, worktreeRoot) {
  */
 export function resolveResearchPath(name, worktreeRoot) {
     validatePath(name);
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.RESEARCH, name);
+    return join(getOmcRoot(worktreeRoot), 'research', name);
 }
 /**
  * Resolve the logs directory path.
  */
 export function resolveLogsPath(worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.LOGS);
+    return join(getOmcRoot(worktreeRoot), 'logs');
 }
 /**
  * Resolve a wisdom/plan-scoped notepad directory path.
@@ -179,16 +259,14 @@ export function resolveLogsPath(worktreeRoot) {
  */
 export function resolveWisdomPath(planName, worktreeRoot) {
     validatePath(planName);
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.NOTEPADS, planName);
+    return join(getOmcRoot(worktreeRoot), 'notepads', planName);
 }
 /**
  * Check if an absolute path is under the .omc directory.
  * @param absolutePath - Absolute path to check
  */
 export function isPathUnderOmc(absolutePath, worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    const omcRoot = join(root, OmcPaths.ROOT);
+    const omcRoot = getOmcRoot(worktreeRoot);
     const normalizedPath = normalize(absolutePath);
     const normalizedOmc = normalize(omcRoot);
     return normalizedPath.startsWith(normalizedOmc + sep) || normalizedPath === normalizedOmc;
@@ -197,18 +275,10 @@ export function isPathUnderOmc(absolutePath, worktreeRoot) {
  * Ensure all standard .omc subdirectories exist.
  */
 export function ensureAllOmcDirs(worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    const dirs = [
-        OmcPaths.ROOT,
-        OmcPaths.STATE,
-        OmcPaths.PLANS,
-        OmcPaths.RESEARCH,
-        OmcPaths.LOGS,
-        OmcPaths.NOTEPADS,
-        OmcPaths.DRAFTS,
-    ];
-    for (const dir of dirs) {
-        const fullPath = join(root, dir);
+    const omcRoot = getOmcRoot(worktreeRoot);
+    const subdirs = ['', 'state', 'plans', 'research', 'logs', 'notepads', 'drafts'];
+    for (const subdir of subdirs) {
+        const fullPath = subdir ? join(omcRoot, subdir) : omcRoot;
         if (!existsSync(fullPath)) {
             mkdirSync(fullPath, { recursive: true });
         }
@@ -218,7 +288,7 @@ export function ensureAllOmcDirs(worktreeRoot) {
  * Clear the worktree cache (useful for testing).
  */
 export function clearWorktreeCache() {
-    worktreeCache = null;
+    worktreeCacheMap.clear();
 }
 // ============================================================================
 // SESSION-SCOPED STATE PATHS
@@ -282,7 +352,7 @@ export function validateSessionId(sessionId) {
 }
 /**
  * Resolve a session-scoped state file path.
- * Path: .omc/state/sessions/{sessionId}/{mode}-state.json
+ * Path: {omcRoot}/state/sessions/{sessionId}/{mode}-state.json
  *
  * @param stateName - State name (e.g., "ralph", "ultrawork")
  * @param sessionId - Session identifier
@@ -300,7 +370,7 @@ export function resolveSessionStatePath(stateName, sessionId, worktreeRoot) {
 }
 /**
  * Get the session state directory path.
- * Path: .omc/state/sessions/{sessionId}/
+ * Path: {omcRoot}/state/sessions/{sessionId}/
  *
  * @param sessionId - Session identifier
  * @param worktreeRoot - Optional worktree root
@@ -308,8 +378,7 @@ export function resolveSessionStatePath(stateName, sessionId, worktreeRoot) {
  */
 export function getSessionStateDir(sessionId, worktreeRoot) {
     validateSessionId(sessionId);
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    return join(root, OmcPaths.SESSIONS, sessionId);
+    return join(getOmcRoot(worktreeRoot), 'state', 'sessions', sessionId);
 }
 /**
  * List all session IDs that have state directories.
@@ -318,8 +387,7 @@ export function getSessionStateDir(sessionId, worktreeRoot) {
  * @returns Array of session IDs
  */
 export function listSessionIds(worktreeRoot) {
-    const root = worktreeRoot || getWorktreeRoot() || process.cwd();
-    const sessionsDir = join(root, OmcPaths.SESSIONS);
+    const sessionsDir = join(getOmcRoot(worktreeRoot), 'state', 'sessions');
     if (!existsSync(sessionsDir)) {
         return [];
     }