@indigoai-us/hq-cli 5.345.169 → 5.345.171

package/dist/lib/doctor/fix/apply.js

@@ -44,6 +44,7 @@ import { getStateDir } from "@indigoai-us/hq-cloud";
 import { isPersonalJournalSlug } from "../checks/sync-health.js";
 import { createDefaultRegistry } from "../registry.js";
 import { flattenFamilies } from "../report.js";
+import { repairDanglingReleaseLinks } from "../checks/release-links.js";
 import { parseHookGateProfiles, requiredMissingProfiles, } from "../hook-gate-profiles.js";
 import { createBackup } from "./backup.js";
 import { removeStrayGateEntries } from "../stray-gate-entries.js";
@@ -735,20 +736,95 @@ function defaultLocksDir() {
 export const REFRESH_SYNC_LOCK_TIMEOUT_SEC = 30;
 /**
  * Default `refresh-manifest` repair: a bounded `hq sync manifest --scope <s>`
- * against the tree `--fix` is repairing. Exit 0 also covers throttled,
- * disabled, and skipped passes, so the post-fix re-check decides whether the
- * row cleared. A timeout or non-zero exit is reported, not thrown.
+ * against the tree `--fix` is repairing, with `--json` so a pass that exits 0
+ * without uploading (soft_skipped, throttled, disabled, locked,
+ * resend_full_scheduled) is reported as not uploaded. A `resend_full` answer
+ * is retried once with `--full`. The post-fix re-check still decides whether
+ * the row cleared. A timeout or non-zero exit is reported, not thrown.
  */
 export function defaultRefreshManifest(target) {
-    const hqBin = process.argv[1];
-    const args = ["sync", "manifest", "--scope", target.scope, "--hq-root", target.hqRoot];
-    const result = spawnSync(hqBin ? process.execPath : "hq", hqBin ? [hqBin, ...args] : args, {
-        encoding: "utf8",
-        timeout: REFRESH_SYNC_TIMEOUT_MS,
-        cwd: target.hqRoot,
-    });
-    return Promise.resolve(manifestUploadResult(target.scope, result));
+    return Promise.resolve(refreshManifestWithRetry(target.scope, (full, json) => {
+        const hqBin = process.argv[1];
+        const args = [
+            "sync",
+            "manifest",
+            "--scope",
+            target.scope,
+            "--hq-root",
+            target.hqRoot,
+            ...(json ? ["--json"] : []),
+            ...(full ? ["--full"] : []),
+        ];
+        return spawnSync(hqBin ? process.execPath : "hq", hqBin ? [hqBin, ...args] : args, {
+            encoding: "utf8",
+            timeout: REFRESH_SYNC_TIMEOUT_MS,
+            cwd: target.hqRoot,
+        });
+    }));
+}
+/**
+ * Run one upload and, when the server answered `resend_full` (it dropped or
+ * refused the delta base), run it once more with `--full`. Without the retry
+ * the scope stays stale until the next day's --fix run, and the health hook
+ * reports it as unrepaired in between (feedback_84d7a862).
+ */
+export function refreshManifestWithRetry(scope, run) {
+    const firstRaw = run(false, true);
+    // `hq` from PATH can be an older binary without `--json`. Fall back to the
+    // exit-code handling it always had instead of reporting a failure.
+    if (manifestJsonUnsupported(firstRaw))
+        return manifestUploadResult(scope, run(false, false));
+    const first = manifestUploadResult(scope, firstRaw);
+    if (first.passStatus !== "resend_full_scheduled")
+        return first;
+    const retry = manifestUploadResult(scope, run(true, true));
+    if (retry.passStatus !== "resend_full_scheduled")
+        return retry;
+    return {
+        ...retry,
+        reason: "the server asked for a full manifest again after a --full retry; a full resend is queued, so run `hq sync` again later",
+    };
 }
+/** Commander's rejection of `--json` by a binary that predates it. */
+export function manifestJsonUnsupported(result) {
+    if (result.status === 0 || result.status === null)
+        return false;
+    return /unknown option ['"]?--json/i.test(`${result.stderr ?? ""}\n${result.stdout ?? ""}`);
+}
+/**
+ * The status token from the `hq sync manifest --json` line, or undefined when
+ * the output has none (an older binary, or a pass that printed only a summary).
+ */
+export function manifestPassStatus(stdout) {
+    const lines = (stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (!line.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed.status === "string" && /^[a-z_]{1,40}$/.test(parsed.status)) {
+                return parsed.status;
+            }
+        }
+        catch {
+            // Not the outcome line.
+        }
+    }
+    return undefined;
+}
+/**
+ * Plain-words reason for a pass that exited 0 without uploading. Each one
+ * leaves `lastUploadAt` unchanged, so the stale row cannot clear.
+ */
+const MANIFEST_NOT_UPLOADED_REASONS = {
+    soft_skipped: "the sync service did not accept manifest uploads (the pass was skipped)",
+    throttled: "the pass was throttled and sent nothing",
+    disabled: "manifest uploads are turned off on this machine",
+    locked: "another manifest pass for this scope was already running",
+    resend_full_scheduled: "the server asked for a fresh full manifest and the upload did not finish",
+    printed: "the pass only printed the manifest",
+};
 /**
  * Map one `hq sync manifest` spawn result to a {@link RefreshManifestResult}.
  * A spawn killed by the timeout has a null status, so it is reported as a
@@ -778,6 +854,15 @@ export function manifestUploadResult(scope, result) {
                 : {}),
         };
     }
+    const passStatus = manifestPassStatus(result.stdout);
+    if (passStatus && passStatus !== "uploaded") {
+        return {
+            ok: false,
+            passStatus,
+            reason: MANIFEST_NOT_UPLOADED_REASONS[passStatus] ?? `the pass ended '${passStatus}' without uploading`,
+            message: `manifest upload for '${scope}' did not upload (${passStatus})`,
+        };
+    }
     return { ok: true, message: `uploaded the manifest for '${scope}'` };
 }
 /** `hq sync manifest` output for a company this identity is not a member of. */
@@ -821,6 +906,8 @@ function planFix(hqRoot, result, rem, refreshSync, rewriteBotNodePath = defaultR
             return planRefreshSync(hqRoot, result, rem, refreshSync);
         case "refresh-manifest":
             return planRefreshManifest(hqRoot, result, rem, refreshManifest);
+        case "repair-release-link":
+            return planRepairReleaseLink(hqRoot, result, rem);
         default:
             return null;
     }
@@ -991,6 +1078,57 @@ function planRefreshManifest(hqRoot, result, rem, refreshManifest) {
         failureReason: () => failureReason,
     };
 }
+/**
+ * Repoint (or remove) one dangling HQ-managed release link. The repair writes
+ * only the link entry, never a hook body, so it needs no backup: a link that
+ * does not resolve has no content to restore.
+ */
+function planRepairReleaseLink(hqRoot, result, rem) {
+    const rel = rem.fixTarget;
+    if (!rel)
+        return null;
+    let failure;
+    return {
+        checkId: result.checkId,
+        fixClass: "repair-release-link",
+        target: rel,
+        relpath: "",
+        preview: `  ${rel}\n` +
+            `    - dangling link\n` +
+            `    + the shipped link to its target under the HQ root (removed if that target is missing)`,
+        summary: `repair dangling link ${rel}`,
+        apply: () => {
+            // Each plan repairs only its own link, and a throw is recorded as this
+            // plan's failure so the remaining plans still run.
+            try {
+                const own = repairDanglingReleaseLinks(hqRoot, { only: rel });
+                const entry = own.find((item) => item.rel === rel);
+                if (!entry) {
+                    failure = `${rel} was not repaired`;
+                }
+                else if (entry.action === "skipped" || entry.action === "failed") {
+                    failure = `${rel} was not repaired: ${entry.reason ?? entry.action}`;
+                }
+                else {
+                    failure = undefined;
+                }
+            }
+            catch (err) {
+                failure = `${rel} was not repaired: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        postStatus: (results) => {
+            const own = results.filter((entry) => entry.checkId === result.checkId);
+            if (own.some((entry) => entry.target === rel))
+                return "FAIL";
+            // Another link's failure is that plan's status, not this one's.
+            if (own.some((entry) => entry.status === "FAIL"))
+                return "PASS";
+            return own[0]?.status ?? null;
+        },
+        failureReason: () => failure,
+    };
+}
 /** Restore the execute bit on a hook script. */
 function planExecutableBit(hqRoot, result, rem) {
     const abs = rem.fixTarget;

package/dist/lib/doctor/fix/remediation.d.ts

@@ -43,6 +43,13 @@
  *                         hq-cli shim (see `lib/windows/ps1-shims.ts`); the
  *                         execution policy is never changed. This is the one
  *                         scoped exception to the no-delete rule below.
+ *   - `repair-release-link` — repoint an HQ-managed release link
+ *                         (`.agents/skills`, `.codex/claude`, ...) whose target
+ *                         is missing, using the link text HQ ships (absolute junction on Windows).
+ *                         When that target is missing too, the dangling link
+ *                         entry is removed. Only a link that does not resolve
+ *                         is touched; a real file or folder never is, and the
+ *                         link is removed without following it.
  *
  * EVERYTHING else — content drift between platform copies, a missing script, a
  * missing Codex counterpart, an unquoted `$CLAUDE_PROJECT_DIR`, a stale
@@ -54,7 +61,7 @@
  */
 import type { CheckResult } from "../types.js";
 /** The allowlisted safe repair classes `--fix` is permitted to apply. */
-export type FixClass = "executable-bit" | "gate-profile" | "remove-stray-gate-entries" | "refresh-sync" | "refresh-manifest" | "bot-node-path" | "bot-hq-binary" | "remove-ps1-shims";
+export type FixClass = "executable-bit" | "gate-profile" | "remove-stray-gate-entries" | "refresh-sync" | "refresh-manifest" | "bot-node-path" | "bot-hq-binary" | "remove-ps1-shims" | "repair-release-link";
 /**
  * A finding's structured remediation. `autoFixable`, `action`, and `command`
  * are the `--json` surface (AC1); `fixTarget`/`fixClass` are the internal handle

package/dist/lib/doctor/fix/remediation.js

@@ -43,6 +43,13 @@
  *                         hq-cli shim (see `lib/windows/ps1-shims.ts`); the
  *                         execution policy is never changed. This is the one
  *                         scoped exception to the no-delete rule below.
+ *   - `repair-release-link` — repoint an HQ-managed release link
+ *                         (`.agents/skills`, `.codex/claude`, ...) whose target
+ *                         is missing, using the link text HQ ships (absolute junction on Windows).
+ *                         When that target is missing too, the dangling link
+ *                         entry is removed. Only a link that does not resolve
+ *                         is touched; a real file or folder never is, and the
+ *                         link is removed without following it.
  *
  * EVERYTHING else — content drift between platform copies, a missing script, a
  * missing Codex counterpart, an unquoted `$CLAUDE_PROJECT_DIR`, a stale
@@ -53,6 +60,7 @@
  * deciding which of two diverged copies is correct needs human judgement.
  */
 import * as path from "node:path";
+import { DANGLING_RELEASE_LINK_PROBLEM, RELEASE_LINKS, RELEASE_LINKS_CHECK_ID, } from "../checks/release-links.js";
 import { isCompanyJournalSlug, isSafeCompanySlug, isPersonalJournalSlug, journalSlugFromCheckId, } from "../checks/sync-health.js";
 /** Matches an exec-bit remediation command, quoted or not: `chmod +x <path>`. */
 const CHMOD_EXEC = /^chmod\s+\+x\s+(.+)$/;
@@ -165,6 +173,20 @@ export function deriveRemediation(result) {
             command: "hq.cmd install --global",
         };
     }
+    // repair-release-link — a shipped link whose target is missing, such as one
+    // a rescue pointed at its deleted temp folder (feedback_2ab63e50).
+    if (checkId === RELEASE_LINKS_CHECK_ID &&
+        result.status === "FAIL" &&
+        RELEASE_LINKS.some((entry) => entry.rel === target) &&
+        result.message.startsWith(target + " " + DANGLING_RELEASE_LINK_PROBLEM)) {
+        return {
+            autoFixable: true,
+            fixClass: "repair-release-link",
+            fixTarget: target,
+            action: `Repoint the dangling ${target} link at its target under the HQ root (or remove the link when that target is missing).`,
+            command: "hq doctor --fix",
+        };
+    }
     // Available hq-core upgrade. WARN is intentional in `hq doctor` and is
     // not a broken sync; --fix has no mechanical repair for it.
     if (checkId === "sync.update.core") {

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

@@ -19,7 +19,7 @@ export declare const DOCTOR_STATUSES: readonly ["PASS", "FAIL", "WARN", "UNTESTE
  */
 export type DoctorStatus = (typeof DOCTOR_STATUSES)[number];
 /** Stable, privacy-safe diagnostics emitted by the sync health family. */
-export declare const SYNC_REASON_CODES: readonly ["core-version-unavailable", "core-update-available", "no-local-tree", "company-not-resolved", "legacy-personal-journal", "never-synced", "invalid-last-sync", "stale-threshold", "refresh-in-progress", "refresh-lock-held", "manifest-unavailable", "manifest-state-unavailable", "no-manifest-scopes", "never-uploaded", "invalid-upload-time", "unresolved-company-uid", "realtime-lag-stuck", "receiver-permission-denied", "pull-access-denied", "runner-restart-loop", "device-limit-backoff", "repeated-conflicts"];
+export declare const SYNC_REASON_CODES: readonly ["core-version-unavailable", "core-update-available", "no-local-tree", "company-not-resolved", "legacy-personal-journal", "never-synced", "invalid-last-sync", "stale-threshold", "refresh-in-progress", "refresh-lock-held", "manifest-unavailable", "manifest-state-unavailable", "no-manifest-scopes", "never-uploaded", "invalid-upload-time", "manifest-upload-rejected", "unresolved-company-uid", "realtime-lag-stuck", "receiver-permission-denied", "pull-access-denied", "runner-restart-loop", "device-limit-backoff", "repeated-conflicts"];
 export type SyncReasonCode = (typeof SYNC_REASON_CODES)[number];
 /** Runtime type guard: true only for a member of the fixed vocabulary. */
 export declare function isDoctorStatus(value: unknown): value is DoctorStatus;

package/dist/lib/doctor/types.js

@@ -38,6 +38,7 @@ export const SYNC_REASON_CODES = [
     "no-manifest-scopes",
     "never-uploaded",
     "invalid-upload-time",
+    "manifest-upload-rejected",
     "unresolved-company-uid",
     "realtime-lag-stuck",
     "receiver-permission-denied",