@indigoai-us/hq-cli 5.319.0 → 5.321.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [5.321.0] — 2026-10-02
+
+- Project catalog cache keys include their source directory, and runtime-probe tests isolate the host CLI and scope checks to hooks.
+
+- Fixed intermittent timeouts in the concurrent journal parity test.
+- Fix repo-run-registry so an unremovable stale lock exits with a clear error instead of retrying forever.
+- Added the default-off `hq core hook-batch journal-due` command for one-process PostToolUse journal counter reads.
+
+## [5.320.0] — 2026-10-02
+- Write session-journal titles as escaped YAML strings so free-form titles remain parseable.
+- Added a default-off hq-flags gate that lets lane list pollers skip remote owner refreshes to reduce poll latency.
+- Publish per-process package-use leases so Desktop updates can wait for active hq-cli work without native locks.
+
 ## [5.319.0] — 2026-10-02
 - Let `hq access` use ACL-checked company presigned reads when STS vend rejects a truncated write-policy scope.
 - Lead autopilot on an Outpost can wake leads that were created on that Outpost, behind the default-off `lanes.autopilot-outpost-native-leads` flag. Before, those leads were skipped as a host mismatch and got no wakes.

package/assets/scaffold/core/scripts/repo-run-registry.sh

@@ -96,7 +96,9 @@ _try_lock() {
         mtime="$(portable_stat_mtime "$LOCK_DIR" 2>/dev/null || echo 0)"
         age=$(( $(date +%s) - mtime ))
         if [[ $age -gt 60 ]]; then
-          rm -rf "$LOCK_DIR" 2>/dev/null || true
+          if ! rm -rf "$LOCK_DIR" 2>/dev/null; then
+            _die "could not remove stale registry lock: $LOCK_DIR"
+          fi
           continue
         fi
       fi

package/assets/scaffold/core/scripts/session-journal.sh

@@ -43,6 +43,41 @@ slugify() {
     | cut -c1-40
 }
 
+yaml_double_quoted() {
+  local value="$1" output='"' character next codepoint hex
+  local LC_ALL=C index
+  for ((index = 0; index < ${#value}; index++)); do
+    character="${value:index:1}"
+    if [[ "$character" == $'\xc2' ]] && (( index + 1 < ${#value} )); then
+      next="${value:index+1:1}"
+      printf -v codepoint '%d' "'${next}"
+      if (( codepoint >= 128 && codepoint <= 159 )); then
+        printf -v hex '%04x' "$codepoint"
+        output+="\\u$hex"
+        index=$((index + 1))
+        continue
+      fi
+    fi
+    case "$character" in
+      \\) output+='\\' ;;
+      '"') output+='\"' ;;
+      $'\n') output+='\n' ;;
+      $'\r') output+='\r' ;;
+      $'\t') output+='\t' ;;
+      *)
+        if [[ "$character" == [[:cntrl:]] ]]; then
+          printf -v codepoint '%d' "'${character}"
+          printf -v hex '%02x' "$codepoint"
+          output+="\\x$hex"
+        else
+          output+="$character"
+        fi
+        ;;
+    esac
+  done
+  printf '%s"' "$output"
+}
+
 # Counters are per-session. A date-global counter lets concurrent Claude and
 # Codex tasks trip (and reset) each other's journal reminders.
 counter_key() {
@@ -140,6 +175,9 @@ case "$cmd" in
 
     slug="$(slugify "$title")"
     [ -z "$slug" ] && slug="entry"
+    yaml_title="$(yaml_double_quoted "$title")"
+    yaml_slug="$slug"
+    [[ "$slug" != *$'\n'* ]] || yaml_slug="$(yaml_double_quoted "$slug")"
     JOURNAL_WRITE_LOCK=""
     acquire_journal_write_lock "$dir" || { warn "write: failed to acquire journal lock"; exit 0; }
     trap release_journal_write_lock EXIT
@@ -161,8 +199,8 @@ case "$cmd" in
         {
           printf -- '---\n'
           printf 'ts: %s\n' "$(now_iso_z)"
-          printf 'title: %s\n' "$title"
-          printf 'slug: %s\n' "$slug"
+          printf 'title: %s\n' "$yaml_title"
+          printf 'slug: %s\n' "$yaml_slug"
           if [ -n "$files_csv" ]; then
             printf 'files:\n'
             old_ifs="$IFS"

package/dist/bin/hq-auth-refresh.d.ts

@@ -11,7 +11,9 @@
  * non-interactively.
  */
 import "../node-preflight.js";
+import { acquireCurrentPackageUseLease } from "../utils/package-use-lease.js";
 import "../node-network-compat.js";
-import { refreshCachedSession } from "../utils/cognito-session.js";
+import type { refreshCachedSession } from "../utils/cognito-session.js";
 export declare function runAuthRefresh(refreshSession?: typeof refreshCachedSession): Promise<number>;
+export declare function startAuthRefresh(acquireLease?: typeof acquireCurrentPackageUseLease): Promise<number>;
 //# sourceMappingURL=hq-auth-refresh.d.ts.map

package/dist/bin/hq-auth-refresh.js

@@ -13,15 +13,16 @@
 // MUST be first: guard the Node version before any dependency that needs a
 // Node 20+ API (e.g. util.styleText) or a newer native ABI is evaluated.
 import "../node-preflight.js";
+import { acquireCurrentPackageUseLease } from "../utils/package-use-lease.js";
 import "../node-network-compat.js";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
-import { finishSentrySession, initSentry, Sentry } from "../sentry.js";
-import { refreshCachedSession } from "../utils/cognito-session.js";
-export async function runAuthRefresh(refreshSession = refreshCachedSession) {
+export async function runAuthRefresh(refreshSession) {
+    const { finishSentrySession, Sentry } = await import("../sentry.js");
+    const { refreshCachedSession: refresh } = await import("../utils/cognito-session.js");
     let exitCode = 1;
     try {
-        const result = await refreshSession();
+        const result = await (refreshSession ?? refresh)();
         if (result.refreshed) {
             exitCode = 0;
         }
@@ -41,8 +42,42 @@ export async function runAuthRefresh(refreshSession = refreshCachedSession) {
     }
     return exitCode;
 }
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+function isPackageUseUpdatePendingError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        error.name === "PackageUseUpdatePendingError");
+}
+function packageUseErrorClass(error) {
+    if (!error || typeof error !== "object")
+        return "unknown";
+    const value = error;
+    if (typeof value.code === "string")
+        return value.code;
+    if (value.cause && typeof value.cause === "object") {
+        const cause = value.cause;
+        if (typeof cause.code === "string")
+            return cause.code;
+        if (typeof cause.name === "string")
+            return cause.name;
+    }
+    return typeof value.name === "string" ? value.name : "unknown";
+}
+export async function startAuthRefresh(acquireLease = acquireCurrentPackageUseLease) {
+    try {
+        acquireLease();
+    }
+    catch (error) {
+        if (isPackageUseUpdatePendingError(error)) {
+            process.stderr.write(`hq-auth-refresh: ${error instanceof Error ? error.message : "The HQ CLI package is being updated"}\n`);
+            return 1;
+        }
+        process.stderr.write(`hq-auth-refresh: package-use lease unavailable (${packageUseErrorClass(error)}); continuing without lease\n`);
+    }
+    const { initSentry } = await import("../sentry.js");
     initSentry();
-    void runAuthRefresh().then((exitCode) => process.exit(exitCode));
+    return runAuthRefresh();
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    void startAuthRefresh().then((exitCode) => process.exit(exitCode));
 }
 //# sourceMappingURL=hq-auth-refresh.js.map

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

@@ -5971,6 +5971,30 @@ export declare const COMMAND_CATALOG: readonly [{
         }];
         readonly options: readonly [];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "hook-batch";
+        readonly description: "Batch PostToolUse hook helper calls";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] [command]";
+        readonly arguments: readonly [];
+        readonly options: readonly [];
+        readonly subcommands: readonly [{
+            readonly name: "journal-due";
+            readonly description: "Resolve the journal path, increment the tool counter, and return its value";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly usage: "[options]";
+            readonly arguments: readonly [];
+            readonly options: readonly [{
+                readonly flags: "--session <key>";
+                readonly description: "Session key used by the journal counter";
+            }, {
+                readonly flags: "--reset";
+                readonly description: "Reset the tool counter before incrementing it";
+            }];
+            readonly subcommands: readonly [];
+        }];
     }, {
         readonly name: "session-journal";
         readonly description: "Write and read session journal entries";

package/dist/command-catalog.generated.js

@@ -7681,6 +7681,36 @@ export const COMMAND_CATALOG = [
                 "options": [],
                 "subcommands": []
             },
+            {
+                "name": "hook-batch",
+                "description": "Batch PostToolUse hook helper calls",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] [command]",
+                "arguments": [],
+                "options": [],
+                "subcommands": [
+                    {
+                        "name": "journal-due",
+                        "description": "Resolve the journal path, increment the tool counter, and return its value",
+                        "aliases": [],
+                        "hidden": false,
+                        "usage": "[options]",
+                        "arguments": [],
+                        "options": [
+                            {
+                                "flags": "--session <key>",
+                                "description": "Session key used by the journal counter"
+                            },
+                            {
+                                "flags": "--reset",
+                                "description": "Reset the tool counter before incrementing it"
+                            }
+                        ],
+                        "subcommands": []
+                    }
+                ]
+            },
             {
                 "name": "session-journal",
                 "description": "Write and read session journal entries",

package/dist/commands/core-hook-batch-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerCoreHookBatchCommand(core: Command): void;
+//# sourceMappingURL=core-hook-batch-command.d.ts.map

package/dist/commands/core-hook-batch-command.js

@@ -0,0 +1,27 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { CORE_HOOK_BATCH_HELP, runCoreHookBatchFast } from "./core-hook-batch-native.js";
+import { coreHookBatchEnabled } from "./core-hook-batch-flag.js";
+export function registerCoreHookBatchCommand(core) {
+    const group = core.command("hook-batch")
+        .description("Batch PostToolUse hook helper calls");
+    const journalDue = group.command("journal-due")
+        .description("Resolve the journal path, increment the tool counter, and return its value")
+        .requiredOption("--session <key>", "Session key used by the journal counter")
+        .option("--reset", "Reset the tool counter before incrementing it")
+        .addHelpText("after", `\n${CORE_HOOK_BATCH_HELP}`)
+        .action(async (options) => {
+        if (!await coreHookBatchEnabled()) {
+            process.stderr.write("hook-batch: journal-due requires the core-hook-batch flag\n");
+            process.exitCode = 1;
+            return;
+        }
+        const root = resolveLiveRoot({ hqRoot: core.opts().hqRoot });
+        const args = ["--session", options.session, ...(options.reset ? ["--reset"] : [])];
+        const code = runCoreHookBatchFast(args, "", process.cwd(), root);
+        if (code !== 0)
+            process.exitCode = code;
+    });
+    describeCoreCommand(journalDue, { execution: "native", root: "live" });
+}
+//# sourceMappingURL=core-hook-batch-command.js.map

package/dist/commands/core-hook-batch-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off gate for the batched PostToolUse helper command. */
+export declare const CORE_HOOK_BATCH_FLAG = "core-hook-batch";
+export declare function coreHookBatchEnabled(): Promise<boolean>;
+//# sourceMappingURL=core-hook-batch-flag.d.ts.map

package/dist/commands/core-hook-batch-flag.js

@@ -0,0 +1,7 @@
+/** Default-off gate for the batched PostToolUse helper command. */
+export const CORE_HOOK_BATCH_FLAG = "core-hook-batch";
+export async function coreHookBatchEnabled() {
+    const { resolveProcessFlagGate } = await import("../lib/flag-registry.js");
+    return resolveProcessFlagGate(CORE_HOOK_BATCH_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=core-hook-batch-flag.js.map

package/dist/commands/core-hook-batch-native.d.ts

@@ -0,0 +1,10 @@
+import { type SessionJournalOperationResult } from "./core-session-journal-native.js";
+import type { SessionHelperRuntimeOverrides } from "./core-session-helper-runtime.js";
+export declare const CORE_HOOK_BATCH_HELP = "Usage: hq core hook-batch journal-due --session <key> [--reset]\n\nRuns session-journal dir-path, tool-counter increment, and tool-counter read\ninside one process. With --reset, tool-counter reset runs before increment.\n\nOutput framing: one ASCII line per helper call, in execution order:\n  HQHB1|<step>|<exit-code>|<stdout-base64>|<stderr-base64>\nThe delimiter is |; the final newline ends each record. Base64 preserves each\nhelper stream byte-for-byte. In Bash, read each field and decode a stream with\nbase64 --decode (GNU) or base64 -D (BSD); jq is not needed. A helper's code 0\ndoes not imply empty output, and empty streams have empty base64 fields.\n";
+type BatchResult = SessionJournalOperationResult;
+/** Build the no-jq frame over the same in-process operation used by session-journal. */
+export declare function runCoreHookBatch(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): BatchResult;
+/** Fast-route entrypoint; the encoded records are the only top-level output. */
+export declare function runCoreHookBatchFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined): number | undefined;
+export {};
+//# sourceMappingURL=core-hook-batch-native.d.ts.map

package/dist/commands/core-hook-batch-native.js

@@ -0,0 +1,85 @@
+import { runSessionJournalOperation } from "./core-session-journal-native.js";
+export const CORE_HOOK_BATCH_HELP = `Usage: hq core hook-batch journal-due --session <key> [--reset]
+
+Runs session-journal dir-path, tool-counter increment, and tool-counter read
+inside one process. With --reset, tool-counter reset runs before increment.
+
+Output framing: one ASCII line per helper call, in execution order:
+  HQHB1|<step>|<exit-code>|<stdout-base64>|<stderr-base64>
+The delimiter is |; the final newline ends each record. Base64 preserves each
+helper stream byte-for-byte. In Bash, read each field and decode a stream with
+base64 --decode (GNU) or base64 -D (BSD); jq is not needed. A helper's code 0
+does not imply empty output, and empty streams have empty base64 fields.
+`;
+function usageError() {
+    return { code: 1, stdout: Buffer.alloc(0), stderr: Buffer.from(CORE_HOOK_BATCH_HELP) };
+}
+function frame(name, result) {
+    const line = [
+        "HQHB1",
+        name,
+        String(result.code),
+        result.stdout.toString("base64"),
+        result.stderr.toString("base64"),
+    ].join("|");
+    return Buffer.from(`${line}\n`, "ascii");
+}
+function parseArgs(args) {
+    if (args.includes("--help") || args.includes("-h"))
+        return "help";
+    let session;
+    let reset = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--session") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("--"))
+                return undefined;
+            session = value;
+            index += 1;
+        }
+        else if (arg === "--reset") {
+            reset = true;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (!session)
+        return undefined;
+    return { session, reset };
+}
+function runParsedCoreHookBatch(parsed, stdin, cwd, hqRoot, dependencies) {
+    const sessionArgs = ["--session", parsed.session];
+    const steps = [
+        { name: "dir-path", args: ["dir-path"] },
+        ...(parsed.reset ? [{ name: "reset", args: ["tool-counter", "reset", ...sessionArgs] }] : []),
+        { name: "increment", args: ["tool-counter", "increment", ...sessionArgs] },
+        { name: "read", args: ["tool-counter", "read", ...sessionArgs] },
+    ];
+    const records = steps.map((step) => {
+        const result = runSessionJournalOperation(step.args, stdin, cwd, hqRoot, dependencies);
+        return frame(step.name, result);
+    });
+    return { code: 0, stdout: Buffer.concat(records), stderr: Buffer.alloc(0) };
+}
+/** Build the no-jq frame over the same in-process operation used by session-journal. */
+export function runCoreHookBatch(args, stdin, cwd, hqRoot, dependencies = {}) {
+    const parsed = parseArgs(args);
+    if (parsed === "help")
+        return { code: 0, stdout: Buffer.from(CORE_HOOK_BATCH_HELP), stderr: Buffer.alloc(0) };
+    if (!parsed)
+        return usageError();
+    return runParsedCoreHookBatch(parsed, stdin, cwd, hqRoot, dependencies);
+}
+/** Fast-route entrypoint; the encoded records are the only top-level output. */
+export function runCoreHookBatchFast(args, stdin, cwd, hqRoot) {
+    const parsed = parseArgs(args);
+    if (!parsed || parsed === "help")
+        return undefined;
+    const result = runParsedCoreHookBatch(parsed, stdin, cwd, hqRoot, {});
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-hook-batch-native.js.map

package/dist/commands/core-repo-run-registry-native.js

@@ -131,7 +131,12 @@ export function runRepoRunRegistry(args, deps) {
                         catch { /* shell falls back to epoch zero when stat fails */ }
                         const age = Math.floor(now().getTime() / 1000) - Math.floor(mtimeMs / 1000);
                         if (age > 60) {
-                            f.rmSync(lockDir, { recursive: true, force: true });
+                            try {
+                                f.rmSync(lockDir, { recursive: true, force: true });
+                            }
+                            catch {
+                                throw new Error(`ERROR: could not remove stale registry lock: ${lockDir}`);
+                            }
                             continue;
                         }
                     }

package/dist/commands/core-session-journal-native.d.ts

@@ -1,4 +1,11 @@
 import { type SessionHelperRuntimeOverrides } from "./core-session-helper-runtime.js";
+export type SessionJournalOperationResult = {
+    code: number;
+    stdout: Buffer;
+    stderr: Buffer;
+};
+/** Execute one native helper call while retaining its two output byte streams. */
+export declare function runSessionJournalOperation(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): SessionJournalOperationResult;
 /** Native implementation of the fail-soft session journal helper. */
-export declare function runSessionJournalFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): number;
+export declare function runSessionJournalFast(args: readonly string[], stdin: string, cwd: string, hqRoot: string | undefined, dependencies?: SessionHelperRuntimeOverrides): number;
 //# sourceMappingURL=core-session-journal-native.d.ts.map

package/dist/commands/core-session-journal-native.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveSessionHelperRuntime } from "./core-session-helper-runtime.js";
+import { resolveBundledAsset } from "../utils/hq-roots.js";
 const USAGE = `session-journal.sh: usage:
   session-journal.sh write "<title>" [--files f1,f2,...] [--body-file PATH] [--session KEY]
   session-journal.sh list [--date YYYY-MM-DD]
@@ -24,7 +25,35 @@ const counterKey = (value) => {
     return key.length > 96 ? key.slice(0, 96) : key;
 };
 const slugify = (value) => value.toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 40);
+    .split("\n")
+    .map((line) => line.replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 40))
+    .join("\n");
+function yamlDoubleQuoted(value) {
+    let escaped = "";
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (character === "\\")
+            escaped += "\\\\";
+        else if (character === '"')
+            escaped += '\\"';
+        else if (character === "\n")
+            escaped += "\\n";
+        else if (character === "\r")
+            escaped += "\\r";
+        else if (character === "\t")
+            escaped += "\\t";
+        else if (codePoint < 0x20 || codePoint === 0x7f) {
+            escaped += `\\x${codePoint.toString(16).padStart(2, "0")}`;
+        }
+        else if (codePoint >= 0x80 && codePoint <= 0x9f) {
+            escaped += `\\u${codePoint.toString(16).padStart(4, "0")}`;
+        }
+        else {
+            escaped += character;
+        }
+    }
+    return `"${escaped}"`;
+}
 const warning = (message) => { process.stderr.write(`session-journal: ${message}\n`); };
 const journalDir = (root, date) => path.join(root, "workspace/threads/journal", date);
 const hasFile = (file) => {
@@ -66,7 +95,7 @@ function acquireJournalWriteLock(dir) {
             try {
                 fs.writeFileSync(ownerFile, `${process.pid}\n`, { flag: "wx" });
             }
-            catch (error) {
+            catch {
                 fs.rmSync(lock, { recursive: true, force: true });
                 return undefined;
             }
@@ -150,7 +179,7 @@ function options(args, valueFlags) {
     }
     return values;
 }
-function runToolCounter(root, action, sessionArg, env, now) {
+function runToolCounter(root, action, sessionArg, env, now, writers) {
     const rawKey = sessionArg || env.HQ_JOURNAL_SESSION || env.HQ_HOOK_SESSION_ID || "";
     const key = counterKey(rawKey);
     const dir = journalDir(root, now().toISOString().slice(0, 10));
@@ -160,31 +189,60 @@ function runToolCounter(root, action, sessionArg, env, now) {
     catch { /* legacy mkdir failure is ignored */ }
     const counter = path.join(dir, `.tool-count-${key}`);
     const lock = `${counter}.lock`;
+    const reportDirectoryWriteFailure = (error, line) => {
+        const code = error.code;
+        if (code !== "EISDIR")
+            return;
+        const asset = resolveBundledAsset("core/scripts/session-journal.sh");
+        writers.stderr(`${asset}: line ${line}: ${counter}: Is a directory\n`);
+    };
     if (action === "increment") {
         withCounterLock(lock, () => {
             try {
                 fs.writeFileSync(counter, `${readCounter(counter) + 1}\n`);
             }
-            catch { /* fail soft */ }
+            catch (error) {
+                reportDirectoryWriteFailure(error, 312);
+            }
         });
     }
     else if (action === "read") {
-        process.stdout.write(`${readCounter(counter)}\n`);
+        writers.stdout(`${readCounter(counter)}\n`);
     }
     else if (action === "reset") {
         withCounterLock(lock, () => {
             try {
                 fs.writeFileSync(counter, "0\n");
             }
-            catch { /* fail soft */ }
+            catch (error) {
+                reportDirectoryWriteFailure(error, 320);
+            }
         });
     }
     else {
-        warning("tool-counter: subcommand required (increment|read|reset)");
+        writers.stderr("session-journal: tool-counter: subcommand required (increment|read|reset)\n");
     }
 }
+/** Execute one native helper call while retaining its two output byte streams. */
+export function runSessionJournalOperation(args, _stdin, cwd, hqRoot, dependencies = {}) {
+    const stdout = [];
+    const stderr = [];
+    const writers = {
+        stdout: (chunk) => stdout.push(Buffer.from(chunk)),
+        stderr: (chunk) => stderr.push(Buffer.from(chunk)),
+    };
+    const code = executeSessionJournal(args, cwd, hqRoot, dependencies, writers);
+    return { code, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) };
+}
 /** Native implementation of the fail-soft session journal helper. */
-export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies = {}) {
+export function runSessionJournalFast(args, stdin, cwd, hqRoot, dependencies = {}) {
+    const result = runSessionJournalOperation(args, stdin, cwd, hqRoot, dependencies);
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    return result.code;
+}
+function executeSessionJournal(args, cwd, hqRoot, dependencies, writers) {
+    const warning = (message) => { writers.stderr(`session-journal: ${message}\n`); };
     const runtime = resolveSessionHelperRuntime(dependencies);
     const today = () => runtime.now().toISOString().slice(0, 10);
     const nowIso = () => runtime.now().toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -211,6 +269,7 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
             return 0;
         }
         const slug = slugify(title) || "entry";
+        const yamlSlug = slug.includes("\n") ? yamlDoubleQuoted(slug) : slug;
         const body = bodyFile && hasFile(bodyFile)
             ? fs.readFileSync(bodyFile, "utf8")
             : "## Goal\n\n## Findings\n\n## Decisions\n\n## Next\n";
@@ -226,7 +285,7 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
             for (let attempt = 0; attempt < 10_000; attempt += 1) {
                 seq = nextSequence(dir);
                 output = path.join(dir, `${seq}-${slug}.md`);
-                const lines = ["---\n", `ts: ${nowIso()}\n`, `title: ${title}\n`, `slug: ${slug}\n`];
+                const lines = ["---\n", `ts: ${nowIso()}\n`, `title: ${yamlDoubleQuoted(title)}\n`, `slug: ${yamlSlug}\n`];
                 if (files) {
                     lines.push("files:\n");
                     for (const file of files.split(","))
@@ -267,8 +326,8 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
         finally {
             releaseJournalWriteLock(writeLock);
         }
-        runToolCounter(root, "reset", counterKey(session || runtime.env.HQ_JOURNAL_SESSION || runtime.env.HQ_HOOK_SESSION_ID || ""), runtime.env, runtime.now);
-        process.stdout.write(`${output}\n`);
+        runToolCounter(root, "reset", counterKey(session || runtime.env.HQ_JOURNAL_SESSION || runtime.env.HQ_HOOK_SESSION_ID || ""), runtime.env, runtime.now, writers);
+        writers.stdout(`${output}\n`);
         return 0;
     }
     if (command === "list" || command === "read" || command === "index-path" || command === "dir-path") {
@@ -277,19 +336,19 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
         const date = options(afterSequence, ["--date"]).get("--date") || today();
         const dir = journalDir(root, date);
         if (command === "dir-path") {
-            process.stdout.write(dir);
+            writers.stdout(dir);
             return 0;
         }
         if (command === "index-path") {
-            process.stdout.write(`${dir}/INDEX.md\n`);
+            writers.stdout(`${dir}/INDEX.md\n`);
             return 0;
         }
         if (command === "list") {
             const index = path.join(dir, "INDEX.md");
             if (hasFile(index))
-                process.stdout.write(fs.readFileSync(index));
+                writers.stdout(fs.readFileSync(index));
             else
-                process.stdout.write(`(no journal for ${date})\n`);
+                writers.stdout(`(no journal for ${date})\n`);
             return 0;
         }
         if (!sequence) {
@@ -310,7 +369,7 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
             }
         })();
         if (match)
-            process.stdout.write(fs.readFileSync(path.join(dir, match)));
+            writers.stdout(fs.readFileSync(path.join(dir, match)));
         else
             warning(`read: no entry ${normalized} for ${date}`);
         return 0;
@@ -318,10 +377,10 @@ export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies =
     if (command === "tool-counter") {
         const action = rest[0] ?? "";
         const session = options(rest.slice(1), ["--session"]).get("--session") ?? "";
-        runToolCounter(root, action, session, runtime.env, runtime.now);
+        runToolCounter(root, action, session, runtime.env, runtime.now, writers);
         return 0;
     }
-    process.stderr.write(USAGE);
+    writers.stderr(USAGE);
     return 1;
 }
 //# sourceMappingURL=core-session-journal-native.js.map

package/dist/commands/core.js

@@ -47,6 +47,7 @@ import { registerCoreRefreshVaultAccessNative } from "./core-refresh-vault-acces
 import { registerCoreWorkMeshBindTrustedNative } from "./core-work-mesh-bind-trusted-native.js";
 import { registerCoreHookHelperNativeCommands } from "./core-native-hook-helper-commands.js";
 import { registerCoreHookStateHelpers } from "./core-hook-state-helpers-native.js";
+import { registerCoreHookBatchCommand } from "./core-hook-batch-command.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";
@@ -397,6 +398,7 @@ export function registerCoreCommands(program) {
     registerCoreWorkMeshBindTrustedNative(core);
     registerCoreHookHelperNativeCommands(core);
     registerCoreHookStateHelpers(core);
+    registerCoreHookBatchCommand(core);
     const sessionHelperCommands = [
         {
             name: "session-journal", asset: "core/scripts/session-journal.sh", root: "live",