@adhdev/daemon-core 0.9.82-rc.314 → 0.9.82-rc.316

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

@@ -21,6 +21,7 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { LOG } from '../../logging/logger.js';
 import type {
     NativeHistoryConfig,
     NativeHistoryJsonlSource,
@@ -138,8 +139,48 @@ function executeJsonl(src: NativeHistoryJsonlSource, input: NativeHistoryInput):
                 || (requestedSessionId ? null : pickSessionBoundFileAcrossDateWindow(src.path, input, filePat, windowMs, sessionFloor, workspaceHint))
                 || (requestedSessionId ? null : newestRecentFileAcrossDateWindow(src.path, input, filePat, windowMs, sessionFloor));
         }
+        // Raw-workspace slug candidate: `resolved` derives its {cwd*} slug from
+        // fs.realpathSync(workspace). On Windows realpath normalizes the path
+        // (drive-letter case D:↔d:, \\?\ long-path prefix, junction expansion)
+        // so the slug can diverge from the one the CLI actually wrote — and the
+        // concrete path above then misses with ENOENT. Retry with the slug built
+        // from the RAW workspace string before falling back to a scan; it's the
+        // cheap fix when realpath divergence is the only problem.
+        if (!sourcePath && !hasDateTemplateSegment(src.path)) {
+            const resolvedRaw = expandPath(src.path, input, { skipWorkspaceRealpath: true });
+            if (resolvedRaw && resolvedRaw !== resolved) {
+                try {
+                    const rawStat = fs.statSync(resolvedRaw);
+                    if (rawStat.isFile()) sourcePath = resolvedRaw;
+                    else if (rawStat.isDirectory()) {
+                        sourcePath = pickExactSessionFile(resolvedRaw, filePat, requestedSessionId)
+                            || (requestedSessionId ? null : newestRecentFile(resolvedRaw, filePat, windowMs, sessionFloor));
+                    }
+                } catch { /* raw slug also missed — fall through to scan */ }
+            }
+        }
+        // Last-resort scan: the slug-derived directory missed entirely (the
+        // dominant Windows failure: realpath/raw slug both diverge from the CLI's
+        // on-disk project dir → 0 messages, no PTY fallback for native-source
+        // providers). When we have an exact session id, walk the projects root
+        // for `<sessionId>.jsonl` regardless of which project subdir holds it.
+        // The session id is a UUID, so basename matching is unambiguous; mirrors
+        // the standalone reader's scan (claude-cli-transcript.ts resolveTranscriptPath).
+        if (!sourcePath && requestedSessionId) {
+            sourcePath = scanProjectsRootForSessionFile(src.path, input, requestedSessionId);
+        }
+    }
+    if (!sourcePath) {
+        // Was silent before — a slug miss produced 0 messages with no trace, so
+        // a live read_chat returning empty was indistinguishable from "no file"
+        // vs "wrong path". Log the attempted concrete path + both slug variants
+        // so the failure mode is greppable in daemon logs.
+        const wsRaw = typeof input.workspace === 'string' ? input.workspace : '';
+        let wsReal = wsRaw;
+        try { if (wsRaw) wsReal = fs.realpathSync(wsRaw); } catch { /* keep raw */ }
+        LOG.debug('NativeHistory', `jsonl unresolved: tried=${JSON.stringify(resolved)} sessionId=${requestedSessionId || '(none)'} wsRaw=${JSON.stringify(wsRaw)} wsReal=${JSON.stringify(wsReal)} rawSlug=${JSON.stringify(claudeProjectDirName(wsRaw))} realSlug=${JSON.stringify(claudeProjectDirName(wsReal))} (concrete miss + raw-slug retry + projects scan all failed)`);
+        return null;
     }
-    if (!sourcePath) return null;
 
     const mtime = safeMtimeMs(sourcePath);
     const lines = readJsonlLines(sourcePath);
@@ -278,7 +319,7 @@ function executeSqlite(src: NativeHistorySqliteSource, input: NativeHistoryInput
 // Path expansion + globbing
 // ────────────────────────────────────────────────────────────────────────────
 
-function expandPath(template: string, input: NativeHistoryInput): string | null {
+function expandPath(template: string, input: NativeHistoryInput, opts?: { skipWorkspaceRealpath?: boolean }): string | null {
     if (!template) return null;
     let out = template;
     if (out.startsWith('~/') || out === '~') {
@@ -301,7 +342,11 @@ function expandPath(template: string, input: NativeHistoryInput): string | null
     // `-`. Realpath also handles aliases such as /tmp -> /private/tmp.
     const workspaceRaw = input.workspace ?? '';
     let workspaceResolved = workspaceRaw;
-    if (workspaceRaw) {
+    // The caller may request the RAW slug (skip realpath) to recover from
+    // Windows realpath normalization diverging the {cwd*} slug from the dir
+    // the CLI actually created. Default keeps realpath (handles /tmp ->
+    // /private/tmp aliasing that the CLI itself resolves on macOS).
+    if (workspaceRaw && !opts?.skipWorkspaceRealpath) {
         try { workspaceResolved = fs.realpathSync(workspaceRaw); }
         catch { /* path may not exist yet — keep the raw value */ }
     }
@@ -333,6 +378,62 @@ function claudeProjectDirName(workspace: string): string {
     return workspace.replace(/[^A-Za-z0-9_-]/g, '-');
 }
 
+/**
+ * Last-resort lookup for a transcript by its exact session id, ignoring the
+ * per-cwd slug entirely. The slug-derived directory above can miss completely
+ * when the CLI's on-disk project dir disagrees with the slug we reconstruct
+ * (notably on Windows, where fs.realpathSync normalizes drive-letter case and
+ * adds a \\?\ prefix). Since the session id is a UUID, scanning the projects
+ * root for `<sessionId>.jsonl` is unambiguous.
+ *
+ * Derives the scan base from the template's segments up to (but excluding) the
+ * first one that references a per-session variable ({cwd*} or {session_id}) —
+ * e.g. `~/.claude/projects/{cwd_claude_project}/{session_id}.jsonl` → scan
+ * `~/.claude/projects`. Returns the matching file path, or null.
+ */
+function scanProjectsRootForSessionFile(template: string, input: NativeHistoryInput, requestedSessionId: string): string | null {
+    if (!requestedSessionId) return null;
+    // Resolve the leading static portion of the template (everything before the
+    // first {var} segment) into a concrete base directory.
+    let head = template;
+    if (head.startsWith('~/') || head === '~') head = path.join(os.homedir(), head.slice(2));
+    const segs = head.split('/');
+    const baseParts: string[] = [];
+    for (const seg of segs) {
+        if (/[{}*?]/.test(seg)) break;
+        baseParts.push(seg);
+    }
+    const base = baseParts.join('/');
+    if (!base) return null;
+    let baseStat: fs.Stats | null = null;
+    try { baseStat = fs.statSync(base); } catch { return null; }
+    if (!baseStat.isDirectory()) return null;
+
+    const needle = `${requestedSessionId.toLowerCase()}.jsonl`;
+    // Bounded walk: project layouts are <root>/<projectDir>/<uuid>.jsonl, so a
+    // shallow scan (root + one level of subdirs) suffices and avoids walking an
+    // unbounded tree. Check the root itself first, then each immediate subdir.
+    const dirsToScan: string[] = [base];
+    try {
+        for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+            if (entry.isDirectory()) dirsToScan.push(path.join(base, entry.name));
+        }
+    } catch { /* readdir failed — fall back to scanning base only */ }
+
+    for (const dir of dirsToScan) {
+        let entries: fs.Dirent[];
+        try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+        for (const entry of entries) {
+            if (!entry.isFile()) continue;
+            if (entry.name.toLowerCase() !== needle) continue;
+            const found = path.join(dir, entry.name);
+            LOG.debug('NativeHistory', `jsonl scan-fallback hit: sessionId=${requestedSessionId} resolved via projects-root scan → ${JSON.stringify(found)} (slug-derived path missed; likely realpath/slug divergence)`);
+            return found;
+        }
+    }
+    return null;
+}
+
 function globToRegex(pattern: string): RegExp {
     // Minimal glob: `*` → `[^/]*`, `?` → `[^/]`, `.` → `\.`. Anchored.
     const re = pattern

package/src/repo-mesh-types.ts

@@ -165,6 +165,106 @@ export function resolveNodeSchedulingPriority(
 export const MESH_CONVERGE_REFINE_TAG = 'converge=refine';
 export const MESH_CONVERGE_FAST_FORWARD_TAG = 'converge=fast_forward';
 
+/**
+ * Standard mesh resource-pool roles. These are the dashboard-provided defaults for
+ * the role=<x> routing tag (advertised by node policy.providerRoles and matched
+ * through nodeSatisfiesRequiredTags). A mesh is free to declare additional custom
+ * role strings in policy.taskAffinity; the dashboard role dropdown exposes the union
+ * of these four standards plus any config-declared roles. Roles are lowercased
+ * everywhere (the role=<x> tag is lowercased in roleCapabilityTags).
+ */
+export const STANDARD_MESH_ROLES = ['investigator', 'coder', 'validator', 'converger'] as const;
+export type StandardMeshRole = typeof STANDARD_MESH_ROLES[number];
+
+/**
+ * Default taskMode → role mapping (all five task modes). A task enqueued with a
+ * given taskMode auto-routes to a node advertising the mapped role=<x> tag, unless
+ * the mesh overrides the mapping in policy.taskAffinity.byTaskMode. Keyed by the
+ * MeshTaskMode string literals (the canonical union lives in mesh-work-queue.ts;
+ * this map is keyed by string to avoid a types ↔ queue import cycle). Kept in sync
+ * with MeshTaskMode by the exhaustive lookup in resolveTaskAffinityRole.
+ */
+export const DEFAULT_TASKMODE_ROLE_MAP: Readonly<Record<string, StandardMeshRole>> = {
+    live_debug_readonly: 'investigator',
+    code_change: 'coder',
+    launch_app: 'coder',
+    validation: 'validator',
+    convergence: 'converger',
+};
+
+/**
+ * Declarative task_mode → role affinity policy. When set, enqueueTask auto-injects a
+ * `role=<role>` required tag (see resolveTaskAffinityRequiredTags) so the task
+ * hard-filters onto nodes advertising that role — but only when the caller did NOT
+ * already pin the task with an explicit target_node_id or its own required_tags.
+ *
+ * - `enabled`: master switch. Defaults to true so the built-in DEFAULT_TASKMODE_ROLE_MAP
+ *   takes effect even when a mesh declares no taskAffinity block at all. Set false to
+ *   fully disable affinity routing (today's pre-affinity behavior).
+ * - `byTaskMode`: per-taskMode override of the default mapping. A role string here may
+ *   be any of STANDARD_MESH_ROLES or a custom role declared by the operator. An empty
+ *   string disables affinity for that one task mode.
+ * - `customRoles`: extra (non-standard) role strings to surface in the dashboard role
+ *   dropdown. Routing itself does not require a role to be pre-declared here — any role
+ *   referenced in byTaskMode is injected regardless; customRoles only widens the UI list.
+ */
+export interface RepoMeshTaskAffinityPolicy {
+    enabled?: boolean;
+    byTaskMode?: Record<string, string>;
+    customRoles?: string[];
+}
+
+/**
+ * Resolve the affinity role for a task mode against a mesh's taskAffinity policy.
+ * Returns the lowercased role string to inject as `role=<role>`, or null when no
+ * affinity applies (affinity disabled, an explicit empty override, or an unknown mode).
+ *
+ * Precedence: policy.byTaskMode[mode] (operator override) → DEFAULT_TASKMODE_ROLE_MAP[mode].
+ * A blank override string explicitly opts that mode out of affinity routing.
+ */
+export function resolveTaskAffinityRole(
+    taskMode: string | undefined,
+    policy: RepoMeshTaskAffinityPolicy | null | undefined,
+): string | null {
+    if (!taskMode) return null;
+    if (policy?.enabled === false) return null;
+    const override = policy?.byTaskMode && Object.prototype.hasOwnProperty.call(policy.byTaskMode, taskMode)
+        ? policy.byTaskMode[taskMode]
+        : undefined;
+    if (typeof override === 'string') {
+        const trimmed = override.trim().toLowerCase();
+        // An explicit blank override opts this task mode out of affinity routing.
+        return trimmed ? trimmed : null;
+    }
+    const fallback = DEFAULT_TASKMODE_ROLE_MAP[taskMode];
+    return fallback ?? null;
+}
+
+/**
+ * Union of the standard roles plus any operator-declared roles (byTaskMode values +
+ * customRoles), lowercased and deduped, preserving standard-first ordering. Used by
+ * the dashboard role dropdown so operators can pick a standard or a config-declared
+ * custom role. Pure/UI-facing — does not gate routing.
+ */
+export function resolveMeshRoleOptions(policy: RepoMeshTaskAffinityPolicy | null | undefined): string[] {
+    const out: string[] = [...STANDARD_MESH_ROLES];
+    const seen = new Set<string>(out);
+    const add = (raw: unknown) => {
+        if (typeof raw !== 'string') return;
+        const role = raw.trim().toLowerCase();
+        if (!role || seen.has(role)) return;
+        seen.add(role);
+        out.push(role);
+    };
+    if (policy?.byTaskMode) {
+        for (const value of Object.values(policy.byTaskMode)) add(value);
+    }
+    if (Array.isArray(policy?.customRoles)) {
+        for (const value of policy.customRoles) add(value);
+    }
+    return out;
+}
+
 /**
  * Resolve whether the load-balancing scheduler should auto-inject a
  * `converge=refine` required tag onto code_change tasks so they hard-filter onto
@@ -220,6 +320,18 @@ export interface RepoMeshPolicy {
      * Defaults to false: code_change routing is unchanged unless opted in.
      */
     autoConvergeCodeChange?: boolean;
+    /**
+     * Declarative task_mode → role affinity routing. When present (and not disabled),
+     * enqueueTask auto-injects a `role=<role>` required tag for the task's taskMode so
+     * the work hard-filters onto nodes advertising that role. Explicit target_node_id
+     * routing and any caller-supplied required_tags are preserved (auto-injection only
+     * applies when the caller pinned neither). When the mapped role has no advertising
+     * node in the mesh, the task is NOT blocked — the role tag is skipped so the work
+     * falls back to ordinary least_loaded eligibility (soft affinity). Defaults to the
+     * built-in DEFAULT_TASKMODE_ROLE_MAP even when this block is omitted; set
+     * `{ enabled: false }` to fully restore pre-affinity routing.
+     */
+    taskAffinity?: RepoMeshTaskAffinityPolicy;
     /**
      * Whether sessions spawned by mesh/coordinator policy should auto-open as visible
      * dashboard tabs or start hidden. Defaults to 'visible' to preserve existing