@indigoai-us/hq-cli 5.345.127 → 5.345.129

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

@@ -0,0 +1,284 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+export const HANDOFF_KNOWLEDGE_COMMIT_ASSET = "core/scripts/handoff-knowledge-commit.sh";
+const USAGE = "Usage: handoff-knowledge-commit.sh --files-touched-json-file <path> [--root <hq-root>]";
+const fail = (message, code = 1) => ({ code, stdout: "", stderr: message + "\n" });
+const gitDefault = (args, cwd) => spawnSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+const text = (value) => typeof value === "string" ? value : value.toString("utf8");
+function canonicalPath(value) {
+    const slashPath = value.replaceAll("\\", "/");
+    const withoutExtendedPrefix = slashPath.startsWith("//?/UNC/")
+        ? `//${slashPath.slice("//?/UNC/".length)}`
+        : slashPath.startsWith("//?/") ? slashPath.slice("//?/".length) : slashPath;
+    const msysPath = withoutExtendedPrefix.match(/^\/([A-Za-z])\/(.*)$/);
+    const nativePath = msysPath ? `${msysPath[1]}:/${msysPath[2]}` : withoutExtendedPrefix;
+    if (/^[A-Za-z]:[\\/]/.test(nativePath) || nativePath.startsWith("\\\\")) {
+        return path.win32.resolve(nativePath).replaceAll("\\", "/").toLowerCase();
+    }
+    return path.resolve(nativePath);
+}
+function samePath(left, right) {
+    if (process.platform === "win32") {
+        const resolveWindowsAliases = (value) => {
+            try {
+                return fs.realpathSync.native(value).replaceAll("\\", "/").toLowerCase();
+            }
+            catch {
+                return value;
+            }
+        };
+        const windowsPath = (value) => {
+            const slashPath = value.replaceAll("\\", "/");
+            const withoutExtendedPrefix = slashPath.startsWith("//?/UNC/")
+                ? `//${slashPath.slice("//?/UNC/".length)}`
+                : slashPath.startsWith("//?/") ? slashPath.slice("//?/".length) : slashPath;
+            const msysPath = withoutExtendedPrefix.match(/^\/([A-Za-z])\/(.*)$/);
+            const nativePath = msysPath ? `${msysPath[1]}:/${msysPath[2]}` : withoutExtendedPrefix;
+            return nativePath.replace(/\/$/, "").toLowerCase();
+        };
+        return windowsPath(resolveWindowsAliases(left)) === windowsPath(resolveWindowsAliases(right));
+    }
+    return canonicalPath(left) === canonicalPath(right);
+}
+function windowsNativePath(value) {
+    const msysPath = value.match(/^\/([A-Za-z])\/(.*)$/);
+    return msysPath ? path.win32.normalize(`${msysPath[1].toUpperCase()}:/${msysPath[2]}`) : value;
+}
+function safePath(value) {
+    return typeof value === "string" && value.length > 0 && !value.startsWith("/")
+        && !value.includes("\n") && !value.includes("\r")
+        && value.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function validChangeset(value) {
+    return Array.isArray(value) && value.every((entry) => safePath(entry) || Boolean(entry && typeof entry === "object" && safePath(entry.path)));
+}
+function readChangeset(file) {
+    try {
+        return { value: JSON.parse(fs.readFileSync(file, "utf8")) };
+    }
+    catch (cause) {
+        return { error: String(cause.message) };
+    }
+}
+function stripTrailingCrFromChangesetPaths(value) {
+    if (!Array.isArray(value))
+        return value;
+    return value.map((entry) => {
+        if (typeof entry === "string")
+            return entry.replace(/\r$/, "");
+        if (entry && typeof entry === "object" && typeof entry.path === "string") {
+            return { ...entry, path: entry.path.replace(/\r$/, "") };
+        }
+        return entry;
+    });
+}
+function entriesUnder(root) {
+    const paths = [];
+    for (const parent of ["core/knowledge/public", "core/knowledge/private", "personal/knowledge"]) {
+        const dir = path.join(root, parent);
+        try {
+            for (const name of fs.readdirSync(dir))
+                paths.push(path.join(dir, name));
+        }
+        catch { /* absent subtree */ }
+    }
+    const companies = path.join(root, "companies");
+    try {
+        for (const company of fs.readdirSync(companies)) {
+            const knowledge = path.join(companies, company, "knowledge");
+            try {
+                fs.lstatSync(knowledge);
+                paths.push(knowledge);
+            }
+            catch { /* company has no knowledge root */ }
+        }
+    }
+    catch { /* no companies tree */ }
+    return paths;
+}
+function gitText(git, args, cwd) {
+    const result = git(args, cwd);
+    return result.status === 0 ? text(result.stdout) : "";
+}
+function gitRoot(git, cwd) {
+    const root = gitText(git, ["rev-parse", "--show-toplevel"], cwd).trim();
+    return process.platform === "win32" ? windowsNativePath(root) : root;
+}
+function statusPaths(git, repo, relative) {
+    const status = git(["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", relative], repo);
+    if (status.status !== 0)
+        return { paths: [], originals: [] };
+    const parts = text(status.stdout).split("\0");
+    const paths = [];
+    const originals = [];
+    for (let index = 0; index < parts.length; index += 1) {
+        const entry = parts[index];
+        if (!entry)
+            continue;
+        const file = entry.slice(3);
+        paths.push(file);
+        if (/[RC]/.test(entry.slice(0, 2)) && parts[index + 1])
+            originals.push(parts[++index]);
+    }
+    return { paths, originals };
+}
+function expandTouched(git, repo, knowledgeRel, touched) {
+    const relative = touched.startsWith(knowledgeRel + "/") ? touched.slice(knowledgeRel.length + 1) : "";
+    if (!relative)
+        return { paths: [], handled: [] };
+    const abs = path.join(repo, relative);
+    try {
+        if (fs.statSync(abs).isDirectory()) {
+            const changed = statusPaths(git, repo, relative);
+            const paths = [...changed.paths, ...changed.originals].filter((value) => value.startsWith(relative + "/"));
+            return { paths, handled: paths.map((value) => knowledgeRel + "/" + value) };
+        }
+    }
+    catch { /* deleted paths are handled by git ls-files below */ }
+    const exists = fs.existsSync(abs);
+    if (!exists && git(gitArgs("ls-files", "--error-unmatch", "--", relative), repo).status !== 0)
+        return { paths: [], handled: [] };
+    return { paths: [relative], handled: [touched] };
+}
+function gitArgs(...args) { return args; }
+function parseNulPaths(status) {
+    const parts = status.split("\0");
+    const paths = [];
+    const originals = [];
+    for (let index = 0; index < parts.length; index += 1) {
+        const entry = parts[index];
+        if (!entry)
+            continue;
+        const name = entry.slice(3);
+        paths.push(name);
+        if (/[RC]/.test(entry.slice(0, 2)) && parts[index + 1])
+            originals.push(parts[++index]);
+    }
+    return { paths, originals };
+}
+function commitKnowledge(git, root, changes, handled, output) {
+    for (const entry of entriesUnder(root)) {
+        let stat;
+        try {
+            stat = fs.lstatSync(entry);
+        }
+        catch {
+            continue;
+        }
+        const relative = path.relative(root, entry).split(path.sep).join("/");
+        if (stat.isSymbolicLink()) {
+            if (relative.startsWith("companies/") && relative.endsWith("/knowledge")) {
+                output.stdout.push("INVALID-LINK: " + relative + " is a symlink; company knowledge must be a plain directory synced through the company vault\n");
+                continue;
+            }
+            const repo = gitRoot(git, entry);
+            if (!repo)
+                continue;
+            const repoReal = fs.realpathSync(repo);
+            const hqRepo = gitRoot(git, root);
+            if (hqRepo && samePath(repoReal, fs.realpathSync(hqRepo)))
+                continue;
+            const dirty = gitText(git, ["status", "--porcelain"], repo).trim();
+            if (dirty)
+                output.stdout.push("INVALID-DIRTY: " + relative + " is a legacy knowledge symlink to " + repo + " with uncommitted changes — NOT auto-committed; run hq reindex to materialize it, then commit, before archiving this session\n");
+            continue;
+        }
+        if (relative.startsWith("companies/") && relative.endsWith("/knowledge"))
+            continue;
+        if (!fs.existsSync(path.join(entry, ".git")))
+            continue;
+        const repo = gitRoot(git, entry);
+        if (!repo || !samePath(fs.realpathSync(entry), fs.realpathSync(repo)))
+            continue;
+        const repoPaths = [];
+        for (const touched of changes) {
+            if (!touched.startsWith(relative + "/"))
+                continue;
+            const expanded = expandTouched(git, repo, relative, touched);
+            repoPaths.push(...expanded.paths);
+            expanded.handled.forEach((item) => handled.add(item));
+        }
+        if (!repoPaths.length)
+            continue;
+        const changed = git(["status", "--porcelain", "--", ...repoPaths], repo);
+        if (changed.status !== 0 || !text(changed.stdout).trim())
+            continue;
+        const add = git(["add", "--", ...repoPaths], repo);
+        if (add.status !== 0) {
+            output.stderr.push(text(add.stderr));
+            return { code: add.status ?? 1, stdout: output.stdout.join(""), stderr: output.stderr.join("") };
+        }
+        const commit = git(["commit", "--only", "-m", "checkpoint: save session knowledge changes", "--", ...repoPaths], repo);
+        output.stdout.push(text(commit.stdout));
+        output.stderr.push(text(commit.stderr));
+        if (commit.status !== 0)
+            return { code: commit.status ?? 1, stdout: output.stdout.join(""), stderr: output.stderr.join("") };
+    }
+    return undefined;
+}
+export function runHandoffKnowledgeCommit(args, cwd = process.cwd(), git = gitDefault) {
+    let changesFile = "";
+    let root = cwd;
+    for (let index = 0; index < args.length;) {
+        const flag = args[index];
+        if (flag === "--files-touched-json-file" || flag === "--root") {
+            if (index + 1 >= args.length)
+                return fail(USAGE, 2);
+            if (flag === "--files-touched-json-file")
+                changesFile = args[index + 1];
+            else
+                root = args[index + 1];
+            index += 2;
+        }
+        else
+            return fail(USAGE, 2);
+    }
+    if (!changesFile)
+        return fail(USAGE, 2);
+    const changesPath = path.resolve(cwd, changesFile);
+    if (!fs.existsSync(changesPath) || !fs.statSync(changesPath).isFile())
+        return fail(USAGE, 2);
+    try {
+        root = fs.realpathSync(root);
+    }
+    catch {
+        return fail(String((new Error("No such file or directory")).message));
+    }
+    const rawParsed = readChangeset(changesPath);
+    const parsed = rawParsed.value === undefined ? rawParsed : { ...rawParsed, value: stripTrailingCrFromChangesetPaths(rawParsed.value) };
+    if (parsed.error || !validChangeset(parsed.value)) {
+        const stdout = [];
+        if (Array.isArray(parsed.value)) {
+            for (const entry of parsed.value) {
+                const candidate = typeof entry === "string" ? entry : entry && typeof entry === "object" ? entry.path : undefined;
+                if (!safePath(candidate))
+                    stdout.push("  offending entry: " + JSON.stringify(entry) + "\n");
+                if (stdout.length >= 5)
+                    break;
+            }
+        }
+        return {
+            code: 1,
+            stdout: "",
+            stderr: "handoff knowledge commit: changeset must be an array of safe relative file paths (files, not folders: no trailing slash, no absolute paths, no .. segments)\n" + stdout.join(""),
+        };
+    }
+    const changes = parsed.value.map((entry) => {
+        const touched = typeof entry === "string" ? entry : entry.path;
+        return touched;
+    });
+    const output = { stdout: [], stderr: [] };
+    const handled = new Set();
+    const commitFailure = commitKnowledge(git, root, changes, handled, output);
+    if (commitFailure)
+        return commitFailure;
+    for (const touched of changes) {
+        if (/^(core\/knowledge\/public|core\/knowledge\/private|personal\/knowledge)\//.test(touched) && !handled.has(touched)) {
+            output.stdout.push("NOT-COMMITTED: " + touched + " is listed in the handoff changeset but no knowledge repository committed it\n");
+        }
+    }
+    return { code: 0, stdout: output.stdout.join(""), stderr: output.stderr.join("") };
+}
+export const __handoffKnowledgeTest = { safePath, validChangeset, entriesUnder, statusPaths, parseNulPaths, expandTouched, gitRoot, samePath, windowsNativePath };
+//# sourceMappingURL=core-bucket-c-handoff-knowledge-native.js.map

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

@@ -0,0 +1,2 @@
+export declare function runHqDetachFast(args: string[]): Promise<number>;
+//# sourceMappingURL=core-bucket-c-hq-detach-fast.d.ts.map

package/dist/commands/core-bucket-c-hq-detach-fast.js

@@ -0,0 +1,10 @@
+import { runHqDetach } from "./core-bucket-c-hq-detach-native.js";
+export async function runHqDetachFast(args) {
+    const result = await runHqDetach(args);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-bucket-c-hq-detach-fast.js.map

package/dist/commands/core-bucket-c-hq-detach-native.d.ts

@@ -0,0 +1,43 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+export declare const HQ_DETACH_ASSET = "core/scripts/hq-detach.sh";
+export type HqDetachResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+type SyncResult = {
+    status: number | null;
+    stdout?: string | Buffer;
+};
+type Dependencies = {
+    spawnSync: (command: string, args: string[], options: Record<string, unknown>) => SyncResult;
+    spawn: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+    platform: NodeJS.Platform;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+};
+declare function parseArgs(args: readonly string[]): {
+    handoff: boolean;
+    pidFile: string;
+    ownerPidFile: string;
+    logFile: string;
+    command: string[];
+} | HqDetachResult;
+declare function findExecutable(name: string, env: NodeJS.ProcessEnv): string | undefined;
+declare function processArgs(deps: Dependencies, pid: string): string;
+declare function isSessionCommand(command: string): boolean;
+declare function writeOwner(deps: Dependencies, ownerFile: string): void;
+declare function isWindowsShell(deps: Dependencies): boolean;
+declare function spawnDetached(deps: Dependencies, command: string, args: string[], logFile: string, detached: boolean): Promise<number | undefined>;
+export declare function runHqDetach(args: readonly string[], deps?: Dependencies): Promise<HqDetachResult>;
+export declare const __hqDetachTest: {
+    parseArgs: typeof parseArgs;
+    isSessionCommand: typeof isSessionCommand;
+    findExecutable: typeof findExecutable;
+    processArgs: typeof processArgs;
+    writeOwner: typeof writeOwner;
+    isWindowsShell: typeof isWindowsShell;
+    spawnDetached: typeof spawnDetached;
+};
+export {};
+//# sourceMappingURL=core-bucket-c-hq-detach-native.d.ts.map

package/dist/commands/core-bucket-c-hq-detach-native.js

@@ -0,0 +1,241 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+export const HQ_DETACH_ASSET = "core/scripts/hq-detach.sh";
+const HELP = [
+    "hq-core: public",
+    "hq-detach.sh — detach a command from the parent turn so its cleanup sweep",
+    "cannot reap it. Linux has setsid(1); stock macOS does not.",
+    "",
+    "Usage:",
+    "  bash core/scripts/hq-detach.sh [--handoff] [--pidfile PATH] [--owner-pidfile PATH] [--logfile PATH] -- <command>...",
+    "",
+    "The child leads its own session (sid == pgid == pid of the session leader).",
+    "stdin is /dev/null. stdout/stderr go to --logfile or /dev/null.",
+    "--handoff uses nohup on Linux/macOS and a hidden Node child on Git Bash/MSYS/Cygwin.",
+    "",
+    "set -euo pipefail",
+    "",
+].join("\n");
+const result = (code, stdout = "", stderr = "") => ({ code, stdout, stderr });
+const fail = (message, code = 1) => result(code, "", message + "\n");
+function parseArgs(args) {
+    let handoff = false;
+    let pidFile = "";
+    let ownerPidFile = "";
+    let logFile = "/dev/null";
+    for (let index = 0; index < args.length;) {
+        const token = args[index];
+        if (token === "--handoff") {
+            handoff = true;
+            index += 1;
+            continue;
+        }
+        if (token === "--pidfile" || token === "--owner-pidfile" || token === "--logfile") {
+            if (index + 1 >= args.length)
+                return result(1);
+            const value = args[index + 1];
+            if (token === "--pidfile")
+                pidFile = value;
+            else if (token === "--owner-pidfile")
+                ownerPidFile = value;
+            else
+                logFile = value;
+            index += 2;
+            continue;
+        }
+        if (token === "--")
+            return { handoff, pidFile, ownerPidFile, logFile, command: args.slice(index + 1) };
+        if (token === "-h" || token === "--help")
+            return result(0, HELP + "\n");
+        return fail("hq-detach: unexpected argument: " + token + " (use -- before the command)", 2);
+    }
+    return result(2, "", "hq-detach: missing command after --\n");
+}
+function findExecutable(name, env) {
+    const candidates = path.isAbsolute(name) ? [name] : (env.PATH ?? "").split(path.delimiter).map((dir) => path.join(dir, name));
+    for (const candidate of candidates) {
+        try {
+            fs.accessSync(candidate, process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+            return candidate;
+        }
+        catch { /* continue through PATH */ }
+    }
+    return undefined;
+}
+function processArgs(deps, pid) {
+    const listing = deps.spawnSync("ps", ["-eww", "-o", "pid=,args="], { cwd: deps.cwd, env: deps.env, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (listing.status !== 0)
+        return "";
+    const text = typeof listing.stdout === "string" ? listing.stdout : Buffer.from(listing.stdout ?? "").toString("utf8");
+    for (const line of text.split(/\r?\n/)) {
+        const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+        if (match?.[1] === pid)
+            return match[2];
+    }
+    return "";
+}
+function isSessionCommand(command) {
+    const [exe = "", script = "", third = ""] = command.trim().split(/\s+/);
+    const names = new Set(["claude", "codex", "codex-code-mode-host", "grok", "grok-cli"]);
+    const base = (value) => path.basename(value.replaceAll("\\", "/"));
+    if (names.has(base(exe)))
+        return true;
+    if (["bash", "sh", "zsh", "dash", "ksh", "node"].includes(base(exe)) && names.has(base(script)))
+        return true;
+    if (base(exe) === "env") {
+        if (names.has(base(script)))
+            return true;
+        return ["bash", "sh", "zsh", "dash", "ksh"].includes(base(script)) && names.has(base(third));
+    }
+    return false;
+}
+function writeFile(file, contents) {
+    if (!file)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+    }
+    catch { /* shell ignores mkdir failure */ }
+    fs.writeFileSync(file, contents);
+}
+function writeOwner(deps, ownerFile) {
+    if (!ownerFile)
+        return;
+    let candidate = String(process.ppid);
+    let hops = 0;
+    while (candidate && candidate !== "0" && candidate !== "1" && hops < 24) {
+        const args = processArgs(deps, candidate);
+        if (isSessionCommand(args)) {
+            const started = deps.spawnSync("ps", ["-o", "lstart=", "-p", candidate], { cwd: deps.cwd, env: deps.env, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+            const start = String(started.stdout ?? "").trim();
+            if (start)
+                writeFile(ownerFile, candidate + "\n" + start + "\n");
+            return;
+        }
+        const parent = deps.spawnSync("ps", ["-o", "ppid=", "-p", candidate], { cwd: deps.cwd, env: deps.env, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        candidate = String(parent.stdout ?? "").trim();
+        hops += 1;
+    }
+}
+function isWindowsShell(deps) {
+    if (deps.platform === "win32")
+        return true;
+    const uname = deps.spawnSync("uname", ["-s"], { cwd: deps.cwd, env: deps.env, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return /^(MINGW|MSYS|CYGWIN)/.test(String(uname.stdout ?? "").trim());
+}
+function spawnDetached(deps, command, args, logFile, detached) {
+    return new Promise((resolve) => {
+        let output = "ignore";
+        try {
+            if (logFile !== "/dev/null")
+                output = fs.openSync(logFile, "a");
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        let child;
+        try {
+            child = deps.spawn(command, args, {
+                cwd: deps.cwd, env: deps.env, detached,
+                windowsHide: deps.platform === "win32" || deps.env.HQ_DETACH_WINDOWS_SHELL === "1",
+                stdio: ["ignore", output, output],
+            });
+        }
+        catch {
+            if (typeof output === "number")
+                fs.closeSync(output);
+            resolve(undefined);
+            return;
+        }
+        if (typeof output === "number")
+            fs.closeSync(output);
+        let done = false;
+        child.once("spawn", () => {
+            if (typeof child.pid !== "number") {
+                done = true;
+                resolve(undefined);
+                return;
+            }
+            child.unref();
+            done = true;
+            resolve(child.pid);
+        });
+        child.once("error", () => { if (!done) {
+            done = true;
+            resolve(undefined);
+        } });
+    });
+}
+const defaults = () => ({
+    spawnSync: (command, args, options) => spawnSync(command, args, options),
+    spawn: (command, args, options) => spawn(command, args, options),
+    platform: process.platform, cwd: process.cwd(), env: process.env,
+});
+export async function runHqDetach(args, deps = defaults()) {
+    const parsed = parseArgs(args);
+    if ("code" in parsed)
+        return parsed;
+    if (!parsed.command.length)
+        return fail("hq-detach: missing command after --", 2);
+    writeOwner(deps, parsed.ownerPidFile);
+    const handoffWindows = parsed.handoff && isWindowsShell(deps);
+    if (parsed.handoff && !handoffWindows) {
+        const pid = await spawnDetached(deps, "nohup", parsed.command, parsed.logFile, false);
+        if (pid === undefined)
+            return fail("hq-detach: failed to spawn detached command");
+        try {
+            writeFile(parsed.pidFile, String(pid) + "\n");
+        }
+        catch (cause) {
+            return fail(String(cause.message));
+        }
+        return result(0);
+    }
+    let setsid = "";
+    if (deps.env.HQ_DETACH_FORCE_NODE !== "1" && !handoffWindows) {
+        for (const candidate of ["setsid", "/opt/homebrew/opt/util-linux/bin/setsid", "/usr/local/opt/util-linux/bin/setsid"]) {
+            const found = findExecutable(candidate, deps.env);
+            if (found) {
+                setsid = found;
+                break;
+            }
+        }
+    }
+    if (setsid) {
+        const pid = await spawnDetached(deps, setsid, parsed.command, parsed.logFile, false);
+        if (pid === undefined)
+            return fail("hq-detach: failed to spawn detached command");
+        try {
+            writeFile(parsed.pidFile, String(pid) + "\n");
+        }
+        catch (cause) {
+            return fail(String(cause.message));
+        }
+        return result(0);
+    }
+    const node = deps.env.HQ_DETACH_NODE?.trim() || "node";
+    if (!findExecutable(node, deps.env))
+        return fail("hq-detach: neither setsid(1) nor " + node + " is available");
+    let logfile = parsed.logFile;
+    if (handoffWindows && logfile !== "/dev/null" && findExecutable("cygpath", deps.env)) {
+        const converted = deps.spawnSync("cygpath", ["-m", logfile], { cwd: deps.cwd, env: deps.env, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        if (converted.status === 0 && String(converted.stdout ?? "").trim())
+            logfile = String(converted.stdout).trim();
+    }
+    const env = { ...deps.env, HQ_DETACH_LOGFILE: logfile, ...(handoffWindows ? { HQ_DETACH_WINDOWS_SHELL: "1" } : {}) };
+    const childDeps = { ...deps, env };
+    const pid = await spawnDetached(childDeps, parsed.command[0], parsed.command.slice(1), logfile, true);
+    if (pid === undefined)
+        return fail("hq-detach: failed to spawn detached command");
+    try {
+        writeFile(parsed.pidFile, String(pid) + "\n");
+    }
+    catch (cause) {
+        return fail(String(cause.message));
+    }
+    return result(0);
+}
+export const __hqDetachTest = { parseArgs, isSessionCommand, findExecutable, processArgs, writeOwner, isWindowsShell, spawnDetached };
+//# sourceMappingURL=core-bucket-c-hq-detach-native.js.map

package/dist/commands/core-bucket-c-work-mesh-offer-native.js

@@ -37,8 +37,14 @@ function cloudUid(root, company) {
         }
         if (inCompany && /^ {2}[^\s#]/.test(line))
             break;
-        if (inCompany && /^\s+cloud_uid:/.test(line))
-            return (line.split(":")[1] ?? "").trim().replace(/["']/g, "");
+        if (inCompany) {
+            // Match the shell's awk field contract: `$1 == "cloud_uid:"` and use
+            // only `$2`. A value must be separated from the key by whitespace;
+            // trailing comments and later fields do not become part of the UID.
+            const [key, value] = line.trim().split(/\s+/);
+            if (key === "cloud_uid:")
+                return (value ?? "").replace(/["']/g, "");
+        }
     }
     return "";
 }

package/dist/commands/core.js

@@ -230,6 +230,18 @@ export const SCAFFOLD_COMMANDS = [
         root: "live",
         summary: "Publish the session continuity pointer to the personal vault",
     },
+    {
+        name: "hq-detach",
+        asset: "core/scripts/hq-detach.sh",
+        root: "cwd",
+        summary: "Detach a command from the parent turn",
+    },
+    {
+        name: "handoff-knowledge-commit",
+        asset: "core/scripts/handoff-knowledge-commit.sh",
+        root: "cwd",
+        summary: "Commit only knowledge files listed in a handoff changeset",
+    },
     {
         name: "hq-task",
         asset: "core/scripts/hq-task.sh",

package/dist/commands/daemon.js

@@ -907,6 +907,7 @@ async function runTmuxService(d, opts) {
             cwd: hqRoot,
             argv: opts.argv,
             label: opts.label,
+            restartOnToolUpdate: opts.restartOnToolUpdate,
             // Only a new version of the tool restarts the session: not a same-version
             // reinstall, and not an hq-cli release (the host's own code rarely matters).
             binaryFingerprint: () => toolFingerprint(opts.watch),
@@ -1094,6 +1095,7 @@ async function runServiceRemoteControlPoolHost(d, accountId) {
         argv: [claude, ...remoteControlPoolArgs(pool)],
         label: `claude remote-control pool ${accountId}`,
         watch: claude,
+        restartOnToolUpdate: false,
         signal: controller.signal,
         sessionEnv: {
             HOME: d.home,

package/dist/commands/lanes-accounts.js

@@ -13,7 +13,7 @@ import { accountQuotaView, clearAccountQuota, loadQuotaState } from "../lib/lane
 import { resolveLaneModel } from "../lib/lanes/spawn.js";
 import { leadLaneIds } from "../lib/lanes/admission.js";
 export function createLaneAccountsHandlers(deps) {
-    const { automaticBalanceMoveHistoryReason, ensureDir, laneWithRecoveredProviderSession, loadClaudeBalanceHostSnapshots, parseRemoteJson, prepareAccountMove, printJson, reconcileHostFromCtx, resolveCallerPath } = deps;
+    const { admitQueuedFromCtx, automaticBalanceMoveHistoryReason, ensureDir, laneWithRecoveredProviderSession, loadClaudeBalanceHostSnapshots, parseRemoteJson, prepareAccountMove, printJson, reconcileHostFromCtx, resolveCallerPath } = deps;
     const VENDOR_LOGIN = {
         claude: { command: "claude", args: ["auth", "login"] },
         codex: { command: "codex", args: ["login"] },
@@ -539,6 +539,7 @@ export function createLaneAccountsHandlers(deps) {
             });
         }
         const cleared = clearAccountQuota(ctx.hqRoot(), provider, account, model === undefined ? {} : { model });
+        const admitted = await admitQueuedFromCtx(ctx);
         printJson({
             ok: true,
             action: "accounts.clear-quota",
@@ -546,6 +547,7 @@ export function createLaneAccountsHandlers(deps) {
             account,
             all_models_quota_reset_at: cleared.all_models_quota_reset_at,
             model_quota_resets: cleared.model_quota_resets,
+            admitted,
         });
     }
     async function runAccountsEnable(ctx, providerRaw, accountId) {