@indigoai-us/hq-cli 5.345.126 → 5.345.128

package/CHANGELOG.md

@@ -2,7 +2,47 @@
 
 ## [Unreleased]
 
+## [5.345.128] — 2026-10-14
+- `hq auth refresh` now says which identity it ensured and where its token file is, for example `HQ session ensured (machine identity <name>; token file: <path>)` or `HQ session ensured (person session; token file: <path>)`. The identity is read after the refresh, so a fallback to the machine identity is reported as machine. Token values are never printed.
+- `hq auth refresh --json` prints `{refreshed, tokenSource, tokenFile, reason?}` on stdout and exits 1 when no session was refreshed.
+
+- A provider 429 or usage-limit error no longer holds the account. This
+  replaces the 15-minute first-strike hold (`quota_default_hold_ms`) and its
+  promotion to the provider reset described in the credential and quota-hold entry,
+  and applies to every provider: the `HQ_LANES_CLAUDE_QUOTA_HOLDS` toggle is
+  removed and Codex and Grok 429s no longer hold an account either. The lane
+  that hit it ends `interrupted` (or `failed` with no partial output) with
+  reason `account_quota_exhausted`, stays resumable, and its senior gets one
+  notice naming the provider's reset and the `hq lanes resume` command. The
+  lane is not moved to another account automatically. Other lanes keep using
+  the account. `personal/lanes/quota.json` still records the last limit hit
+  and the provider's reset, shown as `last_quota_hit_at` and
+  `provider_reset_at` in `hq lanes capacity` and `hq lanes accounts list`;
+  nothing gates on them. `clear-quota` clears the record. A model marked as
+  needing credits on an account still skips that account for that model.
+- Queued lanes are admitted in-process, so the queue drains without
+  `hq daemon`. `hq lanes create`, `hq lanes stop` (including cancelling a
+  queued lane), `hq lanes accounts clear-quota`, and a lane's watcher when
+  the lane exits run queue admission under the existing locks and report the
+  admitted lanes as `admitted` in their JSON output.
+- A queued loop lane whose queue holds only a stop envelope is finished in
+  place by `hq lanes stop`, and by `hq lanes create` for the same worker, so
+  it no longer counts as `worker_lane_busy` while waiting for admission.
+- Claude reset times parse from the structured `resetsAt` on a result when
+  present, and "resets Oct 16 at 1am (America/Denver)" style messages (the
+  `at` form and IANA zones) parse correctly. A needs-credits refusal names
+  the account's email and org and prints the `hq lanes accounts clear-quota`
+  command that clears the marker.
+- `hq skill create` writes the skill slug as the SKILL.md frontmatter `name` and the display title (`--name`) as frontmatter `title` and the heading. A spaced title in `name` stopped the Claude desktop app from sending the slash command.
+
+## [5.345.127] — 2026-10-14
+- Add native `hq core handoff-sync-prefetch` and `hq core handoff-sync-publish` commands behind the `core-native-bucket-c` family gate, with pinned shell rollback assets.
+- Add native `hq core hq-detach` and `hq core handoff-knowledge-commit` commands behind the `core-native-bucket-c` family gate, with pinned shell rollback assets.
+
 ## [5.345.126] — 2026-10-14
+- Claude quota holds are off. A Claude 429 still moves that lane to another account, but it no longer blocks the account for other lanes, and any stored Claude hold is ignored. Set `HQ_LANES_CLAUDE_QUOTA_HOLDS=1` to turn the old behavior back on. Codex and Grok holds are unchanged.
+- Remote Control lanes on the default Claude account now use your normal Claude login too. 5.345.125 fixed this for regular lanes only.
+
 - `hq lanes` resume no longer picks a stale transcript when the same session exists in more than one account home. It uses the copy from the home the lane last ran in, and otherwise refuses with `provider_transcript_ambiguous` naming the homes.
 
 ## [5.345.125] — 2026-10-14

package/assets/scaffold/core/scripts/handoff-knowledge-commit.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# Commit only knowledge-repo files explicitly named by the handoff changeset.
+set -euo pipefail
+
+usage() {
+  echo "Usage: $0 --files-touched-json-file <path> [--root <hq-root>]" >&2
+  exit 2
+}
+
+changeset=""
+root="$(pwd -P)"
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --files-touched-json-file) [ "$#" -ge 2 ] || usage; changeset="$2"; shift 2 ;;
+    --root) [ "$#" -ge 2 ] || usage; root="$2"; shift 2 ;;
+    *) usage ;;
+  esac
+done
+[ -n "$changeset" ] && [ -f "$changeset" ] || usage
+root="$(cd "$root" && pwd -P)"
+tmp_parent="$root/workspace/threads/.handoff-tmp"
+mkdir -p "$tmp_parent"
+tmp_dir="$(mktemp -d "$tmp_parent/handoff-knowledge-commit.XXXXXX")"
+trap 'rm -rf "$tmp_dir"' EXIT
+handled_paths="$tmp_dir/handled-paths"
+: > "$handled_paths"
+
+jq -e 'def safe_path: type == "string" and length > 0 and (startswith("/") | not) and (split("/") | all(.[]; . != "" and . != "." and . != "..")) and (contains("\n") | not) and (contains("\r") | not); type == "array" and all(.[]; if type == "string" then safe_path else type == "object" and (.path | safe_path) end)' "$changeset" >/dev/null || {
+  echo "handoff knowledge commit: changeset must be an array of safe relative file paths (files, not folders: no trailing slash, no absolute paths, no .. segments)" >&2
+  jq -r 'def safe_path: type == "string" and length > 0 and (startswith("/") | not) and (split("/") | all(.[]; . != "" and . != "." and . != "..")) and (contains("\n") | not) and (contains("\r") | not); if type == "array" then (.[] | select((if type == "string" then . elif type == "object" then .path else null end) | safe_path | not) | "  offending entry: " + tojson) else "  the changeset is not a JSON array" end' "$changeset" 2>/dev/null | head -5 >&2 || true
+  exit 1
+}
+
+for knowledge_path in "$root"/core/knowledge/public/* "$root"/core/knowledge/private/* "$root"/personal/knowledge/* "$root"/companies/*/knowledge; do
+  [ -e "$knowledge_path" ] || [ -L "$knowledge_path" ] || continue
+  knowledge_rel="${knowledge_path#"$root"/}"
+  if [ -L "$knowledge_path" ]; then
+    case "$knowledge_path" in
+      "$root"/companies/*/knowledge)
+        echo "INVALID-LINK: $knowledge_rel is a symlink; company knowledge must be a plain directory synced through the company vault"
+        ;;
+      *)
+        repo_dir="$(git -C "$knowledge_path" rev-parse --show-toplevel 2>/dev/null)" || continue
+        repo_real="$(cd "$repo_dir" && pwd -P)"
+        hq_repo="$(git -C "$root" rev-parse --show-toplevel 2>/dev/null)" || hq_repo=""
+        hq_repo_real=""
+        [ -z "$hq_repo" ] || hq_repo_real="$(cd "$hq_repo" && pwd -P)"
+        [ "$repo_real" = "$hq_repo_real" ] && continue
+        dirty="$(git -C "$repo_dir" status --porcelain)"
+        [ -n "$dirty" ] || continue
+        echo "INVALID-DIRTY: $knowledge_rel is a legacy knowledge symlink to $repo_dir with uncommitted changes — NOT auto-committed; run hq reindex to materialize it, then commit, before archiving this session"
+        ;;
+    esac
+    continue
+  fi
+  case "$knowledge_path" in
+    "$root"/companies/*/knowledge) continue ;;
+  esac
+  [ -e "$knowledge_path/.git" ] || continue
+  repo_dir="$(git -C "$knowledge_path" rev-parse --show-toplevel 2>/dev/null)" || continue
+  knowledge_real="$(cd "$knowledge_path" && pwd -P)"
+  repo_real="$(cd "$repo_dir" && pwd -P)"
+  [ "$knowledge_real" = "$repo_real" ] || continue
+  knowledge_rel="${knowledge_path#"$root"/}"
+  repo_paths=()
+  while IFS= read -r touched_path; do
+    case "$touched_path" in
+      "$knowledge_rel"/*) relative_path="${touched_path#"$knowledge_rel"/}" ;;
+      *) continue ;;
+    esac
+    case "/$relative_path/" in */../*|*/./*)
+      echo "handoff knowledge commit: unsafe path in changeset: $touched_path" >&2
+      exit 1
+      ;;
+    esac
+    [ -n "$relative_path" ] || continue
+    if [ -d "$repo_dir/$relative_path" ]; then
+      printf '%s\n' "$touched_path" >> "$handled_paths"
+      while IFS= read -r -d '' status_entry; do
+        status_code="${status_entry:0:2}"
+        status_path="${status_entry:3}"
+        case "$status_code" in *R*|*C*) IFS= read -r -d '' original_path || original_path="" ;; esac
+        case "$status_path" in
+          "$relative_path"/*)
+            repo_paths+=("$status_path")
+            printf '%s/%s\n' "$knowledge_rel" "$status_path" >> "$handled_paths"
+            ;;
+        esac
+        case "$status_code" in *R*|*C*)
+          case "$original_path" in
+            "$relative_path"/*)
+              repo_paths+=("$original_path")
+              printf '%s/%s\n' "$knowledge_rel" "$original_path" >> "$handled_paths"
+              ;;
+          esac
+          ;;
+        esac
+      done < <(git -C "$repo_dir" status --porcelain=v1 -z --untracked-files=all -- "$relative_path")
+      continue
+    fi
+    if [ ! -e "$repo_dir/$relative_path" ] && ! git -C "$repo_dir" ls-files --error-unmatch -- "$relative_path" >/dev/null 2>&1; then
+      continue
+    fi
+    repo_paths+=("$relative_path")
+    printf '%s\n' "$touched_path" >> "$handled_paths"
+  done < <(jq -r '.[] | if type == "string" then . else .path end' "$changeset")
+
+  [ "${#repo_paths[@]}" -gt 0 ] || continue
+  changed="$(git -C "$repo_dir" status --porcelain -- "${repo_paths[@]}")"
+  [ -n "$changed" ] || continue
+  git -C "$repo_dir" add -- "${repo_paths[@]}"
+  git -C "$repo_dir" commit --only -m "checkpoint: save session knowledge changes" -- "${repo_paths[@]}"
+done
+
+while IFS= read -r touched_path; do
+  case "$touched_path" in
+    core/knowledge/public/*|core/knowledge/private/*|personal/knowledge/*)
+      if ! grep -Fqx -- "$touched_path" "$handled_paths"; then
+        echo "NOT-COMMITTED: $touched_path is listed in the handoff changeset but no knowledge repository committed it"
+      fi
+      ;;
+  esac
+done < <(jq -r '.[] | if type == "string" then . else .path end' "$changeset")

package/assets/scaffold/core/scripts/hq-detach.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# 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
+
+PIDFILE=""
+OWNER_PIDFILE=""
+LOGFILE="/dev/null"
+HANDOFF_MODE=0
+CMD=()
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --handoff) HANDOFF_MODE=1; shift ;;
+    --pidfile) PIDFILE="${2:-}"; shift 2 ;;
+    --owner-pidfile) OWNER_PIDFILE="${2:-}"; shift 2 ;;
+    --logfile) LOGFILE="${2:-}"; shift 2 ;;
+    --) shift; CMD=("$@"); break ;;
+    -h|--help)
+      sed -n '2,14p' "$0" | sed 's/^# \{0,1\}//'
+      exit 0
+      ;;
+    *)
+      echo "hq-detach: unexpected argument: $1 (use -- before the command)" >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [ ${#CMD[@]} -eq 0 ]; then
+  echo "hq-detach: missing command after --" >&2
+  exit 2
+fi
+
+write_pid() {
+  local pid="$1"
+  [ -n "$PIDFILE" ] || return 0
+  mkdir -p "$(dirname "$PIDFILE")" 2>/dev/null || true
+  printf '%s\n' "$pid" > "$PIDFILE"
+}
+
+# A caller can ask us to capture the current session owner before the child is
+# detached. PID plus process start time prevents a reused PID from making an
+# orphan look supervised.
+process_args() {
+  local target="$1"
+  # `ps -eww` avoids argument truncation; filter its complete listing back to
+  # the exact PID because combining -e and -p selects all processes on Linux.
+  ps -eww -o pid=,args= 2>/dev/null | awk -v target="$target" '$1 == target { $1=""; sub(/^[[:space:]]+/, ""); print; exit }'
+}
+
+is_session_command() {
+  local cmd="$1" executable script third
+  executable="$(printf '%s\n' "$cmd" | awk '{print $1}')"
+  script="$(printf '%s\n' "$cmd" | awk '{print $2}')"
+  third="$(printf '%s\n' "$cmd" | awk '{print $3}')"
+  case "${executable##*/}" in
+    claude|codex|codex-code-mode-host|grok|grok-cli) return 0 ;;
+    bash|sh|zsh|dash|ksh|node)
+      case "${script##*/}" in claude|codex|codex-code-mode-host|grok|grok-cli) return 0 ;; esac
+      ;;
+    env)
+      case "${script##*/}" in
+        claude|codex|codex-code-mode-host|grok|grok-cli) return 0 ;;
+        bash|sh|zsh|dash|ksh)
+          case "${third##*/}" in claude|codex|codex-code-mode-host|grok|grok-cli) return 0 ;; esac
+          ;;
+      esac
+      ;;
+  esac
+  return 1
+}
+
+write_owner() {
+  local candidate="$PPID" hops=0 args parent started=""
+  [ -n "$OWNER_PIDFILE" ] || return 0
+  while [ -n "$candidate" ] && [ "$candidate" != "0" ] && [ "$candidate" != "1" ] && [ "$hops" -lt 24 ]; do
+    args="$(process_args "$candidate" || true)"
+    if is_session_command "$args"; then
+      started="$(ps -o lstart= -p "$candidate" 2>/dev/null | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' || true)"
+      if [ -n "$started" ]; then
+        mkdir -p "$(dirname "$OWNER_PIDFILE")" 2>/dev/null || true
+        printf '%s\n%s\n' "$candidate" "$started" > "$OWNER_PIDFILE"
+      fi
+      return 0
+    fi
+    parent="$(ps -o ppid= -p "$candidate" 2>/dev/null | tr -d '[:space:]' || true)"
+    candidate="$parent"
+    hops=$((hops + 1))
+  done
+  return 0
+}
+
+write_owner
+WINDOWS_SHELL=0
+if [ "$HANDOFF_MODE" = "1" ]; then
+  case "$(uname -s)" in
+    MINGW*|MSYS*|CYGWIN*) WINDOWS_SHELL=1 ;;
+  esac
+  if [ "$WINDOWS_SHELL" = "0" ]; then
+    nohup "${CMD[@]}" </dev/null >>"$LOGFILE" 2>&1 &
+    write_pid "$!"
+    disown "$!" 2>/dev/null || true
+    exit 0
+  fi
+fi
+
+# setsid(1) lookup. Linux has it on PATH. On macOS it arrives only via Homebrew
+# util-linux, which is keg-only — not symlinked into the PATH — so probe the keg
+# prefixes directly rather than assuming an interactive shell exported them.
+SETSID_BIN=""
+if [ "${HQ_DETACH_FORCE_NODE:-}" != "1" ] && [ "$WINDOWS_SHELL" = "0" ]; then
+  for candidate in setsid /opt/homebrew/opt/util-linux/bin/setsid /usr/local/opt/util-linux/bin/setsid; do
+    if command -v "$candidate" >/dev/null 2>&1; then
+      SETSID_BIN="$candidate"
+      break
+    fi
+  done
+fi
+
+if [ -n "$SETSID_BIN" ]; then
+  "$SETSID_BIN" "${CMD[@]}" </dev/null >>"$LOGFILE" 2>&1 &
+  write_pid "$!"
+  disown "$!" 2>/dev/null || true
+  exit 0
+fi
+
+NODE="${HQ_DETACH_NODE:-node}"
+if ! command -v "$NODE" >/dev/null 2>&1; then
+  echo "hq-detach: neither setsid(1) nor $NODE is available" >&2
+  exit 1
+fi
+
+# Native Windows Node cannot open MSYS paths such as /tmp/x.log, so hand it a
+# C:/... form (same conversion as portable_native_path in lib/portable.sh).
+if [ "$WINDOWS_SHELL" = "1" ] && [ "$LOGFILE" != "/dev/null" ] && command -v cygpath >/dev/null 2>&1; then
+  LOGFILE="$(cygpath -m "$LOGFILE" 2>/dev/null || printf '%s' "$LOGFILE")"
+fi
+
+# argv: node -e <script> -- <cmd...>
+export HQ_DETACH_LOGFILE="$LOGFILE"
+[ "$WINDOWS_SHELL" = "0" ] || export HQ_DETACH_WINDOWS_SHELL=1
+CHILD_PID="$("$NODE" -e '
+const {spawn} = require("child_process");
+const fs = require("fs");
+const cmd = process.argv.slice(1);
+if (!cmd.length) process.exit(2);
+const logfile = process.env.HQ_DETACH_LOGFILE || "/dev/null";
+const out = logfile === "/dev/null" ? "ignore" : fs.openSync(logfile, "a");
+const child = spawn(cmd[0], cmd.slice(1), {
+  detached: true,
+  windowsHide: process.platform === "win32" || process.env.HQ_DETACH_WINDOWS_SHELL === "1",
+  stdio: ["ignore", out, out],
+});
+if (out !== "ignore") fs.closeSync(out);
+child.unref();
+process.stdout.write(String(child.pid));
+' -- "${CMD[@]}")"
+write_pid "$CHILD_PID"
+exit 0

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

@@ -1598,7 +1598,11 @@ export declare const COMMAND_CATALOG: readonly [{
         readonly usage: "[options]";
         readonly helpText: readonly [];
         readonly arguments: readonly [];
-        readonly options: readonly [];
+        readonly options: readonly [{
+            readonly flags: "--json";
+            readonly description: "Print {refreshed, tokenSource, tokenFile, reason?} as JSON";
+            readonly hidden: false;
+        }];
         readonly subcommands: readonly [];
     }, {
         readonly name: "status";
@@ -3306,7 +3310,7 @@ export declare const COMMAND_CATALOG: readonly [{
         }];
         readonly options: readonly [{
             readonly flags: "--name <name>";
-            readonly description: "Display name when creating a new template";
+            readonly description: "Display title for a new template, written as frontmatter title (frontmatter name is always the slug)";
             readonly hidden: false;
         }, {
             readonly flags: "--description <text>";
@@ -9545,6 +9549,40 @@ export declare const COMMAND_CATALOG: readonly [{
         }];
         readonly options: readonly [];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "hq-detach";
+        readonly description: "Detach a command from the parent turn";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: false;
+        readonly helpCommand: false;
+        readonly usage: "[args...]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "args";
+            readonly required: false;
+            readonly variadic: true;
+            readonly description: "arguments passed through to the script";
+        }];
+        readonly options: readonly [];
+        readonly subcommands: readonly [];
+    }, {
+        readonly name: "handoff-knowledge-commit";
+        readonly description: "Commit only knowledge files listed in a handoff changeset";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: false;
+        readonly helpCommand: false;
+        readonly usage: "[args...]";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "args";
+            readonly required: false;
+            readonly variadic: true;
+            readonly description: "arguments passed through to the script";
+        }];
+        readonly options: readonly [];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "hq-task";
         readonly description: "List and update tasks on personal or company boards";

package/dist/command-catalog.generated.js

@@ -1907,7 +1907,13 @@ export const COMMAND_CATALOG = [
                 "usage": "[options]",
                 "helpText": [],
                 "arguments": [],
-                "options": [],
+                "options": [
+                    {
+                        "flags": "--json",
+                        "description": "Print {refreshed, tokenSource, tokenFile, reason?} as JSON",
+                        "hidden": false
+                    }
+                ],
                 "subcommands": []
             },
             {
@@ -3985,7 +3991,7 @@ export const COMMAND_CATALOG = [
                 "options": [
                     {
                         "flags": "--name <name>",
-                        "description": "Display name when creating a new template",
+                        "description": "Display title for a new template, written as frontmatter title (frontmatter name is always the slug)",
                         "hidden": false
                     },
                     {
@@ -11567,6 +11573,46 @@ export const COMMAND_CATALOG = [
                 "options": [],
                 "subcommands": []
             },
+            {
+                "name": "hq-detach",
+                "description": "Detach a command from the parent turn",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": false,
+                "helpCommand": false,
+                "usage": "[args...]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "args",
+                        "required": false,
+                        "variadic": true,
+                        "description": "arguments passed through to the script"
+                    }
+                ],
+                "options": [],
+                "subcommands": []
+            },
+            {
+                "name": "handoff-knowledge-commit",
+                "description": "Commit only knowledge files listed in a handoff changeset",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": false,
+                "helpCommand": false,
+                "usage": "[args...]",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "args",
+                        "required": false,
+                        "variadic": true,
+                        "description": "arguments passed through to the script"
+                    }
+                ],
+                "options": [],
+                "subcommands": []
+            },
             {
                 "name": "hq-task",
                 "description": "List and update tasks on personal or company boards",

package/dist/commands/auth.js

@@ -323,10 +323,27 @@ export function registerAuthCommands(program) {
     authCmd
         .command("refresh")
         .description("Ensure a valid cached Cognito session (refresh only if expiring; no-op if already valid)")
-        .action(async () => {
+        .option("--json", "Print {refreshed, tokenSource, tokenFile, reason?} as JSON")
+        .action(async (opts) => {
         const result = await refreshCachedSession();
+        // Resolve after the refresh so a machine fallback (or a person session
+        // marked rejected during the refresh) is reported as what was ensured.
+        const tokenSource = resolveCognitoTokenSource();
+        const tokenFile = tokenSource === "machine" ? machineTokenCacheFile() : personTokenCacheFile();
+        if (opts.json) {
+            console.log(JSON.stringify({
+                refreshed: result.refreshed,
+                tokenSource,
+                tokenFile,
+                ...(result.reason !== undefined ? { reason: result.reason } : {}),
+            }));
+            if (!result.refreshed)
+                process.exit(1);
+            return;
+        }
         if (result.refreshed) {
-            console.log(chalk.green("HQ session ensured"));
+            const identity = tokenSource === "machine" ? machineIdentityLabel() : "person session";
+            console.log(chalk.green(`HQ session ensured (${identity}; token file: ${tokenFile})`));
             return;
         }
         console.error(chalk.yellow(`No valid session: ${result.reason ?? "unknown"}`));

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

@@ -0,0 +1,2 @@
+export declare function runHandoffKnowledgeCommitFast(args: string[], _stdin: string, cwd: string): number;
+//# sourceMappingURL=core-bucket-c-handoff-knowledge-fast.d.ts.map

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

@@ -0,0 +1,10 @@
+import { runHandoffKnowledgeCommit } from "./core-bucket-c-handoff-knowledge-native.js";
+export function runHandoffKnowledgeCommitFast(args, _stdin, cwd) {
+    const result = runHandoffKnowledgeCommit(args, cwd);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+//# sourceMappingURL=core-bucket-c-handoff-knowledge-fast.js.map

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

@@ -0,0 +1,46 @@
+export declare const HANDOFF_KNOWLEDGE_COMMIT_ASSET = "core/scripts/handoff-knowledge-commit.sh";
+export type KnowledgeCommitResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+type CommandResult = {
+    status: number | null;
+    stdout: string | Buffer;
+    stderr: string | Buffer;
+};
+type GitRunner = (args: string[], cwd: string) => CommandResult;
+declare function samePath(left: string, right: string): boolean;
+declare function windowsNativePath(value: string): string;
+declare function safePath(value: unknown): value is string;
+declare function validChangeset(value: unknown): value is (string | {
+    path: string;
+})[];
+declare function entriesUnder(root: string): string[];
+declare function gitRoot(git: GitRunner, cwd: string): string;
+declare function statusPaths(git: GitRunner, repo: string, relative: string): {
+    paths: string[];
+    originals: string[];
+};
+declare function expandTouched(git: GitRunner, repo: string, knowledgeRel: string, touched: string): {
+    paths: string[];
+    handled: string[];
+};
+declare function parseNulPaths(status: string): {
+    paths: string[];
+    originals: string[];
+};
+export declare function runHandoffKnowledgeCommit(args: readonly string[], cwd?: string, git?: GitRunner): KnowledgeCommitResult;
+export declare const __handoffKnowledgeTest: {
+    safePath: typeof safePath;
+    validChangeset: typeof validChangeset;
+    entriesUnder: typeof entriesUnder;
+    statusPaths: typeof statusPaths;
+    parseNulPaths: typeof parseNulPaths;
+    expandTouched: typeof expandTouched;
+    gitRoot: typeof gitRoot;
+    samePath: typeof samePath;
+    windowsNativePath: typeof windowsNativePath;
+};
+export {};
+//# sourceMappingURL=core-bucket-c-handoff-knowledge-native.d.ts.map