@indigoai-us/hq-cli 5.345.121 → 5.345.123

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

@@ -9511,6 +9511,40 @@ export declare const COMMAND_CATALOG: readonly [{
         }];
         readonly options: readonly [];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "handoff-sync-prefetch";
+        readonly description: "Pull the latest continuity pointer before a session resumes";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: false;
+        readonly helpCommand: false;
+        readonly usage: "[args...]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "args";
+            readonly required: false;
+            readonly variadic: true;
+            readonly description: "arguments passed through to the script";
+        }];
+        readonly options: readonly [];
+        readonly subcommands: readonly [];
+    }, {
+        readonly name: "handoff-sync-publish";
+        readonly description: "Publish the session continuity pointer to the personal vault";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: false;
+        readonly helpCommand: false;
+        readonly usage: "[args...]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "args";
+            readonly required: false;
+            readonly variadic: true;
+            readonly description: "arguments passed through to the script";
+        }];
+        readonly options: readonly [];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "hq-task";
         readonly description: "List and update tasks on personal or company boards";
@@ -9528,6 +9562,40 @@ export declare const COMMAND_CATALOG: readonly [{
         }];
         readonly options: readonly [];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "knowledge-pulse-lock";
+        readonly description: "Atomically claim a company knowledge-pulse run";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: false;
+        readonly helpCommand: false;
+        readonly usage: "[args...]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "args";
+            readonly required: false;
+            readonly variadic: true;
+            readonly description: "arguments passed through to the script";
+        }];
+        readonly options: readonly [];
+        readonly subcommands: readonly [];
+    }, {
+        readonly name: "skill-installed";
+        readonly description: "Check whether a company-scoped skill is installed";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: false;
+        readonly helpCommand: false;
+        readonly usage: "[args...]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "args";
+            readonly required: false;
+            readonly variadic: true;
+            readonly description: "arguments passed through to the script";
+        }];
+        readonly options: readonly [];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "checkpoint-stop-gate";
         readonly description: "Stop-hook checkpoint + company-scope gate (reads the hook payload on stdin)";
@@ -13334,6 +13402,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly flags: "--remote-control";
             readonly description: "Open a Claude lane in Remote Control using account a for login and the selected account for inference";
             readonly hidden: false;
+        }, {
+            readonly flags: "--title <text>";
+            readonly description: "Human-readable Claude Remote Control session title; required with --remote-control";
+            readonly hidden: false;
         }, {
             readonly flags: "--account <id>";
             readonly description: "Provider account id, or 'auto' to pick the account with the most room (all accounts are one pool across companies)";
@@ -17176,6 +17248,31 @@ export declare const COMMAND_CATALOG: readonly [{
             }];
             readonly subcommands: readonly [];
         }];
+    }, {
+        readonly name: "list";
+        readonly description: "List deploy apps in your company, optionally filtered by name or subdomain";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options] [query]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "query";
+            readonly required: false;
+            readonly variadic: false;
+            readonly description: "";
+        }];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "use this company instead of the active company";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--json";
+            readonly description: "print the matching apps as JSON";
+            readonly hidden: false;
+        }];
+        readonly subcommands: readonly [];
     }];
 }, {
     readonly name: "staff";

package/dist/command-catalog.generated.js

@@ -11527,6 +11527,46 @@ export const COMMAND_CATALOG = [
                 "options": [],
                 "subcommands": []
             },
+            {
+                "name": "handoff-sync-prefetch",
+                "description": "Pull the latest continuity pointer before a session resumes",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": false,
+                "helpCommand": false,
+                "usage": "[args...]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "args",
+                        "required": false,
+                        "variadic": true,
+                        "description": "arguments passed through to the script"
+                    }
+                ],
+                "options": [],
+                "subcommands": []
+            },
+            {
+                "name": "handoff-sync-publish",
+                "description": "Publish the session continuity pointer to the personal vault",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": false,
+                "helpCommand": false,
+                "usage": "[args...]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "args",
+                        "required": false,
+                        "variadic": true,
+                        "description": "arguments passed through to the script"
+                    }
+                ],
+                "options": [],
+                "subcommands": []
+            },
             {
                 "name": "hq-task",
                 "description": "List and update tasks on personal or company boards",
@@ -11547,6 +11587,46 @@ export const COMMAND_CATALOG = [
                 "options": [],
                 "subcommands": []
             },
+            {
+                "name": "knowledge-pulse-lock",
+                "description": "Atomically claim a company knowledge-pulse run",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": false,
+                "helpCommand": false,
+                "usage": "[args...]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "args",
+                        "required": false,
+                        "variadic": true,
+                        "description": "arguments passed through to the script"
+                    }
+                ],
+                "options": [],
+                "subcommands": []
+            },
+            {
+                "name": "skill-installed",
+                "description": "Check whether a company-scoped skill is installed",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": false,
+                "helpCommand": false,
+                "usage": "[args...]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "args",
+                        "required": false,
+                        "variadic": true,
+                        "description": "arguments passed through to the script"
+                    }
+                ],
+                "options": [],
+                "subcommands": []
+            },
             {
                 "name": "checkpoint-stop-gate",
                 "description": "Stop-hook checkpoint + company-scope gate (reads the hook payload on stdin)",
@@ -16206,6 +16286,11 @@ export const COMMAND_CATALOG = [
                         "description": "Open a Claude lane in Remote Control using account a for login and the selected account for inference",
                         "hidden": false
                     },
+                    {
+                        "flags": "--title <text>",
+                        "description": "Human-readable Claude Remote Control session title; required with --remote-control",
+                        "hidden": false
+                    },
                     {
                         "flags": "--account <id>",
                         "description": "Provider account id, or 'auto' to pick the account with the most room (all accounts are one pool across companies)",
@@ -20903,6 +20988,37 @@ export const COMMAND_CATALOG = [
                         "subcommands": []
                     }
                 ]
+            },
+            {
+                "name": "list",
+                "description": "List deploy apps in your company, optionally filtered by name or subdomain",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options] [query]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "query",
+                        "required": false,
+                        "variadic": false,
+                        "description": ""
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "use this company instead of the active company",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "print the matching apps as JSON",
+                        "hidden": false
+                    }
+                ],
+                "subcommands": []
             }
         ]
     },

package/dist/command-registration-plan.d.ts

@@ -509,6 +509,12 @@ export declare const REGISTRATION_PLAN: readonly [{
     readonly parent: "deploy";
     readonly module: "./commands/deploy-comments.js";
     readonly exportName: "registerDeployCommentsCommand";
+}, {
+    readonly type: "registrar";
+    readonly root: "deploy";
+    readonly parent: "deploy";
+    readonly module: "./commands/deploy-list.js";
+    readonly exportName: "registerDeployListCommand";
 }, {
     readonly type: "group";
     readonly root: "staff";

package/dist/command-registration-plan.js

@@ -87,6 +87,7 @@ export const REGISTRATION_PLAN = [
     { type: "registrar", root: "report", parent: "program", module: "./commands/report.js", exportName: "registerReportCommand" },
     { type: "group", root: "deploy", id: "deploy", name: "deploy", description: "Manage deployments in hq-deploy" },
     { type: "registrar", root: "deploy", parent: "deploy", module: "./commands/deploy-comments.js", exportName: "registerDeployCommentsCommand" },
+    { type: "registrar", root: "deploy", parent: "deploy", module: "./commands/deploy-list.js", exportName: "registerDeployListCommand" },
     // onboarding-test-accounts US-007 — super-admin staff CLI wrappers over the
     // hq-pro admin surface. New wrappers land under this group; the reset
     // command mirrors POST /v1/admin/test-account/reset.

package/dist/commands/core-bucket-c-handoff-sync-fast.d.ts

@@ -0,0 +1,3 @@
+export declare function runHandoffSyncPrefetchFast(args: string[], _stdin: string, _cwd: string, root: string): Promise<number>;
+export declare function runHandoffSyncPublishFast(args: string[], _stdin: string, _cwd: string, root: string): Promise<number>;
+//# sourceMappingURL=core-bucket-c-handoff-sync-fast.d.ts.map

package/dist/commands/core-bucket-c-handoff-sync-fast.js

@@ -0,0 +1,16 @@
+import { runHandoffSyncPrefetch, runHandoffSyncPublish } from "./core-bucket-c-handoff-sync-native.js";
+async function emit(result) {
+    const output = await result;
+    if (output.stdout)
+        process.stdout.write(output.stdout);
+    if (output.stderr)
+        process.stderr.write(output.stderr);
+    return output.code;
+}
+export function runHandoffSyncPrefetchFast(args, _stdin, _cwd, root) {
+    return emit(runHandoffSyncPrefetch(args, root));
+}
+export function runHandoffSyncPublishFast(args, _stdin, _cwd, root) {
+    return emit(runHandoffSyncPublish(args, root));
+}
+//# sourceMappingURL=core-bucket-c-handoff-sync-fast.js.map

package/dist/commands/core-bucket-c-handoff-sync-native.d.ts

@@ -0,0 +1,45 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+export declare const HANDOFF_SYNC_PREFETCH_ASSET = "core/scripts/handoff-sync-prefetch.sh";
+export declare const HANDOFF_SYNC_PUBLISH_ASSET = "core/scripts/handoff-sync-publish.sh";
+export type HandoffSyncResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+type ChildResult = {
+    code: number;
+    timedOut: boolean;
+};
+type Dependencies = {
+    spawn: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    pid: number;
+    now: () => Date;
+};
+declare function parseArgs(args: readonly string[], kind: "prefetch" | "publish", env?: NodeJS.ProcessEnv): {
+    root: string;
+    timeout: string;
+    log: string;
+    sync: boolean;
+    child: boolean;
+} | HandoffSyncResult;
+declare function exitCode(code: number | null, signal: NodeJS.Signals | null): number;
+declare function runWithTimeout(deps: Dependencies, logFd: number, timeoutText: string, args: string[]): Promise<ChildResult>;
+declare function openLog(log: string): number | HandoffSyncResult;
+declare function header(deps: Dependencies, root: string, kind: "prefetch" | "publish", timeout: string, mode?: string): string;
+declare function resolveRoot(root: string, deps: Dependencies): string;
+declare function commandOnPath(name: string, env: NodeJS.ProcessEnv): boolean;
+export declare function runHandoffSyncPrefetch(args: readonly string[], hqRoot: string, deps?: Dependencies): Promise<HandoffSyncResult>;
+export declare function runHandoffSyncPublish(args: readonly string[], hqRoot: string, deps?: Dependencies): Promise<HandoffSyncResult>;
+export declare const __handoffSyncTest: {
+    parseArgs: typeof parseArgs;
+    exitCode: typeof exitCode;
+    runWithTimeout: typeof runWithTimeout;
+    openLog: typeof openLog;
+    header: typeof header;
+    resolveRoot: typeof resolveRoot;
+    commandOnPath: typeof commandOnPath;
+};
+export {};
+//# sourceMappingURL=core-bucket-c-handoff-sync-native.d.ts.map

package/dist/commands/core-bucket-c-handoff-sync-native.js

@@ -0,0 +1,300 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { buildSpawnPlan } from "../utils/windows-spawn.js";
+export const HANDOFF_SYNC_PREFETCH_ASSET = "core/scripts/handoff-sync-prefetch.sh";
+export const HANDOFF_SYNC_PUBLISH_ASSET = "core/scripts/handoff-sync-publish.sh";
+const PREFETCH_HELP = [
+    "!/bin/bash",
+    "handoff-sync-prefetch.sh - pull the latest session continuity pointer before",
+    "a fresh session reads it.",
+    "",
+    "`/startwork` and `/resumework` both read `workspace/threads/handoff.json`",
+    "(and the thread file it references) to decide what to resume. On a second",
+    "device those files only exist after a vault pull has landed, so a naive",
+    "resume right after sign-in sees stale state. This helper runs that pull",
+    "BEFORE the skill reads the pointer.",
+    "",
+    "Fail-soft:",
+    "  - no-op when the `hq` CLI is missing",
+    "  - no-op when offline or not logged in",
+    "  - timeboxed (default 25s)",
+    "  - never fails the caller: a successful or failed pull are both exit 0;",
+    "    the caller falls through to the local pointer either way.",
+    "",
+    "Usage:",
+    "  handoff-sync-prefetch.sh [--hq-root PATH] [--timeout SECONDS] [--log PATH]",
+    "",
+    "Prints one line of status on stdout for the caller to echo (or ignore):",
+    "  `ok`           - pull completed within the timeout",
+    "  `missing-cli`  - `hq` is not on PATH; nothing was attempted",
+    "  `skipped`      - CLI is present but the pull refused to start (no login,",
+    "                   locked, etc.); local pointer is still used",
+    "  `timed-out`    - pull exceeded the timeout and was killed",
+    "  `error:<rc>`   - pull returned a non-zero exit code",
+    "",
+    "Exits 0 in every case so a shell `|| true` is unnecessary at call sites.",
+    "",
+].join("\n");
+const PUBLISH_HELP = [
+    "!/bin/bash",
+    "handoff-sync-publish.sh - push the session continuity pointer to the personal vault.",
+    "",
+    "Cross-device handoff depends on `workspace/threads/handoff.json` and the",
+    "single thread file it points to reaching the vault before a fresh session on",
+    "another machine runs `/startwork` or `/resumework`. The workspace tree is",
+    "otherwise machine-local (`PERSONAL_VAULT_EXCLUDED_TOP_LEVEL`), so without a",
+    "push run between the two sessions machine B sees stale state or no handoff",
+    "at all. See hq-cloud-sync `computeContinuityPointerPaths`.",
+    "",
+    "This helper is intentionally minimal and fail-soft:",
+    "  - no-op when the `hq` CLI is missing (fresh install, agent box without CLI)",
+    "  - no-op when offline or not logged in (vault push will fail; we never",
+    "    block /handoff on cloud reachability)",
+    "  - timeboxed (default 25s) so a slow network cannot stall session end",
+    "  - detached by default; the handoff-finalize payload is already emitted",
+    "",
+    "Usage:",
+    "  handoff-sync-publish.sh [--hq-root PATH] [--timeout SECONDS]",
+    "                         [--sync] [--log PATH]",
+    "",
+    "  --sync     Run synchronously in the foreground and return the exit code.",
+    "             Default behaviour forks a backgrounded worker and prints its PID.",
+    "  --timeout  Wall-clock bound in seconds; the push is killed on expiry.",
+    "  --log      Append combined stdout/stderr to this path (default: `/tmp/handoff-sync-publish.log`).",
+    "",
+    "Exits 0 on dispatch (background mode) or on push success (sync mode).",
+    "A sync-mode failure returns the underlying `hq` exit, or 124 on timeout.",
+    "",
+].join("\n");
+const result = (code, stdout = "", stderr = "") => ({ code, stdout, stderr });
+const fail = (message, code = 1) => result(code, "", message + "\n");
+const defaults = () => ({ spawn: (command, args, options) => spawn(command, args, options), cwd: process.cwd(), env: process.env, pid: process.pid, now: () => new Date() });
+function parseArgs(args, kind, env = process.env) {
+    let root = "";
+    let timeout = kind === "prefetch"
+        ? (env.HQ_HANDOFF_PREFETCH_TIMEOUT ?? "25")
+        : (env.HQ_HANDOFF_PUBLISH_TIMEOUT ?? "25");
+    let log = kind === "prefetch" ? "/tmp/handoff-sync-prefetch.log" : "/tmp/handoff-sync-publish.log";
+    let sync = false;
+    let child = false;
+    for (let index = 0; index < args.length;) {
+        const token = args[index];
+        if (token === "--hq-root" || token === "--timeout" || token === "--log") {
+            if (index + 1 >= args.length) {
+                const script = kind === "prefetch" ? "handoff-sync-prefetch.sh" : "handoff-sync-publish.sh";
+                const line = kind === "prefetch"
+                    ? { "--hq-root": 39, "--timeout": 40, "--log": 41 }[token]
+                    : { "--hq-root": 39, "--timeout": 40, "--log": 42 }[token];
+                const scriptPath = shellScriptPath(fileURLToPath(new URL(`../../assets/scaffold/core/scripts/${script}`, import.meta.url)));
+                return result(1, "", `${scriptPath}: line ${line}: $2: unbound variable\n`);
+            }
+            const value = args[index + 1];
+            if (token === "--hq-root")
+                root = value;
+            else if (token === "--timeout")
+                timeout = value;
+            else
+                log = value;
+            index += 2;
+            continue;
+        }
+        if (token === "--sync" && kind === "publish") {
+            sync = true;
+            index += 1;
+            continue;
+        }
+        if (token === "--child" && kind === "publish") {
+            sync = true;
+            child = true;
+            index += 1;
+            continue;
+        }
+        if (token === "-h" || token === "--help")
+            return result(0, `${kind === "prefetch" ? PREFETCH_HELP : PUBLISH_HELP}\n`);
+        return fail(`handoff-sync-${kind}: unknown arg: ${token}`, 2);
+    }
+    return { root, timeout, log, sync, child };
+}
+function shellScriptPath(value) {
+    if (process.platform !== "win32")
+        return value;
+    const normalized = value.replaceAll("\\", "/");
+    const drivePath = normalized.match(/^([A-Za-z]):\/(.*)$/);
+    return drivePath ? `/${drivePath[1].toLowerCase()}/${drivePath[2]}` : normalized;
+}
+function exitCode(code, signal) {
+    if (code !== null)
+        return code;
+    if (signal === "SIGTERM")
+        return 143;
+    if (signal === "SIGKILL")
+        return 137;
+    return 1;
+}
+function runWithTimeout(deps, logFd, timeoutText, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            const plan = buildSpawnPlan("hq", args);
+            child = deps.spawn(plan.cmd, plan.args, {
+                cwd: deps.cwd, env: deps.env, stdio: ["ignore", logFd, logFd], windowsHide: true,
+                shell: plan.shell,
+                ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+            });
+        }
+        catch {
+            fs.writeSync(logFd, "spawn hq failed\n");
+            resolve({ code: 127, timedOut: false });
+            return;
+        }
+        const seconds = Number(timeoutText);
+        let timedOut = false;
+        let killTimer;
+        let timeoutTimer;
+        if (Number.isFinite(seconds)) {
+            timeoutTimer = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+                killTimer = setTimeout(() => child.kill("SIGKILL"), 1000);
+            }, Math.max(0, seconds) * 1000);
+            timeoutTimer.unref();
+        }
+        child.once("error", () => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            fs.writeSync(logFd, "hq: command not found\n");
+            resolve({ code: 127, timedOut });
+        });
+        child.once("exit", (code, signal) => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({ code: exitCode(code, signal), timedOut });
+        });
+    });
+}
+function openLog(log) {
+    try {
+        fs.mkdirSync(path.dirname(log), { recursive: true });
+    }
+    catch { /* the shell ignores mkdir failure */ }
+    try {
+        return fs.openSync(log, "a");
+    }
+    catch (cause) {
+        return fail(String(cause.message));
+    }
+}
+function header(deps, root, kind, timeout, mode = "") {
+    return `\n--- handoff-sync-${kind} ${deps.now().toISOString().replace(/\.\d{3}Z$/, "Z")} hq_root=${root} ${mode ? `mode=${mode} ` : ""}timeout=${timeout}s ---\n`;
+}
+function resolveRoot(root, deps) {
+    return root || (deps.env.HQ_ROOT ?? deps.cwd);
+}
+function commandOnPath(name, env) {
+    const pathKey = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+    const searchPath = pathKey ? env[pathKey] ?? "" : "";
+    const windows = process.platform === "win32";
+    const pathExtKey = Object.keys(env).find((key) => key.toUpperCase() === "PATHEXT");
+    const extensions = windows
+        ? (pathExtKey ? env[pathExtKey] ?? ".COM;.EXE;.BAT;.CMD" : ".COM;.EXE;.BAT;.CMD").split(";")
+        : [""];
+    const names = windows && path.extname(name) ? [name] : extensions.map((extension) => `${name}${extension}`);
+    for (const directory of searchPath.split(path.delimiter)) {
+        for (const executable of names) {
+            try {
+                const target = path.join(directory || ".", executable);
+                fs.accessSync(target, windows ? fs.constants.F_OK : fs.constants.X_OK);
+                if (fs.statSync(target).isFile())
+                    return true;
+            }
+            catch {
+                // command -v advances through the path when an entry is absent or unusable.
+            }
+        }
+    }
+    return false;
+}
+export async function runHandoffSyncPrefetch(args, hqRoot, deps = defaults()) {
+    const parsed = parseArgs(args, "prefetch", deps.env);
+    if ("code" in parsed)
+        return parsed;
+    if (!commandOnPath("hq", deps.env))
+        return result(0, "missing-cli\n");
+    const root = resolveRoot(parsed.root || hqRoot, deps);
+    const fd = openLog(parsed.log);
+    if (typeof fd !== "number")
+        return fd;
+    try {
+        fs.writeSync(fd, header(deps, root, "prefetch", parsed.timeout));
+        const run = await runWithTimeout(deps, fd, parsed.timeout, ["sync", "pull", "--personal", "--hq-root", root, "--lock-timeout", "0"]);
+        fs.writeSync(fd, `exit=${run.timedOut ? 124 : run.code}\n`);
+        const text = fs.readFileSync(parsed.log, "utf8");
+        if (run.timedOut)
+            return result(0, "timed-out\n");
+        if (run.code === 0)
+            return result(0, "ok\n");
+        return result(0, /not logged in|no cached session|refused immediately|requires login/i.test(text) ? "skipped\n" : `error:${run.code}\n`);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export async function runHandoffSyncPublish(args, hqRoot, deps = defaults()) {
+    const parsed = parseArgs(args, "publish", deps.env);
+    if ("code" in parsed)
+        return parsed;
+    if (!commandOnPath("hq", deps.env))
+        return result(0);
+    const root = resolveRoot(parsed.root || hqRoot, deps);
+    const fd = openLog(parsed.log);
+    if (typeof fd !== "number")
+        return fd;
+    if (!parsed.child)
+        fs.writeSync(fd, header(deps, root, "publish", parsed.timeout, parsed.sync ? "sync" : "background"));
+    if (!parsed.sync) {
+        fs.closeSync(fd);
+        let output;
+        try {
+            output = fs.openSync(parsed.log, "a");
+        }
+        catch (cause) {
+            return fail(String(cause.message));
+        }
+        let child;
+        try {
+            const args = ["core", "--hq-root", root, "handoff-sync-publish", "--timeout", parsed.timeout, "--log", parsed.log, "--child"];
+            const plan = buildSpawnPlan("hq", args);
+            child = deps.spawn(plan.cmd, plan.args, {
+                cwd: deps.cwd, env: deps.env, detached: true, windowsHide: true, stdio: ["ignore", output, output],
+                shell: plan.shell,
+                ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+            });
+        }
+        catch {
+            if (typeof output === "number")
+                fs.closeSync(output);
+            return fail("handoff-sync-publish: failed to detach hq");
+        }
+        fs.closeSync(output);
+        return new Promise((resolve) => {
+            child.once("spawn", () => { child.unref(); resolve(result(0, `${child.pid ?? 0}\n`)); });
+            child.once("error", () => resolve(result(0, `${child.pid ?? 0}\n`)));
+        });
+    }
+    try {
+        const run = await runWithTimeout(deps, fd, parsed.timeout, ["sync", "push", "--personal", "--hq-root", root, "--lock-timeout", "0", "--message", "handoff continuity pointer"]);
+        fs.writeSync(fd, `exit=${run.timedOut ? 124 : run.code}\n`);
+        return result(run.timedOut ? 124 : run.code);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export const __handoffSyncTest = { parseArgs, exitCode, runWithTimeout, openLog, header, resolveRoot, commandOnPath };
+//# sourceMappingURL=core-bucket-c-handoff-sync-native.js.map

package/dist/commands/core-bucket-c-small-fast.d.ts

@@ -0,0 +1,5 @@
+import { KNOWLEDGE_PULSE_LOCK_ASSET, runKnowledgePulseLock, runSkillInstalled, SKILL_INSTALLED_ASSET } from "./core-bucket-c-small-native.js";
+export { KNOWLEDGE_PULSE_LOCK_ASSET, SKILL_INSTALLED_ASSET, runKnowledgePulseLock, runSkillInstalled };
+export declare function runKnowledgePulseLockFast(args: string[], _stdin: string, _cwd: string, _root: string): number;
+export declare function runSkillInstalledFast(args: string[], _stdin: string, _cwd: string, root: string): Promise<number>;
+//# sourceMappingURL=core-bucket-c-small-fast.d.ts.map