lark-remote 0.1.2 → 0.1.4

package/dist/router/utils.d.ts

@@ -5,6 +5,8 @@
 import type { ActiveRunSnapshot } from '../bridge/index.js';
 export interface SessionDisplayUsage {
     contextLength?: number;
+    /** 当前模型 context window 上限（仅 codex 提供）；用于渲染 "Context - X (Y%)"。 */
+    contextLimit?: number;
     compactCount?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
@@ -18,6 +20,7 @@ export declare function activeRunUsage(activeRun: ActiveRunSnapshot | undefined)
  */
 export declare function formatUsageStats(usage?: {
     contextLength?: number;
+    contextLimit?: number;
     compactCount?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;

package/dist/router/utils.js

@@ -14,10 +14,18 @@ export function activeRunUsage(activeRun) {
 }
 // --- Extracted helpers for refactoring ---
 /**
- * Format number to K unit string, rounding to the nearest integer K
- * (e.g., 120000 → 120K, 1500 → 2K, 1950 → 2K). Values < 1000 are returned as-is.
+ * Format number to human-readable unit string.
+ * - >= 1M: one decimal, M suffix (e.g., 1200000 → 1.2M, 25000000 → 25M)
+ * - >= 1K: rounded to nearest integer K (e.g., 1500 → 2K, 120000 → 120K)
+ * - < 1K: as-is (e.g., 500 → "500")
  */
 function formatTokenK(n) {
+    if (n >= 1_000_000) {
+        const m = n / 1_000_000;
+        const rounded = Math.round(m * 10) / 10;
+        // Drop unnecessary ".0" for whole numbers (2.0M → 2M)
+        return rounded === Math.floor(rounded) ? `${Math.floor(rounded)}M` : `${rounded}M`;
+    }
     if (n >= 1000) {
         const k = Math.round(n / 1000);
         return `${k}K`;
@@ -40,7 +48,11 @@ export function formatUsageStats(usage, options) {
     }
     // 2. Context 长度
     if (usage?.contextLength !== undefined) {
-        lines.push(`Context - ${formatTokenK(usage.contextLength)}`);
+        const ctxLimit = usage.contextLimit;
+        const ctxPercent = ctxLimit !== undefined && ctxLimit > 0
+            ? ` (${Math.round((usage.contextLength / ctxLimit) * 100)}%)`
+            : '';
+        lines.push(`Context - ${formatTokenK(usage.contextLength)}${ctxPercent}`);
     }
     // 3. Compact 次数
     if (usage?.compactCount) {

package/dist/runner/claude/runner.d.ts

@@ -12,7 +12,6 @@ export declare class ClaudeRunner extends SpawningRunner implements IAgentRunner
     private defaultEffort;
     private defaultSettings?;
     constructor(opts: {
-        binary?: string;
         model?: string;
         effort?: string;
         settings?: string;

package/dist/runner/claude/runner.js

@@ -19,7 +19,6 @@ export class ClaudeRunner extends SpawningRunner {
     defaultSettings;
     constructor(opts) {
         super({
-            binary: opts.binary ?? 'claude',
             pidDir: opts.pidDir,
             workspace: opts.workspace,
             stopGraceMs: opts.stopGraceMs,
@@ -27,6 +26,7 @@ export class ClaudeRunner extends SpawningRunner {
             pidFilePrefix: 'claude',
             logTag: 'claude-runner',
         });
+        this.binary = 'claude';
         this.defaultModel = opts.model ?? 'claude-opus-4-8';
         this.defaultEffort = opts.effort ?? 'medium';
         this.defaultSettings = opts.settings;

package/dist/runner/codex/runner.d.ts

@@ -26,8 +26,6 @@ import type { AgentKind, AgentSessionReader, AgentEvent, AgentRunner, AgentStatu
 import type { SpawnOptions } from '../types.js';
 import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
 interface CodexExecRunnerOptions {
-    /** Path to codex binary. Default: 'codex' (in PATH). */
-    binary?: string;
     /** Model override. Omitted → codex reads from its config.toml. */
     model?: string;
     /** Model provider override. Omitted → codex reads from its config.toml. */

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

@@ -20,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 路径错乱).
  */
@@ -83,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);
@@ -92,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
@@ -125,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;
@@ -148,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.
@@ -172,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 = {}) {
@@ -236,11 +268,21 @@ function scanDirForSessions(cwd, dir) {
     return sessions;
 }
 /**
- * Scan OTHER project subdirectories for jsonl files whose cwd matches the
- * requested cwd. Used as a fallback when the primary dir doesn't contain the
- * session (EnterWorktree moves the transcript to the new cwd's project dir).
+ * 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). P1 fix 2026-08-10.
+ * (avoids duplicates). S2 fix 2026-08-10.
  */
 function scanRelocatedSessions(cwd, primaryDir, projectsDir, seenIds) {
     let entries;
@@ -281,13 +323,19 @@ function scanRelocatedSessions(cwd, primaryDir, projectsDir, seenIds) {
                 continue;
             try {
                 const st = fs.statSync(full);
-                if (!jsonlContainsCwd(full, cwd))
+                // 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}`);
@@ -297,11 +345,14 @@ function scanRelocatedSessions(cwd, primaryDir, projectsDir, seenIds) {
     return sessions;
 }
 /** Uncached scan of a claude project dir (the expensive part being cached).
- *  P1 fix: cwd guard now uses `jsonlContainsCwd` (any cwd field matches)
- *  instead of `readCwdFromJsonl` (first cwd only). Relocated sessions
- *  (EnterWorktree) contain multiple cwd values; the first one is the
- *  pre-relocate path, which would be rejected by the old first-cwd-only
- *  check. See regression 2026-08-10 list vs read inconsistency.
+ *  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 = [];
@@ -309,17 +360,12 @@ function scanClaudeSessions(cwd, dir, projectsDir) {
     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. Only scan OTHER project subdirs
-    // when the primary scan found nothing (the common case: primary dir has
-    // all sessions, no need to scan elsewhere). When primary has results,
-    // relocated sessions in other dirs that match this cwd are already
-    // handled by jsonlContainsCwd on files in the primary dir (the file was
-    // moved TO the primary dir's encoded path). Skip to avoid O(all projects)
-    // overhead on every cached-miss list call.
+    // 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 (primarySessions.length === 0 &&
-        effectiveProjectsDir &&
-        dir.startsWith(effectiveProjectsDir)) {
+    if (effectiveProjectsDir && dir.startsWith(effectiveProjectsDir)) {
         const seenIds = new Set(primarySessions.map((s) => s.sessionId));
         const crossDirSessions = scanRelocatedSessions(cwd, dir, effectiveProjectsDir, seenIds);
         sessions.push(...crossDirSessions);
@@ -385,7 +431,7 @@ export function isClaudeSessionActive(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 false;
         filePath = relocated;
@@ -485,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;
                     }
                 }
@@ -583,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.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,
@@ -256,6 +262,9 @@ export function readCodexSessionContent(sessionId, opts = {}) {
     // 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: [] };
     }

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

@@ -24,7 +24,9 @@ export type CwdGuardResult = 'verified' | 'failed' | 'unverifiable';
  * - failed: session has a workDir but it doesn't match realCwd
  * - unverifiable: session has no workDir field (cannot verify)
  *
- * Unverifiable is a fail-open state — the caller should allow access and log a warning.
+ * Unverifiable sessions are handled by the caller: when no cwd source can
+ * verify the session, it is rejected (fail-closed), aligned with claude's
+ * cwd guard semantics.
  */
 export declare function checkCwdGuard(state: KimiSessionState, realCwd: string): CwdGuardResult;
 /**

package/dist/session/kimi/sessions.js

@@ -105,7 +105,9 @@ export function extractWorkDir(state) {
  * - failed: session has a workDir but it doesn't match realCwd
  * - unverifiable: session has no workDir field (cannot verify)
  *
- * Unverifiable is a fail-open state — the caller should allow access and log a warning.
+ * Unverifiable sessions are handled by the caller: when no cwd source can
+ * verify the session, it is rejected (fail-closed), aligned with claude's
+ * cwd guard semantics.
  */
 export function checkCwdGuard(state, realCwd) {
     const sessionWorkDir = extractWorkDir(state);
@@ -330,9 +332,13 @@ export class KimiSessionReader {
             if (indexWorkDir && indexWorkDir !== realCwd) {
                 return { events: [] };
             }
-            // When index also has no workDir, fall through (unverifiable from all sources)
+            // v2 sessions have empty index workDir (v1-only field) and may lack
+            // state.json cwd. When no cwd source can verify the session belongs to
+            // the requested workspace, fail-closed to prevent cross-workspace access
+            // (aligned with claude's fail-closed cwd guard).
             if (!indexWorkDir) {
-                getLogger().warn(`[kimi-session-reader] no cwd source (state.json + index) for session ${sessionId}, skipping cwd guard`);
+                getLogger().warn(`[kimi-session-reader] no cwd source (state.json + index) for session ${sessionId}, rejecting (fail-closed)`);
+                return { events: [] };
             }
         }
         const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');