@indigoai-us/hq-cli 5.345.122 → 5.345.124

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

@@ -137,6 +137,8 @@ export interface StoryPatch {
     status?: string;
     assigneeUid?: string;
     clearAssignee?: boolean;
+    /** Override another holder's assignment (server answers 409 otherwise). */
+    force?: boolean;
 }
 export interface StoryPatchResult {
     projectId: string;

package/dist/lib/mesh/api.js

@@ -56,6 +56,7 @@ export async function meshJson(token, path, init = {}) {
         ].filter(Boolean);
         const failure = new Error(`${res.status} ${code}${detail}${context.length ? ` (${context.join("; ")})` : ""}`);
         failure.status = res.status;
+        failure.body = data;
         if (typeof err.code === "string" && err.code)
             failure.code = err.code;
         throw failure;
@@ -398,6 +399,8 @@ export async function patchStory(token, companyUid, projectId, storyId, patch) {
         body.assigneeUid = patch.assigneeUid;
     if (patch.clearAssignee)
         body.clearAssignee = true;
+    if (patch.force)
+        body.force = true;
     const view = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/stories/${encodeURIComponent(storyId)}`, {
         method: "PATCH",
         body,

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

@@ -114,6 +114,11 @@ export declare function fetchCompanyLive(token: string, companyUid: string, opts
     cursor?: string;
     get?: (path: string, query: Record<string, string>) => Promise<unknown>;
 }): Promise<CompanyLiveReadResponse>;
-export declare function formatCompanyLiveTable(live: CompanyLiveReadResponse, companyLabel: string): string[];
+/**
+ * Fill participants[].displayName from the local directory cache when the
+ * server omitted it (older hq-pro builds do not send it).
+ */
+export declare function withParticipantDisplayNames(live: CompanyLiveReadResponse, names: ReadonlyMap<string, string>): CompanyLiveReadResponse;
+export declare function formatCompanyLiveTable(live: CompanyLiveReadResponse, companyLabel: string, names?: ReadonlyMap<string, string>): string[];
 export type { OrganizeSubmitDecision, OrganizeReceipt, CandidatesResponse, MigrateReceipt, PostMigrateFn, };
 //# sourceMappingURL=client.d.ts.map

package/dist/lib/mesh/client.js

@@ -290,22 +290,35 @@ export async function fetchCompanyLive(token, companyUid, opts) {
         : await meshJson(token, "/v1/work-mesh/live", { query });
     return data;
 }
-export function formatCompanyLiveTable(live, companyLabel) {
+/**
+ * Fill participants[].displayName from the local directory cache when the
+ * server omitted it (older hq-pro builds do not send it).
+ */
+export function withParticipantDisplayNames(live, names) {
+    return {
+        ...live,
+        participants: (live.participants ?? []).map((p) => {
+            const name = p.displayName?.trim() || names.get(p.actorUid);
+            return name ? { ...p, displayName: name } : p;
+        }),
+    };
+}
+export function formatCompanyLiveTable(live, companyLabel, names = new Map()) {
     const lines = [
         `Work mesh live: ${companyLabel}  generatedAt=${live.generatedAt}`,
-        "actorUid\tpresence\tdisplayName\tsessionId\tstatus\tcontext\tproject\ttask\tturns",
+        "name	presence	sessionId	status	context	project	task	turns",
     ];
     for (const p of live.participants ?? []) {
+        const who = p.displayName?.trim() || names.get(p.actorUid) || p.actorUid;
         const sessions = p.sessions ?? [];
         if (sessions.length === 0) {
-            lines.push(`${p.actorUid}\t${p.presence ?? "?"}\t${p.displayName ?? ""}\t-\t-\t-\t-\t-\t-`);
+            lines.push(`${who}\t${p.presence ?? "?"}\t-\t-\t-\t-\t-\t-`);
             continue;
         }
         for (const s of sessions) {
             lines.push([
-                p.actorUid,
+                who,
                 p.presence ?? "?",
-                p.displayName ?? "",
                 s.sessionId,
                 s.status ?? "?",
                 s.contextStatus ?? "?",

package/dist/lib/mesh/team-coordination.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Work Mesh team coordination (WMTC-7 / WMTC-8): story claims, overlap,
+ * project reassignment, assignee suggestions, and the presence roster.
+ *
+ * Every route here except the story PATCH is new on hq-pro. Callers treat a
+ * 404/405 without an error code as "this server does not have the route yet"
+ * and degrade to one plain line instead of failing.
+ */
+export declare const STORY_ASSIGNEE_CONFLICT = "STORY_ASSIGNEE_CONFLICT";
+/**
+ * True when the server does not know the route: 405, or a 404 that carries no
+ * error code. A coded 404 (for example PROJECT_NOT_FOUND) is a real answer.
+ */
+export declare function isRouteUnavailable(err: unknown): boolean;
+export declare function unavailableLine(feature: string): string;
+export interface StoryAssigneeConflict {
+    code: typeof STORY_ASSIGNEE_CONFLICT;
+    error: string;
+    holderUid: string;
+    holderDisplayName?: string;
+}
+/** Extract a structured conflict from a 409 meshJson failure, if it is one. */
+export declare function storyConflictFromError(err: unknown): StoryAssigneeConflict | null;
+export declare function formatStoryConflictLine(storyId: string, conflict: StoryAssigneeConflict, names?: NameDirectory): string;
+export type NameDirectory = Map<string, string>;
+export interface DirectoryPerson {
+    uid: string;
+    displayName?: string;
+    email?: string;
+}
+export declare function peopleFromPayload(payload: unknown): DirectoryPerson[];
+/** People known from the local contacts/directory cache. Never throws. */
+export declare function loadCachedPeople(cacheRoot?: string): DirectoryPerson[];
+export declare function loadNameDirectory(cacheRoot?: string): NameDirectory;
+export declare function displayNameFor(uid: string, serverName: string | undefined, names: NameDirectory): string;
+export type PersonResolution = {
+    ok: true;
+    uid: string;
+    displayName?: string;
+} | {
+    ok: false;
+    reason: "none" | "ambiguous";
+    candidates: DirectoryPerson[];
+};
+/** Resolve a uid, email, or display name against a list of people. */
+export declare function resolvePerson(query: string, people: DirectoryPerson[]): PersonResolution;
+export interface MeshOverlap {
+    actorUid: string;
+    displayName?: string;
+    actorType?: string;
+    sessionId: string;
+    repo: string;
+    branch: string;
+    projectId?: string;
+    storyId?: string;
+    reasons: string[];
+    sharedFiles: string[];
+    lastSeenAt?: string;
+}
+export interface OverlapRequest {
+    companyUid: string;
+    sessionId: string;
+    repo: string;
+    branch: string;
+    projectId?: string;
+    storyId?: string;
+    files?: string[];
+}
+export declare const OVERLAP_MAX_FILES = 200;
+export declare function postOverlap(token: string, req: OverlapRequest): Promise<MeshOverlap[]>;
+export declare function formatOverlapLines(overlaps: MeshOverlap[], names: NameDirectory): string[];
+export interface ReassignResult {
+    projectId: string;
+    ownerUid: string;
+    previousOwnerUid: string | null;
+    reassignedStories: string[];
+}
+export declare function postProjectReassign(token: string, projectId: string, body: {
+    companyUid: string;
+    toUid: string;
+    includeOpenStories?: boolean;
+    note?: string;
+}): Promise<ReassignResult>;
+export interface SuggestionCandidate {
+    actorUid: string;
+    displayName?: string;
+    actorType?: string;
+    score: number;
+    idle: boolean;
+    reasons: string[];
+}
+export declare function fetchStorySuggestions(token: string, companyUid: string, projectId: string, storyId: string): Promise<SuggestionCandidate[]>;
+export declare function formatSuggestionLines(storyId: string, candidates: SuggestionCandidate[], names: NameDirectory): string[];
+export interface RosterMember {
+    actorUid: string;
+    displayName?: string;
+    actorType?: string;
+    daemonLastSeenAt: string | null;
+    lastSessionAt: string | null;
+    boundSessions: number;
+    unboundSessions: number;
+}
+export declare function fetchRoster(token: string, companyUid: string): Promise<RosterMember[]>;
+export declare function rosterFlags(member: RosterMember): string[];
+export declare function formatRosterLines(members: RosterMember[], companyLabel: string, names: NameDirectory): string[];
+//# sourceMappingURL=team-coordination.d.ts.map

package/dist/lib/mesh/team-coordination.js

@@ -0,0 +1,297 @@
+/**
+ * Work Mesh team coordination (WMTC-7 / WMTC-8): story claims, overlap,
+ * project reassignment, assignee suggestions, and the presence roster.
+ *
+ * Every route here except the story PATCH is new on hq-pro. Callers treat a
+ * 404/405 without an error code as "this server does not have the route yet"
+ * and degrade to one plain line instead of failing.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { meshJson } from "./api.js";
+import { meshCacheRoot } from "./cache.js";
+export const STORY_ASSIGNEE_CONFLICT = "STORY_ASSIGNEE_CONFLICT";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function str(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function strArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+/**
+ * True when the server does not know the route: 405, or a 404 that carries no
+ * error code. A coded 404 (for example PROJECT_NOT_FOUND) is a real answer.
+ */
+export function isRouteUnavailable(err) {
+    const e = err;
+    if (!e || typeof e !== "object")
+        return false;
+    if (e.status === 405)
+        return true;
+    return e.status === 404 && !e.code;
+}
+export function unavailableLine(feature) {
+    return `${feature} is not available on this server yet`;
+}
+/** Extract a structured conflict from a 409 meshJson failure, if it is one. */
+export function storyConflictFromError(err) {
+    const e = err;
+    if (!e || typeof e !== "object" || e.status !== 409 || e.code !== STORY_ASSIGNEE_CONFLICT)
+        return null;
+    const body = asRecord(e.body) ?? {};
+    const holderDisplayName = str(body.holderDisplayName);
+    return {
+        code: STORY_ASSIGNEE_CONFLICT,
+        error: str(body.error) ?? e.message,
+        holderUid: str(body.holderUid) ?? "",
+        ...(holderDisplayName ? { holderDisplayName } : {}),
+    };
+}
+export function formatStoryConflictLine(storyId, conflict, names) {
+    const name = conflict.holderDisplayName || names?.get(conflict.holderUid) || "another teammate";
+    const uid = conflict.holderUid ? ` (${conflict.holderUid})` : "";
+    return `Story ${storyId} is assigned to ${name}${uid}. Ask them to hand it off, or re-run with --force.`;
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function peopleFromPayload(payload) {
+    const rec = asRecord(payload);
+    const rows = Array.isArray(payload)
+        ? payload
+        : [
+            ...(Array.isArray(rec?.contacts) ? rec.contacts : []),
+            ...(Array.isArray(rec?.rows) ? rec.rows : []),
+            ...(Array.isArray(rec?.members) ? rec.members : []),
+        ];
+    const out = [];
+    for (const row of rows) {
+        const r = asRecord(row);
+        if (!r)
+            continue;
+        const uid = str(r.personUid) ?? str(r.actorUid) ?? str(r.uid);
+        if (!uid || !/^(prs|agt)_/.test(uid))
+            continue;
+        const displayName = str(r.displayName);
+        const email = str(r.email);
+        out.push({ uid, ...(displayName ? { displayName } : {}), ...(email ? { email } : {}) });
+    }
+    return out;
+}
+/** People known from the local contacts/directory cache. Never throws. */
+export function loadCachedPeople(cacheRoot = meshCacheRoot()) {
+    const people = new Map();
+    for (const dir of ["contacts", "directory"]) {
+        let files;
+        try {
+            files = fs.readdirSync(path.join(cacheRoot, dir)).filter((f) => f.endsWith(".json"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            for (const person of peopleFromPayload(readJson(path.join(cacheRoot, dir, file)))) {
+                const prior = people.get(person.uid);
+                const displayName = prior?.displayName ?? person.displayName;
+                const email = prior?.email ?? person.email;
+                people.set(person.uid, {
+                    uid: person.uid,
+                    ...(displayName ? { displayName } : {}),
+                    ...(email ? { email } : {}),
+                });
+            }
+        }
+    }
+    return [...people.values()];
+}
+export function loadNameDirectory(cacheRoot = meshCacheRoot()) {
+    const names = new Map();
+    for (const person of loadCachedPeople(cacheRoot)) {
+        if (person.displayName)
+            names.set(person.uid, person.displayName);
+    }
+    return names;
+}
+export function displayNameFor(uid, serverName, names) {
+    return serverName?.trim() || names.get(uid) || uid;
+}
+/** Resolve a uid, email, or display name against a list of people. */
+export function resolvePerson(query, people) {
+    const q = query.trim();
+    if (/^(prs|agt)_/.test(q)) {
+        const known = people.find((p) => p.uid === q);
+        return { ok: true, uid: q, ...(known?.displayName ? { displayName: known.displayName } : {}) };
+    }
+    const lower = q.toLowerCase();
+    const exact = people.filter((p) => p.email?.toLowerCase() === lower || p.displayName?.toLowerCase() === lower);
+    const matches = exact.length
+        ? exact
+        : people.filter((p) => p.displayName?.toLowerCase().split(/\s+/)[0] === lower);
+    if (matches.length === 1) {
+        const m = matches[0];
+        return { ok: true, uid: m.uid, ...(m.displayName ? { displayName: m.displayName } : {}) };
+    }
+    return { ok: false, reason: matches.length ? "ambiguous" : "none", candidates: matches };
+}
+export const OVERLAP_MAX_FILES = 200;
+export async function postOverlap(token, req) {
+    const body = {
+        companyUid: req.companyUid,
+        sessionId: req.sessionId,
+        repo: req.repo,
+        branch: req.branch,
+    };
+    if (req.projectId)
+        body.projectId = req.projectId;
+    if (req.storyId)
+        body.storyId = req.storyId;
+    if (req.files?.length)
+        body.files = req.files.slice(0, OVERLAP_MAX_FILES);
+    const data = asRecord(await meshJson(token, "/v1/work-mesh/overlap", { method: "POST", body }));
+    const rows = Array.isArray(data?.overlaps) ? data.overlaps : [];
+    return rows.flatMap((row) => {
+        const r = asRecord(row);
+        const actorUid = str(r?.actorUid);
+        if (!r || !actorUid)
+            return [];
+        const displayName = str(r.displayName);
+        const actorType = str(r.actorType);
+        const projectId = str(r.projectId);
+        const storyId = str(r.storyId);
+        const lastSeenAt = str(r.lastSeenAt);
+        return [{
+                actorUid,
+                ...(displayName ? { displayName } : {}),
+                ...(actorType ? { actorType } : {}),
+                sessionId: str(r.sessionId) ?? "",
+                repo: str(r.repo) ?? "",
+                branch: str(r.branch) ?? "",
+                ...(projectId ? { projectId } : {}),
+                ...(storyId ? { storyId } : {}),
+                reasons: strArray(r.reasons),
+                sharedFiles: strArray(r.sharedFiles),
+                ...(lastSeenAt ? { lastSeenAt } : {}),
+            }];
+    });
+}
+export function formatOverlapLines(overlaps, names) {
+    if (overlaps.length === 0)
+        return ["No overlapping work found."];
+    const lines = [`${overlaps.length} overlapping session${overlaps.length === 1 ? "" : "s"}:`];
+    for (const o of overlaps) {
+        const who = displayNameFor(o.actorUid, o.displayName, names);
+        const where = [
+            o.repo ? `${o.repo}@${o.branch}` : "",
+            o.projectId ? `project ${o.projectId}` : "",
+            o.storyId ? `story ${o.storyId}` : "",
+        ].filter(Boolean).join(", ");
+        lines.push(`- ${who} in session ${o.sessionId}: same ${o.reasons.join(" + ") || "work"}${where ? ` (${where})` : ""}`);
+        if (o.sharedFiles.length) {
+            const shown = o.sharedFiles.slice(0, 10);
+            const more = o.sharedFiles.length - shown.length;
+            lines.push(`  shared files: ${shown.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`);
+        }
+    }
+    return lines;
+}
+export async function postProjectReassign(token, projectId, body) {
+    const payload = { companyUid: body.companyUid, toUid: body.toUid };
+    if (body.includeOpenStories)
+        payload.includeOpenStories = true;
+    if (body.note)
+        payload.note = body.note;
+    const data = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/reassign`, { method: "POST", body: payload }));
+    return {
+        projectId: str(data?.projectId) ?? projectId,
+        ownerUid: str(data?.ownerUid) ?? body.toUid,
+        previousOwnerUid: str(data?.previousOwnerUid) ?? null,
+        reassignedStories: strArray(data?.reassignedStories),
+    };
+}
+export async function fetchStorySuggestions(token, companyUid, projectId, storyId) {
+    const data = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/stories/${encodeURIComponent(storyId)}/suggestions`, { query: { companyUid } }));
+    const rows = Array.isArray(data?.candidates) ? data.candidates : [];
+    return rows.flatMap((row) => {
+        const r = asRecord(row);
+        const actorUid = str(r?.actorUid);
+        if (!r || !actorUid)
+            return [];
+        const displayName = str(r.displayName);
+        const actorType = str(r.actorType);
+        return [{
+                actorUid,
+                ...(displayName ? { displayName } : {}),
+                ...(actorType ? { actorType } : {}),
+                score: typeof r.score === "number" ? r.score : 0,
+                idle: r.idle === true,
+                reasons: strArray(r.reasons),
+            }];
+    });
+}
+export function formatSuggestionLines(storyId, candidates, names) {
+    if (candidates.length === 0)
+        return [`No suggested assignees for ${storyId}.`];
+    const lines = [`Suggested assignees for ${storyId}:`];
+    candidates.forEach((c, i) => {
+        const who = displayNameFor(c.actorUid, c.displayName, names);
+        const why = c.reasons.length ? `: ${c.reasons.join("; ")}` : "";
+        lines.push(`${i + 1}. ${who} (${c.actorUid}) score ${c.score}${c.idle ? ", idle" : ""}${why}`);
+    });
+    return lines;
+}
+export async function fetchRoster(token, companyUid) {
+    const data = asRecord(await meshJson(token, "/v1/work-mesh/live/roster", { query: { companyUid } }));
+    const rows = Array.isArray(data?.members) ? data.members : [];
+    return rows.flatMap((row) => {
+        const r = asRecord(row);
+        const actorUid = str(r?.actorUid);
+        if (!r || !actorUid)
+            return [];
+        const displayName = str(r.displayName);
+        const actorType = str(r.actorType);
+        return [{
+                actorUid,
+                ...(displayName ? { displayName } : {}),
+                ...(actorType ? { actorType } : {}),
+                daemonLastSeenAt: str(r.daemonLastSeenAt) ?? null,
+                lastSessionAt: str(r.lastSessionAt) ?? null,
+                boundSessions: typeof r.boundSessions === "number" ? r.boundSessions : 0,
+                unboundSessions: typeof r.unboundSessions === "number" ? r.unboundSessions : 0,
+            }];
+    });
+}
+export function rosterFlags(member) {
+    const flags = [];
+    if (!member.daemonLastSeenAt)
+        flags.push("no daemon report");
+    if (member.unboundSessions > 0 && member.boundSessions === 0)
+        flags.push("only unbound sessions");
+    return flags;
+}
+export function formatRosterLines(members, companyLabel, names) {
+    const lines = [
+        `Work mesh roster: ${companyLabel}`,
+        "name\tdaemon last seen\tlast session\tbound\tunbound\tflags",
+    ];
+    for (const m of members) {
+        lines.push([
+            displayNameFor(m.actorUid, m.displayName, names),
+            m.daemonLastSeenAt ?? "never",
+            m.lastSessionAt ?? "never",
+            String(m.boundSessions),
+            String(m.unboundSessions),
+            rosterFlags(m).join(", ") || "-",
+        ].join("\t"));
+    }
+    return lines;
+}
+//# sourceMappingURL=team-coordination.js.map

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

@@ -0,0 +1,75 @@
+/**
+ * WMTC-8 gap 7: resolve the project for an unbound (needs_project) session
+ * from local evidence only. No network, no subprocess, so a background hook
+ * refresh can call it cheaply. Every failure resolves to "no binding".
+ *
+ * Order:
+ *  (a) a prior binding for the same repo+branch recorded locally
+ *  (b) PRDs in the session's company whose repo AND branch match
+ *  (c) a PRD matching the repo only, when it is the single candidate
+ */
+import type { SessionStateFile } from "./state.js";
+export interface GitLocation {
+    /** Absolute top-level of the checkout containing cwd. */
+    topLevel: string;
+    /** Main checkout top-level when cwd is a linked worktree. */
+    mainTopLevel?: string;
+    branch: string | null;
+}
+export interface AutoBindCandidate {
+    projectId: string;
+    prdPath: string;
+    matchedBranch: boolean;
+}
+export type AutoBindDecision = {
+    action: "noop";
+    reason: "already_bound" | "not_needs_project" | "no_session";
+    projectId?: string;
+} | {
+    action: "bind";
+    projectId: string;
+    source: "history" | "repo_branch" | "repo_only";
+    candidates: AutoBindCandidate[];
+} | {
+    action: "skip";
+    reason: "no_git" | "no_company" | "no_match" | "ambiguous";
+    candidates: AutoBindCandidate[];
+};
+/** Find the git checkout for cwd and its current branch without spawning git. */
+export declare function readGitLocation(cwd: string): GitLocation | null;
+/** Repo identities for the checkout: HQ-relative paths and absolute paths. */
+export declare function repoIdentities(loc: GitLocation, hqRoot: string): string[];
+/** PRDs under companies/<company>/projects/* that name this checkout. */
+export declare function findRepoPrdCandidates(input: {
+    hqRoot: string;
+    companySlug: string;
+    identities: string[];
+    branch: string | null;
+}): AutoBindCandidate[];
+export declare function autoBindHistoryPath(workContextRoot: string): string;
+export declare function lookupPriorBinding(input: {
+    workContextRoot: string;
+    companySlug: string;
+    identities: string[];
+    branch: string | null;
+}): string | null;
+/** Remember a binding for this repo+branch. Best-effort; never throws. */
+export declare function recordPriorBinding(input: {
+    workContextRoot: string;
+    companySlug: string;
+    identities: string[];
+    branch: string | null;
+    projectId: string;
+    now?: Date;
+}): void;
+export declare function decideAutoBind(input: {
+    state: SessionStateFile | null;
+    cwd: string;
+    hqRoot: string;
+    workContextRoot: string;
+    companySlug?: string;
+}): AutoBindDecision & {
+    git?: GitLocation;
+    identities?: string[];
+};
+//# sourceMappingURL=auto-bind.d.ts.map