@nanhara/hara 0.132.3 → 0.132.4

package/CHANGELOG.md

@@ -5,15 +5,26 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
-## 0.132.3 — 2026-07-22 — immediate prompt-key routing and verified release carrier
+## 0.132.4 — 2026-07-22 — release-class Intel readiness handshakes
+
+- Non-Git `@path` completion now skips the bounded Git inventory subprocess when no repository marker
+  exists. Slow or contended machines keep the full synchronous budget for the actual filesystem walk instead
+  of occasionally returning an empty completion list.
+- TUI streaming and semantic-cancellation regressions now synchronize on concrete composer, render, provider,
+  and completion handshakes rather than fixed millisecond sleeps. Main-branch CI also runs the complete suite
+  on the same Intel macOS class used for native releases before any immutable version tag is created.
+- This patch carries the complete 0.132 feature set into the native and Desktop release train. Upgrade with
+  `npm i -g @nanhara/hara@0.132.4`.
+
+## 0.132.3 — 2026-07-22 — immediate prompt-key routing (npm published; native assets withheld)
 
 - TUI approval/select input now reads the live visible prompt and selection through stable refs. A key pressed
   immediately after the prompt paints can no longer hit the previous render's null-prompt closure and be
   swallowed; rapid arrow-plus-Enter input also uses the current selection before the next paint.
 - The confirmation regression waits for the visible prompt and then presses `y` without an arbitrary grace
   delay, covering the Node 24 CI failure directly. Remaining process-tree fixtures also wait for valid PID
-  content rather than file creation alone. This patch carries the complete 0.132 feature set into the native
-  and Desktop release train. Upgrade with `npm i -g @nanhara/hara@0.132.3`.
+  content rather than file creation alone. The npm package is valid, but native assembly was withheld after
+  the release-class Intel lane exposed additional completion/render fixture races; upgrade to 0.132.4 instead.
 
 ## 0.132.2 — 2026-07-22 — complete bounded native release gates (npm published; native assets withheld)
 

package/dist/fs-walk.js

@@ -1,8 +1,8 @@
 // Shared filesystem walker — powers @file completion and the grep/glob tools.
 // Walks a directory tree, skipping noise dirs, capped so huge trees stay responsive.
-import { readdirSync, statSync } from "node:fs";
+import { lstatSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { opendir } from "node:fs/promises";
-import { join, relative, sep } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { execFile, execSync } from "node:child_process";
 import { fuzzyRank } from "./fuzzy.js";
 import { isSensitiveFilePath } from "./security/sensitive-files.js";
@@ -22,6 +22,37 @@ const DEFAULT_ASYNC_TIMEOUT_MS = 2_000;
 // interruptible. Keep them on a much tighter wall budget; agent/tool paths use the async APIs below.
 const DEFAULT_SYNC_TIMEOUT_MS = 250;
 const DEFAULT_YIELD_EVERY = 128;
+function gitMarkerOnPath(start) {
+    let dir = resolve(start);
+    for (let depth = 0; depth < 128; depth++) {
+        try {
+            lstatSync(join(dir, ".git"));
+            return true;
+        }
+        catch (error) {
+            // An unreadable or otherwise suspicious marker must still take the Git path. Only a definite
+            // absence permits the filesystem fallback to skip spawning Git.
+            if (error?.code !== "ENOENT")
+                return true;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+    return true;
+}
+function gitMarkerAbove(start) {
+    if (gitMarkerOnPath(start))
+        return true;
+    // Preserve worktree semantics when callers reach a repository through a symlinked project path.
+    try {
+        return gitMarkerOnPath(realpathSync.native(start));
+    }
+    catch {
+        return false;
+    }
+}
 function finiteLimit(value, fallback) {
     return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : fallback;
 }
@@ -228,6 +259,12 @@ export function listProjectFiles(root, cap = 8000) {
     if (recursiveRootContainsHome(root))
         return [];
     const startedAt = Date.now();
+    // On a non-repository directory, a contended `git ls-files` can consume the entire synchronous
+    // completion budget before the real filesystem walk starts. A bounded marker scan is sufficient to
+    // prove that Git cannot be authoritative here, leaving the budget for the user's actual files.
+    if (!gitMarkerAbove(root)) {
+        return walkFiles(root, cap, { timeoutMs: Math.max(0, DEFAULT_SYNC_TIMEOUT_MS - (Date.now() - startedAt)) });
+    }
     try {
         const out = execSync("git ls-files --cached --others --exclude-standard", {
             cwd: root,
@@ -288,6 +325,19 @@ export async function listProjectFilesAsync(root, options = {}) {
     if (cfg.maxEntries === 0)
         return result([], 0, 0, "entry_limit");
     const remaining = () => cfg.timeoutMs - (Date.now() - startedAt);
+    if (!gitMarkerAbove(root)) {
+        const timeoutMs = remaining();
+        if (timeoutMs <= 0)
+            return result([], 0, 0, "time_limit");
+        return walkFilesAsync(root, {
+            maxFiles: cfg.maxFiles,
+            maxDirectories: cfg.maxDirectories,
+            maxEntries: cfg.maxEntries,
+            timeoutMs,
+            signal: cfg.signal,
+            yieldEvery: cfg.yieldEvery,
+        });
+    }
     try {
         if (remaining() <= 0)
             return result([], 0, 0, "time_limit");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.132.3",
+  "version": "0.132.4",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "runtime-bootstrap.cjs"