@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/checkpoint-ontology/company-brief.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deterministic `company-brief.md` for one company.
+ *
+ * The cloud gardener used to write this file. The checkpoint renders the same
+ * shape from the local ontology with no model call. Signal dates come from
+ * `sources/_index`, because signal files have no `created_at`.
+ */
+import { type OntologyCompany } from "./company.js";
+export declare const COMPANY_BRIEF_FILE = "company-brief.md";
+export interface CompanyBriefResult {
+    status: "written" | "unchanged" | "skipped" | "failed";
+    /** Set for skipped and failed. */
+    reason?: string;
+}
+/** `null` when fewer than three valid person, project, company, or concept entities exist. */
+export declare function renderCompanyBrief(company: OntologyCompany, now: Date): string | null;
+export declare function writeCompanyBrief(hqRoot: string, company: OntologyCompany, now: Date): CompanyBriefResult;
+//# sourceMappingURL=company-brief.d.ts.map

package/dist/lib/checkpoint-ontology/company-brief.js

@@ -0,0 +1,337 @@
+/**
+ * Deterministic `company-brief.md` for one company.
+ *
+ * The cloud gardener used to write this file. The checkpoint renders the same
+ * shape from the local ontology with no model call. Signal dates come from
+ * `sources/_index`, because signal files have no `created_at`.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeWriteFile, WriteBoundsError } from "./company.js";
+import { parseEntityFile, validateEntityFrontmatter } from "./entity-file.js";
+export const COMPANY_BRIEF_FILE = "company-brief.md";
+const SIGNAL_TYPES = [
+    { dir: "decision", heading: "Decisions" },
+    { dir: "risk", heading: "Risks" },
+    { dir: "question", heading: "Questions" },
+];
+const ENTITY_TYPES = [
+    { dir: "person", heading: "People" },
+    { dir: "project", heading: "Projects" },
+    { dir: "company", heading: "Companies" },
+    { dir: "concept", heading: "Concepts" },
+];
+const CHANNELS = [
+    { id: "meeting", label: "Meeting" },
+    { id: "email", label: "Email" },
+    { id: "slack", label: "Slack" },
+    { id: "slack-dm", label: "Slack DM" },
+    { id: "linear", label: "Linear" },
+    { id: "notion", label: "Notion" },
+];
+const NO_SOURCES = "<!-- source channels: no sources/_index entries in last 7d -->";
+const SIGNAL_PREVIEW_MAX = 160;
+const SIGNAL_TOP = 5;
+const ENTITY_TOP = 8;
+/** Cloud budget: `floor(2000 * 0.4)` reserved tokens, minus the source block. */
+const SIGNAL_TOKEN_RESERVE = Math.floor(2000 * 0.4);
+const MIN_ENTITIES = 3;
+function byCodeUnit(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function tokenCount(text) {
+    return Math.ceil(text.length / 4);
+}
+/** UTC dates `now`, `now − 1 day`, … from the epoch day, not the local calendar. */
+function windowDates(now) {
+    const day = Math.floor(now.getTime() / 86_400_000);
+    const dates = [];
+    for (let i = 0; i < 7; i += 1)
+        dates.push(new Date((day - i) * 86_400_000).toISOString().slice(0, 10));
+    return dates;
+}
+/**
+ * `false` when `dir` does not exist. Throws when it resolves outside the company:
+ * a symlinked directory would otherwise copy another company's files into this brief.
+ */
+function readableInside(companyDir, dir) {
+    let real;
+    try {
+        real = fs.realpathSync(dir);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    const relative = path.relative(fs.realpathSync(companyDir), real);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new WriteBoundsError(`${path.relative(companyDir, dir)} resolves outside the company`);
+    }
+    return true;
+}
+function listDirectMd(companyDir, dir) {
+    if (!readableInside(companyDir, dir))
+        return [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const names = [];
+    for (const entry of entries) {
+        // Files only. A directory whose name starts with `@` or `_` is never entered.
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        names.push(entry.name);
+    }
+    names.sort(byCodeUnit);
+    return names;
+}
+/** `null` when the file is missing, unparsable, or not a JSON array. */
+function readIndexArray(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        throw error;
+    }
+}
+function indexKey(entry) {
+    const keys = entry.keys;
+    const markdown = keys && typeof keys === "object" && !Array.isArray(keys)
+        ? keys.markdown
+        : undefined;
+    if (typeof markdown === "string" && markdown.length > 0)
+        return markdown;
+    const sourceRef = entry.source_ref;
+    const fallback = sourceRef && typeof sourceRef === "object" && !Array.isArray(sourceRef)
+        ? sourceRef.key
+        : undefined;
+    return typeof fallback === "string" && fallback.length > 0 ? fallback : null;
+}
+function mapChannel(value) {
+    if (value === "meeting" || value === "meetings")
+        return "meeting";
+    if (value === "email" || value === "slack" || value === "slack-dm" || value === "linear" || value === "notion") {
+        return value;
+    }
+    return null;
+}
+function loadSources(companyDir, now) {
+    const times = new Map();
+    const counts = new Map();
+    const dir = path.join(companyDir, "sources", "_index");
+    // Regular files only: a symlinked index file could point at another company's index.
+    const names = readableInside(companyDir, dir)
+        ? fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name)
+            .sort(byCodeUnit)
+        : [];
+    const windowFiles = new Set(windowDates(now).map((date) => `${date}.json`));
+    for (const name of names) {
+        const entries = readIndexArray(path.join(dir, name));
+        if (!entries)
+            continue;
+        const inWindow = windowFiles.has(name);
+        for (const entry of entries) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const record = entry;
+            const key = indexKey(record);
+            if (key && typeof record.written_at === "string")
+                times.set(key, record.written_at);
+            if (!inWindow)
+                continue;
+            const channel = mapChannel(record.channel);
+            if (channel)
+                counts.set(channel, (counts.get(channel) ?? 0) + 1);
+        }
+    }
+    return { times, counts };
+}
+function loadSignals(companyDir, times) {
+    const items = [];
+    for (const type of SIGNAL_TYPES) {
+        const dir = path.join(companyDir, "signals", type.dir);
+        for (const name of listDirectMd(companyDir, dir)) {
+            const parsed = parseEntityFile(fs.readFileSync(path.join(dir, name), "utf8"));
+            if (!parsed)
+                continue;
+            const content = parsed.frontmatter.canonical_content;
+            if (typeof content !== "string" || content.length === 0)
+                continue;
+            const sourceRef = parsed.frontmatter.source_ref;
+            const time = typeof sourceRef === "string" ? times.get(sourceRef) ?? null : null;
+            items.push({ type: type.dir, rel: `signals/${type.dir}/${name}`, content, time });
+        }
+    }
+    return items;
+}
+function compareSignals(a, b) {
+    if (a.time !== null && b.time !== null) {
+        if (a.time !== b.time)
+            return a.time < b.time ? 1 : -1;
+    }
+    else if (a.time !== b.time) {
+        return a.time === null ? 1 : -1;
+    }
+    if (a.rel !== b.rel)
+        return a.rel < b.rel ? 1 : -1;
+    return 0;
+}
+function previewContent(content) {
+    const collapsed = content.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= SIGNAL_PREVIEW_MAX)
+        return collapsed;
+    return `${collapsed.slice(0, SIGNAL_PREVIEW_MAX).trimEnd()}…`;
+}
+function renderSignalBlock(items) {
+    const sections = [];
+    for (const type of SIGNAL_TYPES) {
+        const rows = items.filter((item) => item.type === type.dir);
+        if (rows.length === 0)
+            continue;
+        const lines = rows.map((item) => {
+            const base = `- [${previewContent(item.content)}](${item.rel})`;
+            return item.time ? `${base} _(${item.time.slice(0, 10)})_` : base;
+        });
+        sections.push(`### ${type.heading}\n${lines.join("\n")}`);
+    }
+    if (sections.length === 0)
+        return null;
+    return ["## Recent Signals", ...sections].join("\n\n").trimEnd();
+}
+function confidenceOf(frontmatter) {
+    const value = frontmatter.confidence;
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : 0;
+}
+function compareEntities(a, b) {
+    if (a.score !== b.score)
+        return b.score - a.score;
+    if (a.name !== b.name)
+        return a.name < b.name ? -1 : 1;
+    if (a.file !== b.file)
+        return a.file < b.file ? -1 : 1;
+    return 0;
+}
+function loadEntities(companyDir) {
+    let total = 0;
+    const groups = [];
+    for (const type of ENTITY_TYPES) {
+        const dir = path.join(companyDir, "ontology", "entities", type.dir);
+        const items = [];
+        for (const name of listDirectMd(companyDir, dir)) {
+            const parsed = parseEntityFile(fs.readFileSync(path.join(dir, name), "utf8"));
+            if (!parsed)
+                continue;
+            const valid = validateEntityFrontmatter(parsed.frontmatter);
+            if (typeof valid === "string")
+                continue;
+            items.push({
+                file: name,
+                name: valid.canonical_name,
+                signalCount: valid.signal_count,
+                score: valid.signal_count * confidenceOf(parsed.frontmatter),
+            });
+        }
+        total += items.length;
+        items.sort(compareEntities);
+        groups.push({
+            heading: type.heading,
+            lines: items.slice(0, ENTITY_TOP).map((item) => `- [${item.name}](ontology/entities/${type.dir}/${item.file}) (${item.signalCount} signals)`),
+        });
+    }
+    return { total, groups };
+}
+function renderEntityBlock(slug, groups) {
+    const parts = [
+        `# ${slug} company brief`,
+        "_Rendered by hq core checkpoint from the local ontology._",
+        "## Key Entities",
+    ];
+    for (const group of groups) {
+        if (group.lines.length === 0)
+            continue;
+        parts.push(`### ${group.heading}\n${group.lines.join("\n")}`);
+    }
+    return parts.join("\n\n");
+}
+function renderSourceBlock(counts) {
+    const total = CHANNELS.reduce((sum, channel) => sum + (counts.get(channel.id) ?? 0), 0);
+    if (total === 0)
+        return NO_SOURCES;
+    const rows = CHANNELS.map((channel) => `| ${channel.label} | ${counts.get(channel.id) ?? 0} |`);
+    return ["## Source Channels", "", "_Last 7 days_", "", "| Channel | Count |", "| --- | ---: |", ...rows].join("\n");
+}
+function fitSignals(ranked, budget) {
+    const kept = ranked.slice();
+    while (kept.length > 0) {
+        const block = renderSignalBlock(kept);
+        if (block === null || tokenCount(block) <= budget)
+            break;
+        kept.pop();
+    }
+    return kept;
+}
+/** `null` when fewer than three valid person, project, company, or concept entities exist. */
+export function renderCompanyBrief(company, now) {
+    const entities = loadEntities(company.dir);
+    if (entities.total < MIN_ENTITIES)
+        return null;
+    const sources = loadSources(company.dir, now);
+    const signals = loadSignals(company.dir, sources.times);
+    const ranked = [];
+    for (const type of SIGNAL_TYPES) {
+        ranked.push(...signals.filter((item) => item.type === type.dir).sort(compareSignals).slice(0, SIGNAL_TOP));
+    }
+    const sourceBlock = renderSourceBlock(sources.counts);
+    const budget = Math.max(0, SIGNAL_TOKEN_RESERVE - tokenCount(sourceBlock));
+    const signalBlock = renderSignalBlock(fitSignals(ranked, budget));
+    const blocks = [renderEntityBlock(company.slug, entities.groups)];
+    if (signalBlock)
+        blocks.push(signalBlock);
+    blocks.push(sourceBlock);
+    return `${blocks.join("\n\n")}\n`;
+}
+export function writeCompanyBrief(hqRoot, company, now) {
+    try {
+        const content = renderCompanyBrief(company, now);
+        if (content === null)
+            return { status: "skipped", reason: "fewer than 3 entities" };
+        const target = path.join(company.dir, COMPANY_BRIEF_FILE);
+        let existing = null;
+        try {
+            // Never follow a symlinked brief for the equality check; safeWriteFile rejects it below.
+            if (!fs.lstatSync(target).isSymbolicLink())
+                existing = fs.readFileSync(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (existing && existing.equals(Buffer.from(content, "utf8")))
+            return { status: "unchanged" };
+        safeWriteFile(hqRoot, [company.dir], target, content);
+        return { status: "written" };
+    }
+    catch (error) {
+        const failed = error;
+        return { status: "failed", reason: `${failed.name}: ${failed.message}` };
+    }
+}
+//# sourceMappingURL=company-brief.js.map

package/dist/lib/checkpoint-ontology/company.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Company resolution and write bounds for checkpoint ontology.
+ *
+ * The company always comes from the checkpoint payload and must be a key of
+ * `companies/manifest.yaml` with a directory at `companies/<slug>/`. Every
+ * write goes through {@link safeWriteFile}, which refuses any target whose
+ * real path leaves the allowed roots.
+ */
+export interface OntologyCompany {
+    slug: string;
+    /** The hq-flags company uid, or null when the company is local-only. */
+    cloudUid: string | null;
+    /** `<hqRoot>/companies/<slug>` */
+    dir: string;
+}
+export type CompanyResolution = {
+    ok: true;
+    company: OntologyCompany;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function resolveOntologyCompany(hqRoot: string, slug: string | null | undefined): CompanyResolution;
+/** The entity root (`companies/<co>/ontology/entities`) of a company. */
+export declare function entitiesRoot(company: OntologyCompany): string;
+/** The machine-local, unsynced state directory for a company. */
+export declare function stateRoot(hqRoot: string, company: OntologyCompany): string;
+export declare class WriteBoundsError extends Error {
+    constructor(message: string);
+}
+/**
+ * Resolve `target` only when it stays inside one of `roots` with no symlink
+ * anywhere between `anchor` (the HQ root) and the file. A root or a directory
+ * under it that is a symlink fails closed, and so does a target that is itself
+ * a symlink. Missing directories are created only after that check.
+ */
+export declare function assertSafeTarget(anchor: string, roots: string[], target: string): string;
+/**
+ * Write `content` to `target` only when {@link assertSafeTarget} accepts it.
+ * The file is written to a temporary sibling and renamed, so a reader never
+ * sees half a file.
+ */
+export declare function safeWriteFile(anchor: string, roots: string[], target: string, content: string): void;
+//# sourceMappingURL=company.d.ts.map

package/dist/lib/checkpoint-ontology/company.js

@@ -0,0 +1,118 @@
+/**
+ * Company resolution and write bounds for checkpoint ontology.
+ *
+ * The company always comes from the checkpoint payload and must be a key of
+ * `companies/manifest.yaml` with a directory at `companies/<slug>/`. Every
+ * write goes through {@link safeWriteFile}, which refuses any target whose
+ * real path leaves the allowed roots.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import yaml from "js-yaml";
+const SLUG_RE = /^[a-z0-9][a-z0-9_-]*$/;
+export function resolveOntologyCompany(hqRoot, slug) {
+    if (!slug)
+        return { ok: false, reason: "no company" };
+    if (!SLUG_RE.test(slug))
+        return { ok: false, reason: "invalid company" };
+    let manifest;
+    try {
+        manifest = yaml.load(fs.readFileSync(path.join(hqRoot, "companies", "manifest.yaml"), "utf8"), {
+            schema: yaml.CORE_SCHEMA,
+        });
+    }
+    catch (error) {
+        return { ok: false, reason: `manifest unreadable (${error.name})` };
+    }
+    const companies = manifest?.companies;
+    const entry = companies && Object.prototype.hasOwnProperty.call(companies, slug) ? companies[slug] : undefined;
+    if (!entry || typeof entry !== "object")
+        return { ok: false, reason: "company not in manifest" };
+    const dir = path.join(hqRoot, "companies", slug);
+    let stat;
+    try {
+        stat = fs.lstatSync(dir);
+    }
+    catch {
+        return { ok: false, reason: "company directory missing" };
+    }
+    if (!stat.isDirectory())
+        return { ok: false, reason: "company directory missing" };
+    const uid = entry.cloud_uid;
+    return { ok: true, company: { slug, cloudUid: typeof uid === "string" && uid.trim() ? uid.trim() : null, dir } };
+}
+/** The entity root (`companies/<co>/ontology/entities`) of a company. */
+export function entitiesRoot(company) {
+    return path.join(company.dir, "ontology", "entities");
+}
+/** The machine-local, unsynced state directory for a company. */
+export function stateRoot(hqRoot, company) {
+    return path.join(hqRoot, "workspace", "checkpoints", "ontology", company.slug);
+}
+export class WriteBoundsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WriteBoundsError";
+    }
+}
+function isInside(root, target) {
+    const relative = path.relative(root, target);
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+/** The nearest existing ancestor of `target` (or `target` itself). */
+function nearestExisting(target) {
+    let current = target;
+    while (!fs.existsSync(current)) {
+        const up = path.dirname(current);
+        if (up === current)
+            return current;
+        current = up;
+    }
+    return current;
+}
+/**
+ * Resolve `target` only when it stays inside one of `roots` with no symlink
+ * anywhere between `anchor` (the HQ root) and the file. A root or a directory
+ * under it that is a symlink fails closed, and so does a target that is itself
+ * a symlink. Missing directories are created only after that check.
+ */
+export function assertSafeTarget(anchor, roots, target) {
+    const resolved = path.resolve(target);
+    const root = roots.map((candidate) => path.resolve(candidate)).find((candidate) => isInside(candidate, resolved));
+    if (!root)
+        throw new WriteBoundsError(`refusing write outside the ontology bounds: ${target}`);
+    const realAnchor = fs.realpathSync(anchor);
+    const expected = (dir) => path.join(realAnchor, path.relative(path.resolve(anchor), dir));
+    const parent = path.dirname(resolved);
+    const existing = nearestExisting(parent);
+    if (fs.realpathSync(existing) !== expected(existing)) {
+        throw new WriteBoundsError(`refusing write through a symlink: ${target}`);
+    }
+    if (!isInside(path.resolve(anchor), existing) && existing !== path.resolve(anchor)) {
+        throw new WriteBoundsError(`refusing write outside the HQ root: ${target}`);
+    }
+    fs.mkdirSync(parent, { recursive: true });
+    try {
+        if (fs.lstatSync(resolved).isSymbolicLink()) {
+            throw new WriteBoundsError(`refusing write to a symlink: ${target}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return path.resolve(target);
+}
+/**
+ * Write `content` to `target` only when {@link assertSafeTarget} accepts it.
+ * The file is written to a temporary sibling and renamed, so a reader never
+ * sees half a file.
+ */
+export function safeWriteFile(anchor, roots, target, content) {
+    const resolved = assertSafeTarget(anchor, roots, target);
+    const parent = path.dirname(resolved);
+    const tmp = path.join(parent, `.${path.basename(resolved)}.${process.pid}.tmp`);
+    fs.writeFileSync(tmp, content);
+    fs.renameSync(tmp, resolved);
+}
+//# sourceMappingURL=company.js.map

package/dist/lib/checkpoint-ontology/drop-aliases.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `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 { type OntologyCompany } from "./company.js";
+export declare const DROP_ALIASES_FLAG = "checkpoint.ontology.drop-aliases";
+/** One reviewed removal: `entity` is a company-relative entity path. */
+export interface AliasDrop {
+    entity: string;
+    alias: string;
+}
+export type AliasDropSkipReason = "no_entity" | "type_not_writable" | "alias_absent" | "patch_failed";
+export interface AliasDropReport {
+    company: string;
+    mode: "dry_run" | "apply";
+    duplicate_groups_before: number;
+    duplicate_groups_after: number;
+    /** Entity -> aliases removed (dry run: would be removed). */
+    planned: Record<string, string[]>;
+    written: string[];
+    skipped: Array<AliasDrop & {
+        reason: AliasDropSkipReason;
+        detail?: string;
+    }>;
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+export interface DropAliasesOptions {
+    hqRoot: string;
+    company: OntologyCompany;
+    mode: "dry_run" | "apply";
+    drops: AliasDrop[];
+    now: Date;
+}
+export declare function dropAliases(options: DropAliasesOptions): AliasDropReport;
+//# sourceMappingURL=drop-aliases.d.ts.map

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