@indigoai-us/hq-cli 5.318.0 → 5.319.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.319.0] — 2026-10-02
+- Let `hq access` use ACL-checked company presigned reads when STS vend rejects a truncated write-policy scope.
+- Lead autopilot on an Outpost can wake leads that were created on that Outpost, behind the default-off `lanes.autopilot-outpost-native-leads` flag. Before, those leads were skipped as a host mismatch and got no wakes.
+- Add a default-off fix for repo-run-registry worktree-scoped owner matching.
+- Correct keep-alive audit verdicts for pending-work wakes and lanes that were not opted in.
+- Detect and safely redeliver messages stranded in bare-ULID lane dropboxes.
+
 ## [5.318.0] — 2026-10-02
 - `hq lanes autopilot run` now marks missing lead registry entries as stale and includes a command to remove each stale row.
 - Keep retired policies retired regardless of YAML field order in the session helper.

package/assets/scaffold/core/scripts/repo-run-registry.sh

@@ -330,12 +330,32 @@ _cmd_owner_of() {
   [[ -z "$repo" ]] && { echo ""; return; }
   _ensure_reg
   _prune_stale_locked
-  jq --arg repo "$repo" --arg target "$(_abs_path "$path")" \
-    '[.runs[] | select(
-       (.scope == "repo" and .repo_path == $repo)
-       or (.scope | startswith("worktree:")) and
-          ($target | startswith(.scope | sub("^worktree:"; "")))
-     )]' "$REG_FILE"
+  # hq core sets this bridge from the cached hq-flags value; absent means off.
+  if [[ "${HQ_FLAG_CORE_RRR_WORKTREE_SCOPE_FIX:-false}" == "true" ]]; then
+    jq --arg repo "$repo" --arg target "$(_abs_path "$path")" \
+      'def worktree_root($scope):
+         ($scope | sub("^worktree:"; "")) as $raw
+         | ($raw | sub("/+$"; "")) as $trimmed
+         | if $trimmed == "" and ($raw | startswith("/")) then "/" else $trimmed end;
+       def worktree_covers($target; $scope):
+         worktree_root($scope) as $root
+         | if $root == "/" then ($target | startswith("/"))
+           elif $root == "" then false
+           else ($target == $root or ($target | startswith($root + "/")))
+           end;
+       [.runs[] as $entry | select(
+         ($entry.scope == "repo" and $entry.repo_path == $repo)
+         or (($entry.scope | startswith("worktree:")) and
+             worktree_covers($target; $entry.scope))
+       ) | $entry]' "$REG_FILE"
+  else
+    jq --arg repo "$repo" --arg target "$(_abs_path "$path")" \
+      '[.runs[] | select(
+         (.scope == "repo" and .repo_path == $repo)
+         or (.scope | startswith("worktree:")) and
+            ($target | startswith(.scope | sub("^worktree:"; "")))
+       )]' "$REG_FILE"
+  fi
 }
 
 # Check if a target path is owned by a foreign run.
@@ -363,17 +383,41 @@ _cmd_check() {
 
   # Collect foreign entries covering this target
   local matches
-  matches=$(jq -c --arg repo "$repo" \
-                  --arg target "$abs_target" \
-                  --arg mypid "${my_pid:-0}" \
-                  --arg mysid "${my_session:-__none__}" \
-    '[.runs[] | select(
-       ((.scope == "repo" and .repo_path == $repo)
-         or ((.scope | startswith("worktree:")) and
-             ($target | startswith(.scope | sub("^worktree:"; "")))))
-       and ((.pid | tostring) != $mypid)
-       and (.session_id != $mysid)
-     )]' "$REG_FILE" 2>/dev/null || echo '[]')
+  if [[ "${HQ_FLAG_CORE_RRR_WORKTREE_SCOPE_FIX:-false}" == "true" ]]; then
+    matches=$(jq -c --arg repo "$repo" \
+                    --arg target "$abs_target" \
+                    --arg mypid "${my_pid:-0}" \
+                    --arg mysid "${my_session:-__none__}" \
+      'def worktree_root($scope):
+         ($scope | sub("^worktree:"; "")) as $raw
+         | ($raw | sub("/+$"; "")) as $trimmed
+         | if $trimmed == "" and ($raw | startswith("/")) then "/" else $trimmed end;
+       def worktree_covers($target; $scope):
+         worktree_root($scope) as $root
+         | if $root == "/" then ($target | startswith("/"))
+           elif $root == "" then false
+           else ($target == $root or ($target | startswith($root + "/")))
+           end;
+       [.runs[] as $entry | select(
+         (($entry.scope == "repo" and $entry.repo_path == $repo)
+           or (($entry.scope | startswith("worktree:")) and
+               worktree_covers($target; $entry.scope)))
+         and (($entry.pid | tostring) != $mypid)
+         and ($entry.session_id != $mysid)
+       ) | $entry]' "$REG_FILE" 2>/dev/null || echo '[]')
+  else
+    matches=$(jq -c --arg repo "$repo" \
+                    --arg target "$abs_target" \
+                    --arg mypid "${my_pid:-0}" \
+                    --arg mysid "${my_session:-__none__}" \
+      '[.runs[] | select(
+         ((.scope == "repo" and .repo_path == $repo)
+           or ((.scope | startswith("worktree:")) and
+               ($target | startswith(.scope | sub("^worktree:"; "")))))
+         and ((.pid | tostring) != $mypid)
+         and (.session_id != $mysid)
+       )]' "$REG_FILE" 2>/dev/null || echo '[]')
+  fi
 
   local n
   n=$(echo "$matches" | jq 'length')

package/dist/command-catalog.generated.d.ts

@@ -7841,6 +7841,28 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Print a human-readable table";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "repair-dropbox";
+        readonly description: "Inspect or redeliver messages stranded in a bare-ULID lane dropbox";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] <ulid>";
+        readonly arguments: readonly [{
+            readonly name: "ulid";
+            readonly required: true;
+            readonly variadic: false;
+        }];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Select the company by slug";
+        }, {
+            readonly flags: "--apply";
+            readonly description: "Append marked messages to the canonical lane inbox and archive the orphan folder";
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "report";
         readonly description: "Generate the owner report for tracker teams";

package/dist/command-catalog.generated.js

@@ -10087,6 +10087,35 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "repair-dropbox",
+                "description": "Inspect or redeliver messages stranded in a bare-ULID lane dropbox",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] <ulid>",
+                "arguments": [
+                    {
+                        "name": "ulid",
+                        "required": true,
+                        "variadic": false
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Select the company by slug"
+                    },
+                    {
+                        "flags": "--apply",
+                        "description": "Append marked messages to the canonical lane inbox and archive the orphan folder"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "report",
                 "description": "Generate the owner report for tracker teams",

package/dist/commands/access.js

@@ -221,10 +221,20 @@ export async function runAccess(input) {
     }
     catch (err) {
         const status = httpStatusOf(err);
+        const vendError = typeof err === "object" && err !== null
+            ? err
+            : undefined;
         if (status === 403) {
             vendDenied = true;
             steps.push("vend: 403 (no-access)");
         }
+        else if ((status === 422 || vendError?.statusCode === 422) &&
+            vendError?.code === "POLICY_WRITE_SCOPE_TRUNCATED") {
+            // This failure means the company-wide STS write policy could not fit.
+            // Company reads use the separate ACL-filtered presign API, which remains
+            // the authority for listing and materializing this particular object.
+            steps.push("vend: write policy truncated; using presigned read");
+        }
         else if (status === 404) {
             steps.push("vend: 404");
         }

package/dist/commands/core-hook-state-helpers-native.d.ts

@@ -6,6 +6,6 @@ import { runDetectStaleReviewBase } from "./core-detect-stale-review-base-native
 export { runShareSuggestionState, runRepoRunRegistry, runDetectStaleReviewBase };
 export declare function registerCoreHookStateHelpers(core: Command): void;
 export declare function runShareSuggestionStateFast(args: readonly string[], stdin: string, _cwd: string, hqRoot: string | undefined): number;
-export declare function runRepoRunRegistryFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): number;
+export declare function runRepoRunRegistryFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined, _commandName: string, _hqRootArg?: string, worktreeScopeFixEnabled?: boolean): number;
 export declare function runDetectStaleReviewBaseFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): number;
 //# sourceMappingURL=core-hook-state-helpers-native.d.ts.map

package/dist/commands/core-hook-state-helpers-native.js

@@ -2,16 +2,28 @@ import { resolveBundledAsset, resolveLiveRoot } from "../utils/hq-roots.js";
 import { runBundledScript } from "../utils/run-bundled-script.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
 import { coreNativeHookHelpersEnabled } from "./core-native-hook-helpers-flag.js";
+import { coreRrrWorktreeScopeFixEnabled } from "./core-rrr-worktree-scope-fix-flag.js";
 import { runShareSuggestionState, SHARE_SUGGESTION_STATE_ASSET } from "./core-share-suggestion-state-native.js";
 import { runRepoRunRegistry, REPO_RUN_REGISTRY_ASSET } from "./core-repo-run-registry-native.js";
 import { runDetectStaleReviewBase, DETECT_STALE_REVIEW_BASE_ASSET } from "./core-detect-stale-review-base-native.js";
 export { runShareSuggestionState, runRepoRunRegistry, runDetectStaleReviewBase };
 const definitions = [
     { name: "share-suggestion-state", asset: SHARE_SUGGESTION_STATE_ASSET, summary: "Manage hook share suggestion state", run: (args, stdin, _cwd, root) => runShareSuggestionState(args, stdin, { root, cwd: root, env: process.env, stdinIsTty: process.stdin.isTTY }) },
-    { name: "repo-run-registry", asset: REPO_RUN_REGISTRY_ASSET, summary: "Coordinate active runs across repositories", run: (args, _stdin, _cwd, root) => runRepoRunRegistry(args, { root, cwd: root, env: process.env, runShellFallback: (fallbackArgs) => {
+    {
+        name: "repo-run-registry",
+        asset: REPO_RUN_REGISTRY_ASSET,
+        summary: "Coordinate active runs across repositories",
+        run: (args, _stdin, _cwd, root, worktreeScopeFixEnabled) => runRepoRunRegistry(args, {
+            root,
+            cwd: root,
+            env: process.env,
+            worktreeScopeFixEnabled,
+            runShellFallback: (fallbackArgs) => {
                 const { code } = runBundledScript({ asset: REPO_RUN_REGISTRY_ASSET, args: [...fallbackArgs], cwd: root, hqRoot: root });
                 return { code, stdout: "", stderr: "" };
-            } }) },
+            },
+        }),
+    },
     { name: "detect-stale-review-base", asset: DETECT_STALE_REVIEW_BASE_ASSET, summary: "Find stale remote review bases in an HQ root", run: (args, _stdin, _cwd, root) => runDetectStaleReviewBase(args, { cwd: root, env: { ...process.env, HQ_ROOT: root }, scriptPath: resolveBundledAsset(DETECT_STALE_REVIEW_BASE_ASSET) }) },
 ];
 async function readStdin() {
@@ -37,14 +49,25 @@ export function registerCoreHookStateHelpers(core) {
             const cwd = process.cwd(), hqRootArg = core.opts().hqRoot;
             const root = resolveLiveRoot(hqRootArg ? { hqRoot: hqRootArg } : {});
             const operands = cmd.args.length > 0 ? cmd.args : args;
+            const worktreeScopeFixEnabled = entry.name === "repo-run-registry"
+                ? await coreRrrWorktreeScopeFixEnabled()
+                : undefined;
             if (!await coreNativeHookHelpersEnabled()) {
-                const { code } = runBundledScript({ asset: entry.asset, args: operands, cwd: root, hqRoot: root });
+                const { code } = runBundledScript({
+                    asset: entry.asset,
+                    args: operands,
+                    cwd: root,
+                    hqRoot: root,
+                    ...(entry.name === "repo-run-registry"
+                        ? { env: { HQ_FLAG_CORE_RRR_WORKTREE_SCOPE_FIX: String(worktreeScopeFixEnabled) } }
+                        : {}),
+                });
                 if (code !== 0)
                     process.exitCode = code;
                 return;
             }
             const stdin = entry.name === "share-suggestion-state" ? await readStdin() : "";
-            writeResult(await entry.run(operands, stdin, cwd, root));
+            writeResult(await entry.run(operands, stdin, cwd, root, worktreeScopeFixEnabled));
         });
         describeCoreCommand(command, { execution: "native", asset: entry.asset, root: "live" });
     }
@@ -60,12 +83,18 @@ export function runShareSuggestionStateFast(args, stdin, _cwd, hqRoot) {
     const root = hqRoot ?? resolveLiveRoot();
     return writeFast(runShareSuggestionState(args, stdin, { root, cwd: root, env: process.env, stdinIsTty: process.stdin.isTTY }));
 }
-export function runRepoRunRegistryFast(args, _stdin, _cwd, hqRoot) {
+export function runRepoRunRegistryFast(args, _stdin, _cwd, hqRoot, _commandName, _hqRootArg, worktreeScopeFixEnabled = false) {
     const root = hqRoot ?? resolveLiveRoot();
-    return writeFast(runRepoRunRegistry(args, { root, cwd: root, env: process.env, runShellFallback: (fallbackArgs) => {
+    return writeFast(runRepoRunRegistry(args, {
+        root,
+        cwd: root,
+        env: process.env,
+        worktreeScopeFixEnabled,
+        runShellFallback: (fallbackArgs) => {
             const { code } = runBundledScript({ asset: REPO_RUN_REGISTRY_ASSET, args: [...fallbackArgs], cwd: root, hqRoot: root });
             return { code, stdout: "", stderr: "" };
-        } }));
+        },
+    }));
 }
 export function runDetectStaleReviewBaseFast(args, _stdin, _cwd, hqRoot) {
     const root = hqRoot ?? resolveLiveRoot();

package/dist/commands/core-repo-run-registry-native.d.ts

@@ -13,6 +13,7 @@ export type RegistryDependencies = {
     hostname?: () => string;
     sleep?: (milliseconds: number) => void;
     parseDateEpoch?: (value: string) => number;
+    worktreeScopeFixEnabled?: boolean;
     runShellFallback?: (args: readonly string[]) => HookHelperOutput;
 };
 export declare function runRepoRunRegistry(args: readonly string[], deps: RegistryDependencies): HookHelperOutput;

package/dist/commands/core-repo-run-registry-native.js

@@ -40,6 +40,14 @@ function pathAbs(value, cwd, f) {
         return value;
     }
 }
+function worktreeScopeCovers(target, scope) {
+    const rawRoot = scope.slice("worktree:".length);
+    const trimmedRoot = rawRoot.replace(/\/+$/, "");
+    const root = trimmedRoot === "" && rawRoot.startsWith("/") ? "/" : trimmedRoot;
+    if (root === "/")
+        return target.startsWith("/");
+    return root !== "" && (target === root || target.startsWith(`${root}/`));
+}
 function parseStaleMinutes(root, f) {
     const personal = path.join(root, "personal/settings/orchestrator.yaml");
     const core = path.join(root, "core/settings/orchestrator.yaml");
@@ -215,7 +223,7 @@ export function runRepoRunRegistry(args, deps) {
                 const state = JSON.parse(f.readFileSync(regFile, "utf8"));
                 if (!state || typeof state !== "object" || !Array.isArray(state.runs))
                     return deps.runShellFallback(args);
-                if ((sub === "owner-of" || sub === "check") && state.runs.some((run) => typeof run?.scope === "string" && run.scope.startsWith("worktree:"))) {
+                if (!deps.worktreeScopeFixEnabled && (sub === "owner-of" || sub === "check") && state.runs.some((run) => typeof run?.scope === "string" && run.scope.startsWith("worktree:"))) {
                     return deps.runShellFallback(args);
                 }
             }
@@ -338,7 +346,7 @@ export function runRepoRunRegistry(args, deps) {
                 return output();
             const absoluteTarget = pathAbs(target, deps.cwd, f), myPid = valueAfter(rest, "--pid") || "0", mySession = valueAfter(rest, "--session-id") || "__none__";
             const runs = Array.isArray(state.runs) ? state.runs : [];
-            const covers = (run) => (run?.scope === "repo" && run?.repo_path === repo) || (typeof run?.scope === "string" && run.scope.startsWith("worktree:") && absoluteTarget.startsWith(run.scope.slice("worktree:".length)));
+            const covers = (run) => (run?.scope === "repo" && run?.repo_path === repo) || (typeof run?.scope === "string" && run.scope.startsWith("worktree:") && worktreeScopeCovers(absoluteTarget, run.scope));
             if (sub === "owner-of")
                 return jsonOutput(0, runs.filter(covers));
             const owners = runs.filter((run) => covers(run) && String(run?.pid) !== myPid && run?.session_id !== mySession);

package/dist/commands/core-rrr-worktree-scope-fix-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for repo-run-registry worktree-scope matching. */
+export declare const CORE_RRR_WORKTREE_SCOPE_FIX_FLAG = "core-rrr-worktree-scope-fix";
+export declare function coreRrrWorktreeScopeFixEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-rrr-worktree-scope-fix-flag.d.ts.map

package/dist/commands/core-rrr-worktree-scope-fix-flag.js

@@ -0,0 +1,7 @@
+/** Default-off rollout gate for repo-run-registry worktree-scope matching. */
+export const CORE_RRR_WORKTREE_SCOPE_FIX_FLAG = "core-rrr-worktree-scope-fix";
+export async function coreRrrWorktreeScopeFixEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_RRR_WORKTREE_SCOPE_FIX_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-rrr-worktree-scope-fix-flag.js.map

package/dist/commands/lanes-checks.js

@@ -12,6 +12,7 @@ import { DEFAULT_ORPHAN_USER_IDLE_HOURS, findOrphanLanes, parseOrphanMinAge, par
 import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
+import { findOrphanedBareIdDropboxes } from "../lib/lanes/orphaned-dropbox.js";
 export function mappingIncludesStory(mapping, storyId) {
     return (mapping.storyPrefix === undefined || storyId.startsWith(mapping.storyPrefix))
         && (mapping.excludePrefix === undefined || !storyId.startsWith(mapping.excludePrefix));
@@ -810,6 +811,17 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
             host: finding.host,
         })),
     });
+    const orphanedBareIdDropboxes = findOrphanedBareIdDropboxes(root, company);
+    checks.push({
+        id: "orphaned_bare_id_dropbox",
+        result: orphanedBareIdDropboxes.length === 0 ? "ok" : "failing",
+        items: orphanedBareIdDropboxes.map((finding) => ({
+            id: finding.ulid,
+            reason: "orphaned_bare_id_dropbox",
+            message_count: finding.message_count,
+            newest_message_at: finding.newest_message_at,
+        })),
+    });
     return {
         ok: true,
         company: company.slug,

package/dist/commands/lanes-dropbox-repair.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import type { LaneCompanyRef, LaneRecord } from "../lib/lanes/types.js";
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export interface LaneDropboxRepairDeps {
+    hqRoot: () => string;
+    now: () => Date;
+    resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
+    repairEnabled: (lane: LaneRecord) => Promise<boolean>;
+    wrap: WrapHandler;
+}
+/** Register the explicit recovery command. Dry-run is read-only; mutation is separately gated. */
+export declare function registerLaneDropboxRepairCommand(parent: Command, deps: LaneDropboxRepairDeps): void;
+export {};
+//# sourceMappingURL=lanes-dropbox-repair.d.ts.map

package/dist/commands/lanes-dropbox-repair.js

@@ -0,0 +1,33 @@
+import { LanesError } from "../lib/lanes/errors.js";
+import { findOrphanedBareIdDropboxes, repairOrphanedBareIdDropbox } from "../lib/lanes/orphaned-dropbox.js";
+import { readLane } from "../lib/lanes/store.js";
+/** Register the explicit recovery command. Dry-run is read-only; mutation is separately gated. */
+export function registerLaneDropboxRepairCommand(parent, deps) {
+    parent.command("repair-dropbox")
+        .description("Inspect or redeliver messages stranded in a bare-ULID lane dropbox")
+        .argument("<ulid>", "26-character lane ULID")
+        .option("--company <slug>", "Select the company by slug")
+        .option("--apply", "Append marked messages to the canonical lane inbox and archive the orphan folder")
+        .action(deps.wrap(async (ulid, options) => {
+        const root = deps.hqRoot();
+        const globalFinding = findOrphanedBareIdDropboxes(root).find((item) => item.ulid === ulid.trim().toUpperCase());
+        if (globalFinding?.canonical_lane_ids.length !== undefined && globalFinding.canonical_lane_ids.length > 1) {
+            throw new LanesError("orphaned_dropbox_lane_ambiguous", `ULID ${globalFinding.ulid} matches more than one lane record`, { ulid: globalFinding.ulid });
+        }
+        const company = await deps.resolveCompany(options.company);
+        const finding = findOrphanedBareIdDropboxes(root, company).find((item) => item.ulid === ulid.trim().toUpperCase());
+        if (!finding)
+            throw new LanesError("orphaned_dropbox_not_found", `No orphaned bare-ID dropbox was found for ${ulid}`, { ulid });
+        if (finding.canonical_lane_ids.length !== 1)
+            throw new LanesError("orphaned_dropbox_lane_ambiguous", `ULID ${finding.ulid} matches more than one lane record`, { ulid: finding.ulid });
+        const lane = readLane(root, finding.canonical_lane_ids[0]);
+        const enabled = options.apply ? await deps.repairEnabled(lane) : false;
+        const result = repairOrphanedBareIdDropbox(root, ulid, {
+            apply: options.apply === true,
+            enabled,
+            now: deps.now(),
+        });
+        console.log(JSON.stringify({ ok: true, action: "repair-dropbox", ...result }, null, 2));
+    }));
+}
+//# sourceMappingURL=lanes-dropbox-repair.js.map

package/dist/commands/lanes.js

@@ -26,6 +26,7 @@ import { registerLaneKpisCommand } from "./lanes-kpis.js";
 import { registerLaneKeepAliveAuditCommand } from "./lanes-keep-alive-audit.js";
 import { registerLaneAutopilotReportCommand } from "./lanes-autopilot.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
+import { registerLaneDropboxRepairCommand } from "./lanes-dropbox-repair.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneRepoMergeHoldCommand } from "./lanes-hold.js";
 import { registerLaneReviewCommand } from "./lanes-review.js";
@@ -34,7 +35,7 @@ import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG } from "../lib/lanes/flag-keys.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG } from "../lib/lanes/flag-keys.js";
 import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -8322,6 +8323,21 @@ export function registerLanesCommand(parent, deps = {}) {
             deps: ctx.livenessDeps,
         }),
     }, wrap);
+    registerLaneDropboxRepairCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        now: ctx.now,
+        resolveCompany: ctx.resolveCompany,
+        repairEnabled: async (lane) => {
+            const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
+            const company = resolution.company ?? undefined;
+            return readLanesRegistryFlagFailOff(LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, {
+                company,
+                ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+                env: ctx.env,
+            }, readLanesRegistryFlag);
+        },
+        wrap,
+    });
     registerLaneReportCommands(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,

package/dist/fast-core.js

@@ -9,6 +9,7 @@
 import { resolveLiveRoot } from "./utils/hq-roots.js";
 import { runBundledScript } from "./utils/run-bundled-script.js";
 import { parseFastCore } from "./fast-scaffold.js";
+import { CORE_RRR_WORKTREE_SCOPE_FIX_FLAG } from "./commands/core-rrr-worktree-scope-fix-flag.js";
 export async function readStdinIfPiped(stream) {
     if (stream.isTTY)
         return "";
@@ -35,6 +36,9 @@ export async function runFastCore(argv) {
         familyEnabled = envOverride ?? await (await import("./native-fast-route.js")).fastFlagEnabled(entry.familyFlagKey, process.env, { numericEnvironmentOverride: false });
     }
     const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
+    const worktreeScopeFixEnabled = entry.name === "repo-run-registry"
+        ? await (await import("./native-fast-route.js")).fastFlagEnabled(CORE_RRR_WORKTREE_SCOPE_FIX_FLAG, process.env, { numericEnvironmentOverride: false })
+        : undefined;
     const shouldInjectRoot = useShell
         ? entry.shellHqRoot === "live" || (entry.shellHqRoot === "reconcile-default" &&
             !parsed.args.includes("--hq-root") && !parsed.args.includes("--help") && !parsed.args.includes("-h"))
@@ -69,7 +73,7 @@ export async function runFastCore(argv) {
         }
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
         const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
-        const code = await handler(parsed.args, stdin, process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
+        const code = await handler(parsed.args, stdin, process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg, worktreeScopeFixEnabled);
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;
@@ -90,6 +94,7 @@ export async function runFastCore(argv) {
         ...(entry.name === "migrate-policy-triggers"
             ? { CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR || process.cwd() }
             : {}),
+        ...(entry.name === "repo-run-registry" ? { HQ_FLAG_CORE_RRR_WORKTREE_SCOPE_FIX: String(worktreeScopeFixEnabled) } : {}),
     };
     const { code } = runBundledScript({
         asset,

package/dist/lib/lanes/autopilot.js

@@ -6,7 +6,7 @@ import { isControllerAliasOutpostId } from "./admission-host.js";
 import { LEAD_REGISTRY_REL, validateOutpostLeadRegistry } from "./autopilot-registry.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { LanesError } from "./errors.js";
-import { LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_FLAG, LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG, LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG as PER_LEAD_ERRORS_FLAG, } from "./flag-keys.js";
+import { LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_FLAG, LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG, LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG, LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG as PER_LEAD_ERRORS_FLAG, } from "./flag-keys.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 import { readAllLanes } from "./store.js";
@@ -786,9 +786,16 @@ async function runLeadAutopilotPassUnlocked(input) {
             result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_company_unresolved" });
             continue;
         }
+        // A lead created on an Outpost records a local host, while its registry row names the Outpost.
+        const outpostNativeLead = !registeredLocalHost &&
+            input.outpostId === registered.host &&
+            lead.host.kind === "local" &&
+            lead.host.id === input.hostname &&
+            await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG, { company }).catch(() => false);
         const hostMatchesRegistry = registeredLocalHost
             ? lead.host.kind === "local"
-            : lead.host.kind === "outpost" && lead.host.id === registered.host && input.outpostId === registered.host;
+            : outpostNativeLead ||
+                (lead.host.kind === "outpost" && lead.host.id === registered.host && input.outpostId === registered.host);
         if (!hostMatchesRegistry ||
             !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: effectiveOutpostId })) {
             result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_host_mismatch" });

package/dist/lib/lanes/flag-keys.d.ts

@@ -22,4 +22,10 @@ export declare const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_DEFAULT_ENABLED = false;
 /** Enables staleness notices for a registered lead's dashboard headline. */
 export declare const LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG = "lanes.autopilot-headline-staleness";
 export declare const LEAD_AUTOPILOT_HEADLINE_STALENESS_DEFAULT_ENABLED = false;
+/** Lets an Outpost's autopilot wake leads created on that Outpost, which record a local host. */
+export declare const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot-outpost-native-leads";
+export declare const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_DEFAULT_ENABLED = false;
+/** Allows applying an operator-reviewed repair of messages stranded in bare-ULID dropboxes. */
+export declare const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
+export declare const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.d.ts.map

package/dist/lib/lanes/flag-keys.js

@@ -22,4 +22,10 @@ export const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_DEFAULT_ENABLED = false;
 /** Enables staleness notices for a registered lead's dashboard headline. */
 export const LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG = "lanes.autopilot-headline-staleness";
 export const LEAD_AUTOPILOT_HEADLINE_STALENESS_DEFAULT_ENABLED = false;
+/** Lets an Outpost's autopilot wake leads created on that Outpost, which record a local host. */
+export const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot-outpost-native-leads";
+export const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_DEFAULT_ENABLED = false;
+/** Allows applying an operator-reviewed repair of messages stranded in bare-ULID dropboxes. */
+export const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
+export const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.js.map

package/dist/lib/lanes/keep-alive-audit.d.ts

@@ -1,4 +1,4 @@
-type KeepAliveAuditVerdict = "on_time" | "late" | "early_wake" | "message_wake" | "self_wake" | "early_by_keep_alive" | "not_restarted" | "waiting";
+type KeepAliveAuditVerdict = "on_time" | "late" | "early_wake" | "message_wake" | "self_wake" | "early_by_keep_alive" | "not_restarted" | "keep_alive_off" | "waiting";
 interface KeepAliveAuditRestart {
     at: string;
     trigger: string;

package/dist/lib/lanes/keep-alive-audit.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS } from "./keep-alive.js";
 import { LanesError } from "./errors.js";
 import { laneRunDir } from "./spawn.js";
-import { readAllLanes } from "./store.js";
+import { listQuestionIds, readAllLanes, tryReadQuestion } from "./store.js";
 function readDoneClassifications(hqRoot, laneId) {
     const root = fs.realpathSync(hqRoot);
     const watcherLog = path.join(laneRunDir(root, laneId), "logs", "watcher.out");
@@ -56,6 +56,7 @@ const VERDICTS = [
     "message_wake",
     "self_wake",
     "early_by_keep_alive",
+    "keep_alive_off",
     "not_restarted",
     "waiting",
 ];
@@ -219,9 +220,66 @@ function hasDeliveredDropboxEvidence(hqRoot, laneId, stoppedAt, restartAt) {
         const realFile = fs.realpathSync(file);
         if (!withinRoot(root, realFile))
             return false;
-        return stat.mtimeMs >= stoppedAt && stat.mtimeMs <= restartAt + 2 * 60_000;
+        if (stat.mtimeMs >= stoppedAt && stat.mtimeMs <= restartAt + 2 * 60_000)
+            return true;
+        if (!name.endsWith(".inbox.jsonl") && !name.endsWith(".resume.jsonl"))
+            return false;
+        const text = fs.readFileSync(realFile, "utf8");
+        for (const line of text.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch (err) {
+                throw new LanesError("keep_alive_audit_event_invalid", `Cannot parse delivered lane message ${realFile}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: laneId, path: realFile });
+            }
+            if (isRecord(value)) {
+                const at = parseTime(value.at);
+                if (at !== undefined && at >= stoppedAt && at <= restartAt + 2 * 60_000)
+                    return true;
+            }
+        }
+        return false;
     });
 }
+function hasMessageResumeEvidence(lane, stoppedAt, restartAt) {
+    return (lane.resume_history ?? []).some((entry) => (entry.trigger === "message" || entry.trigger === "answered_questions") &&
+        (parseTime(entry.at) ?? Number.NaN) >= stoppedAt &&
+        (parseTime(entry.at) ?? Number.NaN) <= restartAt + 2 * 60_000);
+}
+function hasAnsweredQuestionEvidence(hqRoot, laneId, stoppedAt, restartAt) {
+    for (const questionId of listQuestionIds(hqRoot)) {
+        let question;
+        try {
+            question = tryReadQuestion(hqRoot, questionId);
+        }
+        catch {
+            // One unreadable question file must not fail the whole audit.
+            continue;
+        }
+        if (!question || question.lane_id !== laneId || question.origin?.id !== laneId)
+            continue;
+        const timestamps = [
+            question.delivered_at,
+            question.answer?.answered_at,
+            ...(question.answer_history ?? []).map((answer) => answer.answered_at),
+        ];
+        if (timestamps.some((timestamp) => {
+            const at = parseTime(timestamp);
+            return at !== undefined && at >= stoppedAt && at <= restartAt + 2 * 60_000;
+        }))
+            return true;
+    }
+    return false;
+}
+function laneWasKeepAliveOffAtStop(lane, stoppedAt) {
+    if (lane.keep_alive === true)
+        return false;
+    const optedInAt = parseTime(lane.keep_alive_opted_in_at);
+    return optedInAt === undefined || optedInAt > stoppedAt;
+}
 function firstRestartAfter(lane, stop, nextEnvelopeMs) {
     const restart = (lane.resume_history ?? [])
         .map((entry) => ({ entry, at: parseTime(entry.at) }))
@@ -241,13 +299,18 @@ function classifyVerdict(input) {
         const restartAt = Date.parse(restart.at);
         if (restart.caller === lane.lane_id)
             return "self_wake";
+        if (restart.trigger === "message" || restart.trigger === "answered_questions")
+            return "message_wake";
         if (restart.trigger === "keep_alive") {
             const event = input.resumeEvents
-                .filter((candidate) => candidate.at > input.stoppedAt && Math.abs(candidate.at - restartAt) <= 2 * 60_000)
+                .filter((candidate) => candidate.at > input.stoppedAt && candidate.at <= restartAt + 2 * 60_000)
                 .sort((left, right) => Math.abs(left.at - restartAt) - Math.abs(right.at - restartAt))[0];
             if (event?.reason === "pending_work")
                 return "message_wake";
-            if (event?.reason === undefined && hasDeliveredDropboxEvidence(input.hqRoot, lane.lane_id, input.stoppedAt, restartAt)) {
+            if (event?.reason === undefined &&
+                (hasDeliveredDropboxEvidence(input.hqRoot, lane.lane_id, input.stoppedAt, restartAt) ||
+                    hasMessageResumeEvidence(lane, input.stoppedAt, restartAt) ||
+                    hasAnsweredQuestionEvidence(input.hqRoot, lane.lane_id, input.stoppedAt, restartAt))) {
                 return "message_wake";
             }
             const nextCheckAt = parseTime(input.nextCheckAt);
@@ -264,6 +327,8 @@ function classifyVerdict(input) {
             return "early_wake";
         return "late";
     }
+    if (laneWasKeepAliveOffAtStop(lane, input.stoppedAt))
+        return "keep_alive_off";
     if (lane.state === "done" && nowMs > dueAt + KEEP_ALIVE_NOT_RESTARTED_GRACE_MS)
         return "not_restarted";
     return "waiting";

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

@@ -0,0 +1,24 @@
+import type { LaneCompanyRef } from "./types.js";
+export interface OrphanedBareIdDropbox {
+    ulid: string;
+    canonical_lane_ids: string[];
+    message_count: number;
+    newest_message_at: string | null;
+    source_dir: string;
+}
+/** Finds bare-ULID run folders that have no bare lane record but do have a canonical lane. */
+export declare function findOrphanedBareIdDropboxes(hqRoot: string, company?: LaneCompanyRef): OrphanedBareIdDropbox[];
+export interface RepairOrphanedDropboxResult {
+    ulid: string;
+    canonical_lane_id: string;
+    message_count: number;
+    newest_message_at: string | null;
+    applied: boolean;
+    archived_dir?: string;
+}
+export declare function repairOrphanedBareIdDropbox(hqRoot: string, ulidInput: string, options: {
+    apply: boolean;
+    enabled: boolean;
+    now: Date;
+}): RepairOrphanedDropboxResult;
+//# sourceMappingURL=orphaned-dropbox.d.ts.map

package/dist/lib/lanes/orphaned-dropbox.js

@@ -0,0 +1,213 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+import { LANES_RUNS_REL } from "./spawn.js";
+import { readAllLanes, tryReadLane } from "./store.js";
+import { resolveLaneCompany } from "./lane-company.js";
+const ULID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+function laneUlid(laneId) {
+    const prefix = laneId.slice(0, 26);
+    if (!ULID_PATTERN.test(prefix))
+        return null;
+    return laneId.length === 26 || laneId[26] === "_" ? prefix.toUpperCase() : null;
+}
+function checkedInbox(sourceDir) {
+    const dropboxDir = path.join(sourceDir, "dropbox");
+    const inbox = path.join(dropboxDir, "inbox.jsonl");
+    try {
+        const dropboxStat = fs.lstatSync(dropboxDir);
+        if (!dropboxStat.isDirectory() || dropboxStat.isSymbolicLink()) {
+            return fail("orphaned_dropbox_invalid", "Orphaned dropbox path must be a regular directory", { path: dropboxDir });
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { inbox, messages: [] };
+        if (error instanceof LanesError)
+            throw error;
+        return fail("orphaned_dropbox_unreadable", `Could not inspect orphaned dropbox: ${error instanceof Error ? error.message : String(error)}`, { path: dropboxDir });
+    }
+    let stat;
+    try {
+        stat = fs.lstatSync(inbox);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { inbox, messages: [] };
+        return fail("orphaned_dropbox_unreadable", `Could not inspect orphaned inbox: ${error instanceof Error ? error.message : String(error)}`, { path: inbox });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        return fail("orphaned_dropbox_invalid", "Orphaned inbox must be a regular file", { path: inbox });
+    }
+    let text;
+    try {
+        text = fs.readFileSync(inbox, "utf8");
+    }
+    catch (error) {
+        return fail("orphaned_dropbox_unreadable", `Could not read orphaned inbox: ${error instanceof Error ? error.message : String(error)}`, { path: inbox });
+    }
+    const messages = [];
+    for (const [index, line] of text.split(/\r?\n/).entries()) {
+        if (line.trim() === "")
+            continue;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return fail("orphaned_dropbox_message_invalid", "Orphaned inbox contains malformed JSONL", { path: inbox, line: index + 1 });
+        }
+        if (value === null || typeof value !== "object" || Array.isArray(value) || typeof value.text !== "string") {
+            return fail("orphaned_dropbox_message_invalid", "Orphaned inbox contains an invalid dropbox message", { path: inbox, line: index + 1 });
+        }
+        messages.push(value);
+    }
+    return { inbox, messages };
+}
+function canonicalLanesByUlid(hqRoot) {
+    const grouped = new Map();
+    for (const lane of readAllLanes(hqRoot)) {
+        const ulid = laneUlid(lane.lane_id);
+        if (!ulid)
+            continue;
+        grouped.set(ulid, [...(grouped.get(ulid) ?? []), lane]);
+    }
+    return grouped;
+}
+/** Finds bare-ULID run folders that have no bare lane record but do have a canonical lane. */
+export function findOrphanedBareIdDropboxes(hqRoot, company) {
+    const runsRoot = path.join(hqRoot, LANES_RUNS_REL);
+    let entries;
+    try {
+        const stat = fs.lstatSync(runsRoot);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            return fail("orphaned_dropbox_runs_invalid", "Lane runs path must be a regular directory", { path: runsRoot });
+        }
+        entries = fs.readdirSync(runsRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        if (error instanceof LanesError)
+            throw error;
+        return fail("orphaned_dropbox_runs_unreadable", `Could not list lane runs: ${error instanceof Error ? error.message : String(error)}`, { path: runsRoot });
+    }
+    const lanesByUlid = canonicalLanesByUlid(hqRoot);
+    const findings = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !ULID_PATTERN.test(entry.name))
+            continue;
+        const ulid = entry.name.toUpperCase();
+        if (tryReadLane(hqRoot, entry.name) !== null)
+            continue;
+        const canonicalLanes = lanesByUlid.get(ulid) ?? [];
+        const visibleLanes = company === undefined ? canonicalLanes : canonicalLanes.filter((lane) => {
+            const resolved = resolveLaneCompany(hqRoot, lane).company;
+            return resolved?.slug === company.slug && resolved.uid === company.uid;
+        });
+        const canonicalLaneIds = visibleLanes.map((lane) => lane.lane_id);
+        if (canonicalLaneIds.length === 0)
+            continue;
+        const sourceDir = path.join(runsRoot, entry.name);
+        const { messages } = checkedInbox(sourceDir);
+        const newest = messages.reduce((current, message) => {
+            if (typeof message.at !== "string")
+                return current;
+            const ms = Date.parse(message.at);
+            if (!Number.isFinite(ms) || (current !== null && current.ms >= ms))
+                return current;
+            return { at: message.at, ms };
+        }, null);
+        findings.push({
+            ulid,
+            canonical_lane_ids: canonicalLaneIds,
+            message_count: messages.length,
+            newest_message_at: newest?.at ?? null,
+            source_dir: sourceDir,
+        });
+    }
+    return findings.sort((a, b) => a.ulid.localeCompare(b.ulid));
+}
+export function repairOrphanedBareIdDropbox(hqRoot, ulidInput, options) {
+    const ulid = ulidInput.trim().toUpperCase();
+    if (!ULID_PATTERN.test(ulid))
+        return fail("orphaned_dropbox_ulid_invalid", "Expected a 26-character ULID", { ulid: ulidInput });
+    const finding = findOrphanedBareIdDropboxes(hqRoot).find((entry) => entry.ulid === ulid);
+    if (!finding)
+        return fail("orphaned_dropbox_not_found", `No orphaned bare-ID dropbox was found for ${ulid}`, { ulid });
+    if (finding.canonical_lane_ids.length !== 1) {
+        return fail("orphaned_dropbox_lane_ambiguous", `ULID ${ulid} matches more than one lane record`, { ulid, lane_ids: finding.canonical_lane_ids });
+    }
+    const canonicalLaneId = finding.canonical_lane_ids[0];
+    if (tryReadLane(hqRoot, canonicalLaneId) === null) {
+        return fail("orphaned_dropbox_lane_changed", `Canonical lane ${canonicalLaneId} disappeared before repair`, { ulid, lane_id: canonicalLaneId });
+    }
+    const { messages } = checkedInbox(finding.source_dir);
+    const newest = messages.reduce((current, message) => {
+        if (typeof message.at !== "string")
+            return current;
+        const ms = Date.parse(message.at);
+        if (!Number.isFinite(ms) || (current !== null && current.ms >= ms))
+            return current;
+        return { at: message.at, ms };
+    }, null);
+    const result = {
+        ulid,
+        canonical_lane_id: canonicalLaneId,
+        message_count: messages.length,
+        newest_message_at: newest?.at ?? null,
+        applied: false,
+    };
+    if (!options.apply)
+        return result;
+    if (!options.enabled)
+        return fail("orphaned_dropbox_repair_disabled", "Applying orphaned dropbox repairs requires the lanes.orphaned-bare-id-dropbox-repair flag", { ulid });
+    const archiveName = `${ulid}.orphaned-${options.now.toISOString().replaceAll(/[:.]/g, "-")}`;
+    const archivedDir = path.join(path.dirname(finding.source_dir), archiveName);
+    if (fs.existsSync(archivedDir))
+        return fail("orphaned_dropbox_archive_exists", "Orphaned dropbox archive path already exists", { ulid, path: archivedDir });
+    if (messages.length > 0) {
+        const targetRunDir = path.join(hqRoot, LANES_RUNS_REL, canonicalLaneId);
+        const targetDropboxDir = path.join(targetRunDir, "dropbox");
+        fs.mkdirSync(targetRunDir, { recursive: true });
+        for (const dir of [targetRunDir, targetDropboxDir]) {
+            try {
+                const stat = fs.lstatSync(dir);
+                if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                    return fail("orphaned_dropbox_target_invalid", "Canonical dropbox path must be a regular directory", { path: dir });
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    return fail("orphaned_dropbox_target_unreadable", `Could not inspect canonical dropbox path: ${error instanceof Error ? error.message : String(error)}`, { path: dir });
+                }
+                fs.mkdirSync(dir);
+            }
+        }
+        const targetInbox = path.join(targetDropboxDir, "inbox.jsonl");
+        try {
+            const stat = fs.lstatSync(targetInbox);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                return fail("orphaned_dropbox_target_invalid", "Canonical inbox must be a regular file", { path: targetInbox });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                return fail("orphaned_dropbox_target_unreadable", `Could not inspect canonical inbox: ${error instanceof Error ? error.message : String(error)}`, { path: targetInbox });
+            }
+        }
+        const redeliveredAt = options.now.toISOString();
+        const redelivered = messages.map((message) => ({
+            ...message,
+            redelivered: true,
+            redelivered_from: ulid,
+            redelivered_at: redeliveredAt,
+        }));
+        fs.appendFileSync(targetInbox, `${redelivered.map((message) => JSON.stringify(message)).join("\n")}\n`, "utf8");
+    }
+    fs.renameSync(finding.source_dir, archivedDir);
+    return { ...result, applied: true, archived_dir: archivedDir };
+}
+//# sourceMappingURL=orphaned-dropbox.js.map

package/dist/lib/lanes/tracker-checks.d.ts

@@ -69,7 +69,7 @@ export interface TrackerCheckFinding {
     [key: string]: unknown;
 }
 export interface TrackerCheckResult {
-    id: "questions" | "lead_lanes" | "freshness" | "blockers" | "kpis" | "directives" | "orphaned_lane";
+    id: "questions" | "lead_lanes" | "freshness" | "blockers" | "kpis" | "directives" | "orphaned_lane" | "orphaned_bare_id_dropbox";
     result: "ok" | "failing";
     items: TrackerCheckFinding[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.318.0",
+  "version": "5.319.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {