@indigoai-us/hq-cli 5.345.55 → 5.345.56

package/dist/commands/lanes.js

@@ -38,9 +38,11 @@ import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff, readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
+import { readLaneStatusRowFields } from "../lib/lanes/status-fields.js";
 import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
-import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
+import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_FLAG, } from "../lib/lanes/flag-keys.js";
+import { findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -462,6 +464,7 @@ function resolveDeps(deps = {}) {
         focusGuardEnabled: deps.focusGuardEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
+        withAdmissionLock: deps.withAdmissionLock ?? withLaneAdmissionLock,
         mergeReviewEnabled: deps.mergeReviewEnabled,
         mergeHoldEnabled: deps.mergeHoldEnabled,
     };
@@ -3365,6 +3368,16 @@ async function runCreate(ctx, opts) {
     const provider = explicitProvider ??
         profile?.meta.provider ??
         parseLaneProvider("codex");
+    const continuityEnabled = opts.worker !== undefined && await readLanesRegistryFlagFailOpen(LANE_WORKER_CONTINUITY_FLAG, { company: company ?? meshCompany, env: ctx.env });
+    let workerContinuity = continuityEnabled
+        ? findWorkerContinuityLane(loadAllLanes(hqRoot), {
+            senior,
+            worker: resolvedWorker?.id ?? opts.worker,
+            provider,
+            company: company ?? meshCompany,
+            freshThread: opts.freshThread,
+        })
+        : { resumable: false };
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === provider;
     const cliModel = parseCliModel(opts.model);
     // Validated here because `claude --effort <unknown>` only warns and runs.
@@ -3739,6 +3752,24 @@ async function runCreate(ctx, opts) {
     // The lane id is created in `persist`; its Work Mesh thread is ensured
     // immediately afterward from that stable identity.
     const persist = async () => {
+        const host = placementHostOverride ?? (outpostId !== undefined
+            ? { kind: "outpost", id: outpostId }
+            : { kind: "local", id: ctx.hostname() });
+        // Repeat the busy check while holding provider admission serialization so
+        // two concurrent creates cannot both claim one worker's provider thread.
+        if (continuityEnabled) {
+            workerContinuity = findWorkerContinuityLane(loadAllLanes(hqRoot), {
+                senior,
+                worker: resolvedWorker?.id ?? opts.worker,
+                provider,
+                company: company ?? meshCompany,
+                freshThread: opts.freshThread,
+            });
+            if (workerContinuity.resumable && workerContinuity.previous &&
+                !sameLaneHost(workerContinuity.previous.host, host)) {
+                workerContinuity = { previous: workerContinuity.previous, resumable: false, fallbackReason: "host_mismatch" };
+            }
+        }
         let admission;
         let validation;
         if (!outpostId && provider === "claude" && explicitBalanceAccount === undefined &&
@@ -3842,9 +3873,6 @@ async function runCreate(ctx, opts) {
                 throw admission.error;
             }
         }
-        const host = placementHostOverride ?? (outpostId !== undefined
-            ? { kind: "outpost", id: outpostId }
-            : { kind: "local", id: ctx.hostname() });
         const queuedReason = admission.action === "queue" ? admission.reason : undefined;
         const admissionReservedAt = admission.action === "start" ? ctx.now().toISOString() : undefined;
         const laneInit = {
@@ -3888,6 +3916,18 @@ async function runCreate(ctx, opts) {
             keep_alive: keepAlive,
             ...(keepAlive ? { keep_alive_opted_in_at: createdAt } : {}),
             provider,
+            ...(workerContinuity.resumable && workerContinuity.previous
+                ? {
+                    provider_session_id: workerContinuity.previous.provider_session_id,
+                    last_message_at: workerContinuity.previous.last_message_at ?? workerContinuity.previous.created_at,
+                    pending_resume: {
+                        session_id: workerContinuity.previous.provider_session_id,
+                        at: createdAt,
+                        trigger: "resume",
+                        resumed_from: workerContinuity.previous.state,
+                    },
+                }
+                : {}),
             provider_source: explicitProvider !== undefined
                 ? "cli"
                 : profile?.meta.provider !== undefined
@@ -3957,12 +3997,7 @@ async function runCreate(ctx, opts) {
         return { lane, admission, validation };
     };
     let persisted;
-    if (outpostId) {
-        persisted = await persist();
-    }
-    else {
-        persisted = await withLaneAdmissionLock(hqRoot, provider, persist, ctx.sleep);
-    }
+    persisted = await ctx.withAdmissionLock(hqRoot, provider, persist, ctx.sleep);
     let lane = persisted.lane;
     const { admission, validation } = persisted;
     if (focusAssessment.enabled && opts.focusOverride !== undefined) {
@@ -4052,10 +4087,25 @@ async function runCreate(ctx, opts) {
     ensureDir(path.join(dest, "dropbox"));
     ensureDir(path.join(dest, "questions"));
     const taskBrief = fs.readFileSync(briefAbs, "utf8");
-    const briefText = resolvedWorker
+    const previousResult = workerContinuity.previous
+        ? readLatestEnvelopeRecord(hqRoot, workerContinuity.previous.lane_id)
+        : undefined;
+    const briefText = `${workerContinuity.resumable && workerContinuity.previous
+        ? workerContinuityPrompt(workerContinuity.previous, previousResult?.envelope.summary, previousResult?.ref)
+        : ""}${resolvedWorker
         ? composeWorkerBrief(resolvedWorker, taskBrief)
-        : composeGeneralBrief(taskBrief);
+        : composeGeneralBrief(taskBrief)}`;
     fs.writeFileSync(path.join(dest, "brief.md"), briefText);
+    if (workerContinuity.resumable && lane.pending_resume) {
+        const newBriefPath = path.join(dest, "brief.md");
+        lane = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+            ...current,
+            pending_resume: current.pending_resume ? {
+                ...current.pending_resume,
+                text: `The new brief at ${newBriefPath} is the instruction for this turn. Read and follow it.`,
+            } : undefined,
+        }));
+    }
     if (timeoutSecs !== undefined) {
         writeJsonFile(timeoutPath(hqRoot, lane.lane_id), {
             timeout_secs: timeoutSecs,
@@ -4122,6 +4172,16 @@ async function runCreate(ctx, opts) {
             stories: laneStories(started),
             story_warning: combinedStoryWarning(started, createStoryWarnings),
             thread_id: started.thread_id ?? null,
+            ...(continuityEnabled ? {
+                worker_continuity: workerContinuity.resumable
+                    ? { action: "resume", previous_lane_id: workerContinuity.previous?.lane_id }
+                    : {
+                        action: "fresh",
+                        ...(workerContinuity.previous ? { previous_lane_id: workerContinuity.previous.lane_id } : {}),
+                        ...(opts.freshThread ? { reason: "fresh_thread_requested" } : {}),
+                        ...(workerContinuity.fallbackReason ? { reason: workerContinuity.fallbackReason } : {}),
+                    },
+            } : {}),
             senior: started.senior,
             depth: started.depth,
             timeout_secs: timeoutSecs ?? null,
@@ -5343,6 +5403,24 @@ async function runPickup(ctx, opts) {
         lane: started,
     });
 }
+async function laneStatusFieldsForCommand(ctx, hqRoot, lane, now) {
+    const resolved = resolveLaneCompany(hqRoot, lane).company;
+    let enabled = true;
+    try {
+        enabled = await readLanesRegistryFlagFailOpen(LANE_STATUS_ROW_FIELDS_FLAG, {
+            ...(resolved ? { company: resolved } : {}),
+            env: ctx.env,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: status row fields flag read failed open: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    if (!enabled)
+        return {};
+    const host = reconcileHostFromCtx(ctx);
+    const local = laneRunsHere(lane, host);
+    return { ...readLaneStatusRowFields(hqRoot, lane, now.getTime(), local) };
+}
 async function runList(ctx, opts) {
     if (opts.json && opts.human) {
         throw new LanesError("conflicting_output_format", "Use either --json or --human for hq lanes list", { json: true, human: true });
@@ -5365,7 +5443,7 @@ async function runList(ctx, opts) {
             new Set(opts.hierarchy).size !== opts.hierarchy.length)) {
         throw new LanesError("lane_list_hierarchy_invalid", "--hierarchy must be repeated with distinct, non-empty lane ids without surrounding whitespace", {});
     }
-    if (opts.snapshot && (opts.human || opts.company || opts.project || opts.story || opts.state || opts.senior)) {
+    if (opts.snapshot && (opts.human || opts.company || opts.project || opts.story || opts.state || opts.senior || opts.worker)) {
         throw new LanesError("lane_list_snapshot_invalid", "--snapshot only supports owner lane filters and JSON output", {});
     }
     if (opts.hierarchy !== undefined && !opts.snapshot) {
@@ -5414,21 +5492,29 @@ async function runList(ctx, opts) {
         }
         if (senior && seniorKey(lane.senior) !== seniorKey(senior))
             return false;
+        if (opts.worker && lane.worker !== opts.worker)
+            return false;
         return true;
     };
     const selectLanes = () => laneSource
         .filter((lane) => matchesLaneFilters(lane, true))
         .sort(compareLaneQueueOrder);
     let selectedLanes = selectLanes();
+    const statusFieldsByLane = new Map();
+    const statusNow = ctx.now();
+    await Promise.all(selectedLanes.map(async (lane) => {
+        statusFieldsByLane.set(lane.lane_id, await laneStatusFieldsForCommand(ctx, hqRoot, lane, statusNow));
+    }));
     if (opts.snapshot) {
         printJson({
             ok: true,
             action: "list",
             lanes: selectedLanes.map((lane) => {
+                const fields = statusFieldsByLane.get(lane.lane_id) ?? {};
                 if (!isTerminalLaneState(lane.state))
-                    return lane;
+                    return { ...lane, ...fields };
                 const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
-                return envelope?.summary ? { ...lane, envelope_summary: envelope.summary } : lane;
+                return { ...lane, ...fields, ...(envelope?.summary ? { envelope_summary: envelope.summary } : {}) };
             }),
         });
         return;
@@ -5532,6 +5618,7 @@ async function runList(ctx, opts) {
             !laneRunsHere(lane, host);
         return {
             ...lane,
+            ...statusFieldsByLane.get(lane.lane_id),
             ...hireByLane.get(lane.lane_id),
             ...(remoteRefresh.unverifiedRemote.has(lane.lane_id) ? { unverified_remote: true } : {}),
             stories: laneStories(lane),
@@ -5901,7 +5988,10 @@ async function runShow(ctx, laneId, hasPendingQuestionForLane, resolveLaneTarget
     })
         .slice(0, 20)
         .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
-    const laneForShow = { ...lane };
+    const laneForShow = {
+        ...lane,
+        ...await laneStatusFieldsForCommand(ctx, hqRoot, storedLane, ctx.now()),
+    };
     delete laneForShow.resume_history;
     printJson({
         ok: true,
@@ -9248,6 +9338,15 @@ export function registerLanesCommand(parent, deps = {}) {
             presenceConnected: ctx.presenceConnected ?? false,
             deps: ctx.livenessDeps,
         }),
+        stopEnabled: (lane) => {
+            const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
+            const company = resolution.company ?? undefined;
+            return readLanesRegistryFlag(LANE_REAP_STOP_FLAG, {
+                company,
+                ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+                env: ctx.env,
+            });
+        },
     }, wrap);
     registerLaneDropboxRepairCommand(lanes, {
         hqRoot: ctx.hqRoot,
@@ -9313,6 +9412,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--additional-story <id>", "Additional story carried by this lane; repeatable and discouraged when active", collectRepeatable)
         .requiredOption("--brief-file <path>", "Path to the lane brief")
         .option("--worker <name>", "HQ worker or reusable profile id")
+        .option("--fresh-thread", "Skip worker continuity and start a cold provider session")
         .option("--provider <name>", "claude | codex | grok")
         .option("--account <id>", "Provider account id")
         .option("--model <id>", "Model id for the provider CLI")
@@ -9412,6 +9512,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Filter by story")
         .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
         .option("--senior <ref>", "Filter by senior ref")
+        .option("--worker <id>", "Filter by worker id")
         .option("--lane <id>", "Filter by lane id (repeatable)", (value, previous = []) => [...previous, value], [])
         .addOption(new Option("--lane-ulid <ulid>", "Filter by lane ULID for internal owner lookup").hideHelp()
         .argParser((value, previous = []) => [...previous, value]))

package/dist/commands/members.d.ts

@@ -48,6 +48,8 @@ export interface InviteOptions {
     companyUid: string;
     callerUid: string;
     token: string;
+    /** Reports only whether the request returned a 2xx response. */
+    onRequestResult?: (ok: boolean) => void;
 }
 /**
  * Outcome of `hq members invite`. Two shapes depending on server schema:
@@ -96,6 +98,8 @@ export interface ResendInviteOptions {
     companyUid: string;
     callerUid: string;
     token: string;
+    /** Reports only whether the request returned a 2xx response. */
+    onRequestResult?: (ok: boolean) => void;
 }
 /**
  * Outcome of `hq members invite --resend`. No new membership row was

package/dist/commands/members.js

@@ -3,6 +3,7 @@ import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
 import { gateApiKeyCapabilities } from "../utils/api-key-command-gate.js";
 import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
 import { isPlanGateError } from "../utils/plan-gate-error.js";
+import { queueCliFeatureUsed } from "../utils/cli-telemetry.js";
 const EMAIL_PATTERN = /^[^\s]+@[^\s]+$/;
 const PERSON_UID_PATTERN = /^prs_[A-Za-z0-9_-]+$/;
 const AGENT_UID_PATTERN = /^agt_[A-Za-z0-9_-]+$/i;
@@ -107,6 +108,7 @@ export async function inviteMember(options) {
         body,
     });
     if (!res.ok) {
+        options.onRequestResult?.(false);
         const err = (await res.json().catch(() => ({})));
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
@@ -116,6 +118,7 @@ export async function inviteMember(options) {
         throw new Error(`Invite endpoint returned 2xx with no membership row (response keys: ${keys}). ` +
             "This is a server-side regression — file an issue.");
     }
+    options.onRequestResult?.(true);
     // Two server schemas in the wild:
     //   - Legacy (schemaVersion ≤ 1): response carries a random `inviteToken`
     //     the invitee redeems via `hq://accept/{token}`.
@@ -177,6 +180,7 @@ export async function resendInvite(options) {
         },
     });
     if (!res.ok) {
+        options.onRequestResult?.(false);
         const err = (await res.json().catch(() => ({})));
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
@@ -184,6 +188,7 @@ export async function resendInvite(options) {
     if (data.resent !== true) {
         throw new Error("Resend endpoint returned 2xx without `resent: true` — the connected hq-pro likely doesn't support `resend: true` yet. Upgrade hq-pro or re-invite without --resend.");
     }
+    options.onRequestResult?.(true);
     return {
         resent: true,
         emailSent: data.emailSent === true,
@@ -436,6 +441,7 @@ export function registerMembersCommand(program) {
         let token;
         let companyUid;
         let companySlug;
+        let outcome = "failure";
         try {
             token = (await resolveVaultCredential()).token;
             companySlug = members.opts().company;
@@ -448,6 +454,9 @@ export function registerMembersCommand(program) {
                     companyUid,
                     callerUid,
                     token,
+                    onRequestResult: (ok) => {
+                        outcome = ok ? "success" : "failure";
+                    },
                 });
                 console.log(chalk.green(`Re-fired invite email for ${target.toLowerCase()} (existing pending row left untouched)`));
                 console.log();
@@ -472,6 +481,9 @@ export function registerMembersCommand(program) {
                 companyUid,
                 callerUid,
                 token,
+                onRequestResult: (ok) => {
+                    outcome = ok ? "success" : "failure";
+                },
             });
             const agentTarget = detectTarget(target)?.isAgent === true;
             console.log(chalk.green(`Invited ${target} as ${result.membership.role} (status: ${result.membership.status})`));
@@ -612,10 +624,19 @@ export function registerMembersCommand(program) {
             }
             if (err instanceof InviteHttpError) {
                 console.error(chalk.red(formatInviteHttpError(err.status, err.message, err.code)));
-                process.exit(1);
+                process.exitCode = 1;
+                return;
             }
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
-            process.exit(1);
+            process.exitCode = 1;
+            return;
+        }
+        finally {
+            queueCliFeatureUsed({
+                kind: "members_invite",
+                outcome,
+                ...(companyUid ? { companyUid } : {}),
+            });
         }
     });
     members

package/dist/lanes-drain-hook.js

@@ -17,7 +17,7 @@ function parseHookInput(text) {
         throw new Error("invalid_hook_input_shape: expected a JSON object");
     }
     const value = parsed;
-    for (const key of ["transcript_path", "session_id", "hook_event_name"]) {
+    for (const key of ["transcript_path", "session_id", "hook_event_name", "hookEventName"]) {
         if (value[key] !== undefined && value[key] !== null && typeof value[key] !== "string") {
             throw new Error(`invalid_hook_input_field: ${key} must be a string`);
         }
@@ -25,7 +25,11 @@ function parseHookInput(text) {
     return {
         ...(typeof value.transcript_path === "string" ? { transcript_path: value.transcript_path } : {}),
         ...(typeof value.session_id === "string" ? { session_id: value.session_id } : {}),
-        ...(typeof value.hook_event_name === "string" ? { hook_event_name: value.hook_event_name } : {}),
+        ...(typeof value.hook_event_name === "string"
+            ? { hook_event_name: value.hook_event_name }
+            : typeof value.hookEventName === "string"
+                ? { hookEventName: value.hookEventName }
+                : {}),
     };
 }
 function laneIdIsSafe(laneId) {

package/dist/lib/doctor/checks/sync-health.d.ts

@@ -59,6 +59,8 @@ export interface SyncManifestUploadStatus {
     snapshotId: string | null;
     sequence: number;
     baseUsable: boolean;
+    /** Local company slug for company-scoped remediation; absent for personal. */
+    companySlug?: string;
 }
 /** Injectable dependencies — defaults are the real collectors. */
 export interface SyncHealthDeps {

package/dist/lib/doctor/checks/sync-health.js

@@ -32,6 +32,7 @@ import * as path from "node:path";
 // ../../hq-cloud-manifest.js.
 import * as hqCloud from "@indigoai-us/hq-cloud";
 import { loadManifestExports, MANIFEST_UNAVAILABLE_REASON, } from "../../hq-cloud-manifest.js";
+import { readCompaniesManifestMap } from "../../work-context/repo-remote.js";
 import { CLI_VERSION } from "../../../cli-version.js";
 import { readSyncVersion } from "../../../utils/feedback-versions.js";
 import { readHqVersion } from "../../../utils/pack-contributions.js";
@@ -52,9 +53,9 @@ function withDefaults(deps, hqRoot) {
     return {
         ...deps,
         runtime: deps.runtime ?? (() => []),
-        manifestStatuses: deps.manifestStatuses ?? defaultManifestStatuses,
+        manifestStatuses: deps.manifestStatuses ?? ((journals) => defaultManifestStatuses(hqRoot, journals)),
         manifestAvailable: deps.manifestAvailable ?? (() => loadManifestExports() !== null),
-        unresolvedScopes: deps.unresolvedScopes ?? defaultUnresolvedScopes,
+        unresolvedScopes: deps.unresolvedScopes ?? ((journals) => defaultUnresolvedScopes(hqRoot, journals)),
         localCompanyExists: deps.localCompanyExists ??
             ((slug) => defaultLocalCompanyExists(hqRoot, slug)),
     };
@@ -78,15 +79,35 @@ function defaultLocalCompanyExists(hqRoot, slug) {
         return false;
     }
 }
-/**
- * Company journal shards are unresolvable by the default collector: the
- * snapshot store keys company scopes by `companyUid`, which `listJournals()`
- * does not carry. Naming them here keeps them visible.
- */
-function defaultUnresolvedScopes(journals) {
-    return journals
-        .filter((entry) => !NON_COMPANY_JOURNAL_SLUGS.has(entry.slug))
-        .map((entry) => entry.slug);
+/** Resolve locally-known company journal slugs to the UID used by snapshots. */
+function resolvedCompanyScopes(hqRoot, journals) {
+    const companies = readCompaniesManifestMap(hqRoot);
+    const seen = new Set();
+    const scopes = [];
+    for (const { slug } of journals) {
+        if (NON_COMPANY_JOURNAL_SLUGS.has(slug) ||
+            !isSafeCompanySlug(slug) ||
+            !defaultLocalCompanyExists(hqRoot, slug) ||
+            seen.has(slug)) {
+            continue;
+        }
+        seen.add(slug);
+        const uid = companies?.[slug]?.cloud_uid;
+        if (typeof uid === "string" && /^cmp_[A-Za-z0-9]{3,128}$/.test(uid.trim())) {
+            scopes.push({ kind: "company", companyUid: uid.trim(), slug });
+        }
+    }
+    return scopes;
+}
+function defaultUnresolvedScopes(hqRoot, journals) {
+    const resolved = new Set(resolvedCompanyScopes(hqRoot, journals).map((scope) => scope.slug));
+    return [
+        ...new Set(journals
+            .filter((entry) => !NON_COMPANY_JOURNAL_SLUGS.has(entry.slug) &&
+            defaultLocalCompanyExists(hqRoot, entry.slug) &&
+            !resolved.has(entry.slug))
+            .map((entry) => entry.slug)),
+    ];
 }
 function defaultVersions(hqRoot) {
     return {
@@ -119,21 +140,15 @@ const DEFAULT_DEPS = {
     // than no check.
     journals: () => hqCloud.listJournals(),
     now: () => new Date(),
-    manifestStatuses: defaultManifestStatuses,
     runtime: defaultSyncRuntimeResults,
 };
 /**
  * Map the machine's journal shards onto the manifest scopes hq-cloud keys its
- * snapshot store by, then read each one's last upload.
- *
- * The journal slug `personal` is the personal tree; every other slug is a
- * company. Note the snapshot store keys company scopes by `companyUid`, which
- * the journal listing does not carry — so a company whose uid we cannot name
- * is simply not reported here rather than reported wrongly. That is the honest
- * outcome: this check exists to tell an operator when a manifest STOPPED being
- * uploaded, and inventing a scope key would make it lie in both directions.
+ * snapshot store by, then read each one's last upload. Company journal rows
+ * carry only slugs, so resolve their UIDs from the local companies manifest;
+ * a missing or malformed UID stays explicitly unresolved below.
  */
-function defaultManifestStatuses(journals) {
+function defaultManifestStatuses(hqRoot, journals) {
     // Both the legacy `personal` shard and the current personal-vault
     // pseudo-slug name the SAME personal tree; a machine mid-migration has both
     // on disk, so collapse them to a single personal scope rather than asking
@@ -141,6 +156,7 @@ function defaultManifestStatuses(journals) {
     const scopes = journals.some((entry) => NON_COMPANY_JOURNAL_SLUGS.has(entry.slug))
         ? [{ kind: "personal" }]
         : [];
+    scopes.push(...resolvedCompanyScopes(hqRoot, journals));
     if (scopes.length === 0)
         return [];
     // Absent on an older hq-cloud; the NA row is emitted by `manifestResults`
@@ -148,7 +164,15 @@ function defaultManifestStatuses(journals) {
     const exports = loadManifestExports();
     if (!exports)
         return [];
-    return exports.readManifestUploadStatus(exports.getStateDir(), scopes);
+    const companySlugsByUid = new Map(scopes
+        .filter((scope) => scope.kind === "company")
+        .map((scope) => [scope.companyUid, scope.slug]));
+    const statuses = exports.readManifestUploadStatus(exports.getStateDir(), scopes);
+    return statuses.map((status) => {
+        const companyUid = /^company:(cmp_[A-Za-z0-9]{3,128})$/.exec(status.scopeKey)?.[1];
+        const companySlug = companyUid ? companySlugsByUid.get(companyUid) : undefined;
+        return companySlug ? { ...status, companySlug } : status;
+    });
 }
 /** The legacy journal slug that named the personal (non-company) tree. */
 const PERSONAL_SCOPE_SLUG = "personal";
@@ -526,7 +550,7 @@ function manifestResults(deps, journals) {
                 checkId,
                 reasonCode: "stale-threshold",
                 message: `Scope '${entry.scopeKey}' last uploaded a sync manifest ${days} day${days === 1 ? "" : "s"} ago (${entry.lastUploadAt}) — the daily audit pass is not running.`,
-                remediation: "Run `hq sync manifest` and check HQ_SYNC_MANIFEST_DISABLED and the sync runner.",
+                remediation: `Run \`hq sync manifest${entry.companySlug ? ` --scope ${entry.companySlug}` : ""}\` and check HQ_SYNC_MANIFEST_DISABLED and the sync runner.`,
             };
         }
         return {

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

@@ -53,12 +53,14 @@ export interface DrainDeps {
 }
 export interface LaneDrainHookInput {
     transcript_path?: string | null;
-    session_id?: string;
     hook_event_name?: string;
+    hookEventName?: string;
+    session_id?: string;
 }
 export interface RunDrainHookDeps {
     readLane?: typeof tryReadLane;
     probeCompactionsSince?: typeof import("./compaction.js").probeProviderCompactionsSince;
+    readLifecycleDeliveryFlag?: () => Promise<boolean>;
 }
 export declare function mintClaimId(): string;
 export declare function assertSafeLaneId(laneId: string): void;
@@ -102,7 +104,7 @@ export declare function formatOperatorInstruction(messages: DropboxMessage[]): s
 export declare function formatMonitorEvent(message: DropboxMessage): string;
 /** Keep event order while framing monitor output separately from operator messages. */
 export declare function formatDropboxMessages(messages: DropboxMessage[]): string;
-export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "UserPromptSubmit", leadingNote?: string): string;
+export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "PostToolUse" | "UserPromptSubmit", leadingNote?: string): string;
 export interface DrainHookResult {
     exitCode: number;
     stdout: string;

package/dist/lib/lanes/dropbox.js

@@ -14,6 +14,8 @@ import { LanesError } from "./errors.js";
 import { MESSAGE_COMPACTION_REPLAY_NOTE, MESSAGE_REPLAY_STATE_NAME, readMessageReplayState, updateMessageReplayTranscript, writeMessageReplayState, } from "./message-replay.js";
 import { LANES_RUNS_REL, readProcStarttime } from "./spawn.js";
 import { tryReadLane } from "./store.js";
+import { readLanesRegistryFlagFailOpen } from "./registry-flag.js";
+import { LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG } from "./flag-keys.js";
 export const DROPBOX_DIR = "dropbox";
 export const INBOX_NAME = "inbox.jsonl";
 export const DRAINING_DIR = "draining";
@@ -426,6 +428,9 @@ export function hookAdditionalContextJson(messages, hookEventName = "PreToolUse"
         },
     })}\n`;
 }
+function hookStopBlockJson(reason) {
+    return `${JSON.stringify({ decision: "block", reason })}\n`;
+}
 function replayStatePath(hqRoot, laneId) {
     return path.join(dropboxDir(hqRoot, laneId), MESSAGE_REPLAY_STATE_NAME);
 }
@@ -465,14 +470,47 @@ export async function runDrainHook(env, input = {}, deps = {}) {
             stderr: "hq-lanes-drain: HQ_ROOT is unset while HQ_LANE_ID is set\n",
         };
     }
-    // Liveness first: a failed drain must still leave proof the worker called
-    // a tool. A failure here is reported, never fatal to delivery.
-    let stderr = "";
-    try {
-        recordToolActivity(hqRoot, laneId);
+    const hookEvent = input.hook_event_name ?? input.hookEventName ?? "PreToolUse";
+    if (hookEvent !== "PreToolUse" && hookEvent !== "PostToolUse" && hookEvent !== "Stop") {
+        return { exitCode: 0, stdout: "", stderr: "" };
     }
-    catch (err) {
-        stderr += `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
+    // Grok invokes lifecycle hooks, but their output cannot reach the model.
+    // Preserve queued messages for its next deliverable PreToolUse event.
+    if (env.HQ_LANE_PROVIDER === "grok" && hookEvent !== "PreToolUse") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    const hasQueuedMessages = dropboxInboxHasMessages(hqRoot, laneId);
+    if (hookEvent === "Stop" && !hasQueuedMessages) {
+        return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    if ((hookEvent === "PostToolUse" || hookEvent === "Stop") && hasQueuedMessages) {
+        const lane = (deps.readLane ?? tryReadLane)(hqRoot, laneId);
+        const company = lane?.mesh_company ?? lane?.company ?? undefined;
+        let enabled = true;
+        try {
+            enabled = deps.readLifecycleDeliveryFlag
+                ? await deps.readLifecycleDeliveryFlag()
+                : await readLanesRegistryFlagFailOpen(LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG, {
+                    ...(company ? { company } : {}),
+                    env,
+                });
+        }
+        catch (err) {
+            process.stderr.write(`hq-lanes-drain: lifecycle delivery flag read failed open: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+        if (!enabled)
+            return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    // PreToolUse remains the tool-activity liveness touch used by watcher.ts.
+    // PostToolUse and Stop add delivery opportunities without extra liveness writes.
+    let stderr = "";
+    if (hookEvent === "PreToolUse") {
+        try {
+            recordToolActivity(hqRoot, laneId);
+        }
+        catch (err) {
+            stderr += `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
+        }
     }
     try {
         const turnId = env.HQ_LANE_TURN_ID ?? "";
@@ -515,15 +553,22 @@ export async function runDrainHook(env, input = {}, deps = {}) {
             }
         }
         if (replayNote && replayed && replayed.length > 0) {
+            const formatted = `${replayNote}\n\n${formatDropboxMessages(replayed)}`;
             return {
                 exitCode: 0,
-                stdout: hookAdditionalContextJson(replayed, "PreToolUse", replayNote),
+                stdout: hookEvent === "Stop"
+                    ? hookStopBlockJson(formatted)
+                    : hookAdditionalContextJson(replayed, hookEvent, replayNote),
                 stderr,
             };
         }
         if (messages.length === 0)
             return { exitCode: 0, stdout: "", stderr };
-        return { exitCode: 0, stdout: hookAdditionalContextJson(messages), stderr };
+        const formatted = formatDropboxMessages(messages);
+        if (hookEvent === "Stop") {
+            return { exitCode: 0, stdout: hookStopBlockJson(formatted), stderr };
+        }
+        return { exitCode: 0, stdout: hookAdditionalContextJson(messages, hookEvent), stderr };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);