@indigoai-us/hq-cli 5.219.0 → 5.221.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [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
+
+- Lane questions now resolve their company from the lane's project before using
+  the active HQ company. Project ownership is used only when unique; otherwise
+  active-company selection applies without choosing a project owner. Legacy
+  questions can be answered with `--company <slug>` when lane or project
+  ownership cannot be resolved.
+
+- CLI updates no longer interrupt background flag refreshes when the
+  self-contained worker rollout is enabled.
+
 ## [5.219.0] — 2026-09-26
 
 ### Added

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

@@ -7257,6 +7257,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

@@ -9381,6 +9381,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/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

package/dist/commands/lanes-report.js

@@ -0,0 +1,330 @@
+import * as path from "node:path";
+import { LanesError } from "../lib/lanes/errors.js";
+import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
+import { questionRecordPath } from "../lib/lanes/store.js";
+import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
+import { mapSourceStoryStatus } from "../lib/mesh/story-status.js";
+import { buildTrackerOwnerReport, buildTrackerTeamPage, renderTrackerOwnerReportText, renderTrackerTeamPageText, } from "../lib/lanes/tracker-report.js";
+import { FIRST_TRACKER_REPORT_SINCE, readTrackerReportState, writeTrackerReportState, } from "../lib/lanes/tracker-report-state.js";
+import { listTrackerRecordsTolerant, loadCompanyQuestionRecords, loadProjectMappings, pathForTrackerRecord, readProject, resolveTrackerCompany, } from "./lanes-checks.js";
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+function canonicalStoryStatus(story, sourcePath, storyId) {
+    try {
+        const rawStatus = story.state ?? story.status;
+        if (rawStatus === "dropped")
+            return "dropped";
+        const status = mapSourceStoryStatus(story, `${sourcePath}#${storyId}`);
+        if (status !== undefined)
+            return status;
+        return story.passes === true ? "done" : "queued";
+    }
+    catch (err) {
+        return fail("tracker_report_story_invalid", err instanceof Error ? err.message : String(err), { path: sourcePath, story_id: storyId, field: "state" });
+    }
+}
+function recordsArray(record, field, sourcePath, storyId, errors) {
+    const value = record[field];
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        errors.push({ path: sourcePath, field, story_id: storyId, message: `${field} must be an array` });
+        return [];
+    }
+    return value;
+}
+function timestampOrIssue(value, field, sourcePath, storyId, errors) {
+    const timestamp = normalizeIsoTimestamp(value);
+    if (timestamp === null) {
+        errors.push({ path: sourcePath, field, story_id: storyId, message: `${field} must be a valid timestamp` });
+        return null;
+    }
+    return timestamp;
+}
+function numericPr(value, url) {
+    if (typeof value === "string" && /^[1-9]\d*$/.test(value))
+        return value;
+    if (typeof value === "number" && Number.isSafeInteger(value) && value > 0)
+        return String(value);
+    return url.match(/\/pull\/(\d+)(?:\/|$)/)?.[1] ?? null;
+}
+function storyReferences(story, sourcePath, storyId, errors) {
+    const references = new Set();
+    const pullRequests = [];
+    const releases = [];
+    const addPullRequest = (value, field) => {
+        if (typeof value === "string" && value.trim()) {
+            references.add(value.trim());
+            return;
+        }
+        if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) {
+            references.add(`#${value}`);
+            return;
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            errors.push({ path: sourcePath, field, story_id: storyId, message: "Pull request entry must be a reference or object" });
+            return;
+        }
+        const record = value;
+        const url = typeof record.url === "string" ? record.url : typeof record.html_url === "string" ? record.html_url : "";
+        const number = numericPr(record.number, url);
+        const reference = typeof record.ref === "string" ? record.ref : url || (number ? `#${number}` : "");
+        if (reference)
+            references.add(reference);
+        else
+            errors.push({ path: sourcePath, field, story_id: storyId, message: "Pull request object needs a number, URL, or ref" });
+        const mergedAt = record.merged_at ?? record.mergedAt ?? record.at;
+        if (mergedAt === undefined)
+            return;
+        if (!number) {
+            errors.push({ path: sourcePath, field, story_id: storyId, message: "Timed pull request object needs a number or pull URL" });
+            return;
+        }
+        const at = timestampOrIssue(mergedAt, "merged_at", sourcePath, storyId, errors);
+        if (at)
+            pullRequests.push({ number, title: typeof record.title === "string" && record.title.trim() ? record.title : `Pull request #${number}`, merged_at: at, source_path: sourcePath });
+    };
+    const addRelease = (value, field) => {
+        if (typeof value === "string" && value.trim()) {
+            references.add(value.trim());
+            return;
+        }
+        if (typeof value === "number" && Number.isSafeInteger(value)) {
+            references.add(String(value));
+            return;
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            errors.push({ path: sourcePath, field, story_id: storyId, message: "Release or deployment entry must be a reference or object" });
+            return;
+        }
+        const record = value;
+        const version = typeof record.version === "string" ? record.version : typeof record.tag === "string" ? record.tag : "";
+        const reference = typeof record.ref === "string" ? record.ref : typeof record.url === "string" ? record.url : version;
+        if (reference)
+            references.add(reference);
+        else
+            errors.push({ path: sourcePath, field, story_id: storyId, message: "Release or deployment object needs version, tag, ref, or URL" });
+        const releasedAt = record.released_at ?? record.releasedAt ?? record.deployed_at ?? record.deployedAt ?? record.at;
+        if (releasedAt === undefined)
+            return;
+        if (!version) {
+            errors.push({ path: sourcePath, field, story_id: storyId, message: "Timed release or deployment object needs a version or tag" });
+            return;
+        }
+        const at = timestampOrIssue(releasedAt, "released_at", sourcePath, storyId, errors);
+        if (at)
+            releases.push({ version, released_at: at, source_path: sourcePath });
+    };
+    for (const field of ["prs", "pull_requests"]) {
+        for (const value of recordsArray(story, field, sourcePath, storyId, errors))
+            addPullRequest(value, field);
+    }
+    for (const field of ["releases", "deploys"]) {
+        for (const value of recordsArray(story, field, sourcePath, storyId, errors))
+            addRelease(value, field);
+    }
+    return { references: [...references].sort(), pullRequests, releases };
+}
+function currentAudience(question, sourcePath) {
+    const latest = question.routing_history.at(-1);
+    if (!latest || typeof latest !== "object" || Array.isArray(latest)) {
+        return fail("tracker_report_question_route_invalid", "Question has no valid routing history for its current audience", { question_id: question.question_id, path: sourcePath });
+    }
+    const audience = latest.audience;
+    if (!audience || typeof audience !== "object" || Array.isArray(audience) || typeof audience.kind !== "string") {
+        return fail("tracker_report_question_route_invalid", "Question current audience is malformed", { question_id: question.question_id, path: sourcePath });
+    }
+    switch (audience.kind) {
+        case "user": return "owner";
+        case "session": return "operator";
+        case "lane": return "lane";
+        default: return fail("tracker_report_question_route_invalid", "Question current audience is unsupported", { question_id: question.question_id, path: sourcePath });
+    }
+}
+function trackerRecords(root, company, project, kind, errors) {
+    const projectDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
+    const loaded = listTrackerRecordsTolerant(projectDirectory, kind);
+    for (const issue of loaded.errors) {
+        errors.push({ path: issue.path, field: issue.field, message: issue.message, ...(issue.record_id ? { record_id: issue.record_id } : {}) });
+    }
+    return loaded.records
+        .filter((record) => record.company === company.slug && record.project_id === project.projectId)
+        .map((record) => ({ ...record, source_path: pathForTrackerRecord(projectDirectory, kind, record.id) }));
+}
+function issueFromError(err, fallbackPath, fallbackField, ids = {}) {
+    const details = err instanceof LanesError ? err.details : {};
+    return {
+        path: typeof details.path === "string" ? details.path : fallbackPath,
+        field: typeof details.field === "string" ? details.field : fallbackField,
+        message: err instanceof Error ? err.message : String(err),
+        ...(typeof details.story_id === "string" ? { story_id: details.story_id } : ids.story_id ? { story_id: ids.story_id } : {}),
+        ...(typeof details.id === "string" ? { record_id: details.id } : ids.record_id ? { record_id: ids.record_id } : {}),
+        ...(typeof details.question_id === "string" ? { question_id: details.question_id } : ids.question_id ? { question_id: ids.question_id } : {}),
+    };
+}
+function teamInput(root, company, project, questions, deps, errors = []) {
+    const projectDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
+    const prdPath = path.join(projectDirectory, "prd.json");
+    let prd = { stories: [], mtime: 0 };
+    try {
+        prd = readProject(root, company.slug, prdPath, true);
+        for (const issue of prd.errors ?? [])
+            errors.push(issue);
+    }
+    catch (err) {
+        errors.push(issueFromError(err, prdPath, "project"));
+    }
+    const pullRequests = [];
+    const releases = [];
+    const stories = [];
+    for (const story of prd.stories) {
+        const id = typeof story.id === "string" ? story.id : "";
+        if (!id.trim()) {
+            errors.push({ path: prdPath, field: "id", message: "Story id must be a non-empty string" });
+            continue;
+        }
+        const title = typeof story.title === "string" ? story.title : "";
+        if (!title.trim()) {
+            errors.push({ path: prdPath, field: "title", story_id: id, message: "Story title must be a non-empty string" });
+            continue;
+        }
+        let status;
+        try {
+            status = canonicalStoryStatus(story, prdPath, id);
+        }
+        catch (err) {
+            errors.push(issueFromError(err, prdPath, "state", { story_id: id }));
+            continue;
+        }
+        const updatedAt = story.updated_at ?? story.updatedAt;
+        if (status === "done" && updatedAt === undefined) {
+            errors.push({ path: prdPath, field: "updated_at", story_id: id, message: "Done story is missing updated_at" });
+            continue;
+        }
+        let normalizedUpdatedAt;
+        if (updatedAt !== undefined) {
+            const normalized = normalizeIsoTimestamp(updatedAt);
+            if (normalized === null) {
+                errors.push({ path: prdPath, field: "updated_at", story_id: id, message: "updated_at must be a valid timestamp" });
+                continue;
+            }
+            normalizedUpdatedAt = normalized;
+        }
+        const refs = storyReferences(story, prdPath, id, errors);
+        pullRequests.push(...refs.pullRequests);
+        releases.push(...refs.releases);
+        stories.push({ id, title, status, references: refs.references, ...(normalizedUpdatedAt ? { updated_at: normalizedUpdatedAt } : {}), source_path: prdPath });
+    }
+    const teamQuestions = [];
+    for (const record of questions.filter((question) => question.project_id === project.projectId)) {
+        const sourcePath = questionRecordPath(root, record.question_id);
+        try {
+            const body = deps.readQuestionBody(root, record);
+            assertQuestionBodySecretSafe(body);
+            teamQuestions.push({ record, body, current_audience: currentAudience(record, sourcePath), source_path: sourcePath });
+        }
+        catch (err) {
+            errors.push(issueFromError(err, sourcePath, "body", { question_id: record.question_id }));
+        }
+    }
+    return {
+        company: company.slug,
+        team: project.team,
+        project_id: project.projectId,
+        stories,
+        pull_requests: pullRequests,
+        releases,
+        blockers: trackerRecords(root, company, project, "blocker", errors),
+        kpis: trackerRecords(root, company, project, "kpi", errors),
+        okrs: trackerRecords(root, company, project, "okr", errors),
+        directives: trackerRecords(root, company, project, "directive", errors),
+        questions: teamQuestions,
+        errors,
+    };
+}
+function allTeamInputs(root, company, deps) {
+    const mappings = loadProjectMappings(root, company.slug);
+    return [...mappings.values()]
+        .sort((a, b) => a.team.localeCompare(b.team) || a.projectId.localeCompare(b.projectId))
+        .map((project) => {
+        const errors = [];
+        let questions = [];
+        try {
+            questions = loadCompanyQuestionRecords(root, company, project.projectId);
+        }
+        catch (err) {
+            errors.push(issueFromError(err, path.join(root, "companies", company.slug, "projects", project.projectId), "questions"));
+        }
+        return teamInput(root, company, project, questions, deps, errors);
+    });
+}
+function sinceForTeam(root, company) {
+    return readTrackerReportState(root, company)?.last_report_at ?? FIRST_TRACKER_REPORT_SINCE;
+}
+function validateTeamSlug(team) {
+    const value = team.trim();
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value) || value === "." || value === "..") {
+        return fail("tracker_team_invalid", "Team slug must be a safe path segment", { team });
+    }
+    return value;
+}
+export function registerLaneReportCommands(parent, deps, wrap) {
+    parent.command("report")
+        .description("Generate the owner report for tracker teams")
+        .option("--company <slug>", "Select the company by slug")
+        .option("--since <iso>", "Report activity from this ISO timestamp")
+        .option("--json", "Emit JSON instead of the owner report text")
+        .action(wrap(async (options) => {
+        const company = await resolveTrackerCompany(deps, options.company);
+        const root = deps.hqRoot();
+        const generatedAt = deps.now().toISOString();
+        const previous = options.since === undefined ? readTrackerReportState(root, company.slug) : null;
+        const since = options.since ?? previous?.last_report_at ?? FIRST_TRACKER_REPORT_SINCE;
+        const input = {
+            company: company.slug,
+            generated_at: generatedAt,
+            since,
+            since_source: options.since !== undefined ? "explicit" : previous ? "previous_report" : "first_run",
+            teams: allTeamInputs(root, company, deps),
+        };
+        const report = buildTrackerOwnerReport(input);
+        const hasErrors = report.teams.some((team) => team.errors.length > 0);
+        if (hasErrors)
+            process.exitCode = 2;
+        else
+            writeTrackerReportState(root, company.slug, generatedAt);
+        console.log(options.json ? JSON.stringify(report, null, 2) : renderTrackerOwnerReportText(report));
+    }));
+    parent.command("team")
+        .description("Show a team's OKRs, KPIs, work, blockers, and questions")
+        .argument("<slug>", "Team slug")
+        .option("--company <slug>", "Select the company by slug")
+        .option("--json", "Emit JSON instead of the team page text")
+        .action(wrap(async (slug, options) => {
+        const team = validateTeamSlug(slug);
+        const company = await resolveTrackerCompany(deps, options.company);
+        const root = deps.hqRoot();
+        const since = sinceForTeam(root, company.slug);
+        const candidates = [...loadProjectMappings(root, company.slug).values()].filter((project) => project.team === team);
+        if (candidates.length === 0)
+            fail("tracker_team_not_found", "Team was not found for this company", { team, company: company.slug });
+        if (candidates.length > 1)
+            fail("tracker_team_ambiguous", "More than one project maps to this team", { team, company: company.slug, project_ids: candidates.map((item) => item.projectId) });
+        const generatedAt = deps.now().toISOString();
+        const errors = [];
+        let questions = [];
+        try {
+            questions = loadCompanyQuestionRecords(root, company, candidates[0].projectId);
+        }
+        catch (err) {
+            errors.push(issueFromError(err, path.join(root, "companies", company.slug, "projects", candidates[0].projectId), "questions"));
+        }
+        const input = teamInput(root, company, candidates[0], questions, deps, errors);
+        const page = buildTrackerTeamPage(input, company.slug, since, generatedAt);
+        if (page.errors.length > 0)
+            process.exitCode = 2;
+        console.log(options.json ? JSON.stringify(page, null, 2) : renderTrackerTeamPageText(page));
+    }));
+}
+//# sourceMappingURL=lanes-report.js.map