@indigoai-us/hq-cli 5.293.0 → 5.295.0

package/dist/fast-core.js

@@ -18,43 +18,71 @@ export async function runFastCore(argv) {
     const parsed = parseFastCore(argv);
     if (!parsed)
         return;
-    // `root: "live"` — resolve the live HQ root and run the script in it, exactly
-    // as core.ts's runEntry does. Fail soft: if no root can be resolved, run the
-    // script anyway with the inherited environment (the hook already carries
-    // CLAUDE_PROJECT_DIR, and each script has its own root fallback) rather than
-    // crashing a Stop hook on a resolution error.
+    const entry = parsed.entry;
+    // The full graph's process gate accepts textual true/false overrides. It ignores
+    // numeric env values, so preserve that behavior for family flags here too.
+    const familyEnabled = entry.kind !== "native" || !entry.familyFlagKey ||
+        await (await import("./native-fast-route.js")).fastFlagEnabled(entry.familyFlagKey, process.env, { numericEnvironmentOverride: false });
+    const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
+    const shouldInjectRoot = useShell
+        ? entry.shellHqRoot === "live" || (entry.shellHqRoot === "reconcile-default" &&
+            !parsed.args.includes("--hq-root") && !parsed.args.includes("--help") && !parsed.args.includes("-h"))
+        : entry.kind === "shell"
+            ? true
+            : entry.root === "live";
+    // `root: "live"` — resolve the live HQ root using the same resolver as the
+    // full command graph. Existing shell fast entries keep their historical
+    // fail-soft behavior; newly routed commands fall back to the full graph so
+    // its expected-user-error formatting remains authoritative.
     let hqRoot;
-    try {
-        hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
-    }
-    catch {
-        hqRoot = undefined;
+    if (shouldInjectRoot) {
+        try {
+            hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
+        }
+        catch {
+            if (entry.kind === "native") {
+                const { runCli } = await import("./main.js");
+                await runCli();
+                return;
+            }
+            hqRoot = undefined;
+        }
     }
-    if (parsed.entry.kind === "native") {
-        const handlerModule = await import(parsed.entry.modulePath);
-        const handler = handlerModule[parsed.entry.exportName];
+    if (entry.kind === "native" && !useShell) {
+        const { installFastPathStreamErrorHandlers } = await import("./utils/fast-stream-errors.js");
+        installFastPathStreamErrorHandlers();
+        const handlerModule = await import(entry.modulePath);
+        const handler = handlerModule[entry.exportName];
         if (typeof handler !== "function") {
-            throw new Error(`Native fast handler ${parsed.entry.exportName} was not exported`);
+            throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
         const chunks = [];
-        for await (const chunk of process.stdin)
-            chunks.push(chunk);
-        const code = await handler(argv, Buffer.concat(chunks).toString("utf8"), process.cwd(), hqRoot);
+        if (entry.readsStdin) {
+            for await (const chunk of process.stdin)
+                chunks.push(chunk);
+        }
+        const code = await handler(parsed.args, entry.readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;
         return;
     }
-    // Keep the CHILD in the caller's cwd, unlike the generic "live" dispatch. The
-    // relocated scripts read their data tree from the injected root, not cwd, and
-    // hq-session's Work Mesh registration serializes $PWD — so changing directory
-    // to the HQ root would mislabel a bind made from inside a project/worktree.
+    const asset = entry.asset;
+    if (!asset)
+        throw new Error(`Fast route ${entry.name} has no shell companion`);
+    // Some historical registrations run from the live root, others preserve the
+    // caller cwd and only inject HQ_ROOT. Keep those choices explicit per entry.
+    const cwd = entry.kind === "native" && entry.shellCwd === "live"
+        ? hqRoot ?? process.cwd()
+        : process.cwd();
+    const injectRoot = entry.kind === "shell" || entry.kind === "native" &&
+        (entry.shellHqRoot === "live" || entry.shellHqRoot === "reconcile-default" && shouldInjectRoot);
     const { code } = runBundledScript({
-        asset: parsed.entry.asset,
+        asset,
         args: parsed.args,
-        cwd: process.cwd(),
-        hqRoot,
-        env: parsed.entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : undefined,
+        cwd,
+        ...(injectRoot ? { hqRoot } : {}),
+        env: entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : undefined,
     });
     // Propagate verbatim: these scripts use their exit code as their interface.
     process.exit(code);

package/dist/fast-scaffold.d.ts

@@ -15,16 +15,29 @@ export type FastScaffoldScript = {
     kind: "shell";
     /** Path under `assets/scaffold/`, e.g. `core/scripts/foo.sh`. */
     asset: string;
+    root?: "live";
 } | {
-    /** Direct subcommand name — `hq core <name>`. */
+    /** Command path, joined with spaces, e.g. `policy frontmatter`. */
     name: string;
     kind: "native";
     /** Relative ESM module specifier, resolved from fast-core.js. */
     modulePath: string;
     /** Named export which accepts the native fast-handler contract. */
     exportName: string;
-    /** Default-off registry flag for this native route. */
+    /** Existing default-off gate for the whole fast route. */
     flagKey: string;
+    /** Existing family gate that chooses this native handler or its shell companion. */
+    familyFlagKey?: string;
+    /** Shell rollback companion used while the family gate is off. */
+    asset?: string;
+    /** Root context used by the native handler. */
+    root?: "live" | "cwd" | "passthrough";
+    /** Cwd used for a shell rollback companion. Defaults to the caller cwd. */
+    shellCwd?: "caller" | "live";
+    /** Root injection behavior for a shell rollback companion. */
+    shellHqRoot?: "none" | "live" | "reconcile-default";
+    /** Whether this handler consumes stdin. Shell companions inherit stdin directly. */
+    readsStdin?: boolean;
 };
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export declare const FAST_SCAFFOLD_SCRIPTS: readonly FastScaffoldScript[];
@@ -53,11 +66,6 @@ export type ParsedSecretsEnvFastRequest = {
  * the full CLI, which remains the source of truth for help and errors.
  */
 export declare function parseSecretsEnvFastRequest(argv: readonly string[]): ParsedSecretsEnvFastRequest | null;
-/**
- * The cache-first list path only handles the bare JSON request. `--fresh`,
- * filters, help, and unknown options stay with Commander and the full CLI.
- */
-export declare function isFastCachedLanesListRequest(argv: readonly string[]): boolean;
 /**
  * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
  * fast-path script. Returns null for anything else so the caller defers to the

package/dist/fast-scaffold.js

@@ -11,15 +11,175 @@
  */
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export const FAST_SCAFFOLD_SCRIPTS = [
-    { name: "checkpoint-stop-gate", kind: "shell", asset: "core/scripts/checkpoint-stop-gate.sh" },
-    { name: "hq-session", kind: "shell", asset: "core/scripts/hq-session.sh" },
+    { name: "checkpoint-stop-gate", kind: "shell", asset: "core/scripts/checkpoint-stop-gate.sh", root: "live" },
+    { name: "hq-session", kind: "shell", asset: "core/scripts/hq-session.sh", root: "live" },
     {
         name: "timeout-guard",
         kind: "native",
         modulePath: "./lib/core-utils/timeout-guard-native.js",
         exportName: "runTimeoutGuardFast",
         flagKey: "hq-core-native-fast-route",
+        root: "cwd",
+        readsStdin: true,
     },
+    {
+        name: "policy frontmatter",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/read-policy-frontmatter.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "policy age-report",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/policy-age-report.sh",
+        root: "live",
+        shellCwd: "caller",
+        shellHqRoot: "live",
+    },
+    {
+        name: "policy retire",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/policy-retire.sh",
+        root: "live",
+        shellCwd: "caller",
+        shellHqRoot: "live",
+    },
+    {
+        name: "knowledge-prefs",
+        kind: "native",
+        modulePath: "./commands/core-knowledge-prefs.js",
+        exportName: "runKnowledgePrefsFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/knowledge-prefs.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...["finalize", "post", "open-steps"].map((name) => ({
+        name: `handoff ${name}`,
+        kind: "native",
+        modulePath: name === "open-steps"
+            ? "./commands/core-handoff-open-steps.js"
+            : "./commands/core-handoff-fast.js",
+        exportName: name === "open-steps" ? "runHandoffOpenStepsFast" : "runHandoffFastEntry",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: `core/scripts/handoff-${name === "open-steps" ? "open-steps" : name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    })),
+    {
+        name: "worktree-gc",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/worktree-gc.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "clean-worktree-reconcile-handoff",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/clean-worktree-reconcile-handoff.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "resume-thread-lock",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/resume-thread-lock.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "verify-story-deliverables",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/verify-story-deliverables.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...["schedule-parse", "validate", "reconcile"].map((name) => ({
+        name: `jobs ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-jobs-native.js",
+        exportName: "runJobsFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-jobs",
+        asset: `core/scripts/${name === "reconcile" ? "outpost-jobs-reconcile" : `jobs-${name}`}.sh`,
+        root: name === "reconcile" ? "passthrough" : "cwd",
+        shellCwd: "caller",
+        shellHqRoot: name === "reconcile" ? "reconcile-default" : "none",
+    })),
+    ...["resolve", "pickup", "repo", "secrets", "transfer"].map((name) => ({
+        name: `delegate ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-delegate.js",
+        exportName: "runDelegateFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-delegate",
+        asset: `core/scripts/hq-delegate-${name}.sh`,
+        root: name === "pickup" ? "cwd" : "live",
+        shellCwd: name === "pickup" ? "caller" : "live",
+        shellHqRoot: name === "pickup" ? "none" : "live",
+    })),
+    ...["bundle", "grant", "publish", "send", "verify"].map((name) => ({
+        name: `delegate ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-delegate-w1b.js",
+        exportName: "runDelegateW1bFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-delegate",
+        asset: `core/scripts/hq-delegate-${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    })),
+    ...["audience-grant", "brief", "candidate", "garden", "source-worklist", "source-yaml-validate"].map((name) => ({
+        name: `ontology ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-ontology-native.js",
+        exportName: "runOntologyNativeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-ontology",
+        asset: `core/scripts/${name === "audience-grant" ? "ontology-audience-grant" : name === "source-worklist" ? "ontology-source-worklist" : name === "source-yaml-validate" ? "source-yaml-validate" : `ontology-${name}`}.${name === "brief" || name === "garden" ? "mjs" : "sh"}`,
+        root: name === "source-yaml-validate" ? "cwd" : "live",
+        shellCwd: "caller",
+        shellHqRoot: name === "source-yaml-validate" ? "none" : "live",
+    })),
 ];
 /**
  * Parse the small, non-ambiguous `hq secrets env` surface for the gated entry
@@ -112,16 +272,6 @@ export function parseSecretsEnvFastRequest(argv) {
     }
     return hasOnly ? { options, scope } : null;
 }
-/**
- * The cache-first list path only handles the bare JSON request. `--fresh`,
- * filters, help, and unknown options stay with Commander and the full CLI.
- */
-export function isFastCachedLanesListRequest(argv) {
-    return argv.length === 5 &&
-        argv[2] === "lanes" &&
-        argv[3] === "list" &&
-        argv[4] === "--json";
-}
 /**
  * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
  * fast-path script. Returns null for anything else so the caller defers to the
@@ -148,13 +298,13 @@ export function parseFastCore(argv) {
         hqRootArg = head.slice("--hq-root=".length);
         i += 1;
     }
-    const name = argv[i];
-    if (typeof name !== "string")
-        return null;
-    const entry = FAST_SCAFFOLD_SCRIPTS.find((candidate) => candidate.name === name);
+    const commandArgs = argv.slice(i);
+    const entry = [...FAST_SCAFFOLD_SCRIPTS]
+        .sort((left, right) => right.name.split(" ").length - left.name.split(" ").length)
+        .find((candidate) => candidate.name.split(" ").every((part, index) => commandArgs[index] === part));
     if (!entry)
         return null;
-    return { entry, hqRootArg, args: argv.slice(i + 1) };
+    return { entry, hqRootArg, args: argv.slice(i + entry.name.split(" ").length) };
 }
 /** Whether this invocation is a fast-path scaffold dispatch. */
 export function isFastCoreRequest(argv) {

package/dist/index.js

@@ -6,7 +6,7 @@ import "./node-network-compat.js";
 import { isVersionRequest, wantsLabelledVersionReport } from "./version-request.js";
 // Dependency-light: a pure parser + table, no command graph. Safe to load on
 // every path (including --version) without reintroducing the heavy startup.
-import { isFastCachedLanesListRequest, isFastCoreRequest, parseFastCore, parseSecretsEnvFastRequest, } from "./fast-scaffold.js";
+import { isFastCoreRequest, parseFastCore, parseSecretsEnvFastRequest, } from "./fast-scaffold.js";
 // Also dependency-light: registers a process-level rejection boundary; its only
 // heavy import (main.js) is lazy and reached only when a rejection fires.
 import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.js";
@@ -61,15 +61,6 @@ else if (parseSecretsEnvFastRequest(process.argv)) {
         });
     });
 }
-else if (isFastCachedLanesListRequest(process.argv)) {
-    void import("./fast-lanes-list-route.js").then(async ({ runFastLanesListRequest }) => {
-        const handled = await runFastLanesListRequest(process.argv);
-        if (!handled) {
-            const { runCli } = await import("./main.js");
-            await runCli();
-        }
-    });
-}
 else if (isFastCoreRequest(process.argv)) {
     // Hot relocated plumbing (`hq core hq-session`, `hq core checkpoint-stop-gate`)
     // dispatches straight to the bundled-script runner, so it never pays for the

package/dist/lib/core-utils/sentry-report.d.ts

@@ -17,7 +17,6 @@
  */
 import * as Sentry from "@sentry/node";
 import type { CaptureContext, SeverityLevel } from "@sentry/node";
-import type { ClientHealthSentryEvent } from "../doctor/client-health-sentry.js";
 export declare const DEFAULT_SENTRY_REPORT_TIMEOUT_MS = 750;
 export declare const MAX_SENTRY_REPORT_TIMEOUT_MS = 5000;
 export declare const MAX_SENTRY_REPORT_PAYLOAD_BYTES = 2048;
@@ -96,17 +95,6 @@ export type SentryReportResult = {
     event?: SentryReportEvent;
     droppedMetadataKeys?: number;
 };
-export interface ClientHealthSentryScope {
-    clear(): void;
-    setLevel(level: SeverityLevel): void;
-    setFingerprint(fingerprint: string[]): void;
-    setTags(tags: Record<string, string>): void;
-    setUser(user: {
-        id: string;
-        ip_address: null;
-    }): void;
-}
-export type ClientHealthSentryScopeRunner = (callback: (scope: ClientHealthSentryScope) => void) => void;
 /**
  * Read no more than the accepted event size. Returning early keeps a malformed
  * pipe from making a watchdog retain an unbounded hook payload in memory.
@@ -129,11 +117,4 @@ export declare function parseSentryReportEvent(stdin: string): SentryReportResul
  * transport errors cannot echo event data back to a hook.
  */
 export declare function reportSentryEvent(stdin: string, options?: SentryReportOptions, dependencies?: SentryReportDependencies): Promise<SentryReportResult>;
-/** Send the client-health projection with a clean Sentry scope and no metadata payload. */
-export declare function reportClientHealthEvents(events: readonly ClientHealthSentryEvent[], options?: {
-    timeoutMs?: number;
-    scopeRunner?: ClientHealthSentryScopeRunner;
-}, dependencies?: SentryReportDependencies): Promise<{
-    code: 0 | 1;
-}>;
 //# sourceMappingURL=sentry-report.d.ts.map

package/dist/lib/core-utils/sentry-report.js

@@ -577,6 +577,14 @@ function hookTimeoutDebugContextTags(context) {
 }
 function safeSlowChild(metadata) {
     const value = metadata.slow_child;
+    const slowChildMs = metadata.slow_child_ms;
+    const hasMeasuredChild = typeof slowChildMs === "number" && Number.isFinite(slowChildMs) && slowChildMs >= 0;
+    if (metadata.hook_event === "SessionStart" &&
+        (metadata.bash_env_set === true || metadata.bash_env_set === "set") &&
+        !hasMeasuredChild &&
+        (typeof value !== "string" || value.length === 0 || value === "other")) {
+        return "entry-bash-startup";
+    }
     if (typeof value !== "string" || !SAFE_HOOK_SCRIPT.test(value))
         return "other";
     return value;
@@ -1006,65 +1014,4 @@ export async function reportSentryEvent(stdin, options = {}, dependencies = defa
     dependencies.stderr.write("Sentry report failed.\n");
     return invalidInput();
 }
-function isSafeClientHealthEvent(event) {
-    const tags = event.tags;
-    const checkClass = tags.check_class;
-    const reasonCode = tags.reason_code;
-    const classPattern = /^sync\.(?:update\.core|journal\.(?:personal|personal_vault|company)|manifest\.(?:personal|personal_vault|company))$|^other$/;
-    const reasonPattern = /^(?:none|core-version-unavailable|core-update-available|no-local-tree|never-synced|invalid-last-sync|stale-threshold|manifest-unavailable|manifest-state-unavailable|no-manifest-scopes|never-uploaded|invalid-upload-time|unresolved-company-uid)$/;
-    const versionPattern = /^(?:unknown|\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?(?:\+[A-Za-z0-9.-]+)?)$/;
-    const safeTagKeys = [
-        "check_class", "reason_code", "fix_outcome", "status", "failing_check_count",
-        "cli_version", "core_version", "sync_version", "platform", "arch",
-    ];
-    return (event.level === "warning" &&
-        classPattern.test(checkClass) &&
-        reasonPattern.test(reasonCode) &&
-        event.message === `Client health: ${checkClass} unresolved after hq doctor --fix` &&
-        event.fingerprint.length === 3 &&
-        event.fingerprint[0] === "client-health" &&
-        event.fingerprint[1] === checkClass &&
-        event.fingerprint[2] === reasonCode &&
-        (tags.fix_outcome === "not_auto_fixable" || tags.fix_outcome === "fix_failed" || tags.fix_outcome === "fix_timed_out") &&
-        (tags.status === "FAIL" || tags.status === "WARN") &&
-        /^\d{1,3}$/.test(tags.failing_check_count) &&
-        safeTagKeys.every((key) => Object.hasOwn(tags, key)) &&
-        Object.keys(tags).length === safeTagKeys.length &&
-        [tags.cli_version, tags.core_version, tags.sync_version].every((value) => versionPattern.test(value)) &&
-        /^[a-z0-9]+$/.test(tags.platform) &&
-        /^[a-z0-9]+$/.test(tags.arch) &&
-        /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(event.user.id) &&
-        event.user.ip_address === null);
-}
-/** Send the client-health projection with a clean Sentry scope and no metadata payload. */
-export async function reportClientHealthEvents(events, options = {}, dependencies = defaultDependencies) {
-    const timeoutMs = resolveTimeout(options.timeoutMs);
-    if (timeoutMs === null ||
-        events.length === 0 ||
-        events.length > 250 ||
-        events.some((event) => !isSafeClientHealthEvent(event))) {
-        dependencies.stderr.write("Invalid client health Sentry event.\n");
-        return { code: 1 };
-    }
-    const withScope = options.scopeRunner ?? ((callback) => Sentry.withScope((scope) => callback(scope)));
-    try {
-        for (const event of events) {
-            withScope((scope) => {
-                scope.clear();
-                scope.setLevel(event.level);
-                scope.setFingerprint([...event.fingerprint]);
-                scope.setTags({ sentry_event_type: "client_health", ...event.tags });
-                scope.setUser({ id: event.user.id, ip_address: null });
-                dependencies.sentry.captureMessage(event.message);
-            });
-        }
-        if (await flushWithin(dependencies.sentry, timeoutMs))
-            return { code: 0 };
-    }
-    catch {
-        // Keep the event and transport details out of hook stderr.
-    }
-    dependencies.stderr.write("Client health Sentry report failed.\n");
-    return { code: 1 };
-}
 //# sourceMappingURL=sentry-report.js.map

package/dist/lib/core-utils/worktree-resume.d.ts

@@ -15,4 +15,6 @@ export declare function runWorktreeGc(args: readonly string[], hqRoot: string, i
 export declare function runCleanWorktreeReconcileHandoff(args: readonly string[], io?: CoreIo): number;
 export declare function runResumeThreadLock(args: readonly string[], hqRoot: string, io?: CoreIo): number;
 export declare function runVerifyStoryDeliverables(args: readonly string[], hqRoot: string, io?: CoreIo): Promise<number>;
+/** Fast-entry adapter; family gating and shell fallback happen before import. */
+export declare function runWorktreeResumeFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, commandName: string): Promise<number>;
 //# sourceMappingURL=worktree-resume.d.ts.map

package/dist/lib/core-utils/worktree-resume.js

@@ -1179,4 +1179,20 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
         stdout(io, `verify-story-deliverables: ${storyId} — all ${refs.length} reference(s) present (${declaredCount} declared, ${refs.length - declaredCount} from worker evidence)${recordedSuffix}\n`);
     return 0;
 }
+/** Fast-entry adapter; family gating and shell fallback happen before import. */
+export async function runWorktreeResumeFast(args, _stdin, cwd, hqRoot, commandName) {
+    const root = hqRoot ?? cwd;
+    let code;
+    if (commandName === "worktree-gc")
+        code = runWorktreeGc(args, root);
+    else if (commandName === "clean-worktree-reconcile-handoff")
+        code = runCleanWorktreeReconcileHandoff(args);
+    else if (commandName === "resume-thread-lock")
+        code = runResumeThreadLock(args, root);
+    else
+        code = await runVerifyStoryDeliverables(args, root);
+    if (code !== 0)
+        process.exitCode = code;
+    return code;
+}
 //# sourceMappingURL=worktree-resume.js.map

package/dist/lib/daemon/migrate.d.ts

@@ -9,7 +9,9 @@
  * back. A unit whose stop fails is left where it was and not recorded.
  *
  * Units owned by another product (the desktop app's sync agent) are never
- * touched, and box system units need root. System units are recorded and
+ * touched, and box system units need root. Root on a box stops and restarts
+ * the login user's own units through that user's systemd manager, since
+ * root's `systemctl --user` reaches only root's. System units are recorded and
  * saved in root-owned storage (not the login user's daemon folder, which the
  * user can edit), and a restore checks each one lands in the system unit
  * folder, so nobody but root decides what gets installed there.
@@ -33,6 +35,11 @@ export interface MigrateDeps {
     systemRecordPath: string;
     /** Where box system units live (/etc/systemd/system); restores must land here. */
     systemUnitDir: string;
+    /** Root on a box: the login user whose systemd user units these are. */
+    userUnitsOwner?: {
+        user: string;
+        uid: number;
+    };
     now?: () => number;
     /** Tests inject a failing writer. */
     writeRecord?: (recordPath: string, units: AdoptedUnit[]) => void;

package/dist/lib/daemon/migrate.js

@@ -9,7 +9,9 @@
  * back. A unit whose stop fails is left where it was and not recorded.
  *
  * Units owned by another product (the desktop app's sync agent) are never
- * touched, and box system units need root. System units are recorded and
+ * touched, and box system units need root. Root on a box stops and restarts
+ * the login user's own units through that user's systemd manager, since
+ * root's `systemctl --user` reaches only root's. System units are recorded and
  * saved in root-owned storage (not the login user's daemon folder, which the
  * user can edit), and a restore checks each one lands in the system unit
  * folder, so nobody but root decides what gets installed there.
@@ -56,6 +58,18 @@ function must(run, cmd, args) {
     }
     return r.stdout;
 }
+/** `systemctl` for a unit: `--user` units go to their owner's manager, as that user when root acts for them. */
+function systemctl(unit, deps, args) {
+    if (unit.kind !== "systemd-user")
+        return ["systemctl", args];
+    const owner = deps.isRoot ? deps.userUnitsOwner : undefined;
+    if (!owner)
+        return ["systemctl", ["--user", ...args]];
+    return [
+        "runuser",
+        ["-u", owner.user, "--", "env", `XDG_RUNTIME_DIR=/run/user/${owner.uid}`, "systemctl", "--user", ...args],
+    ];
+}
 function moveFile(from, to) {
     ensurePrivateDir(path.dirname(to));
     try {
@@ -92,10 +106,9 @@ function adoptOne(unit, deps) {
         case "systemd-system": {
             if (!unit.path)
                 throw new Error(`no unit file path for ${unit.name}`);
-            const scope = unit.kind === "systemd-user" ? ["--user"] : [];
-            must(deps.run, "systemctl", [...scope, "disable", "--now", unit.name]);
+            must(deps.run, ...systemctl(unit, deps, ["disable", "--now", unit.name]));
             moveFile(unit.path, to);
-            deps.run("systemctl", [...scope, "daemon-reload"]);
+            deps.run(...systemctl(unit, deps, ["daemon-reload"]));
             return to;
         }
         case "schtasks": {
@@ -190,10 +203,9 @@ function restoreOne(unit, deps) {
             if (unit.kind === "systemd-system" && !deps.isRoot) {
                 throw new Error("a system unit; run `sudo hq daemon uninstall --restore-legacy`");
             }
-            const scope = unit.kind === "systemd-user" ? ["--user"] : [];
             moveBack(unit, unit.path);
-            deps.run("systemctl", [...scope, "daemon-reload"]);
-            must(deps.run, "systemctl", [...scope, "enable", "--now", unit.name]);
+            deps.run(...systemctl(unit, deps, ["daemon-reload"]));
+            must(deps.run, ...systemctl(unit, deps, ["enable", "--now", unit.name]));
             return;
         }
         case "schtasks":

package/dist/lib/doctor/checks/claude-wiring.js

@@ -460,6 +460,15 @@ function requiredFromFirstCommand(first) {
         k += 1;
     if (k >= first.length)
         return { required, gatedHookId };
+    // SessionStart can use env to set BASH_ENV before Bash itself starts.
+    // Walk through that launcher and its assignments just like the shell scanner.
+    if (baseName(first[k]) === "env") {
+        k += 1;
+        while (k < first.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(first[k]))
+            k += 1;
+        if (k >= first.length || first[k].startsWith("-"))
+            return { required, gatedHookId };
+    }
     if (INTERPRETERS.has(baseName(first[k]))) {
         k += 1;
         while (k < first.length && first[k].startsWith("-")) {