@indigoai-us/hq-cli 5.220.0 → 5.222.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [5.222.0] — 2026-09-26
+
+- Checkpoint ontology, behind `checkpoint.ontology.multi-writer` (off by
+  default): entity versions that sync set aside after losing a push race are
+  merged back at the start of each plan (aliases, back-references, the higher
+  `signal_count`, the later `last_updated`). Any other difference keeps both
+  and leaves the set-aside copy, and an entity deleted since is not
+  re-created. Every entity file the step writes is recorded in
+  `.hq/ontology-outbox/<company>.json`. The apply report counts duplicate
+  entity groups, and `hq core ontology duplicates --company <slug> [--json]`
+  lists them.
+
+## [5.221.0] — 2026-09-26
+
+### Added
+
+- `hq lanes report` prints the company-scoped owner report and `hq lanes team
+  <slug>` shows OKRs, KPI trends, work, blockers, and questions. Successful
+  reports save their per-company report time for the next report and team page.
+  PR, release, and deployment references on stories may be strings, integers,
+  or objects. Only timestamped objects count as activity. Invalid rows appear
+  under their team's errors, set exit status 2, and leave the saved report time
+  unchanged.
+
 ## [5.220.0] — 2026-09-26
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -5124,6 +5124,24 @@ export declare const COMMAND_CATALOG: readonly [{
                 readonly description: "HQ installation to operate on";
             }];
             readonly subcommands: readonly [];
+        }, {
+            readonly name: "duplicates";
+            readonly description: "List same-type entities whose names collide, with a proposed survivor (read-only)";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly usage: "[options]";
+            readonly arguments: readonly [];
+            readonly options: readonly [{
+                readonly flags: "--company <slug>";
+                readonly description: "company to scan";
+            }, {
+                readonly flags: "--json";
+                readonly description: "print JSON";
+            }, {
+                readonly flags: "--hq-root <path>";
+                readonly description: "HQ installation to operate on";
+            }];
+            readonly subcommands: readonly [];
         }, {
             readonly name: "apply";
             readonly description: "Validate the run's entity candidates and write them to the payload company";
@@ -7257,6 +7275,43 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "JSON on stdout (always)";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "report";
+        readonly description: "Generate the owner report for tracker teams";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options]";
+        readonly arguments: readonly [];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Select the company by slug";
+        }, {
+            readonly flags: "--since <iso>";
+            readonly description: "Report activity from this ISO timestamp";
+        }, {
+            readonly flags: "--json";
+            readonly description: "Emit JSON instead of the owner report text";
+        }];
+        readonly subcommands: readonly [];
+    }, {
+        readonly name: "team";
+        readonly description: "Show a team's OKRs, KPIs, work, blockers, and questions";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] <slug>";
+        readonly arguments: readonly [{
+            readonly name: "slug";
+            readonly required: true;
+            readonly variadic: false;
+        }];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Select the company by slug";
+        }, {
+            readonly flags: "--json";
+            readonly description: "Emit JSON instead of the team page text";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "outpost-pruner";
         readonly description: "Inspect, install, and run safe outpost worktree pruning";

package/dist/command-catalog.generated.js

@@ -6626,6 +6626,29 @@ export const COMMAND_CATALOG = [
                         ],
                         "subcommands": []
                     },
+                    {
+                        "name": "duplicates",
+                        "description": "List same-type entities whose names collide, with a proposed survivor (read-only)",
+                        "aliases": [],
+                        "hidden": false,
+                        "usage": "[options]",
+                        "arguments": [],
+                        "options": [
+                            {
+                                "flags": "--company <slug>",
+                                "description": "company to scan"
+                            },
+                            {
+                                "flags": "--json",
+                                "description": "print JSON"
+                            },
+                            {
+                                "flags": "--hq-root <path>",
+                                "description": "HQ installation to operate on"
+                            }
+                        ],
+                        "subcommands": []
+                    },
                     {
                         "name": "apply",
                         "description": "Validate the run's entity candidates and write them to the payload company",
@@ -9381,6 +9404,54 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "report",
+                "description": "Generate the owner report for tracker teams",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options]",
+                "arguments": [],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Select the company by slug"
+                    },
+                    {
+                        "flags": "--since <iso>",
+                        "description": "Report activity from this ISO timestamp"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "Emit JSON instead of the owner report text"
+                    }
+                ],
+                "subcommands": []
+            },
+            {
+                "name": "team",
+                "description": "Show a team's OKRs, KPIs, work, blockers, and questions",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] <slug>",
+                "arguments": [
+                    {
+                        "name": "slug",
+                        "required": true,
+                        "variadic": false
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Select the company by slug"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "Emit JSON instead of the team page text"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "outpost-pruner",
                 "description": "Inspect, install, and run safe outpost worktree pruning",

package/dist/commands/core-ontology.d.ts

@@ -18,5 +18,11 @@ export interface OntologyCommandDeps {
 }
 export declare function runOntologyPlan(hqRoot: string, runDirOption: string | undefined, deps?: OntologyCommandDeps): Promise<string>;
 export declare function runOntologyApply(hqRoot: string, runDirOption: string | undefined, deps?: OntologyCommandDeps): string;
+/**
+ * `hq core ontology duplicates`: every group of same-type entities whose
+ * names collide, with a proposed survivor. Read-only; gated by
+ * `checkpoint.ontology.multi-writer`.
+ */
+export declare function runOntologyDuplicates(hqRoot: string, slug: string | undefined, json: boolean, deps?: OntologyCommandDeps): Promise<string>;
 export declare function registerCoreOntologyCommand(core: Command): void;
 //# sourceMappingURL=core-ontology.d.ts.map

package/dist/commands/core-ontology.js

@@ -11,9 +11,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
-import { planOntologyRun } from "../lib/checkpoint-ontology/plan.js";
+import { MULTI_WRITER_FLAG, planOntologyRun, } from "../lib/checkpoint-ontology/plan.js";
 import { applyOntologyRun, ApplyError } from "../lib/checkpoint-ontology/apply.js";
-import { WriteBoundsError } from "../lib/checkpoint-ontology/company.js";
+import { resolveOntologyCompany, WriteBoundsError } from "../lib/checkpoint-ontology/company.js";
+import { findDuplicateGroups, summarizeMergeBack, } from "../lib/checkpoint-ontology/multi-writer.js";
+import { buildEntityIndex } from "../lib/checkpoint-ontology/tree.js";
 export const ONTOLOGY_PAYLOAD_FILE = "payload.json";
 class OntologyUsageError extends Error {
 }
@@ -49,6 +51,16 @@ function companyBriefSuffix(brief) {
         return "";
     return `; company brief ${brief.status}${brief.reason ? ` (${brief.reason})` : ""}`;
 }
+function multiWriterSuffix(start) {
+    if (!start)
+        return "";
+    const parts = [];
+    if (start.merge_back.length > 0)
+        parts.push(`set-aside versions: ${summarizeMergeBack(start.merge_back)}`);
+    if (start.error)
+        parts.push(`multi-writer error ${start.error}`);
+    return parts.length > 0 ? `; ${parts.join("; ")}` : "";
+}
 export async function runOntologyPlan(hqRoot, runDirOption, deps = {}) {
     const runDir = requireRunDir(runDirOption);
     const outcome = await planOntologyRun({
@@ -59,12 +71,13 @@ export async function runOntologyPlan(hqRoot, runDirOption, deps = {}) {
         now: deps.now?.(),
     });
     if (outcome.status === "skipped") {
-        return `ontology: skipped (${outcome.reason})${companyBriefSuffix(outcome.companyBrief)}`;
+        return `ontology: skipped (${outcome.reason})${companyBriefSuffix(outcome.companyBrief)}${multiWriterSuffix(outcome.multiWriter)}`;
     }
     const { plan } = outcome;
     return (`ontology: planned ${plan.inputs.length} input(s), ~${plan.budget.planned_tokens} tokens, ` +
         `${plan.pending_after_run} left for later runs; plan at ${outcome.planPath}` +
-        companyBriefSuffix(outcome.companyBrief));
+        companyBriefSuffix(outcome.companyBrief) +
+        multiWriterSuffix(plan.multi_writer));
 }
 export function runOntologyApply(hqRoot, runDirOption, deps = {}) {
     const runDir = requireRunDir(runDirOption);
@@ -78,7 +91,36 @@ export function runOntologyApply(hqRoot, runDirOption, deps = {}) {
     return (`ontology: ${report.created.length} created, ${report.updated.length} updated, ` +
         `${report.matched} matched, ${report.rejected.length} rejected, ${report.deferred.length} deferred, ` +
         `${report.suspect_duplicates.length} suspect duplicate(s), ${report.write_errors.length} write error(s)` +
-        companyBriefSuffix(report.company_brief));
+        companyBriefSuffix(report.company_brief) +
+        (report.multi_writer?.duplicates ? `; ${report.multi_writer.duplicates.groups} duplicate group(s) in the company` : "") +
+        (report.multi_writer?.error ? `; multi-writer error ${report.multi_writer.error}` : ""));
+}
+/**
+ * `hq core ontology duplicates`: every group of same-type entities whose
+ * names collide, with a proposed survivor. Read-only; gated by
+ * `checkpoint.ontology.multi-writer`.
+ */
+export async function runOntologyDuplicates(hqRoot, slug, json, deps = {}) {
+    const resolution = resolveOntologyCompany(hqRoot, slug);
+    if (!resolution.ok)
+        throw new OntologyUsageError(`ontology: company rejected: ${resolution.reason}`);
+    const company = resolution.company;
+    if (!(await (deps.readFlag ?? registryFlagReader)(MULTI_WRITER_FLAG, company))) {
+        return json ? JSON.stringify({ company: company.slug, skipped: "flag off" }) : `ontology duplicates: skipped (${MULTI_WRITER_FLAG} is off)`;
+    }
+    const groups = findDuplicateGroups(buildEntityIndex(company.dir));
+    if (json)
+        return JSON.stringify({ company: company.slug, groups }, null, 2);
+    if (groups.length === 0)
+        return `ontology duplicates: none in ${company.slug}`;
+    const lines = [`ontology duplicates: ${groups.length} group(s) in ${company.slug}`];
+    for (const group of groups) {
+        lines.push(`${group.type} (${group.reason.replaceAll("_", " ")}), keep ${group.survivor}`);
+        for (const rel of group.paths)
+            if (rel !== group.survivor)
+                lines.push(`  ${rel}`);
+    }
+    return lines.join("\n");
 }
 function fail(error) {
     if (error instanceof OntologyUsageError || error instanceof ApplyError || error instanceof WriteBoundsError) {
@@ -105,6 +147,20 @@ export function registerCoreOntologyCommand(core) {
             fail(error);
         }
     });
+    ontology
+        .command("duplicates")
+        .description("List same-type entities whose names collide, with a proposed survivor (read-only)")
+        .requiredOption("--company <slug>", "company to scan")
+        .option("--json", "print JSON")
+        .option("--hq-root <path>", "HQ installation to operate on")
+        .action(async (options) => {
+        try {
+            process.stdout.write(`${await runOntologyDuplicates(rootFor(options), options.company, options.json === true)}\n`);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
     ontology
         .command("apply")
         .description("Validate the run's entity candidates and write them to the payload company")

package/dist/commands/lanes-checks.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
-import type { LaneCompanyRef } from "../lib/lanes/types.js";
-interface LaneChecksDeps {
+import { type TrackerKind, type TrackerRecord } from "../lib/lanes/tracker-store.js";
+import type { LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
+export interface LaneChecksDeps {
     hqRoot: () => string;
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
     trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
@@ -8,6 +9,39 @@ interface LaneChecksDeps {
     now: () => Date;
 }
 type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export interface ProjectMapping {
+    projectId: string;
+    team: string;
+    leadLaneId?: string;
+    statusPath: string;
+}
+export interface ProjectReadResult {
+    stories: Array<Record<string, unknown>>;
+    mtime: number;
+    errors?: Array<{
+        path: string;
+        field: string;
+        message: string;
+        story_id?: string;
+    }>;
+}
+export declare function loadProjectMappings(root: string, company: string, requestedProject?: string): Map<string, ProjectMapping>;
+export declare function readProject(root: string, company: string, prdPath: string, tolerantStories?: boolean): ProjectReadResult;
+export declare function loadCompanyQuestionRecords(root: string, company: LaneCompanyRef, projectId?: string): QuestionRecord[];
+export declare function pathForTrackerRecord(projectDirectory: string, kind: TrackerKind, id: string): string;
+export declare function listTrackerRecords(projectDirectory: string, kind: TrackerKind): TrackerRecord[];
+export interface TolerantTrackerReadIssue {
+    path: string;
+    field: string;
+    message: string;
+    record_id?: string;
+}
+/** Report loader that preserves valid records while making every unreadable file visible. */
+export declare function listTrackerRecordsTolerant(projectDirectory: string, kind: TrackerKind): {
+    records: TrackerRecord[];
+    errors: TolerantTrackerReadIssue[];
+};
+export declare function resolveTrackerCompany(deps: LaneChecksDeps, requested?: string): Promise<LaneCompanyRef>;
 export declare function registerLaneChecksCommand(parent: Command, deps: LaneChecksDeps, wrap: WrapHandler): void;
 export {};
 //# sourceMappingURL=lanes-checks.d.ts.map

package/dist/commands/lanes-checks.js

@@ -171,7 +171,7 @@ function projectHasTrackerRecords(root, company, projectId) {
     }
     return false;
 }
-function loadProjectMappings(root, company, requestedProject) {
+export function loadProjectMappings(root, company, requestedProject) {
     const registryPath = path.join(root, "workspace", "lane-briefs", "juniors.json");
     const registry = readJsonObject(registryPath, "empty");
     const mappings = new Map();
@@ -215,7 +215,7 @@ function loadProjectMappings(root, company, requestedProject) {
     }
     return mappings;
 }
-function readProject(root, company, prdPath) {
+export function readProject(root, company, prdPath, tolerantStories = false) {
     checkCompanyPath(root, company, path.relative(root, prdPath), prdPath);
     const parsed = readJsonObject(prdPath);
     if (parsed === null)
@@ -236,17 +236,26 @@ function readProject(root, company, prdPath) {
     const rawStories = parsed.userStories === undefined ? parsed.stories : parsed.userStories;
     if (!Array.isArray(rawStories))
         return fail("tracker_checks_input_invalid", "Project task list must contain a userStories or stories array", { path: prdPath });
-    const stories = rawStories.map((story, index) => {
+    const errors = [];
+    const stories = rawStories.flatMap((story, index) => {
         if (!isObject(story) || typeof story.id !== "string" || story.id.trim() === "") {
+            if (tolerantStories) {
+                errors.push({ path: prdPath, field: `userStories[${index}]`, message: "Project task list contains a story without an id" });
+                return [];
+            }
             return fail("tracker_checks_input_invalid", "Project task list contains a story without an id", { path: prdPath, index });
         }
         if (story.prs !== undefined && !Array.isArray(story.prs)) {
+            if (tolerantStories) {
+                errors.push({ path: prdPath, field: "prs", message: "Project story prs must be an array", story_id: story.id });
+                return [{ ...story, prs: [] }];
+            }
             return fail("tracker_checks_input_invalid", "Project story prs must be an array", { path: prdPath, story_id: story.id });
         }
-        return story;
+        return [story];
     });
     try {
-        return { stories, mtime: fs.statSync(prdPath).mtimeMs };
+        return { stories, mtime: fs.statSync(prdPath).mtimeMs, ...(tolerantStories ? { errors } : {}) };
     }
     catch (err) {
         return fail("tracker_checks_input_unreadable", `Project task list could not be stat'ed: ${err instanceof Error ? err.message : String(err)}`, { path: prdPath });
@@ -352,7 +361,7 @@ function questionMetadataMatchesScope(record, company, projectId) {
         return false;
     return true;
 }
-function readCompanyQuestions(root, company, projectId) {
+export function loadCompanyQuestionRecords(root, company, projectId) {
     const records = listQuestionIds(root)
         .flatMap((id) => {
         const file = questionRecordPath(root, id);
@@ -365,6 +374,10 @@ function readCompanyQuestions(root, company, projectId) {
         return question.company?.slug === company.slug && question.company.uid === company.uid &&
             (projectId === undefined || question.project_id === projectId) ? [question] : [];
     });
+    return records;
+}
+function readCompanyQuestions(root, company, projectId) {
+    const records = loadCompanyQuestionRecords(root, company, projectId);
     const surfacedAt = questionSurfacingState(root, records.map((question) => ({
         id: question.question_id,
         status: question.status,
@@ -418,7 +431,7 @@ function readTeamInputs(root, company, projects, lanes) {
     }
     return inputs;
 }
-function pathForTrackerRecord(projectDirectory, kind, id) {
+export function pathForTrackerRecord(projectDirectory, kind, id) {
     return path.join(projectDirectory, "tracker", kind, `${id}.json`);
 }
 function recordInvalid(kind, record, projectDirectory, field) {
@@ -435,7 +448,7 @@ function requiredRecordDate(kind, record, projectDirectory, field) {
         return recordInvalid(kind, record, projectDirectory, field);
     return value;
 }
-function listTrackerRecords(projectDirectory, kind) {
+export function listTrackerRecords(projectDirectory, kind) {
     try {
         return createLocalTrackerStore(projectDirectory).list(kind);
     }
@@ -445,6 +458,51 @@ function listTrackerRecords(projectDirectory, kind) {
         return fail("tracker_checks_store_unreadable", `Tracker ${kind} records could not be read: ${err instanceof Error ? err.message : String(err)}`, { path: path.join(projectDirectory, "tracker", kind) });
     }
 }
+/** Report loader that preserves valid records while making every unreadable file visible. */
+export function listTrackerRecordsTolerant(projectDirectory, kind) {
+    const root = path.join(projectDirectory, "tracker");
+    const directory = path.join(projectDirectory, "tracker", kind);
+    let names;
+    try {
+        const rootStat = fs.lstatSync(root);
+        if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+            return { records: [], errors: [{ path: root, field: "directory", message: "Tracker storage path must be a regular directory" }] };
+        }
+        const stat = fs.lstatSync(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            return { records: [], errors: [{ path: directory, field: "directory", message: "Tracker record path must be a regular directory" }] };
+        }
+        names = fs.readdirSync(directory).filter((name) => name.endsWith(".json")).sort();
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { records: [], errors: [] };
+        return { records: [], errors: [{ path: directory, field: "directory", message: `Tracker records could not be listed: ${err instanceof Error ? err.message : String(err)}` }] };
+    }
+    const store = createLocalTrackerStore(projectDirectory);
+    const records = [];
+    const errors = [];
+    for (const name of names) {
+        const id = name.slice(0, -5);
+        const file = path.join(directory, name);
+        try {
+            const record = store.read(kind, id);
+            if (record !== null)
+                records.push(record);
+        }
+        catch (err) {
+            const details = isLanesError(err) ? err.details : {};
+            errors.push({
+                path: typeof details.path === "string" ? details.path : file,
+                field: typeof details.field === "string" ? details.field : "record",
+                message: err instanceof Error ? err.message : String(err),
+                record_id: typeof details.id === "string" ? details.id : id,
+            });
+        }
+    }
+    records.sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
+    return { records, errors };
+}
 function readTrackerCheckRecords(root, company, projects) {
     const blockers = [];
     const kpis = [];
@@ -499,7 +557,7 @@ function readTrackerCheckRecords(root, company, projects) {
     }
     return { blockers, kpis, directives };
 }
-async function resolveTrackerCompany(deps, requested) {
+export async function resolveTrackerCompany(deps, requested) {
     const company = await deps.resolveCompany(requested);
     if (!company.slug)
         fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});

package/dist/commands/lanes-report.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import { type QuestionBody } from "../lib/lanes/questions.js";
+import type { QuestionRecord } from "../lib/lanes/types.js";
+import { type LaneChecksDeps } from "./lanes-checks.js";
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export interface LaneReportsDeps extends LaneChecksDeps {
+    readQuestionBody: (root: string, question: QuestionRecord) => QuestionBody;
+}
+export declare function registerLaneReportCommands(parent: Command, deps: LaneReportsDeps, wrap: WrapHandler): void;
+export {};
+//# sourceMappingURL=lanes-report.d.ts.map