@indigoai-us/hq-cli 5.234.2 → 5.236.0

package/dist/commands/lanes.js

@@ -17,13 +17,11 @@ import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { createTrackerMeshQuestionClient, deliverTrackerMeshQuestionOnce } from "../lib/lanes/tracker-mesh-questions.js";
-import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
-import { defaultTrackerActor, LANES_TRACKER_FLAG, LANES_TRACKER_MESH_FLAG, registerLaneTrackerCommands, } from "./lanes-tracker.js";
+import { defaultTrackerActor, LANES_TRACKER_FLAG, registerLaneTrackerCommands, } from "./lanes-tracker.js";
 import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGrantSenior, } from "../lib/lanes/hire-grant-dispatch.js";
 import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } from "../lib/lanes/outpost-profile-repin.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
@@ -46,7 +44,7 @@ import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
-import { questionBodyAbsPath, questionRecordRefusalCode, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
+import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
@@ -81,9 +79,6 @@ function defaultLanePlacementEnabled() {
 function defaultLaneTrackerEnabled(company) {
     return readLanesRegistryFlag(LANES_TRACKER_FLAG, { company });
 }
-function defaultLaneTrackerMeshEnabled(company) {
-    return readLanesRegistryFlag(LANES_TRACKER_MESH_FLAG, { company });
-}
 function defaultLaneOutpostQuestionVisibilityEnabled(company, env) {
     return readLanesRegistryFlag(LANE_OUTPOST_QUESTION_VISIBILITY_FLAG, {
         company,
@@ -319,8 +314,6 @@ function resolveDeps(deps = {}) {
         laneOutpostQuestionVisibilityEnabled: deps.laneOutpostQuestionVisibilityEnabled ??
             ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
-        laneTrackerMeshEnabled: deps.laneTrackerMeshEnabled ?? defaultLaneTrackerMeshEnabled,
-        trackerMeshRequest: deps.trackerMeshRequest,
         laneHostScopedAccountHomesEnabled: deps.laneHostScopedAccountHomesEnabled ??
             ((company) => defaultLaneHostScopedAccountHomesEnabled(company, env)),
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
@@ -510,167 +503,6 @@ function requireQuestionBody(hqRoot, question) {
     }
     return body;
 }
-function trackerMeshAudience(ref) {
-    if (ref.kind === "user")
-        return "owner";
-    if (ref.kind === "session")
-        return "operator";
-    return `lane:${ref.id ?? ""}`;
-}
-function trackerMeshAudienceKind(value) {
-    if (value === "owner" || value.startsWith("owner:"))
-        return "owner";
-    if (value === "operator" || value.startsWith("operator:"))
-        return "operator";
-    return "lane";
-}
-function trackerMeshQuestionInput(lane, question, body) {
-    if (!lane.project_id.trim())
-        throw new LanesError("tracker_mesh_question_invalid", "Question lane has no project id", { lane_id: lane.lane_id });
-    const route = question.routing_history;
-    const currentAudience = route.at(-1)?.audience ?? lane.senior;
-    return {
-        laneId: lane.lane_id,
-        ...(lane.thread_id ? { threadId: lane.thread_id } : {}),
-        projectId: lane.project_id,
-        audience: trackerMeshAudienceKind(trackerMeshAudience(currentAudience)),
-        audienceChain: route.length ? route.map((entry) => trackerMeshAudience(entry.audience)) : [trackerMeshAudience(currentAudience)],
-        routingHistory: route.map((entry) => ({ audience: trackerMeshAudience(entry.audience), at: entry.at, reason: entry.reason })),
-        question: body.question,
-        context: body.context,
-        options: body.options,
-        ...(body.recommended !== undefined ? { recommended: body.recommended } : {}),
-    };
-}
-function assertMeshQuestionMatchesLocal(row, question, company) {
-    if (row.companyUid !== company.uid || row.laneId !== question.lane_id || row.projectId !== question.project_id) {
-        throw new LanesError("tracker_question_company_mismatch", "Work Mesh question does not match the local lane company and project", {
-            question_id: question.question_id,
-            mesh_question_id: row.questionId,
-            lane_id: question.lane_id,
-        });
-    }
-}
-async function indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest })) {
-    if (question.mesh_question_id)
-        return question;
-    if (question.status !== "pending")
-        return question;
-    const input = trackerMeshQuestionInput(lane, question, body);
-    const candidates = (await client.list(["pending", "answered"])).filter((row) => row.laneId === input.laneId && row.projectId === input.projectId && row.threadId === (input.threadId ?? row.threadId) &&
-        row.audience === input.audience && row.question === input.question && row.context === input.context &&
-        JSON.stringify(row.options) === JSON.stringify(input.options) &&
-        row.routingHistory.at(-1)?.at === input.routingHistory.at(-1)?.at);
-    if (candidates.length > 1) {
-        throw new LanesError("tracker_mesh_question_ambiguous", "More than one pending Work Mesh question matches this local question", { question_id: question.question_id, lane_id: lane.lane_id });
-    }
-    const row = candidates[0] ?? await client.create(input);
-    assertMeshQuestionMatchesLocal(row, question, company);
-    return casUpdateQuestion(hqRoot, question.question_id, (current) => {
-        if (current.status !== "pending")
-            return current;
-        if (current.mesh_question_id && current.mesh_question_id !== row.questionId) {
-            throw new LanesError("tracker_mesh_question_conflict", "Local question was already linked to another Work Mesh question", { question_id: current.question_id });
-        }
-        return current.mesh_question_id === row.questionId ? current : { ...current, mesh_question_id: row.questionId };
-    });
-}
-async function syncTrackerMeshQuestions(ctx, hqRoot) {
-    if (!ctx.laneTrackerMeshEnabled)
-        return;
-    const lanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
-    const byCompany = new Map();
-    for (const lane of lanes.values()) {
-        let company;
-        try {
-            company = await resolveQuestionCompanyWithFallback(hqRoot, lane, () => resolveActiveQuestionCompany(ctx, "Cannot sync lane questions without an HQ company"));
-        }
-        catch (err) {
-            if (lane.company || lane.mesh_company ||
-                !isLanesError(err) || err.error !== "question_company_unavailable" ||
-                err.details.resolution !== "active_company_required")
-                throw err;
-            continue;
-        }
-        if (!await ctx.laneTrackerMeshEnabled(company))
-            continue;
-        const key = `${company.uid}\0${company.slug}`;
-        if (!byCompany.has(key))
-            byCompany.set(key, { company, client: createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }) });
-    }
-    const localQuestions = loadAllQuestions(hqRoot);
-    for (const question of localQuestions) {
-        if (question.status !== "pending" || question.mesh_question_id)
-            continue;
-        const lane = lanes.get(question.lane_id);
-        if (!lane)
-            continue;
-        const company = question.company ?? lane.company ?? lane.mesh_company;
-        if (!company)
-            continue;
-        const client = byCompany.get(`${company.uid}\0${company.slug}`)?.client;
-        if (!client)
-            continue;
-        const body = requireQuestionBody(hqRoot, question);
-        await indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client);
-    }
-    for (const { company, client } of byCompany.values()) {
-        const remote = await client.list(["answered"]);
-        const remoteById = new Map(remote.map((row) => [row.questionId, row]));
-        for (const question of loadAllQuestions(hqRoot)) {
-            if (!question.mesh_question_id || question.company?.uid !== company.uid)
-                continue;
-            const row = remoteById.get(question.mesh_question_id);
-            if (!row)
-                continue;
-            assertMeshQuestionMatchesLocal(row, question, company);
-            const lane = lanes.get(question.lane_id);
-            if (!lane)
-                continue;
-            if (row.status === "answered" && question.status === "pending") {
-                if (typeof row.choice !== "string" || typeof row.answeredAt !== "string" || typeof row.answeredBy !== "string") {
-                    throw new LanesError("tracker_mesh_response_invalid", "Answered Work Mesh question is missing its answer fields", { mesh_question_id: row.questionId });
-                }
-                const currentBody = requireQuestionBody(hqRoot, question);
-                let notesRef;
-                let nextBody = question.body;
-                if (row.notes !== undefined) {
-                    const bodyQuestion = question.company || question.body.store === "personal" ? question : { ...question, company };
-                    const stored = writeQuestionBody(hqRoot, bodyQuestion, { ...currentBody, notes: row.notes });
-                    notesRef = stored.ref;
-                    nextBody = stored;
-                }
-                casUpdateQuestion(hqRoot, question.question_id, (current) => {
-                    if (current.status !== "pending")
-                        return current;
-                    if (current.mesh_question_id !== row.questionId)
-                        throw new LanesError("tracker_mesh_question_conflict", "Local question link changed during answer sync", { question_id: current.question_id });
-                    return {
-                        ...current,
-                        company: current.company ?? company,
-                        body: nextBody,
-                        status: "answered",
-                        answer: {
-                            choice: row.choice,
-                            answer_kind: currentBody.options.includes(row.choice) ? "option" : "freeform",
-                            notes_ref: notesRef,
-                            answered_by: row.answeredBy,
-                            answered_at: row.answeredAt,
-                            answered_level: current.hop,
-                        },
-                    };
-                });
-            }
-        }
-        for (const question of loadAllQuestions(hqRoot)) {
-            if (question.company?.uid !== company.uid || !question.mesh_question_id)
-                continue;
-            await deliverTrackerMeshQuestionOnce(question, company, client, (deliveredAt) => casUpdateQuestion(hqRoot, question.question_id, (current) => current.mesh_delivered_at
-                ? current
-                : { ...current, mesh_delivered_at: deliveredAt }));
-        }
-    }
-}
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
@@ -7996,7 +7828,7 @@ async function runAsk(ctx, opts) {
     const attempts = ASK_ATTEMPTS;
     for (let i = 0; i < attempts; i += 1) {
         try {
-            let withBody = raiseLaneQuestion({
+            const withBody = raiseLaneQuestion({
                 hqRoot,
                 lane,
                 body,
@@ -8006,9 +7838,6 @@ async function runAsk(ctx, opts) {
                 questionId,
             });
             questionId = withBody.question_id;
-            if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
-                withBody = await indexTrackerQuestion(ctx, hqRoot, lane, withBody, body, questionCompany);
-            }
             await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question", {
                 lane_id: lane.lane_id,
                 question_id: withBody.question_id,
@@ -8395,28 +8224,18 @@ async function runQuestionsList(ctx, opts) {
     const outpostLoad = opts.allHosts
         ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
         : { questions: [], errors: [] };
-    const meshRows = await ctx.laneTrackerMeshEnabled(company) && status !== "expired"
-        ? await createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }).list(status ? [status] : undefined)
-        : [];
     for (const owner of outpostLoad.questions) {
         assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
         syncPrimaryQuestionDelivery(hqRoot, owner);
     }
     const remoteQuestionIds = new Set(outpostLoad.questions.map(({ question }) => question.question_id));
-    const localMeshQuestionIds = new Set(localQuestions.map((question) => question.mesh_question_id).filter((id) => Boolean(id)));
     const questions = [
         ...localQuestions
             .filter((q) => !remoteQuestionIds.has(q.question_id))
             .map((q) => {
-            const meshRow = q.mesh_question_id ? meshRows.find((row) => row.questionId === q.mesh_question_id) : undefined;
             const row = {
                 ...q,
                 audience: resolveAudience(hqRoot, q, ctx),
-                ...(meshRow ? {
-                    mesh_question_id: meshRow.questionId,
-                    body_preview: { question: meshRow.question, context: meshRow.context ?? "", options: meshRow.options, ...(meshRow.recommended ? { recommended: meshRow.recommended } : {}) },
-                    host: `${meshRow.host.kind}:${meshRow.host.id}`,
-                } : {}),
                 ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
             };
             if (!opts.allHosts)
@@ -8448,50 +8267,6 @@ async function runQuestionsList(ctx, opts) {
             audience,
             ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
         })),
-        ...meshRows
-            .filter((row) => {
-            if (localMeshQuestionIds.has(row.questionId))
-                return false;
-            if (status && row.status !== status)
-                return false;
-            if (opts.from && row.laneId !== opts.from)
-                return false;
-            if (opts.project && row.projectId !== opts.project)
-                return false;
-            if (opts.story) {
-                const lane = localLanes.get(row.laneId);
-                if (!lane || lane.story_id !== opts.story)
-                    return false;
-            }
-            const audience = row.audience === "owner"
-                ? { kind: "user" }
-                : row.audience === "operator"
-                    ? { kind: "session", id: "mesh" }
-                    : { kind: "lane", id: row.laneId };
-            if (forFilter && !audienceMatches(audience, forFilter))
-                return false;
-            return true;
-        })
-            .map((row) => ({
-            question_id: row.questionId,
-            mesh_question_id: row.questionId,
-            lane_id: row.laneId,
-            company,
-            project_id: row.projectId,
-            story_id: localLanes.get(row.laneId)?.story_id ?? "",
-            ...(row.threadId ? { thread_id: row.threadId } : {}),
-            asked_at: row.askedAt,
-            origin: { kind: "lane", id: row.laneId },
-            hop: row.routingHistory.length || 1,
-            status: row.status,
-            audience: row.audience,
-            host: `${row.host.kind}:${row.host.id}`,
-            question: row.question,
-            context: row.context ?? "",
-            options: row.options,
-            ...(row.recommended ? { recommended: row.recommended } : {}),
-            ...(row.choice !== undefined ? { answer: { choice: row.choice, answered_by: row.answeredBy, answered_at: row.answeredAt, notes: row.notes } } : {}),
-        })),
     ];
     printJson({
         ok: true,
@@ -8509,43 +8284,6 @@ async function runQuestionsShow(ctx, questionId) {
     catch (err) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
-        let meshCompany = null;
-        try {
-            meshCompany = await resolveActiveQuestionCompany(ctx, "Cannot look up Work Mesh question without an active company");
-        }
-        catch (companyError) {
-            if (questionRecordRefusalCode(companyError) !== "question_company_unavailable")
-                throw companyError;
-            // The Outpost lookup below remains available to unscoped primary hosts.
-        }
-        if (meshCompany && await ctx.laneTrackerMeshEnabled(meshCompany)) {
-            const rows = await createTrackerMeshQuestionClient({ company: meshCompany, request: ctx.trackerMeshRequest }).list();
-            const matches = rows.filter((row) => row.questionId === questionId);
-            if (matches.length > 1)
-                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
-            const row = matches[0];
-            if (row) {
-                printJson({
-                    ok: true,
-                    action: "questions.show",
-                    question: {
-                        question_id: row.questionId,
-                        mesh_question_id: row.questionId,
-                        lane_id: row.laneId,
-                        company: meshCompany,
-                        project_id: row.projectId,
-                        thread_id: row.threadId,
-                        asked_at: row.askedAt,
-                        status: row.status,
-                        audience: row.audience,
-                        host: `${row.host.kind}:${row.host.id}`,
-                    },
-                    audience: row.audience,
-                    body: { question: row.question, context: row.context ?? "", options: row.options, ...(row.recommended ? { recommended: row.recommended } : {}), ...(row.notes ? { notes: row.notes } : {}) },
-                });
-                return;
-            }
-        }
         const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
         if (lookup.errors.length > 0) {
             throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
@@ -8601,42 +8339,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
         const company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
-        if (await ctx.laneTrackerMeshEnabled(company)) {
-            const client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest });
-            const matches = (await client.list(["pending", "answered"])).filter((row) => row.questionId === questionId);
-            if (matches.length > 1)
-                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
-            const row = matches[0];
-            if (row) {
-                if (row.status !== "pending")
-                    throw new LanesError("question_not_pending", `Question ${questionId} is ${row.status}`, { question_id: questionId, status: row.status });
-                const freeform = opts.freeform?.trim() || undefined;
-                if (freeform !== undefined && row.options.length === 0)
-                    throw new LanesError("freeform_not_allowed", "--freeform is only allowed for a question with options", { question_id: questionId });
-                if (!freeform && !opts.choice)
-                    throw new LanesError("missing_choice", "--choice or --freeform is required", {});
-                const choice = freeform ?? resolveAnswerChoice(opts.choice, row.options, false);
-                const answer = await client.answer(questionId, choice, opts.notes);
-                printJson({
-                    ok: true,
-                    action: "questions.answer",
-                    lane_id: answer.laneId,
-                    question: {
-                        question_id: answer.questionId,
-                        mesh_question_id: answer.questionId,
-                        lane_id: answer.laneId,
-                        project_id: answer.projectId,
-                        status: answer.status,
-                        choice: answer.choice,
-                        answered_by: answer.answeredBy,
-                        answered_at: answer.answeredAt,
-                        delivered_at: answer.deliveredAt ?? null,
-                    },
-                    delivery: "awaiting_host_poll",
-                });
-                return;
-            }
-        }
         const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
         if (lookup.errors.length > 0) {
             throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
@@ -8712,22 +8414,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         throw new LanesError("missing_choice", "--choice or --freeform is required", {});
     }
     const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
-    let remoteAnswer;
-    let meshQuestionId = question.mesh_question_id;
-    if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
-        const client = createTrackerMeshQuestionClient({ company: questionCompany, request: ctx.trackerMeshRequest });
-        if (!meshQuestionId) {
-            const indexed = await indexTrackerQuestion(ctx, hqRoot, askingLane, question, body, questionCompany, client);
-            meshQuestionId = indexed.mesh_question_id;
-        }
-        if (!meshQuestionId)
-            throw new LanesError("tracker_mesh_question_link_missing", "Work Mesh question could not be linked before answering", { question_id: question.question_id });
-        remoteAnswer = await client.answer(meshQuestionId, choice, opts.notes);
-        assertMeshQuestionMatchesLocal(remoteAnswer, question, questionCompany);
-        if (remoteAnswer.status !== "answered" || remoteAnswer.choice !== choice) {
-            throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not record the requested question answer", { mesh_question_id: meshQuestionId });
-        }
-    }
     const at = ctx.now().toISOString();
     const answeredBy = sessionIdFromEnv(ctx.env)
         ? `session:${sessionIdFromEnv(ctx.env)}`
@@ -8762,7 +8448,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
                 answered_at: at,
                 answered_level: current.hop,
             },
-            ...(meshQuestionId ? { mesh_question_id: meshQuestionId } : {}),
         };
     });
     const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
@@ -8797,8 +8482,6 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         if (wake.status === "failed") {
             throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${wake.error}`, { lane_id: askingLane.lane_id, question_id: questionId, wake_error: wake.error });
         }
-        if (remoteAnswer)
-            await syncTrackerMeshQuestions(ctx, hqRoot);
         printJson({
             ok: true,
             action: "questions.answer",
@@ -9430,7 +9113,6 @@ async function runReconcile(ctx, opts) {
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
         resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
-        syncTrackerQuestions: (root) => syncTrackerMeshQuestions(ctx, root),
         recoverQueuedMessages: async (lane) => {
             await recoverQueuedMessages(ctx, lane.lane_id);
         },
@@ -9510,8 +9192,6 @@ export function registerLanesCommand(parent, deps = {}) {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
@@ -9519,24 +9199,18 @@ export function registerLanesCommand(parent, deps = {}) {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneChecksCommand(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneReportCommands(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
-        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
-        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         readQuestionBody: (root, question) => {
             const body = requireQuestionBody(root, question);

package/dist/lib/bot/config.d.ts

@@ -29,6 +29,8 @@ export declare function normalizeBotCompanies(values: readonly string[] | undefi
 export declare function effectiveBotKind(config: Pick<BotConfig, "kind" | "workerId">): BotKind;
 /** The companies a bot belongs to (empty for a personal bot: its owner's memberships apply). */
 export declare function effectiveBotCompanies(config: Pick<BotConfig, "kind" | "companies" | "workerId">): string[];
+/** Longest display name (Slack's own limit for a bot's display name). */
+export declare const BOT_DISPLAY_NAME_MAX_CHARS = 35;
 /** Longest `intro` (first-start hello DM) a bot may store. */
 export declare const BOT_INTRO_MAX_CHARS = 500;
 /** Longest `kickoff` (first-start model turn prompt) a bot may store. */
@@ -61,6 +63,11 @@ export declare function validateBotEffort(runtime: BotRuntimeId, value: string):
  * it cannot be a model id.
  */
 export declare function validateBotModel(value: string): string | undefined;
+/**
+ * Trim and check a display name: the human name people see in HQ (the DM list,
+ * the bot's own "You are …"). The handle (`name`) stays the CLI's key.
+ */
+export declare function validateBotDisplayName(text: string): string;
 /** Trim and bound the intro text; throws an expected error when unusable. */
 export declare function validateBotIntro(text: string): string;
 /** Trim and bound the kickoff prompt; throws an expected error when unusable. */
@@ -112,6 +119,11 @@ export interface BotConfig {
      * the synced tree (~/.hq/bots/<name>/memory).
      */
     memoryDir?: string;
+    /**
+     * The human name people see (e.g. "Maya"). Sent to HQ as the bot's name at
+     * create; `name` stays the handle every hq bot command uses. Unset = `name`.
+     */
+    displayName?: string;
     /**
      * Verbatim hello the bot DMs its owner when it first comes online (and on
      * `hq bot intro`). Unset = the default introduction.

package/dist/lib/bot/config.js

@@ -64,6 +64,8 @@ export function effectiveBotCompanies(config) {
     }
     return listed;
 }
+/** Longest display name (Slack's own limit for a bot's display name). */
+export const BOT_DISPLAY_NAME_MAX_CHARS = 35;
 /** Longest `intro` (first-start hello DM) a bot may store. */
 export const BOT_INTRO_MAX_CHARS = 500;
 /** Longest `kickoff` (first-start model turn prompt) a bot may store. */
@@ -120,6 +122,29 @@ export function validateBotModel(value) {
     }
     return v;
 }
+/**
+ * Trim and check a display name: the human name people see in HQ (the DM list,
+ * the bot's own "You are …"). The handle (`name`) stays the CLI's key.
+ */
+export function validateBotDisplayName(text) {
+    const trimmed = (text ?? "").replace(/\s+/g, " ").trim();
+    if (!trimmed) {
+        throw Object.assign(new Error("--display-name needs some text (the name people see, e.g. Maya)."), {
+            expected: true,
+        });
+    }
+    if (trimmed.length > BOT_DISPLAY_NAME_MAX_CHARS) {
+        throw Object.assign(new Error(`--display-name is too long (${trimmed.length} chars); keep it under ${BOT_DISPLAY_NAME_MAX_CHARS}.`), {
+            expected: true,
+        });
+    }
+    if (!/^[\p{L}\p{M}][\p{L}\p{M} .'-]*$/u.test(trimmed)) {
+        throw Object.assign(new Error("--display-name can use letters, spaces, apostrophes, periods and hyphens."), {
+            expected: true,
+        });
+    }
+    return trimmed;
+}
 /** Trim and bound the intro text; throws an expected error when unusable. */
 export function validateBotIntro(text) {
     const trimmed = (text ?? "").replace(/\r\n/g, "\n").trim();

package/dist/lib/bot/local-config.d.ts

@@ -34,13 +34,14 @@ export interface BotLocalConfig {
     autoApprove?: boolean;
     /** Only the memory *kind* travels — never an absolute path from another Mac. */
     memory?: BotMemoryMode;
+    displayName?: string;
     intro?: string;
     kickoff?: string;
 }
 /** Walks a value and throws when any key looks like it could carry a secret. */
 export declare function assertNoSecretKeys(value: unknown, path?: string): void;
 /** The bot.json fields a localConfig is built from — nothing else is read. */
-export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "intro" | "kickoff">;
+export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "displayName" | "intro" | "kickoff">;
 /**
  * The non-secret settings of a bot, for the cloud to keep. Absolute paths
  * (hqRoot, memoryDir, workerDir) are deliberately left out: they belong to the

package/dist/lib/bot/local-config.js

@@ -51,6 +51,7 @@ export function buildBotLocalConfig(config) {
         ...(kind === "company" ? { companies } : {}),
         ...(config.autoApprove === false ? { autoApprove: false } : {}),
         memory: botMemoryMode(config),
+        ...(config.displayName ? { displayName: config.displayName } : {}),
         ...(config.intro ? { intro: config.intro } : {}),
         ...(config.kickoff ? { kickoff: config.kickoff } : {}),
     };
@@ -107,6 +108,9 @@ export function parseBotLocalConfig(value) {
     const memory = str("memory");
     if (isBotMemoryMode(memory))
         out.memory = memory;
+    const displayName = str("displayName");
+    if (displayName)
+        out.displayName = displayName;
     const intro = str("intro");
     if (intro)
         out.intro = intro;

package/dist/lib/bot/progress.d.ts

@@ -27,6 +27,9 @@ export declare const PROGRESS_COALESCE_MS = 2000;
 export declare const PROGRESS_MIN_GAP_MS = 4000;
 export declare const WORKING_NOTICE_MS = 60000;
 export declare const WORKING_NOTICE_TEXT = "Working on it \u2014 I'll reply here when it's done.";
+/** The setup bot's heads-up, sent once when a turn runs past SETUP_WORKING_NOTICE_MS. */
+export declare const SETUP_WORKING_NOTICE_MS = 30000;
+export declare const SETUP_WORKING_NOTICE_TEXT = "This one takes a minute. I'll reply here as soon as it's done.";
 export interface ProgressPosterOptions {
     /** Post one message; resolve true when it was delivered. */
     send: (body: string) => Promise<boolean>;
@@ -49,6 +52,14 @@ export interface ProgressPosterOptions {
      * (when the turn is not silent); `abandon` posts nothing.
      */
     buffer?: boolean;
+    /**
+     * Never post a message the model wrote right before a tool call. Those are
+     * the model's notes to itself ("Now write the worker."), not replies: the
+     * runtime stream shows them as a text block followed by a tool_use. A
+     * message is held until the next event says which it was: a tool call drops
+     * it, anything else (another message, the end of the turn) keeps it.
+     */
+    dropPreToolMessages?: boolean;
 }
 /** Whitespace-insensitive form used to recognise repeated text. */
 export declare function normalizeForCompare(text: string): string;
@@ -65,6 +76,9 @@ export declare class ProgressPoster {
     private readonly workingNoticeMs;
     private readonly workingNoticeText;
     private readonly buffer;
+    private readonly dropPreTool;
+    /** dropPreToolMessages: messages waiting to learn whether a tool call follows. */
+    private candidates;
     private pending;
     /** In-between questions, held until the turn ends (see the header). */
     private heldQuestions;
@@ -77,11 +91,22 @@ export declare class ProgressPoster {
     private finished;
     private noticeSent;
     private delivered;
+    /**
+     * Posts handed to the send chain this turn, counted when queued rather than
+     * when delivered. The "(no reply)" fallback checks this: a post still in
+     * flight when the turn ends has not bumped `delivered` yet, and counting only
+     * deliveries posted the placeholder right after a real message.
+     */
+    private queued;
     constructor(opts: ProgressPosterOptions);
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start(): void;
     /** One finished assistant message from the model. */
     message(text: string): void;
+    /** The model called a tool: whatever it wrote just before was a note to itself. */
+    tool(): void;
+    private promoteCandidates;
+    private accept;
     /** Posts that actually reached the chat (progress, notice and final). */
     get postedCount(): number;
     /** True once any message from the model was said this turn (not counting the notice). */