@adhdev/daemon-core 0.9.82-rc.540 → 0.9.82-rc.541

package/dist/providers/spec/types.d.ts

@@ -71,8 +71,62 @@ export interface NativeHistoryJsonlSource {
     path: string;
     file_pattern?: string;
     recent_window_ms?: number;
-    session_id_from?: 'filename_uuid' | 'first_record';
+    /**
+     * Where to read the provider session id from.
+     *   'filename_uuid' (default) — the transcript FILE basename embeds the
+     *     uuid (`<uuid>.jsonl`, cursor-agent).
+     *   'first_record'  — jsonpath (`session_id_path`) into the first record.
+     *   'dir_uuid'      — a PARENT DIRECTORY segment embeds the uuid, and the
+     *     leaf file has a fixed name. kimi persists every session at
+     *     `~/.kimi-code/sessions/<wdKey>/session_<uuid>/agents/main/wire.jsonl`
+     *     — the file is always `wire.jsonl`, so the uuid can only come from the
+     *     `session_<uuid>` directory segment. The nearest ancestor segment
+     *     containing a uuid wins.
+     */
+    session_id_from?: 'filename_uuid' | 'first_record' | 'dir_uuid';
     session_id_path?: string;
+    /**
+     * Fallback workspace attribution from a per-session SIDECAR json file when
+     * the transcript itself carries no `session_meta` cwd record AND the on-disk
+     * directory slug is irreversible. kimi's `wire.jsonl` has no cwd line and the
+     * `wd_<slug>_<sha12>` directory segment is a lossy slug + hash that cannot be
+     * reversed to the real workspace. But kimi writes a sibling `state.json` next
+     * to the session dir carrying the authoritative `workDir`. This option names
+     * that sidecar (relative to the resolved wire file's directory) and the json
+     * path to the workspace inside it; the executor reads it, stamps the value as
+     * the transcript workspace on every message, and — for workspace-scoped file
+     * selection (no pinned session id yet, the antigravity/opencode first-read
+     * case) — only accepts a candidate wire file whose sidecar workDir matches the
+     * input workspace. Mirrors cursor's `workspace_from_input` and opencode's
+     * per-row `message_map.workspace`, for a jsonl store whose workspace lives in
+     * a sidecar rather than in the transcript or a reversible slug.
+     */
+    workspace_from_sidecar?: {
+        /** Path to the sidecar json, relative to the resolved wire file's
+         *  directory. e.g. `../../state.json` for
+         *  `session_<uuid>/agents/main/wire.jsonl` → `session_<uuid>/state.json`. */
+        rel_path: string;
+        /** jsonpath-lite to the workspace string inside the sidecar. e.g.
+         *  `$.workDir`. */
+        workspace_path: string;
+    };
+    /**
+     * Multi-shape record projection. A jsonl store whose user turns and
+     * assistant turns are DIFFERENT record types (so a single `message_map`
+     * can't extract both roles) declares one matcher per shape here. For each
+     * on-disk record the executor picks the FIRST entry whose `where` matches
+     * and projects the record with that entry's `message_map`; a record that
+     * matches no entry is dropped. kimi stores user turns as
+     * `type=="turn.prompt"` (`$.input[*].text`, role=user) and assistant text as
+     * `type=="context.append_loop_event"` content.part events
+     * (`$.event.part.text`, role=assistant) — two shapes with different role and
+     * content paths. Absent → the top-level single `message_map` (+ optional
+     * `message_filter`) path is used unchanged.
+     */
+    records?: Array<{
+        where?: string;
+        message_map: NativeHistoryMessageMap;
+    }>;
     message_filter?: {
         where: string;
     };
@@ -93,7 +147,8 @@ export interface NativeHistoryJsonlSource {
      * closed as before.
      */
     workspace_from_input?: boolean;
-    message_map: NativeHistoryMessageMap;
+    /** Single-shape projection. Required unless `records` (multi-shape) is set. */
+    message_map?: NativeHistoryMessageMap;
 }
 export interface NativeHistorySqliteSource {
     kind: 'sqlite';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.540",
+  "version": "0.9.82-rc.541",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.540",
-    "@adhdev/session-host-core": "0.9.82-rc.540",
+    "@adhdev/mesh-shared": "0.9.82-rc.541",
+    "@adhdev/session-host-core": "0.9.82-rc.541",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -112,6 +112,21 @@ const IDLE_CONFIRMATION_GRACE_MS = 2_000;
 // so a genuinely-finished turn can never be held past this bound (no infinite defer).
 const APPROVAL_RESUME_IDLE_DEFER_CAP_MS = 18_000;
 
+// FALSE-IDLE (screen-quiet gate): the generating→idle transition (both the
+// candidate-confirmed finish AND the idleFinish timeout finish) requires the
+// VISIBLE TERMINAL SCREEN CONTENT to have been byte-identical for at least this
+// long, continuously. `snap.lastScreenChangeAt` is bumped by the adapter every
+// time the normalized screen snapshot changes (a spinner frame, streaming
+// command output, etc.), so `now - lastScreenChangeAt` is the real screen-diff
+// quiet age. A worker that is WAITING on a long-running foreground command
+// (e.g. a `curl :3847/health` poll loop) keeps repainting the screen, so its
+// quiet age never reaches this threshold and it can never be declared idle.
+// This is a NECESSARY gate layered on top of the existing settle conditions —
+// it only ever prevents a finish, never forces one. Owner-chosen at 5s (8s felt
+// too long). Screen snapshots are read at most every 250ms
+// (SCREEN_SNAPSHOT_MIN_INTERVAL_MS), so the granularity is well under 5s.
+const SCREEN_QUIET_IDLE_MS = 5_000;
+
 // ─── Engine ────────────────────────────────────────────────────────────────
 
 export class CliStateEngine {
@@ -773,6 +788,13 @@ export class CliStateEngine {
         this.idleTimeout = setTimeout(() => {
             if (this.isWaitingForResponse && !this.hasActionableApproval()) {
                 if (this.shouldDeferIdleTimeoutFinish()) return;
+                // FALSE-IDLE (screen-quiet gate): a recent_activity_hold worker still
+                // repainting (spinner + streaming command output) must NOT be finished
+                // by this timeout. Re-arm and re-evaluate until the screen is quiet.
+                if (!this.hasScreenBeenQuietForIdle(Date.now())) {
+                    this.evaluateSettled(this.transport.getSnapshot());
+                    return;
+                }
                 this.finishResponse();
             }
         }, this.timeouts.generatingIdle);
@@ -794,6 +816,12 @@ export class CliStateEngine {
                 this.idleTimeout = setTimeout(() => {
                     if (this.isWaitingForResponse && !this.hasActionableApproval()) {
                         if (this.shouldDeferIdleTimeoutFinish()) return;
+                        // FALSE-IDLE (screen-quiet gate): do not finish while the screen
+                        // is still repainting (see applyHoldGenerating).
+                        if (!this.hasScreenBeenQuietForIdle(Date.now())) {
+                            this.evaluateSettled(this.transport.getSnapshot());
+                            return;
+                        }
                         this.finishResponse();
                     }
                 }, this.timeouts.generatingIdle);
@@ -922,6 +950,15 @@ export class CliStateEngine {
         this.idleTimeout = setTimeout(() => {
             if (this.isWaitingForResponse) {
                 if (this.shouldDeferIdleTimeoutFinish()) return;
+                // FALSE-IDLE (screen-quiet gate): the generating→idle timeout must NOT
+                // finish while the visible screen is still changing (spinner + streaming
+                // command output). This is the primary false-idle path — a worker WAITING
+                // on a long-running foreground command sits in generating with a live,
+                // repainting screen. Re-evaluate until the screen has been quiet >= 5s.
+                if (!this.hasScreenBeenQuietForIdle(Date.now())) {
+                    this.evaluateSettled(this.transport.getSnapshot());
+                    return;
+                }
                 this.finishResponse();
             }
         }, this.timeouts.generatingIdle);
@@ -1007,7 +1044,15 @@ export class CliStateEngine {
         const assistantLength = (lastParsedAssistant as any)?.content?.length || 0;
         const idleFinishConfirmMs = this.timeouts.idleFinishConfirm;
         const idleQuietThresholdMs = Math.max(idleFinishConfirmMs, this.timeouts.outputSettle);
-        const idleReady = !modal && hasAssistantTurn && quietForMs >= idleQuietThresholdMs && screenStableMs >= idleFinishConfirmMs;
+        // FALSE-IDLE (screen-quiet gate): NECESSARY condition — the visible screen
+        // content must have been byte-identical for >= SCREEN_QUIET_IDLE_MS. A worker
+        // still repainting (spinner frame, streaming command output) resets
+        // lastScreenChangeAt on every change, so its quiet age never reaches the
+        // threshold and it can never arm/confirm idle. Layered on top of the existing
+        // conditions — it only ever prevents a finish, never forces one.
+        const screenQuietForIdle = screenStableMs >= SCREEN_QUIET_IDLE_MS;
+        const idleReady = !modal && hasAssistantTurn && quietForMs >= idleQuietThresholdMs
+            && screenStableMs >= idleFinishConfirmMs && screenQuietForIdle;
         const candidate = this.idleFinishCandidate;
         const candidateQuiet = !!candidate && candidate.responseEpoch === this.responseEpoch
             && candidate.lastOutputAt === snap.lastOutputAt
@@ -1060,6 +1105,19 @@ export class CliStateEngine {
                     return;
                 }
                 if (this.shouldDeferIdleTimeoutFinish()) return;
+                // FALSE-IDLE (screen-quiet gate): the idleFinish timeout must NOT
+                // finish while the visible screen is still changing. A worker
+                // WAITING on a long-running foreground command keeps repainting the
+                // screen (spinner + streaming output), so lastScreenChangeAt stays
+                // fresh and the quiet age never reaches SCREEN_QUIET_IDLE_MS. Re-arm
+                // and re-evaluate instead of emitting a weak/false completion.
+                if (!this.hasScreenBeenQuietForIdle(Date.now())) {
+                    if (this.idleTimeout) clearTimeout(this.idleTimeout);
+                    this.idleTimeout = setTimeout(() => {
+                        if (this.isWaitingForResponse) this.evaluateSettled(this.transport.getSnapshot());
+                    }, this.timeouts.idleFinish);
+                    return;
+                }
                 const parsed = this.runParseSession(this.transport.getSnapshot());
                 if (this.shouldDeferFinishForTranscript(parsed)) {
                     this.rescheduleTranscriptFinishCheck('transcript_idle_timeout_not_final');
@@ -1071,6 +1129,23 @@ export class CliStateEngine {
         }, this.timeouts.idleFinish);
     }
 
+    /**
+     * FALSE-IDLE (screen-quiet gate): has the visible terminal screen content been
+     * byte-identical for at least SCREEN_QUIET_IDLE_MS continuously?
+     *
+     * `lastScreenChangeAt` is bumped by the adapter every time the normalized screen
+     * snapshot changes (spinner frame, streaming command output, etc.), so
+     * `now - lastScreenChangeAt` is the real screen-diff quiet age. Reads the LIVE
+     * transport snapshot so the deferred idleFinish timeout re-checks current screen
+     * state, not the stale snapshot from when the timer was armed. A never-changed
+     * screen (lastScreenChangeAt === 0) is treated as quiet.
+     */
+    private hasScreenBeenQuietForIdle(now: number): boolean {
+        const lastChange = this.transport.getSnapshot().lastScreenChangeAt;
+        if (!lastChange) return true;
+        return (now - lastChange) >= SCREEN_QUIET_IDLE_MS;
+    }
+
     /**
      * FALSE-IDLE (Fix 2): should applyIdle suppress the idle/finish for the current
      * turn because we are inside the post-approval resume grace?

package/src/commands/chat-commands-read.ts

@@ -3,6 +3,7 @@
  * native-history / source-resolution / normalization helpers they use.
  */
 
+import * as fs from 'node:fs';
 import * as path from 'node:path';
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
@@ -1151,7 +1152,33 @@ function readExactRuntimeMirrorMessages(args: {
 function normalizeComparableWorkspace(value: unknown): string {
     const text = typeof value === 'string' ? value.trim() : '';
     if (!text) return '';
-    return path.resolve(text);
+    // Canonicalize via realpath so symlink aliases compare equal. On macOS
+    // `/tmp` is a symlink to `/private/tmp`: a provider whose on-disk workspace
+    // record is stored realpath'd (kimi's state.json workDir → `/private/tmp/…`)
+    // must still match an ADHDev session workspace passed as `/tmp/…`. Without
+    // this the native-history workspace-safety gate (workspace_from_sidecar) saw
+    // a false mismatch, marked the read unsafe, and fell back to the PTY parser.
+    // realpath throws when the path doesn't exist (e.g. a stale/never-created
+    // workspace) — fall back to the lexical resolve then, never crash the read
+    // path. Fail-closed cross-workspace safety is preserved: two genuinely
+    // different directories still realpath to different paths, and the lexical
+    // fallback is unchanged from the prior behaviour.
+    const lexical = path.resolve(text);
+    try {
+        return fs.realpathSync.native(lexical);
+    } catch {
+        try {
+            return fs.realpathSync(lexical);
+        } catch {
+            return lexical;
+        }
+    }
+}
+
+/** Test hook for the symlink-safe workspace comparison used by the
+ *  native-history workspace-safety gate. */
+export function __normalizeComparableWorkspaceForTest(value: unknown): string {
+    return normalizeComparableWorkspace(value);
 }
 function isCurrentRuntimePtySafelyAttributed(args: {
     adapter: CliAdapter;

package/src/mesh/coordinator-prompt.ts

@@ -842,7 +842,8 @@ function buildRulesSection(coordinatorCliType?: string): string {
 
     return `## Rules
 
-- **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator — keep context lean.
+- **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator — keep context lean. See also: **Never use local sub-agents** below.
+- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh — they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no \`mesh_task_history\` record. ALL code reading, analysis, RCA, and implementation must be delegated to mesh nodes via \`mesh_enqueue_task\` / \`mesh_send_task\` (use \`task_mode: "live_debug_readonly"\` for read-only investigation), or cross-verified via \`mesh_magi_review\` for read-only fan-out. The coordinator's own actions are limited to \`mesh_*\` tool orchestration and synthesizing results.
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, or (d) the user explicitly asks for a different provider/session. Continuation of the same issue in an already-idle session is allowed and preferred — this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups.
 - **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node by targeting \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` — the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.

package/src/providers/spec/native-history-executor.ts

@@ -109,29 +109,40 @@ function executeJsonl(src: NativeHistoryJsonlSource, input: NativeHistoryInput):
     // Prefer an in-transcript session_meta cwd; fall back to the input workspace
     // only when the spec opts in AND the resolved file lives under that
     // workspace's project slug (cursor-agent writes no session_meta and hides the
-    // workspace in the lossy on-disk slug — see workspace_from_input).
+    // workspace in the lossy on-disk slug — see workspace_from_input). A store
+    // whose workspace lives in a per-session sidecar json (kimi's state.json,
+    // whose `wd_<slug>_<sha12>` dir is irreversible) reads it from there.
     const transcriptWorkspace = readSessionMetaWorkspace(lines)
+        ?? (src.workspace_from_sidecar ? readSidecarWorkspace(sourcePath, src.workspace_from_sidecar) : undefined)
         ?? (src.workspace_from_input ? workspaceFromInputIfSlugMatches(sourcePath, input) : undefined);
 
-    // session id: filename uuid or extracted from first record
+    // session id: filename uuid, a parent directory uuid, or extracted from the
+    // first record.
     let providerSessionId: string | undefined;
     if (src.session_id_from === 'first_record' && src.session_id_path) {
         const v = jsonPathGet(lines[0], src.session_id_path);
         if (typeof v === 'string' && v) providerSessionId = v;
+    } else if (src.session_id_from === 'dir_uuid') {
+        providerSessionId = dirUuid(sourcePath) || undefined;
     } else if (src.session_id_from === 'filename_uuid' || !src.session_id_from) {
         const m = path.basename(sourcePath).match(UUID_RE);
         if (m) providerSessionId = m[1];
     }
 
+    // Compare requested vs resolved by embedded uuid so a `session_<uuid>` pin
+    // (kimi's on-disk session id carries a `session_` prefix) still matches the
+    // bare uuid the executor extracts from the directory segment.
     const requested = readRequestedSessionId(input) || '';
-    if (requested && providerSessionId && providerSessionId !== requested) return null;
+    if (requested && providerSessionId && !sameSessionUuid(providerSessionId, requested)) return null;
 
-    const filter = src.message_filter ? compileWhere(src.message_filter.where) : null;
+    // Multi-shape (records[]) vs single-shape (message_map) projection.
+    const shapes = compileRecordShapes(src);
     const messages: NativeHistoryMessage[] = [];
     for (let i = 0; i < lines.length; i += 1) {
         const rec = lines[i];
-        if (filter && !filter(rec)) continue;
-        for (const msg of projectMessages(rec, src.message_map, i, lines.length, mtime)) {
+        const shape = shapes.pick(rec);
+        if (!shape) continue;
+        for (const msg of projectMessages(rec, shape.map, i, lines.length, mtime)) {
             if (transcriptWorkspace) msg.workspace = transcriptWorkspace;
             messages.push(msg);
         }
@@ -188,9 +199,31 @@ export function resolveJsonlSourcePath(src: NativeHistoryJsonlSource, input: Nat
     const workspaceHint = typeof input.workspace === 'string' && input.workspace.trim() ? input.workspace.trim() : '';
     let sourcePath: string | null = null;
     if (resolved.includes('*')) {
-        sourcePath = pickExactSessionFileAcrossGlob(resolved, filePat, requestedSessionId)
-            || pickSessionBoundFileAcrossGlob(resolved, filePat, windowMs, sessionFloor, workspaceHint)
-            || newestRecentFileAcrossGlob(resolved, filePat, windowMs, sessionFloor);
+        // dir_uuid + sidecar-workspace stores (kimi): the session id lives in a
+        // parent directory segment (not the fixed leaf filename) and the
+        // workspace lives in a per-session sidecar json (not the irreversible
+        // `wd_<slug>_<sha12>` dir, not the transcript). The filename-uuid pickers
+        // can't match here, so select by the directory uuid when pinned, else by
+        // the sidecar workDir + recency when workspace-scoped.
+        if (src.session_id_from === 'dir_uuid' || src.workspace_from_sidecar) {
+            // Pinned → match by directory uuid. Unpinned + a workspace hint →
+            // scope to the sidecar workDir and FAIL CLOSED (no workspace-blind
+            // newest-file fallback) so another workspace's session is never
+            // aliased. Only when there is neither a pin nor a workspace hint do
+            // we fall back to newest-recent (single-session dev/test case).
+            sourcePath = pickDirUuidFileAcrossGlob(resolved, filePat, requestedSessionId);
+            if (!sourcePath && !requestedSessionId) {
+                if (src.workspace_from_sidecar && workspaceHint) {
+                    sourcePath = pickSidecarWorkspaceFileAcrossGlob(resolved, filePat, windowMs, sessionFloor, workspaceHint, src.workspace_from_sidecar);
+                } else {
+                    sourcePath = newestRecentFileAcrossGlob(resolved, filePat, windowMs, sessionFloor);
+                }
+            }
+        } else {
+            sourcePath = pickExactSessionFileAcrossGlob(resolved, filePat, requestedSessionId)
+                || pickSessionBoundFileAcrossGlob(resolved, filePat, windowMs, sessionFloor, workspaceHint)
+                || newestRecentFileAcrossGlob(resolved, filePat, windowMs, sessionFloor);
+        }
     } else {
         let stat: fs.Stats | null = null;
         try { stat = fs.statSync(resolved); } catch { /* fall through to date-walk fallback */ }
@@ -253,6 +286,82 @@ function readSessionMetaWorkspace(lines: any[]): string | undefined {
     return undefined;
 }
 
+/**
+ * Read the workspace from a per-session sidecar json file (kimi's state.json).
+ * `rel_path` is resolved relative to the wire file's directory and the workspace
+ * is pulled out via `workspace_path` (jsonpath-lite). Returns undefined on any
+ * miss so the caller falls through to the next attribution strategy.
+ */
+function readSidecarWorkspace(
+    sourcePath: string,
+    cfg: { rel_path: string; workspace_path: string },
+): string | undefined {
+    try {
+        const sidecar = path.resolve(path.dirname(sourcePath), cfg.rel_path);
+        const parsed = JSON.parse(fs.readFileSync(sidecar, 'utf8'));
+        const v = jsonPathGet(parsed, cfg.workspace_path);
+        return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+/**
+ * Extract a uuid from the nearest ancestor DIRECTORY segment of a file path
+ * (kimi's `.../session_<uuid>/agents/main/wire.jsonl`). Walks from the leaf's
+ * parent upward and returns the first uuid found, or '' when none.
+ */
+function dirUuid(filePath: string): string {
+    const segs = path.dirname(filePath).split(path.sep);
+    for (let i = segs.length - 1; i >= 0; i -= 1) {
+        const m = segs[i].match(UUID_RE);
+        if (m) return m[1];
+    }
+    return '';
+}
+
+/** Compare two session ids by their embedded uuid, ignoring any prefix/suffix
+ *  (kimi's `session_<uuid>` pin vs the bare `<uuid>` the executor extracts). */
+function sameSessionUuid(a: string, b: string): boolean {
+    if (a === b) return true;
+    const ua = a.match(UUID_RE)?.[1]?.toLowerCase();
+    const ub = b.match(UUID_RE)?.[1]?.toLowerCase();
+    return !!ua && !!ub && ua === ub;
+}
+
+/**
+ * Resolve the projection strategy for a jsonl source. Multi-shape (`records[]`)
+ * picks the first entry whose `where` matches a record; single-shape falls back
+ * to the top-level `message_map` gated by the optional `message_filter`.
+ */
+function compileRecordShapes(src: NativeHistoryJsonlSource): {
+    pick: (record: any) => { map: NativeHistoryMessageMap } | null;
+} {
+    if (Array.isArray(src.records) && src.records.length > 0) {
+        const compiled = src.records.map((r) => ({
+            where: r.where ? compileWhere(r.where) : null,
+            map: r.message_map,
+        }));
+        return {
+            pick: (record: any) => {
+                for (const shape of compiled) {
+                    if (!shape.where || shape.where(record)) return { map: shape.map };
+                }
+                return null;
+            },
+        };
+    }
+    const filter = src.message_filter ? compileWhere(src.message_filter.where) : null;
+    const map = src.message_map;
+    return {
+        pick: (record: any) => {
+            if (!map) return null;
+            if (filter && !filter(record)) return null;
+            return { map };
+        },
+    };
+}
+
 /**
  * Return `input.workspace` when the resolved transcript file provably lives
  * under that workspace's project-slug directory, else undefined.
@@ -835,6 +944,62 @@ function pickExactSessionFileAcrossGlob(template: string, pattern: RegExp, reque
     return matches[0] || null;
 }
 
+/**
+ * dir_uuid exact pick across a glob: the requested session uuid is embedded in a
+ * parent DIRECTORY segment (kimi's `session_<uuid>/…/wire.jsonl`), not the leaf
+ * filename. Match the file whose ancestor path carries the requested uuid.
+ */
+function pickDirUuidFileAcrossGlob(template: string, pattern: RegExp, requestedSessionId: string): string | null {
+    if (!requestedSessionId) return null;
+    const wantUuid = requestedSessionId.match(UUID_RE)?.[1]?.toLowerCase();
+    if (!wantUuid) return null;
+    const dirs = expandDirGlob(template);
+    const matches: string[] = [];
+    for (const d of dirs) {
+        for (const p of listMatchingFiles(d, pattern)) {
+            if (dirUuid(p).toLowerCase() === wantUuid) matches.push(p);
+        }
+    }
+    matches.sort((a, b) => safeMtimeMs(b) - safeMtimeMs(a));
+    return matches[0] || null;
+}
+
+/**
+ * Workspace-scoped pick across a glob for a sidecar-workspace store (kimi's
+ * first read, before a session id is pinned): among candidate wire files within
+ * the recency window, keep only those whose sidecar `state.json` workDir matches
+ * the input workspace, then take the newest. Fails closed (null) when no sidecar
+ * matches so an unrelated workspace's session is never aliased.
+ */
+function pickSidecarWorkspaceFileAcrossGlob(
+    template: string,
+    pattern: RegExp,
+    windowMs: number,
+    sessionFloorMs: number,
+    workspaceHint: string,
+    sidecar?: { rel_path: string; workspace_path: string },
+): string | null {
+    if (!sidecar || !workspaceHint) return null;
+    let wsResolved = workspaceHint;
+    try { wsResolved = fs.realpathSync(workspaceHint); } catch { /* keep raw */ }
+    const dirs = expandDirGlob(template);
+    const cutoff = Math.max(Date.now() - windowMs, sessionFloorMs);
+    let best: { p: string; mtime: number } | null = null;
+    for (const d of dirs) {
+        for (const p of listMatchingFiles(d, pattern)) {
+            const mtime = safeMtimeMs(p);
+            if (mtime < cutoff) continue;
+            const ws = readSidecarWorkspace(p, sidecar);
+            if (!ws) continue;
+            let wsReal = ws;
+            try { wsReal = fs.realpathSync(ws); } catch { /* keep raw */ }
+            if (ws !== workspaceHint && wsReal !== wsResolved) continue;
+            if (!best || mtime > best.mtime) best = { p, mtime };
+        }
+    }
+    return best ? best.p : null;
+}
+
 function pickExactSessionFileAcrossDateWindow(
     template: string,
     input: NativeHistoryInput,

package/src/providers/spec/types.ts

@@ -92,8 +92,59 @@ export interface NativeHistoryJsonlSource {
     path: string;
     file_pattern?: string;
     recent_window_ms?: number;
-    session_id_from?: 'filename_uuid' | 'first_record';
+    /**
+     * Where to read the provider session id from.
+     *   'filename_uuid' (default) — the transcript FILE basename embeds the
+     *     uuid (`<uuid>.jsonl`, cursor-agent).
+     *   'first_record'  — jsonpath (`session_id_path`) into the first record.
+     *   'dir_uuid'      — a PARENT DIRECTORY segment embeds the uuid, and the
+     *     leaf file has a fixed name. kimi persists every session at
+     *     `~/.kimi-code/sessions/<wdKey>/session_<uuid>/agents/main/wire.jsonl`
+     *     — the file is always `wire.jsonl`, so the uuid can only come from the
+     *     `session_<uuid>` directory segment. The nearest ancestor segment
+     *     containing a uuid wins.
+     */
+    session_id_from?: 'filename_uuid' | 'first_record' | 'dir_uuid';
     session_id_path?: string;
+    /**
+     * Fallback workspace attribution from a per-session SIDECAR json file when
+     * the transcript itself carries no `session_meta` cwd record AND the on-disk
+     * directory slug is irreversible. kimi's `wire.jsonl` has no cwd line and the
+     * `wd_<slug>_<sha12>` directory segment is a lossy slug + hash that cannot be
+     * reversed to the real workspace. But kimi writes a sibling `state.json` next
+     * to the session dir carrying the authoritative `workDir`. This option names
+     * that sidecar (relative to the resolved wire file's directory) and the json
+     * path to the workspace inside it; the executor reads it, stamps the value as
+     * the transcript workspace on every message, and — for workspace-scoped file
+     * selection (no pinned session id yet, the antigravity/opencode first-read
+     * case) — only accepts a candidate wire file whose sidecar workDir matches the
+     * input workspace. Mirrors cursor's `workspace_from_input` and opencode's
+     * per-row `message_map.workspace`, for a jsonl store whose workspace lives in
+     * a sidecar rather than in the transcript or a reversible slug.
+     */
+    workspace_from_sidecar?: {
+        /** Path to the sidecar json, relative to the resolved wire file's
+         *  directory. e.g. `../../state.json` for
+         *  `session_<uuid>/agents/main/wire.jsonl` → `session_<uuid>/state.json`. */
+        rel_path: string;
+        /** jsonpath-lite to the workspace string inside the sidecar. e.g.
+         *  `$.workDir`. */
+        workspace_path: string;
+    };
+    /**
+     * Multi-shape record projection. A jsonl store whose user turns and
+     * assistant turns are DIFFERENT record types (so a single `message_map`
+     * can't extract both roles) declares one matcher per shape here. For each
+     * on-disk record the executor picks the FIRST entry whose `where` matches
+     * and projects the record with that entry's `message_map`; a record that
+     * matches no entry is dropped. kimi stores user turns as
+     * `type=="turn.prompt"` (`$.input[*].text`, role=user) and assistant text as
+     * `type=="context.append_loop_event"` content.part events
+     * (`$.event.part.text`, role=assistant) — two shapes with different role and
+     * content paths. Absent → the top-level single `message_map` (+ optional
+     * `message_filter`) path is used unchanged.
+     */
+    records?: Array<{ where?: string; message_map: NativeHistoryMessageMap }>;
     message_filter?: { where: string };
     /**
      * Fallback workspace attribution when the transcript carries no
@@ -112,7 +163,8 @@ export interface NativeHistoryJsonlSource {
      * closed as before.
      */
     workspace_from_input?: boolean;
-    message_map: NativeHistoryMessageMap;
+    /** Single-shape projection. Required unless `records` (multi-shape) is set. */
+    message_map?: NativeHistoryMessageMap;
 }
 
 export interface NativeHistorySqliteSource {