@indigoai-us/hq-cli 5.183.0 → 5.185.0

package/dist/lib/mesh/live/enqueue.d.ts

@@ -23,6 +23,11 @@ export interface EnqueueOptions {
     status?: "queued" | "in_progress" | "review" | "done";
     reason?: string;
     summary?: string;
+    repo?: string;
+    gitBranch?: string;
+    prUrls?: string[];
+    /** Local only: used to build a session_end summary; never written to the spool. */
+    transcriptPath?: string;
     cwd?: string;
     hqRoot?: string;
     companySlug?: string;

package/dist/lib/mesh/live/enqueue.js

@@ -2,6 +2,7 @@
  * Local session-event enqueue (US-008): validate + append one spool line.
  * No network. Shared line format with work-mesh-enqueue.sh.
  */
+import { enrichSessionEndEvent } from "./report-summary.js";
 import { validateSessionEvent } from "./validate-session-event.js";
 import { formatSpoolLine, } from "./format-spool-line.js";
 import { generateUlid } from "./ulid.js";
@@ -65,6 +66,12 @@ export function enqueueSessionEvent(opts) {
         event.reason = opts.reason;
     if (opts.summary)
         event.summary = opts.summary;
+    if (opts.repo)
+        event.repo = opts.repo;
+    if (opts.gitBranch)
+        event.gitBranch = opts.gitBranch;
+    if (opts.prUrls && opts.prUrls.length > 0)
+        event.prUrls = opts.prUrls;
     if (opts.cwd)
         event.cwd = opts.cwd;
     if (opts.hqRoot)
@@ -77,6 +84,18 @@ export function enqueueSessionEvent(opts) {
         event.task = opts.task;
     if (opts.toolWrites !== undefined)
         event.toolWrites = opts.toolWrites;
+    if (event.kind === "session_end") {
+        const enriched = enrichSessionEndEvent(event, { transcriptPath: opts.transcriptPath });
+        if (typeof enriched.summary === "string")
+            event.summary = enriched.summary;
+        if (typeof enriched.repo === "string")
+            event.repo = enriched.repo;
+        if (typeof enriched.gitBranch === "string")
+            event.gitBranch = enriched.gitBranch;
+        if (Array.isArray(enriched.prUrls) && enriched.prUrls.length > 0) {
+            event.prUrls = enriched.prUrls;
+        }
+    }
     const candidate = {
         ...event,
         v: 1,

package/dist/lib/mesh/live/flush.js

@@ -20,6 +20,7 @@ import { repairAckedRegisterStates } from "../../work-context/outbox.js";
 import { workContextRoot } from "../../work-context/paths.js";
 import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.js";
 import { LOCAL_ONLY_FIELDS, stripLocalOnlyFields } from "./format-spool-line.js";
+import { enrichSessionEndEvent } from "./report-summary.js";
 import { SESSION_EVENTS_BATCH_MAX, WRITABLE_CONTEXT_STATUSES, parseSessionEventsBatchAck, } from "./session-events-client.js";
 import { appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendSpoolLine, claimHeld, claimSpool, countJsonlLines, ensureSpoolFile, recoverOrphanClaims, removeClaimFile, } from "./spool.js";
 import { workMeshHeldPath, workMeshRoot } from "./paths.js";
@@ -316,7 +317,7 @@ export async function flushSessionEvents(deps) {
             // presence-leave). Untouched events stay in pendingRestore and are put
             // back on the spool below.
             const flushItems = remainingItems.slice(0, SESSION_EVENTS_MAX_PER_SESSION_PER_FLUSH);
-            const stripped = flushItems.map((item) => stripLocalOnlyFields(item.event));
+            const stripped = flushItems.map((item) => stripLocalOnlyFields(enrichSessionEndEvent(item.event)));
             for (let i = 0; i < stripped.length; i += SESSION_EVENTS_BATCH_MAX) {
                 const chunk = stripped.slice(i, i + SESSION_EVENTS_BATCH_MAX);
                 const originalChunk = flushItems.slice(i, i + SESSION_EVENTS_BATCH_MAX);
@@ -608,7 +609,7 @@ function synthesizeSessionEnd(sessionId, sample, seq, at) {
     const harness = harnessRaw && SESSION_EVENT_HARNESSES.has(harnessRaw)
         ? harnessRaw
         : "claude-code";
-    return stripLocalOnlyFields({
+    return stripLocalOnlyFields(enrichSessionEndEvent({
         v: 1,
         eventId: generateUlid(),
         kind: "session_end",
@@ -617,7 +618,8 @@ function synthesizeSessionEnd(sessionId, sample, seq, at) {
         adapterVersion: eventText(sample, "adapterVersion") || "1.0.0",
         at,
         seq,
-    });
+        cwd: eventText(sample, "cwd"),
+    }));
 }
 async function postPresenceLeaveIfNeeded(input) {
     const leave = input.state?.presenceLeave;

package/dist/lib/mesh/live/format-spool-line.d.ts

@@ -5,7 +5,7 @@
 export declare const LOCAL_ONLY_FIELDS: readonly ["cwd", "hqRoot", "companySlug", "project", "task", "toolWrites"];
 export type LocalOnlyField = (typeof LOCAL_ONLY_FIELDS)[number];
 /** Network + local key order matching work-mesh-enqueue.sh. */
-export declare const SPOOL_KEY_ORDER: readonly ["v", "eventId", "kind", "sessionId", "harness", "adapterVersion", "runtimeVersion", "source", "at", "seq", "taskId", "status", "reason", "summary", "cwd", "hqRoot", "companySlug", "project", "task", "toolWrites"];
+export declare const SPOOL_KEY_ORDER: readonly ["v", "eventId", "kind", "sessionId", "harness", "adapterVersion", "runtimeVersion", "source", "at", "seq", "taskId", "status", "reason", "summary", "repo", "gitBranch", "prUrls", "cwd", "hqRoot", "companySlug", "project", "task", "toolWrites"];
 export type SessionEventKind = "session_start" | "turn_start" | "turn_end" | "session_end" | "task_status" | "blocked" | "note";
 export type SessionEventHarness = "claude-code" | "claude-desktop" | "codex" | "grok" | "hq-sessions" | "agent-box" | "agents-v2";
 export type SessionEventSource = "hooks" | "transcript";
@@ -24,6 +24,9 @@ export interface SpoolEventInput {
     status?: "queued" | "in_progress" | "review" | "done";
     reason?: string;
     summary?: string;
+    repo?: string;
+    gitBranch?: string;
+    prUrls?: string[];
     cwd?: string;
     hqRoot?: string;
     companySlug?: string;
@@ -35,7 +38,7 @@ export interface SpoolEventInput {
  * Build a compact JSON object in SPOOL_KEY_ORDER, omitting absent optional
  * strings. `toolWrites` is included when it is a finite number >= 0 (including 0).
  */
-export declare function buildOrderedSpoolObject(input: SpoolEventInput): Record<string, string | number>;
+export declare function buildOrderedSpoolObject(input: SpoolEventInput): Record<string, string | number | string[]>;
 /** Compact JSON line body (no trailing newline). */
 export declare function formatSpoolLine(input: SpoolEventInput): string;
 export declare function stripLocalOnlyFields(event: Record<string, unknown>): Record<string, unknown>;

package/dist/lib/mesh/live/format-spool-line.js

@@ -26,6 +26,9 @@ export const SPOOL_KEY_ORDER = [
     "status",
     "reason",
     "summary",
+    "repo",
+    "gitBranch",
+    "prUrls",
     "cwd",
     "hqRoot",
     "companySlug",
@@ -63,6 +66,13 @@ export function buildOrderedSpoolObject(input) {
         out.reason = input.reason;
     if (includeString(input.summary))
         out.summary = input.summary;
+    if (includeString(input.repo))
+        out.repo = input.repo;
+    if (includeString(input.gitBranch))
+        out.gitBranch = input.gitBranch;
+    if (Array.isArray(input.prUrls) && input.prUrls.length > 0) {
+        out.prUrls = input.prUrls.filter(includeString).slice(0, 5);
+    }
     if (includeString(input.cwd))
         out.cwd = input.cwd;
     if (includeString(input.hqRoot))

package/dist/lib/mesh/live/report-summary.d.ts

@@ -0,0 +1,45 @@
+/**
+ * US-051 — one-sentence quiet-report fields for session_end.
+ *
+ * Built locally at the quiet trigger / SessionEnd flush. Never includes file
+ * contents. Tokens, secret-looking strings, and secrets-file paths are redacted.
+ */
+export declare const REPORT_SUMMARY_MAX_CHARS = 140;
+export declare const REPORT_SUMMARY_SCHEMA_MAX = 280;
+export declare const REPORT_TRANSCRIPT_TAIL_BYTES: number;
+export interface SessionEndReportFields {
+    summary?: string;
+    repo?: string;
+    gitBranch?: string;
+    prUrls?: string[];
+}
+export interface BuildSessionEndReportFieldsInput {
+    sessionId?: string;
+    cwd?: string;
+    transcriptPath?: string;
+    home?: string;
+    /** Injectable git runner (tests). */
+    git?: (cwd: string, args: string[]) => string | undefined;
+    /** Injectable transcript reader (tests). */
+    readTranscript?: (p: string) => string | undefined;
+}
+export declare function redactReportSummary(text: string): string;
+export declare function firstSentence(text: string, max?: number): string;
+export declare function extractLastAssistantText(jsonl: string): string | undefined;
+export declare function readTranscriptTail(transcriptPath: string, maxBytes?: number): string | undefined;
+export declare function collectGitContext(cwd: string, git?: (cwd: string, args: string[]) => string | undefined): {
+    repo?: string;
+    gitBranch?: string;
+};
+export declare function extractPrUrls(text: string, max?: number): string[];
+export declare function claudeTranscriptPathFor(sessionId: string, cwd: string, home?: string): string;
+export declare function resolveTranscriptPath(input: {
+    transcriptPath?: string;
+    sessionId?: string;
+    cwd?: string;
+    home?: string;
+}): string | undefined;
+export declare function buildSessionEndReportFields(input: BuildSessionEndReportFieldsInput): SessionEndReportFields;
+/** Merge report fields onto a session_end event object (no-op for other kinds). */
+export declare function enrichSessionEndEvent(event: Record<string, unknown>, extra?: Pick<BuildSessionEndReportFieldsInput, "transcriptPath" | "home" | "git" | "readTranscript">): Record<string, unknown>;
+//# sourceMappingURL=report-summary.d.ts.map

package/dist/lib/mesh/live/report-summary.js

@@ -0,0 +1,222 @@
+/**
+ * US-051 — one-sentence quiet-report fields for session_end.
+ *
+ * Built locally at the quiet trigger / SessionEnd flush. Never includes file
+ * contents. Tokens, secret-looking strings, and secrets-file paths are redacted.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const REPORT_SUMMARY_MAX_CHARS = 140;
+export const REPORT_SUMMARY_SCHEMA_MAX = 280;
+export const REPORT_TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+const SECRET_RE = /(?:Bearer\s+[A-Za-z0-9._\-+=/]+)|(?:sk-[A-Za-z0-9]{8,})|(?:ghp_[A-Za-z0-9]{8,})|(?:github_pat_[A-Za-z0-9_]{8,})|(?:xox[baprs]-[A-Za-z0-9-]{8,})|(?:AKIA[0-9A-Z]{8,})|(?:op:\/\/[^\s"]+)/gi;
+const SECRETS_PATH_RE = /(?:^|[\s"'`])((?:~|\/|\.\/|\.\.\/)?(?:[\w.-]+\/)*(?:\.env(?:\.[A-Za-z0-9._-]+)?|secrets(?:\/[\w.-]+)*|id_rsa|credentials(?:\.json)?|\.netrc|\.npmrc))/gi;
+const PR_URL_RE = /https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+/g;
+export function redactReportSummary(text) {
+    let out = text.replace(SECRET_RE, "[redacted]");
+    out = out.replace(SECRETS_PATH_RE, (full, match) => full.replace(match, "[redacted-path]"));
+    // eslint-disable-next-line no-control-regex -- strip C0 controls from report text
+    return out.replace(/[\u0000-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim();
+}
+export function firstSentence(text, max = REPORT_SUMMARY_MAX_CHARS) {
+    const cleaned = redactReportSummary(text);
+    if (!cleaned)
+        return "";
+    const cut = cleaned.split(/(?<=[.!?])\s+/)[0] ?? cleaned;
+    const sentence = cut.trim();
+    if (sentence.length <= max)
+        return sentence;
+    const slice = sentence.slice(0, max);
+    const lastSpace = slice.lastIndexOf(" ");
+    return (lastSpace > 40 ? slice.slice(0, lastSpace) : slice).trim();
+}
+function textFromUnknown(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === "string")
+                return item;
+            if (item && typeof item === "object") {
+                const rec = item;
+                if (rec.type === "text" && typeof rec.text === "string")
+                    return rec.text;
+            }
+            return "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (value && typeof value === "object") {
+        const rec = value;
+        if (typeof rec.text === "string")
+            return rec.text;
+        if (rec.content !== undefined)
+            return textFromUnknown(rec.content);
+    }
+    return "";
+}
+export function extractLastAssistantText(jsonl) {
+    let last;
+    for (const rawLine of jsonl.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line.startsWith("{"))
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = typeof obj.type === "string" ? obj.type : "";
+        const role = typeof obj.role === "string" ? obj.role : "";
+        const payload = obj.payload;
+        let text = "";
+        if (type === "assistant" || role === "assistant") {
+            text = textFromUnknown(obj.message ?? obj.content);
+        }
+        else if (payload &&
+            (payload.type === "agent_message" || payload.type === "assistant")) {
+            text = textFromUnknown(payload.message ?? payload.content ?? payload.text);
+        }
+        const trimmed = text.trim();
+        if (trimmed)
+            last = trimmed;
+    }
+    return last;
+}
+export function readTranscriptTail(transcriptPath, maxBytes = REPORT_TRANSCRIPT_TAIL_BYTES) {
+    try {
+        const st = fs.statSync(transcriptPath);
+        if (!st.isFile() || st.size <= 0)
+            return undefined;
+        const size = Math.min(st.size, maxBytes);
+        const fd = fs.openSync(transcriptPath, "r");
+        try {
+            const buf = Buffer.alloc(size);
+            fs.readSync(fd, buf, 0, size, Math.max(0, st.size - size));
+            let text = buf.toString("utf8");
+            if (st.size > maxBytes) {
+                const nl = text.indexOf("\n");
+                if (nl >= 0)
+                    text = text.slice(nl + 1);
+            }
+            return text;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultGit(cwd, args) {
+    try {
+        const r = spawnSync("git", ["-C", cwd, ...args], {
+            timeout: 800,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (r.status !== 0)
+            return undefined;
+        const out = (r.stdout ?? "").trim();
+        return out || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function collectGitContext(cwd, git = defaultGit) {
+    const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const top = git(cwd, ["rev-parse", "--show-toplevel"]);
+    const repo = top ? path.basename(top) : undefined;
+    const out = {};
+    if (repo && repo.length <= 128 && !repo.includes("\0"))
+        out.repo = repo;
+    if (branch && branch !== "HEAD" && branch.length <= 128)
+        out.gitBranch = branch;
+    return out;
+}
+export function extractPrUrls(text, max = 5) {
+    const seen = new Set();
+    const urls = [];
+    for (const match of text.match(PR_URL_RE) ?? []) {
+        if (seen.has(match))
+            continue;
+        seen.add(match);
+        urls.push(match.slice(0, 256));
+        if (urls.length >= max)
+            break;
+    }
+    return urls;
+}
+export function claudeTranscriptPathFor(sessionId, cwd, home = os.homedir()) {
+    const encoded = cwd.startsWith("/") ? cwd.replace(/\//g, "-") : `-${cwd.replace(/\//g, "-")}`;
+    return path.join(home, ".claude", "projects", encoded, `${sessionId}.jsonl`);
+}
+export function resolveTranscriptPath(input) {
+    const explicit = input.transcriptPath?.trim();
+    if (explicit)
+        return explicit;
+    const envPath = process.env.CLAUDE_TRANSCRIPT_PATH?.trim();
+    if (envPath)
+        return envPath;
+    const sid = input.sessionId?.trim();
+    const cwd = input.cwd?.trim();
+    if (sid && cwd)
+        return claudeTranscriptPathFor(sid, cwd, input.home);
+    return undefined;
+}
+export function buildSessionEndReportFields(input) {
+    const fields = {};
+    const git = input.git ?? defaultGit;
+    const cwd = input.cwd?.trim();
+    if (cwd)
+        Object.assign(fields, collectGitContext(cwd, git));
+    const transcriptPath = resolveTranscriptPath(input);
+    const read = input.readTranscript ?? ((p) => readTranscriptTail(p));
+    let assistant;
+    if (transcriptPath) {
+        const tail = read(transcriptPath);
+        if (tail)
+            assistant = extractLastAssistantText(tail);
+    }
+    if (assistant) {
+        const summary = firstSentence(assistant);
+        if (summary)
+            fields.summary = summary.slice(0, REPORT_SUMMARY_SCHEMA_MAX);
+        const prs = extractPrUrls(assistant);
+        if (prs.length > 0)
+            fields.prUrls = prs;
+    }
+    return fields;
+}
+/** Merge report fields onto a session_end event object (no-op for other kinds). */
+export function enrichSessionEndEvent(event, extra) {
+    if (event.kind !== "session_end")
+        return event;
+    const built = buildSessionEndReportFields({
+        sessionId: typeof event.sessionId === "string" ? event.sessionId : undefined,
+        cwd: typeof event.cwd === "string" ? event.cwd : undefined,
+        transcriptPath: extra?.transcriptPath,
+        home: extra?.home,
+        git: extra?.git,
+        readTranscript: extra?.readTranscript,
+    });
+    const out = { ...event };
+    if (!out.summary && built.summary)
+        out.summary = built.summary;
+    if (!out.repo && built.repo)
+        out.repo = built.repo;
+    if (!out.gitBranch && built.gitBranch)
+        out.gitBranch = built.gitBranch;
+    if (!out.prUrls && built.prUrls)
+        out.prUrls = built.prUrls;
+    return out;
+}
+//# sourceMappingURL=report-summary.js.map

package/dist/lib/mesh/live/session-event.schema.json

@@ -109,7 +109,30 @@
       "type": "string",
       "minLength": 1,
       "maxLength": 280,
-      "description": "Optional short summary allowed only on note, blocked, and task_status. Never prompt-derived content."
+      "description": "Optional short summary on note, blocked, task_status, and session_end (US-051 quiet report). Redacted; never raw prompts, tokens, or file contents."
+    },
+    "repo": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128,
+      "description": "Optional git repository basename on session_end for the quiet work report (US-051)."
+    },
+    "gitBranch": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128,
+      "description": "Optional git branch of the session cwd on session_end (US-051)."
+    },
+    "prUrls": {
+      "type": "array",
+      "maxItems": 5,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 256,
+        "pattern": "^https://github\\.com/"
+      },
+      "description": "Optional pull-request URLs seen in the quiet window (US-051)."
     },
     "cwd": {
       "type": "string",

package/dist/lib/mesh/live/validate-session-event.d.ts

@@ -8,7 +8,7 @@
 import type { ValidateFunction } from "ajv";
 export declare const SESSION_EVENT_SCHEMA_PATH: string;
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export declare const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
+export declare const SESSION_EVENT_SCHEMA_SHA256 = "e3a9b05daf0037688809e8825a286f9dc89d69aa9266696270d776b64bf99dda";
 export declare const PROHIBITED_CONTENT_CLASSES: readonly ["prompts", "model_output", "transcripts", "message_bodies", "tokens", "credentials"];
 export type ProhibitedContentClass = (typeof PROHIBITED_CONTENT_CLASSES)[number];
 /** Fixture field name → prohibited class. */

package/dist/lib/mesh/live/validate-session-event.js

@@ -13,7 +13,7 @@ import Ajv2020 from "ajv/dist/2020.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const SESSION_EVENT_SCHEMA_PATH = join(HERE, "session-event.schema.json");
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
+export const SESSION_EVENT_SCHEMA_SHA256 = "e3a9b05daf0037688809e8825a286f9dc89d69aa9266696270d776b64bf99dda";
 export const PROHIBITED_CONTENT_CLASSES = [
     "prompts",
     "model_output",

package/dist/lib/search-index/collection-path-repair-flag.d.ts

@@ -0,0 +1,4 @@
+export declare const QMD_COLLECTION_PATH_REPAIR_FLAG = "qmd.collection-path-repair";
+/** Keep collection-path repair off unless the hq-flags registry enables a canary. */
+export declare function qmdCollectionPathRepairEnabled(): boolean;
+//# sourceMappingURL=collection-path-repair-flag.d.ts.map

package/dist/lib/search-index/collection-path-repair-flag.js

@@ -0,0 +1,7 @@
+import { resolveProcessFlagGate } from '../flag-registry.js';
+export const QMD_COLLECTION_PATH_REPAIR_FLAG = 'qmd.collection-path-repair';
+/** Keep collection-path repair off unless the hq-flags registry enables a canary. */
+export function qmdCollectionPathRepairEnabled() {
+    return resolveProcessFlagGate(QMD_COLLECTION_PATH_REPAIR_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=collection-path-repair-flag.js.map

package/dist/lib/search-index/index.d.ts

@@ -537,10 +537,14 @@ export declare function deriveCollections(hqRoot: string): SearchCollection[];
 export type ReconcileCollectionsOptions = {
     bin?: string;
     runner?: QmdProcessRunner;
+    /** Test seam for the default-off collection-path repair rollout. */
+    repairPathDrift?: boolean;
 };
 /**
  * Register expected collections that qmd does not yet know about, returning the
  * collections this call actually created (a `collection add` that exited 0).
+ * When the default-off hq-flags rollout is enabled, it also replaces a registered
+ * collection whose path matches a known prior HQ-managed layout.
  *
  * A same-name idempotent duplicate — qmd already owns the exact requested name
  * in its YAML config (`Collection '<name>' already exists.`), while the

package/dist/lib/search-index/index.js

@@ -3,6 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { dump, load } from 'js-yaml';
 import { isQmdModelDownloadError } from '../../utils/qmd-model-download-error.js';
 import { isQmdModuleMissingError } from '../../utils/qmd-module-missing-error.js';
 import { isQmdNativeBindingError } from '../../utils/qmd-native-binding-error.js';
@@ -12,6 +13,8 @@ import { isQmdStoreUnopenableError } from '../../utils/qmd-store-unopenable-erro
 import { markExpectedUserError } from '../../utils/expected-cli-error.js';
 import { redactErrorText } from '../../utils/redact-error-text.js';
 import { planCommandSpawn } from '../../utils/windows-spawn.js';
+import { resolveQmdConfigPath } from './max-doc-bytes.js';
+import { qmdCollectionPathRepairEnabled } from './collection-path-repair-flag.js';
 /** The `path` implementation for a (possibly injected) platform. */
 function pathFor(platform) {
     return platform === 'win32' ? path.win32 : path.posix;
@@ -1350,9 +1353,90 @@ export function deriveCollections(hqRoot) {
     }
     return collections;
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function qmdConfigPath(hqRoot) {
+    const env = {
+        ...process.env,
+        HOME: process.env.HOME ?? process.env.USERPROFILE ?? os.homedir(),
+    };
+    return resolveQmdConfigPath({ env, startDir: hqRoot });
+}
+/** Read qmd's configured collection metadata from the same config file its CLI uses. */
+function configuredCollections(hqRoot) {
+    const configPath = qmdConfigPath(hqRoot);
+    if (!configPath || !fs.existsSync(configPath))
+        return new Map();
+    const document = load(fs.readFileSync(configPath, 'utf8'));
+    if (!isRecord(document) || !isRecord(document.collections))
+        return new Map();
+    return new Map(Object.entries(document.collections).flatMap(([name, config]) => isRecord(config) && typeof config.path === 'string' ? [[name, config]] : []));
+}
+/** Restore existing collection options after qmd's add command rewrites the entry. */
+function restoreCollectionMetadata(hqRoot, collection, previousConfig) {
+    const configPath = qmdConfigPath(hqRoot);
+    if (!configPath || !fs.existsSync(configPath)) {
+        throw new Error(`QMD config disappeared while repairing collection '${collection.name}'`);
+    }
+    const document = load(fs.readFileSync(configPath, 'utf8'));
+    if (!isRecord(document) || !isRecord(document.collections)) {
+        throw new Error(`QMD config has no collections map while repairing '${collection.name}'`);
+    }
+    const currentConfig = document.collections[collection.name];
+    document.collections[collection.name] = {
+        ...(isRecord(currentConfig) ? currentConfig : {}),
+        ...previousConfig,
+        path: collection.path,
+    };
+    fs.writeFileSync(configPath, dump(document, { lineWidth: 0 }));
+}
+function resolvedPath(value) {
+    const absolutePath = path.resolve(value);
+    try {
+        return fs.realpathSync(absolutePath);
+    }
+    catch {
+        return absolutePath;
+    }
+}
+function comparablePath(value) {
+    return process.platform === 'win32' ? value.toLowerCase() : value;
+}
+/** Repair a known HQ-managed path, including the former company knowledge mirror layout. */
+function isPreviousHqManagedPath(hqRoot, collection, configuredPath) {
+    const root = resolvedPath(hqRoot);
+    const expectedPath = resolvedPath(collection.path);
+    const managedRelativePath = path.relative(root, expectedPath);
+    if (!managedRelativePath ||
+        path.isAbsolute(managedRelativePath) ||
+        managedRelativePath === '..' ||
+        managedRelativePath.startsWith(`..${path.sep}`)) {
+        return false;
+    }
+    const actualPath = resolvedPath(path.resolve(hqRoot, configuredPath));
+    const suffix = `${path.sep}${managedRelativePath}`;
+    const actualForComparison = comparablePath(actualPath);
+    const suffixForComparison = comparablePath(suffix);
+    const prefixLength = actualForComparison.length - suffixForComparison.length;
+    if (prefixLength > path.parse(actualPath).root.length && actualForComparison.endsWith(suffixForComparison)) {
+        return true;
+    }
+    const expectedParts = managedRelativePath.split(path.sep);
+    if (expectedParts.length !== 3 || expectedParts[0] !== 'companies' || expectedParts[2] !== 'knowledge') {
+        return false;
+    }
+    const slug = expectedParts[1];
+    if (!slug)
+        return false;
+    const formerMirrorPath = resolvedPath(path.join(root, 'repos', 'private', `knowledge-${slug}`));
+    return comparablePath(actualPath) === comparablePath(formerMirrorPath);
+}
 /**
  * Register expected collections that qmd does not yet know about, returning the
  * collections this call actually created (a `collection add` that exited 0).
+ * When the default-off hq-flags rollout is enabled, it also replaces a registered
+ * collection whose path matches a known prior HQ-managed layout.
  *
  * A same-name idempotent duplicate — qmd already owns the exact requested name
  * in its YAML config (`Collection '<name>' already exists.`), while the
@@ -1368,11 +1452,29 @@ export function deriveCollections(hqRoot) {
 export function reconcileCollections(hqRoot, options = {}) {
     const runOptions = { bin: options.bin, runner: options.runner, cwd: hqRoot };
     const registered = listRegisteredCollections(hqRoot, runOptions);
-    const missing = deriveCollections(hqRoot).filter((collection) => !registered.has(collection.name));
+    const expected = deriveCollections(hqRoot);
+    const repairPathDrift = options.repairPathDrift ?? qmdCollectionPathRepairEnabled();
+    const configured = repairPathDrift ? configuredCollections(hqRoot) : new Map();
+    const stale = repairPathDrift
+        ? expected.filter((collection) => {
+            const previousConfig = configured.get(collection.name);
+            return previousConfig !== undefined
+                && comparablePath(resolvedPath(path.resolve(hqRoot, previousConfig.path))) !== comparablePath(resolvedPath(collection.path))
+                && isPreviousHqManagedPath(hqRoot, collection, previousConfig.path);
+        })
+        : [];
+    for (const collection of stale) {
+        runQmd(['collection', 'remove', collection.name], runOptions);
+        registered.delete(collection.name);
+    }
+    const missing = expected.filter((collection) => !registered.has(collection.name));
     const created = [];
     for (const collection of missing) {
         try {
             runQmd(['collection', 'add', collection.path, '--name', collection.name, '--mask', collection.mask], runOptions);
+            const previousConfig = configured.get(collection.name);
+            if (previousConfig)
+                restoreCollectionMetadata(hqRoot, collection, previousConfig);
             created.push(collection);
         }
         catch (error) {
@@ -1381,6 +1483,9 @@ export function reconcileCollections(hqRoot, options = {}) {
             // different collection — stays fatal.
             if (!(error instanceof QmdCollectionExistsError) || error.collectionName !== collection.name)
                 throw error;
+            const previousConfig = configured.get(collection.name);
+            if (previousConfig)
+                restoreCollectionMetadata(hqRoot, collection, previousConfig);
         }
         runQmd(['context', 'add', `qmd://${collection.name}`, collection.context], runOptions);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.183.0",
+  "version": "5.185.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {