lark-remote 0.1.1 → 0.1.3

package/dist/runner/codex/runner.js

@@ -34,7 +34,6 @@ export class CodexExecRunner extends SpawningRunner {
     reasoningEffort;
     constructor(opts) {
         super({
-            binary: opts.binary ?? 'codex',
             pidDir: opts.pidDir,
             workspace: opts.workspace,
             stopGraceMs: opts.stopGraceMs,
@@ -42,6 +41,7 @@ export class CodexExecRunner extends SpawningRunner {
             pidFilePrefix: 'codex',
             logTag: 'codex-exec-runner',
         });
+        this.binary = 'codex';
         this.defaultModel = opts.model;
         this.modelProvider = opts.modelProvider;
         this.reasoningEffort = opts.reasoningEffort;

package/dist/runner/common/spawning-runner.d.ts

@@ -109,7 +109,6 @@ export declare abstract class SpawningRunner {
      */
     protected stoppedByUser: boolean;
     constructor(opts: {
-        binary?: string;
         pidDir?: string;
         workspace: string;
         stopGraceMs?: number;

package/dist/runner/common/spawning-runner.js

@@ -111,10 +111,8 @@ export class SpawningRunner {
      */
     stoppedByUser = false;
     constructor(opts) {
-        // Neutral default — empty string fails loudly at spawn time if a caller
-        // forgets to configure binary. 'claude' would be wrong (biases the base
-        // class toward one agent). Subclasses pass their own binary.
-        this.binary = opts.binary ?? '';
+        // Subclasses set this.binary after super()
+        this.binary = '';
         this.stopGraceMs = opts.stopGraceMs ?? DEFAULT_STOP_GRACE_MS;
         this.logTag = opts.logTag ?? 'spawning-runner';
         const pidDir = opts.pidDir ?? path.join(os.homedir(), '.lark-remote');

package/dist/runner/kimi/runner.d.ts

@@ -2,7 +2,6 @@ import type { ChildProcess } from 'node:child_process';
 import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
 import type { AgentRunner, AgentSessionReader, SpawnOptions, AgentStatusInfo } from '../types.js';
 interface KimiRunnerConfig {
-    binary?: string;
     model?: string;
     thinkingEffort?: string;
     stopGraceMs?: number;

package/dist/runner/kimi/runner.js

@@ -32,7 +32,6 @@ export class KimiRunner extends SpawningRunner {
     completionTimeoutMs;
     constructor(opts) {
         super({
-            binary: opts.binary ?? 'kimi',
             pidDir: opts.pidDir,
             workspace: opts.workspace,
             stopGraceMs: opts.stopGraceMs,
@@ -40,6 +39,7 @@ export class KimiRunner extends SpawningRunner {
             pidFilePrefix: 'kimi',
             logTag: 'kimi-runner',
         });
+        this.binary = 'kimi';
         this.defaultModel = opts.model ?? 'kimi-code/k3';
         this.thinkingEffort = opts.thinkingEffort ?? 'max';
         this.completionTimeoutMs = opts.completionTimeoutMs ?? KIMI_TIMEOUT_MS;

package/dist/runner/opencode/runner.d.ts

@@ -30,8 +30,6 @@ import type { AgentKind, AgentSessionReader, AgentRunner, AgentStatusInfo } from
 import type { SpawnOptions } from '../types.js';
 import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
 interface OpencodeExecRunnerOptions {
-    /** Path to opencode binary. Default: 'opencode' (in PATH). */
-    binary?: string;
     /** Model override in provider/model format (e.g. 'anthropic/claude-sonnet-4-20250514'). Omitted → opencode config default. */
     model?: string;
     /** Grace period (ms) for SIGTERM→SIGKILL. Default: 5000. */

package/dist/runner/opencode/runner.js

@@ -35,7 +35,6 @@ export class OpencodeExecRunner extends SpawningRunner {
     defaultModel;
     constructor(opts) {
         super({
-            binary: opts.binary ?? 'opencode',
             pidDir: opts.pidDir,
             workspace: opts.workspace,
             stopGraceMs: opts.stopGraceMs,
@@ -43,6 +42,7 @@ export class OpencodeExecRunner extends SpawningRunner {
             pidFilePrefix: 'opencode',
             logTag: 'opencode-exec-runner',
         });
+        this.binary = 'opencode';
         this.defaultModel = opts.model;
         this.sessionReader = opts.sessionReader;
     }

package/dist/runner/pi/runner.d.ts

@@ -1,7 +1,6 @@
 import type { AgentRunner, AgentSessionReader, SpawnOptions, AgentStatusInfo } from '../types.js';
 import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
 interface PiRunnerConfig {
-    binary?: string;
     provider?: string;
     model?: string;
     thinking?: string;

package/dist/runner/pi/runner.js

@@ -18,7 +18,6 @@ export class PiRunner extends SpawningRunner {
     tools;
     constructor(opts) {
         super({
-            binary: opts.binary ?? 'pi',
             pidDir: opts.pidDir,
             workspace: opts.workspace,
             stopGraceMs: opts.stopGraceMs,
@@ -26,6 +25,7 @@ export class PiRunner extends SpawningRunner {
             pidFilePrefix: 'pi',
             logTag: 'pi-runner',
         });
+        this.binary = 'pi';
         this.provider = opts.provider ?? 'Volcano';
         this.defaultModel = opts.model ?? 'glm-5.2';
         this.thinking = opts.thinking ?? 'medium';

package/dist/runner/probe.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Agent availability probe — detect whether each CLI binary is installed
+ * by checking whether it resolves on PATH via `which`.
+ *
+ * Why `which` over `<binary> --help`:
+ * - `--help` starts a full Node.js process per agent (2–8 s on
+ *   resource-constrained devices like Raspberry Pi). Under startup load
+ *   (auto-resume spawns, CPU contention) probes time out and installed
+ *   agents are falsely reported as unavailable.
+ * - `which` is a lightweight PATH lookup (<10 ms), immune to CPU contention.
+ * - "Installed but broken" cases surface at run time via SpawningRunner's
+ *   ENOENT/error handling (src/runner/common/spawning-runner.ts), which
+ *   shows a friendly error card instead of a startup-time mislabel.
+ *
+ * Why `which` over `command -v`:
+ * - `which` is a standalone executable (e.g. /usr/bin/which on macOS and
+ *   Debian-based Linux), so no `shell: true` and no Node DEP0190 warning.
+ * - Caveat: `which` is not POSIX-guaranteed. macOS, Raspberry Pi OS and
+ *   other Debian-based distributions ship it by default; if Windows or
+ *   minimal Alpine containers become supported, prefer a pure-Node
+ *   PATH + X_OK lookup instead.
+ */
+import type { AgentKind } from './types.js';
+/**
+ * Probe a single agent, using cache when fresh.
+ * Updates cache on completion.
+ */
+export declare function probeAgentAvailability(kind: AgentKind): Promise<boolean>;
+/**
+ * Probe all agents concurrently.
+ *
+ * Concurrent (not sequential) because `which` is a lightweight PATH lookup
+ * (<10 ms) with no CPU contention risk — unlike the previous `--help`
+ * probes, which needed to run one-at-a-time to avoid starving each other
+ * on resource-constrained devices.
+ */
+export declare function probeAllAgents(): Promise<Map<AgentKind, boolean>>;
+/**
+ * Synchronous cache read — returns cached availability if fresh,
+ * or `undefined` if no fresh cache entry exists.
+ * Used by synchronous code paths (e.g. buildConfigCard) that cannot await.
+ */
+export declare function getCachedAvailability(kind: AgentKind): boolean | undefined;
+/** Clear all cache entries. Exported for test use only (cache auto-expires via TTL). */
+export declare function _clearCacheForTest(): void;

package/dist/runner/probe.js

@@ -0,0 +1,87 @@
+/**
+ * Agent availability probe — detect whether each CLI binary is installed
+ * by checking whether it resolves on PATH via `which`.
+ *
+ * Why `which` over `<binary> --help`:
+ * - `--help` starts a full Node.js process per agent (2–8 s on
+ *   resource-constrained devices like Raspberry Pi). Under startup load
+ *   (auto-resume spawns, CPU contention) probes time out and installed
+ *   agents are falsely reported as unavailable.
+ * - `which` is a lightweight PATH lookup (<10 ms), immune to CPU contention.
+ * - "Installed but broken" cases surface at run time via SpawningRunner's
+ *   ENOENT/error handling (src/runner/common/spawning-runner.ts), which
+ *   shows a friendly error card instead of a startup-time mislabel.
+ *
+ * Why `which` over `command -v`:
+ * - `which` is a standalone executable (e.g. /usr/bin/which on macOS and
+ *   Debian-based Linux), so no `shell: true` and no Node DEP0190 warning.
+ * - Caveat: `which` is not POSIX-guaranteed. macOS, Raspberry Pi OS and
+ *   other Debian-based distributions ship it by default; if Windows or
+ *   minimal Alpine containers become supported, prefer a pure-Node
+ *   PATH + X_OK lookup instead.
+ */
+import { spawn } from 'child_process';
+/** Map from AgentKind to its CLI binary name. */
+const BINARY_MAP = {
+    claude: 'claude',
+    codex: 'codex',
+    opencode: 'opencode',
+    pi: 'pi',
+    kimi: 'kimi',
+};
+const CACHE_TTL_MS = 5 * 60_000;
+/** Module-level cache, survives across calls within the process. */
+const cache = new Map();
+/**
+ * Probe a single agent's availability by spawning `which <binary>`.
+ * Exit code 0 = binary on PATH; error / non-zero = unavailable.
+ */
+async function probeOne(kind) {
+    const binary = BINARY_MAP[kind];
+    return new Promise((resolve) => {
+        const proc = spawn('which', [binary], { stdio: 'ignore' });
+        proc.on('error', () => resolve(false));
+        proc.on('exit', (code) => resolve(code === 0));
+    });
+}
+/**
+ * Probe a single agent, using cache when fresh.
+ * Updates cache on completion.
+ */
+export async function probeAgentAvailability(kind) {
+    const cached = cache.get(kind);
+    if (cached && Date.now() - cached.ts < CACHE_TTL_MS)
+        return cached.ok;
+    const ok = await probeOne(kind);
+    cache.set(kind, { ts: Date.now(), ok });
+    return ok;
+}
+/**
+ * Probe all agents concurrently.
+ *
+ * Concurrent (not sequential) because `which` is a lightweight PATH lookup
+ * (<10 ms) with no CPU contention risk — unlike the previous `--help`
+ * probes, which needed to run one-at-a-time to avoid starving each other
+ * on resource-constrained devices.
+ */
+export async function probeAllAgents() {
+    const kinds = Object.keys(BINARY_MAP);
+    const entries = await Promise.all(kinds.map(async (k) => [k, await probeAgentAvailability(k)]));
+    return new Map(entries);
+}
+/**
+ * Synchronous cache read — returns cached availability if fresh,
+ * or `undefined` if no fresh cache entry exists.
+ * Used by synchronous code paths (e.g. buildConfigCard) that cannot await.
+ */
+export function getCachedAvailability(kind) {
+    const cached = cache.get(kind);
+    if (!cached || Date.now() - cached.ts >= CACHE_TTL_MS)
+        return undefined;
+    return cached.ok;
+}
+/** Clear all cache entries. Exported for test use only (cache auto-expires via TTL). */
+export function _clearCacheForTest() {
+    cache.clear();
+}
+//# sourceMappingURL=probe.js.map

package/dist/runner/types.d.ts

@@ -153,6 +153,9 @@ export interface AgentSessionUsage {
     inputTokens: number;
     outputTokens: number;
     contextLength: number;
+    /** Agent 上报的当前模型 context window 上限（codex token_count.info.model_context_window）。
+     *  仅 codex 提供；缺省时卡片只显示绝对量、不显示百分比。 */
+    contextLimit?: number;
     /** Claude auto-compact 次数（数 compact_boundary 事件）；codex/opencode 无此概念，留 undefined。 */
     compactCount?: number;
     /** 从缓存读取的 token 数（节省的费用）。 */

package/dist/session/claude/sessions.d.ts

@@ -1,13 +1,15 @@
 import type { AgentSession, AgentSessionContentEvent, AgentSessionUsage } from '../../runner/index.js';
 /**
- * Read cwd from a Claude session JSONL by scanning events for the first
- * `cwd` field. Claude CLI writes the absolute (symlink-resolved) cwd on
+ * Read the FIRST cwd from a Claude session JSONL. Used for display and
+ * diagnostics. Claude CLI writes the absolute (symlink-resolved) cwd on
  * every event that produces one; older versions wrote it once on init.
  * Returns the first non-empty value, or undefined if absent.
  *
- * This is the SOLE source of truth for cwd. The directory name under
- * ~/.claude/projects/ is lossy (encodes `/` AND `_` as `-`), so it cannot
- * be decoded back to a real path. See regression 2026-06-21 /resume & /cd 路径错乱.
+ * For cwd GUARD checks (list/read), use `jsonlContainsCwd` which accepts
+ * any matching cwd field (required for relocated sessions whose first cwd
+ * is the pre-relocate path). The directory name under ~/.claude/projects/
+ * is lossy (encodes `/` AND `_` as `-`), so it cannot be decoded back to
+ * a real path. See regression 2026-06-21 /resume & /cd 路径错乱.
  */
 export declare function readCwdFromJsonl(filePath: string): string | undefined;
 /**
@@ -18,7 +20,7 @@ export declare function readCwdFromJsonl(filePath: string): string | undefined;
  *
  * We locate the directory via `projectDirForCwd` (lossy but OK for locating
  * a known cwd) and then **verify** each jsonl's cwd field matches. This
- * prevents collision: `my_disk/foo` and `my-disk/foo` both encode to the same
+ * prevents collision: `disk_d/foo` and `disk-d/foo` both encode to the same
  * directory name, but only the matching cwd field is kept.
  */
 export declare function listClaudeSessions(cwd: string, opts?: {

package/dist/session/claude/sessions.js

@@ -12,8 +12,8 @@ import { truncate } from '../../card/card-shared.js';
  * Claude encodes the cwd by replacing `/` with `-` (e.g.
  * `/Users/x/proj` -> `-Users-x-proj`). Underscores are also replaced with `-`.
  *
- * Note: this encoding is LOSSY (`my_disk/foo` and `my-disk/foo` both encode to
- * `my-disk-foo`). It is only safe to use the result to **locate** files; never
+ * Note: this encoding is LOSSY (`disk_d/foo` and `disk-d/foo` both encode to
+ * `disk-d-foo`). It is only safe to use the result to **locate** files; never
  * to **decode** a directory name back to a cwd. Use `readCwdFromJsonl` for
  * cwd (regression 2026-06-21 /resume & /cd 路径错乱).
  */
@@ -22,14 +22,16 @@ function projectDirForCwd(cwd, projectsDir) {
     return path.join(projectsDir, encoded);
 }
 /**
- * Read cwd from a Claude session JSONL by scanning events for the first
- * `cwd` field. Claude CLI writes the absolute (symlink-resolved) cwd on
+ * Read the FIRST cwd from a Claude session JSONL. Used for display and
+ * diagnostics. Claude CLI writes the absolute (symlink-resolved) cwd on
  * every event that produces one; older versions wrote it once on init.
  * Returns the first non-empty value, or undefined if absent.
  *
- * This is the SOLE source of truth for cwd. The directory name under
- * ~/.claude/projects/ is lossy (encodes `/` AND `_` as `-`), so it cannot
- * be decoded back to a real path. See regression 2026-06-21 /resume & /cd 路径错乱.
+ * For cwd GUARD checks (list/read), use `jsonlContainsCwd` which accepts
+ * any matching cwd field (required for relocated sessions whose first cwd
+ * is the pre-relocate path). The directory name under ~/.claude/projects/
+ * is lossy (encodes `/` AND `_` as `-`), so it cannot be decoded back to
+ * a real path. See regression 2026-06-21 /resume & /cd 路径错乱.
  */
 export function readCwdFromJsonl(filePath) {
     const line = findJsonlLine(filePath, (l) => {
@@ -81,7 +83,7 @@ function defaultProjectsDir() {
  * sorted, first match wins; the cwd guard in `readSessionContent` still
  * validates the file afterwards.
  */
-function findSessionFileInProjects(sessionId, projectsDir) {
+function findSessionFileInProjects(sessionId, projectsDir, cwd) {
     let entries;
     try {
         entries = fs.readdirSync(projectsDir);
@@ -90,12 +92,27 @@ function findSessionFileInProjects(sessionId, projectsDir) {
         return undefined;
     }
     const name = `${sessionId}.jsonl`;
+    const candidates = [];
     for (const entry of entries.sort()) {
         const candidate = path.join(projectsDir, entry, name);
-        if (fs.existsSync(candidate))
-            return candidate;
+        if (fs.existsSync(candidate)) {
+            candidates.push(candidate);
+        }
+    }
+    if (candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return candidates[0];
+    // Multiple copies: prefer the one whose jsonl contains the requested cwd
+    // (handles EnterWorktree relocate where the same sessionId exists in
+    // multiple project dirs). Fall back to the first sorted candidate.
+    if (cwd) {
+        for (const candidate of candidates) {
+            if (jsonlContainsCwd(candidate, cwd))
+                return candidate;
+        }
     }
-    return undefined;
+    return candidates[0];
 }
 /**
  * P1-19: TTL cache for full project listings (mirror codex getSessionIndex's
@@ -123,7 +140,11 @@ function summarizeSession(filePath) {
     const line = findJsonlLine(filePath, (l) => {
         try {
             const obj = JSON.parse(l);
-            return obj.type === 'user' && !!obj.message?.content && !!extractText(obj.message.content);
+            if (obj.type === 'user' && !!obj.message?.content) {
+                const text = extractText(obj.message.content);
+                return !!text && !isTaskNotificationText(text);
+            }
+            return false;
         }
         catch {
             return false;
@@ -146,6 +167,19 @@ const CLAUDE_MAPPING = {
     toolInputField: 'input',
     toolErrorField: 'is_error',
 };
+/**
+ * Detect Claude CLI sub-agent completion notification text.
+ * Claude CLI injects a `type:"user"` record with string content starting
+ * with `<task-notification>` when a sub-agent (Agent tool) finishes.
+ * These must be excluded from displayTitle/summary — they are machine
+ * injections, not real user input. Primary criterion: extracted text
+ * starts with `<task-notification` (works for both string and array
+ * content since `extractText` is called first). Secondary (optional):
+ * `origin.kind === 'task-notification'` (not all CLI versions write it).
+ */
+function isTaskNotificationText(text) {
+    return text.trimStart().startsWith('<task-notification');
+}
 /**
  * Extract first text from a user message.
  * Used by readFirstUserMessage.
@@ -170,7 +204,7 @@ function extractText(content) {
  *
  * We locate the directory via `projectDirForCwd` (lossy but OK for locating
  * a known cwd) and then **verify** each jsonl's cwd field matches. This
- * prevents collision: `my_disk/foo` and `my-disk/foo` both encode to the same
+ * prevents collision: `disk_d/foo` and `disk-d/foo` both encode to the same
  * directory name, but only the matching cwd field is kept.
  */
 export function listClaudeSessions(cwd, opts = {}) {
@@ -185,7 +219,7 @@ export function listClaudeSessions(cwd, opts = {}) {
         sessions = cached.sessions;
     }
     else {
-        sessions = scanClaudeSessions(cwd, dir);
+        sessions = scanClaudeSessions(cwd, dir, opts.projectsDir);
         claudeListCache.set(cacheKey, { builtAt: Date.now(), sessions });
         // Bound the cache (map iteration order = insertion order).
         if (claudeListCache.size > LIST_CACHE_MAX_ENTRIES) {
@@ -196,8 +230,13 @@ export function listClaudeSessions(cwd, opts = {}) {
     }
     return limit === undefined ? sessions : sessions.slice(0, limit);
 }
-/** Uncached scan of a claude project dir (the expensive part being cached). */
-function scanClaudeSessions(cwd, dir) {
+/**
+ * Scan a single project directory for jsonl files whose cwd field matches
+ * the requested cwd. Uses `jsonlContainsCwd` (any cwd field matches) rather
+ * than `readCwdFromJsonl` (first cwd only) so that relocated sessions whose
+ * first cwd is the pre-relocate path are still found. P1 fix 2026-08-10.
+ */
+function scanDirForSessions(cwd, dir) {
     let files;
     try {
         files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
@@ -210,11 +249,10 @@ function scanClaudeSessions(cwd, dir) {
         const full = path.join(dir, f);
         try {
             const st = fs.statSync(full);
-            // Verify the jsonl's cwd field actually matches. Defends against
-            // directory-name collisions where a different cwd encoded to the same
-            // directory name.
-            const fileCwd = readCwdFromJsonl(full);
-            if (fileCwd !== cwd)
+            // P1 fix: use jsonlContainsCwd (any match) instead of readCwdFromJsonl
+            // (first only). Defends against directory-name collisions AND includes
+            // relocated sessions whose first cwd is the pre-relocate path.
+            if (!jsonlContainsCwd(full, cwd))
                 continue;
             const sessionId = f.slice(0, -'.jsonl'.length);
             sessions.push({
@@ -227,6 +265,111 @@ function scanClaudeSessions(cwd, dir) {
             getLogger().warn(`[session] skip ${f}: ${err.message}`);
         }
     }
+    return sessions;
+}
+/**
+ * Scan OTHER project subdirectories for jsonl files whose first cwd matches
+ * the requested cwd. Used to find sessions that were MOVED OUT of the primary
+ * dir by EnterWorktree (which relocates the transcript to the target worktree's
+ * project dir). Such sessions always have firstCwd == queryCwd because
+ * EnterWorktree happens after session start.
+ *
+ * Uses `readCwdFromJsonl` (first cwd only) instead of `jsonlContainsCwd`
+ * (full-file scan) because:
+ * - Relocated-out sessions always have firstCwd == queryCwd → readCwdFromJsonl
+ *   is sufficient and ~10× faster (no full-file streaming).
+ * - Relocated-IN sessions are found by Phase 1's jsonlContainsCwd in the
+ *   primary dir — no need for Phase 2 to find them again.
+ *
+ * Skips the primary dir (already scanned) and any sessionIds already found
+ * (avoids duplicates). S2 fix 2026-08-10.
+ */
+function scanRelocatedSessions(cwd, primaryDir, projectsDir, seenIds) {
+    let entries;
+    try {
+        entries = fs.readdirSync(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const entry of entries.sort()) {
+        const subdir = path.join(projectsDir, entry);
+        // Skip the primary dir (already scanned) and non-directories
+        if (subdir === primaryDir)
+            continue;
+        try {
+            if (!fs.statSync(subdir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        let files;
+        try {
+            files = fs
+                .readdirSync(subdir)
+                .filter((f) => f.endsWith('.jsonl'))
+                .sort();
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            const full = path.join(subdir, f);
+            const sessionId = f.slice(0, -'.jsonl'.length);
+            // Skip sessions already found in the primary dir scan
+            if (seenIds.has(sessionId))
+                continue;
+            try {
+                const st = fs.statSync(full);
+                // S2: use readCwdFromJsonl (first cwd only) instead of
+                // jsonlContainsCwd (full-file scan). Relocated-out sessions
+                // always have firstCwd == queryCwd.
+                const firstCwd = readCwdFromJsonl(full);
+                if (firstCwd === undefined || firstCwd !== cwd)
+                    continue;
+                sessions.push({
+                    sessionId,
+                    summary: truncate(summarizeSession(full), 60, { normalizeWhitespace: true }),
+                    mtime: st.mtimeMs,
+                });
+                // Prevent duplicates if the same sessionId exists in multiple dirs
+                seenIds.add(sessionId);
+            }
+            catch (err) {
+                getLogger().warn(`[session] skip ${f}: ${err.message}`);
+            }
+        }
+    }
+    return sessions;
+}
+/** Uncached scan of a claude project dir (the expensive part being cached).
+ *  Phase 1 scans the primary project dir using jsonlContainsCwd (any cwd
+ *  match) to find sessions including relocated-in ones.
+ *  Phase 2 scans all OTHER project dirs using readCwdFromJsonl (first cwd
+ *  only) to find relocated-out sessions (always firstCwd == queryCwd).
+ *  S2 fix 2026-08-10: removed the primarySessions.length === 0 guard so
+ *  relocated-out sessions are visible even when the primary dir has other
+ *  sessions. readCwdFromJsonl is ~10× cheaper than jsonlContainsCwd for
+ *  cross-dir scanning.
+ */
+function scanClaudeSessions(cwd, dir, projectsDir) {
+    const sessions = [];
+    // Phase 1: scan the primary project dir (fast path)
+    const primarySessions = scanDirForSessions(cwd, dir);
+    sessions.push(...primarySessions);
+    // Phase 2: cross-dir fallback for relocated sessions whose transcript
+    // was moved away from the primary dir by EnterWorktree.
+    // Always executed (S2 fix): relocated-out sessions have firstCwd == queryCwd
+    // but are invisible to Phase 1 (file moved away). seenIds prevents
+    // double-counting sessions already found by Phase 1.
+    const effectiveProjectsDir = projectsDir ?? defaultProjectsDir();
+    if (effectiveProjectsDir && dir.startsWith(effectiveProjectsDir)) {
+        const seenIds = new Set(primarySessions.map((s) => s.sessionId));
+        const crossDirSessions = scanRelocatedSessions(cwd, dir, effectiveProjectsDir, seenIds);
+        sessions.push(...crossDirSessions);
+    }
     // Same-mtime ties: secondary key keeps the full order deterministic.
     sessions.sort((a, b) => b.mtime - a.mtime || a.sessionId.localeCompare(b.sessionId));
     return sessions;
@@ -283,9 +426,18 @@ function isSessionActive(filePath, mtimeMs, now = Date.now()) {
  * used for session-active detection. Returns false if the file doesn't exist.
  */
 export function isClaudeSessionActive(sessionId, cwd, opts = {}) {
-    const dir = projectDirForCwd(cwd, opts.projectsDir ?? defaultProjectsDir());
-    const filePath = path.join(dir, `${sessionId}.jsonl`);
-    if (!fs.existsSync(filePath))
+    const projectsDir = opts.projectsDir ?? defaultProjectsDir();
+    const dir = projectDirForCwd(cwd, projectsDir);
+    let filePath = path.join(dir, `${sessionId}.jsonl`);
+    if (!fs.existsSync(filePath)) {
+        // EnterWorktree relocate: transcript moved to the new cwd's project dir.
+        const relocated = findSessionFileInProjects(sessionId, projectsDir, cwd);
+        if (!relocated)
+            return false;
+        filePath = relocated;
+    }
+    // Verify the jsonl belongs to the requested cwd (any cwd field may match).
+    if (!jsonlContainsCwd(filePath, cwd))
         return false;
     try {
         const st = fs.statSync(filePath);
@@ -379,7 +531,7 @@ function scalarScan(filePath) {
                     content[0]?.type === 'tool_result';
                 if (!isToolResult) {
                     const userContent = extractText(content);
-                    if (userContent) {
+                    if (userContent && !isTaskNotificationText(userContent)) {
                         lastUserMessage = userContent;
                     }
                 }
@@ -477,7 +629,7 @@ export function readSessionContent(sessionId, cwd, opts = {}) {
     let filePath = path.join(dir, `${sessionId}.jsonl`);
     if (!fs.existsSync(filePath)) {
         // EnterWorktree relocate: transcript moved to the new cwd's project dir.
-        const relocated = findSessionFileInProjects(sessionId, projectsDir);
+        const relocated = findSessionFileInProjects(sessionId, projectsDir, cwd);
         if (!relocated)
             return { events: [] };
         filePath = relocated;

package/dist/session/codex/rollout-reader.d.ts

@@ -70,6 +70,7 @@ export declare function listCodexRollouts(opts?: ListCodexRolloutsOptions): {
 export declare function readCodexSessionContent(sessionId: string, opts?: {
     codexHome?: string;
     maxEvents?: number;
+    cwd?: string;
 }): SessionContent;
 /**
  * Check if a session is still active (recently updated).

package/dist/session/codex/rollout-reader.js

@@ -51,6 +51,9 @@ export function readCodexRollout(filePath) {
         // pi/opencode /resume "last turn" display semantics). When
         // last_token_usage is absent we derive it as total - previous_total.
         let lastRawUsage;
+        // Context window limit from the same token_count event as lastRawUsage
+        // (codex reports info.model_context_window per turn; absent on old data).
+        let lastContextLimit;
         // Final total_token_usage (cumulative across the whole session) for the
         // Run card's "累计" display. Codex emits this alongside last_token_usage.
         let lastTotalUsage;
@@ -95,6 +98,8 @@ export function readCodexRollout(filePath) {
                         }
                         if (raw && (raw.input_tokens || raw.cached_input_tokens || raw.output_tokens)) {
                             lastRawUsage = raw;
+                            const ctxWindow = info?.model_context_window;
+                            lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
                         }
                     }
                 }
@@ -150,6 +155,7 @@ export function readCodexRollout(filePath) {
                 inputTokens: r.input_tokens - cached,
                 outputTokens: r.output_tokens,
                 contextLength: r.input_tokens,
+                contextLimit: lastContextLimit,
                 cacheReadTokens: cached,
                 cacheCreationTokens: 0,
                 totalTokens: r.total_tokens,
@@ -253,6 +259,15 @@ export function readCodexSessionContent(sessionId, opts = {}) {
     if (!entry) {
         return { events: [] };
     }
+    // Cwd guard: when a cwd is provided, the session's working directory must
+    // match. Without this, /resume <id> finds sessions by global ID lookup and
+    // allows resuming a session from workspace B while the user is in workspace A.
+    // Codex has no relocation (no EnterWorktree equivalent), so a simple equality
+    // check suffices — unlike claude which needs jsonlContainsCwd to handle
+    // relocated sessions with multiple cwd values.
+    if (opts.cwd && entry.cwd !== opts.cwd) {
+        return { events: [] };
+    }
     const rollout = readCodexRollout(entry.filePath);
     if (!rollout || rollout.threadId !== sessionId) {
         return { events: [] };

package/dist/session/codex/sessions.d.ts

@@ -13,7 +13,7 @@ export declare class CodexSessionReader implements AgentSessionReader {
         total: number;
     };
     getNewestSession(cwd: string): AgentSession | null;
-    readSessionContent(sessionId: string, _cwd: string, opts?: {
+    readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
     isSessionActive(sessionId: string, _cwd: string): boolean;