@indigoai-us/hq-cli 5.307.0 → 5.309.0

package/dist/commands/core-resolve-company-native.js

@@ -0,0 +1,408 @@
+/** Native port of resolve-company.sh. This module stays on the fast import path. */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const RESOLVE_COMPANY_ASSET = "core/scripts/resolve-company.sh";
+export const RESOLVE_COMPANY_HELP = [
+    "hq-core: public",
+    "resolve-company.sh — resolve the active company for skills and routing.",
+    "",
+    "Resolution order (first hit wins): explicit manifest slug in the prompt,",
+    "session company_slug, enabled device default, then none. Prompt matching is",
+    "whole-token only; free text never guesses a company.",
+    "",
+    "Output: {\"company\":\"<slug>\",\"source\":\"prompt|session|device_default|none\"}",
+    "Always exits 0 and never writes state.",
+    "",
+    "set -uo pipefail",
+    "",
+    "ROOT=\"\"",
+].join("\n") + "\n";
+const EMPTY_ENV = {};
+const keepSlug = (slug) => slug !== "" && slug !== "_template" && slug !== "companies" && slug !== "unaffiliated_repos";
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function readFile(filePath, fileSystem) {
+    try {
+        return fileSystem.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "ELOOP")
+            return undefined;
+        throw error;
+    }
+}
+function readManifest(filePath, fileSystem) {
+    try {
+        return fileSystem.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "EACCES") {
+            return {
+                code: 0,
+                stdout: Buffer.from('{"company":"","source":"none"}\n'),
+                stderr: Buffer.from("awk: fatal: cannot open file `" + filePath + "' for reading: Permission denied\n"),
+            };
+        }
+        if (code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP")
+            return output("", "none");
+        throw error;
+    }
+}
+function isFile(filePath, fileSystem) {
+    try {
+        return fileSystem.statSync(filePath).isFile();
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "ELOOP")
+            return false;
+        throw error;
+    }
+}
+function parseManifestSlugs(text) {
+    const slugs = new Set();
+    let wrapped = false;
+    for (const rawLine of text.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (/^companies:[ \t]*$/.test(line)) {
+            wrapped = true;
+            continue;
+        }
+        if (wrapped && /^[^ \t][^:]*:[ \t]*$/.test(line))
+            wrapped = false;
+        if (wrapped) {
+            const match = line.match(/^ {2}([A-Za-z][A-Za-z0-9_-]*):/);
+            if (match && keepSlug(match[1]))
+                slugs.add(match[1]);
+            continue;
+        }
+        const match = line.match(/^([A-Za-z][A-Za-z0-9_-]*):/);
+        if (match && keepSlug(match[1]))
+            slugs.add(match[1]);
+    }
+    return [...slugs];
+}
+function promptSlug(prompt, slugs) {
+    if (!prompt)
+        return "";
+    const asciiLower = (value) => value.replace(/[A-Z]/g, (letter) => String.fromCharCode(letter.charCodeAt(0) + 32));
+    const normalized = asciiLower(prompt).replace(/[^a-z0-9_-]/g, " ");
+    const positions = new Map();
+    normalized.split(/[ \t]+/).forEach((token, index) => {
+        if (token && !positions.has(token))
+            positions.set(token, index + 1);
+    });
+    const matches = new Map();
+    for (const slug of slugs) {
+        const key = asciiLower(slug);
+        if (!positions.has(key))
+            continue;
+        matches.set(key, [...(matches.get(key) ?? []), slug]);
+    }
+    let bestSlug = "";
+    let bestLength = 0;
+    let bestPosition = 0;
+    for (const [key, candidates] of matches) {
+        if (candidates.length !== 1)
+            continue;
+        const slug = candidates[0];
+        const length = slug.length;
+        const position = positions.get(key);
+        if (length > bestLength || (length === bestLength && position < bestPosition)) {
+            bestSlug = slug;
+            bestLength = length;
+            bestPosition = position;
+        }
+    }
+    return bestSlug;
+}
+function validSessionId(value) {
+    return value !== "" && value !== "." && value !== ".." && /^[A-Za-z0-9._-]+$/.test(value);
+}
+function sessionId(root, env, fileSystem) {
+    for (const name of ["HQ_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "GROK_SESSION_ID"]) {
+        const value = (env[name] ?? "").replace(/[ \t\n\v\f\r]/g, "");
+        if (validSessionId(value))
+            return value;
+    }
+    const current = readFile(path.join(root, "workspace/sessions/.current"), fileSystem)?.replace(/[ \t\n\v\f\r]/g, "") ?? "";
+    return validSessionId(current) ? current : "";
+}
+function sessionCompany(root, env, fileSystem) {
+    const helper = path.join(root, "core/scripts/hq-session.sh");
+    try {
+        fileSystem.accessSync(helper, fs.constants.X_OK);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "ELOOP")
+            return "";
+        throw error;
+    }
+    // A directory may be executable according to access(2), but `bash directory`
+    // fails without output, just as hq-session.sh does here.
+    if (!isFile(helper, fileSystem))
+        return "";
+    const id = sessionId(root, env, fileSystem);
+    if (!id)
+        return "";
+    const meta = readFile(path.join(root, "workspace/sessions", id, "meta.yaml"), fileSystem);
+    if (meta === undefined)
+        return "";
+    let value = "";
+    for (const line of meta.split("\n")) {
+        const firstField = line.replace(/^[ \t]+/, "").split(/[ \t]+/, 1)[0];
+        if (firstField !== "company_slug:")
+            continue;
+        value = line.replace(/^[^:]+:[ \t]*/, "").replace(/^"|"$/g, "");
+        break;
+    }
+    // The shell's command substitution strips trailing newlines, then tr removes
+    // all remaining whitespace and double quotes from the helper's output.
+    return value.replace(/[ \t\n\v\f\r"]/g, "");
+}
+function fleetIdentityPresent(rootPrefix, env, fileSystem) {
+    if (env.HQ_AGENT_WORKDIR || env.HQ_AGENT_COMPANY_DIR || env.HQ_AGENT_IDENTITY_FILE)
+        return true;
+    const paths = [
+        "/etc/hq-agent/identity.json",
+        "/etc/hq-agent/machine-creds.json",
+        rootPrefix ? `${rootPrefix.replace(/\/$/, "")}/var/lib/hq-agent/identity.json` : "/var/lib/hq-agent/identity.json",
+        "/var/lib/hq-agent/machine-creds.json",
+    ];
+    return paths.some((filePath) => isFile(filePath, fileSystem));
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function normalizeShellValue(value) {
+    return value.replace(/[ \t\n\v\f\r"]/g, "");
+}
+function defaultSlugFromJson(text, knownSlugs) {
+    const root = record(parseJson(text));
+    if (!root)
+        return "";
+    const candidate = root.defaultCompany;
+    const preference = candidate === null || candidate === undefined || candidate === false
+        ? root
+        : record(candidate);
+    if (!preference)
+        return "";
+    if (preference.enabled !== true || (preference.source ?? "") === "disabled" || (preference.needsChoice ?? false) !== false)
+        return "";
+    if (typeof preference.slug !== "string")
+        return "";
+    const slug = normalizeShellValue(preference.slug);
+    return knownSlugs.has(slug) ? slug : "";
+}
+function validPreflight(text, slug, session, operation) {
+    const value = record(parseJson(text));
+    return Boolean(value && value.contractVersion === 1 && value.sessionId === session &&
+        value.clientOperationId === operation &&
+        typeof value.kind === "string" && ["queued", "needs_project", "needs_task", "bound"].includes(value.kind) &&
+        typeof value.classification === "string" && ["needs_project", "needs_task", "bound"].includes(value.classification) &&
+        typeof value.delivery === "string" && ["queued", "acked"].includes(value.delivery) && value.lifecycle === "open" &&
+        value.companySlug === slug &&
+        typeof value.companyUid === "string" && value.companyUid.length > 0);
+}
+function commandOnPath(name, env) {
+    const pathValue = env.PATH ?? "";
+    for (const directory of pathValue.split(path.delimiter)) {
+        const candidate = path.join(directory || ".", name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // `command -v` simply advances to the next PATH entry.
+        }
+    }
+    return false;
+}
+function runHq(args, env, timeoutMs, cwd) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let stdout = "";
+        let child;
+        let timeoutKill;
+        let timedOut = false;
+        const signalGroup = (signal) => {
+            if (!child?.pid)
+                return;
+            try {
+                process.kill(-child.pid, signal);
+            }
+            catch (error) {
+                if (errorCode(error) !== "ESRCH")
+                    finish({ code: 1, stdout });
+            }
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (timeoutKill)
+                clearTimeout(timeoutKill);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            if (child?.pid) {
+                signalGroup("SIGTERM");
+                // The shell wrapper returns shortly after its 2 second deadline. Do
+                // not wait for inherited stdio handles after killing the process group.
+                timeoutKill = setTimeout(() => {
+                    signalGroup("SIGKILL");
+                    finish({ code: 124, stdout });
+                }, 250);
+            }
+            else {
+                finish({ code: 124, stdout });
+            }
+        }, timeoutMs);
+        try {
+            child = spawn("hq", args, { cwd, detached: true, stdio: ["ignore", "pipe", "ignore"], env });
+        }
+        catch {
+            finish({ code: 127, stdout });
+            return;
+        }
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => { stdout += chunk; });
+        child.once("error", () => finish({ code: 127, stdout }));
+        child.once("exit", (code, signal) => {
+            signalGroup("SIGTERM");
+            finish({ code: timedOut ? 124 : typeof code === "number" ? code : signal ? 128 : 1, stdout });
+        });
+    });
+}
+function output(company, source) {
+    return { code: 0, stdout: Buffer.from(`{"company":"${company}","source":"${source}"}\n`), stderr: Buffer.alloc(0) };
+}
+function parseArgs(args) {
+    let root = "";
+    let prompt = "";
+    let havePrompt = false;
+    for (let index = 0; index < args.length;) {
+        const arg = args[index];
+        if (arg === "--root") {
+            root = args[index + 1] ?? "";
+            index += Math.min(2, args.length - index);
+        }
+        else if (arg === "--prompt") {
+            prompt = args[index + 1] ?? "";
+            havePrompt = true;
+            index += Math.min(2, args.length - index);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { root, prompt, havePrompt, help: true };
+        }
+        else {
+            index += 1;
+        }
+    }
+    return { root, prompt, havePrompt, help: false };
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+export async function resolveCompany(args, dependencies) {
+    const env = dependencies.env ?? process.env;
+    const fileSystem = dependencies.fs ?? fs;
+    const parsed = parseArgs(args);
+    if (parsed.help)
+        return { code: 0, stdout: Buffer.from(RESOLVE_COMPANY_HELP), stderr: Buffer.alloc(0) };
+    let prompt = parsed.prompt;
+    if (!parsed.havePrompt && dependencies.stdinIsTty !== true) {
+        prompt = dependencies.stdin ?? await readStdin();
+    }
+    const root = parsed.root || dependencies.hqRoot || env.HQ_ROOT || env.CLAUDE_PROJECT_DIR || dependencies.cwd;
+    const manifest = path.join(root, "companies/manifest.yaml");
+    if (!isFile(manifest, fileSystem))
+        return output("", "none");
+    const manifestResult = readManifest(manifest, fileSystem);
+    if (typeof manifestResult !== "string")
+        return manifestResult;
+    const manifestText = manifestResult;
+    const slugs = parseManifestSlugs(manifestText);
+    if (slugs.length === 0)
+        return output("", "none");
+    const knownSlugs = new Set(slugs);
+    const promptMatch = promptSlug(prompt, slugs);
+    if (promptMatch)
+        return output(promptMatch, "prompt");
+    const sessionMatch = sessionCompany(root, env, fileSystem);
+    if (sessionMatch && knownSlugs.has(sessionMatch))
+        return output(sessionMatch, "session");
+    if (fleetIdentityPresent(env.HQ_AGENT_ROOT_PREFIX ?? "", env, fileSystem))
+        return output("", "none");
+    // jq is intentionally no longer needed. The native route is always hosted by
+    // Node; the old shell route required `node`, `hq`, and `jq` on PATH.
+    if (!commandOnPath("hq", env))
+        return output("", "none");
+    const hqEnv = { ...EMPTY_ENV, ...env };
+    if (dependencies.hqRoot) {
+        hqEnv.HQ_ROOT = dependencies.hqRoot;
+        hqEnv.CLAUDE_PROJECT_DIR = dependencies.hqRoot;
+    }
+    const invoke = dependencies.spawnHq ?? runHq;
+    const defaultResponse = await invoke(["mesh", "context", "default", "get", "--json"], hqEnv, 2_000, root);
+    const defaultSlug = defaultSlugFromJson(defaultResponse.stdout, knownSlugs);
+    if (!defaultSlug)
+        return output("", "none");
+    const pid = dependencies.pid ?? process.pid;
+    const random = dependencies.random ?? Math.random;
+    const session = `resolve-default-${pid}-${Math.floor(random() * 32768)}`;
+    const operation = `resolve-default-op-${pid}-${Math.floor(random() * 32768)}`;
+    const observation = JSON.stringify({
+        contractVersion: 1,
+        clientOperationId: operation,
+        identity: { sessionId: session, harness: "hq-core", adapterVersion: "1" },
+        cwd: root,
+        hqRoot: root,
+    }).replaceAll("\u007f", "\\u007f");
+    const preflight = await invoke([
+        "mesh", "context", "reconcile", "--observation-json", observation, "--machine", "--offline",
+    ], hqEnv, 2_000, root);
+    if (preflight.code === 0 && validPreflight(preflight.stdout, defaultSlug, session, operation)) {
+        return output(defaultSlug, "device_default");
+    }
+    return output("", "none");
+}
+export async function runResolveCompanyFast(args, stdin, cwd, hqRoot, _commandName, _hqRootArg, stdinReader = readStdin) {
+    const parsed = parseArgs(args);
+    const actualStdin = parsed.havePrompt || process.stdin.isTTY === true
+        ? stdin
+        : stdin || await stdinReader();
+    const result = await resolveCompany(args, {
+        cwd,
+        hqRoot,
+        stdin: actualStdin,
+        stdinIsTty: process.stdin.isTTY === true,
+    });
+    process.stdout.write(result.stdout);
+    if (result.stderr.length)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-resolve-company-native.js.map

package/dist/commands/core.js

@@ -37,6 +37,7 @@ import { registerCoreOntologyCommand } from "./core-ontology.js";
 import { registerCoreKnowledgePrefsCommand } from "./core-knowledge-prefs.js";
 import { registerCorePolicyCommand } from "./core-policy.js";
 import { registerCoreJobsNativeCommand } from "./core-job-native.js";
+import { registerCoreResolveCompanyNativeCommand } from "./core-resolve-company-command.js";
 import { registerCoreCheckpointGateSettingCommand } from "./core-checkpoint-gate-setting.js";
 import { registerCoreAuditLogNative } from "./core-audit-log-native.js";
 import { registerCoreGitPackExtensionCheckNative } from "./core-git-pack-extension-check-native.js";
@@ -218,6 +219,7 @@ export const SCAFFOLD_COMMANDS = [
  * direct `hq core` command.
  */
 export const SCAFFOLD_ONLY_ASSETS = [
+    { asset: "core/scripts/resolve-company.sh", root: "live", summary: "Rollback companion for native resolve-company" },
     { asset: "core/scripts/jobs-schedule-parse.sh", root: "live", summary: "Rollback companion for native jobs schedule-parse" },
     { asset: "core/scripts/jobs-validate.sh", root: "live", summary: "Rollback companion for native jobs validate" },
     { asset: "core/scripts/outpost-jobs-reconcile.sh", root: "live", summary: "Rollback companion for native jobs reconcile" },
@@ -365,6 +367,7 @@ export function registerCoreCommands(program) {
     registerCoreKnowledgePrefsCommand(core);
     registerCorePolicyCommand(core);
     registerCoreJobsNativeCommand(core);
+    registerCoreResolveCompanyNativeCommand(core);
     registerCoreAuditLogNative(core);
     registerCoreGitPackExtensionCheckNative(core);
     registerCorePinNative(core);

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

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
+import { type TrackerCheckTeam } from "../lib/lanes/tracker-checks.js";
 import { type TrackerKind, type TrackerRecord } from "../lib/lanes/tracker-store.js";
-import type { LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
+import type { LaneRecord, LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
 export interface LaneChecksDeps {
     hqRoot: () => string;
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
@@ -14,7 +15,11 @@ export interface ProjectMapping {
     team: string;
     leadLaneId?: string;
     statusPath: string;
+    storyPrefix?: string;
+    excludePrefix?: string;
 }
+export declare function mappingIncludesStory(mapping: ProjectMapping, storyId: string): boolean;
+export declare function ambiguousProjectMappings(mappings: readonly ProjectMapping[]): Map<string, string[]>;
 export interface ProjectReadResult {
     stories: Array<Record<string, unknown>>;
     mtime: number;
@@ -28,6 +33,7 @@ export interface ProjectReadResult {
 export declare function loadProjectMappings(root: string, company: string, requestedProject?: string): Map<string, ProjectMapping>;
 export declare function readProject(root: string, company: string, prdPath: string, tolerantStories?: boolean): ProjectReadResult;
 export declare function loadCompanyQuestionRecords(root: string, company: LaneCompanyRef, projectId?: string): QuestionRecord[];
+export declare function readTeamInputs(root: string, company: LaneCompanyRef, projects: readonly ProjectMapping[], lanes: readonly LaneRecord[]): TrackerCheckTeam[];
 export declare function pathForTrackerRecord(projectDirectory: string, kind: TrackerKind, id: string): string;
 export declare function listTrackerRecords(projectDirectory: string, kind: TrackerKind): TrackerRecord[];
 export interface TolerantTrackerReadIssue {

package/dist/commands/lanes-checks.js

@@ -12,6 +12,37 @@ import { DEFAULT_ORPHAN_USER_IDLE_HOURS, findOrphanLanes, parseOrphanMinAge, par
 import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
+export function mappingIncludesStory(mapping, storyId) {
+    return (mapping.storyPrefix === undefined || storyId.startsWith(mapping.storyPrefix))
+        && (mapping.excludePrefix === undefined || !storyId.startsWith(mapping.excludePrefix));
+}
+function mappingsOverlap(left, right) {
+    const includes = [left.storyPrefix, right.storyPrefix].filter((value) => value !== undefined);
+    if (includes.length === 2 && !includes[0].startsWith(includes[1]) && !includes[1].startsWith(includes[0]))
+        return false;
+    const commonPrefix = includes.sort((a, b) => b.length - a.length)[0] ?? "";
+    return ![left.excludePrefix, right.excludePrefix].some((excluded) => excluded !== undefined && commonPrefix.startsWith(excluded));
+}
+export function ambiguousProjectMappings(mappings) {
+    const byProject = new Map();
+    for (const mapping of mappings)
+        byProject.set(mapping.projectId, [...(byProject.get(mapping.projectId) ?? []), mapping]);
+    const ambiguous = new Map();
+    for (const [projectId, rows] of byProject) {
+        const conflicts = new Set();
+        for (let i = 0; i < rows.length; i++) {
+            for (let j = i + 1; j < rows.length; j++) {
+                if (mappingsOverlap(rows[i], rows[j])) {
+                    conflicts.add(rows[i].team);
+                    conflicts.add(rows[j].team);
+                }
+            }
+        }
+        if (conflicts.size > 0)
+            ambiguous.set(projectId, [...conflicts].sort());
+    }
+    return ambiguous;
+}
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -165,16 +196,26 @@ export function loadProjectMappings(root, company, requestedProject) {
             const team = validSegment(entry.team, "team");
             const leadLaneId = validSegment(entry.lane, "lead lane id");
             const statusPath = checkCompanyPath(root, company, entry.status, registryPath);
-            if (mappings.has(projectId))
-                return fail("tracker_checks_mapping_ambiguous", "More than one active team maps to a project", { path: registryPath, project_id: projectId });
-            mappings.set(projectId, { projectId, team, leadLaneId, statusPath });
+            const parsePrefix = (field) => {
+                const value = entry[field];
+                if (value === undefined)
+                    return undefined;
+                if (typeof value !== "string" || value.trim() === "") {
+                    return fail("tracker_checks_mapping_invalid", `${field} must be a non-empty string`, { path: registryPath, index, field });
+                }
+                return value.trim();
+            };
+            const storyPrefix = parsePrefix("story_prefix");
+            const excludePrefix = parsePrefix("exclude_prefix");
+            const key = `${projectId}:${team}:${index}`;
+            mappings.set(key, { projectId, team, leadLaneId, statusPath, ...(storyPrefix === undefined ? {} : { storyPrefix }), ...(excludePrefix === undefined ? {} : { excludePrefix }) });
         }
     }
     const projectsRoot = path.join(root, "companies", company, "projects");
     const knownProjectIds = new Set(projectDirectories(root, company));
     for (const projectId of knownProjectIds) {
-        if (projectHasTrackerRecords(root, company, projectId) && !mappings.has(projectId)) {
-            mappings.set(projectId, {
+        if (projectHasTrackerRecords(root, company, projectId) && ![...mappings.values()].some((mapping) => mapping.projectId === projectId)) {
+            mappings.set(`${projectId}:tracker`, {
                 projectId,
                 team: projectId,
                 statusPath: path.join(projectsRoot, projectId, "manager-status.json"),
@@ -183,10 +224,10 @@ export function loadProjectMappings(root, company, requestedProject) {
     }
     if (requestedProject !== undefined) {
         const projectId = validSegment(requestedProject, "project");
-        if (!knownProjectIds.has(projectId) && !mappings.has(projectId)) {
+        if (!knownProjectIds.has(projectId) && ![...mappings.values()].some((mapping) => mapping.projectId === projectId)) {
             return fail("tracker_project_not_found", "Project directory was not found for this company", { project_id: projectId, path: path.join(projectsRoot, projectId) });
         }
-        return new Map([...mappings].filter(([mappedProjectId]) => mappedProjectId === projectId));
+        return new Map([...mappings].filter(([, mapping]) => mapping.projectId === projectId));
     }
     return mappings;
 }
@@ -539,17 +580,18 @@ function readCompanyQuestions(root, company, projectId) {
         surfaced_at: surfacedAt.get(question.question_id) ?? null,
     }));
 }
-function readTeamInputs(root, company, projects, lanes) {
+export function readTeamInputs(root, company, projects, lanes) {
     const inputs = [];
     for (const project of projects) {
         const projectPath = path.join(root, "companies", company.slug, "projects", project.projectId);
         const prdPath = path.join(projectPath, "prd.json");
         const { stories, mtime } = readProject(root, company.slug, prdPath);
-        const teamLanes = lanes.filter((lane) => sameCompanyLane(lane, company) && laneMatchesProject(lane, project.projectId));
+        const teamLanes = lanes.filter((lane) => sameCompanyLane(lane, company) && laneMatchesProject(lane, project.projectId)
+            && (lane.lane_id === project.leadLaneId || mappingIncludesStory(project, lane.story_id)));
         const lead = project.leadLaneId === undefined
             ? undefined
             : teamLanes.find((lane) => lane.lane_id === project.leadLaneId);
-        const openStories = stories.filter((story) => !storyIsDone(story));
+        const openStories = stories.filter((story) => mappingIncludesStory(project, String(story.id)) && !storyIsDone(story));
         const openPrRefs = new Set();
         for (const story of openStories) {
             for (const ref of pullRequestReferences(story.prs ?? []))
@@ -658,7 +700,7 @@ async function readTrackerCheckRecords(root, company, projects) {
     const blockers = [];
     const kpis = [];
     const directives = [];
-    for (const project of projects) {
+    for (const project of [...new Map(projects.map((project) => [project.projectId, project])).values()]) {
         const absoluteDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
         const store = createLocalTrackerStore(absoluteDirectory);
         const records = {
@@ -715,7 +757,7 @@ export async function resolveTrackerCompany(deps, requested) {
         fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
     return company;
 }
-async function checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, now, deps) {
+async function checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, now, deps, projectErrors) {
     const selectedProjects = [...projects.values()];
     const laneRecords = readScopedLanes(root, company, selectedProjects);
     const warnings = laneRecords.flatMap((lane) => {
@@ -773,6 +815,7 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
         company: company.slug,
         generated_at: now.toISOString(),
         ...(warnings.length === 0 ? {} : { warnings }),
+        ...(projectErrors.length === 0 ? {} : { project_errors: projectErrors }),
         checks,
     };
 }
@@ -855,13 +898,20 @@ export function registerLaneChecksCommand(parent, deps, wrap) {
         const root = deps.hqRoot();
         const projectFilter = options.project === undefined ? undefined : validSegment(options.project, "project");
         const minAgeMinutes = parseOrphanMinAge(options.minAge);
-        const projects = loadProjectMappings(root, company.slug, projectFilter);
-        const directiveProjects = projectFilter === undefined
-            ? projects
-            : loadProjectMappings(root, company.slug);
-        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, deps.now(), deps);
+        const allProjects = loadProjectMappings(root, company.slug);
+        const ambiguous = ambiguousProjectMappings([...allProjects.values()]);
+        const selectedAll = projectFilter === undefined ? [...allProjects.values()] : [...allProjects.values()].filter((mapping) => mapping.projectId === projectFilter);
+        const projectErrors = [...ambiguous].filter(([projectId]) => projectFilter === undefined || projectId === projectFilter).map(([project_id, teams]) => ({
+            project_id,
+            code: "tracker_checks_mapping_ambiguous",
+            teams,
+            message: "Team story prefixes overlap for this project",
+        }));
+        const projects = new Map(selectedAll.filter((mapping) => !ambiguous.has(mapping.projectId)).map((mapping, index) => [`${mapping.projectId}:${mapping.team}:${index}`, mapping]));
+        const directiveProjects = new Map([...allProjects.values()].filter((mapping) => !ambiguous.has(mapping.projectId)).map((mapping, index) => [`${mapping.projectId}:${mapping.team}:${index}`, mapping]));
+        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, deps.now(), deps, projectErrors);
         console.log(JSON.stringify(report, null, 2));
-        if (report.checks.some((item) => item.result === "failing"))
+        if (report.checks.some((item) => item.result === "failing") || projectErrors.length > 0)
             process.exitCode = 2;
     }));
     parent.command("orphans")

package/dist/commands/lanes-report.js

@@ -6,7 +6,7 @@ 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";
+import { listTrackerRecordsTolerant, loadCompanyQuestionRecords, loadProjectMappings, mappingIncludesStory, pathForTrackerRecord, readProject, resolveTrackerCompany, } from "./lanes-checks.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -184,6 +184,8 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
             errors.push({ path: prdPath, field: "id", message: "Story id must be a non-empty string" });
             continue;
         }
+        if (!mappingIncludesStory(project, id))
+            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" });
@@ -217,7 +219,8 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
         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)) {
+    for (const record of questions.filter((question) => question.project_id === project.projectId
+        && (typeof question.story_id !== "string" || mappingIncludesStory(project, question.story_id)))) {
         const sourcePath = questionRecordPath(root, record.question_id);
         try {
             const body = deps.readQuestionBody(root, record);

package/dist/fast-scaffold.js

@@ -144,6 +144,18 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "caller",
         shellHqRoot: name === "reconcile" ? "reconcile-default" : "none",
     })),
+    {
+        name: "resolve-company",
+        kind: "native",
+        modulePath: "./commands/core-resolve-company-native.js",
+        exportName: "runResolveCompanyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-utilities",
+        asset: "core/scripts/resolve-company.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
     ...["resolve", "pickup", "repo", "secrets", "transfer"].map((name) => ({
         name: `delegate ${name}`,
         kind: "native",