@indigoai-us/hq-cli 5.138.0 → 5.140.0

package/dist/commands/report.js

@@ -1,11 +1,80 @@
+/** `hq report` — safe channel-report lifecycle commands for bot runbooks. */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { ensureCognitoToken, } from "../utils/cognito-session.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { listReportTemplates } from "../lib/report-templates.js";
 import { adoptReport, buildReportTarball, conventionReportDir, deployOrgContext, ReportPublishError, plainFailureReason, publishReport, } from "../lib/report-publish.js";
 const DEPLOY_API_URL = process.env.HQ_DEPLOY_API_URL ?? "https://api.indigo-hq.com";
+const REPORT_CHANNEL_STATE_FILE = "report-channels.json";
+const MAX_REPORT_DISCOVERY_CHANNELS = 50;
 function reportPath(channelId, reportId) {
     return `/v1/notify/channels/${encodeURIComponent(channelId)}/reports/${encodeURIComponent(reportId)}`;
 }
+function reportListPath(channelId) {
+    return `/v1/notify/channels/${encodeURIComponent(channelId)}/reports`;
+}
+function reportChannelStatePath() {
+    const stateDir = process.env.HQ_STATE_DIR?.trim() || path.join(os.homedir(), ".hq");
+    return path.join(stateDir, REPORT_CHANNEL_STATE_FILE);
+}
+function readReportChannelState() {
+    const file = reportChannelStatePath();
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { version: 1, channels: {} };
+        }
+        throw new ReportPublishError("Could not read the local report channel state.");
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || !parsed.channels || typeof parsed.channels !== "object")
+            throw new Error("invalid state");
+        const channels = Object.fromEntries(Object.entries(parsed.channels).filter((entry) => typeof entry[1] === "string" && entry[1].length > 0));
+        return { version: 1, channels };
+    }
+    catch {
+        throw new ReportPublishError("Could not read the local report channel state.");
+    }
+}
+function rememberReportChannel(reportId, channelId) {
+    const file = reportChannelStatePath();
+    const state = readReportChannelState();
+    state.channels[reportId] = channelId;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        if (fs.existsSync(temporary))
+            fs.rmSync(temporary, { force: true });
+    }
+}
+function rememberReportChannelAfterSuccess(report) {
+    try {
+        rememberReportChannel(report.reportId, report.channelId);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "local state write failed";
+        console.warn(`Report succeeded but local channel context was not saved: ${reason}`);
+    }
+}
+function locallyRecordedChannel(reportId) {
+    return readReportChannelState().channels[reportId];
+}
+function notFoundMessage(scannedChannels) {
+    const scope = scannedChannels >= MAX_REPORT_DISCOVERY_CHANNELS
+        ? `the first ${MAX_REPORT_DISCOVERY_CHANNELS} channels`
+        : `${scannedChannels} channel${scannedChannels === 1 ? "" : "s"}`;
+    return `Report not found. Pass --channel or set HQ_REPORT_CHANNEL_ID. Searched ${scope}.`;
+}
 function errorMessage(error) {
     if (error instanceof ReportPublishError)
         return plainFailureReason(error);
@@ -29,30 +98,38 @@ export async function resolveReport(token, reportId, requestedChannelId) {
             throw new ReportPublishError("Report response was incomplete.");
         return body.report;
     }
+    const recordedChannel = locallyRecordedChannel(reportId);
+    if (recordedChannel) {
+        const res = await vaultApiFetch({ token, path: reportPath(recordedChannel, reportId) });
+        if (res.ok) {
+            const body = await res.json();
+            if (body.report)
+                return body.report;
+        }
+    }
     // The report API is intentionally channel-scoped. Discover only among the
-    // caller's existing channels rather than inventing an unscoped report route.
+    // caller's existing channels, using list endpoints so missing reports never
+    // become one server-side 404 per channel.
     const channels = await vaultApiFetch({ token, path: "/v1/notify/channels" });
     if (!channels.ok)
         throw new ReportPublishError("Could not resolve the report channel.");
     const listed = await channels.json();
-    const matches = [];
+    let scannedChannels = 0;
     for (const row of listed.channels ?? []) {
         if (!row.channelId)
             continue;
-        const res = await vaultApiFetch({ token, path: reportPath(row.channelId, reportId) });
-        if (res.status === 404)
-            continue;
+        if (scannedChannels >= MAX_REPORT_DISCOVERY_CHANNELS)
+            break;
+        scannedChannels += 1;
+        const res = await vaultApiFetch({ token, path: reportListPath(row.channelId) });
         if (!res.ok)
             continue;
         const body = await res.json();
-        if (body.report)
-            matches.push(body.report);
+        const match = body.reports?.find((report) => report.reportId === reportId);
+        if (match)
+            return match;
     }
-    if (matches.length === 1)
-        return matches[0];
-    if (matches.length > 1)
-        throw new ReportPublishError("Report ID is ambiguous; pass --channel or set HQ_REPORT_CHANNEL_ID.");
-    throw new ReportPublishError("Report not found. Pass --channel or set HQ_REPORT_CHANNEL_ID.");
+    throw new ReportPublishError(notFoundMessage(scannedChannels));
 }
 export async function patchReport(token, report, patch) {
     const res = await vaultApiFetch({ token, path: reportPath(report.channelId, report.reportId), method: "PATCH", body: patch });
@@ -146,7 +223,7 @@ export async function deployReportStatic(token, input) {
     return { appId: app.id, url, deployId };
 }
 async function publishWithOrg(token, report, directory, draft) {
-    return publishReport(report, directory, draft, {
+    const published = await publishReport(report, directory, draft, {
         patch: (current, patch) => patchReport(token, current, patch),
         deploy: async (input) => {
             const org = await orgFor(token, report);
@@ -154,6 +231,8 @@ async function publishWithOrg(token, report, directory, draft) {
         },
         now: () => new Date().toISOString(),
     });
+    rememberReportChannelAfterSuccess(published);
+    return published;
 }
 async function publishAction(reportId, options) {
     const token = await ensureCognitoToken();
@@ -246,6 +325,7 @@ async function adoptAction(reportId, options) {
         },
         patch: (current, patch) => patchReport(token, current, patch),
     });
+    rememberReportChannelAfterSuccess(updated);
     print(updated, options.json === true);
 }
 async function decommissionAction(reportId, options) {

package/dist/lib/lanes/monitor.js

@@ -348,7 +348,26 @@ function defaultProcessCommands() {
     }
 }
 function processHasExactCommand(processCommands, command) {
-    return processCommands.some((line) => line.trim() === command);
+    const laneIds = parseCanonicalWatchCommand(command);
+    if (!laneIds)
+        return false;
+    const expectedSuffix = ["lanes", "watch", ...laneIds];
+    return processCommands.some((line) => {
+        const tokens = line.trim().split(/\s+/u);
+        const suffixStart = tokens.length - expectedSuffix.length;
+        if (suffixStart < 1)
+            return false;
+        if (!expectedSuffix.every((token, index) => tokens[suffixStart + index] === token)) {
+            return false;
+        }
+        const hqToken = tokens[suffixStart - 1];
+        if (path.basename(hqToken) !== "hq")
+            return false;
+        const prefix = tokens.slice(0, suffixStart - 1);
+        return (prefix.length === 0 ||
+            (prefix.length === 1 &&
+                ["bun", "deno", "node", "nodejs", "ts-node", "tsx"].includes(path.basename(prefix[0]))));
+    });
 }
 export function readLiveMonitorEvidence(sessionId, options = {}) {
     if (!SESSION_ID_PATTERN.test(sessionId)) {

package/dist/lib/mesh/api.d.ts

@@ -31,6 +31,7 @@ export interface MeshProjectStoryInput {
     status?: string;
     passes?: boolean;
     priority?: number;
+    assigneeUid?: string;
 }
 export interface MeshProjectRepo {
     path: string;

package/dist/lib/mesh/live/flush.d.ts

@@ -16,7 +16,7 @@ export declare const HELD_TTL_MS: number;
 export declare const HELD_RETRY_INTERVAL_MS: number;
 /** Cap held.jsonl size; oldest overflow is dead-lettered with HELD_OVERFLOW. */
 export declare const HELD_MAX_LINES = 20000;
-export type HeldReason = "STATE_ABSENT" | "NEEDS_COMPANY" | "COMPANY_CONFLICT" | "HELD_EXPIRED" | "HELD_OVERFLOW";
+export type HeldReason = "STATE_ABSENT" | "NEEDS_COMPANY" | "COMPANY_CONFLICT" | "NEEDS_PROJECT" | "HELD_EXPIRED" | "HELD_OVERFLOW";
 export interface HeldLineRecord {
     /** Original spool event fields. */
     event: Record<string, unknown>;

package/dist/lib/mesh/live/flush.js

@@ -12,7 +12,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveCompany } from "../../work-context/company.js";
 import { deriveRemoteOwnerSlug, deriveRepoIdentityKey, } from "../../work-context/repo-remote.js";
-import { readSessionState } from "../../work-context/state.js";
+import { readSessionState, updateSessionState } from "../../work-context/state.js";
 import { repairAckedRegisterStates } from "../../work-context/outbox.js";
 import { workContextRoot } from "../../work-context/paths.js";
 import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.js";
@@ -222,6 +222,7 @@ export async function flushSessionEvents(deps) {
         const markDisposed = (event) => {
             pendingRestore.delete(event);
         };
+        const loggedProject404 = new Set();
         for (const [sessionId, items] of bySession) {
             const state = readSessionState(sessionId, deps.workContextRoot);
             if (state?.companyConfidence === "device_default" &&
@@ -286,6 +287,36 @@ export async function flushSessionEvents(deps) {
                     accountBatchSuccess(result.body, originalChunk, deps.workMeshRoot, now, summary, markDisposed);
                     continue;
                 }
+                if (!result.retryable && result.status === 404) {
+                    const rejectedProjectId = decision.projectId;
+                    updateSessionState(sessionId, deps.workContextRoot, (current) => {
+                        if (!current)
+                            return current;
+                        return {
+                            ...current,
+                            contextStatus: "needs_project",
+                            projectGate: "missing_board",
+                            projectBindReason: "server returned HTTP 404 for this session's project",
+                            projectCandidates: rejectedProjectId
+                                ? [{ projectId: rejectedProjectId }]
+                                : current.projectCandidates,
+                            projectId: undefined,
+                            taskId: undefined,
+                            updatedAt: now().toISOString(),
+                        };
+                    });
+                    if (!loggedProject404.has(sessionId)) {
+                        loggedProject404.add(sessionId);
+                        deps.log?.(`work-mesh: session ${sessionId} project missing (HTTP 404); downgraded to needs_project and held events`);
+                    }
+                    const heldAt = now().toISOString();
+                    for (const item of originalChunk) {
+                        appendHeldLine(heldEnvelope(item.event, "NEEDS_PROJECT", item.heldAt ?? heldAt), deps.workMeshRoot);
+                        summary.held += 1;
+                        markDisposed(item.event);
+                    }
+                    continue;
+                }
                 if (!result.retryable) {
                     const at = now().toISOString();
                     for (const item of originalChunk) {
@@ -484,6 +515,9 @@ function classifySession(state) {
     if (state.contextStatus === "company_conflict") {
         return { action: "hold", heldReason: "COMPANY_CONFLICT" };
     }
+    if (state.projectGate === "choose" || state.projectGate === "missing_board") {
+        return { action: "hold", heldReason: "NEEDS_PROJECT" };
+    }
     if (!WRITABLE_CONTEXT_STATUSES.has(state.contextStatus)) {
         return { action: "hold", heldReason: "STATE_ABSENT" };
     }

package/dist/lib/mesh/project-board.d.ts

@@ -0,0 +1,19 @@
+import { type MeshCompany, type MeshProjectRegistration, type MeshProjectRepo, type MeshProjectStoryInput, type MeshProjectView } from "./api.js";
+/**
+ * Create a missing Board. Register returns 403 PROJECT_NOT_IN_COMPANY until
+ * the genesis thread and the project view both exist, so the order is fixed:
+ * thread, view, register, then a GET to confirm the view.
+ */
+export declare function ensureProjectBoard(input: {
+    token: string;
+    company: MeshCompany;
+    projectId: string;
+    name: string;
+    description?: string;
+    stories: MeshProjectStoryInput[];
+    repos?: MeshProjectRepo[];
+}): Promise<{
+    view: MeshProjectView;
+    registration: MeshProjectRegistration;
+}>;
+//# sourceMappingURL=project-board.d.ts.map

package/dist/lib/mesh/project-board.js

@@ -0,0 +1,27 @@
+import { ensureProjectThread, getProjectView, putProjectView, registerMeshProject, } from "./api.js";
+/**
+ * Create a missing Board. Register returns 403 PROJECT_NOT_IN_COMPANY until
+ * the genesis thread and the project view both exist, so the order is fixed:
+ * thread, view, register, then a GET to confirm the view.
+ */
+export async function ensureProjectBoard(input) {
+    const genesis = await ensureProjectThread(input.token, input.company, input.projectId, {
+        summary: input.name || input.projectId,
+    });
+    if (!genesis.threadId) {
+        throw new Error("Work mesh did not return a threadId.");
+    }
+    await putProjectView(input.token, input.company.companyUid, input.projectId, {
+        name: input.name || input.projectId,
+        description: input.description ?? "",
+        stories: input.stories,
+        repos: input.repos ?? [],
+    });
+    const registration = await registerMeshProject(input.token, input.company.companyUid, input.projectId);
+    const view = await getProjectView(input.token, input.company.companyUid, input.projectId);
+    if (view.projectId !== input.projectId || view.companyUid !== input.company.companyUid) {
+        throw new Error(`Work mesh project board does not match ${input.company.companyUid}/${input.projectId}.`);
+    }
+    return { view, registration };
+}
+//# sourceMappingURL=project-board.js.map

package/dist/lib/work-context/bind-best.d.ts

@@ -0,0 +1,64 @@
+/**
+ * US-036: pick the best existing project for a session hint.
+ * Exact Board, then exact local PRD, then a ranked match.
+ * A tie or an empty field stays unbound so the session can ask.
+ */
+export interface BindCandidate {
+    projectId: string;
+    title?: string;
+    score: number;
+}
+export interface CatalogProject {
+    projectId: string;
+    title?: string;
+    repos: string[];
+    journalMtimeMs?: number;
+    hasPrd: boolean;
+    hasBoard: boolean;
+    prdPath?: string;
+}
+export type RefineAction = {
+    action: "keep";
+} | {
+    action: "bind";
+    projectId: string;
+    reason: string;
+} | {
+    action: "create";
+    projectId: string;
+    prdPath: string;
+    reason: string;
+} | {
+    action: "ask";
+    reason: string;
+    candidates: BindCandidate[];
+};
+export declare function scoreProject(hint: string, row: CatalogProject, repoPath: string | undefined, nowMs: number): number;
+export declare function discoverProjects(input: {
+    hqRoot?: string;
+    companySlug?: string;
+    companyUid?: string;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+}): CatalogProject[];
+export declare function refineProjectBinding(input: {
+    hint?: string;
+    hqRoot?: string;
+    companySlug?: string;
+    companyUid?: string;
+    repoPath?: string;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    nowMs?: number;
+}): RefineAction;
+export declare function findLocalPrd(hqRoot: string | undefined, companySlug: string | undefined, projectId: string): string | null;
+export declare function listNeedsProjectSessions(workContextRoot: string): Array<{
+    sessionId: string;
+    reason?: string;
+    candidates: BindCandidate[];
+}>;
+export declare function formatProjectAsk(candidates: Array<{
+    projectId: string;
+    title?: string;
+}>): string;
+//# sourceMappingURL=bind-best.d.ts.map

package/dist/lib/work-context/bind-best.js

@@ -0,0 +1,299 @@
+/**
+ * US-036: pick the best existing project for a session hint.
+ * Exact Board, then exact local PRD, then a ranked match.
+ * A tie or an empty field stays unbound so the session can ask.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { meshCacheRoot } from "../mesh/cache.js";
+const MARGIN = 15;
+const CLEAR_FLOOR = 25;
+const DAY_MS = 24 * 60 * 60 * 1000;
+function tokens(value) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((part) => part.length > 2);
+}
+export function scoreProject(hint, row, repoPath, nowMs) {
+    const hintL = hint.toLowerCase();
+    const idL = row.projectId.toLowerCase();
+    let score = 0;
+    if (idL === hintL)
+        score += 100;
+    else if (idL.startsWith(hintL) || hintL.startsWith(idL))
+        score += 40;
+    const hintTokens = new Set(tokens(hint));
+    const titleTokens = new Set(tokens(`${row.projectId} ${row.title ?? ""}`));
+    for (const token of hintTokens) {
+        if (titleTokens.has(token))
+            score += 15;
+    }
+    if (repoPath) {
+        const repoL = repoPath.toLowerCase();
+        if (row.repos.some((repo) => {
+            const item = repo.toLowerCase();
+            return item.length > 0 && (repoL.includes(item) || item.includes(repoL));
+        })) {
+            score += 50;
+        }
+    }
+    if (row.journalMtimeMs) {
+        const age = nowMs - row.journalMtimeMs;
+        if (age >= 0 && age < 14 * DAY_MS)
+            score += 10;
+        else if (age >= 0 && age < 60 * DAY_MS)
+            score += 5;
+    }
+    return score;
+}
+function readJson(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function reposFromMetadata(metadata) {
+    if (!metadata || typeof metadata !== "object")
+        return [];
+    const repos = metadata.repos;
+    if (!Array.isArray(repos))
+        return [];
+    const out = [];
+    for (const repo of repos) {
+        if (typeof repo === "string" && repo.trim())
+            out.push(repo.trim());
+        else if (repo && typeof repo === "object" && typeof repo.path === "string") {
+            const value = repo.path.trim();
+            if (value)
+                out.push(value);
+        }
+    }
+    return out;
+}
+function journalMtime(dir) {
+    const candidates = ["journal.md", "journal.json", path.join("journal", "index.md")];
+    let newest = 0;
+    for (const name of candidates) {
+        try {
+            const stat = fs.statSync(path.join(dir, name));
+            if (stat.mtimeMs > newest)
+                newest = stat.mtimeMs;
+        }
+        catch {
+            /* absent */
+        }
+    }
+    try {
+        const journalDir = path.join(dir, "journal");
+        for (const name of fs.readdirSync(journalDir)) {
+            const stat = fs.statSync(path.join(journalDir, name));
+            if (stat.mtimeMs > newest)
+                newest = stat.mtimeMs;
+        }
+    }
+    catch {
+        /* absent */
+    }
+    return newest > 0 ? newest : undefined;
+}
+function absorbDir(map, dir, projectId) {
+    const prdPath = path.join(dir, "prd.json");
+    const prd = fs.existsSync(prdPath) ? readJson(prdPath) : null;
+    const current = map.get(projectId) ?? {
+        projectId,
+        repos: [],
+        hasPrd: false,
+        hasBoard: false,
+    };
+    if (prd) {
+        current.hasPrd = true;
+        current.prdPath = prdPath;
+        const title = typeof prd.name === "string" ? prd.name
+            : typeof prd.title === "string" ? prd.title
+                : undefined;
+        if (title)
+            current.title = title;
+        const repos = reposFromMetadata(prd.metadata);
+        if (repos.length)
+            current.repos = repos;
+    }
+    const journal = journalMtime(dir);
+    if (journal)
+        current.journalMtimeMs = Math.max(current.journalMtimeMs ?? 0, journal);
+    map.set(projectId, current);
+}
+function listProjectDirs(parent, map) {
+    if (!fs.existsSync(parent))
+        return;
+    let names;
+    try {
+        names = fs.readdirSync(parent);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name))
+            continue;
+        const dir = path.join(parent, name);
+        try {
+            if (!fs.statSync(dir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        absorbDir(map, dir, name);
+    }
+}
+export function discoverProjects(input) {
+    const map = new Map();
+    const hqRoot = input.hqRoot?.trim();
+    const slug = input.companySlug?.trim();
+    if (hqRoot && slug) {
+        listProjectDirs(path.join(hqRoot, "companies", slug, "projects"), map);
+        listProjectDirs(path.join(hqRoot, "personal", "projects"), map);
+    }
+    if (input.companyUid) {
+        const cache = path.join(meshCacheRoot(input.home ?? os.homedir(), input.env), "projects", input.companyUid);
+        if (fs.existsSync(cache)) {
+            for (const name of fs.readdirSync(cache)) {
+                if (!name.endsWith(".json"))
+                    continue;
+                const projectId = name.slice(0, -".json".length);
+                if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(projectId))
+                    continue;
+                const view = readJson(path.join(cache, name));
+                const current = map.get(projectId) ?? {
+                    projectId,
+                    repos: [],
+                    hasPrd: false,
+                    hasBoard: false,
+                };
+                current.hasBoard = true;
+                const title = typeof view?.name === "string" ? view.name : undefined;
+                if (title && !current.title)
+                    current.title = title;
+                const repos = Array.isArray(view?.repos) ? reposFromMetadata({ repos: view?.repos }) : [];
+                if (repos.length && current.repos.length === 0)
+                    current.repos = repos;
+                map.set(projectId, current);
+            }
+        }
+    }
+    return [...map.values()];
+}
+export function refineProjectBinding(input) {
+    const hint = input.hint?.trim();
+    if (!hint)
+        return { action: "keep" };
+    const catalog = discoverProjects(input);
+    const exact = catalog.find((row) => row.projectId === hint);
+    if (exact?.hasBoard) {
+        return { action: "bind", projectId: hint, reason: "exact slug has a Board" };
+    }
+    if (exact?.hasPrd && exact.prdPath) {
+        return {
+            action: "create",
+            projectId: hint,
+            prdPath: exact.prdPath,
+            reason: "exact slug has a local PRD; Board created from that PRD",
+        };
+    }
+    if (catalog.length === 0)
+        return { action: "keep" };
+    const nowMs = input.nowMs ?? Date.now();
+    const ranked = catalog
+        .filter((row) => row.projectId !== hint)
+        .map((row) => ({
+        projectId: row.projectId,
+        title: row.title,
+        score: scoreProject(hint, row, input.repoPath, nowMs),
+    }))
+        .filter((row) => row.score > 0)
+        .sort((a, b) => b.score - a.score || a.projectId.localeCompare(b.projectId));
+    if (ranked.length === 0) {
+        return {
+            action: "ask",
+            reason: `no project matches ${hint}`,
+            candidates: [],
+        };
+    }
+    const top = ranked[0];
+    const second = ranked[1];
+    const clear = top.score >= CLEAR_FLOOR && (!second || top.score - second.score >= MARGIN);
+    if (clear) {
+        return {
+            action: "bind",
+            projectId: top.projectId,
+            reason: `best match for ${hint}: ${top.projectId} (score ${top.score})`,
+        };
+    }
+    return {
+        action: "ask",
+        reason: `unclear match for ${hint}`,
+        candidates: ranked.slice(0, 5).map((row) => ({
+            projectId: row.projectId,
+            ...(row.title ? { title: row.title } : {}),
+            score: row.score,
+        })),
+    };
+}
+export function findLocalPrd(hqRoot, companySlug, projectId) {
+    if (!hqRoot || !companySlug)
+        return null;
+    const candidates = [
+        path.join(hqRoot, "companies", companySlug, "projects", projectId, "prd.json"),
+        path.join(hqRoot, "personal", "projects", projectId, "prd.json"),
+    ];
+    return candidates.find((file) => fs.existsSync(file)) ?? null;
+}
+export function listNeedsProjectSessions(workContextRoot) {
+    const dir = path.join(workContextRoot, "sessions");
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    for (const name of fs.readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        const raw = readJson(path.join(dir, name));
+        if (!raw || raw.contextStatus !== "needs_project")
+            continue;
+        const sessionId = typeof raw.sessionId === "string" ? raw.sessionId : name.replace(/\.json$/, "");
+        const candidates = Array.isArray(raw.projectCandidates)
+            ? raw.projectCandidates.flatMap((item) => {
+                if (!item || typeof item !== "object")
+                    return [];
+                const projectId = item.projectId;
+                if (typeof projectId !== "string" || !projectId)
+                    return [];
+                const title = item.title;
+                const score = item.score;
+                return [{
+                        projectId,
+                        ...(typeof title === "string" ? { title } : {}),
+                        score: typeof score === "number" ? score : 0,
+                    }];
+            })
+            : [];
+        out.push({
+            sessionId,
+            ...(typeof raw.projectBindReason === "string" ? { reason: raw.projectBindReason } : {}),
+            candidates,
+        });
+    }
+    return out.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+}
+export function formatProjectAsk(candidates) {
+    const parts = candidates.map((candidate, index) => {
+        const title = candidate.title?.trim() || candidate.projectId;
+        return `${index + 1}) ${candidate.projectId} ${title}`;
+    });
+    return `This session is not bound to a project. Best matches: ${parts.join(" ")}. Reply with a number, a project id, or \`new <slug>\`.`;
+}
+//# sourceMappingURL=bind-best.js.map