@indigoai-us/hq-cli 5.147.0 → 5.149.1

package/dist/lib/lanes/store.js

@@ -13,7 +13,8 @@ import * as path from "node:path";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
-import { HISTORY_CAP, HOST_KINDS, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isLaneState, isQuestionStatus, isSeniorKind, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
+import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isLaneState, isQuestionStatus, isSeniorKind, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
+import { laneStories } from "./stories.js";
 export const LANES_STORE_REL = path.join("workspace", "lanes");
 export const LANE_RECORDS_DIR = "lanes";
 export const QUESTION_RECORDS_DIR = "questions";
@@ -277,6 +278,80 @@ function parseOptionalMeshCompanyField(raw, filePath) {
     requireString(raw.mesh_company.slug, "mesh_company.slug");
     requireString(raw.mesh_company.uid, "mesh_company.uid");
 }
+function legacyLaneStory(raw) {
+    const status = raw.state === "blocked"
+        ? "blocked"
+        : raw.story_status === "review"
+            ? "review"
+            : raw.story_status === "done" || raw.story_complete === true
+                ? "review"
+                : "in_progress";
+    const story = {
+        project_id: requireString(raw.project_id, "project_id"),
+        story_id: requireString(raw.story_id, "story_id"),
+        status,
+        added_at: requireString(raw.created_at, "created_at"),
+        updated_at: requireString(raw.updated_at, "updated_at"),
+    };
+    if (typeof raw.blocked_reason === "string" && raw.blocked_reason.length > 0) {
+        story.blocked_reason = raw.blocked_reason;
+    }
+    return story;
+}
+function parseLaneStories(raw, filePath) {
+    if (raw.stories === undefined) {
+        // v1 records carried one story in the top-level fields. Keep the old
+        // fields authoritative for the migration and give worker-completed work
+        // the review state until a senior explicitly verifies it.
+        raw.stories = [legacyLaneStory(raw)];
+        return;
+    }
+    if (!Array.isArray(raw.stories) || raw.stories.length === 0) {
+        throw new LaneSchemaError("stories must be a non-empty array when present", {
+            path: filePath,
+            field: "stories",
+        });
+    }
+    for (const [index, value] of raw.stories.entries()) {
+        const field = `stories[${index}]`;
+        if (!isPlainObject(value)) {
+            throw new LaneSchemaError(`${field} must be an object`, { path: filePath, field });
+        }
+        requireString(value.project_id, `${field}.project_id`);
+        requireString(value.story_id, `${field}.story_id`);
+        requireString(value.added_at, `${field}.added_at`);
+        requireString(value.updated_at, `${field}.updated_at`);
+        if (typeof value.status !== "string" ||
+            !LANE_STORY_STATUSES.includes(value.status)) {
+            throw new LaneSchemaError(`Unknown story status ${JSON.stringify(value.status)}`, {
+                path: filePath,
+                field: `${field}.status`,
+                value: value.status,
+                accepted: [...LANE_STORY_STATUSES],
+            });
+        }
+        if (value.blocked_reason !== undefined) {
+            requireString(value.blocked_reason, `${field}.blocked_reason`);
+        }
+        if (value.verified_at !== undefined) {
+            requireString(value.verified_at, `${field}.verified_at`);
+        }
+        if (value.verified_by !== undefined) {
+            if (!isPlainObject(value.verified_by)) {
+                throw new LaneSchemaError(`${field}.verified_by must be an object`, {
+                    path: filePath,
+                    field: `${field}.verified_by`,
+                });
+            }
+            if (!isSeniorKind(value.verified_by.kind)) {
+                throw new LaneSchemaError(`Unknown senior kind ${JSON.stringify(value.verified_by.kind)}`, { path: filePath, field: `${field}.verified_by.kind` });
+            }
+            if (value.verified_by.kind !== "user") {
+                requireString(value.verified_by.id, `${field}.verified_by.id`);
+            }
+        }
+    }
+}
 export function parseLaneRecord(raw, filePath) {
     if (!isPlainObject(raw)) {
         throw new LaneSchemaError("Lane record must be a JSON object", {
@@ -302,6 +377,7 @@ export function parseLaneRecord(raw, filePath) {
     if (!isLaneProvider(raw.provider)) {
         throw new LaneSchemaError(`Unknown provider ${JSON.stringify(raw.provider)}`, { path: filePath, value: raw.provider });
     }
+    parseLaneStories(raw, filePath);
     parseOptionalCompanyField(raw, filePath);
     parseOptionalMeshCompanyField(raw, filePath);
     if (!isPlainObject(raw.senior)) {
@@ -472,6 +548,37 @@ function higherVersionRecord(live, others) {
     }
     return best;
 }
+function laneStoryIdentity(story) {
+    return `${story.project_id}\u0000${story.story_id}`;
+}
+function mergeLaneStories(records, base) {
+    const baseStories = laneStories(base);
+    const merged = new Map();
+    const baseOrder = [];
+    for (const story of baseStories) {
+        const key = laneStoryIdentity(story);
+        if (!merged.has(key))
+            baseOrder.push(key);
+        merged.set(key, story);
+    }
+    for (const record of records) {
+        if (record === base)
+            continue;
+        for (const story of laneStories(record)) {
+            const key = laneStoryIdentity(story);
+            const current = merged.get(key);
+            if (!current || story.updated_at > current.updated_at) {
+                merged.set(key, story);
+            }
+        }
+    }
+    const sideOnly = [...merged.keys()]
+        .filter((key) => !baseOrder.includes(key))
+        .sort();
+    return [...baseOrder, ...sideOnly]
+        .map((key) => merged.get(key))
+        .filter((story) => story !== undefined);
+}
 export function mergeLaneRecords(live, sidecars) {
     if (sidecars.length === 0)
         return live;
@@ -486,6 +593,7 @@ export function mergeLaneRecords(live, sidecars) {
                 account_history: unionHistory(all.map((record) => record.account_history ?? []), entryIdentity, base.account_history ?? []),
             }
             : {}),
+        stories: mergeLaneStories(all, base),
     };
 }
 export function mergeQuestionRecords(live, sidecars) {

package/dist/lib/lanes/stories.d.ts

@@ -0,0 +1,17 @@
+import type { LaneRecord, LaneStory } from "./types.js";
+/** Board-facing states for the stories a lane currently carries. */
+export declare const ACTIVE_LANE_STORY_STATUSES: readonly ["in_progress", "blocked", "review"];
+export declare function storyKey(projectId: string, storyId: string): string;
+/**
+ * Read the v1 multi-story field while keeping old one-story records usable.
+ * The returned legacy row is deliberately in-memory until the next normal
+ * lane write, so reading an old record never changes it on disk by itself.
+ */
+export declare function laneStories(lane: LaneRecord): LaneStory[];
+export declare function activeLaneStories(lane: LaneRecord): LaneStory[];
+export declare function laneStory(lane: LaneRecord, projectId: string, storyId: string): LaneStory | undefined;
+export declare function storyWarning(lane: LaneRecord): string | undefined;
+export declare function withCurrentStory(lane: LaneRecord, projectId: string, storyId: string): LaneRecord;
+export declare function withLaneStories(lane: LaneRecord, stories: LaneStory[]): LaneRecord;
+export declare function storyStatusForEnvelope(status: string): "in_progress" | "review";
+//# sourceMappingURL=stories.d.ts.map

package/dist/lib/lanes/stories.js

@@ -0,0 +1,73 @@
+/** Board-facing states for the stories a lane currently carries. */
+export const ACTIVE_LANE_STORY_STATUSES = [
+    "in_progress",
+    "blocked",
+    "review",
+];
+export function storyKey(projectId, storyId) {
+    return `${projectId}\u0000${storyId}`;
+}
+function legacyStatus(lane) {
+    if (lane.state === "blocked")
+        return "blocked";
+    if (lane.story_status === "review")
+        return "review";
+    // A worker envelope was historically allowed to say done. The worker's
+    // terminal result only earns review; senior verification is the sole path
+    // to the durable done state.
+    if (lane.story_status === "done" || lane.story_complete === true) {
+        return "review";
+    }
+    return "in_progress";
+}
+/**
+ * Read the v1 multi-story field while keeping old one-story records usable.
+ * The returned legacy row is deliberately in-memory until the next normal
+ * lane write, so reading an old record never changes it on disk by itself.
+ */
+export function laneStories(lane) {
+    if (Array.isArray(lane.stories) && lane.stories.length > 0) {
+        return lane.stories;
+    }
+    const at = lane.updated_at || lane.created_at;
+    return [
+        {
+            project_id: lane.project_id,
+            story_id: lane.story_id,
+            status: legacyStatus(lane),
+            added_at: lane.created_at,
+            updated_at: at,
+        },
+    ];
+}
+export function activeLaneStories(lane) {
+    return laneStories(lane).filter((story) => ACTIVE_LANE_STORY_STATUSES.includes(story.status));
+}
+export function laneStory(lane, projectId, storyId) {
+    const key = storyKey(projectId, storyId);
+    return laneStories(lane).find((story) => storyKey(story.project_id, story.story_id) === key);
+}
+export function storyWarning(lane) {
+    const count = activeLaneStories(lane).length;
+    if (count <= 1)
+        return undefined;
+    return `Lane ${lane.lane_id} carries ${count} active stories; parallel story work is allowed but discouraged.`;
+}
+export function withCurrentStory(lane, projectId, storyId) {
+    return {
+        ...lane,
+        project_id: projectId,
+        story_id: storyId,
+    };
+}
+export function withLaneStories(lane, stories) {
+    return { ...lane, stories };
+}
+export function storyStatusForEnvelope(status) {
+    // A worker's `done` envelope is reviewable work. Durable `done` is reserved
+    // for the senior verification command.
+    if (status === "review")
+        return "review";
+    return "in_progress";
+}
+//# sourceMappingURL=stories.js.map

package/dist/lib/lanes/types.d.ts

@@ -176,6 +176,9 @@ export declare const ENVELOPE_DECISIONS: readonly ["done", "ask", "blocked"];
 export type EnvelopeDecision = (typeof ENVELOPE_DECISIONS)[number];
 export declare const STORY_STATUSES: readonly ["queued", "in_progress", "review", "done"];
 export type StoryStatus = (typeof STORY_STATUSES)[number];
+/** Durable Board status for a story carried by a lane. */
+export declare const LANE_STORY_STATUSES: readonly ["in_progress", "blocked", "review", "done"];
+export type LaneStoryStatus = (typeof LANE_STORY_STATUSES)[number];
 /**
  * `expired` is accepted on read for records that already carry it. Spec §9
  * ageing advances hop with `unanswered_timeout` and never expires a question,
@@ -237,6 +240,16 @@ export interface LastEnvelopeRef {
     decision: EnvelopeDecision;
     at: string;
 }
+export interface LaneStory {
+    project_id: string;
+    story_id: string;
+    status: LaneStoryStatus;
+    added_at: string;
+    updated_at: string;
+    blocked_reason?: string;
+    verified_at?: string;
+    verified_by?: SeniorRef;
+}
 export interface LaneRecord {
     schema_version: typeof LANE_SCHEMA_VERSION | string;
     lane_id: string;
@@ -246,6 +259,11 @@ export interface LaneRecord {
     mesh_company?: LaneCompanyRef;
     project_id: string;
     story_id: string;
+    /**
+     * Stories currently carried by this lane. Old records omit this field and
+     * are migrated in memory from project_id/story_id on read.
+     */
+    stories?: LaneStory[];
     thread_id?: string;
     depth: number;
     senior: SeniorRef;
@@ -367,6 +385,8 @@ export interface LaneRecord {
      */
     provider_session_id?: string;
     provider_session_id_absent?: string;
+    /** Provider home used by the most recently spawned run, for transcript recovery. */
+    provider_home_at_spawn?: string;
     /** Set at spawn when this run continued a recorded session instead of starting fresh. */
     last_resume?: LaneResumeRecord;
     /** Cache counters from the last exited run's result. Nothing else from the payload. */

package/dist/lib/lanes/types.js

@@ -105,6 +105,13 @@ export const STORY_STATUSES = [
     "review",
     "done",
 ];
+/** Durable Board status for a story carried by a lane. */
+export const LANE_STORY_STATUSES = [
+    "in_progress",
+    "blocked",
+    "review",
+    "done",
+];
 /**
  * `expired` is accepted on read for records that already carry it. Spec §9
  * ageing advances hop with `unanswered_timeout` and never expires a question,
@@ -195,7 +202,7 @@ export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spaw
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
     schema_version: ["creator"], lane_id: ["creator"], company: ["creator"],
-    project_id: ["command"], story_id: ["command"], thread_id: ["creator", "command"], mesh_company: ["creator"],
+    project_id: ["command"], story_id: ["command"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
@@ -208,7 +215,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher"], provider_session_id_absent: ["watcher"], last_resume: ["spawn"], last_run_usage: ["watcher"], envelope_repair: ["watcher", "reconcile"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], last_run_usage: ["watcher"], envelope_repair: ["watcher", "reconcile"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);

package/dist/lib/lanes/watcher.js

@@ -36,6 +36,7 @@ import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { raiseEnvelopeQuestions } from "./questions.js";
 import { isTerminalLaneState, parseLaneEnvelope, } from "./types.js";
+import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { readLane, retryUpdateLane } from "./store.js";
 import { readWorkerRunResult } from "./delivery.js";
 import { applyDefaultQuotaHold, quotaSignalFromFields, readQuotaSignal, recordAccountQuota, } from "./quota.js";
@@ -243,8 +244,15 @@ function runResultFields(hqRoot, lane) {
         fields.provider_session_id_absent = undefined;
     }
     else {
-        fields.provider_session_id = undefined;
-        fields.provider_session_id_absent = result.session_id_absent ?? "no_result_json";
+        // A resumed provider may exit before it emits a new result object. Keep
+        // the prior session id so the lane remains resumable; only describe an
+        // absent id when no earlier run recorded one.
+        if (lane.provider_session_id || lane.last_resume?.session_id) {
+            fields.provider_session_id_absent = undefined;
+        }
+        else {
+            fields.provider_session_id_absent = result.session_id_absent ?? "no_result_json";
+        }
     }
     return fields;
 }
@@ -337,17 +345,36 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
         if (opts.providerRejection) {
             next.terminal_details = providerRejectionDetails(opts.providerRejection, current);
         }
-        if (opts.envelope && opts.envelopeRef) {
+        const envelope = opts.envelope;
+        if (envelope && opts.envelopeRef) {
             next.last_envelope = {
                 ref: opts.envelopeRef,
-                decision: opts.envelope.decision,
+                decision: envelope.decision,
                 at,
             };
-            next.story_status = opts.envelope.story_status;
-            if (opts.envelope.story_complete !== undefined) {
-                next.story_complete = opts.envelope.story_complete;
-                next.story_complete_reason = opts.envelope.story_complete_reason;
+            next.story_status = envelope.story_status;
+            if (envelope.story_complete !== undefined) {
+                next.story_complete = envelope.story_complete;
+                next.story_complete_reason = envelope.story_complete_reason;
             }
+            const currentProject = current.project_id;
+            const currentStory = current.story_id;
+            const storyStatus = envelope.decision === "blocked"
+                ? "blocked"
+                : envelope.decision === "done"
+                    ? "review"
+                    : storyStatusForEnvelope(envelope.story_status);
+            const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory
+                ? {
+                    ...story,
+                    status: storyStatus,
+                    updated_at: at,
+                    ...(envelope.decision === "blocked"
+                        ? { blocked_reason: envelope.blocked_reason ?? "" }
+                        : { blocked_reason: undefined }),
+                }
+                : story);
+            next.stories = updatedStories;
         }
         return next;
     });
@@ -550,9 +577,42 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
     const progressFiles = [...logFiles, ...activityFiles];
     // Mesh seam (spec §8). Non-interactive: nobody is at this process's tty.
     const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+    const meshRequestTimeoutMs = deps.meshRequestTimeoutMs ?? 10_000;
+    const initialLane = readLaneSoft(hqRoot, laneId);
+    if (mesh && initialLane) {
+        // Explicit mesh attribution is the repair signal. Ordinary company lanes
+        // already receive their thread during create; legacy records without one
+        // stay quiet until an operator or the owning flow repairs them.
+        const company = initialLane.mesh_company;
+        if (company && !initialLane.thread_id) {
+            let timer;
+            try {
+                const threadId = await Promise.race([
+                    mesh.ensureProjectThread(company, initialLane.project_id),
+                    new Promise((_resolve, reject) => {
+                        timer = setTimeout(() => reject(new Error(`mesh thread ensure timed out after ${meshRequestTimeoutMs}ms`)), meshRequestTimeoutMs);
+                    }),
+                ]);
+                retryUpdateLane(hqRoot, laneId, "spawn", (current) => current.thread_id ? current : { ...current, thread_id: threadId });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`hq lanes watcher: mesh thread ensure failed for ${laneId}: ${message}\n`);
+                writeWatcherDecision(outPath, {
+                    event: "mesh_event_failed",
+                    at: new Date(now()).toISOString(),
+                    mesh_event: "ensure_project_thread",
+                    error: message,
+                }, outMax);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
+    }
     const progressIntervalMs = deps.progressEventMinIntervalMs ?? readProgressIntervalMs(hqRoot, readLaneSoft(hqRoot, laneId));
     const spawnRepair = deps.spawnRepair ?? spawnEnvelopeRepair;
-    const meshRequestTimeoutMs = deps.meshRequestTimeoutMs ?? 10_000;
     let lastSignalMs = now();
     let lastSeenMtime = 0;
     let lastAlive = null;

package/dist/lib/mesh/live/daemon/doctor.d.ts

@@ -57,6 +57,15 @@ export interface DaemonDoctorReport {
     deviceDefaultAuthorizationDenials: number;
     /** True when the pack-era listen unit is still on disk. */
     legacyListenerInstalled: boolean;
+    /** One line when the running daemon's recorded CLI is not this CLI. */
+    cliMismatchLine?: string;
+    /** Every `hq` executable found on PATH, with the package version behind it. */
+    hqOnPath: Array<{
+        path: string;
+        version: string | null;
+    }>;
+    /** True when PATH lists more than one hq. */
+    multipleHqOnPath: boolean;
 }
 export interface DaemonDoctorDeps {
     home?: string;
@@ -70,7 +79,25 @@ export interface DaemonDoctorDeps {
     /** Override the legacy-listen probe (tests). */
     legacyListenerInstalled?: boolean;
     platform?: LegacyListenPlatform;
+    /** This process's CLI version. Defaults to the package version. */
+    cliVersion?: string;
+    /** This process's CLI entry. Defaults to realpath of argv[1]. */
+    cliEntry?: string;
+    /** PATH used to list hq binaries. Defaults to the process PATH. */
+    pathEnv?: string;
 }
+/** Every hq named on PATH. Does not pick one; the caller prints all of them. */
+export declare function listHqBinariesOnPath(env?: NodeJS.ProcessEnv): Array<{
+    path: string;
+    version: string | null;
+}>;
+export declare function formatCliMismatchLine(input: {
+    recordedVersion?: string | null;
+    recordedEntry?: string | null;
+    currentVersion: string;
+    currentEntry: string;
+}): string | undefined;
+export declare function formatCliIdentityLines(report: Pick<DaemonDoctorReport, "cliMismatchLine" | "hqOnPath" | "multipleHqOnPath">): string[];
 export declare function collectDaemonDoctor(deps?: DaemonDoctorDeps): DaemonDoctorReport;
 export declare function formatDaemonDoctor(report: DaemonDoctorReport): string[];
 //# sourceMappingURL=doctor.d.ts.map

package/dist/lib/mesh/live/daemon/doctor.js

@@ -19,6 +19,9 @@ import { hasCurrentAcknowledgedRegistration, readHeldSessions, refWithLocalCompa
 import { readDaemonConfig } from "./config.js";
 import { pidLockStatus, readPidLock } from "./pid-lock.js";
 import { readDaemonState } from "./state.js";
+import { CLI_VERSION } from "../../../../cli-version.js";
+import { resolveRunningCliEntry } from "./install.js";
+import { readInstalledCliVersion } from "./version-drift.js";
 import { LEGACY_LISTENER_DOCTOR_LINE, legacyListenInstalled, } from "./legacy-listen.js";
 export const UNHEALTHY_SPOOL_AGE_MS = 60_000;
 function oldestJsonlAgeMs(filePath, nowMs) {
@@ -55,6 +58,65 @@ function oldestJsonlAgeMs(filePath, nowMs) {
         return undefined;
     }
 }
+function samePath(a, b) {
+    const left = tryRealpath(a);
+    const right = tryRealpath(b);
+    return left === right;
+}
+function tryRealpath(value) {
+    try {
+        return fs.realpathSync(value);
+    }
+    catch {
+        return path.resolve(value);
+    }
+}
+/** Every hq named on PATH. Does not pick one; the caller prints all of them. */
+export function listHqBinariesOnPath(env = process.env) {
+    const found = [];
+    const pathEnv = env.PATH ?? "";
+    const names = process.platform === "win32" ? ["hq.cmd", "hq.exe", "hq"] : ["hq"];
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            const candidate = path.join(dir, name);
+            if (!fs.existsSync(candidate))
+                continue;
+            found.push({
+                path: tryRealpath(candidate),
+                version: readInstalledCliVersion(candidate),
+            });
+        }
+    }
+    return found;
+}
+export function formatCliMismatchLine(input) {
+    const recordedVersion = input.recordedVersion?.trim() || "";
+    const recordedEntry = input.recordedEntry?.trim() || "";
+    const versionMatches = recordedVersion !== "" && recordedVersion === input.currentVersion;
+    const entryMatches = recordedEntry !== "" &&
+        input.currentEntry !== "" &&
+        samePath(recordedEntry, input.currentEntry);
+    if (versionMatches && entryMatches)
+        return undefined;
+    const recordedLabel = recordedVersion || "(none)";
+    const recordedAt = recordedEntry || "(none)";
+    const currentAt = input.currentEntry || "(none)";
+    return (`daemon hq ${recordedLabel} at ${recordedAt} does not match this CLI ` +
+        `${input.currentVersion} at ${currentAt}. Run hq mesh daemon install to repoint it.`);
+}
+export function formatCliIdentityLines(report) {
+    const lines = [];
+    if (report.cliMismatchLine)
+        lines.push(report.cliMismatchLine);
+    for (const hit of report.hqOnPath) {
+        lines.push(`hq on PATH: ${hit.path} (${hit.version ?? "unknown"})`);
+    }
+    if (report.multipleHqOnPath)
+        lines.push("more than one hq is on PATH");
+    return lines;
+}
 function countDeviceDefaultAttribution(root) {
     try {
         return fs.readdirSync(path.join(root, "sessions")).filter((entry) => {
@@ -93,6 +155,24 @@ export function collectDaemonDoctor(deps = {}) {
     const record = readPidLock(lockPath);
     const running = lock === "held";
     const state = readDaemonState(dir);
+    let currentEntry = deps.cliEntry ?? "";
+    if (!deps.cliEntry) {
+        try {
+            currentEntry = resolveRunningCliEntry();
+        }
+        catch {
+            currentEntry = "";
+        }
+    }
+    const currentVersion = deps.cliVersion ?? CLI_VERSION;
+    const pathEnv = deps.pathEnv ?? env.PATH ?? "";
+    const hqOnPath = listHqBinariesOnPath({ ...env, PATH: pathEnv });
+    const cliMismatchLine = formatCliMismatchLine({
+        recordedVersion: state?.cliVersion,
+        recordedEntry: state?.cliEntry,
+        currentVersion,
+        currentEntry,
+    });
     const spoolPath = workMeshSpoolPath(meshRoot);
     const heldPath = workMeshHeldPath(meshRoot);
     const deadPath = workMeshDeadLetterPath(meshRoot);
@@ -203,6 +283,9 @@ export function collectDaemonDoctor(deps = {}) {
             : undefined,
         deviceDefaultAuthorizationDenials,
         legacyListenerInstalled: legacyListener,
+        cliMismatchLine,
+        hqOnPath,
+        multipleHqOnPath: hqOnPath.length > 1,
     };
 }
 export function formatDaemonDoctor(report) {
@@ -253,6 +336,7 @@ export function formatDaemonDoctor(report) {
     else {
         lines.push(`health: ok`);
     }
+    lines.push(...formatCliIdentityLines(report));
     return lines;
 }
 //# sourceMappingURL=doctor.js.map

package/dist/lib/mesh/live/daemon/index.d.ts

@@ -12,12 +12,12 @@ export type { DaemonStateFile, PresenceRefusalState } from "./state.js";
 export { appendDaemonLog, daemonLogLine, ensureDaemonLog, resolveDaemonAssetDir, rotateDaemonLogIfNeeded, } from "./log.js";
 export { BOARD_REFRESH_INTERVAL_MS, createVaultBoardReader, formatBoardMarkdown, refreshBoundSessionBoards, writeBoardMarkdown, } from "./board-refresh.js";
 export type { BoardReader, BoardRefreshDeps, BoardStorySnapshot } from "./board-refresh.js";
-export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonService, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveHqBinary, resolveNodeBinary, parseSchtasksLastResult, parseWindowsTaskHqRoot, readRecordedWindowsHqRoot, schtasksLastResultFailed, uninstallDaemonService, windowsLaunchMode, windowsLogonNotice, } from "./install.js";
-export type { DaemonInstallPlatform, InstallPaths, InstallResult, } from "./install.js";
+export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonIfStale, installDaemonService, isNewerCliVersion, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveAbsoluteNodeBinary, resolveHqBinary, resolveNodeBinary, resolveRunningCliEntry, parseSchtasksLastResult, parseWindowsTaskHqRoot, readRecordedWindowsHqRoot, schtasksLastResultFailed, uninstallDaemonService, windowsLaunchMode, windowsLogonNotice, } from "./install.js";
+export type { DaemonInstallPlatform, InstallIfStaleResult, InstallPaths, InstallResult, } from "./install.js";
 export { daemonConfigPath, findAncestorHqRoot, isInstallableHqRoot, readDaemonConfig, registerTrustedHqRoot, resolveInstallHqRoot, verifyHqRoot, } from "./config.js";
 export type { InstallHqRootResolution } from "./config.js";
 export type { DaemonConfig } from "./config.js";
-export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatDaemonDoctor, } from "./doctor.js";
+export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatCliIdentityLines, formatCliMismatchLine, formatDaemonDoctor, listHqBinariesOnPath, } from "./doctor.js";
 export type { DaemonDoctorDeps, DaemonDoctorReport } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, DAEMON_VERSION_DRIFT_EXIT_CODE, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";

package/dist/lib/mesh/live/daemon/index.js

@@ -6,9 +6,9 @@ export { CLOSE_LOG_ALWAYS_COUNT, CLOSE_LOG_INTERVAL_MS, CONNECT_STABLE_GRACE_MS,
 export { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
 export { appendDaemonLog, daemonLogLine, ensureDaemonLog, resolveDaemonAssetDir, rotateDaemonLogIfNeeded, } from "./log.js";
 export { BOARD_REFRESH_INTERVAL_MS, createVaultBoardReader, formatBoardMarkdown, refreshBoundSessionBoards, writeBoardMarkdown, } from "./board-refresh.js";
-export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonService, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveHqBinary, resolveNodeBinary, parseSchtasksLastResult, parseWindowsTaskHqRoot, readRecordedWindowsHqRoot, schtasksLastResultFailed, uninstallDaemonService, windowsLaunchMode, windowsLogonNotice, } from "./install.js";
+export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonIfStale, installDaemonService, isNewerCliVersion, readAssetTemplate, restartDaemonServiceIfInstalled, renderLaunchdPlist, renderSystemdSystemUnit, renderSystemdUserUnit, resolveAbsoluteNodeBinary, resolveHqBinary, resolveNodeBinary, resolveRunningCliEntry, parseSchtasksLastResult, parseWindowsTaskHqRoot, readRecordedWindowsHqRoot, schtasksLastResultFailed, uninstallDaemonService, windowsLaunchMode, windowsLogonNotice, } from "./install.js";
 export { daemonConfigPath, findAncestorHqRoot, isInstallableHqRoot, readDaemonConfig, registerTrustedHqRoot, resolveInstallHqRoot, verifyHqRoot, } from "./config.js";
-export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatDaemonDoctor, } from "./doctor.js";
+export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatCliIdentityLines, formatCliMismatchLine, formatDaemonDoctor, listHqBinariesOnPath, } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, DAEMON_VERSION_DRIFT_EXIT_CODE, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";
 export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_ENTRY_CAP, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";