@indigoai-us/hq-cli 5.312.2-beta.0 → 5.313.0

package/dist/commands/core-register-project-native.js

@@ -0,0 +1,347 @@
+/** Native implementation of core/scripts/register-project.sh. */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
+import { resolveBundledAsset } from "../utils/hq-roots.js";
+export const REGISTER_PROJECT_ASSET = "core/scripts/register-project.sh";
+const USAGE = "usage: register-project.sh <company> <project> | --audit <company> | --backfill <company> --only-active [--yes] | --retry-pending <company>";
+const MIN_HQ_CLI = "5.139.0";
+export function createRegisterProjectHqRunner(spawn = spawnSync) {
+    return (args, options) => {
+        const result = spawn("hq", args, {
+            cwd: options.cwd,
+            env: options.env,
+            encoding: "utf8",
+            // Shell hq children inherit fd 0 even when their output is captured or discarded.
+            stdio: options.capture ? ["inherit", "pipe", "pipe"] : ["inherit", "ignore", "ignore"],
+        });
+        return {
+            code: result.status ?? 127,
+            stdout: options.capture ? String(result.stdout ?? "") : "",
+            stderr: options.capture ? String(result.stderr ?? "") : "",
+        };
+    };
+}
+const defaultRunHq = createRegisterProjectHqRunner();
+function errorResult(message, code = 1) { return { code, stdout: "", stderr: `${message}\n` }; }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function jqOr(value, fallback) { return value === null || value === undefined || value === false ? fallback : value; }
+function jqString(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined || value === false)
+        return "";
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+function readJson(fileSystem, file) {
+    return JSON.parse(fileSystem.readFileSync(file, "utf8"));
+}
+function timestamp(deps) { return deps.now().toISOString().replace(/\.\d{3}Z$/, "Z"); }
+function companyUid(company, deps) {
+    const direct = deps.env.HQ_COMPANY_UID ?? "";
+    if (direct)
+        return direct;
+    const file = path.join(deps.root, "companies", company, ".company-uid");
+    try {
+        return deps.fs.readFileSync(file, "utf8").replace(/[\s\u0085\u00a0]+/g, "");
+    }
+    catch {
+        return null;
+    }
+}
+function boardPath(company, deps) { return path.join(deps.root, "companies", company, "board.json"); }
+function runHelpProbe(deps) {
+    return deps.runHq(["mesh", "project", "ensure", "--help"], { cwd: deps.cwd, env: deps.env, capture: false }).code === 0;
+}
+function prdName(prd, deps) {
+    const value = readJson(deps.fs, prd);
+    return jqString(jqOr(asRecord(value)?.name, ""));
+}
+function boardData(company, board, deps) {
+    if (!deps.fs.existsSync(board))
+        return { company, projects: [] };
+    const value = asRecord(readJson(deps.fs, board));
+    if (!value)
+        throw new Error("board.json must contain an object");
+    return value;
+}
+function projectRows(board) {
+    const projects = jqOr(board.projects, []);
+    if (!Array.isArray(projects))
+        throw new Error("board.json projects must be an array");
+    return projects.map((item) => {
+        const record = asRecord(item);
+        if (!record)
+            throw new Error("board.json project must be an object");
+        return record;
+    });
+}
+function matchesProject(row, id, rel) {
+    return row.id === id || row.prd_path === rel || row.mesh_project_id === id;
+}
+function atomicJqWrite(target, value, deps, initialize = false) {
+    deps.fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (initialize && !deps.fs.existsSync(target))
+        deps.fs.writeFileSync(target, serializeJqJson(value, "pretty"), { encoding: "utf8", mode: 0o666 });
+    const temporary = path.join(path.dirname(target), `.register-project.${process.pid}.${Math.random().toString(16).slice(2)}`);
+    deps.fs.writeFileSync(temporary, serializeJqJson(value, "pretty"), { encoding: "utf8", mode: 0o600, flag: "wx" });
+    deps.fs.chmodSync(temporary, 0o600);
+    deps.fs.renameSync(temporary, target);
+}
+function markPending(company, project, deps) {
+    const board = boardPath(company, deps);
+    const prd = path.join(deps.root, "companies", company, "projects", project, "prd.json");
+    const rel = `companies/${company}/projects/${project}/prd.json`;
+    const now = timestamp(deps);
+    let title = "";
+    try {
+        title = prdName(prd, deps);
+    }
+    catch { /* shell suppresses title jq errors */ }
+    if (!title)
+        title = project;
+    const document = boardData(company, board, deps);
+    const rows = projectRows(document);
+    if (rows.some((row) => matchesProject(row, project, rel))) {
+        document.projects = rows.map((row) => matchesProject(row, project, rel)
+            ? { ...row, pending_registration: true, updated_at: now, prd_path: jqOr(row.prd_path, rel) }
+            : row);
+    }
+    else {
+        document.projects = [...rows, {
+                id: project, title, status: "prd_created", scope: "company", prd_path: rel,
+                pending_registration: true, created_at: now, updated_at: now,
+            }];
+    }
+    atomicJqWrite(board, document, deps, true);
+}
+function ensureOne(company, project, deps) {
+    const prd = path.join(deps.root, "companies", company, "projects", project, "prd.json");
+    if (!deps.fs.existsSync(prd))
+        return errorResult(`registration incomplete: missing ${prd}`);
+    if (!runHelpProbe(deps)) {
+        try {
+            markPending(company, project, deps);
+        }
+        catch { /* legacy jq/write errors remain a failed registration */ }
+        return errorResult(`hq-cli ${MIN_HQ_CLI} or newer is required; ${company}/${project} stays local until then`);
+    }
+    const ensure = deps.runHq(["mesh", "project", "ensure", project, "--company", company, "--stories-file", prd, "--json"], {
+        cwd: deps.cwd, env: deps.env, capture: true,
+    });
+    if (ensure.code !== 0)
+        return errorResult(`registration incomplete: hq mesh project ensure failed for ${company}/${project}`);
+    let result;
+    try {
+        result = asRecord(JSON.parse(ensure.stdout));
+    }
+    catch {
+        return errorResult("registration incomplete: ensure output missing threadId");
+    }
+    if (result?.threadId === null || result?.threadId === undefined || result?.threadId === false)
+        return errorResult("registration incomplete: ensure output missing threadId");
+    if (result?.channelId === null || result?.channelId === undefined || result?.channelId === false)
+        return errorResult("registration incomplete: ensure output missing channelId");
+    const thread = jqString(result.threadId);
+    const channel = jqString(result.channelId);
+    if (!thread)
+        return errorResult("registration incomplete: empty threadId");
+    if (!channel)
+        return errorResult("registration incomplete: empty channelId");
+    const board = boardPath(company, deps);
+    const rel = `companies/${company}/projects/${project}/prd.json`;
+    const now = timestamp(deps);
+    let title = prdName(prd, deps);
+    if (!title)
+        title = project;
+    const document = boardData(company, board, deps);
+    const rows = projectRows(document);
+    if (rows.some((row) => matchesProject(row, project, rel))) {
+        document.projects = rows.map((row) => {
+            if (!matchesProject(row, project, rel))
+                return row;
+            const updated = { ...row, threadId: thread, channelId: channel, updated_at: now, prd_path: jqOr(row.prd_path, rel), mesh_project_id: project };
+            delete updated.pending_registration;
+            return updated;
+        });
+    }
+    else {
+        document.projects = [...rows, {
+                id: project, title, status: "prd_created", scope: "company", prd_path: rel,
+                threadId: thread, channelId: channel, mesh_project_id: project, created_at: now, updated_at: now,
+            }];
+    }
+    try {
+        atomicJqWrite(board, document, deps, true);
+    }
+    catch {
+        return errorResult("registration incomplete: board.json write failed");
+    }
+    const written = boardData(company, board, deps);
+    const verified = projectRows(written).some((row) => matchesProject(row, project, rel) && row.threadId === thread && row.channelId === channel);
+    if (!verified)
+        return errorResult(`registration incomplete: board.json entry for ${project} did not verify`);
+    return { code: 0, stdout: `registered ${company}/${project} thread=${thread} channel=${channel}\n`, stderr: "" };
+}
+function audit(company, deps) {
+    if (!company)
+        return errorResult("usage: register-project.sh --audit <company>");
+    const directory = path.join(deps.root, "companies", company, "projects");
+    let projects;
+    try {
+        projects = deps.fs.readdirSync(directory).sort();
+    }
+    catch {
+        return { code: 0, stdout: "", stderr: "" };
+    }
+    let stderr = "";
+    const unregistered = projects.filter((project) => {
+        if (project.startsWith("."))
+            return false;
+        const prd = path.join(directory, project, "prd.json");
+        try {
+            if (!deps.fs.statSync(prd).isFile())
+                return false;
+            const uid = companyUid(company, deps);
+            if (uid === null) {
+                stderr += `no company uid for ${company} (set HQ_COMPANY_UID or companies/${company}/.company-uid)\n`;
+                return true;
+            }
+            return !deps.fs.existsSync(path.join(deps.env.HOME || os.homedir(), ".hq/work-mesh/cache/projects", uid, `${project}.json`));
+        }
+        catch {
+            return false;
+        }
+    });
+    return { code: 0, stdout: unregistered.length ? `${unregistered.join("\n")}\n` : "", stderr };
+}
+function storyNotDone(prd, deps, diagnostics) {
+    try {
+        const stories = asRecord(readJson(deps.fs, prd))?.userStories;
+        if (!Array.isArray(stories))
+            return false;
+        return stories.some((story) => jqOr(asRecord(story)?.status, "") !== "done");
+    }
+    catch {
+        const jq = spawnSync("jq", ["-e", '[.userStories[]? | select((.status // "") != "done")] | length > 0', prd], {
+            cwd: deps.cwd, env: deps.env, encoding: "utf8",
+        });
+        if (jq.stderr)
+            diagnostics.push(jq.stderr);
+        else if (jq.error?.code === "ENOENT") {
+            const script = resolveBundledAsset(REGISTER_PROJECT_ASSET);
+            diagnostics.push(`${script}: line 34: jq: command not found\n`);
+        }
+        return false;
+    }
+}
+function backfill(args, deps) {
+    let company = "", only = false, yes = false;
+    for (const arg of args) {
+        if (arg === "--only-active")
+            only = true;
+        else if (arg === "--yes")
+            yes = true;
+        else if (arg.startsWith("--"))
+            return errorResult(`unknown flag ${arg}`);
+        else
+            company = arg;
+    }
+    if (!company)
+        return errorResult("usage: register-project.sh --backfill <company> --only-active [--yes]");
+    if (!only)
+        return errorResult("--backfill requires --only-active");
+    const directory = path.join(deps.root, "companies", company, "projects");
+    let projects;
+    try {
+        projects = deps.fs.readdirSync(directory).sort();
+    }
+    catch {
+        return { code: 0, stdout: "", stderr: "" };
+    }
+    projects = projects.filter((project) => !project.startsWith("."));
+    const diagnostics = [];
+    const targets = projects.filter((project) => {
+        const pdir = path.join(directory, project);
+        const prd = path.join(pdir, "prd.json");
+        try {
+            if (!deps.fs.statSync(prd).isFile() || !storyNotDone(prd, deps, diagnostics))
+                return false;
+            return Math.floor(deps.now().getTime() / 1000) - Math.floor(deps.fs.statSync(pdir).mtimeMs / 1000) < 30 * 86400;
+        }
+        catch {
+            return false;
+        }
+    });
+    let stderr = diagnostics.join("");
+    if (!yes)
+        return { code: 0, stdout: targets.map((project) => `would register ${company}/${project}\n`).join(""), stderr };
+    let stdout = "";
+    for (const project of targets) {
+        const output = ensureOne(company, project, deps);
+        stdout += output.stdout;
+        stderr += output.stderr;
+        if (output.code !== 0)
+            return { ...output, stdout, stderr };
+    }
+    return { code: 0, stdout, stderr };
+}
+function retryPending(company, deps) {
+    if (!company)
+        return errorResult("usage: register-project.sh --retry-pending <company>");
+    if (!runHelpProbe(deps))
+        return { code: 0, stdout: "", stderr: "" };
+    const board = boardPath(company, deps);
+    if (!deps.fs.existsSync(board))
+        return { code: 0, stdout: "", stderr: "" };
+    let rows;
+    try {
+        rows = projectRows(boardData(company, board, deps));
+    }
+    catch {
+        return { code: 0, stdout: "", stderr: "" };
+    }
+    let stdout = "", stderr = "";
+    const ids = rows.filter((item) => item.pending_registration === true)
+        .map((row) => jqString(jqOr(row.id, ""))).filter(Boolean).slice(0, 3);
+    for (const id of ids) {
+        const result = ensureOne(company, id, deps);
+        stdout += result.stdout;
+        stderr += result.stderr;
+    }
+    return { code: 0, stdout, stderr };
+}
+export function runRegisterProject(args, deps) {
+    try {
+        const [mode, arg1, ...rest] = args;
+        if (mode === "--audit")
+            return audit(arg1 ?? "", deps);
+        if (mode === "--backfill")
+            return backfill([arg1 ?? "", ...rest].filter((value, index) => index > 0 || value !== ""), deps);
+        if (mode === "--retry-pending")
+            return retryPending(arg1 ?? "", deps);
+        if (args.length === 2)
+            return ensureOne(args[0], args[1], deps);
+        return errorResult(USAGE);
+    }
+    catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+    }
+}
+export async function runRegisterProjectFast(args, _stdin, cwd, root) {
+    const chosenRoot = root || process.env.HQ_ROOT || cwd;
+    const result = runRegisterProject(args, {
+        root: chosenRoot, cwd, env: process.env, fs, now: () => new Date(),
+        runHq: (argv, opts) => defaultRunHq(argv, opts),
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-register-project-native.js.map

package/dist/commands/core-work-mesh-live-rebind-native.d.ts

@@ -0,0 +1,18 @@
+/** Native implementation of core/scripts/work-mesh-live-rebind.sh. */
+import * as fs from "node:fs";
+export declare const WORK_MESH_LIVE_REBIND_ASSET = "core/scripts/work-mesh-live-rebind.sh";
+export type WorkMeshLiveRebindDeps = {
+    cwd: string;
+    root: string;
+    env: NodeJS.ProcessEnv;
+    fs: typeof fs;
+    now: () => Date;
+    ulid: (date: Date) => string;
+};
+export declare function runWorkMeshLiveRebind(args: readonly string[], deps: WorkMeshLiveRebindDeps): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runWorkMeshLiveRebindFast(args: readonly string[], _stdin: string, cwd: string, root?: string): Promise<number>;
+//# sourceMappingURL=core-work-mesh-live-rebind-native.d.ts.map

package/dist/commands/core-work-mesh-live-rebind-native.js

@@ -0,0 +1,262 @@
+/** Native implementation of core/scripts/work-mesh-live-rebind.sh. */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { generateUlid } from "../lib/mesh/live/ulid.js";
+import { formatSpoolLine } from "../lib/mesh/live/format-spool-line.js";
+export const WORK_MESH_LIVE_REBIND_ASSET = "core/scripts/work-mesh-live-rebind.sh";
+const WORK_MESH_LIVE_REBIND_LIBRARY_ASSET = "core/scripts/lib/work-mesh-live-rebind.sh";
+const USAGE = "usage: work-mesh-live-rebind.sh --session <sid> ...\n";
+function defaultDeps(root, cwd, env) {
+    return { root, cwd, env, fs, now: () => new Date(), ulid: (date) => generateUlid(date.getTime()) };
+}
+function stateRoot(deps) { return deps.env.WORK_MESH_HOME || deps.env.HOME || os.homedir(); }
+function markerPath(sid, deps) { return path.join(stateRoot(deps), ".hq/work-context/sessions", `${sid}.live-binding`); }
+class MarkerWriteError extends Error {
+    target;
+    constructor(target, cause) {
+        super("live binding marker write failed", { cause });
+        this.target = target;
+    }
+}
+function readMarker(sid, deps) {
+    try {
+        const body = deps.fs.readFileSync(markerPath(sid, deps), "utf8").replace(/\r/g, "");
+        const value = (key) => {
+            const line = body.split("\n").find((row) => row.startsWith(`${key}=`));
+            return line === undefined ? "" : line.slice(key.length + 1).split("=", 1)[0];
+        };
+        return [value("companySlug"), value("project"), value("task")];
+    }
+    catch {
+        return ["", "", ""];
+    }
+}
+function writeMarker(sid, company, project, task, deps) {
+    const target = markerPath(sid, deps);
+    const directory = path.dirname(target);
+    try {
+        deps.fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    }
+    catch { /* shell mkdir is best effort */ }
+    try {
+        deps.fs.chmodSync(directory, 0o700);
+    }
+    catch { /* shell chmod is best effort */ }
+    try {
+        deps.fs.writeFileSync(target, `companySlug=${company}\nproject=${project}\ntask=${task}\n`);
+    }
+    catch (error) {
+        throw new MarkerWriteError(target, error);
+    }
+    try {
+        deps.fs.chmodSync(target, 0o600);
+    }
+    catch { /* shell chmod is best effort */ }
+}
+function readState(sid, deps) {
+    const file = path.join(stateRoot(deps), ".hq/work-context/sessions", `${sid}.json`);
+    if (!deps.fs.existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(deps.fs.readFileSync(file, "utf8"));
+        const raw = (key) => {
+            const value = parsed?.[key];
+            if (value === null || value === undefined || value === false)
+                return "";
+            return typeof value === "string" ? value : typeof value === "object" ? JSON.stringify(value) : String(value);
+        };
+        return { company: raw("companySlug"), project: raw("projectId"), task: raw("taskId") };
+    }
+    catch {
+        return null;
+    }
+}
+function nextSeq(sid, deps) {
+    const directory = deps.env.WORK_MESH_SEQ_DIR || path.join(deps.env.HOME || os.homedir(), ".hq/work-mesh/seq");
+    try {
+        if (!deps.fs.existsSync(directory)) {
+            deps.fs.mkdirSync(directory, { recursive: true });
+            try {
+                deps.fs.chmodSync(directory, 0o700);
+            }
+            catch { /* best effort */ }
+        }
+    }
+    catch { /* next write will fail */ }
+    const file = path.join(directory, sid);
+    let current = "0";
+    try {
+        current = deps.fs.readFileSync(file, "utf8").replace(/\s/g, "");
+    }
+    catch { /* first event */ }
+    if (!/^\d+$/.test(current))
+        current = "0";
+    const value = Number(current) + 1;
+    if (!Number.isSafeInteger(value))
+        return null;
+    try {
+        deps.fs.writeFileSync(file, `${value}\n`);
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function enqueueLifecycle(kind, sid, harness, adapter, company, project, task, deps) {
+    const seq = nextSeq(sid, deps);
+    if (seq === null)
+        return false;
+    const now = deps.now();
+    const event = {
+        v: 1,
+        eventId: deps.ulid(now),
+        kind,
+        sessionId: sid,
+        harness: harness,
+        adapterVersion: adapter,
+        at: `${now.toISOString().slice(0, 19)}.000Z`,
+        seq,
+        cwd: deps.env.PWD ?? "",
+        hqRoot: deps.env.HQ_ROOT ?? deps.root,
+    };
+    if (company)
+        event.companySlug = company;
+    if (project)
+        event.project = project;
+    if (task)
+        event.task = task;
+    const spool = deps.env.WORK_MESH_SPOOL || path.join(deps.env.HOME || os.homedir(), ".hq/work-mesh/spool.jsonl");
+    try {
+        if (!deps.fs.existsSync(spool)) {
+            try {
+                deps.fs.mkdirSync(path.dirname(spool), { recursive: true, mode: 0o700 });
+            }
+            catch { /* legacy mkdir is best effort */ }
+            try {
+                deps.fs.chmodSync(path.dirname(spool), 0o700);
+            }
+            catch { /* best effort */ }
+            deps.fs.writeFileSync(spool, "", { encoding: "utf8", mode: 0o600 });
+            try {
+                deps.fs.chmodSync(spool, 0o600);
+            }
+            catch { /* best effort */ }
+        }
+        const fd = deps.fs.openSync(spool, fs.constants.O_APPEND | fs.constants.O_WRONLY);
+        try {
+            deps.fs.writeSync(fd, `${formatSpoolLine(event)}\n`);
+        }
+        finally {
+            deps.fs.closeSync(fd);
+        }
+    }
+    catch { /* work_mesh_enqueue is called with `|| true` by the shell library */ }
+    return true;
+}
+function normalizedHarness(env) {
+    let value = env.HQ_HARNESS || env.HQ_WORK_MESH_HARNESS || env.HQ_CHECKPOINT_RUNTIME || "claude-code";
+    if (["claude", "Claude", "ClaudeCode"].includes(value))
+        value = "claude-code";
+    else if (value === "Codex")
+        value = "codex";
+    else if (value === "Grok")
+        value = "grok";
+    return value;
+}
+function runRebind(sid, oldCompany, oldProject, oldTask, company, project, task, deps) {
+    if (!sid || !project)
+        return 1;
+    if (oldProject === project) {
+        writeMarker(sid, company, project, task, deps);
+        return 0;
+    }
+    const harness = normalizedHarness(deps.env);
+    const adapter = deps.env.HQ_ADAPTER_CONTRACT_VERSION || "1.0.0";
+    if (oldProject && !enqueueLifecycle("session_end", sid, harness, adapter, oldCompany, oldProject, oldTask, deps))
+        return 1;
+    if (!enqueueLifecycle("session_start", sid, harness, adapter, company, project, task, deps))
+        return 1;
+    writeMarker(sid, company, project, task, deps);
+    return 0;
+}
+function runWorkMeshLiveRebindUnsafe(args, deps) {
+    let sid = "", oldCompany = "", oldProject = "", oldTask = "", company = "", project = "", task = "", fromState = false;
+    const takesValue = {
+        "--session": "sid", "--session-id": "sid", "--old-company": "oldCompany", "--old-project": "oldProject", "--old-task": "oldTask",
+        "--company": "company", "--company-slug": "company", "--project": "project", "--task": "task",
+    };
+    for (let i = 0; i < args.length;) {
+        const arg = args[i];
+        const key = takesValue[arg];
+        if (key) {
+            if (i + 1 >= args.length)
+                return { code: 1, stdout: "", stderr: `assets/scaffold/${WORK_MESH_LIVE_REBIND_ASSET}: line 27: shift: shift count out of range\n` };
+            const value = args[i + 1] ?? "";
+            if (key === "sid")
+                sid = value;
+            else if (key === "oldCompany")
+                oldCompany = value;
+            else if (key === "oldProject")
+                oldProject = value;
+            else if (key === "oldTask")
+                oldTask = value;
+            else if (key === "company")
+                company = value;
+            else if (key === "project")
+                project = value;
+            else
+                task = value;
+            i += 2;
+        }
+        else if (arg === "--from-state") {
+            fromState = true;
+            i += 1;
+        }
+        else
+            i += 1;
+    }
+    if (!sid)
+        return { code: 1, stdout: "", stderr: USAGE };
+    if (fromState || !project) {
+        const current = readState(sid, deps);
+        if (!current?.project)
+            return { code: 0, stdout: "", stderr: "" };
+        const [previousCompany, previousProject, previousTask] = readMarker(sid, deps);
+        if (!previousProject || previousProject === current.project) {
+            writeMarker(sid, current.company, current.project, current.task, deps);
+            return { code: 0, stdout: "", stderr: "" };
+        }
+        return { code: runRebind(sid, previousCompany, previousProject, previousTask, current.company, current.project, current.task, deps), stdout: "", stderr: "" };
+    }
+    if (!oldProject)
+        [oldCompany, oldProject, oldTask] = readMarker(sid, deps);
+    return { code: runRebind(sid, oldCompany, oldProject, oldTask, company, project, task, deps), stdout: "", stderr: "" };
+}
+export function runWorkMeshLiveRebind(args, deps) {
+    try {
+        return runWorkMeshLiveRebindUnsafe(args, deps);
+    }
+    catch (error) {
+        if (!(error instanceof MarkerWriteError))
+            throw error;
+        const cause = error.cause;
+        const message = cause?.code === "EISDIR" ? "Is a directory"
+            : cause?.code === "EACCES" || cause?.code === "EPERM" ? "Permission denied"
+                : cause?.code === "EROFS" ? "Read-only file system"
+                    : cause?.code === "ENOSPC" ? "No space left on device"
+                        : "Input/output error";
+        const script = path.join(deps.root, WORK_MESH_LIVE_REBIND_LIBRARY_ASSET);
+        return { code: 1, stdout: "", stderr: `${script}: line 34: ${error.target}: ${message}\n` };
+    }
+}
+export async function runWorkMeshLiveRebindFast(args, _stdin, cwd, root) {
+    const chosenRoot = process.env.HQ_ROOT || root || cwd;
+    const result = runWorkMeshLiveRebind(args, defaultDeps(chosenRoot, cwd, process.env));
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-work-mesh-live-rebind-native.js.map

package/dist/commands/core-worker-share-native.d.ts

@@ -1,5 +1,4 @@
 import { type WorkerSkillDependencies, type WorkerSkillResult } from "./core-worker-skills-runtime.js";
 export declare const WORKER_SKILL_SHARE_ASSET = "core/scripts/share-worker-skill.sh";
-export declare const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
 export declare function runWorkerSkillShare(argv: string[], dependencies: WorkerSkillDependencies): WorkerSkillResult;
 //# sourceMappingURL=core-worker-share-native.d.ts.map

package/dist/commands/core-worker-share-native.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { resolveBundledAsset } from "../utils/hq-roots.js";
 import { existsFollowingLinks, isDirectory, isSymlink, resolveWorkerCallerRoot, runGit, errorCode, } from "./core-worker-skills-runtime.js";
 export const WORKER_SKILL_SHARE_ASSET = "core/scripts/share-worker-skill.sh";
-export const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
+const WORKER_SKILL_SHARE_USAGE = "usage: $0 [--apply] [--force] <scope-dir> <skill-name> <worker-skill-path>...\n";
 function error(message, code = 2) {
     return { code, stdout: "", stderr: `${message}\n` };
 }

package/dist/commands/core.js

@@ -45,6 +45,7 @@ import { registerCoreGitPackExtensionCheckNative } from "./core-git-pack-extensi
 import { registerCorePinNative } from "./core-pin-native.js";
 import { registerCoreRefreshVaultAccessNative } from "./core-refresh-vault-access-native.js";
 import { registerCoreWorkMeshBindTrustedNative } from "./core-work-mesh-bind-trusted-native.js";
+import { registerCoreHookHelperNativeCommands } from "./core-native-hook-helper-commands.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";
 import { CompanyIndexUserError, renderIndexTarget } from "../lib/index-render/index.js";
@@ -240,6 +241,8 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/lib/session-scope-capability.sh", root: "live", summary: "Session scope-capability lib sourced by hq-session" },
     { asset: "core/scripts/lib/session-id.sh", root: "live", summary: "Session-id resolver lib sourced by hq-session" },
     { asset: "core/scripts/lib/work-mesh-enqueue.sh", root: "live", summary: "Work Mesh Live spool enqueue lib sourced by hooks" },
+    { asset: "core/scripts/lib/work-mesh-live-hook.sh", root: "live", summary: "Work Mesh Live hook helpers sourced by rebind" },
+    { asset: "core/scripts/lib/work-mesh-live-rebind.sh", root: "live", summary: "Work Mesh Live session rebind library sourced by hooks and the native rollback command" },
     // Wave 2 handoff/worktree commands retain their old scripts for one release,
     // behind the shared default-off rollback flag.
     { asset: WORKTREE_GC_ASSET, root: "live", summary: "Rollback companion for native worktree-gc" },
@@ -276,6 +279,9 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/policy-retire.sh", root: "live", summary: "Rollback companion for native policy retire" },
     { asset: "core/scripts/read-policy-frontmatter.sh", root: "cwd", summary: "Rollback companion for native policy frontmatter" },
     { asset: "core/scripts/eval-trigger.sh", root: "live", summary: "Trigger grammar helper used by the policy validator companion" },
+    { asset: "core/scripts/migrate-policy-triggers.sh", root: "live", summary: "Rollback shell for native migrate-policy-triggers" },
+    { asset: "core/scripts/register-project.sh", root: "live", summary: "Rollback shell for native register-project" },
+    { asset: "core/scripts/work-mesh-live-rebind.sh", root: "live", summary: "Rollback shell for native work-mesh-live-rebind" },
     { asset: ".claude/hooks/validate-policy-frontmatter.sh", root: "live", summary: "Policy validator companion used by policy-retire rollback" },
     // Wave 2a handoff shells remain bundled as the default-off rollback path.
     { asset: "core/scripts/handoff-finalize.sh", root: "live", summary: "Rollback shell for native handoff finalize" },
@@ -380,6 +386,7 @@ export function registerCoreCommands(program) {
     registerCoreRefreshVaultAccessNative(core);
     registerCoreDmBindNative(core);
     registerCoreWorkMeshBindTrustedNative(core);
+    registerCoreHookHelperNativeCommands(core);
     // Wave 2 handoff/worktree commands retain their byte-identical shell assets
     // as a default-off rollback path for one release. Keep the gate helper small
     // so sibling Wave 2 work can reuse it without editing this command table.