@indigoai-us/hq-cli 5.220.0 → 5.222.0

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

package/dist/commands/lanes.d.ts

@@ -12,7 +12,7 @@ export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 export { LANE_HIRE_GRANTS_FLAG };
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.js";
-import { LANE_HIRE_GRANTS_FLAG, MAX_LANE_DEPTH, withLaneHireLocks, type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
+import { LANE_HIRE_GRANTS_FLAG, MAX_LANE_DEPTH, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { type RunCompactionFn } from "../lib/lanes/compaction.js";
 import { type KnownModelsDeps, type ProbeCommand } from "../lib/lanes/models.js";
@@ -107,6 +107,7 @@ export declare const LANE_OUTPOST_QUESTION_VISIBILITY_FLAG = "lanes.outpost-ques
 export declare const LANE_HOST_SCOPED_ACCOUNT_HOMES_FLAG = "lanes.host-scoped-account-homes";
 export declare function parseSeniorRef(raw: string): SeniorRef;
 export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
+export declare function parseQuestionBody(raw: unknown): QuestionBody | null;
 /**
  * Spec §5.1: `hq lanes ask` from inside a lane can hit a binary or dist
  * being replaced mid-call (ENOENT / ETXTBSY / a module that no longer

package/dist/commands/lanes.js

@@ -14,6 +14,7 @@ import { readLocalOverride } from "@indigoai-us/hq-flags-client";
 import { Option } from "commander";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
+import { registerLaneReportCommands } from "./lanes-report.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -43,6 +44,7 @@ import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
+import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
@@ -438,16 +440,20 @@ function readJsonFile(filePath) {
         throw err;
     }
 }
-function parseQuestionBody(raw) {
+export function parseQuestionBody(raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw))
         return null;
     const obj = raw;
-    const options = Array.isArray(obj.options)
-        ? obj.options.filter((item) => typeof item === "string")
-        : [];
+    if (typeof obj.question !== "string" || typeof obj.context !== "string" || !Array.isArray(obj.options) || obj.options.some((item) => typeof item !== "string"))
+        return null;
+    if (obj.recommended !== undefined && typeof obj.recommended !== "string")
+        return null;
+    if (obj.notes !== undefined && typeof obj.notes !== "string")
+        return null;
+    const options = obj.options.filter((item) => typeof item === "string");
     const body = {
-        question: typeof obj.question === "string" ? obj.question : "",
-        context: typeof obj.context === "string" ? obj.context : "",
+        question: obj.question,
+        context: obj.context,
         options,
     };
     if (typeof obj.recommended === "string")
@@ -8506,6 +8512,18 @@ export function registerLanesCommand(parent, deps = {}) {
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
         now: ctx.now,
     }, wrap);
+    registerLaneReportCommands(lanes, {
+        hqRoot: ctx.hqRoot,
+        resolveCompany: ctx.resolveCompany,
+        trackerEnabled: ctx.laneTrackerEnabled,
+        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        now: ctx.now,
+        readQuestionBody: (root, question) => {
+            const body = requireQuestionBody(root, question);
+            assertQuestionBodySecretSafe(body);
+            return body;
+        },
+    }, wrap);
     registerOutpostPrunerCommand(lanes);
     const noStoryOption = new Option("--no-story <reason>", "Create a lane without a story and record why");
     noStoryOption.attributeName = () => "noStory";

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

@@ -0,0 +1,17 @@
+/**
+ * Alias rules shared by `apply` and the multi-writer merge-back.
+ */
+import type { EntityIndex } from "./tree.js";
+/** Longest canonical name or alias the writer accepts. */
+export declare const MAX_NAME_LENGTH = 200;
+/** The index key for a normalised name of one type. */
+export declare function entityKey(type: string, normalized: string): string;
+/**
+ * Aliases worth adding to the entity at `self`: new to it, and held by no
+ * other entity of any type, so an alias can never make a later match
+ * ambiguous. `own` holds the normalised names the entity already answers to.
+ */
+export declare function freshAliases(index: EntityIndex, type: string, self: string, own: Set<string>, names: string[]): string[];
+/** The normalised names an indexed entity answers to, plus aliases queued this run. */
+export declare function ownNames(index: EntityIndex, rel: string, queued: string[]): Set<string>;
+//# sourceMappingURL=aliases.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * Alias rules shared by `apply` and the multi-writer merge-back.
+ */
+import { canonicalizeName, isRejectedName, normalizeEntityName } from "./identity.js";
+/** Longest canonical name or alias the writer accepts. */
+export const MAX_NAME_LENGTH = 200;
+/** The index key for a normalised name of one type. */
+export function entityKey(type, normalized) {
+    return `${type}\0${normalized}`;
+}
+/**
+ * Aliases worth adding to the entity at `self`: new to it, and held by no
+ * other entity of any type, so an alias can never make a later match
+ * ambiguous. `own` holds the normalised names the entity already answers to.
+ */
+export function freshAliases(index, type, self, own, names) {
+    const seen = new Set(own);
+    const out = [];
+    for (const raw of names) {
+        const alias = canonicalizeName(raw);
+        if (!alias || alias.length > MAX_NAME_LENGTH)
+            continue;
+        const normalized = normalizeEntityName(alias, type);
+        if (!normalized || seen.has(normalized) || isRejectedName(normalized))
+            continue;
+        const holders = [
+            ...(index.canonical.get(entityKey(type, normalized)) ?? []),
+            ...(index.alias.get(entityKey(type, normalized)) ?? []),
+        ];
+        if (holders.some((holder) => holder !== self))
+            continue;
+        if ([...(index.types.get(normalized) ?? [])].some((other) => other !== type))
+            continue;
+        seen.add(normalized);
+        out.push(alias);
+    }
+    return out;
+}
+/** The normalised names an indexed entity answers to, plus aliases queued this run. */
+export function ownNames(index, rel, queued) {
+    const entity = index.byRel.get(rel);
+    return new Set([entity.canonical_name, ...entity.aliases, ...queued].map((name) => normalizeEntityName(name, entity.type)));
+}
+//# sourceMappingURL=aliases.js.map

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

@@ -5,6 +5,7 @@
  * sections 4.3, 5 and 14). The model output is untrusted input: a malformed
  * candidate is rejected and counted, never repaired.
  */
+import { type DuplicateReport, type MergeBackOutcome } from "./multi-writer.js";
 import { type CompanyBriefResult } from "./company-brief.js";
 import { type WritableEntityType } from "./identity.js";
 import { type EntityIndex } from "./tree.js";
@@ -76,6 +77,15 @@ export interface ApplyReport {
     }>;
     /** Present only when the plan ran the company brief and this apply created or updated entities. */
     company_brief?: CompanyBriefResult;
+    /** Present only when `checkpoint.ontology.multi-writer` was on for the plan (design section 20). */
+    multi_writer?: {
+        conflicts: MergeBackOutcome[];
+        /** Entity files this apply wrote and recorded in the outbox. */
+        outbox_recorded: number;
+        outbox_reset?: true;
+        error?: string;
+        duplicates?: DuplicateReport;
+    };
     duration_ms: number;
 }
 export interface ApplyOptions {