@indigoai-us/hq-cli 5.291.0 → 5.293.0

package/dist/lib/checkpoint-ontology/drop-aliases.js

@@ -0,0 +1,76 @@
+/**
+ * `hq core ontology drop-aliases`: remove reviewed wrong aliases from entity
+ * files (CO-74). An alias that names a different entity joins two unrelated
+ * entities into one duplicate group; a person lists each `{ entity, alias }`
+ * to remove, and nothing else changes. The dry run writes nothing; `apply`
+ * writes the entity files through the multi-writer outbox so sync pushes them.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { entitiesRoot, safeWriteFile } from "./company.js";
+import { patchEntityFile } from "./entity-file.js";
+import { isWritableEntityType } from "./identity.js";
+import { findDuplicateGroups, recordOutbox } from "./multi-writer.js";
+import { buildEntityIndex } from "./tree.js";
+export const DROP_ALIASES_FLAG = "checkpoint.ontology.drop-aliases";
+export function dropAliases(options) {
+    const { hqRoot, company, mode, drops, now } = options;
+    const index = buildEntityIndex(company.dir);
+    const report = {
+        company: company.slug,
+        mode,
+        duplicate_groups_before: findDuplicateGroups(index).length,
+        duplicate_groups_after: 0,
+        planned: {},
+        written: [],
+        skipped: [],
+        errors: [],
+    };
+    const byEntity = new Map();
+    for (const drop of drops) {
+        const entity = index.byRel.get(drop.entity);
+        if (!entity) {
+            report.skipped.push({ ...drop, reason: "no_entity" });
+        }
+        else if (!isWritableEntityType(entity.type)) {
+            report.skipped.push({ ...drop, reason: "type_not_writable" });
+        }
+        else if (!entity.aliases.includes(drop.alias)) {
+            report.skipped.push({ ...drop, reason: "alias_absent" });
+        }
+        else {
+            byEntity.set(drop.entity, [...(byEntity.get(drop.entity) ?? []), drop]);
+        }
+    }
+    const writes = new Map();
+    for (const [rel, list] of [...byEntity].sort(([a], [b]) => a.localeCompare(b))) {
+        const content = fs.readFileSync(path.join(company.dir, rel), "utf8");
+        const patched = patchEntityFile(content, { removeAliases: list.map((drop) => drop.alias), lastUpdated: now.toISOString() });
+        if (!patched.ok) {
+            for (const drop of list)
+                report.skipped.push({ ...drop, reason: "patch_failed", detail: patched.reason });
+            continue;
+        }
+        report.planned[rel] = [...new Set(list.map((drop) => drop.alias))];
+        writes.set(rel, patched.content);
+    }
+    if (mode === "apply") {
+        for (const [rel, content] of writes) {
+            try {
+                // Outbox first: sync pushes an entity file only when its bytes match.
+                recordOutbox(hqRoot, company, [{ rel, content }], now);
+                safeWriteFile(hqRoot, [entitiesRoot(company)], path.join(company.dir, rel), content);
+                report.written.push(rel);
+            }
+            catch (error) {
+                report.errors.push({ path: rel, error: error.name });
+            }
+        }
+        report.duplicate_groups_after = findDuplicateGroups(buildEntityIndex(company.dir)).length;
+    }
+    else {
+        report.duplicate_groups_after = report.duplicate_groups_before;
+    }
+    return report;
+}
+//# sourceMappingURL=drop-aliases.js.map

package/dist/lib/checkpoint-ontology/entity-file.d.ts

@@ -47,6 +47,8 @@ export declare function renderNewEntity(entity: NewEntity): string;
 export declare const OWNED_KEYS: ReadonlySet<string>;
 export interface EntityPatch {
     addAliases?: string[];
+    /** Exact alias strings to remove (reviewed wrong aliases). Applied before `addAliases`. */
+    removeAliases?: string[];
     signalCount?: number;
     lastUpdated: string;
     /** The caller changed the body, so `last_updated` moves even with no key change. */
@@ -61,9 +63,10 @@ export type PatchResult = {
     reason: string;
 };
 /**
- * Patch an existing, valid entity file. Aliases are only appended, and
- * `signal_count` never goes down. When nothing but `last_updated` would
- * change, the file is returned unchanged so a rerun writes nothing.
+ * Patch an existing, valid entity file. Aliases are appended, and removed
+ * only when `removeAliases` names them exactly; `signal_count` never goes
+ * down. When nothing but `last_updated` would change, the file is returned
+ * unchanged so a rerun writes nothing.
  */
 export declare function patchEntityFile(content: string, patch: EntityPatch): PatchResult;
 /** A namespaced record in a source system, as the cloud schema's `external_refs` holds it. */

package/dist/lib/checkpoint-ontology/entity-file.js

@@ -144,9 +144,10 @@ function appendAliases(lines, all, added) {
     return [...lines.slice(0, end), ...added.map((alias) => `${indent}- ${quote(alias)}`), ...lines.slice(end)];
 }
 /**
- * Patch an existing, valid entity file. Aliases are only appended, and
- * `signal_count` never goes down. When nothing but `last_updated` would
- * change, the file is returned unchanged so a rerun writes nothing.
+ * Patch an existing, valid entity file. Aliases are appended, and removed
+ * only when `removeAliases` names them exactly; `signal_count` never goes
+ * down. When nothing but `last_updated` would change, the file is returned
+ * unchanged so a rerun writes nothing.
  */
 export function patchEntityFile(content, patch) {
     const match = FRONTMATTER_RE.exec(content);
@@ -156,19 +157,24 @@ export function patchEntityFile(content, patch) {
     const before = validateEntityFrontmatter(parsed.frontmatter);
     if (typeof before === "string")
         return { ok: false, reason: `invalid_existing:${before}` };
-    const aliases = [...before.aliases];
+    const remove = new Set(patch.removeAliases ?? []);
+    const kept = before.aliases.filter((alias) => !remove.has(alias));
+    const aliases = [...kept];
     for (const alias of patch.addAliases ?? []) {
         if (!aliases.includes(alias))
             aliases.push(alias);
     }
     const signalCount = Math.max(before.signal_count, patch.signalCount ?? 0);
-    const aliasesChanged = aliases.length !== before.aliases.length;
+    const removed = kept.length !== before.aliases.length;
+    const aliasesChanged = removed || aliases.length !== before.aliases.length;
     const countChanged = signalCount !== before.signal_count;
     if (!aliasesChanged && !countChanged && !patch.bodyChanged)
         return { ok: true, content, changed: false };
     const newline = content.includes("\r\n") ? "\r\n" : "\n";
     let lines = match[1].split(/\r?\n/);
-    if (aliasesChanged)
+    if (removed)
+        lines = replaceTopLevelKey(lines, "aliases", renderAliases(aliases));
+    else if (aliasesChanged)
         lines = appendAliases(lines, aliases, aliases.slice(before.aliases.length));
     if (lines && countChanged)
         lines = replaceTopLevelKey(lines, "signal_count", `signal_count: ${signalCount}`);

package/dist/lib/checkpoint-ontology/merge-copies.d.ts

@@ -27,16 +27,25 @@
  *
  * A signal whose `entity_refs` names a copy holds that copy: signals are
  * server-owned, so the ref cannot be re-pointed from here. With `rewriteRefs`
- * (flag `checkpoint.ontology.merge-rewrite-refs`) signal refs, invoice and
- * bill links, source and knowledge links are re-pointed at the survivor, the
- * survivor receives the copy's `external_ids` and `web_domains`, and only a
- * link from another copy or an external id conflict holds a pair.
+ * (flag `checkpoint.ontology.merge-rewrite-refs`) invoice and bill links and
+ * knowledge links are re-pointed at the survivor and the survivor receives
+ * the copy's `external_ids` and `web_domains`. A signal ref or a link from a
+ * source still holds the pair (`server_owned_refs`): the sync client cannot
+ * push those files. A link from another copy or an external id conflict also
+ * holds a pair.
  *
  * With `pairKind: "variants"` (flag `checkpoint.ontology.merge-variants`) the
  * pairs are two-file duplicate groups whose canonical names differ only in
  * case, spacing or punctuation; the survivor is the spaced name, then the
  * higher `signal_count`, then path order. The copy's canonical name becomes
  * an alias of the survivor. Merge and delete work as for numbered copies.
+ *
+ * With `pairKind: "listed"` (flag `checkpoint.ontology.merge-listed-pairs`)
+ * the pairs are exactly the `only` entries, reviewed by a person: no finder
+ * runs, so the names may differ. Each entry must name two entities of one
+ * type; a copy listed twice, or listed both as a copy and as an original, is
+ * skipped as `listed_conflict`. Holds, merge and delete work as for numbered
+ * copies.
  */
 import { type OntologyCompany } from "./company.js";
 import { type EntityIndex } from "./tree.js";
@@ -46,14 +55,16 @@ export declare const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
  * names differ only in spacing, case or punctuation (CO-65).
  */
 export declare const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
+/** `merge-copies --listed`: merge exactly the reviewed `--only` pairs (CO-74). */
+export declare const MERGE_LISTED_PAIRS_FLAG = "checkpoint.ontology.merge-listed-pairs";
 /**
  * `merge-copies --rewrite-refs`: re-point signal `entity_refs`, invoice and
  * bill links, source and knowledge links from a copy to its survivor, and
  * carry the copy's `external_ids` and `web_domains` to the survivor.
  */
 export declare const MERGE_REWRITE_REFS_FLAG = "checkpoint.ontology.merge-rewrite-refs";
-export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed";
-export type PairKind = "numbered" | "variants";
+export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed" | "listed_conflict";
+export type PairKind = "numbered" | "variants" | "listed";
 export interface CopySkip {
     copy: string;
     reason: CopySkipReason;
@@ -97,7 +108,7 @@ export interface CopyPlan extends CopyPair {
     /** Signal files whose `entity_refs` name the copy. */
     signal_refs: string[];
     /** Why the copy cannot be merged or deleted from here. */
-    held?: "signal_refs" | "linked_from_unwritable" | "merge_invalid" | "external_id_conflict";
+    held?: "signal_refs" | "linked_from_unwritable" | "merge_invalid" | "external_id_conflict" | "server_owned_refs";
     detail?: string;
     /** Keys added to the survivor. Set only when `rewriteRefs` is on. */
     add_external_ids?: string[];
@@ -133,7 +144,7 @@ export interface MergeCopiesReport {
     }[];
     /** Listed entries the finder did not produce. Absent unless `--only` was set. */
     only_unmatched?: ListedPair[];
-    /** Signal, source and knowledge files re-pointed at a survivor. Absent unless `rewriteRefs` was set. */
+    /** Knowledge files re-pointed at a survivor. Absent unless `rewriteRefs` was set. */
     rewritten?: string[];
     /** Entity-file links whose target file does not exist. */
     broken_links_before: number;
@@ -171,6 +182,14 @@ export declare function findVariantPairs(index: EntityIndex): {
     pairs: CopyPair[];
     skipped: CopySkip[];
 };
+/**
+ * The reviewed pairs themselves, for `pairKind: "listed"`. An entry is kept
+ * when both files are indexed entities of one writable type. Read-only.
+ */
+export declare function findListedPairs(index: EntityIndex, only: ListedPair[]): {
+    pairs: CopyPair[];
+    skipped: CopySkip[];
+};
 /**
  * Plan, merge or delete numbered copies for one company. The dry run writes
  * nothing; merge writes entity files only; delete removes vault keys and

package/dist/lib/checkpoint-ontology/merge-copies.js

@@ -27,16 +27,25 @@
  *
  * A signal whose `entity_refs` names a copy holds that copy: signals are
  * server-owned, so the ref cannot be re-pointed from here. With `rewriteRefs`
- * (flag `checkpoint.ontology.merge-rewrite-refs`) signal refs, invoice and
- * bill links, source and knowledge links are re-pointed at the survivor, the
- * survivor receives the copy's `external_ids` and `web_domains`, and only a
- * link from another copy or an external id conflict holds a pair.
+ * (flag `checkpoint.ontology.merge-rewrite-refs`) invoice and bill links and
+ * knowledge links are re-pointed at the survivor and the survivor receives
+ * the copy's `external_ids` and `web_domains`. A signal ref or a link from a
+ * source still holds the pair (`server_owned_refs`): the sync client cannot
+ * push those files. A link from another copy or an external id conflict also
+ * holds a pair.
  *
  * With `pairKind: "variants"` (flag `checkpoint.ontology.merge-variants`) the
  * pairs are two-file duplicate groups whose canonical names differ only in
  * case, spacing or punctuation; the survivor is the spaced name, then the
  * higher `signal_count`, then path order. The copy's canonical name becomes
  * an alias of the survivor. Merge and delete work as for numbered copies.
+ *
+ * With `pairKind: "listed"` (flag `checkpoint.ontology.merge-listed-pairs`)
+ * the pairs are exactly the `only` entries, reviewed by a person: no finder
+ * runs, so the names may differ. Each entry must name two entities of one
+ * type; a copy listed twice, or listed both as a copy and as an original, is
+ * skipped as `listed_conflict`. Holds, merge and delete work as for numbered
+ * copies.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -53,6 +62,8 @@ export const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
  * names differ only in spacing, case or punctuation (CO-65).
  */
 export const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
+/** `merge-copies --listed`: merge exactly the reviewed `--only` pairs (CO-74). */
+export const MERGE_LISTED_PAIRS_FLAG = "checkpoint.ontology.merge-listed-pairs";
 /**
  * `merge-copies --rewrite-refs`: re-point signal `entity_refs`, invoice and
  * bill links, source and knowledge links from a copy to its survivor, and
@@ -219,6 +230,36 @@ export function findVariantPairs(index) {
     pairs.sort((a, b) => a.copy.localeCompare(b.copy));
     return { pairs, skipped };
 }
+/**
+ * The reviewed pairs themselves, for `pairKind: "listed"`. An entry is kept
+ * when both files are indexed entities of one writable type. Read-only.
+ */
+export function findListedPairs(index, only) {
+    const pairs = [];
+    const skipped = [];
+    const copyCount = new Map();
+    for (const entry of only)
+        copyCount.set(entry.copy, (copyCount.get(entry.copy) ?? 0) + 1);
+    const originals = new Set(only.map((entry) => entry.original));
+    for (const entry of only) {
+        const copy = index.byRel.get(entry.copy);
+        const original = index.byRel.get(entry.original);
+        if (copyCount.get(entry.copy) > 1 || originals.has(entry.copy) || entry.copy === entry.original) {
+            skipped.push({ copy: entry.copy, reason: "listed_conflict" });
+        }
+        else if (!copy || !original) {
+            skipped.push({ copy: entry.copy, reason: index.invalid.has(entry.original) ? "original_invalid" : "no_original" });
+        }
+        else if (copy.type !== original.type || !isWritableEntityType(copy.type)) {
+            skipped.push({ copy: entry.copy, reason: "type_differs" });
+        }
+        else {
+            pairs.push({ type: copy.type, copy: entry.copy, original: entry.original });
+        }
+    }
+    pairs.sort((a, b) => a.copy.localeCompare(b.copy));
+    return { pairs, skipped };
+}
 /** Resolve a relative link in `fromRel` to a company-relative path, or null. */
 function resolveLink(fromRel, href) {
     if (/^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("#") || href.startsWith("/"))
@@ -525,76 +566,13 @@ function referencesCopy(fromRel, content, copy) {
     }
     return false;
 }
-function entityRefOf(rel) {
-    const [, , type, file] = rel.split("/");
-    return `${type}/${file.slice(0, -3)}`;
-}
-/** Re-point block-style `entity_refs` items from a copy to its survivor. */
-function rewriteSignalRefs(content, copyRef, originalRef) {
-    const front = frontLines(content);
-    if (!front)
-        return content;
-    const index = front.lines.findIndex((line) => /^entity_refs:\s*$/.test(line));
-    if (index === -1) {
-        const inline = front.lines.some((line) => /^entity_refs:\s*\S/.test(line));
-        if (inline && content.includes(copyRef))
-            return "signal_ref_format";
-        return content;
-    }
-    let end = index + 1;
-    // A block sequence may sit at the key's own indent: `entity_refs:\n- company/x`.
-    while (end < front.lines.length && (/^\s/.test(front.lines[end]) || /^- /.test(front.lines[end])))
-        end += 1;
-    const itemRe = /^(\s*)- (["']?)([^"'\n]+?)\2\s*$/;
-    const refs = [];
-    for (let i = index + 1; i < end; i += 1) {
-        const match = itemRe.exec(front.lines[i]);
-        if (!match)
-            continue;
-        const hadMd = match[3].endsWith(".md");
-        refs.push({
-            index: i,
-            value: hadMd ? match[3].slice(0, -3) : match[3],
-            hadMd,
-            indent: match[1],
-            quote: match[2],
-        });
-    }
-    const copyItems = refs.filter((item) => item.value === copyRef);
-    if (copyItems.length === 0)
-        return content;
-    const lines = [...front.lines];
-    const remove = new Set();
-    let seenOriginal = refs.some((item) => item.value === originalRef);
-    for (const item of copyItems) {
-        if (seenOriginal) {
-            remove.add(item.index);
-        }
-        else {
-            const value = item.hadMd ? `${originalRef}.md` : originalRef;
-            lines[item.index] = `${item.indent}- ${item.quote}${value}${item.quote}`;
-            seenOriginal = true;
-        }
-    }
-    const next = withFrontLines(content, front, lines.filter((_, i) => !remove.has(i)), fileNewline(content));
-    const oldParsed = parseEntityFile(content);
-    const newParsed = parseEntityFile(next);
-    if (!oldParsed || !newParsed || oldParsed.body !== newParsed.body)
-        return "signal_ref_format";
-    const keys = new Set([...Object.keys(oldParsed.frontmatter), ...Object.keys(newParsed.frontmatter)]);
-    for (const key of keys) {
-        if (key === "entity_refs")
-            continue;
-        if (!isDeepStrictEqual(oldParsed.frontmatter[key], newParsed.frontmatter[key]))
-            return "signal_ref_format";
-    }
-    const newRefs = newParsed.frontmatter.entity_refs;
-    if (!Array.isArray(newRefs) || !newRefs.every((ref) => typeof ref === "string"))
-        return "signal_ref_format";
-    const normalized = newRefs.map((ref) => (ref.endsWith(".md") ? ref.slice(0, -3) : ref));
-    if (!normalized.includes(originalRef) || normalized.includes(copyRef))
-        return "signal_ref_format";
-    return next;
+/**
+ * Signals and sources are written by the server pipeline and the sync
+ * client never pushes them, so a rewrite made here would not reach the
+ * vault (hq-cloud cloud-authoritative.ts).
+ */
+function isServerOwnedRel(rel) {
+    return rel.startsWith("signals/") || rel.startsWith("sources/");
 }
 const REF_KEYS = new Set(["system", "namespace", "objectType", "recordId"]);
 function refKey(ref) {
@@ -871,6 +849,7 @@ function plan(company, index, pairs, allPairs, now, rewriteRefs, resolutions = n
         const unwritable = rewriteRefs
             ? inbound.filter((rel) => copies.has(rel))
             : inbound.filter((rel) => !rel.startsWith("ontology/entities/") || !isWritableEntityType(rel.split("/")[2]) || copies.has(rel));
+        const serverOwned = rewriteRefs ? [...refs, ...inbound.filter(isServerOwnedRel)] : [];
         if (typeof merged === "string") {
             entry.held = "merge_invalid";
             entry.detail = merged;
@@ -879,6 +858,10 @@ function plan(company, index, pairs, allPairs, now, rewriteRefs, resolutions = n
             entry.held = "external_id_conflict";
             entry.detail = identity.conflicts.join(", ");
         }
+        else if (serverOwned.length > 0) {
+            entry.held = "server_owned_refs";
+            entry.detail = [...new Set(serverOwned)].sort().join(", ");
+        }
         else if (!rewriteRefs && refs.length > 0) {
             entry.held = "signal_refs";
         }
@@ -960,7 +943,13 @@ export async function mergeCopies(options) {
     const { hqRoot, company, mode, now } = options;
     const index = buildEntityIndex(company.dir);
     const pairKind = options.pairKind ?? "numbered";
-    const found = pairKind === "variants" ? findVariantPairs(index) : findCopyPairs(index);
+    if (pairKind === "listed" && !options.only)
+        throw new Error("merge-copies: listed pairs need an only list");
+    const found = pairKind === "listed"
+        ? findListedPairs(index, options.only)
+        : pairKind === "variants"
+            ? findVariantPairs(index)
+            : findCopyPairs(index);
     const listed = options.only
         ? found.pairs.filter((pair) => options.only.some((entry) => entry.copy === pair.copy && entry.original === pair.original))
         : found.pairs;
@@ -1060,28 +1049,6 @@ export async function mergeCopies(options) {
                     report.errors.push({ path: rel, error: error.name });
                 }
             }
-            if (!rewriteRefs)
-                continue;
-            const copyRef = entityRefOf(entry.copy);
-            const originalRef = entityRefOf(entry.original);
-            for (const rel of entry.signal_refs) {
-                try {
-                    const content = read(company, rel);
-                    const next = rewriteSignalRefs(content, copyRef, originalRef);
-                    if (next === "signal_ref_format") {
-                        report.errors.push({ path: rel, error: "signal_ref_format" });
-                        continue;
-                    }
-                    if (next === content)
-                        continue;
-                    safeWriteFile(hqRoot, [company.dir], path.join(company.dir, rel), next);
-                    if (!report.rewritten.includes(rel))
-                        report.rewritten.push(rel);
-                }
-                catch (error) {
-                    report.errors.push({ path: rel, error: error.name });
-                }
-            }
         }
     }
     if (mode === "delete") {

package/dist/lib/core-utils/sentry-report.js

@@ -677,13 +677,13 @@ function scrubbedSentryEnvelope(event, overrides, additionalTags = {}) {
         ...sentryEnvelope(event, overrides, additionalTags),
     }, {});
 }
-/** Keep all hook-timeout conditions together by script while retaining tags for triage. */
+/** Group hook-timeout conditions by normalized kind while retaining triage tags. */
 function hookTimeoutExceededOverrides(event) {
     if (!isHookTimeoutEvent(event))
         return undefined;
     return {
         level: "warning",
-        fingerprint: ["hook-timeout", hookScript(event.metadata)],
+        fingerprint: ["hook-timeout", hookTimeoutKind(event)],
     };
 }
 /**

package/dist/lib/daemon/flag.d.ts

@@ -6,6 +6,8 @@
 import { type FlagClientOptions, type FlagResolution } from "@indigoai-us/hq-flags-client";
 /** Outposts hand running services to the next daemon on a CLI update instead of restarting them all. */
 export declare const SUPERVISOR_HANDOFF_FLAG = "daemon.supervisor-handoff";
+/** Self-updates build the new CLI beside the running one and swap it in, so `hq` never disappears mid-update. */
+export declare const STAGED_SELF_UPDATE_FLAG = "cli.staged-self-update";
 export interface DaemonFlagClient {
     ready(): Promise<void>;
     explain(flagKey: string, options?: {

package/dist/lib/daemon/flag.js

@@ -9,6 +9,8 @@ import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 import { resolveProcessFlagCompanyContext } from "../flag-registry.js";
 /** Outposts hand running services to the next daemon on a CLI update instead of restarting them all. */
 export const SUPERVISOR_HANDOFF_FLAG = "daemon.supervisor-handoff";
+/** Self-updates build the new CLI beside the running one and swap it in, so `hq` never disappears mid-update. */
+export const STAGED_SELF_UPDATE_FLAG = "cli.staged-self-update";
 const READ_TIMEOUT_MS = 5_000;
 export async function readDaemonFlag(flagKey, options = {}) {
     const env = options.env ?? process.env;

package/dist/lib/daemon/run.d.ts

@@ -62,5 +62,16 @@ export declare function rotateLogs(logsDir: string, maxBytes?: number): number;
  * an on-failure unit down. The daemon's updater handles CLI updates.
  */
 export declare function unitProcessEnv(base: NodeJS.ProcessEnv, unit: UnitPlan): NodeJS.ProcessEnv;
+/**
+ * A systemd system unit starts the daemon as the login user without the
+ * variables a login session sets, so `systemctl --user` from its services
+ * cannot find the user bus ("Failed to connect to bus: No medium found").
+ * Point them at the user's runtime dir when it exists and nothing set one.
+ */
+export declare function withUserRuntimeDir(env: NodeJS.ProcessEnv, host: {
+    platform: NodeJS.Platform;
+    uid: number;
+    exists: (dir: string) => boolean;
+}): NodeJS.ProcessEnv;
 export declare function runDaemon(opts: RunDaemonOptions): Promise<number>;
 //# sourceMappingURL=run.d.ts.map

package/dist/lib/daemon/run.js

@@ -233,8 +233,24 @@ function isFifo(file) {
         return false;
     }
 }
+/**
+ * A systemd system unit starts the daemon as the login user without the
+ * variables a login session sets, so `systemctl --user` from its services
+ * cannot find the user bus ("Failed to connect to bus: No medium found").
+ * Point them at the user's runtime dir when it exists and nothing set one.
+ */
+export function withUserRuntimeDir(env, host) {
+    if (host.platform !== "linux" || host.uid === 0 || env.XDG_RUNTIME_DIR)
+        return env;
+    const dir = `/run/user/${host.uid}`;
+    return host.exists(dir) ? { ...env, XDG_RUNTIME_DIR: dir } : env;
+}
 export async function runDaemon(opts) {
-    const env = opts.env ?? process.env;
+    const env = withUserRuntimeDir(opts.env ?? process.env, {
+        platform: process.platform,
+        uid: process.getuid?.() ?? -1,
+        exists: fs.existsSync,
+    });
     const home = opts.home ?? os.homedir();
     const platform = process.platform;
     const paths = daemonPaths(home, env);

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

@@ -12,8 +12,9 @@ export interface RegisteredLead {
     status: string;
     prd: string;
 }
+export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane";
 export interface AutopilotWake {
-    condition: "review_finished_worker" | "fill_grant";
+    condition: AutopilotCondition;
     lead_lane: string;
     story_id: string;
     worker_lane?: string;
@@ -30,6 +31,14 @@ export interface AutopilotPassResult {
         story_id: string;
         worker_lane: string;
     }>;
+    escalated: Array<{
+        team: string;
+        lead_lane: string;
+        condition: AutopilotCondition;
+        story_id: string;
+        at: string;
+        fingerprint: string;
+    }>;
     skipped: Array<{
         lead_lane: string;
         reason: string;
@@ -38,15 +47,18 @@ export interface AutopilotPassResult {
 interface ProjectStory {
     id: string;
     status: string;
+    passes?: boolean;
     briefPath?: string;
     laneIds?: string[];
     updatedAt?: string;
+    externalBlocker?: string;
 }
 export declare function planLeadAutopilotWakes(input: {
     lead: LaneRecord;
     children: readonly LaneRecord[];
     stories: readonly ProjectStory[];
     now: Date;
+    managerStatus?: Record<string, unknown>;
     keepAliveResumed?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {