@indigoai-us/hq-cli 5.345.123 → 5.345.124

package/dist/commands/mesh.js

@@ -13,11 +13,11 @@ import { CLI_VERSION } from "../cli-version.js";
 import chalk from "chalk";
 import { ensureCognitoToken, isExpiring, isMachineIdentity, loadCachedTokens, } from "../utils/cognito-session.js";
 import * as readline from "node:readline/promises";
-import { STORY_STATUSES, appendThreadEvent, addProjectMember, ensureProjectThread, eventPayload, getProjectView, listActiveMembershipCompanies, listActiveThreads, patchStory, putProjectView, registerMeshProject, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
+import { STORY_STATUSES, appendThreadEvent, addProjectMember, ensureProjectThread, eventPayload, getProjectView, listActiveMembershipCompanies, listActiveThreads, meshJson, patchStory, putProjectView, registerMeshProject, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
 import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard, boardStoryStatus, formatStoryStatusChanges, mergeProjectStories, prdSyncEventsThatChangeBoard, reconcileProjectStories, } from "../lib/mesh/project-board.js";
 import { ACCEPTED_LEDGER_STATES, mapSourceStoryStatus, UnknownProjectStoryStateError } from "../lib/mesh/story-status.js";
 import { buildPreflightFixtures } from "../lib/work-context/preflight-contract.js";
-import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
+import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, withParticipantDisplayNames, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
 import { clearDefaultCompany, effectiveUsageAttribution, isDefaultCompanyDisabled, readDeviceConfig, recordMigrationCapabilitySnapshot, setRepairHeldWithDefault, setDefaultCompany, setUsageAttribution, } from "../lib/work-context/config.js";
 import { ensureDefaultCompany } from "../lib/work-context/default-company.js";
 import { cognitoSubFromTokens } from "../lib/work-context/person-identity.js";
@@ -49,6 +49,8 @@ import { formatMigrateConfirmation, submitSessionMigration, } from "../lib/work-
 import { formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, submitOrganizeDecision, } from "../lib/work-context/organize.js";
 import { applyOperatorProjectBinding, readSessionState, updateSessionState, } from "../lib/work-context/state.js";
 import { findLocalPrd, listNeedsProjectSessions } from "../lib/work-context/bind-best.js";
+import { decideAutoBind, readGitLocation, recordPriorBinding, repoIdentities, } from "../lib/work-context/auto-bind.js";
+import { OVERLAP_MAX_FILES, fetchRoster, fetchStorySuggestions, formatOverlapLines, formatRosterLines, formatStoryConflictLine, formatSuggestionLines, isRouteUnavailable, loadCachedPeople, loadNameDirectory, peopleFromPayload, postOverlap, postProjectReassign, resolvePerson, storyConflictFromError, unavailableLine, } from "../lib/mesh/team-coordination.js";
 import { bindCallingSession, formatSessionBoundLine } from "../lib/work-context/bind-calling-session.js";
 import { rebindNeedsProjectOnPrompt } from "../lib/work-context/prompt-rebind.js";
 import { planPrdSync, rebindSessionToProject } from "../lib/work-context/prd-sync.js";
@@ -146,6 +148,32 @@ async function runEvent(verb, opts) {
     }
     console.log(`Work mesh: ${verb} ${ensured.threadId}${event.eventId ? ` (${event.eventId})` : ""}`);
 }
+/** Exit code for a story already held by someone else (`--force` overrides). */
+const STORY_CONFLICT_EXIT = 2;
+function reportStoryConflict(action, storyId, conflict, json) {
+    if (json) {
+        console.log(JSON.stringify({ ok: false, action, storyId, conflict }, null, 2));
+    }
+    else {
+        console.error(formatStoryConflictLine(storyId, conflict, loadNameDirectory()));
+    }
+    process.exit(STORY_CONFLICT_EXIT);
+}
+/** Print the "route not on this server" line (or JSON) and return normally. */
+function reportUnavailable(feature, action, json) {
+    if (json) {
+        console.log(JSON.stringify({ ok: false, unavailable: true, action, feature }));
+        return;
+    }
+    console.log(unavailableLine(feature));
+}
+async function requireAssignableSelf(token, verb) {
+    const resolved = await resolveMeshPrincipalUid(token, loadCachedTokens());
+    if (!resolved || resolved === "session") {
+        fail(`\`${verb}\` needs the signed-in person or agent. The synthetic session identity cannot be assigned. Sign in again and retry.`);
+    }
+    return resolved;
+}
 async function runStory(opts) {
     const storyId = opts.story?.trim();
     const status = opts.status?.trim();
@@ -167,11 +195,7 @@ async function runStory(opts) {
         clearAssignee = true;
     }
     else if (assignee === "me") {
-        const resolved = await resolveMeshPrincipalUid(token, loadCachedTokens());
-        if (!resolved || resolved === "session") {
-            fail("`--assignee me` needs the signed-in person or agent. The synthetic session identity cannot be assigned. Sign in again and retry `hq mesh story`.");
-        }
-        assigneeUid = resolved;
+        assigneeUid = await requireAssignableSelf(token, "--assignee me");
     }
     else if (assignee) {
         if (!/^(prs|agt)_/.test(assignee)) {
@@ -179,11 +203,21 @@ async function runStory(opts) {
         }
         assigneeUid = assignee;
     }
-    const patched = await patchStory(token, company.companyUid, projectId, storyId, {
-        ...(status ? { status } : {}),
-        ...(assigneeUid ? { assigneeUid } : {}),
-        ...(clearAssignee ? { clearAssignee: true } : {}),
-    });
+    let patched;
+    try {
+        patched = await patchStory(token, company.companyUid, projectId, storyId, {
+            ...(status ? { status } : {}),
+            ...(assigneeUid ? { assigneeUid } : {}),
+            ...(clearAssignee ? { clearAssignee: true } : {}),
+            ...(opts.force ? { force: true } : {}),
+        });
+    }
+    catch (err) {
+        const conflict = storyConflictFromError(err);
+        if (conflict)
+            reportStoryConflict("story", storyId, conflict, opts.json);
+        throw err;
+    }
     if (opts.json) {
         console.log(JSON.stringify({ ok: true, action: "story", company, ...patched, storyId }, null, 2));
         return;
@@ -196,6 +230,34 @@ async function runStory(opts) {
     const statusPart = status ? `${storyId} → ${patched.status}` : storyId;
     console.log(`Work mesh: story ${statusPart}${assignment ? ` ${assignment}` : ""} (v${patched.version ?? "?"})`);
 }
+/** `hq mesh claim`: assignee me + in_progress in one PATCH. */
+async function runClaim(opts) {
+    const storyId = opts.story?.trim();
+    if (!storyId)
+        fail("claim requires --story <id>");
+    const projectId = requireProject(opts);
+    const { token, company } = await withCompany(opts);
+    const me = await requireAssignableSelf(token, "hq mesh claim");
+    let patched;
+    try {
+        patched = await patchStory(token, company.companyUid, projectId, storyId, {
+            status: "in_progress",
+            assigneeUid: me,
+            ...(opts.force ? { force: true } : {}),
+        });
+    }
+    catch (err) {
+        const conflict = storyConflictFromError(err);
+        if (conflict)
+            reportStoryConflict("claim", storyId, conflict, opts.json);
+        throw err;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, action: "claim", company, ...patched, storyId }, null, 2));
+        return;
+    }
+    console.log(`Work mesh: claimed ${storyId} (in_progress, assignee ${patched.assigneeUid ?? me}) (v${patched.version ?? "?"})`);
+}
 function record(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -769,9 +831,11 @@ async function runPrdSync(opts) {
         touchedPaths: [resolvePath(file)],
     };
     let toEmit = plan.events;
+    let liveStories = null;
     if (bound?.companyUid && bound.projectId) {
         try {
             const live = await getProjectView(token, bound.companyUid, bound.projectId);
+            liveStories = live.stories;
             toEmit = prdSyncEventsThatChangeBoard(plan.events, live.stories);
         }
         catch {
@@ -852,6 +916,16 @@ async function runPrdSync(opts) {
     }
     const advanced = events.flatMap((event) => (event.eventId && event.taskId && !blocked.has(event.eventId) ? [event.taskId] : []));
     plan.commit([...alreadyOnBoard, ...advanced]);
+    const claimed = bound?.companyUid && bound.projectId
+        ? await claimUnassignedInProgress({
+            token,
+            companyUid: bound.companyUid,
+            projectId: bound.projectId,
+            storyIds: toEmit.filter((event) => event.status === "in_progress" && advanced.includes(event.taskId))
+                .map((event) => event.taskId),
+            liveStories,
+        })
+        : [];
     if (plan.taskId && advanced.includes(plan.taskId)) {
         updateSessionState(sessionId, root, (current) => {
             if (!current)
@@ -865,11 +939,62 @@ async function runPrdSync(opts) {
         });
     }
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "context.prd-sync", changed: toEmit.length, taskId: plan.taskId }));
+        console.log(JSON.stringify({
+            ok: true,
+            action: "context.prd-sync",
+            changed: toEmit.length,
+            taskId: plan.taskId,
+            ...(claimed.length ? { claimed } : {}),
+        }));
         return;
     }
     console.log(`Work mesh: prd-sync emitted ${toEmit.length} task_status`);
 }
+/**
+ * WMTC-7: a story prd-sync moves to in_progress with no Board assignee is
+ * claimed for the signed-in principal. A conflict means someone else holds
+ * it: warn and continue, never --force. Fail-open on every other error.
+ */
+async function claimUnassignedInProgress(input) {
+    if (input.storyIds.length === 0)
+        return [];
+    const assigned = new Set((input.liveStories ?? [])
+        .filter((story) => {
+        const uid = story.assigneeUid;
+        return typeof uid === "string" && uid.trim() !== "";
+    })
+        .map((story) => story.id));
+    const pending = input.storyIds.filter((id) => !assigned.has(id));
+    if (pending.length === 0)
+        return [];
+    let me;
+    try {
+        me = await resolveMeshPrincipalUid(input.token, loadCachedTokens());
+    }
+    catch {
+        me = undefined;
+    }
+    if (!me || me === "session")
+        return [];
+    const claimed = [];
+    for (const storyId of pending) {
+        try {
+            await patchStory(input.token, input.companyUid, input.projectId, storyId, { assigneeUid: me });
+            claimed.push(storyId);
+        }
+        catch (err) {
+            const conflict = storyConflictFromError(err);
+            if (conflict) {
+                console.error(`work-mesh: ${formatStoryConflictLine(storyId, conflict, loadNameDirectory())}`);
+            }
+            else {
+                const reason = err instanceof Error ? err.message : String(err);
+                console.error(`work-mesh: prd-sync could not claim ${storyId} (${reason.slice(0, 160)})`);
+            }
+        }
+    }
+    return claimed;
+}
 function noteCallingSessionBound(projectId, company) {
     try {
         const bound = bindCallingSession({
@@ -927,6 +1052,27 @@ async function runDoctor(opts) {
         console.log(`- ${row.sessionId}: ${row.reason ?? "no reason recorded"}; candidates: ${choices}`);
     }
 }
+/** Remember cwd's repo+branch → project so auto-bind can reuse it. Best-effort. */
+function rememberRepoBinding(root, companySlug, projectId) {
+    if (!companySlug)
+        return;
+    try {
+        const git = readGitLocation(process.cwd());
+        if (!git)
+            return;
+        const hqRoot = process.env.HQ_ROOT?.trim() || findHqRoot();
+        recordPriorBinding({
+            workContextRoot: root,
+            companySlug,
+            identities: repoIdentities(git, hqRoot),
+            branch: git.branch,
+            projectId,
+        });
+    }
+    catch {
+        /* hint only */
+    }
+}
 async function runBindProject(target, opts) {
     const sessionId = opts.session.trim();
     const root = workContextHomeRoot();
@@ -971,6 +1117,7 @@ async function runBindProject(target, opts) {
     const updated = updateSessionState(sessionId, root, (state) => state ? applyOperatorProjectBinding(state, projectId) : null);
     if (!updated)
         fail(`No work-context state for session ${sessionId}.`);
+    rememberRepoBinding(root, updated.companySlug, projectId);
     if (opts.json) {
         console.log(JSON.stringify({ ok: true, action: "context.bind-project", sessionId, projectId, contextStatus: updated.contextStatus }));
         return;
@@ -1770,18 +1917,261 @@ async function runSessionStatus(opts) {
         fail("`--company <slug>` is required for `hq mesh session status`");
     }
     const { token, company } = await withCompany({ company: opts.company });
-    const live = await fetchCompanyLive(token, company.companyUid);
+    const names = loadNameDirectory();
+    const live = withParticipantDisplayNames(await fetchCompanyLive(token, company.companyUid), names);
     const unattributedEvents = collectDaemonDoctor().unattributedEvents;
     if (opts.json) {
         console.log(JSON.stringify({ ok: true, action: "session-status", company, live, unattributedEvents }, null, 2));
         return;
     }
-    for (const line of formatCompanyLiveTable(live, company.companySlug || company.companyUid)) {
+    for (const line of formatCompanyLiveTable(live, company.companySlug || company.companyUid, names)) {
         console.log(line);
     }
     console.log(`unattributed events: ${unattributedEvents.total} ` +
         `(spool=${unattributedEvents.spool} held=${unattributedEvents.held} dead-letter=${unattributedEvents.deadLetter})`);
 }
+function parseFilesJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        fail("--files-json must be a JSON array of repo-relative paths");
+    }
+    if (!Array.isArray(parsed) || !parsed.every((f) => typeof f === "string")) {
+        fail("--files-json must be a JSON array of repo-relative paths");
+    }
+    return parsed;
+}
+/** WMTC-8 gap 1: who else is working on this story, branch, or these files. */
+async function runOverlap(opts) {
+    const sessionId = opts.session?.trim();
+    const repo = opts.repo?.trim();
+    const branch = opts.branch?.trim();
+    if (!opts.company?.trim() || !sessionId || !repo || !branch) {
+        fail("Usage: hq mesh overlap --company <slug> --session <sid> --repo <name> --branch <b>");
+    }
+    if (opts.file?.length && opts.filesJson)
+        fail("Use --file or --files-json, not both.");
+    const files = [...new Set((opts.filesJson ? parseFilesJson(opts.filesJson) : opts.file ?? [])
+            .map((f) => f.trim()).filter(Boolean))];
+    if (files.length > OVERLAP_MAX_FILES) {
+        console.error(`work-mesh: sending the first ${OVERLAP_MAX_FILES} of ${files.length} files`);
+    }
+    const { token, company } = await withCompany({ company: opts.company });
+    let overlaps;
+    try {
+        overlaps = await postOverlap(token, {
+            companyUid: company.companyUid,
+            sessionId,
+            repo,
+            branch,
+            ...(opts.project?.trim() ? { projectId: opts.project.trim() } : {}),
+            ...(opts.story?.trim() ? { storyId: opts.story.trim() } : {}),
+            ...(files.length ? { files } : {}),
+        });
+    }
+    catch (err) {
+        if (isRouteUnavailable(err))
+            return reportUnavailable("Overlap detection", "overlap", opts.json);
+        throw err;
+    }
+    const names = loadNameDirectory();
+    if (opts.json) {
+        const named = overlaps.map((o) => {
+            const displayName = o.displayName || names.get(o.actorUid);
+            return displayName ? { ...o, displayName } : o;
+        });
+        console.log(JSON.stringify({ ok: true, action: "overlap", company, overlaps: named }, null, 2));
+        return;
+    }
+    for (const line of formatOverlapLines(overlaps, names))
+        console.log(line);
+}
+async function resolveReassignTarget(token, query) {
+    let resolution = resolvePerson(query, loadCachedPeople());
+    if (!resolution.ok && resolution.reason === "none") {
+        try {
+            resolution = resolvePerson(query, peopleFromPayload(await meshJson(token, "/v1/notify/contacts")));
+        }
+        catch {
+            /* fall through to the cached answer */
+        }
+    }
+    if (resolution.ok)
+        return resolution;
+    if (resolution.reason === "ambiguous") {
+        const list = resolution.candidates
+            .map((p) => `${p.displayName ?? p.uid} (${p.uid}${p.email ? `, ${p.email}` : ""})`)
+            .join("; ");
+        fail(`--to "${query}" matches more than one person: ${list}. Pass a uid or email.`);
+    }
+    fail(`--to "${query}" did not match anyone in the directory. Run \`hq mesh doctor\` to refresh it, or pass a uid.`);
+}
+/** WMTC-8 gap 3: move project ownership (and optionally open stories) to someone else. */
+async function runProjectReassign(projectId, opts) {
+    const to = opts.to?.trim();
+    if (!to)
+        fail("project reassign requires --to <uid|email|name>");
+    const { token, company } = await withCompany({ company: opts.company });
+    const target = await resolveReassignTarget(token, to);
+    let result;
+    try {
+        result = await postProjectReassign(token, projectId, {
+            companyUid: company.companyUid,
+            toUid: target.uid,
+            ...(opts.includeOpenStories ? { includeOpenStories: true } : {}),
+            ...(opts.note?.trim() ? { note: opts.note.trim() } : {}),
+        });
+    }
+    catch (err) {
+        if (isRouteUnavailable(err))
+            return reportUnavailable("Project reassignment", "project.reassign", opts.json);
+        throw err;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            ok: true,
+            action: "project.reassign",
+            company,
+            ...result,
+            ...(target.displayName ? { ownerDisplayName: target.displayName } : {}),
+        }, null, 2));
+        return;
+    }
+    const names = loadNameDirectory();
+    const owner = target.displayName || names.get(result.ownerUid) || result.ownerUid;
+    const stories = result.reassignedStories.length
+        ? `; reassigned ${result.reassignedStories.length} open stor${result.reassignedStories.length === 1 ? "y" : "ies"} (${result.reassignedStories.join(", ")})`
+        : "";
+    console.log(`Work mesh: project ${result.projectId} now owned by ${owner}${stories}`);
+}
+/** WMTC-8 gap 5: ranked assignee candidates for a story. */
+async function runSuggest(opts) {
+    const storyId = opts.story?.trim();
+    if (!storyId)
+        fail("suggest requires --story <id>");
+    const projectId = requireProject(opts);
+    const { token, company } = await withCompany({ company: opts.company });
+    let candidates;
+    try {
+        candidates = await fetchStorySuggestions(token, company.companyUid, projectId, storyId);
+    }
+    catch (err) {
+        if (isRouteUnavailable(err))
+            return reportUnavailable("Assignee suggestions", "suggest", opts.json);
+        throw err;
+    }
+    const names = loadNameDirectory();
+    if (opts.json) {
+        const named = candidates.map((c) => {
+            const displayName = c.displayName || names.get(c.actorUid);
+            return displayName ? { ...c, displayName } : c;
+        });
+        console.log(JSON.stringify({ ok: true, action: "suggest", company, projectId, storyId, candidates: named }, null, 2));
+        return;
+    }
+    for (const line of formatSuggestionLines(storyId, candidates, names))
+        console.log(line);
+}
+/** WMTC-8 gap 6: who has a daemon reporting and who only has unbound sessions. */
+async function runRoster(opts) {
+    if (!opts.company?.trim())
+        fail("`--company <slug>` is required for `hq mesh roster`");
+    const { token, company } = await withCompany({ company: opts.company });
+    let members;
+    try {
+        members = await fetchRoster(token, company.companyUid);
+    }
+    catch (err) {
+        if (isRouteUnavailable(err))
+            return reportUnavailable("The presence roster", "roster", opts.json);
+        throw err;
+    }
+    const names = loadNameDirectory();
+    if (opts.json) {
+        const named = members.map((m) => {
+            const displayName = m.displayName || names.get(m.actorUid);
+            return displayName ? { ...m, displayName } : m;
+        });
+        console.log(JSON.stringify({ ok: true, action: "roster", company, members: named }, null, 2));
+        return;
+    }
+    for (const line of formatRosterLines(members, company.companySlug || company.companyUid, names)) {
+        console.log(line);
+    }
+}
+/**
+ * WMTC-8 gap 7: bind a needs_project session from local repo/branch evidence.
+ * Runs from a background hook refresh, so it is local-only and fail-open:
+ * any unexpected error prints one line and exits 0.
+ */
+async function runContextAutoBind(opts) {
+    const sessionId = opts.session?.trim();
+    if (!sessionId)
+        fail("Usage: hq mesh context auto-bind --session <sid>");
+    const out = (payload, line) => {
+        if (opts.json)
+            console.log(JSON.stringify({ action: "context.auto-bind", sessionId, ...payload }));
+        else
+            console.log(line);
+    };
+    try {
+        const root = workContextHomeRoot();
+        const hqRoot = process.env.HQ_ROOT?.trim() || findHqRoot();
+        const state = readSessionState(sessionId, root);
+        const decision = decideAutoBind({
+            state,
+            cwd: opts.cwd?.trim() || process.cwd(),
+            hqRoot,
+            workContextRoot: root,
+            ...(opts.company?.trim() ? { companySlug: opts.company.trim() } : {}),
+        });
+        const candidates = "candidates" in decision
+            ? decision.candidates.map((c) => ({ projectId: c.projectId, prdPath: c.prdPath, matchedBranch: c.matchedBranch }))
+            : [];
+        if (decision.action === "noop") {
+            out({ ok: true, bound: false, reason: decision.reason, ...(decision.projectId ? { projectId: decision.projectId } : {}) }, decision.reason === "already_bound"
+                ? `Work mesh: session ${sessionId} already bound to ${decision.projectId}`
+                : `Work mesh: auto-bind skipped (${decision.reason})`);
+            return;
+        }
+        if (decision.action === "skip") {
+            const list = candidates.map((c) => c.projectId).join(", ");
+            out({ ok: true, bound: false, reason: decision.reason, candidates }, `Work mesh: auto-bind did not bind (${decision.reason})${list ? `; candidates: ${list}` : ""}`);
+            return;
+        }
+        if (opts.dryRun) {
+            out({ ok: true, bound: false, dryRun: true, projectId: decision.projectId, source: decision.source, candidates }, `Work mesh: would bind session ${sessionId} to ${decision.projectId} (${decision.source})`);
+            return;
+        }
+        const updated = updateSessionState(sessionId, root, (current) => current && current.contextStatus === "needs_project"
+            ? applyOperatorProjectBinding(current, decision.projectId)
+            : current);
+        const companySlug = opts.company?.trim() || state?.companySlug;
+        if (companySlug && decision.git && decision.identities) {
+            recordPriorBinding({
+                workContextRoot: root,
+                companySlug,
+                identities: decision.identities,
+                branch: decision.git.branch,
+                projectId: decision.projectId,
+            });
+        }
+        out({
+            ok: true,
+            bound: updated?.projectId === decision.projectId,
+            projectId: decision.projectId,
+            source: decision.source,
+            contextStatus: updated?.contextStatus,
+            candidates,
+        }, `Work mesh: session ${sessionId} bound to project ${decision.projectId} (${decision.source})`);
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        out({ ok: false, bound: false, reason: "error", error: reason.slice(0, 200) }, `work-mesh: auto-bind failed open (${reason.slice(0, 160)})`);
+    }
+}
 const HARNESSES = new Set([
     "claude-code",
     "codex",
@@ -2116,7 +2506,40 @@ export function registerMeshCommand(program, deps = {}) {
         .description("PATCH one Board story status and/or assignee")
         .requiredOption("--story <id>", "Story id, e.g. US-001")
         .option("--status <status>", "queued|in_progress|review|done")
-        .option("--assignee <uid|me|none>", "Assign a person or agent uid, yourself, or clear")).action((opts) => wrap(() => runStory(opts))());
+        .option("--assignee <uid|me|none>", "Assign a person or agent uid, yourself, or clear")
+        .option("--force", "Override another holder's assignment")).action((opts) => wrap(() => runStory(opts))());
+    addSharedFlags(mesh
+        .command("claim")
+        .description("Assign a story to yourself and move it to in_progress")
+        .requiredOption("--story <id>", "Story id, e.g. US-001")
+        .option("--force", "Take the story even when someone else holds it")).action((opts) => wrap(() => runClaim(opts))());
+    mesh
+        .command("overlap")
+        .description("List other sessions working on the same story, branch, or files")
+        .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
+        .requiredOption("--session <sid>", "Your session id")
+        .requiredOption("--repo <name>", "Repository name")
+        .requiredOption("--branch <branch>", "Current branch")
+        .option("--project <id>", "Project id")
+        .option("--story <id>", "Story id")
+        .option("--file <path>", "Repo-relative file you are changing (repeatable)", collectRepeatable)
+        .option("--files-json <json>", "JSON array of repo-relative file paths")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runOverlap(opts))());
+    mesh
+        .command("suggest")
+        .description("Rank teammates and agents to pick up a story")
+        .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
+        .requiredOption("--project <id>", "Project id")
+        .requiredOption("--story <id>", "Story id")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runSuggest(opts))());
+    mesh
+        .command("roster")
+        .description("Show each member's daemon and session reporting state")
+        .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runRoster(opts))());
     const project = mesh
         .command("project")
         .description("Set a project Board view or register its project channel");
@@ -2157,6 +2580,15 @@ export function registerMeshCommand(program, deps = {}) {
         .option("--channel <channelId>", "Bind the project to an existing company or project channel")
         .option("--json", "Print machine-readable JSON")
         .action((projectId, opts) => wrap(() => runProjectRegister(projectId, opts))());
+    project
+        .command("reassign <projectId>")
+        .description("Move project ownership to another person or agent")
+        .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
+        .requiredOption("--to <uid|email|name>", "New owner (uid, email, or directory name)")
+        .option("--include-open-stories", "Also reassign the project's open stories")
+        .option("--note <text>", "Handoff note")
+        .option("--json", "Print machine-readable JSON")
+        .action((projectId, opts) => wrap(() => runProjectReassign(projectId, opts))());
     project
         .command("member")
         .description("Manage project members")
@@ -2217,6 +2649,15 @@ export function registerMeshCommand(program, deps = {}) {
         .requiredOption("--file <path>", "prd.json written by the bound session")
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runPrdSync(opts))());
+    context
+        .command("auto-bind")
+        .description("Bind a needs_project session to the project its repo and branch belong to (local-only, fail-open)")
+        .requiredOption("--session <sid>", "Canonical session id")
+        .option("--cwd <dir>", "Working directory to read the repo and branch from")
+        .option("--company <slug>", "Company slug (defaults to the session's company)")
+        .option("--dry-run", "Print the decision without binding")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runContextAutoBind(opts))());
     context
         .command("organize")
         .description("List or submit one-time project/task decisions (US-007B / US-005B)")

package/dist/fast-scaffold.js

@@ -160,6 +160,19 @@ export function isDefaultOnFastFamily(flagKey) {
 }
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export const FAST_SCAFFOLD_SCRIPTS = [
+    {
+        name: "work-mesh-project-registration-offer",
+        kind: "native",
+        modulePath: "./commands/core-bucket-c-workflow-gate-fast.js",
+        exportName: "runWorkMeshProjectRegistrationOfferFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-bucket-c",
+        asset: "core/scripts/work-mesh-project-registration-offer.sh",
+        requiresNodeNetworkCompatibility: true,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
     {
         name: "handoff-sync-prefetch",
         kind: "native",
@@ -208,6 +221,19 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "live",
         shellHqRoot: "live",
     },
+    {
+        name: "workflow-gate",
+        kind: "native",
+        modulePath: "./commands/core-bucket-c-workflow-gate-fast.js",
+        exportName: "runWorkflowGateFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-bucket-c",
+        asset: "core/scripts/workflow-gate.sh",
+        requiresNodeNetworkCompatibility: true,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
     {
         name: "sentry report",
         kind: "native",

package/dist/lib/lanes/quota-notice.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ *
+ * An account-wide hold stops every lane on that account, so the senior needs
+ * to see it with the provider's own words and the command that lifts it. One
+ * message per (provider, account, hold), so several lanes failing on the same
+ * hold produce one notice.
+ */
+import type { QuotaState } from "./quota.js";
+import { type LaneProvider, type LaneRecord } from "./types.js";
+export interface QuotaHoldNotice {
+    message_id: string;
+    text: string;
+}
+/** Build the notice for the account's current hold, or null when there is none. */
+export declare function quotaHoldNotice(state: QuotaState, provider: LaneProvider, accountId: string, laneId: string): QuotaHoldNotice | null;
+/**
+ * Deliver the notice to the lane's senior inbox. A session senior gets it in
+ * its monitor-session inbox, a lane senior in that lane's dropbox. The notice
+ * is always written to stderr as well, so a senior with no inbox still has it
+ * in the watcher log. Returns where it was delivered.
+ */
+export declare function deliverQuotaHoldNotice(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "senior">, notice: QuotaHoldNotice, at: string): "session_inbox" | "lane_inbox" | "stderr_only";
+//# sourceMappingURL=quota-notice.d.ts.map