@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/commands/core-eval-trigger-native.js

@@ -1,12 +0,0 @@
-/** Native implementation of core/scripts/eval-trigger.sh. */
-import { checkTriggerExpressions, evaluateTrigger } from "../utils/core-eval-trigger.js";
-export { checkTriggerExpressions, evaluateTrigger } from "../utils/core-eval-trigger.js";
-export const EVAL_TRIGGER_ASSET = "core/scripts/eval-trigger.sh";
-export async function runEvalTriggerFast(args, stdin, _cwd, _root) {
-    if (args[0] === "--check") {
-        process.stdout.write(checkTriggerExpressions(stdin));
-        return 0;
-    }
-    return evaluateTrigger(args[0] ?? "", args[1] ?? "");
-}
-//# sourceMappingURL=core-eval-trigger-native.js.map

package/dist/commands/core-git-pack-extension-check-native.d.ts

@@ -1,22 +0,0 @@
-import * as fs from "node:fs";
-import type { Command } from "commander";
-import { type UtilityOutput } from "./core-native-utilities.js";
-export declare const GIT_PACK_EXTENSION_CHECK_ASSET = "core/scripts/git-pack-extension-check.sh";
-export declare const GIT_PACK_EXTENSION_CHECK_HELP: string;
-export type GitResult = {
-    code: number;
-    stdout: string;
-    stderr: string;
-};
-export type GitPackDependencies = {
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    runGit?: (args: string[], cwd: string) => GitResult;
-    renameFile?: (source: string, destination: string) => void;
-};
-type PackHeaderReader = Pick<typeof fs, "openSync" | "readSync" | "closeSync">;
-export declare function readPackHeaderHex(file: string, reader?: PackHeaderReader): string;
-export declare function runGitPackExtensionCheck(args: string[], deps: GitPackDependencies): UtilityOutput;
-export declare function registerCoreGitPackExtensionCheckNative(core: Command): void;
-export {};
-//# sourceMappingURL=core-git-pack-extension-check-native.d.ts.map

package/dist/commands/core-git-pack-extension-check-native.js

@@ -1,190 +0,0 @@
-/** In-process pack scan/repair for core/scripts/git-pack-extension-check.sh. */
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { registerNativeUtility, utilityError } from "./core-native-utilities.js";
-export const GIT_PACK_EXTENSION_CHECK_ASSET = "core/scripts/git-pack-extension-check.sh";
-export const GIT_PACK_EXTENSION_CHECK_HELP = `# hq-core: public
-# git-pack-extension-check.sh — find pack files that have lost their extension.
-#
-# A git packfile set is three files sharing one basename:
-#
-#   pack-<sha>.pack   the objects           (magic "PACK")
-#   pack-<sha>.idx    the index into them   (magic "\\377tOc")
-#   pack-<sha>.rev    reverse index         (magic "RIDX")
-#
-# Git pairs them BY EXTENSION. Strip the extension off any one of them and git
-# stops seeing the set entirely: the objects are still on disk, byte for byte,
-# but they become unreachable. The repo then fails in a way that reads like
-# catastrophic history loss rather than a filename problem:
-#
-#   fatal: unable to read tree (<sha>)
-#   error: bad tree object HEAD
-#   error: refs/heads/<branch>: invalid sha1 pointer <sha>
-#
-# \`git fsck\` reports the objects as missing and \`git gc\` cannot help, because
-# nothing is actually corrupt — the bytes are intact and the repair is a
-# rename. That mismatch between how it presents and what it is makes this
-# failure expensive to diagnose from the error text alone, which is why this
-# check exists as a deterministic probe.
-#
-# Git never writes an extensionless \`pack-*\` file, so finding one is
-# unambiguous. Observed in the wild on a macOS HQ root where a folder-level
-# sync/backup agent had been walking the tree; the mechanism that drops the
-# extension is not established.
-#
-# Usage:
-#   git-pack-extension-check.sh [--root <path>] [--fix] [--quiet]
-#
-#   --root <path>   Repository to check (default: current directory).
-#   --fix           Rename each orphan back to the extension its magic bytes
-#                   prove it should carry. Without this the script only
-#                   reports.
-#   --quiet         Suppress the healthy-case line; findings still print.
-#
-# Exit codes:
-#   0  healthy, or every orphan was repaired under --fix
-#   1  usage error, or the root is not a git repository
-#   2  orphans found and left in place (report-only, or unrepairable)
-#
-# The repair is a rename and nothing else. It never deletes, never rewrites
-# file contents, never touches refs or the index, and refuses to overwrite an
-# existing target. A file whose magic bytes are not a known pack signature is
-# reported and left alone — this script will not guess.
-
-set -uo pipefail
-`.replace(/^# ?/gm, "");
-function defaultGit(args, cwd, env) {
-    const result = spawnSync("git", args, { cwd, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
-    if (result.error)
-        return { code: 127, stdout: "", stderr: result.error.message };
-    return { code: result.status ?? 128, stdout: String(result.stdout ?? ""), stderr: String(result.stderr ?? "") };
-}
-export function readPackHeaderHex(file, reader = fs) {
-    let fd;
-    try {
-        fd = reader.openSync(file, "r");
-        const header = Buffer.alloc(4);
-        const bytesRead = reader.readSync(fd, header, 0, header.length, 0);
-        return header.subarray(0, bytesRead).toString("hex");
-    }
-    catch {
-        return "";
-    }
-    finally {
-        if (fd !== undefined) {
-            try {
-                reader.closeSync(fd);
-            }
-            catch { /* preserve the old unreadable-header result */ }
-        }
-    }
-}
-export function runGitPackExtensionCheck(args, deps) {
-    let root = ".";
-    let emptyRoot = false;
-    let fix = false;
-    let quiet = false;
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--root") {
-            if (i + 1 >= args.length)
-                return utilityError("git-pack-extension-check: --root needs a path");
-            root = args[++i];
-            emptyRoot = root.length === 0;
-        }
-        else if (arg === "--fix")
-            fix = true;
-        else if (arg === "--quiet")
-            quiet = true;
-        else if (arg === "-h" || arg === "--help")
-            return { code: 0, stdout: GIT_PACK_EXTENSION_CHECK_HELP, stderr: "" };
-        else
-            return utilityError(`git-pack-extension-check: unknown argument '${arg}'`);
-    }
-    if (emptyRoot)
-        return utilityError("git-pack-extension-check: not a directory: ");
-    const rootPath = path.resolve(deps.cwd, root);
-    try {
-        if (!fs.statSync(rootPath).isDirectory())
-            throw new Error("not a directory");
-    }
-    catch {
-        return utilityError(`git-pack-extension-check: not a directory: ${root}`);
-    }
-    const git = deps.runGit ?? ((gitArgs, cwd) => defaultGit(gitArgs, cwd, deps.env ?? process.env));
-    const renameFile = deps.renameFile ?? ((source, destination) => fs.renameSync(source, destination));
-    const shellOutput = (value) => value.replace(/(?:\r?\n)+$/, "");
-    let common = shellOutput(git(["-C", root, "rev-parse", "--path-format=absolute", "--git-common-dir"], deps.cwd).stdout);
-    if (!common) {
-        common = shellOutput(git(["-C", root, "rev-parse", "--git-common-dir"], deps.cwd).stdout);
-        if (!common)
-            return utilityError(`git-pack-extension-check: not a git repository: ${root}`);
-        if (!path.isAbsolute(common))
-            common = path.resolve(rootPath, common);
-    }
-    const packDir = path.join(common, "objects/pack");
-    let names;
-    try {
-        names = fs.readdirSync(packDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.startsWith("pack-") && !entry.name.includes(".")).map((entry) => entry.name);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT" && error.code !== "ENOTDIR")
-            throw error;
-        return { code: 0, stdout: quiet ? "" : "git-pack-extension-check: no pack directory, nothing to check\n", stderr: "" };
-    }
-    let found = 0;
-    let repaired = 0;
-    let unrepaired = 0;
-    let stdout = "";
-    let stderr = "";
-    for (const name of names) {
-        const orphan = path.join(packDir, name);
-        const hex = readPackHeaderHex(orphan);
-        const ext = hex === "5041434b" ? "pack" : hex === "ff744f63" ? "idx" : hex === "52494458" ? "rev" : "";
-        found += 1;
-        if (!ext) {
-            stderr += `git-pack-extension-check: FOUND ${name} — extensionless, but its magic bytes (${hex || "empty"}) are not a pack/idx/rev signature; leaving it alone\n`;
-            unrepaired += 1;
-            continue;
-        }
-        const target = `${orphan}.${ext}`;
-        if (fs.existsSync(target)) {
-            stderr += `git-pack-extension-check: FOUND ${name} — should be ${name}.${ext}, but that file already exists; resolve by hand\n`;
-            unrepaired += 1;
-            continue;
-        }
-        if (!fix) {
-            stderr += `git-pack-extension-check: FOUND ${name} — lost its .${ext} extension; git cannot see this pack set. Re-run with --fix to rename it.\n`;
-            unrepaired += 1;
-            continue;
-        }
-        try {
-            // Rename works on filesystems that do not support hard links.
-            renameFile(orphan, target);
-            stdout += `git-pack-extension-check: REPAIRED ${name} -> ${name}.${ext}\n`;
-            repaired += 1;
-        }
-        catch {
-            stderr += `git-pack-extension-check: FAILED to rename ${name} -> ${name}.${ext}\n`;
-            unrepaired += 1;
-        }
-    }
-    if (found === 0)
-        return { code: 0, stdout: quiet ? "" : `git-pack-extension-check: ok — no extensionless pack files in ${packDir}\n`, stderr: "" };
-    if (unrepaired > 0)
-        return { code: 2, stdout, stderr: `${stderr}git-pack-extension-check: ${found} orphan(s), ${repaired} repaired, ${unrepaired} still broken\n` };
-    return { code: 0, stdout: `${stdout}git-pack-extension-check: ${repaired} pack file(s) repaired — re-run 'git fsck' to confirm\n`, stderr: "" };
-}
-export function registerCoreGitPackExtensionCheckNative(core) {
-    registerNativeUtility(core, {
-        name: "git-pack-extension-check", asset: GIT_PACK_EXTENSION_CHECK_ASSET, root: "cwd", summary: "Find or repair extensionless Git pack files",
-        resolveRoot: (cwd) => cwd,
-        run: (args, context) => runGitPackExtensionCheck(args, {
-            cwd: context.cwd,
-            env: context.env,
-            runGit: (gitArgs, cwd) => defaultGit(gitArgs, cwd, context.env),
-        }),
-    });
-}
-//# sourceMappingURL=core-git-pack-extension-check-native.js.map

package/dist/commands/core-handoff-fast.d.ts

@@ -1,18 +0,0 @@
-/** Lightweight entry adapters for the fast handoff routes. */
-type RunResult = {
-    code: number;
-    stdout: string;
-    stderr: string;
-};
-/**
- * `handoff finalize --help` is historically an unknown-argument error. Keep
- * that fast error path out of the large handoff implementation module.
- */
-export declare function handoffFinalizeHelpResult(args: readonly string[], root: string, tmpRoot?: string): RunResult | undefined;
-/**
- * Keep cheap help/launch paths in this small module. Commands that do the
- * actual handoff work load the existing implementation only when invoked.
- */
-export declare function runHandoffFastEntry(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, commandName: string): Promise<number>;
-export {};
-//# sourceMappingURL=core-handoff-fast.d.ts.map

package/dist/commands/core-handoff-fast.js

@@ -1,104 +0,0 @@
-/** Lightweight entry adapters for the fast handoff routes. */
-import { spawn, spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-/**
- * `handoff finalize --help` is historically an unknown-argument error. Keep
- * that fast error path out of the large handoff implementation module.
- */
-export function handoffFinalizeHelpResult(args, root, tmpRoot = "/tmp") {
-    if (args[0] !== "--help")
-        return undefined;
-    const absoluteRoot = fs.realpathSync(root);
-    const rootEnvironment = {
-        ...process.env,
-        HQ_ROOT: absoluteRoot,
-        CLAUDE_PROJECT_DIR: absoluteRoot,
-        PWD: absoluteRoot,
-    };
-    const probe = spawnSync("git", ["rev-parse", "--git-common-dir"], {
-        cwd: absoluteRoot,
-        env: { ...rootEnvironment, LC_ALL: "C" },
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (!probe.error && probe.status === 0) {
-        // The result only determines whether later finalize work stages files. The
-        // unknown --help argument returns before that work starts.
-    }
-    else {
-        const output = `${String(probe.stdout ?? "")}${String(probe.stderr ?? "")}`.trimEnd();
-        const checkoutMarker = path.join(absoluteRoot, ".git");
-        if (fs.existsSync(checkoutMarker) || fs.lstatSync(checkoutMarker, { throwIfNoEntry: false })
-            || !output.includes("not a git repository")) {
-            return {
-                code: 4,
-                stdout: "",
-                stderr: `handoff-finalize: Git checkout probe failed (exit ${probe.status ?? 127}): ${output}\n`,
-            };
-        }
-    }
-    const gitPidFile = path.join(tmpRoot, "handoff-git-bg.pid");
-    if (fs.existsSync(gitPidFile)) {
-        try {
-            fs.rmSync(gitPidFile, { force: true });
-        }
-        catch { /* legacy cleanup is best-effort */ }
-    }
-    return { code: 2, stdout: "", stderr: "Unknown arg: --help\n" };
-}
-async function launchHandoffPost(args, root) {
-    return await new Promise((resolve) => {
-        try {
-            const child = spawn("hq", ["core", "--hq-root", root, "handoff", "post", ...args], {
-                cwd: root,
-                env: {
-                    ...process.env,
-                    HQ_ROOT: root,
-                    CLAUDE_PROJECT_DIR: root,
-                    PWD: root,
-                    HQ_NATIVE_HANDOFF_POST_CHILD: "1",
-                },
-                detached: true,
-                windowsHide: true,
-                stdio: "ignore",
-            });
-            child.once("error", (error) => {
-                process.stderr.write(`${error.message}\n`);
-                resolve(127);
-            });
-            child.once("spawn", () => {
-                child.unref();
-                resolve(0);
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`${message}\n`);
-            resolve(1);
-        }
-    });
-}
-/**
- * Keep cheap help/launch paths in this small module. Commands that do the
- * actual handoff work load the existing implementation only when invoked.
- */
-export async function runHandoffFastEntry(args, stdin, cwd, hqRoot, commandName) {
-    const root = hqRoot ?? cwd;
-    if (commandName === "post" && process.env.HQ_NATIVE_HANDOFF_POST_CHILD !== "1") {
-        return await launchHandoffPost(args, root);
-    }
-    if (commandName === "finalize") {
-        const helpResult = handoffFinalizeHelpResult(args, root);
-        if (helpResult) {
-            if (helpResult.stdout)
-                process.stdout.write(helpResult.stdout);
-            if (helpResult.stderr)
-                process.stderr.write(helpResult.stderr);
-            return helpResult.code;
-        }
-    }
-    const handoff = await import("./core-handoff.js");
-    return await handoff.runHandoffFast(args, stdin, cwd, root, commandName);
-}
-//# sourceMappingURL=core-handoff-fast.js.map

package/dist/commands/core-handoff-open-steps.d.ts

@@ -1,21 +0,0 @@
-/** Lightweight native handler for the handoff open-steps helper. */
-type RunResult = {
-    code: number;
-    stdout: string;
-    stderr: string;
-};
-type HandoffContext = {
-    root: string;
-    cwd: string;
-    now?: () => Date;
-};
-export declare function prettyJson(value: unknown): string;
-export declare function compactJson(value: unknown): string;
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function jqTruthy(value: unknown): boolean;
-export declare function shellDate(date: Date): string;
-export declare function runHandoffOpenSteps(args: string[], context: HandoffContext): RunResult;
-/** Fast-entry adapter for the lightweight open-steps implementation. */
-export declare function runHandoffOpenStepsFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined): number;
-export {};
-//# sourceMappingURL=core-handoff-open-steps.d.ts.map

package/dist/commands/core-handoff-open-steps.js

@@ -1,264 +0,0 @@
-/** Lightweight native handler for the handoff open-steps helper. */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
-const OPEN_STEPS_UNKNOWN_USAGE = `# hq-core: public
-# handoff-open-steps.sh — list and close next steps across handoff threads
-# (2026-09-07).
-#
-# Handoff threads record next_steps; since 2026-09-07 each carries an \x60id\x60
-# (\x60<thread_id>#<n>\x60) and a \x60status\x60 (open|done|dropped). This script is the
-# closure side: /startwork and /resumework list what is still open instead of
-# re-copying it forward, and a session closes a step when it is actually done.
-#
-# Usage:
-#   handoff-open-steps.sh list [--limit N] [--company <slug>] [--json]
-#   handoff-open-steps.sh close <step-id> [--as done|dropped] [--note "<why>"]
-#   handoff-open-steps.sh reopen <step-id>
-#
-# Threads live in workspace/threads/T-*.json (and archive/**). Closing edits
-# the step in place inside its thread file (only \x60status\x60, \x60closed_at\x60,
-# \x60closed_by\x60, \x60note\x60) and bumps \x60updated_at\x60; nothing else in the thread is
-# touched. Legacy steps without an id are listed with a synthetic id and can be
-# closed the same way (the id is written on first close).
-set -uo pipefail
-HQ_ROOT="\${HQ_ROOT:-\${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "\${BASH_SOURCE[0]}")/../.." && pwd)}}"
-`;
-export function prettyJson(value) {
-    return serializeJqJson(value, "pretty");
-}
-export function compactJson(value) {
-    return serializeJqJson(value, "compact");
-}
-export function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-export function jqTruthy(value) {
-    return value !== undefined && value !== null && value !== false;
-}
-function listFiles(root, predicate) {
-    const found = [];
-    const visit = (directory) => {
-        let entries;
-        try {
-            entries = fs.readdirSync(directory, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const file = path.join(directory, entry.name);
-            if (entry.isDirectory())
-                visit(file);
-            else if (entry.isFile() && predicate(file, entry))
-                found.push(file);
-        }
-    };
-    visit(root);
-    return found;
-}
-function sortThreadFilesNewest(files) {
-    return files.sort((left, right) => {
-        const leftMtime = Math.floor(fs.statSync(left).mtimeMs / 1000);
-        const rightMtime = Math.floor(fs.statSync(right).mtimeMs / 1000);
-        if (leftMtime !== rightMtime)
-            return rightMtime - leftMtime;
-        // GNU sort -rn falls back to reverse lexical order for equal numeric keys.
-        return right.localeCompare(left);
-    });
-}
-function normalizedSteps(file, value) {
-    if (!isRecord(value))
-        return undefined;
-    const steps = value.next_steps ?? [];
-    if (!Array.isArray(steps))
-        return undefined;
-    const basename = path.basename(file).replace(/\.json$/, "");
-    const normalized = [];
-    for (let index = 0; index < steps.length; index += 1) {
-        const raw = steps[index];
-        if (typeof raw !== "string" && !isRecord(raw))
-            return undefined;
-        const step = typeof raw === "string" ? { step: raw } : { ...raw };
-        if (!jqTruthy(step.id))
-            step.id = `${basename}#${index + 1}`;
-        if (!jqTruthy(step.status))
-            step.status = "open";
-        delete step.key;
-        normalized.push(step);
-    }
-    return normalized;
-}
-function parseJson(file) {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-}
-export function shellDate(date) {
-    return date.toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-export function runHandoffOpenSteps(args, context) {
-    const root = context.root;
-    const threads = path.join(root, "workspace/threads");
-    const argv = [...args];
-    const command = argv[0] || "list";
-    if (argv.length > 0)
-        argv.shift();
-    if (command === "list") {
-        let limitText = "20";
-        let company = "";
-        let json = false;
-        for (let index = 0; index < argv.length;) {
-            const token = argv[index];
-            if (token === "--limit") {
-                limitText = argv[index + 1] ?? "";
-                index += 2;
-            }
-            else if (token === "--company") {
-                company = argv[index + 1] ?? "";
-                index += 2;
-            }
-            else if (token === "--json") {
-                json = true;
-                index += 1;
-            }
-            else
-                index += 1;
-        }
-        const numericLimit = /^-?\d+$/.test(limitText) ? Number(limitText) : Number.NaN;
-        const candidates = sortThreadFilesNewest(listFiles(threads, (file) => {
-            const name = path.basename(file);
-            return /^T-.*\.json$/.test(name) && !name.endsWith(".changeset.json") && !file.split(path.sep).includes("resume-locks");
-        }));
-        let count = 0;
-        const rows = [];
-        for (const file of candidates) {
-            if (!Number.isNaN(numericLimit) && count >= numericLimit)
-                break;
-            count += 1;
-            let thread;
-            let nextSteps;
-            try {
-                thread = parseJson(file);
-                nextSteps = normalizedSteps(file, thread);
-            }
-            catch {
-                continue;
-            }
-            if (!nextSteps || !isRecord(thread))
-                continue;
-            if (company) {
-                const companies = (isRecord(thread.metadata) ? thread.metadata.company : undefined) ?? [];
-                const contains = Array.isArray(companies)
-                    ? companies.includes(company)
-                    : typeof companies === "string" && companies.includes(company);
-                if (!contains)
-                    continue;
-            }
-            for (const step of nextSteps) {
-                if (step.status !== "open")
-                    continue;
-                rows.push({
-                    thread: thread.thread_id,
-                    title: (isRecord(thread.metadata) ? thread.metadata.title : undefined) ?? "",
-                    created: thread.created_at,
-                    id: step.id,
-                    step: step.step ?? null,
-                });
-            }
-        }
-        if (json)
-            return { code: 0, stdout: prettyJson(rows), stderr: "" };
-        if (rows.length === 0)
-            return { code: 0, stdout: `No open handoff steps in the last ${count} thread(s).\n`, stderr: "" };
-        const jqString = (value) => value === null || value === undefined
-            ? "null"
-            : typeof value === "string" ? value : compactJson(value).trimEnd();
-        const output = rows.map((row) => `${jqString(row.id)}  ${jqString(row.step)}  [${jqString(row.title)}]\n`).join("");
-        return { code: 0, stdout: output, stderr: "" };
-    }
-    if (command === "close" || command === "reopen") {
-        const id = argv[0] ?? "";
-        const rest = argv.slice(1);
-        if (!id)
-            return { code: 2, stdout: "", stderr: `usage: ${command} <step-id>\n` };
-        let as = "done";
-        let note = "";
-        for (let index = 0; index < rest.length;) {
-            if (rest[index] === "--as") {
-                as = rest[index + 1] ?? "";
-                index += 2;
-            }
-            else if (rest[index] === "--note") {
-                note = rest[index + 1] ?? "";
-                index += 2;
-            }
-            else
-                index += 1;
-        }
-        if (command === "reopen")
-            as = "open";
-        if (!new Set(["done", "dropped", "open"]).has(as))
-            return { code: 2, stdout: "", stderr: "--as must be done|dropped\n" };
-        const threadId = id.split("#", 1)[0] ?? "";
-        const candidates = listFiles(threads, (file) => path.basename(file) === `${threadId}.json` && !file.split(path.sep).includes("resume-locks"));
-        const file = candidates[0];
-        if (!file)
-            return { code: 3, stdout: "", stderr: `handoff-open-steps: thread ${threadId} not found under ${threads}\n` };
-        const now = shellDate(context.now?.() ?? new Date());
-        const by = process.env.HQ_SESSION_ID || process.env.CLAUDE_SESSION_ID || "unknown-session";
-        let text;
-        try {
-            const thread = parseJson(file);
-            const steps = normalizedSteps(file, thread);
-            if (!steps || !isRecord(thread))
-                throw new Error("Cannot iterate over null (null)");
-            if (!steps.some((step) => step.id === id))
-                throw new Error(`step ${id} not in thread`);
-            const updated = steps.map((step) => {
-                if (step.id !== id)
-                    return step;
-                if (as === "open") {
-                    delete step.closed_at;
-                    delete step.closed_by;
-                    step.status = "open";
-                }
-                else {
-                    step.status = as;
-                    step.closed_at = now;
-                    step.closed_by = by;
-                    if (note !== "")
-                        step.note = note;
-                }
-                return step;
-            });
-            thread.next_steps = updated;
-            thread.updated_at = now;
-            text = prettyJson(thread);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const jqMessage = message.startsWith("step ")
-                ? `jq: error (at <stdin>:1): ${message}`
-                : `jq: error: ${message}`;
-            return { code: 3, stdout: "", stderr: `${jqMessage}\n` };
-        }
-        // jq > file.tmp followed by mv uses the caller's umask for this new inode.
-        const temporary = `${file}.tmp`;
-        fs.writeFileSync(temporary, text);
-        fs.renameSync(temporary, file);
-        return { code: 0, stdout: `handoff-open-steps: ${id} -> ${as}\n`, stderr: "" };
-    }
-    return { code: 2, stdout: OPEN_STEPS_UNKNOWN_USAGE, stderr: "" };
-}
-/** Fast-entry adapter for the lightweight open-steps implementation. */
-export function runHandoffOpenStepsFast(args, _stdin, cwd, hqRoot) {
-    const root = hqRoot ?? cwd;
-    const result = runHandoffOpenSteps([...args], { root, cwd });
-    if (result.stdout)
-        process.stdout.write(result.stdout);
-    if (result.stderr)
-        process.stderr.write(result.stderr);
-    if (result.code !== 0)
-        process.exitCode = result.code;
-    return result.code;
-}
-//# sourceMappingURL=core-handoff-open-steps.js.map

package/dist/commands/core-handoff.d.ts

@@ -1,24 +0,0 @@
-/** Native implementations of the handoff scaffold command family. */
-import { Command } from "commander";
-import { runHandoffOpenSteps } from "./core-handoff-open-steps.js";
-export { runHandoffOpenSteps };
-type RunResult = {
-    code: number;
-    stdout: string;
-    stderr: string;
-};
-type HandoffContext = {
-    root: string;
-    cwd: string;
-    now?: () => Date;
-    /** Test-only override for the finalizer's historical fixed /tmp paths. */
-    tmpDir?: string;
-};
-export declare function runHandoffFinalize(args: string[], context: HandoffContext): RunResult;
-export declare function runHandoffPost(args: string[], context: HandoffContext): RunResult | Promise<RunResult>;
-export declare function runHandoffPostWorker(args: string[], context: HandoffContext): RunResult;
-/** Fast-entry adapter; the shared family flag is resolved before this module loads. */
-export declare function runHandoffFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined, commandName: string): Promise<number>;
-/** Register native handoff commands behind the shared default-off flag. */
-export declare function registerCoreHandoffCommand(core: Command): void;
-//# sourceMappingURL=core-handoff.d.ts.map