@indigoai-us/hq-cli 5.345.123 → 5.345.125

package/dist/lib/lanes/session-relink.js

@@ -117,8 +117,102 @@ function uniqueHomes(homes) {
     }
     return [...unique];
 }
-function missingTranscript(input, homes) {
-    return new LanesError("provider_transcript_missing", `Provider transcript for session ${input.sessionId} was not found. Homes searched: ${homes.join(", ")}`, { provider: input.provider, session_id: input.sessionId, homes_searched: homes });
+function missingTranscript(input, homes, dirsScanned) {
+    return new LanesError("provider_transcript_missing", `Provider transcript for session ${input.sessionId} was not found. Homes searched: ${homes.join(", ")}. Directories scanned: ${dirsScanned.length > 0 ? dirsScanned.join(", ") : "none"}`, {
+        provider: input.provider,
+        session_id: input.sessionId,
+        homes_searched: homes,
+        directories_scanned: dirsScanned,
+    });
+}
+/**
+ * Every `<home>/projects/<dir>/` that could hold a claude transcript. A lane
+ * can record one cwd and have run in another (a worktree), so a resume looks
+ * in every project directory before refusing.
+ */
+function claudeProjectDirs(home) {
+    const root = path.join(home, "projects");
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return [];
+        throw new LanesError("provider_home_search_failed", `Could not search provider home ${home}: ${err instanceof Error ? err.message : String(err)}`, { provider: "claude", home });
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(root, entry.name))
+        .sort();
+}
+function isFile(target) {
+    try {
+        return fs.statSync(target).isFile();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return false;
+        throw err;
+    }
+}
+/**
+ * Last resort for a claude session that is not under the expected project
+ * directory in any home: scan every project directory of every searched home,
+ * then copy the transcript (and its sibling subagent directory) into the
+ * target home under the project directory for `input.cwd`, which is where
+ * `claude --resume` started in that cwd looks for it.
+ */
+function relinkFromAnyProject(input, targetHome, searched) {
+    const scanned = [];
+    if (input.provider !== "claude") {
+        for (const home of searched)
+            scanned.push(path.join(home, "sessions"));
+        throw missingTranscript(input, searched, scanned);
+    }
+    for (const home of searched) {
+        const found = [];
+        const dirs = claudeProjectDirs(home);
+        if (dirs.length === 0)
+            scanned.push(path.join(home, "projects"));
+        for (const dir of dirs) {
+            scanned.push(dir);
+            const candidate = path.join(dir, `${input.sessionId}.jsonl`);
+            if (isFile(candidate))
+                found.push(candidate);
+        }
+        if (found.length === 0)
+            continue;
+        if (found.length > 1) {
+            throw new LanesError("provider_transcript_ambiguous", `Multiple claude transcripts for session ${input.sessionId} exist in ${home}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: found });
+        }
+        const source = found[0];
+        const targetDir = path.join(targetHome, "projects", encodeClaudeProjectDir(input.cwd));
+        const target = path.join(targetDir, `${input.sessionId}.jsonl`);
+        const subagents = path.join(path.dirname(source), input.sessionId);
+        const hasSubagents = statDirectory(subagents);
+        const plan = {
+            provider: "claude",
+            sources: [source],
+            targets: [target],
+            source_dir: hasSubagents ? subagents : null,
+            target_dir: hasSubagents ? path.join(targetDir, input.sessionId) : null,
+        };
+        const copied = copySessionFiles(plan);
+        if (!isFile(target)) {
+            throw new LanesError("provider_transcript_relink_failed", `Could not verify session ${input.sessionId} in target home ${targetHome}`, { provider: input.provider, session_id: input.sessionId, target_home: targetHome });
+        }
+        return {
+            ...copied,
+            source_home: home,
+            transcript_path: target,
+            homes_searched: searched,
+            found_outside_cwd: true,
+        };
+    }
+    throw missingTranscript(input, searched, scanned);
 }
 function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
     let copied;
@@ -132,7 +226,7 @@ function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
     }
     catch (err) {
         if (err instanceof LanesError && err.error === "provider_session_missing") {
-            throw missingTranscript(input, searched);
+            return relinkFromAnyProject(input, targetHome, searched);
         }
         throw err;
     }
@@ -202,7 +296,7 @@ export function ensureSessionHome(input) {
             matches.push({ home, transcript: found[0] });
     }
     if (matches.length === 0)
-        throw missingTranscript(input, searched);
+        return relinkFromAnyProject(input, targetHome, searched);
     if (matches.length > 1) {
         throw new LanesError("provider_transcript_ambiguous", `Provider transcript for session ${input.sessionId} exists in multiple homes: ${matches.map((match) => match.home).join(", ")}`, {
             provider: input.provider,

package/dist/lib/lanes/spawn.d.ts

@@ -255,7 +255,7 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
 export declare function workerEnv(base: NodeJS.ProcessEnv, resolved: {
     envVar: string;
     home: string;
-}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef, workerPolicyDir?: string, registryWorker?: LaneRecord["registry_worker"]): NodeJS.ProcessEnv;
+}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef, workerPolicyDir?: string, registryWorker?: LaneRecord["registry_worker"], homedir?: () => string): NodeJS.ProcessEnv;
 export declare const WORKER_POLICY_HOOK_CAPABILITY = "# hq-capability: worker-policy-dir v1";
 /** Grok does not run HQ hooks; Claude and Codex use the installed capability marker. */
 export declare function workerPolicyDeliveryMode(hqRoot: string, provider: LaneProvider): "hook" | "prompt";

package/dist/lib/lanes/spawn.js

@@ -13,7 +13,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configureRemoteControlChildEnv, prepareRemoteControlLane, remoteControlSelectionConfig } from "./remote-control-lane.js";
-import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
+import { PROVIDER_HOME_ENV, accountStatus, isDefaultProviderHome, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { buildHostCapacitySnapshot } from "./host-capacity.js";
 import { selectClaudeAccount } from "./claude-balance.js";
@@ -1661,7 +1661,7 @@ export function buildProviderCommand(provider, input) {
         args: appendFastModeFlags(parsed, appendEffortFlag(parsed, appendModelFlag(parsed, appendCodexWorkerPolicyDirFlag(parsed, appendProviderProfileFlags(parsed, args, input.profile), input.workerPolicyDir), input.model), input.effort), input.fastMode),
     };
 }
-export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany, workerPolicyDir, registryWorker) {
+export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany, workerPolicyDir, registryWorker, homedir) {
     const accepted = Object.values(PROVIDER_HOME_ENV);
     if (!accepted.includes(resolved.envVar)) {
         throw new LanesError("unknown_provider_home_env", `Unknown provider home variable ${JSON.stringify(resolved.envVar)}. Accepted: ${accepted.join(", ")}`, { accepted, value: resolved.envVar });
@@ -1672,7 +1672,16 @@ export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, mes
     delete env.HQ_POLICY_WORKER_DIR;
     delete env.HQ_LANE_APPROVAL_REQUIRED;
     delete env.HQ_LANE_HUMAN_CHECKPOINTS;
-    env[resolved.envVar] = resolved.home;
+    if (resolved.envVar === PROVIDER_HOME_ENV.claude &&
+        isDefaultProviderHome("claude", resolved.home, homedir)) {
+        // The default ~/.claude home runs with CLAUDE_CONFIG_DIR unset so the
+        // worker reads the same keychain credential as the interactive session
+        // (see isDefaultProviderHome). An inherited value is dropped too.
+        delete env[resolved.envVar];
+    }
+    else {
+        env[resolved.envVar] = resolved.home;
+    }
     delete env[CLAUDE_AUTO_COMPACT_ENV];
     if (resolved.envVar === PROVIDER_HOME_ENV.claude && autoCompactTokens !== undefined) {
         env[CLAUDE_AUTO_COMPACT_ENV] = String(autoCompactTokens);
@@ -2075,6 +2084,14 @@ export function readSpawnManifest(runDir) {
     }
     return out;
 }
+function isExistingDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function laneLaunchResult(lane) {
     const { provider_home_at_spawn: _providerHomeAtSpawn, ...safe } = lane;
     return safe;
@@ -2327,6 +2344,17 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             : existing;
         throw new LanesError("account_not_logged_in", `Account ${resolved.id} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: resolved.id, lane_id: lane.lane_id, lane: failed });
     }
+    // The worker starts here, and claude keys its transcript by this directory,
+    // so the transcript checks below use the same value. A resume reuses the
+    // directory the last run started in (a worktree for pipeline lanes) when it
+    // still exists.
+    const recordedWorkingDirectory = plan.mode === "resume" &&
+        typeof existing.working_directory_at_spawn === "string" &&
+        existing.working_directory_at_spawn.trim() !== "" &&
+        isExistingDirectory(existing.working_directory_at_spawn)
+        ? existing.working_directory_at_spawn
+        : undefined;
+    const workerCwd = deps.workingDirectory ?? pendingResume?.working_directory ?? recordedWorkingDirectory ?? hqRoot;
     if (existing.account !== resolved.id) {
         const source = existing.account
             ? config.providers[existing.provider].accounts[existing.account]
@@ -2335,12 +2363,22 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             source &&
             existing.provider_session_id &&
             providerSupportsSessionResume(existing.provider)) {
-            copySessionFiles(planSessionCopy(existing.provider, {
-                sourceHome: existing.provider_home_at_spawn ?? effectiveAccountHome(source, hostname).home,
-                targetHome: resolved.home,
-                cwd: hqRoot,
-                sessionId: existing.provider_session_id,
-            }));
+            try {
+                copySessionFiles(planSessionCopy(existing.provider, {
+                    sourceHome: existing.provider_home_at_spawn ?? effectiveAccountHome(source, hostname).home,
+                    targetHome: resolved.home,
+                    cwd: workerCwd,
+                    sessionId: existing.provider_session_id,
+                }));
+            }
+            catch (err) {
+                // A resume below searches every home and project directory for the
+                // session, so a transcript under another cwd is handled there.
+                const resumeFollows = plan.mode === "resume" && existing.provider !== "grok";
+                if (!(resumeFollows && err instanceof LanesError && err.error === "provider_session_missing")) {
+                    throw err;
+                }
+            }
         }
     }
     if (plan.mode === "resume" && existing.provider !== "grok") {
@@ -2350,7 +2388,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         ensureSessionHome({
             provider: existing.provider,
             sessionId: plan.session_id,
-            cwd: hqRoot,
+            cwd: workerCwd,
             targetHome,
             registeredHomes: Object.values(config.providers[existing.provider].accounts)
                 .map((account) => effectiveAccountHome(account, hostname).home),
@@ -2644,6 +2682,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             pending_settings: undefined,
             account: resolved.id,
             provider_home_at_spawn: remoteControlHome ?? resolved.home,
+            working_directory_at_spawn: workerCwd,
             ...(model !== undefined ? { model } : {}),
             ...(model !== undefined
                 ? {
@@ -2789,7 +2828,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let watcherPid;
     try {
         noteCapacityAdvisory(lane, env);
-        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, deps.workingDirectory ?? pendingResume?.working_directory ?? hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, workerCwd, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,
@@ -3095,12 +3134,19 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             ? { resume: { session_id: sessionId, prompt: repairPrompt } }
             : { freshTurnPrompt: repairPrompt }),
     });
+    // The repair turn resumes the run's session, which claude keys by the
+    // directory that run started in.
+    const repairCwd = mode === "resume" &&
+        typeof lane.working_directory_at_spawn === "string" &&
+        isExistingDirectory(lane.working_directory_at_spawn)
+        ? lane.working_directory_at_spawn
+        : hqRoot;
     const workerOutOffset = fileSizeOrZero(path.join(logsDir, "worker.out"));
     const previous = readSpawnManifest(runDir);
     let workerPid;
     try {
         noteCapacityAdvisory(lane, env);
-        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, repairCwd, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,

package/dist/lib/lanes/types.d.ts

@@ -772,6 +772,11 @@ export interface LaneRecord {
     provider_session_id_absent?: string;
     /** Provider home used by the most recently spawned run, for transcript recovery. */
     provider_home_at_spawn?: string;
+    /**
+     * Working directory the most recently spawned run started in. Claude keys
+     * its transcript by this directory, so a later resume starts there too.
+     */
+    working_directory_at_spawn?: string;
     /** Set at spawn when this run continued a recorded session instead of starting fresh. */
     last_resume?: LaneResumeRecord;
     /** Last 50 lane worker starts after the initial start, including actor provenance. */

package/dist/lib/lanes/types.js

@@ -242,7 +242,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile", "spawn"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile", "spawn", "command"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], working_directory_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);

package/dist/lib/lanes/watcher.js

@@ -43,6 +43,7 @@ import { appendCappedHistory, listQuestionIds, readLane, readQuestion, retryUpda
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
 import { readWorkerRunResult } from "./delivery.js";
 import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, quotaSignalFromFields, readQuotaSignal, recordAccountQuota, } from "./quota.js";
+import { deliverQuotaHoldNotice, quotaHoldNotice } from "./quota-notice.js";
 import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, isProviderLoginFailure, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 import { appendDropboxMessageAtPath, dropboxInboxHasMessages, readToolActivity, toolActivityPath } from "./dropbox.js";
 import { loadLanesConfig, providerProgressEventMinIntervalMs, providerQuotaDefaultHoldMs } from "./config.js";
@@ -1764,7 +1765,18 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                     (classification.reason === "account_quota_exhausted" ||
                         classification.reason === "account_model_unavailable")) {
                     try {
-                        recordAccountQuota(hqRoot, quotaLane.provider, quotaLane.account, quota);
+                        const observedAt = new Date(now());
+                        const quotaState = recordAccountQuota(hqRoot, quotaLane.provider, quotaLane.account, quota, {
+                            now: observedAt,
+                            unconfirmedHoldMs: providerQuotaDefaultHoldMs(loadLanesConfig(hqRoot).providers[quotaLane.provider]),
+                        });
+                        if (classification.reason === "account_quota_exhausted") {
+                            const notice = quotaHoldNotice(quotaState, quotaLane.provider, quotaLane.account, quotaLane.lane_id);
+                            if (notice) {
+                                const deliveredTo = deliverQuotaHoldNotice(hqRoot, quotaLane, notice, observedAt.toISOString());
+                                logDecision({ event: "quota_hold_notice", at: tick.emit.at, account: quotaLane.account, delivered_to: deliveredTo });
+                            }
+                        }
                     }
                     catch (err) {
                         process.stderr.write(`hq lanes watcher: quota record failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);

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