@indigoai-us/hq-cli 5.273.0-alpha.0 → 5.273.0

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

@@ -1,18 +0,0 @@
-import type { Command } from "commander";
-import { type TrackerStore } from "../lib/lanes/tracker-store.js";
-import type { LaneCompanyRef } from "../lib/lanes/types.js";
-export declare const LANES_TRACKER_FLAG = "lanes.tracker";
-export interface LaneTrackerCommandDeps {
-    hqRoot: () => string;
-    resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
-    trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    now: () => Date;
-    actor: () => string | null;
-    /** Test seam; production uses the same local store used by the public commands. */
-    store?: (projectDirectory: string) => TrackerStore;
-}
-type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
-export declare function registerLaneTrackerCommands(parent: Command, deps: LaneTrackerCommandDeps, wrap: WrapHandler): void;
-export declare function defaultTrackerActor(): string | null;
-export {};
-//# sourceMappingURL=lanes-tracker.d.ts.map

package/dist/commands/lanes-tracker.js

@@ -1,452 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { loadCachedTokens } from "@indigoai-us/hq-cloud";
-import { LanesError } from "../lib/lanes/errors.js";
-import { resolveProjectStoryLedger } from "../lib/lanes/story-ledger.js";
-import { tryReadQuestion } from "../lib/lanes/store.js";
-import { assertNoSecretText } from "../lib/lanes/text-scan.js";
-import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
-import { peekIdToken } from "../utils/id-token.js";
-export const LANES_TRACKER_FLAG = "lanes.tracker";
-const MAX_POLICY_PATH_BYTES = 4096;
-function fail(error, message, details = {}) {
-    throw new LanesError(error, message, details);
-}
-function validSegment(value, label) {
-    const normalized = value.trim();
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(normalized) || normalized === "." || normalized === "..") {
-        return fail("tracker_input_invalid", `${label} must be a safe path segment`, { field: label, value });
-    }
-    return normalized;
-}
-function requiredText(field, text) {
-    if (!text.trim())
-        fail("tracker_input_invalid", `${field} must not be empty`, { field });
-    return text;
-}
-function checkedText(field, text, maxBytes) {
-    requiredText(field, text);
-    if (maxBytes !== undefined && Buffer.byteLength(text, "utf8") > maxBytes) {
-        fail("tracker_input_too_long", `${field} exceeds the maximum length`, { field, max_length: maxBytes });
-    }
-    assertNoSecretText(field, text);
-    return text;
-}
-function readProjectCompany(prdPath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(prdPath, "utf8"));
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            fail("tracker_project_not_found", "Project prd.json was not found for this company", { path: prdPath });
-        fail("tracker_project_invalid", "Project prd.json must contain valid JSON", { path: prdPath });
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return fail("tracker_project_invalid", "Project prd.json must contain a JSON object", { path: prdPath });
-    }
-    const object = parsed;
-    const metadata = object.metadata && typeof object.metadata === "object" && !Array.isArray(object.metadata)
-        ? object.metadata
-        : undefined;
-    const raw = object.company ?? metadata?.company;
-    if (raw === undefined || raw === null)
-        return null;
-    if (typeof raw === "string")
-        return raw;
-    if (typeof raw === "object" && !Array.isArray(raw)) {
-        const slug = raw.slug;
-        if (typeof slug === "string")
-            return slug;
-    }
-    return fail("tracker_project_invalid", "Project company metadata must name a company slug", { path: prdPath });
-}
-async function target(deps, options) {
-    const company = await deps.resolveCompany(options.company);
-    if (!company.slug)
-        fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
-    // Check the feature gate before inspecting the project path. A disabled flag
-    // reveals neither project existence nor any local tracker data.
-    if (!await deps.trackerEnabled(company)) {
-        fail("tracker_disabled", "hq lanes tracker commands require the lanes.tracker flag", { company: company.slug });
-    }
-    const project = validSegment(options.project, "project");
-    const ledger = resolveProjectStoryLedger(deps.hqRoot(), project, company.slug);
-    const projectCompany = readProjectCompany(ledger.path);
-    if (projectCompany !== null && projectCompany !== company.slug) {
-        fail("tracker_company_mismatch", "Project company does not match the active HQ company", {
-            active_company: company.slug,
-            project_company: projectCompany,
-            project_id: project,
-        });
-    }
-    const directory = path.dirname(ledger.path);
-    let realDirectory;
-    try {
-        realDirectory = fs.realpathSync(directory);
-    }
-    catch (err) {
-        fail("tracker_project_not_found", "Project directory was not found for this company", {
-            project_id: project,
-            filesystem_code: err.code ?? "unknown",
-        });
-    }
-    const expectedRoot = fs.realpathSync(path.join(deps.hqRoot(), "companies", company.slug, "projects"));
-    if (!realDirectory.startsWith(`${expectedRoot}${path.sep}`)) {
-        fail("tracker_company_mismatch", "Project directory resolves outside the active HQ company", {
-            active_company: company.slug,
-            project_id: project,
-        });
-    }
-    return {
-        company,
-        project,
-        store: deps.store?.(realDirectory) ?? createLocalTrackerStore(realDirectory, deps.now),
-    };
-}
-function requireActor(deps) {
-    const actor = deps.actor()?.trim();
-    if (!actor)
-        fail("tracker_identity_unavailable", "Cannot record approval without a signed-in HQ identity", {});
-    return actor;
-}
-function approvalQuestionId(deps, company, project, rawQuestionId) {
-    if (rawQuestionId === undefined)
-        return undefined;
-    const questionId = validSegment(rawQuestionId, "question-id");
-    const question = tryReadQuestion(deps.hqRoot(), questionId);
-    if (!question)
-        fail("tracker_question_not_found", `Answered owner question ${questionId} was not found`, { question_id: questionId });
-    if (question.status !== "answered" || !question.answer) {
-        fail("tracker_question_not_answered", `Owner question ${questionId} is not answered`, { question_id: questionId });
-    }
-    if (question.company?.slug !== company.slug || question.project_id !== project) {
-        fail("tracker_question_scope_mismatch", `Owner question ${questionId} does not belong to this company project`, {
-            question_id: questionId,
-            company: company.slug,
-            project_id: project,
-        });
-    }
-    return questionId;
-}
-function numberValue(raw, field) {
-    const value = Number(raw);
-    if (!Number.isFinite(value))
-        return fail("tracker_input_invalid", `${field} must be a finite number`, { field });
-    return value;
-}
-function parseKr(raw) {
-    const match = /^(.+)=([a-zA-Z0-9][a-zA-Z0-9._-]{0,127}):(-?(?:\d+(?:\.\d*)?|\.\d+))$/.exec(raw);
-    if (!match)
-        fail("tracker_key_result_invalid", "Key result must be <text>=<kpi-id>:<target>", {});
-    return { text: match[1].trim(), kpi_id: validSegment(match[2], "kpi-id"), target: numberValue(match[3], "key-result target") };
-}
-function validDate(raw) {
-    let normalized;
-    try {
-        normalized = new Date(`${raw}T00:00:00.000Z`).toISOString().slice(0, 10);
-    }
-    catch {
-        normalized = undefined;
-    }
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(raw) || normalized !== raw) {
-        return fail("tracker_date_invalid", "Date must be a valid YYYY-MM-DD value", { field: "date" });
-    }
-    return raw;
-}
-function validTimestamp(raw) {
-    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?(Z|[+-]\d{2}:\d{2})$/.exec(raw);
-    if (!match)
-        return fail("tracker_date_invalid", "KPI --at must be an ISO 8601 timestamp with a timezone", { field: "at" });
-    const [, year, month, day, hour, minute, second = "00", fraction = "", zone] = match;
-    const date = `${year}-${month}-${day}`;
-    let calendarDate;
-    try {
-        calendarDate = new Date(`${date}T00:00:00.000Z`).toISOString().slice(0, 10);
-    }
-    catch {
-        calendarDate = undefined;
-    }
-    if (calendarDate !== date || Number(hour) > 23 || Number(minute) > 59 || Number(second) > 59) {
-        return fail("tracker_date_invalid", "KPI --at must be an ISO 8601 timestamp with a timezone", { field: "at" });
-    }
-    let offsetMinutes = 0;
-    if (zone !== "Z") {
-        const offset = /^([+-])(\d{2}):(\d{2})$/.exec(zone);
-        const offsetHours = Number(offset?.[2]);
-        const offsetRemainder = Number(offset?.[3]);
-        if (!offset || offsetHours > 14 || offsetRemainder > 59 || (offsetHours === 14 && offsetRemainder !== 0)) {
-            return fail("tracker_date_invalid", "KPI --at must be an ISO 8601 timestamp with a timezone", { field: "at" });
-        }
-        const sign = offset[1] === "+" ? 1 : -1;
-        offsetMinutes = sign * (offsetHours * 60 + offsetRemainder);
-    }
-    const localTimeAsUtc = new Date(`${date}T${hour}:${minute}:${second}.${fraction.padEnd(3, "0")}Z`);
-    const expectedEpoch = localTimeAsUtc.getTime() - offsetMinutes * 60_000;
-    const parsed = new Date(raw);
-    if (!Number.isFinite(expectedEpoch) || !Number.isFinite(parsed.getTime()) || parsed.getTime() !== expectedEpoch) {
-        return fail("tracker_date_invalid", "KPI --at must be an ISO 8601 timestamp with a timezone", { field: "at" });
-    }
-    const roundTripped = new Date(parsed.toISOString());
-    if (roundTripped.getTime() !== expectedEpoch) {
-        return fail("tracker_date_invalid", "KPI --at must be an ISO 8601 timestamp with a timezone", { field: "at" });
-    }
-    return parsed;
-}
-function addProjectOptions(command) {
-    return command
-        .requiredOption("--project <slug>", "HQ team project slug")
-        .option("--company <slug>", "Select the company by slug");
-}
-async function createRecord(store, kind, company, project, fields) {
-    return await store.create({ kind, id: randomUUID(), company, project_id: project, ...fields });
-}
-export function registerLaneTrackerCommands(parent, deps, wrap) {
-    const blocker = parent.command("blocker").description("Record and manage project blockers");
-    addProjectOptions(blocker.command("open").description("Open a blocker"))
-        .requiredOption("--story <id>", "Blocked story id")
-        .requiredOption("--what <text>", "What is blocked")
-        .requiredOption("--waiting-on <text>", "Who or what is needed")
-        .requiredOption("--next-step <text>", "Next action")
-        .action(wrap(async (options) => {
-        const { company, project, store } = await target(deps, options);
-        if (!options.story.trim())
-            fail("tracker_input_invalid", "story must not be empty", { field: "story" });
-        for (const [field, value] of [["what", options.what], ["waiting_on", options.waitingOn], ["next_step", options.nextStep]])
-            checkedText(field, value);
-        const record = await createRecord(store, "blocker", company.slug, project, {
-            story_id: options.story.trim(), what: options.what, waiting_on: options.waitingOn,
-            next_step: options.nextStep, opened_at: deps.now().toISOString(), resolved_at: null, resolution: null,
-        });
-        console.log(JSON.stringify({ ok: true, action: "blocker.open", record }, null, 2));
-    }));
-    addProjectOptions(blocker.command("update").description("Update a blocker").argument("<blocker-id>", "Blocker id"))
-        .option("--waiting-on <text>", "Who or what is needed")
-        .option("--next-step <text>", "Next action")
-        .action(wrap(async (id, options) => {
-        const { store } = await target(deps, options);
-        if (options.waitingOn === undefined && options.nextStep === undefined)
-            fail("tracker_update_empty", "Supply --waiting-on or --next-step", {});
-        if (options.waitingOn !== undefined)
-            checkedText("waiting_on", options.waitingOn);
-        if (options.nextStep !== undefined)
-            checkedText("next_step", options.nextStep);
-        const current = await store.read("blocker", id);
-        if (!current)
-            fail("tracker_record_not_found", `Tracker blocker record ${id} was not found`, { kind: "blocker", id });
-        if (current.resolved_at !== null)
-            fail("tracker_already_resolved", "Blocker is already resolved", { id });
-        const record = await store.update("blocker", id, current.version, (value) => ({
-            ...value,
-            ...(options.waitingOn === undefined ? {} : { waiting_on: options.waitingOn }),
-            ...(options.nextStep === undefined ? {} : { next_step: options.nextStep }),
-        }));
-        console.log(JSON.stringify({ ok: true, action: "blocker.update", record }, null, 2));
-    }));
-    addProjectOptions(blocker.command("resolve").description("Resolve a blocker").argument("<blocker-id>", "Blocker id"))
-        .requiredOption("--resolution <text>", "Resolution details")
-        .action(wrap(async (id, options) => {
-        const { store } = await target(deps, options);
-        checkedText("resolution", options.resolution);
-        const current = await store.read("blocker", id);
-        if (!current)
-            fail("tracker_record_not_found", `Tracker blocker record ${id} was not found`, { kind: "blocker", id });
-        if (current.resolved_at !== null)
-            fail("tracker_already_resolved", "Blocker is already resolved", { id });
-        const record = await store.update("blocker", id, current.version, (value) => ({ ...value, resolved_at: deps.now().toISOString(), resolution: options.resolution }));
-        console.log(JSON.stringify({ ok: true, action: "blocker.resolve", record }, null, 2));
-    }));
-    addProjectOptions(blocker.command("list").description("List blockers")).option("--all", "Include resolved blockers")
-        .action(wrap(async (options) => {
-        const { store } = await target(deps, options);
-        const records = (await store.list("blocker")).filter((record) => options.all || record.resolved_at === null);
-        console.log(JSON.stringify({ ok: true, action: "blocker.list", records }, null, 2));
-    }));
-    const kpi = parent.command("kpi").description("Define KPIs and record values");
-    addProjectOptions(kpi.command("define").description("Define a proposed KPI"))
-        .requiredOption("--name <text>", "KPI name")
-        .requiredOption("--definition <text>", "Definition or query")
-        .requiredOption("--unit <unit>", "Measurement unit")
-        .requiredOption("--target <number>", "Target value")
-        .requiredOption("--direction <direction>", "up | down")
-        .action(wrap(async (options) => {
-        const { company, project, store } = await target(deps, options);
-        if (options.direction !== "up" && options.direction !== "down")
-            fail("tracker_direction_invalid", "KPI direction must be up or down", { direction: options.direction });
-        checkedText("name", options.name);
-        checkedText("definition", options.definition);
-        requiredText("unit", options.unit);
-        const record = await createRecord(store, "kpi", company.slug, project, {
-            name: options.name, definition: options.definition, unit: options.unit,
-            target: numberValue(options.target, "target"), direction: options.direction,
-            status: "proposed", approved_by: null, approved_at: null, values: [],
-        });
-        console.log(JSON.stringify({ ok: true, action: "kpi.define", record }, null, 2));
-    }));
-    addProjectOptions(kpi.command("record").description("Record a KPI value").argument("<kpi-id>", "KPI id"))
-        .requiredOption("--value <number>", "Observed value")
-        .requiredOption("--source <text>", "Value source")
-        .option("--at <iso>", "Observation time")
-        .action(wrap(async (id, options) => {
-        const { store } = await target(deps, options);
-        checkedText("source", options.source);
-        const value = numberValue(options.value, "value");
-        const at = options.at === undefined ? deps.now() : validTimestamp(options.at);
-        const current = await store.read("kpi", id);
-        if (!current)
-            fail("tracker_record_not_found", `Tracker KPI record ${id} was not found`, { kind: "kpi", id });
-        const values = current.values;
-        if (!Array.isArray(values))
-            fail("tracker_record_invalid", "KPI values must be an array", { id });
-        const record = await store.update("kpi", id, current.version, (record) => ({ ...record, values: [...values, { at: at.toISOString(), value, source: options.source }] }));
-        console.log(JSON.stringify({ ok: true, action: "kpi.record", record }, null, 2));
-    }));
-    addProjectOptions(kpi.command("approve").description("Approve a KPI proposal").argument("<kpi-id>", "KPI id"))
-        .option("--question <id>", "Answered owner question authorizing this approval")
-        .action(wrap(async (id, options) => {
-        const { company, project, store } = await target(deps, options);
-        const questionId = approvalQuestionId(deps, company, project, options.question);
-        const current = await store.read("kpi", id);
-        if (!current)
-            fail("tracker_record_not_found", `Tracker KPI record ${id} was not found`, { kind: "kpi", id });
-        const record = await store.update("kpi", id, current.version, (value) => {
-            if (value.status === "approved")
-                fail("tracker_already_approved", "KPI is already approved", { id });
-            return {
-                ...value,
-                status: "approved",
-                approved_by: requireActor(deps),
-                approved_at: deps.now().toISOString(),
-                ...(questionId ? { approval_question_id: questionId } : {}),
-            };
-        });
-        console.log(JSON.stringify({ ok: true, action: "kpi.approve", record }, null, 2));
-    }));
-    addProjectOptions(kpi.command("list").description("List KPIs")).action(wrap(async (options) => {
-        const { store } = await target(deps, options);
-        console.log(JSON.stringify({ ok: true, action: "kpi.list", records: await store.list("kpi") }, null, 2));
-    }));
-    const okr = parent.command("okr").description("Set and approve OKRs");
-    addProjectOptions(okr.command("set").description("Create a proposed OKR"))
-        .requiredOption("--objective <text>", "Objective")
-        .requiredOption("--period <period>", "Planning period")
-        .requiredOption("--key-result <text=kpi-id:target>", "Key result", (value, previous = []) => previous.concat(value))
-        .action(wrap(async (options) => {
-        const { company, project, store } = await target(deps, options);
-        checkedText("objective", options.objective);
-        requiredText("period", options.period);
-        if (!Array.isArray(options.keyResult) || options.keyResult.length === 0)
-            fail("tracker_key_result_invalid", "At least one --key-result is required", {});
-        const keyResults = options.keyResult.map(parseKr);
-        for (const keyResult of keyResults)
-            checkedText("key_result", keyResult.text);
-        for (const keyResult of keyResults) {
-            if (!await store.read("kpi", keyResult.kpi_id)) {
-                fail("tracker_kpi_not_found", `Referenced KPI ${keyResult.kpi_id} was not found in this project`, { kpi_id: keyResult.kpi_id, project_id: project });
-            }
-        }
-        const record = await createRecord(store, "okr", company.slug, project, {
-            objective: options.objective, period: options.period,
-            key_results: keyResults.map((value) => ({ kr_id: randomUUID(), ...value })),
-            status: "proposed", approved_by: null, approved_at: null,
-        });
-        console.log(JSON.stringify({ ok: true, action: "okr.set", record }, null, 2));
-    }));
-    addProjectOptions(okr.command("approve").description("Approve an OKR proposal").argument("<okr-id>", "OKR id"))
-        .option("--question <id>", "Answered owner question authorizing this approval")
-        .action(wrap(async (id, options) => {
-        const { company, project, store } = await target(deps, options);
-        const questionId = approvalQuestionId(deps, company, project, options.question);
-        const current = await store.read("okr", id);
-        if (!current)
-            fail("tracker_record_not_found", `Tracker OKR record ${id} was not found`, { kind: "okr", id });
-        const record = await store.update("okr", id, current.version, (value) => {
-            if (value.status === "approved")
-                fail("tracker_already_approved", "OKR is already approved", { id });
-            return {
-                ...value,
-                status: "approved",
-                approved_by: requireActor(deps),
-                approved_at: deps.now().toISOString(),
-                ...(questionId ? { approval_question_id: questionId } : {}),
-            };
-        });
-        console.log(JSON.stringify({ ok: true, action: "okr.approve", record }, null, 2));
-    }));
-    addProjectOptions(okr.command("list").description("List OKRs")).action(wrap(async (options) => {
-        const { store } = await target(deps, options);
-        console.log(JSON.stringify({ ok: true, action: "okr.list", records: await store.list("okr") }, null, 2));
-    }));
-    const directive = parent.command("directive").description("Record directives and acknowledgements");
-    addProjectOptions(directive.command("record").description("Record a directive"))
-        .requiredOption("--text <text>", "Verbatim directive")
-        .requiredOption("--date <yyyy-mm-dd>", "Directive date")
-        .requiredOption("--source-url <url>", "Source URL")
-        .requiredOption("--team <slug>", "Affected team (repeatable)", (value, previous = []) => previous.concat(value))
-        .option("--policy-path <path>", "Related policy path")
-        .action(wrap(async (options) => {
-        const { company, project, store } = await target(deps, options);
-        checkedText("text", options.text);
-        checkedText("source_url", options.sourceUrl);
-        const policyPath = options.policyPath === undefined
-            ? null
-            : checkedText("policy_path", options.policyPath, MAX_POLICY_PATH_BYTES);
-        const teams = (options.team ?? []).map((team) => validSegment(team, "team"));
-        if (teams.length === 0)
-            fail("tracker_input_invalid", "At least one --team is required", { field: "team" });
-        let url;
-        try {
-            url = new URL(options.sourceUrl);
-        }
-        catch {
-            return fail("tracker_source_url_invalid", "Source URL must be an absolute URL", {});
-        }
-        if (url.protocol !== "https:" && url.protocol !== "http:")
-            fail("tracker_source_url_invalid", "Source URL must use HTTP or HTTPS", {});
-        const record = await createRecord(store, "directive", company.slug, project, {
-            text: options.text, date: validDate(options.date), source_url: options.sourceUrl,
-            teams: [...new Set(teams)].sort(), policy_path: policyPath, acknowledgements: [],
-        });
-        console.log(JSON.stringify({ ok: true, action: "directive.record", record }, null, 2));
-    }));
-    addProjectOptions(directive.command("ack").description("Acknowledge a directive").argument("<directive-id>", "Directive id"))
-        .requiredOption("--team <slug>", "Acknowledging team")
-        .requiredOption("--lane <lane-id>", "Acknowledging lane id")
-        .action(wrap(async (id, options) => {
-        const { store } = await target(deps, options);
-        const team = validSegment(options.team, "team");
-        const lane = validSegment(options.lane, "lane");
-        const current = await store.read("directive", id);
-        if (!current)
-            fail("tracker_record_not_found", `Tracker directive record ${id} was not found`, { kind: "directive", id });
-        const teams = current.teams;
-        const acknowledgements = current.acknowledgements;
-        if (!Array.isArray(teams) || !teams.includes(team))
-            fail("tracker_team_not_targeted", "Team is not listed on this directive", { id, team });
-        if (!Array.isArray(acknowledgements))
-            fail("tracker_record_invalid", "Directive acknowledgements must be an array", { id });
-        const record = await store.update("directive", id, current.version, (value) => ({
-            ...value,
-            acknowledgements: [...acknowledgements.filter((ack) => !(ack && typeof ack === "object" && ack.team === team && ack.lane_id === lane)), { team, lane_id: lane, at: deps.now().toISOString() }],
-        }));
-        console.log(JSON.stringify({ ok: true, action: "directive.ack", record }, null, 2));
-    }));
-    addProjectOptions(directive.command("list").description("List directives")).action(wrap(async (options) => {
-        const { store } = await target(deps, options);
-        console.log(JSON.stringify({ ok: true, action: "directive.list", records: await store.list("directive") }, null, 2));
-    }));
-}
-export function defaultTrackerActor() {
-    const tokens = loadCachedTokens();
-    if (!tokens)
-        return null;
-    const claims = peekIdToken(tokens.idToken);
-    const uid = claims["custom:entityUid"];
-    if (typeof uid === "string" && uid.trim())
-        return uid.trim();
-    const sub = claims.sub;
-    return typeof sub === "string" && sub.trim() ? sub.trim() : null;
-}
-//# sourceMappingURL=lanes-tracker.js.map

package/dist/lib/daemon/sync-runner.d.ts

@@ -1,58 +0,0 @@
-/** Local status and resource controls shared by the daemon and its sync runner. */
-export declare const SYNC_RUNNER_OWNER = "hq-daemon";
-export declare const SYNC_RUNNER_LEASE_CONFLICT_EXIT = 20;
-export declare const SYNC_RUNNER_LEASE_RETRY_MS = 15000;
-export declare const DEFAULT_SYNC_HEARTBEAT_TIMEOUT_MS = 300000;
-export declare const DEFAULT_SYNC_RUNNER_HEAP_MB = 3584;
-export declare const SYNC_HEARTBEAT_TIMEOUT_ENV = "HQ_DAEMON_SYNC_HEARTBEAT_TIMEOUT_SECONDS";
-export declare const SYNC_RUNNER_HEAP_ENV = "HQ_SYNC_RUNNER_MAX_OLD_SPACE_MB";
-export interface WatchRunnerOwnerStatus {
-    owner: string;
-    pid: number;
-    version: string;
-    startedAt: string;
-    heartbeatAt: string;
-}
-export interface SyncRunnerProcess {
-    pid: number;
-    commandLine: string;
-}
-export type SyncRunnerProcessList = {
-    ok: true;
-    processes: SyncRunnerProcess[];
-} | {
-    ok: false;
-    error: string;
-};
-export interface ProcessListCommandResult {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    error?: Error;
-}
-export type ProcessListRunner = (command: string, args: string[]) => ProcessListCommandResult;
-export interface SyncPassResult {
-    status: "ok" | "partial" | "failed";
-    completedAt: string;
-    companiesAttempted?: number;
-    errors: number;
-    transient: number;
-}
-/** The status file path used by hq-cloud's watch-owner lease. */
-export declare function watchRunnerOwnerStatusPath(hqRoot: string, home?: string, env?: NodeJS.ProcessEnv): string;
-/** Read the watch-owner status JSON without taking or changing its lease. */
-export declare function readWatchRunnerOwnerStatus(statusPath: string): WatchRunnerOwnerStatus | null;
-/** Match a live process command line to the hq-cloud watch runner executable. */
-export declare function isSyncRunnerCommandLine(commandLine: string): boolean;
-/** Return a clear wait reason when an unleased runner already targets this HQ root. */
-export declare function syncRunnerUnleasedBlockReason(hqRoot: string, processes: readonly SyncRunnerProcess[], ownerPid: number | null, platform?: NodeJS.Platform, daemonRunnerPids?: ReadonlySet<number>): string | undefined;
-/** Read complete process command lines so root matching can include trailing arguments. */
-export declare function listSyncRunnerProcesses(platform?: NodeJS.Platform, run?: ProcessListRunner): SyncRunnerProcessList;
-/** The watchdog follows the runner's NDJSON protocol, the same liveness signal used by the desktop app. */
-export declare function parseSyncRunnerProtocolLine(line: string): Record<string, unknown> | null;
-/** Summarize the runner's all-complete event for daemon status. */
-export declare function syncPassResult(event: Record<string, unknown>, completedAt?: string): SyncPassResult | null;
-export declare function syncHeartbeatTimeoutMs(env: NodeJS.ProcessEnv): number;
-/** Preserve an explicit NODE_OPTIONS heap setting; otherwise apply the desktop runner's default/override. */
-export declare function syncRunnerNodeOptions(env: NodeJS.ProcessEnv): string | undefined;
-//# sourceMappingURL=sync-runner.d.ts.map