@indigoai-us/hq-cli 5.222.0 → 5.224.0

package/dist/commands/lanes-import.js

@@ -0,0 +1,1213 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { LanesError } from "../lib/lanes/errors.js";
+import { assertNoSecretText } from "../lib/lanes/text-scan.js";
+import { createLocalTrackerStore, } from "../lib/lanes/tracker-store.js";
+import { LANES_TRACKER_FLAG, LANES_TRACKER_MESH_FLAG } from "./lanes-tracker.js";
+const IMPORT_DATE = "2026-09-25";
+const IMPORT_KEY_PREFIX = "trk7";
+const MAX_TEXT_BYTES = 32_000;
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function within(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+function validSegment(value, field) {
+    const normalized = value.trim();
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(normalized) || normalized === "." || normalized === "..") {
+        return fail("tracker_import_input_invalid", `${field} must be a safe path segment`, { field });
+    }
+    return normalized;
+}
+function relativeSource(root, absolutePath) {
+    return path.relative(root, absolutePath).split(path.sep).join("/");
+}
+function resolveSourcePath(root, raw, field) {
+    if (typeof raw !== "string" || !raw.trim()) {
+        return fail("tracker_import_input_invalid", `${field} must be a path`, { field });
+    }
+    const lexicalRoot = path.resolve(root);
+    const candidate = path.resolve(lexicalRoot, raw);
+    if (!within(lexicalRoot, candidate)) {
+        return fail("tracker_import_path_outside_root", `${field} resolves outside the HQ root`, { field, path: candidate });
+    }
+    try {
+        const rootReal = fs.realpathSync(root);
+        const real = fs.realpathSync(candidate);
+        if (!within(rootReal, real)) {
+            return fail("tracker_import_path_outside_root", `${field} resolves outside the HQ root`, { field, path: real });
+        }
+        return real;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return candidate;
+        if (err instanceof LanesError)
+            throw err;
+        return fail("tracker_import_path_unreadable", `${field} could not be resolved`, { field, path: candidate });
+    }
+}
+function readText(file, source) {
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            return fail("tracker_import_input_invalid", `${source} must be a regular file`, { path: file, source });
+        }
+        return fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err instanceof LanesError)
+            throw err;
+        const code = err.code;
+        if (code === "ENOENT")
+            return fail("tracker_import_input_missing", `${source} file is missing`, { path: file, source });
+        return fail("tracker_import_input_unreadable", `${source} file could not be read`, { path: file, source });
+    }
+}
+function readJsonObject(file, source) {
+    const text = readText(file, source);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return fail("tracker_import_input_malformed", `${source} file contains invalid JSON`, { path: file, source });
+    }
+    if (!isObject(parsed)) {
+        return fail("tracker_import_input_invalid", `${source} file must contain a JSON object`, { path: file, source });
+    }
+    return parsed;
+}
+function companyFromPrd(prd, file) {
+    const metadata = isObject(prd.metadata) ? prd.metadata : undefined;
+    const raw = prd.company ?? metadata?.company;
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw === "string")
+        return raw;
+    if (isObject(raw) && typeof raw.slug === "string")
+        return raw.slug;
+    return fail("tracker_import_prd_invalid", "Project company metadata must name a company slug", { path: file });
+}
+function resolveCompanyPrd(root, company, rawPath) {
+    const candidate = resolveSourcePath(root, rawPath, "prd");
+    const rootReal = fs.realpathSync(root);
+    const candidateParts = path.relative(rootReal, candidate).split(path.sep);
+    if (candidateParts[0] !== "companies" || candidateParts[1] !== company || candidateParts[2] !== "projects" || candidateParts.length !== 5 || candidateParts[4] !== "prd.json") {
+        return fail("tracker_import_scope_refused", "Team prd.json must belong to the selected company's project", { path: candidate, company });
+    }
+    let real;
+    try {
+        const stat = fs.lstatSync(candidate);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            return fail("tracker_import_input_invalid", "Team prd.json must be a regular file", { path: candidate, source: "prd" });
+        }
+        real = fs.realpathSync(candidate);
+    }
+    catch (err) {
+        if (err instanceof LanesError)
+            throw err;
+        if (err.code === "ENOENT") {
+            return fail("tracker_import_input_missing", "Team prd.json file is missing", { path: candidate, source: "prd" });
+        }
+        return fail("tracker_import_input_unreadable", "Team prd.json path could not be resolved", { path: candidate, source: "prd" });
+    }
+    if (!within(rootReal, real)) {
+        return fail("tracker_import_scope_refused", "Team prd.json resolves outside this HQ root", { path: real });
+    }
+    const parts = path.relative(rootReal, real).split(path.sep);
+    if (parts[0] !== "companies" || parts[1] !== company || parts[2] !== "projects" || parts.length !== 5 || parts[4] !== "prd.json") {
+        return fail("tracker_import_scope_refused", "Team prd.json must belong to the selected company's project", { path: real, company });
+    }
+    const projectId = validSegment(parts[3], "project");
+    return { path: real, projectId };
+}
+function resolveStatusPath(root, company, rawPath) {
+    const candidate = resolveSourcePath(root, rawPath, "status");
+    let real;
+    try {
+        const stat = fs.lstatSync(candidate);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            return fail("tracker_import_input_invalid", "Team status must be a regular file", { path: candidate, source: "status" });
+        }
+        real = fs.realpathSync(candidate);
+    }
+    catch (err) {
+        if (err instanceof LanesError)
+            throw err;
+        if (err.code === "ENOENT") {
+            return fail("tracker_import_input_missing", "Team status file is missing", { path: candidate, source: "status" });
+        }
+        return fail("tracker_import_input_unreadable", "Team status path could not be resolved", { path: candidate, source: "status" });
+    }
+    const rootReal = fs.realpathSync(root);
+    const parts = path.relative(rootReal, real).split(path.sep);
+    if (!within(rootReal, real) || (parts[0] === "companies" && parts[1] !== company)) {
+        return fail("tracker_import_scope_refused", "Team status resolves outside the selected company's HQ root", { path: real, company });
+    }
+    return real;
+}
+function requireStoryList(prd, file) {
+    const raw = prd.userStories === undefined ? prd.stories : prd.userStories;
+    if (!Array.isArray(raw)) {
+        return fail("tracker_import_prd_invalid", "Project prd.json must contain a userStories or stories array", { path: file });
+    }
+    return raw.map((story, index) => {
+        if (!isObject(story)) {
+            return fail("tracker_import_prd_invalid", "Project story must be an object", { path: file, index });
+        }
+        return story;
+    });
+}
+function safeSourceId(value, fallback) {
+    if (typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value) && value !== "." && value !== "..") {
+        return `id:${value}`;
+    }
+    return fallback;
+}
+function digest(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 24);
+}
+function importKey(team, sourcePath, sourceItemId) {
+    return `${IMPORT_KEY_PREFIX}:${team}:${sourcePath}:${sourceItemId}`;
+}
+function importedRecordId(candidate) {
+    return `trk7-${createHash("sha256").update(candidate.importKey).digest("hex")}`;
+}
+function normalizeName(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
+}
+function finiteNumber(raw) {
+    if (typeof raw === "number")
+        return Number.isFinite(raw) ? raw : null;
+    if (typeof raw !== "string" || !/^-?(?:\d+(?:\.\d*)?|\.\d+)$/.test(raw.trim()))
+        return null;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function isoTimestamp(raw) {
+    if (typeof raw !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw))
+        return null;
+    const parsed = new Date(raw);
+    return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : null;
+}
+function sourceTimestamp(raw) {
+    const timestamp = isoTimestamp(raw);
+    if (timestamp)
+        return timestamp;
+    if (typeof raw === "string" && /^\d{4}-\d{2}-\d{2}$/.test(raw.trim())) {
+        const date = dateFrom(raw);
+        return date ? `${date}T00:00:00.000Z` : null;
+    }
+    return null;
+}
+function dateFrom(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const match = /^(\d{4}-\d{2}-\d{2})/.exec(raw.trim());
+    if (!match)
+        return null;
+    const parsed = new Date(`${match[1]}T00:00:00.000Z`);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === match[1] ? match[1] : null;
+}
+function dateInText(raw) {
+    const match = /\b(\d{4}-\d{2}-\d{2})\b/.exec(raw);
+    return match ? dateFrom(match[1]) : null;
+}
+function direction(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const normalized = raw.trim().toLowerCase();
+    if (/^(?:up|higher|increase|increasing|more|greater|fewer errors prevented)$/i.test(normalized))
+        return "up";
+    if (/^(?:down|lower|decrease|decreasing|less|fewer|reduce)$/i.test(normalized))
+        return "down";
+    return null;
+}
+function addSkip(result, entry) {
+    result.skipped.push(entry);
+}
+function addSecretError(result, field, category, sourcePath, kind) {
+    result.errors.push({ error: "secret_text_refused", field, category, source_path: sourcePath });
+    addSkip(result, { kind, source_path: sourcePath, reason: "secret_text_refused", field, category });
+}
+function checkedText(result, kind, sourcePath, sourceItemId, field, raw, options = {}) {
+    if (typeof raw !== "string" || !raw.trim()) {
+        addSkip(result, { kind, source_path: sourcePath, source_item_id: sourceItemId, reason: "missing_or_empty_field", field });
+        return null;
+    }
+    if (Buffer.byteLength(raw, "utf8") > MAX_TEXT_BYTES) {
+        addSkip(result, { kind, source_path: sourcePath, source_item_id: sourceItemId, reason: "field_too_long", field });
+        return null;
+    }
+    try {
+        assertNoSecretText(field, raw);
+    }
+    catch (err) {
+        const category = err instanceof LanesError && typeof err.details.kind === "string" ? err.details.kind : "sensitive_text";
+        addSecretError(result, field, category, sourcePath, kind);
+        return null;
+    }
+    return options.preserveWhitespace ? raw : raw.trim();
+}
+function recordCandidate(team, kind, sourcePath, sourceItemId, managed, createOnly = {}, warnings = []) {
+    const key = importKey(team, sourcePath, sourceItemId);
+    return {
+        kind,
+        importKey: key,
+        sourcePath,
+        sourceItemId,
+        managed: { ...managed, import_key: key, source_path: sourcePath, source_item_id: sourceItemId },
+        createOnly,
+        warnings,
+    };
+}
+function uniqueCandidates(candidates, result) {
+    const counts = new Map();
+    for (const candidate of candidates)
+        counts.set(candidate.importKey, (counts.get(candidate.importKey) ?? 0) + 1);
+    const reported = new Set();
+    const unique = [];
+    for (const candidate of candidates) {
+        if (counts.get(candidate.importKey) === 1) {
+            unique.push(candidate);
+            continue;
+        }
+        if (reported.has(candidate.importKey))
+            continue;
+        reported.add(candidate.importKey);
+        result.errors.push({
+            error: "tracker_import_duplicate_source_key",
+            path: candidate.sourcePath,
+            source_item_id: candidate.sourceItemId,
+        });
+        addSkip(result, {
+            kind: candidate.kind,
+            source_path: candidate.sourcePath,
+            source_item_id: candidate.sourceItemId,
+            reason: "duplicate_source_key",
+        });
+    }
+    return unique;
+}
+function kpiEntries(raw) {
+    if (Array.isArray(raw))
+        return raw.map((value, index) => ({ value, hint: "", index }));
+    if (!isObject(raw))
+        return null;
+    const metricKeys = ["name", "value", "target", "unit", "direction", "better", "measured_at"];
+    if (metricKeys.some((key) => key in raw))
+        return [{ value: raw, hint: "", index: 0 }];
+    return Object.entries(raw).map(([hint, value], index) => ({ value, hint, index }));
+}
+function parseKpis(status, result, team, statusSource) {
+    const candidates = [];
+    const seenNames = new Set();
+    const groups = [
+        { field: "kpis", value: status.kpis },
+        { field: "kpi", value: status.kpi },
+        { field: "kpi_headline", value: status.kpi_headline },
+    ];
+    for (const group of groups) {
+        if (group.value === undefined || group.value === null)
+            continue;
+        const entries = kpiEntries(group.value);
+        if (entries === null) {
+            addSkip(result, { kind: "kpi", source_path: statusSource, source_item_id: group.field, reason: "unsupported_kpi_shape" });
+            continue;
+        }
+        for (const entry of entries) {
+            const itemId = isObject(entry.value)
+                ? safeSourceId(entry.value.id, `hash:${digest({ name: entry.value.name ?? entry.hint, unit: entry.value.unit })}`)
+                : `index:${entry.index}`;
+            if (!isObject(entry.value)) {
+                addSkip(result, { kind: "kpi", source_path: statusSource, source_item_id: itemId, reason: "unsupported_kpi_item_shape" });
+                continue;
+            }
+            const raw = entry.value;
+            const sourceItemId = `${group.field}:${itemId}`;
+            const name = checkedText(result, "kpi", statusSource, sourceItemId, "name", raw.name ?? entry.hint);
+            if (!name)
+                continue;
+            const duplicateKey = normalizeName(name);
+            if (seenNames.has(duplicateKey)) {
+                addSkip(result, { kind: "kpi", source_path: statusSource, source_item_id: sourceItemId, reason: "duplicate_kpi_name" });
+                continue;
+            }
+            const unit = checkedText(result, "kpi", statusSource, sourceItemId, "unit", raw.unit);
+            const definitionRaw = raw.definition ?? raw.detail ?? raw.note ?? name;
+            const definition = checkedText(result, "kpi", statusSource, sourceItemId, "definition", definitionRaw);
+            const target = finiteNumber(raw.target);
+            const value = finiteNumber(raw.value);
+            const measuredAt = isoTimestamp(raw.measured_at);
+            const better = direction(raw.direction ?? raw.better);
+            const missing = [];
+            if (!unit)
+                missing.push("unit");
+            if (target === null)
+                missing.push("target");
+            if (value === null)
+                missing.push("value");
+            if (!measuredAt)
+                missing.push("measured_at");
+            if (!better)
+                missing.push("direction_or_better");
+            if (!definition)
+                missing.push("definition");
+            if (missing.length) {
+                addSkip(result, { kind: "kpi", source_path: statusSource, source_item_id: sourceItemId, reason: "missing_or_invalid_fields", fields: missing });
+                continue;
+            }
+            seenNames.add(duplicateKey);
+            const managed = {
+                name,
+                definition,
+                unit,
+                target,
+                direction: better,
+                values: [{
+                        at: measuredAt,
+                        value,
+                        source: statusSource,
+                        import_key: importKey(team, statusSource, sourceItemId),
+                    }],
+            };
+            candidates.push(recordCandidate(team, "kpi", statusSource, sourceItemId, managed, {
+                status: "proposed",
+                approved_by: null,
+                approved_at: null,
+            }));
+        }
+    }
+    if (groups.every((group) => group.value === undefined || group.value === null)) {
+        addSkip(result, { kind: "kpi", source_path: statusSource, reason: "no_kpi_field" });
+    }
+    return candidates;
+}
+function entriesForField(raw) {
+    if (Array.isArray(raw))
+        return raw.map((value, index) => ({ value, index }));
+    if (isObject(raw))
+        return [{ value: raw, index: 0 }];
+    if (typeof raw === "string")
+        return [{ value: raw, index: 0 }];
+    return null;
+}
+function closedBlocker(raw) {
+    const state = raw.status ?? raw.state;
+    return raw.closed === true || raw.resolved === true || raw.closed_at != null || raw.resolved_at != null ||
+        (typeof state === "string" && /^(closed|resolved|done|dropped)$/i.test(state));
+}
+function parseStatusBlockers(status, result, team, statusSource, now) {
+    const candidates = [];
+    const groups = ["blockers", "blocked"];
+    let found = false;
+    for (const field of groups) {
+        const raw = status[field];
+        if (raw === undefined || raw === null)
+            continue;
+        found = true;
+        const entries = entriesForField(raw);
+        if (!entries) {
+            addSkip(result, { kind: "blocker", source_path: statusSource, source_item_id: field, reason: "unsupported_blocker_shape" });
+            continue;
+        }
+        for (const entry of entries) {
+            const object = isObject(entry.value) ? entry.value : null;
+            const itemId = object
+                ? safeSourceId(object.id, `hash:${digest({ what: object.what ?? object.item ?? object.reason, story: object.story_id })}`)
+                : `index:${entry.index}`;
+            const sourceItemId = `${field}:${itemId}`;
+            const sourceClosed = object !== null && closedBlocker(object);
+            const rawWhat = typeof entry.value === "string" ? entry.value : object?.what ?? object?.item ?? object?.reason ?? object?.note;
+            const rawWaiting = object?.waiting_on ?? object?.blocked_on ?? object?.owner;
+            const rawNext = object?.next_step ?? object?.next;
+            const what = sourceClosed && rawWhat == null ? null : checkedText(result, "blocker", statusSource, sourceItemId, "what", rawWhat);
+            const waitingOn = sourceClosed && rawWaiting == null ? null : rawWaiting === undefined ? null : checkedText(result, "blocker", statusSource, sourceItemId, "waiting_on", rawWaiting);
+            const nextStep = sourceClosed && rawNext == null ? null : rawNext === undefined ? null : checkedText(result, "blocker", statusSource, sourceItemId, "next_step", rawNext);
+            const storyIdRaw = object?.story_id ?? object?.story;
+            const storyId = typeof storyIdRaw === "string" && storyIdRaw.trim() ? validSegment(storyIdRaw, "story id") : null;
+            const openedAt = dateFrom(object?.opened_at ?? object?.since ?? object?.added ?? object?.at);
+            const missing = [
+                ...(!sourceClosed && !what ? ["what"] : []),
+                ...(!sourceClosed && !waitingOn ? ["waiting_on"] : []),
+                ...(!sourceClosed && !nextStep ? ["next_step"] : []),
+                ...(!sourceClosed && !storyId ? ["story_id"] : []),
+                ...(!sourceClosed && !openedAt ? ["opened_at"] : []),
+            ];
+            if (missing.length) {
+                addSkip(result, { kind: "blocker", source_path: statusSource, source_item_id: sourceItemId, reason: "missing_required_blocker_fields", fields: missing });
+                continue;
+            }
+            const managed = {};
+            if (what)
+                managed.what = what;
+            if (waitingOn)
+                managed.waiting_on = waitingOn;
+            if (nextStep)
+                managed.next_step = nextStep;
+            if (storyId)
+                managed.story_id = storyId;
+            if (openedAt)
+                managed.opened_at = `${openedAt}T00:00:00.000Z`;
+            let closedSourceWithoutTimestamp = false;
+            if (sourceClosed) {
+                const rawResolvedAt = object?.resolved_at ?? object?.closed_at;
+                closedSourceWithoutTimestamp = rawResolvedAt === undefined || rawResolvedAt === null;
+                const resolvedAt = closedSourceWithoutTimestamp ? now().toISOString() : sourceTimestamp(rawResolvedAt);
+                if (!resolvedAt) {
+                    addSkip(result, { kind: "blocker", source_path: statusSource, source_item_id: sourceItemId, reason: "invalid_resolution_timestamp", field: "closed_at" });
+                    continue;
+                }
+                const resolution = checkedText(result, "blocker", statusSource, sourceItemId, "resolution", object?.resolution ?? "Closed in source status");
+                if (!resolution)
+                    continue;
+                managed.resolved_at = resolvedAt;
+                managed.resolution = resolution;
+            }
+            else {
+                managed.resolved_at = null;
+                managed.resolution = null;
+            }
+            const candidate = recordCandidate(team, "blocker", statusSource, sourceItemId, managed);
+            if (sourceClosed) {
+                candidate.closedSource = true;
+                candidate.closedSourceWithoutTimestamp = closedSourceWithoutTimestamp;
+            }
+            candidates.push(candidate);
+        }
+    }
+    if (!found)
+        addSkip(result, { kind: "blocker", source_path: statusSource, reason: "no_blocker_field" });
+    return candidates;
+}
+function parseBlockedStories(stories, result, team, prdSource) {
+    const candidates = [];
+    for (const [index, story] of stories.entries()) {
+        const state = typeof story.state === "string" ? story.state : story.status;
+        if (typeof state !== "string" || state.toLowerCase() !== "blocked")
+            continue;
+        const rawId = story.id;
+        const storyId = typeof rawId === "string" && rawId.trim() ? validSegment(rawId, "story id") : null;
+        const sourceItemId = `story:${storyId ?? `index-${index}`}`;
+        const what = checkedText(result, "blocker", prdSource, sourceItemId, "what", story.title ?? story.description);
+        const rawWaiting = story.waiting_on ?? story.blocked_on;
+        const waitingOn = rawWaiting === undefined ? null : checkedText(result, "blocker", prdSource, sourceItemId, "waiting_on", rawWaiting);
+        const notes = isObject(story.notes) ? story.notes : undefined;
+        const rawNext = story.next_step ?? notes?.next_step;
+        const nextStep = rawNext === undefined ? null : checkedText(result, "blocker", prdSource, sourceItemId, "next_step", rawNext);
+        const opened = dateFrom(story.created_at ?? story.updated_at);
+        const missing = [
+            ...(!storyId ? ["story_id"] : []),
+            ...(what ? [] : ["what"]),
+            ...(waitingOn ? [] : ["waiting_on"]),
+            ...(nextStep ? [] : ["next_step"]),
+            ...(!opened ? ["opened_at"] : []),
+        ];
+        if (missing.length) {
+            addSkip(result, { kind: "blocker", source_path: prdSource, source_item_id: sourceItemId, reason: "missing_required_blocker_fields", fields: missing });
+            continue;
+        }
+        const managed = { story_id: storyId, what, waiting_on: waitingOn, next_step: nextStep, opened_at: `${opened}T00:00:00.000Z`, resolved_at: null, resolution: null };
+        candidates.push(recordCandidate(team, "blocker", prdSource, sourceItemId, managed));
+    }
+    return candidates;
+}
+function markdownGoalDrafts(text, sourcePath) {
+    const lines = text.split(/\r?\n/);
+    const objectives = [];
+    const pendingKeyResults = [];
+    let inKpis = false;
+    let inGoalCriteria = false;
+    let goalHeadingPending = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        const heading = /^#{1,6}\s+(.+)$/.exec(trimmed)?.[1];
+        if (heading) {
+            inKpis = false;
+            inGoalCriteria = /^goal and (?:done|success) criteria\b/i.test(heading);
+            goalHeadingPending = inGoalCriteria;
+            continue;
+        }
+        const plain = trimmed.replace(/^[-*+]\s+/, "").replace(/\*\*/g, "").trim();
+        const labeled = /^(objective|okr|goal)\.?\s*[:.]\s*(.+)$/i.exec(plain);
+        if (labeled?.[2]) {
+            objectives.push({ text: labeled[2].trim(), line: index + 1, keyResults: pendingKeyResults.splice(0) });
+            goalHeadingPending = false;
+            continue;
+        }
+        const goalSentence = /^(?:the\s+)?goal\s+is\s+(?:to\s+)?(.+)$/i.exec(plain);
+        if (goalSentence?.[1]) {
+            objectives.push({ text: goalSentence[1].trim(), line: index + 1, keyResults: pendingKeyResults.splice(0) });
+            continue;
+        }
+        if (goalHeadingPending && trimmed) {
+            objectives.push({ text: plain.replace(/^\d+[.)]\s*/, "").trim(), line: index + 1, keyResults: pendingKeyResults.splice(0) });
+            goalHeadingPending = false;
+        }
+        if (/^\s*(?:KPIs?|Key results?)\s*:/i.test(line)) {
+            inKpis = true;
+            continue;
+        }
+        if (inKpis && !trimmed)
+            continue;
+        const bullet = /^\s*(?:[-*+]\s+|\d+[.)]\s+)(.+)$/.exec(line);
+        if (inKpis && bullet?.[1]) {
+            const keyResult = { sourceItemId: `line:${index + 1}`, text: bullet[1].trim() };
+            const current = objectives.at(-1);
+            if (current)
+                current.keyResults.push(keyResult);
+            else
+                pendingKeyResults.push(keyResult);
+            continue;
+        }
+        if (inGoalCriteria && bullet?.[1]) {
+            const keyResult = { sourceItemId: `line:${index + 1}`, text: bullet[1].trim() };
+            const current = objectives.at(-1);
+            if (current)
+                current.keyResults.push(keyResult);
+            else
+                pendingKeyResults.push(keyResult);
+        }
+        if (inKpis && trimmed && !bullet && !/^\s/.test(line))
+            inKpis = false;
+    }
+    if (objectives.length === 0)
+        return [];
+    const period = /\b(?:each|every)\s+week\b|week-over-week/i.test(text)
+        ? "weekly"
+        : /\b(?:each|every)\s+hour\b|hourly/i.test(text)
+            ? "hourly"
+            : /trailing\s+\d+\s+days?/i.exec(text)?.[0] ?? "unspecified";
+    return objectives.map((objective, index) => ({
+        sourcePath,
+        sourceItemId: `brief-line:${objective.line}:${index}`,
+        objective: objective.text,
+        period,
+        keyResults: objective.keyResults.map((item) => ({ ...item })),
+        warnings: period === "unspecified" ? [{ field: "period", reason: "period_not_stated_in_source" }] : [],
+    }));
+}
+function keyResultDraft(item, sourceItemId) {
+    if (typeof item === "string")
+        return { sourceItemId, text: item };
+    if (!isObject(item))
+        return { sourceItemId, text: "", invalidFields: ["key_result"] };
+    const invalidFields = [];
+    const rawText = item.text ?? item.name;
+    if (typeof rawText !== "string")
+        invalidFields.push("key_result");
+    if ("kpi_name" in item && item.kpi_name !== undefined && typeof item.kpi_name !== "string") {
+        invalidFields.push("kpi_name");
+    }
+    return {
+        sourceItemId,
+        text: typeof rawText === "string" ? rawText : "",
+        ...(typeof item.kpi_name === "string" ? { kpiName: item.kpi_name } : {}),
+        ...(finiteNumber(item.target) !== null ? { target: finiteNumber(item.target) } : {}),
+        ...(invalidFields.length ? { invalidFields } : {}),
+    };
+}
+function structuredOkrDrafts(status, sourcePath) {
+    const drafts = [];
+    const skips = [];
+    for (const field of ["okrs", "okr", "goals", "goal", "objective"]) {
+        const raw = status[field];
+        if (raw === undefined || raw === null)
+            continue;
+        const values = Array.isArray(raw) ? raw : [raw];
+        for (const [index, value] of values.entries()) {
+            if (typeof value === "string") {
+                const keyResultsRaw = status.key_results ?? status.keyResults ?? status.krs;
+                const keyResults = Array.isArray(keyResultsRaw) ? keyResultsRaw : [];
+                drafts.push({
+                    sourcePath,
+                    sourceItemId: `${field}:${index}`,
+                    objective: value,
+                    period: typeof status.period === "string" && status.period.trim() ? status.period.trim() : "unspecified",
+                    keyResults: keyResults.map((item, krIndex) => keyResultDraft(item, `${field}:${index}:kr:${krIndex}`)),
+                    warnings: typeof status.period === "string" ? [] : [{ field: "period", reason: "period_not_stated_in_source" }],
+                });
+                continue;
+            }
+            if (!isObject(value)) {
+                skips.push({ kind: "okr", source_path: sourcePath, source_item_id: `${field}:${index}`, reason: "unsupported_okr_shape" });
+                continue;
+            }
+            const objective = value.objective ?? value.goal ?? value.text;
+            const rawResults = value.key_results ?? value.keyResults ?? value.krs;
+            const results = Array.isArray(rawResults) ? rawResults : [];
+            drafts.push({
+                sourcePath,
+                sourceItemId: safeSourceId(value.id, `${field}:${index}`),
+                objective: typeof objective === "string" ? objective : "",
+                period: typeof value.period === "string" && value.period.trim() ? value.period.trim() : "unspecified",
+                keyResults: results.map((item, krIndex) => keyResultDraft(item, isObject(item) ? safeSourceId(item.id, `index:${krIndex}`) : `index:${krIndex}`)),
+                warnings: typeof value.period === "string" ? [] : [{ field: "period", reason: "period_not_stated_in_source" }],
+            });
+        }
+    }
+    return { drafts, skips };
+}
+function kpiMatch(text, explicitName, candidates) {
+    const query = normalizeName(explicitName ?? text);
+    if (!query)
+        return null;
+    const matches = candidates.filter((candidate) => {
+        const name = normalizeName(String(candidate.managed.name ?? ""));
+        return name !== "" && query === name;
+    });
+    return matches.length === 1 ? matches[0] : null;
+}
+function okrCandidates(drafts, kpis, result, team) {
+    const candidates = [];
+    for (const draft of drafts) {
+        const sourceItemId = draft.sourceItemId;
+        const objective = checkedText(result, "okr", draft.sourcePath, sourceItemId, "objective", draft.objective);
+        const period = checkedText(result, "okr", draft.sourcePath, sourceItemId, "period", draft.period);
+        if (!objective || !period)
+            continue;
+        if (draft.keyResults.length === 0) {
+            addSkip(result, { kind: "okr", source_path: draft.sourcePath, source_item_id: sourceItemId, reason: "no_key_results_found" });
+            continue;
+        }
+        const keyResults = [];
+        const keyLinks = [];
+        let invalid = false;
+        for (const keyResult of draft.keyResults) {
+            if (keyResult.invalidFields?.length) {
+                addSkip(result, {
+                    kind: "okr",
+                    source_path: draft.sourcePath,
+                    source_item_id: `${sourceItemId}:${keyResult.sourceItemId}`,
+                    reason: "unsupported_key_result_shape",
+                    fields: keyResult.invalidFields,
+                });
+                invalid = true;
+                continue;
+            }
+            const explicitKpiName = keyResult.kpiName === undefined
+                ? undefined
+                : checkedText(result, "okr", draft.sourcePath, `${sourceItemId}:${keyResult.sourceItemId}`, "kpi_name", keyResult.kpiName);
+            if (keyResult.kpiName !== undefined && explicitKpiName === null) {
+                invalid = true;
+                continue;
+            }
+            const text = checkedText(result, "okr", draft.sourcePath, `${sourceItemId}:${keyResult.sourceItemId}`, "key_result", keyResult.text);
+            if (!text) {
+                invalid = true;
+                continue;
+            }
+            const match = explicitKpiName === null ? null : kpiMatch(text, explicitKpiName, kpis);
+            const krId = `kr-${digest({ importKey: importKey(team, draft.sourcePath, sourceItemId), item: keyResult.sourceItemId })}`;
+            if (!match) {
+                result.unlinked_key_results.push({
+                    source_path: draft.sourcePath,
+                    source_item_id: sourceItemId,
+                    key_result_id: krId,
+                    text,
+                    reason: "no_imported_kpi_name_match",
+                });
+                continue;
+            }
+            const target = keyResult.target ?? finiteNumber(match.managed.target);
+            if (target === null || !Number.isFinite(target)) {
+                result.unlinked_key_results.push({
+                    source_path: draft.sourcePath,
+                    source_item_id: sourceItemId,
+                    key_result_id: krId,
+                    text,
+                    reason: "missing_finite_target",
+                });
+                continue;
+            }
+            keyResults.push({ kr_id: krId, text, kpi_id: null, target });
+            keyLinks.push({ krId, importKey: match.importKey });
+        }
+        if (invalid || keyResults.length === 0) {
+            if (keyResults.length === 0 && !invalid) {
+                addSkip(result, { kind: "okr", source_path: draft.sourcePath, source_item_id: sourceItemId, reason: "no_linked_key_results" });
+            }
+            continue;
+        }
+        const candidate = recordCandidate(team, "okr", draft.sourcePath, sourceItemId, {
+            objective,
+            period,
+            key_results: keyResults,
+        }, {
+            status: "proposed",
+            approved_by: null,
+            approved_at: null,
+        }, draft.warnings);
+        candidate.keyLinks = keyLinks;
+        candidates.push(candidate);
+    }
+    return candidates;
+}
+function aliasesForTeam(team, projectId, statusStem) {
+    return [...new Set([team, projectId, statusStem, team.replace(/-/g, " "), projectId.replace(/-/g, " "), statusStem.replace(/-/g, " ")])]
+        .filter((value) => value.length >= 3);
+}
+function mentionsTeam(text, aliases) {
+    return aliases.some((alias) => {
+        const pattern = alias.split(/[-\s]+/).map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[-\\s]+");
+        return new RegExp(`(?:^|[^a-z0-9])${pattern}(?:$|[^a-z0-9])`, "i").test(text);
+    });
+}
+function globalDirectiveItems(markdown, aliases) {
+    const lines = markdown.split(/\r?\n/);
+    const items = [];
+    let sectionDate = null;
+    let current = [];
+    const flush = () => {
+        const text = current.join("\n").trim();
+        current = [];
+        if (!text)
+            return;
+        const inlineDate = dateInText(text);
+        if ((inlineDate ?? sectionDate) !== IMPORT_DATE || !mentionsTeam(text, aliases))
+            return;
+        items.push({ text, sourceItemId: `hash:${digest(text)}` });
+    };
+    for (const line of lines) {
+        const heading = /^#{1,6}\s+(.+)$/.exec(line.trim())?.[1];
+        if (heading) {
+            flush();
+            sectionDate = dateInText(heading);
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed) {
+            flush();
+            continue;
+        }
+        if (/^(?:[-*+]\s+|\d+[.)]\s+)/.test(trimmed) && current.length > 0) {
+            flush();
+        }
+        current.push(line);
+    }
+    flush();
+    return items;
+}
+function statusDirectiveItems(status, result, statusSource) {
+    const items = [];
+    for (const field of ["directives", "operator_directives"]) {
+        const raw = status[field];
+        if (raw === undefined || raw === null)
+            continue;
+        const entries = Array.isArray(raw) ? raw : isObject(raw) ? [raw] : typeof raw === "string" ? [raw] : null;
+        if (!entries) {
+            addSkip(result, { kind: "directive", source_path: statusSource, source_item_id: field, reason: "unsupported_directive_shape" });
+            continue;
+        }
+        for (const entry of entries) {
+            const object = isObject(entry) ? entry : null;
+            const rawText = typeof entry === "string" ? entry : object?.text ?? object?.directive;
+            const explicitId = object ? safeSourceId(object.id, "") : "";
+            if (!explicitId && (typeof rawText !== "string" || !rawText.trim())) {
+                addSkip(result, { kind: "directive", source_path: statusSource, source_item_id: field, reason: "directive_identity_missing" });
+                continue;
+            }
+            const sourceItemId = `${field}:${explicitId || `hash:${digest(rawText)}`}`;
+            const entryDate = dateFrom(object?.date ?? object?.at ?? object?.created_at) ??
+                (typeof rawText === "string" ? dateInText(rawText) : null);
+            if (entryDate !== IMPORT_DATE) {
+                addSkip(result, { kind: "directive", source_path: statusSource, source_item_id: sourceItemId, reason: entryDate ? "outside_requested_date" : "directive_date_missing" });
+                continue;
+            }
+            const text = checkedText(result, "directive", statusSource, sourceItemId, "text", rawText, { preserveWhitespace: true });
+            if (text === null)
+                continue;
+            items.push({ text, sourceItemId });
+        }
+    }
+    return items;
+}
+function directiveCandidates(team, status, statusSource, globalItems, globalSource, result) {
+    const fromStatus = statusDirectiveItems(status, result, statusSource)
+        .map((item) => ({ ...item, sourcePath: statusSource }));
+    const fromGlobal = globalItems.map((item) => ({ ...item, sourcePath: globalSource }));
+    const combined = [...fromStatus, ...fromGlobal];
+    if (combined.length === 0 && status.directives === undefined && status.operator_directives === undefined && globalItems.length === 0) {
+        addSkip(result, { kind: "directive", source_path: statusSource, reason: "no_directive_source" });
+    }
+    const candidates = [];
+    for (const item of combined) {
+        const text = checkedText(result, "directive", item.sourcePath, item.sourceItemId, "text", item.text, { preserveWhitespace: true });
+        if (text === null)
+            continue;
+        candidates.push(recordCandidate(team, "directive", item.sourcePath, item.sourceItemId, {
+            text,
+            date: IMPORT_DATE,
+            source_url: null,
+            source_path: item.sourcePath,
+            teams: [team],
+        }, { policy_path: null, acknowledgements: [] }));
+    }
+    return candidates;
+}
+function statusStem(statusPath) {
+    const base = path.basename(statusPath);
+    if (base === "manager-status.json")
+        return validSegment(path.basename(path.dirname(statusPath)), "status project");
+    return validSegment(base.replace(/-manager-status\.json$/, "").replace(/\.json$/, ""), "status project");
+}
+function safeError(err, fallbackPath) {
+    if (err instanceof LanesError) {
+        const details = err.details;
+        return {
+            error: err.error,
+            ...(typeof details.path === "string" ? { path: details.path } : fallbackPath ? { path: fallbackPath } : {}),
+            ...(typeof details.source === "string" ? { source: details.source } : {}),
+            ...(typeof details.field === "string" ? { field: details.field } : {}),
+        };
+    }
+    const code = err?.code;
+    return { error: typeof code === "string" ? `tracker_import_${code.toLowerCase()}` : "tracker_import_input_error", ...(fallbackPath ? { path: fallbackPath } : {}) };
+}
+function addTeamError(result, err, fallbackPath) {
+    result.errors.push(safeError(err, fallbackPath));
+    result.status = result.actions.length > 0 ? "imported_with_errors" : "error";
+}
+function preview(candidate, kpiIds, isApply, managedOverrides = {}) {
+    const fields = { ...candidate.managed, ...managedOverrides };
+    if (candidate.kind === "okr" && Array.isArray(fields.key_results) && candidate.keyLinks) {
+        fields.key_results = fields.key_results.map((kr) => {
+            const link = candidate.keyLinks.find((value) => value.krId === kr.kr_id);
+            return {
+                ...kr,
+                kpi_id: link?.importKey ? kpiIds.get(link.importKey) ?? null : null,
+                ...(link?.importKey && !kpiIds.has(link.importKey) && !isApply ? { pending_kpi_import_key: link.importKey } : {}),
+            };
+        });
+    }
+    return { ...fields, ...candidate.createOnly };
+}
+function sameManaged(record, candidate, fields) {
+    const { values: importedValues, ...otherFields } = fields;
+    const ordinaryFieldsMatch = Object.entries(otherFields).every(([key, value]) => isDeepStrictEqual(record[key], value)) &&
+        isDeepStrictEqual(record.import_key, candidate.importKey);
+    if (!ordinaryFieldsMatch || candidate.kind !== "kpi")
+        return ordinaryFieldsMatch;
+    if (!Array.isArray(record.values) || !Array.isArray(importedValues))
+        return false;
+    const matchingValues = record.values.filter((value) => isObject(value) && value.import_key === candidate.importKey);
+    return matchingValues.length === importedValues.length && isDeepStrictEqual(matchingValues, importedValues);
+}
+function mergeImportedKpiValues(record, candidate) {
+    if (!Array.isArray(record.values) || !Array.isArray(candidate.managed.values)) {
+        return fail("tracker_record_invalid", "KPI values must be arrays before importing a source reading", { id: record.id });
+    }
+    return [
+        ...record.values.filter((value) => !isObject(value) || value.import_key !== candidate.importKey),
+        ...candidate.managed.values,
+    ];
+}
+function definitionChanged(kind, record, fields) {
+    const definitionFields = kind === "kpi"
+        ? ["name", "definition", "unit", "target", "direction"]
+        : kind === "okr"
+            ? ["objective", "period", "key_results"]
+            : kind === "directive"
+                ? ["text"]
+                : [];
+    return definitionFields.some((field) => !isDeepStrictEqual(record[field], fields[field]));
+}
+function candidateInitial(candidate, kpiIds) {
+    const initial = { ...candidate.managed, ...candidate.createOnly };
+    if (candidate.kind === "okr" && Array.isArray(candidate.managed.key_results) && candidate.keyLinks) {
+        initial.key_results = candidate.managed.key_results.map((kr) => {
+            const link = candidate.keyLinks.find((value) => value.krId === kr.kr_id);
+            return { ...kr, kpi_id: link?.importKey ? kpiIds.get(link.importKey) ?? null : null };
+        });
+    }
+    return initial;
+}
+function importedFields(candidate, kpiIds) {
+    const fields = { ...candidate.managed };
+    if (candidate.kind === "okr" && Array.isArray(candidate.managed.key_results) && candidate.keyLinks) {
+        fields.key_results = candidate.managed.key_results.map((kr) => {
+            const link = candidate.keyLinks.find((value) => value.krId === kr.kr_id);
+            return { ...kr, kpi_id: link?.importKey ? kpiIds.get(link.importKey) ?? null : null };
+        });
+    }
+    return fields;
+}
+async function executeCandidates(work, candidates, mode, company, now, kpiIds) {
+    const kinds = [...new Set(candidates.map((candidate) => candidate.kind))];
+    const existing = new Map();
+    try {
+        for (const kind of kinds)
+            existing.set(kind, work.store.list(kind));
+    }
+    catch (err) {
+        addTeamError(work.result, err);
+        return;
+    }
+    for (const candidate of candidates) {
+        const records = existing.get(candidate.kind) ?? [];
+        const current = records.find((record) => record.import_key === candidate.importKey);
+        const preserveResolution = candidate.closedSourceWithoutTimestamp && current?.resolved_at != null
+            ? { resolved_at: current.resolved_at, resolution: current.resolution }
+            : {};
+        const fields = { ...importedFields(candidate, kpiIds), ...preserveResolution };
+        if (candidate.closedSource && !current) {
+            addSkip(work.result, {
+                kind: candidate.kind,
+                source_path: candidate.sourcePath,
+                source_item_id: candidate.sourceItemId,
+                reason: "source_blocker_closed_before_import",
+            });
+            continue;
+        }
+        if (mode === "apply" && candidate.kind === "okr" && candidate.keyLinks?.some((link) => link.importKey && !kpiIds.has(link.importKey))) {
+            addSkip(work.result, {
+                kind: candidate.kind,
+                source_path: candidate.sourcePath,
+                source_item_id: candidate.sourceItemId,
+                reason: "linked_kpi_not_imported",
+            });
+            continue;
+        }
+        if (mode === "dry-run") {
+            const action = !current ? "create" : sameManaged(current, candidate, fields) ? "unchanged" : "update";
+            const recordId = current?.id ?? null;
+            work.result.actions.push({
+                kind: candidate.kind,
+                action,
+                ...(recordId ? { id: recordId } : {}),
+                source_path: candidate.sourcePath,
+                source_item_id: candidate.sourceItemId,
+                record: preview(candidate, kpiIds, false, preserveResolution),
+                ...(candidate.warnings.length ? { warnings: candidate.warnings } : {}),
+            });
+            if (candidate.kind === "kpi" && recordId)
+                kpiIds.set(candidate.importKey, recordId);
+            continue;
+        }
+        try {
+            let record;
+            let action;
+            if (!current) {
+                record = work.store.create({
+                    kind: candidate.kind,
+                    id: importedRecordId(candidate),
+                    company,
+                    project_id: work.projectId,
+                    ...candidateInitial(candidate, kpiIds),
+                });
+                action = "created";
+            }
+            else if (sameManaged(current, candidate, fields)) {
+                record = current;
+                action = "unchanged";
+            }
+            else {
+                record = work.store.update(candidate.kind, current.id, current.version, (live) => ({
+                    ...live,
+                    ...fields,
+                    ...(candidate.kind === "kpi" ? { values: mergeImportedKpiValues(live, candidate) } : {}),
+                    ...((candidate.kind === "kpi" || candidate.kind === "okr") && definitionChanged(candidate.kind, live, fields)
+                        ? { status: "proposed", approved_by: null, approved_at: null }
+                        : {}),
+                    ...(candidate.kind === "directive" && definitionChanged(candidate.kind, live, fields) ? { acknowledgements: [] } : {}),
+                }));
+                action = "updated";
+            }
+            if (candidate.kind === "kpi")
+                kpiIds.set(candidate.importKey, record.id);
+            work.result.actions.push({
+                kind: candidate.kind,
+                action,
+                id: record.id,
+                version: record.version,
+                source_path: candidate.sourcePath,
+                source_item_id: candidate.sourceItemId,
+                ...(candidate.warnings.length ? { warnings: candidate.warnings } : {}),
+            });
+        }
+        catch (err) {
+            addTeamError(work.result, err);
+            work.result.skipped.push({ kind: candidate.kind, source_path: candidate.sourcePath, source_item_id: candidate.sourceItemId, reason: "write_failed" });
+        }
+    }
+}
+function statusOkrCandidates(status, statusSource, result) {
+    const { drafts, skips } = structuredOkrDrafts(status, statusSource);
+    result.skipped.push(...skips);
+    return drafts;
+}
+function makeEmptyTeamResult(team) {
+    return { team, status: "error", sources: { prd: null, status: null, brief: null, directives: null }, actions: [], skipped: [], errors: [], unlinked_key_results: [] };
+}
+async function prepareTeam(root, company, row, index, globalMarkdown, globalDirectivePath, deps) {
+    const team = typeof row.team === "string" && row.team.trim() ? row.team.trim() : `unknown-${index}`;
+    const result = makeEmptyTeamResult(team);
+    let prdPath = "";
+    try {
+        validSegment(team, "team");
+        const resolved = resolveCompanyPrd(root, company, row.prd);
+        prdPath = resolved.path;
+        const prdSource = relativeSource(fs.realpathSync(root), prdPath);
+        result.project_id = resolved.projectId;
+        result.sources.prd = prdSource;
+        const prd = readJsonObject(prdPath, "prd");
+        const prdCompany = companyFromPrd(prd, prdPath);
+        if (prdCompany !== null && prdCompany !== company) {
+            fail("tracker_import_scope_refused", "Project company does not match the selected company", { path: prdPath, company, project_company: prdCompany });
+        }
+        const stories = requireStoryList(prd, prdPath);
+        const statusPath = resolveStatusPath(root, company, row.status);
+        const statusSource = relativeSource(fs.realpathSync(root), statusPath);
+        result.sources.status = statusSource;
+        const status = readJsonObject(statusPath, "status");
+        const rootReal = fs.realpathSync(root);
+        const globalPath = resolveSourcePath(root, "workspace/lane-briefs/operator-session-directives.md", "directives");
+        const globalSource = relativeSource(rootReal, globalPath);
+        result.sources.directives = globalSource;
+        const statusProjectStem = statusStem(statusPath);
+        const briefPath = path.join(rootReal, "workspace", "lane-briefs", `${statusProjectStem}-manager-brief.md`);
+        let briefText = null;
+        if (fs.existsSync(briefPath)) {
+            const realBrief = resolveSourcePath(root, briefPath, "brief");
+            briefText = readText(realBrief, "brief");
+            result.sources.brief = relativeSource(rootReal, realBrief);
+        }
+        else {
+            addSkip(result, { kind: "okr", source_path: relativeSource(rootReal, briefPath), reason: "team_brief_missing" });
+        }
+        const candidates = [];
+        const kpis = parseKpis(status, result, team, statusSource);
+        candidates.push(...kpis);
+        candidates.push(...parseStatusBlockers(status, result, team, statusSource, deps.now));
+        candidates.push(...parseBlockedStories(stories, result, team, prdSource));
+        const globalItems = globalDirectiveItems(globalMarkdown, aliasesForTeam(team, resolved.projectId, statusProjectStem));
+        candidates.push(...directiveCandidates(team, status, statusSource, globalItems, globalSource, result));
+        const statusOkrs = statusOkrCandidates(status, statusSource, result);
+        const briefOkrs = briefText === null ? [] : markdownGoalDrafts(briefText, result.sources.brief);
+        if (statusOkrs.length === 0 && briefOkrs.length === 0) {
+            addSkip(result, { kind: "okr", source_path: statusSource, reason: "no_explicit_goal_or_okr_source" });
+        }
+        candidates.push(...okrCandidates([...statusOkrs, ...briefOkrs], kpis, result, team));
+        const store = (deps.store ?? ((directory) => createLocalTrackerStore(directory, deps.now)))(path.dirname(prdPath));
+        const importCandidates = uniqueCandidates(candidates, result);
+        result.status = result.errors.length ? "imported_with_errors" : "imported";
+        return { result, company, projectId: resolved.projectId, store, candidates: importCandidates };
+    }
+    catch (err) {
+        addTeamError(result, err, prdPath || (typeof row.prd === "string" ? row.prd : undefined));
+        return { result, company, projectId: result.project_id ?? team, store: { read: () => null, list: () => [], create: () => fail("tracker_import_unavailable", "No project store is available"), update: () => fail("tracker_import_unavailable", "No project store is available") }, candidates: [] };
+    }
+}
+export function registerLaneTrackerImportCommand(parent, deps, wrap) {
+    parent.command("import")
+        .description("Backfill team tracker records from project ledgers and manager status files")
+        .requiredOption("--company <slug>", "Company slug")
+        .option("--team <slug>", "Import one team from the juniors registry")
+        .option("--dry-run", "Plan tracker records without writing")
+        .option("--apply", "Write tracker records to the selected company's projects")
+        .option("--json", "Emit JSON on stdout (default)")
+        .action(wrap(async (options) => {
+        if (options.dryRun === options.apply) {
+            fail("tracker_import_mode_invalid", "Choose exactly one of --dry-run or --apply", {});
+        }
+        const requestedCompany = options.company.trim();
+        if (!requestedCompany) {
+            fail("tracker_import_company_invalid", "--company must be a non-empty company slug", {});
+        }
+        const company = await deps.resolveCompany(requestedCompany);
+        if (!company.slug)
+            fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
+        if (!await deps.trackerEnabled(company)) {
+            fail("tracker_disabled", `hq lanes import requires the ${LANES_TRACKER_FLAG} flag`, { company: company.slug });
+        }
+        if (await deps.trackerMeshEnabled(company)) {
+            fail("tracker_mesh_unavailable", `hq lanes import cannot write while ${LANES_TRACKER_MESH_FLAG} is enabled`, { company: company.slug });
+        }
+        const root = deps.hqRoot();
+        const registryPath = resolveSourcePath(root, "workspace/lane-briefs/juniors.json", "juniors registry");
+        const registry = readJsonObject(registryPath, "juniors registry");
+        if (!Array.isArray(registry.juniors)) {
+            fail("tracker_import_registry_invalid", "juniors.json must contain a juniors array", { path: registryPath });
+        }
+        const rows = registry.juniors.filter(isObject);
+        if (rows.length !== registry.juniors.length) {
+            fail("tracker_import_registry_invalid", "juniors.json contains a non-object team row", { path: registryPath });
+        }
+        const requestedTeam = options.team === undefined ? undefined : validSegment(options.team, "team");
+        const selectedRows = requestedTeam === undefined ? rows : rows.filter((row) => row.team === requestedTeam);
+        if (selectedRows.length === 0) {
+            fail("tracker_import_team_not_found", "No juniors.json row matches the requested team", { team: requestedTeam, path: registryPath });
+        }
+        const globalPath = resolveSourcePath(root, "workspace/lane-briefs/operator-session-directives.md", "directives");
+        const globalMarkdown = readText(globalPath, "operator-session-directives.md");
+        const works = [];
+        for (const [index, row] of selectedRows.entries()) {
+            works.push(await prepareTeam(root, company.slug, row, index, globalMarkdown, globalPath, deps));
+        }
+        const mode = options.apply ? "apply" : "dry-run";
+        const kpiIds = new Map();
+        for (const work of works) {
+            try {
+                for (const record of work.store.list("kpi")) {
+                    if (typeof record.import_key === "string")
+                        kpiIds.set(record.import_key, record.id);
+                }
+            }
+            catch (err) {
+                addTeamError(work.result, err);
+                work.preloadFailed = true;
+            }
+        }
+        const nonOkrs = works.map((work) => work.candidates.filter((candidate) => candidate.kind !== "okr"));
+        for (const [index, work] of works.entries()) {
+            if (work.preloadFailed)
+                continue;
+            await executeCandidates(work, nonOkrs[index], mode, company.slug, deps.now, kpiIds);
+        }
+        for (const work of works) {
+            if (work.preloadFailed)
+                continue;
+            const okrs = work.candidates.filter((candidate) => candidate.kind === "okr");
+            await executeCandidates(work, okrs, mode, company.slug, deps.now, kpiIds);
+        }
+        for (const work of works) {
+            if (work.result.errors.length) {
+                work.result.status = work.result.actions.length > 0 ? "imported_with_errors" : "error";
+            }
+            else {
+                work.result.status = "imported";
+            }
+        }
+        const actions = works.flatMap((work) => work.result.actions);
+        const summary = {
+            teams: works.length,
+            created: actions.filter((action) => action.action === "created").length,
+            updated: actions.filter((action) => action.action === "updated").length,
+            unchanged: actions.filter((action) => action.action === "unchanged").length,
+            would_create: actions.filter((action) => action.action === "create").length,
+            would_update: actions.filter((action) => action.action === "update").length,
+            skipped: works.reduce((total, work) => total + work.result.skipped.length, 0),
+            errors: works.reduce((total, work) => total + work.result.errors.length, 0),
+        };
+        console.log(JSON.stringify({
+            ok: summary.errors === 0,
+            action: "lanes.import",
+            company: company.slug,
+            mode,
+            teams: works.map((work) => work.result),
+            summary,
+        }, null, 2));
+        if (summary.errors > 0)
+            process.exitCode = 2;
+    }));
+}
+//# sourceMappingURL=lanes-import.js.map