@indigoai-us/hq-cli 5.268.0 → 5.270.0

package/dist/lib/lanes/reviews.js

@@ -0,0 +1,395 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { assertNoSecretText } from "./text-scan.js";
+import { LanesError } from "./errors.js";
+export const LANE_REVIEWS_REL = path.join("workspace", "lanes", "reviews");
+export const LANE_REVIEW_SCHEMA_VERSION = "hq-lanes-review.v1";
+export const LANE_REVIEW_HISTORY_CAP = 50;
+const REVIEW_LOCK_WAIT_MS = 5_000;
+const REVIEW_LOCK_STALE_MS = 5 * 60_000;
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+export function canonicalLaneReviewRepo(raw) {
+    const value = raw.trim();
+    const parts = value.split("/");
+    if (parts.length !== 2) {
+        return fail("review_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    const [owner, repository] = parts;
+    if (!owner || !repository ||
+        !/^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(owner) ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repository) ||
+        owner === "." || owner === ".." || repository === "." || repository === "..") {
+        return fail("review_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    return `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+}
+export function parseLaneReviewPr(raw) {
+    const text = String(raw).trim();
+    if (!/^\d+$/.test(text)) {
+        return fail("review_pr_invalid", "Pull request number must be a positive integer", { field: "pr" });
+    }
+    const pr = Number(text);
+    if (!Number.isSafeInteger(pr) || pr <= 0) {
+        return fail("review_pr_invalid", "Pull request number must be a positive integer", { field: "pr" });
+    }
+    return pr;
+}
+function parseHeadSha(value, field = "head") {
+    const head = value.trim();
+    if (!/^[a-fA-F0-9]{40}$/.test(head)) {
+        return fail("review_head_invalid", "Head must be a 40-character hexadecimal commit SHA", { field });
+    }
+    return head.toLowerCase();
+}
+function reviewPath(hqRoot, repo, pr) {
+    const [owner, name] = canonicalLaneReviewRepo(repo).split("/");
+    return path.join(hqRoot, LANE_REVIEWS_REL, `${owner}__${name}`, `${parseLaneReviewPr(pr)}.json`);
+}
+export function laneReviewPath(hqRoot, repo, pr) {
+    return reviewPath(hqRoot, repo, pr);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isTimestamp(value) {
+    if (typeof value !== "string")
+        return false;
+    const date = Date.parse(value);
+    return Number.isFinite(date) && new Date(date).toISOString() === value;
+}
+function isNullableText(value) {
+    return value === null || (typeof value === "string" && value.length > 0);
+}
+function storedTextIsSafe(field, value, file) {
+    try {
+        assertNoSecretText(field, value);
+    }
+    catch {
+        fail("review_record_invalid", "Review record contains unsafe text", { path: file, field });
+    }
+}
+function parseHistoryEntry(value, file) {
+    if (!isObject(value) || typeof value.repo !== "string" ||
+        !Number.isSafeInteger(value.pr) || value.pr <= 0 ||
+        typeof value.head_sha !== "string" || !/^[a-f0-9]{40}$/.test(value.head_sha) ||
+        !isNullableText(value.reviewer_lane) || !isNullableText(value.reviewer_session) ||
+        !isNullableText(value.worker_lane) || !isNullableText(value.note) ||
+        !isTimestamp(value.recorded_at)) {
+        return fail("review_record_invalid", "Review history entry has invalid fields", { path: file });
+    }
+    let repo;
+    try {
+        repo = canonicalLaneReviewRepo(value.repo);
+    }
+    catch {
+        return fail("review_record_invalid", "Review history entry has an invalid repository", { path: file });
+    }
+    if (repo !== value.repo) {
+        return fail("review_record_invalid", "Review history repository is not canonical", { path: file });
+    }
+    for (const field of ["reviewer_lane", "reviewer_session", "worker_lane", "note"]) {
+        const text = value[field];
+        if (typeof text === "string")
+            storedTextIsSafe(`review.${field}`, text, file);
+    }
+    return value;
+}
+function parseReview(value, file) {
+    if (!isObject(value) || value.schema_version !== LANE_REVIEW_SCHEMA_VERSION || !Array.isArray(value.history)) {
+        return fail("review_record_invalid", "Review record has invalid fields", { path: file });
+    }
+    const current = parseHistoryEntry(value, file);
+    if (value.history.length > LANE_REVIEW_HISTORY_CAP) {
+        return fail("review_record_invalid", "Review record history exceeds its cap", { path: file });
+    }
+    const history = value.history.map((entry) => parseHistoryEntry(entry, file));
+    return { ...current, schema_version: LANE_REVIEW_SCHEMA_VERSION, history };
+}
+export function readLaneReview(hqRoot, repo, pr) {
+    const canonicalRepo = canonicalLaneReviewRepo(repo);
+    const canonicalPr = parseLaneReviewPr(pr);
+    const file = reviewPath(hqRoot, canonicalRepo, canonicalPr);
+    let contents;
+    try {
+        contents = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        return fail("review_record_unreadable", "Review record could not be read", { path: file });
+    }
+    let value;
+    try {
+        value = JSON.parse(contents);
+    }
+    catch {
+        return fail("review_record_invalid", "Review record is not valid JSON", { path: file });
+    }
+    const review = parseReview(value, file);
+    if (review.repo !== canonicalRepo || review.pr !== canonicalPr || reviewPath(hqRoot, review.repo, review.pr) !== file) {
+        return fail("review_record_invalid", "Review record identity does not match its path", { path: file });
+    }
+    return review;
+}
+export function listLaneReviews(hqRoot, reviewerLane) {
+    const directory = path.join(hqRoot, LANE_REVIEWS_REL);
+    let repoDirectories;
+    try {
+        repoDirectories = fs.readdirSync(directory).sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { reviews: [], skipped: 0 };
+        return { reviews: [], skipped: 1 };
+    }
+    const reviews = [];
+    let skipped = 0;
+    for (const repoDirectory of repoDirectories) {
+        const match = /^([a-z0-9-]+)__([a-z0-9._-]+)$/.exec(repoDirectory);
+        if (!match || repoDirectory.startsWith(".")) {
+            skipped += 1;
+            continue;
+        }
+        const repoPath = path.join(directory, repoDirectory);
+        try {
+            const stat = fs.lstatSync(repoPath);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                skipped += 1;
+                continue;
+            }
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        const repo = `${match[1]}/${match[2]}`;
+        let names;
+        try {
+            names = fs.readdirSync(repoPath).sort();
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        for (const name of names) {
+            if (/^\d+\.json\.lock$/.test(name) || /^\d+\.json\.\d+\.[a-f0-9]{12}\.tmp$/.test(name))
+                continue;
+            if (name.startsWith(".") || !/^\d+\.json$/.test(name)) {
+                skipped += 1;
+                continue;
+            }
+            const file = path.join(repoPath, name);
+            try {
+                const stat = fs.lstatSync(file);
+                if (!stat.isFile() || stat.isSymbolicLink()) {
+                    skipped += 1;
+                    continue;
+                }
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            let pr;
+            try {
+                pr = parseLaneReviewPr(name.slice(0, -5));
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            let review;
+            try {
+                review = readLaneReview(hqRoot, repo, pr);
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            if (!review) {
+                skipped += 1;
+                continue;
+            }
+            if (reviewerLane === undefined || review.reviewer_lane === reviewerLane)
+                reviews.push(review);
+        }
+    }
+    return {
+        reviews: reviews.sort((left, right) => right.recorded_at.localeCompare(left.recorded_at) ||
+            left.repo.localeCompare(right.repo) || left.pr - right.pr),
+        skipped,
+    };
+}
+export async function recordLaneReview(hqRoot, input) {
+    const repo = canonicalLaneReviewRepo(input.repo);
+    const pr = parseLaneReviewPr(input.pr);
+    const head_sha = parseHeadSha(input.headSha);
+    const reviewer_lane = input.reviewerLane?.trim() || null;
+    const reviewer_session = input.reviewerSession?.trim() || null;
+    const worker_lane = input.workerLane?.trim() || null;
+    const note = input.note?.trim() || null;
+    if (worker_lane && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,200}$/.test(worker_lane)) {
+        return fail("review_worker_invalid", "Worker lane id has an invalid format", { field: "worker" });
+    }
+    if (reviewer_lane)
+        assertNoSecretText("reviewer_lane", reviewer_lane);
+    if (reviewer_session)
+        assertNoSecretText("reviewer_session", reviewer_session);
+    if (note)
+        assertNoSecretText("note", note);
+    if (worker_lane)
+        assertNoSecretText("worker", worker_lane);
+    const file = reviewPath(hqRoot, repo, pr);
+    return withReviewRecordLock(file, async () => {
+        const previous = readLaneReview(hqRoot, repo, pr);
+        const entry = {
+            repo,
+            pr,
+            head_sha,
+            reviewer_lane,
+            reviewer_session,
+            worker_lane,
+            note,
+            recorded_at: input.recordedAt.toISOString(),
+        };
+        const review = {
+            ...entry,
+            schema_version: LANE_REVIEW_SCHEMA_VERSION,
+            history: [...(previous?.history ?? []), ...(previous ? [currentHistoryEntry(previous)] : [])]
+                .slice(-LANE_REVIEW_HISTORY_CAP),
+        };
+        writeAtomic(file, review);
+        return review;
+    });
+}
+function reviewLockOwnerAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+function removeStaleReviewLock(lockPath) {
+    let first;
+    try {
+        first = fs.lstatSync(lockPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (Date.now() - first.mtimeMs < REVIEW_LOCK_STALE_MS)
+        return false;
+    let pid;
+    try {
+        pid = Number(fs.readFileSync(lockPath, "utf8").split("\n", 1)[0]);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (!Number.isSafeInteger(pid) || pid <= 0 || reviewLockOwnerAlive(pid))
+        return false;
+    let second;
+    try {
+        second = fs.lstatSync(lockPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (second.dev !== first.dev || second.ino !== first.ino || second.mtimeMs !== first.mtimeMs)
+        return false;
+    try {
+        fs.unlinkSync(lockPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+}
+async function withReviewRecordLock(file, action) {
+    const lockPath = `${file}.lock`;
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const started = Date.now();
+    let fd;
+    while (fd === undefined) {
+        try {
+            fd = fs.openSync(lockPath, "wx", 0o600);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (Date.now() - started >= REVIEW_LOCK_WAIT_MS) {
+                return fail("review_record_write_busy", "This review record is being updated; retry the command", { path: file });
+            }
+            if (!removeStaleReviewLock(lockPath))
+                await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    let ownedStat;
+    try {
+        ownedStat = fs.fstatSync(fd);
+        fs.writeSync(fd, `${process.pid}\n${Date.now()}\n`);
+        return await action();
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch (error) {
+            process.stderr.write(`hq lanes review: lock close failed for ${lockPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        if (ownedStat) {
+            try {
+                const current = fs.lstatSync(lockPath);
+                if (current.dev === ownedStat.dev && current.ino === ownedStat.ino)
+                    fs.unlinkSync(lockPath);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    process.stderr.write(`hq lanes review: lock cleanup failed for ${lockPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+        }
+    }
+}
+function currentHistoryEntry(review) {
+    const { repo, pr, head_sha, reviewer_lane, reviewer_session, worker_lane, note, recorded_at } = review;
+    return { repo, pr, head_sha, reviewer_lane, reviewer_session, worker_lane, note, recorded_at };
+}
+function writeAtomic(file, review) {
+    const temporary = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(review, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        fs.renameSync(temporary, file);
+        fs.chmodSync(file, 0o600);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch (cleanupError) {
+            throw new LanesError("review_record_write_failed", "Review record could not be written and temporary cleanup failed", {
+                path: file,
+                error: error instanceof Error ? error.name : "UnknownError",
+                cleanup_error: cleanupError instanceof Error ? cleanupError.name : "UnknownError",
+            });
+        }
+        throw new LanesError("review_record_write_failed", "Review record could not be written", {
+            path: file,
+            error: error instanceof Error ? error.name : "UnknownError",
+        });
+    }
+}
+//# sourceMappingURL=reviews.js.map

package/dist/lib/lanes/watcher.js

@@ -48,6 +48,7 @@ import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, laneStoryStatusSuppressionKey, progressEventDue, } from "./mesh-events.js";
 import { envelopeQuestionId } from "./questions.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
 import { krFreshnessFingerprint, resolveKrFreshnessForLane, } from "./kr-freshness.js";
 import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
@@ -647,11 +648,12 @@ async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, l
     const readFlag = deps.readManagerStatusGateFlag ?? readLanesRegistryFlag;
     let enabled = false;
     try {
-        const company = lane.company ?? lane.mesh_company ?? undefined;
+        const resolution = resolveLaneCompany(hqRoot, lane);
+        const company = resolution.company ?? undefined;
         enabled = await readFlag(MANAGER_STATUS_GATE_FLAG, {
             company,
             ...(company ? {
-                companyUidSource: lane.company ? "lane.company.uid" : "lane.mesh_company.uid",
+                companyUidSource: laneCompanyUidSource(resolution.source),
             } : {}),
         });
     }

package/dist/lib/plan-limit-nag.js

@@ -37,7 +37,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { resolveProcessFlagCompanyContext } from "./flag-registry.js";
-import { isPlanLimitUpgradeFallbackEnabled, planLimitUpgradeFallbackUrl, selectPlanLimitUpgradeUrl, } from "./billing/plan-limit-upgrade-url.js";
+import { planLimitUpgradeFallbackUrl, selectPlanLimitUpgradeUrl, } from "./billing/plan-limit-upgrade-url.js";
 export const PLAN_LIMIT_UPGRADE_URL = "https://hq.computer/billing/upgrade";
 /**
  * Cadence of the over-limit per-turn line (US-036). Was once a day; the nag
@@ -230,9 +230,7 @@ export function recordPlanLimitStatus(body, opts = {}) {
                 : null;
             const topLevelUpgradeUrl = parseUpgradeUrl(bodyRecord?.upgradeUrl);
             const nestedUpgradeUrl = parseNestedUpgradeUrl(body);
-            const companySlug = isPlanLimitUpgradeFallbackEnabled()
-                ? resolveProcessFlagCompanyContext().companySlug
-                : undefined;
+            const companySlug = resolveProcessFlagCompanyContext().companySlug;
             resolvedUpgradeUrl = selectPlanLimitUpgradeUrl(companySlug, {
                 topLevelUrl: topLevelUpgradeUrl,
                 nestedUrl: nestedUpgradeUrl,

package/dist/utils/feedback-logs.d.ts

@@ -13,8 +13,9 @@
  *     (`hq-sync.log.1`, `.2`, `.3`) are eligible too — just after a rotation
  *     the active file is nearly empty and the history lives in `.1`.
  *     `logs/mcp-registry.log` is the CLI's own append-only MCP audit trail.
- *     Any future `*.log`/`*.jsonl` dropped into `~/.hq/logs/` is picked up
- *     automatically.
+ *     The daemon runner's `daemon/logs/sync.log` and its three rotations are
+ *     eligible too. When both sync families exist, only the newer family is
+ *     attached.
  *
  *   - STATE SNAPSHOTS (`state`) — small JSON files that describe where sync
  *     and client health currently stand: the in-flight sync phase and conflict
@@ -36,8 +37,9 @@
  *
  *   1. ALLOWLIST, NOT A SCAN. `~/.hq` also holds `cognito-tokens.json`,
  *      `deploy-passwords.json`, and `secrets-cache/`. Only `*.log` files
- *      directly inside `~/.hq/logs/` plus the two known root-level boot logs
- *      are ever eligible. A recursive walk over `~/.hq` is a credential leak
+ *      directly inside `~/.hq/logs/`, the exact daemon sync-log generations
+ *      under the configured daemon root, and the two known root-level boot
+ *      logs are eligible. A recursive walk over `~/.hq` is a credential leak
  *      and must never be introduced here.
  *
  *   2. NO SYMLINKS. Eligibility is decided with `lstat`, and a candidate must
@@ -235,12 +237,13 @@ export declare function feedbackLogsEnabled(env?: NodeJS.ProcessEnv): boolean;
  * Enumerate eligible log files under `hqDir`.
  *
  * Eligibility is the allowlist described in the module header: `*.log` files
- * directly inside `hqDir/logs/`, plus {@link FEEDBACK_ROOT_LOG_FILENAMES} at
- * the root. Every candidate must be a REGULAR file by `lstat` — directories
- * and, critically, symlinks are rejected. Returned newest-modified first so
- * the most relevant log is offered the budget before older ones.
+ * directly inside `hqDir/logs/`, the exact daemon sync-log generations, plus
+ * {@link FEEDBACK_ROOT_LOG_FILENAMES} at the root. Every candidate must be a
+ * REGULAR file by `lstat` — directories and, critically, symlinks are rejected.
+ * Returned newest-modified first so the most relevant log is offered budget
+ * before older ones.
  */
-export declare function discoverLogFiles(hqDir: string): LogCandidate[];
+export declare function discoverLogFiles(hqDir: string, env?: NodeJS.ProcessEnv): LogCandidate[];
 /**
  * Read the last `maxBytes` of a file.
  *
@@ -314,6 +317,8 @@ export interface CollectFeedbackLogsOptions {
     hqDir?: string;
     /** Override the home directory used to derive `~/.hq` (tests). */
     homeDir?: string;
+    /** Override process environment for configured log paths (tests). */
+    env?: NodeJS.ProcessEnv;
 }
 /**
  * Collect redacted `~/.hq` evidence within `budgetBytes`.

package/dist/utils/feedback-logs.js

@@ -13,8 +13,9 @@
  *     (`hq-sync.log.1`, `.2`, `.3`) are eligible too — just after a rotation
  *     the active file is nearly empty and the history lives in `.1`.
  *     `logs/mcp-registry.log` is the CLI's own append-only MCP audit trail.
- *     Any future `*.log`/`*.jsonl` dropped into `~/.hq/logs/` is picked up
- *     automatically.
+ *     The daemon runner's `daemon/logs/sync.log` and its three rotations are
+ *     eligible too. When both sync families exist, only the newer family is
+ *     attached.
  *
  *   - STATE SNAPSHOTS (`state`) — small JSON files that describe where sync
  *     and client health currently stand: the in-flight sync phase and conflict
@@ -36,8 +37,9 @@
  *
  *   1. ALLOWLIST, NOT A SCAN. `~/.hq` also holds `cognito-tokens.json`,
  *      `deploy-passwords.json`, and `secrets-cache/`. Only `*.log` files
- *      directly inside `~/.hq/logs/` plus the two known root-level boot logs
- *      are ever eligible. A recursive walk over `~/.hq` is a credential leak
+ *      directly inside `~/.hq/logs/`, the exact daemon sync-log generations
+ *      under the configured daemon root, and the two known root-level boot
+ *      logs are eligible. A recursive walk over `~/.hq` is a credential leak
  *      and must never be introduced here.
  *
  *   2. NO SYMLINKS. Eligibility is decided with `lstat`, and a candidate must
@@ -58,6 +60,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { currentSyncLogFamily, SYNC_LOG_RELATIVE_PATHS, SYNC_LOG_GENERATIONS, syncLogBasePaths, syncLogFamilyForRelativePath, syncLogGenerationPath, } from "./sync-log-sources.js";
 /**
  * Ceiling on the total redacted log text attached to one submission.
  *
@@ -279,15 +282,15 @@ function lstatOrNull(absPath) {
  * Enumerate eligible log files under `hqDir`.
  *
  * Eligibility is the allowlist described in the module header: `*.log` files
- * directly inside `hqDir/logs/`, plus {@link FEEDBACK_ROOT_LOG_FILENAMES} at
- * the root. Every candidate must be a REGULAR file by `lstat` — directories
- * and, critically, symlinks are rejected. Returned newest-modified first so
- * the most relevant log is offered the budget before older ones.
+ * directly inside `hqDir/logs/`, the exact daemon sync-log generations, plus
+ * {@link FEEDBACK_ROOT_LOG_FILENAMES} at the root. Every candidate must be a
+ * REGULAR file by `lstat` — directories and, critically, symlinks are rejected.
+ * Returned newest-modified first so the most relevant log is offered budget
+ * before older ones.
  */
-export function discoverLogFiles(hqDir) {
+export function discoverLogFiles(hqDir, env = process.env) {
     const candidates = [];
-    const consider = (relName) => {
-        const absPath = path.join(hqDir, relName);
+    const consider = (relName, absPath = path.join(hqDir, relName)) => {
         const st = lstatOrNull(absPath);
         // isFile() is false for both directories and symlinks under lstat. A
         // symlink here would be the credential-exfiltration path (see header).
@@ -313,11 +316,37 @@ export function discoverLogFiles(hqDir) {
             continue;
         consider(`${FEEDBACK_LOGS_DIRNAME}/${entry}`);
     }
+    const daemonLogPath = syncLogBasePaths(hqDir, env).daemon;
+    for (let generation = 0; generation < SYNC_LOG_GENERATIONS; generation += 1) {
+        const relName = syncLogGenerationPath(SYNC_LOG_RELATIVE_PATHS.daemon, generation);
+        const absPath = syncLogGenerationPath(daemonLogPath, generation);
+        consider(relName, absPath);
+    }
     for (const filename of FEEDBACK_ROOT_LOG_FILENAMES) {
         consider(filename);
     }
-    candidates.sort((a, b) => b.modifiedMs - a.modifiedMs);
-    return candidates;
+    let desktopModifiedMs = null;
+    let daemonModifiedMs = null;
+    for (const candidate of candidates) {
+        const family = syncLogFamilyForRelativePath(candidate.name);
+        if (family === "desktop") {
+            desktopModifiedMs = desktopModifiedMs === null
+                ? candidate.modifiedMs
+                : Math.max(desktopModifiedMs, candidate.modifiedMs);
+        }
+        else if (family === "daemon") {
+            daemonModifiedMs = daemonModifiedMs === null
+                ? candidate.modifiedMs
+                : Math.max(daemonModifiedMs, candidate.modifiedMs);
+        }
+    }
+    const selectedFamily = currentSyncLogFamily(desktopModifiedMs, daemonModifiedMs);
+    const selected = candidates.filter((candidate) => {
+        const family = syncLogFamilyForRelativePath(candidate.name);
+        return family === null || family === selectedFamily;
+    });
+    selected.sort((a, b) => b.modifiedMs - a.modifiedMs);
+    return selected;
 }
 /**
  * Read the last `maxBytes` of a file.
@@ -546,7 +575,7 @@ export function collectFeedbackLogs(opts = {}) {
     let logCandidates;
     let stateCandidates;
     try {
-        logCandidates = discoverLogFiles(hqDir);
+        logCandidates = discoverLogFiles(hqDir, opts.env);
         // Order matters: root status documents first, then the lock/claim files
         // (highest signal for a hang), then scheduled-job status. Under a tight
         // budget the earlier ones win, and that is the intended priority.

package/dist/utils/local-files-overview.d.ts

@@ -11,10 +11,11 @@
  * cross the wire; there is no string field on it for anything sensitive to
  * hide inside.
  *
- * Sources (metadata only, via `fs.stat` — full content is read only for the
+ * Sources (metadata only, via `fs.lstat` — full content is read only for the
  * bounded error-line count below, and even then only a capped tail window,
  * and even then only an integer count is ever returned):
- *   - the hq-sync desktop app's log file, `~/.hq/logs/hq-sync.log`
+ *   - the newest available desktop or daemon sync-log family and its rotations
+ *     under `~/.hq/logs/` or `~/.hq/daemon/logs/`
  *   - the CLI's own per-company sync journals, enumerated via `listJournals()`
  *     (never a hand-reconstructed path — see client-health.ts's note on the
  *     single-path-reconstruction regression this mirrors).
@@ -42,6 +43,7 @@ export declare function countRecentErrorLines(filePath: string, maxBytes?: numbe
 export interface CollectLocalFilesOverviewDeps {
     now?: () => Date;
     homeDir?: () => string;
+    env?: NodeJS.ProcessEnv;
     journals?: () => readonly {
         path: string;
     }[];