@oscharko-dev/keiko 0.2.0-beta.3 → 0.2.0-beta.5

package/node_modules/@oscharko-dev/keiko-workspace/dist/gitHistory.js

@@ -9,6 +9,7 @@
 // non-empty because git-history is a repo-level signal that cannot meaningfully scope to a
 // sub-folder.
 import { createHash } from "node:crypto";
+import { isAbsolute, normalize } from "node:path";
 import { redact } from "@oscharko-dev/keiko-security";
 import { resolveWithinWorkspace } from "./paths.js";
 import { assertContainedRealPath } from "./realpath.js";
@@ -19,11 +20,15 @@ function queryFingerprint(query) {
 }
 const GIT_DIR_PREFIX = "gitdir:";
 const HEAD_MAX_BYTES = 256;
+const GIT_POINTER_MAX_BYTES = 4096;
 const REFLOG_MAX_BYTES = 1_048_576;
 const REFLOG_MAX_LINES = 10_000;
 function isAllowedExternalGitdir(candidate) {
     return candidate.replace(/\\/g, "/").includes("/.git/worktrees/");
 }
+function containsParentTraversal(candidate) {
+    return candidate.split(/[\\/]+/).includes("..");
+}
 async function readGuardedAbsolute(fs, base, absolutePath, label, maxBytes) {
     try {
         assertContainedRealPath(fs, base, absolutePath, label);
@@ -68,20 +73,49 @@ async function readGuardedAbsolute(fs, base, absolutePath, label, maxBytes) {
 function statOrUndefined(fs, abs) {
     try {
         const stat = fs.stat(abs);
-        return { isFile: stat.isFile, isDirectory: stat.isDirectory };
+        return {
+            size: stat.size,
+            isFile: stat.isFile,
+            isDirectory: stat.isDirectory,
+            hardLinkCount: stat.hardLinkCount,
+        };
     }
     catch {
         return undefined;
     }
 }
-function readWorktreePointerTarget(fs, dotGit) {
-    let raw;
+async function readSmallUtf8File(fs, abs, maxBytes) {
+    const stat = statOrUndefined(fs, abs);
+    if (!stat?.isFile) {
+        return undefined;
+    }
+    if (stat.hardLinkCount !== undefined && stat.hardLinkCount > 1) {
+        return undefined;
+    }
+    if (stat.size > maxBytes) {
+        return undefined;
+    }
+    if (fs.readFileBytes !== undefined) {
+        try {
+            const bytes = await fs.readFileBytes(abs, maxBytes);
+            return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+        }
+        catch {
+            return undefined;
+        }
+    }
     try {
-        raw = fs.readFileUtf8(dotGit);
+        return fs.readFileUtf8(abs);
     }
     catch {
         return undefined;
     }
+}
+async function readWorktreePointerTarget(fs, dotGit) {
+    const raw = await readSmallUtf8File(fs, dotGit, GIT_POINTER_MAX_BYTES);
+    if (raw === undefined) {
+        return undefined;
+    }
     const trimmed = raw.trim();
     if (!trimmed.startsWith(GIT_DIR_PREFIX)) {
         return undefined;
@@ -92,23 +126,45 @@ function readWorktreePointerTarget(fs, dotGit) {
     }
     return target;
 }
-function isContainedAndPresent(fs, base, abs, label) {
+function containedPathIfPresent(fs, base, abs, label) {
     try {
-        assertContainedRealPath(fs, base, abs, label);
+        const contained = assertContainedRealPath(fs, base, abs, label);
+        if (!fs.exists(contained)) {
+            return undefined;
+        }
+        return contained;
     }
     catch {
-        return false;
+        return undefined;
     }
-    return fs.exists(abs);
 }
-function acceptsPointedGitdir(fs, root, target, candidate) {
-    if (!target.startsWith("/")) {
-        return true;
+function isContainedAndPresent(fs, base, abs, label) {
+    return containedPathIfPresent(fs, base, abs, label) !== undefined;
+}
+function resolvePointedGitdir(fs, root, target, candidate) {
+    if (!isAbsolute(target)) {
+        try {
+            return assertContainedRealPath(fs, root, candidate, ".git pointer");
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (containsParentTraversal(target)) {
+        return undefined;
     }
-    if (isContainedAndPresent(fs, root, candidate, ".git pointer")) {
-        return true;
+    const contained = containedPathIfPresent(fs, root, candidate, ".git pointer");
+    if (contained !== undefined) {
+        return contained;
+    }
+    let canonical;
+    try {
+        canonical = fs.realPath(candidate);
     }
-    return isAllowedExternalGitdir(candidate);
+    catch {
+        return undefined;
+    }
+    return isAllowedExternalGitdir(canonical) ? canonical : undefined;
 }
 // Find the first 10-digit run that is not preceded by '<'. Avoids regex backtracking.
 function firstUnixTimestamp(line) {
@@ -170,7 +226,7 @@ function gitHeadAtom(scope, fingerprint, nowMs) {
 // Strategy: check whether HEAD lives directly at `.git/HEAD` first (covers the normal case AND
 // the memFs directory simulation where only child keys are recorded); fall back to treating
 // `.git` as a worktree-pointer file only when that leaf check fails.
-function resolveGitdir(fs, root) {
+async function resolveGitdir(fs, root) {
     const dotGit = resolveWithinWorkspace(root, ".git");
     const headDirect = `${dotGit}/HEAD`;
     // Fast path: HEAD exists directly under .git — this is the standard directory layout.
@@ -188,31 +244,32 @@ function resolveGitdir(fs, root) {
         return undefined;
     }
     // Worktree-pointer: read the `gitdir: <path>` value, validate containment once.
-    const target = readWorktreePointerTarget(fs, dotGit);
+    const target = await readWorktreePointerTarget(fs, dotGit);
     if (target === undefined) {
         return undefined;
     }
-    const candidate = target.startsWith("/") ? target : resolveWithinWorkspace(root, target);
+    const candidate = isAbsolute(target) ? normalize(target) : resolveWithinWorkspace(root, target);
     // Real git worktrees usually point outside the checkout root to `.git/worktrees/<name>`.
     // Allow that one narrow shape, but still constrain the actual reads to files whose realpaths
     // stay inside the resolved gitdir itself.
-    if (!acceptsPointedGitdir(fs, root, target, candidate)) {
+    const gitdir = resolvePointedGitdir(fs, root, target, candidate);
+    if (gitdir === undefined) {
         return undefined;
     }
-    const pointedHead = `${candidate}/HEAD`;
-    if (!isContainedAndPresent(fs, candidate, pointedHead, ".git-pointer/HEAD")) {
+    const pointedHead = `${gitdir}/HEAD`;
+    if (!isContainedAndPresent(fs, gitdir, pointedHead, ".git-pointer/HEAD")) {
         return undefined;
     }
-    return candidate;
+    return gitdir;
 }
-function isAvailableForScope(scope, fs) {
+async function isAvailableForScope(scope, fs) {
     // Finding 8: git-history is a repo-level signal; sub-folder scoping is meaningless and
     // would require reading outside the user-selected boundary.
     if (scope.relativePaths.length > 0) {
         return false;
     }
     const root = scope.workspace.root;
-    const gitdir = resolveGitdir(fs, root);
+    const gitdir = await resolveGitdir(fs, root);
     if (gitdir === undefined) {
         return false;
     }
@@ -222,12 +279,12 @@ function isAvailableForScope(scope, fs) {
 }
 export const gitHistoryAdapter = {
     name: "git-history",
-    isAvailable: (scope, fs) => {
+    isAvailable: async (scope, fs) => {
         try {
-            return Promise.resolve(isAvailableForScope(scope, fs));
+            return await isAvailableForScope(scope, fs);
         }
         catch {
-            return Promise.resolve(false);
+            return false;
         }
     },
     lookup: async (scope, query, limits, fs, deps) => {
@@ -239,7 +296,7 @@ export const gitHistoryAdapter = {
         }
         const root = scope.workspace.root;
         // Finding 7: resolve the real gitdir so worktree-pointer layouts work end-to-end.
-        const gitdir = resolveGitdir(fs, root);
+        const gitdir = await resolveGitdir(fs, root);
         if (gitdir === undefined) {
             return [];
         }

package/node_modules/@oscharko-dev/keiko-workspace/dist/ignore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../src/ignore.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAgFjD,CAAC;AA+BH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAajD;AAMD,UAAU,UAAU;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAGvB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAkFD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CASrE;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAS1F"}
+{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../src/ignore.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAmGjD,CAAC;AA+BH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAajD;AAMD,UAAU,UAAU;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAGvB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAkFD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CASrE;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAS1F"}

package/node_modules/@oscharko-dev/keiko-workspace/dist/ignore.js

@@ -67,11 +67,30 @@ export const DEFAULT_DENY_PATTERNS = Object.freeze([
     ".node_repl_history",
     ".irb_history",
     "service-account*.json",
+    // Epic #177 post-closure audit: additional pure-credential FILES denied outright. These filenames
+    // hold secrets by convention (cloud storage keys, OAuth tokens, VCS/registry/shell credentials,
+    // IaC variables); secret-shaped content in otherwise-allowed files is still scrubbed by the
+    // redaction layer as defence-in-depth.
+    ".s3cfg",
+    ".boto",
+    ".dockercfg",
+    ".gitconfig",
+    ".envrc",
+    "*.tfvars",
+    "*.tfvars.json",
+    ".terraformrc",
     // deps
     "node_modules",
     // Keiko runtime/evidence state. These files are internal product artifacts, not repository
     // source, and must never be discoverable through connected repository grounding.
     ".keiko",
+    "keiko.config.json",
+    // Local tool and IDE runtime state. These directories can contain prompts, transcripts,
+    // worktrees, extension caches, shelves, and machine-local metadata; they are not source context.
+    ".codex",
+    ".claude",
+    ".playwright-mcp",
+    ".idea",
     // build
     "dist",
     "build",

package/node_modules/@oscharko-dev/keiko-workspace/dist/importGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"importGraph.d.ts","sourceRoot":"","sources":["../src/importGraph.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,iBAAiB,EAAyB,MAAM,yBAAyB,CAAC;AA4HxF,eAAO,MAAM,kBAAkB,EAAE,iBAkChC,CAAC"}
+{"version":3,"file":"importGraph.d.ts","sourceRoot":"","sources":["../src/importGraph.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,iBAAiB,EAAyB,MAAM,yBAAyB,CAAC;AA+HxF,eAAO,MAAM,kBAAkB,EAAE,iBAkChC,CAAC"}

package/node_modules/@oscharko-dev/keiko-workspace/dist/importGraph.js

@@ -85,9 +85,12 @@ function elapsedOver(ctx) {
 }
 async function scanFileForImports(ctx, relativePath, atoms) {
     const abs = resolveWithinWorkspace(ctx.scope.workspace.root, relativePath);
-    assertContainedRealPath(ctx.fs, ctx.scope.workspace.root, abs, "scope");
-    const stat = ctx.fs.stat(abs);
-    if (await probeBinary(ctx.fs, abs, stat.size)) {
+    const containedAbs = assertContainedRealPath(ctx.fs, ctx.scope.workspace.root, abs, "scope");
+    const stat = ctx.fs.stat(containedAbs);
+    if (stat.hardLinkCount !== undefined && stat.hardLinkCount > 1) {
+        return;
+    }
+    if (await probeBinary(ctx.fs, containedAbs, stat.size)) {
         return;
     }
     const content = readWorkspaceFile(ctx.scope.workspace, relativePath, { maxBytes: ctx.limits.maxBytesPerFileScanned }, ctx.fs);

package/node_modules/@oscharko-dev/keiko-workspace/dist/realpath.d.ts

@@ -2,6 +2,7 @@ import type { WorkspaceFs } from "./fs.js";
 export interface ContainedRealPathInfo {
     readonly path: string;
     readonly realRelative: string;
+    readonly realBase: string;
 }
 export declare function containedRealPathInfo(fs: WorkspaceFs, root: string, absolutePath: string): ContainedRealPathInfo;
 export declare function assertContainedRealPath(fs: WorkspaceFs, root: string, absolutePath: string, _label: string): string;

package/node_modules/@oscharko-dev/keiko-workspace/dist/realpath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"realpath.d.ts","sourceRoot":"","sources":["../src/realpath.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAqC3C,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GACnB,qBAAqB,CAwBvB;AAQD,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,MAAM,CAGR"}
+{"version":3,"file":"realpath.d.ts","sourceRoot":"","sources":["../src/realpath.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAqC3C,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAI9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GACnB,qBAAqB,CAwBvB;AAQD,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,MAAM,CAGR"}

package/node_modules/@oscharko-dev/keiko-workspace/dist/realpath.js

@@ -47,7 +47,7 @@ export function containedRealPathInfo(fs, root, absolutePath) {
         if (!isWithinWorkspace(realBase, target)) {
             throw new PathEscapeError(`path escapes the workspace boundary via symlink: ${absolutePath}`, absolutePath);
         }
-        return { path: target, realRelative: toRelative(realBase, target) };
+        return { path: target, realRelative: toRelative(realBase, target), realBase };
     }
     catch (error) {
         if (error instanceof PathEscapeError) {
@@ -57,7 +57,7 @@ export function containedRealPathInfo(fs, root, absolutePath) {
         if (!isWithinWorkspace(realBase, parentReal)) {
             throw new PathEscapeError(`path escapes the workspace boundary via symlink: ${absolutePath}`, absolutePath);
         }
-        return { path: absolutePath, realRelative: toRelative(realBase, parentReal) };
+        return { path: absolutePath, realRelative: toRelative(realBase, parentReal), realBase };
     }
 }
 // Asserts that `absolutePath` (already lexically contained) does not escape `root` via a symlink.

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repoSearch.d.ts","sourceRoot":"","sources":["../src/repoSearch.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACf,MAAM,iDAAiD,CAAC;AAWzD,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAiB5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIhD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,eAAO,MAAM,qBAAqB,EAAE,YAK1B,CAAC;AAWX,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,UAAU,UAAU;IAClB,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAgCD,wBAAsB,UAAU,CAC9B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,cAAc,EACrB,MAAM,GAAE,YAAoC,EAC5C,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,YAAY,CAAC,CA6CvB;AAiED,wBAAsB,SAAS,CAC7B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,cAAc,EACrB,MAAM,GAAE,YAAoC,EAC5C,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,YAAY,CAAC,CASvB;AAwDD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAgD5B"}
+{"version":3,"file":"repoSearch.d.ts","sourceRoot":"","sources":["../src/repoSearch.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACf,MAAM,iDAAiD,CAAC;AAWzD,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAmB5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIhD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,eAAO,MAAM,qBAAqB,EAAE,YAK1B,CAAC;AAWX,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,UAAU,UAAU;IAClB,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AA4DD,wBAAsB,UAAU,CAC9B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,cAAc,EACrB,MAAM,GAAE,YAAoC,EAC5C,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,YAAY,CAAC,CAuCvB;AA+DD,wBAAsB,SAAS,CAC7B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,cAAc,EACrB,MAAM,GAAE,YAAoC,EAC5C,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,YAAY,CAAC,CASvB;AAmHD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAyC5B"}

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearch.js

@@ -1,5 +1,5 @@
 // Governed, deterministic, audit-friendly repository search facade (Epic #177, Issue #179).
-// Composes the existing workspace primitives — discovery, ignore/deny, realpath gate,
+// Composes the existing workspace primitives — discovery, deny policy, realpath gate,
 // readWorkspaceFile, plus the new binaryDetect and stableId modules — into three public
 // APIs that emit normalized EvidenceAtom output: searchText, findFiles, readExcerpt.
 // Pure JS (no subprocess, no ripgrep — deferred). Every fs touch goes through the
@@ -8,11 +8,11 @@ import { isValidScopePath, validateRetrievalQuery, } from "@oscharko-dev/keiko-c
 import { readWorkspaceFile } from "./discovery.js";
 import { RepoSearchInvalidQueryError, RepoSearchInvalidRangeError, RepoSearchUnsupportedFileError, } from "./errors.js";
 import { nodeWorkspaceFs } from "./fs.js";
-import { compileIgnore, isDenied, isIgnored } from "./ignore.js";
+import { isDenied } from "./ignore.js";
 import { resolveWithinWorkspace } from "./paths.js";
-import { assertContainedRealPath } from "./realpath.js";
+import { containedRealPathInfo } from "./realpath.js";
 import { buildMatcher, compileGlob, fingerprintFor } from "./repoSearchMatchers.js";
-import { buildAtom, buildCandidate, elapsed, gatherCandidates, hitLimit, probeBinary, scanFile, } from "./repoSearchScan.js";
+import { buildAtom, buildCandidate, elapsed, gatherCandidates, hitLimit, isImageScopePath, isIoError, probeBinary, scanFile, } from "./repoSearchScan.js";
 export const DEFAULT_SEARCH_LIMITS = {
     maxFilesScanned: 2_000,
     maxMatchesReturned: 200,
@@ -52,6 +52,26 @@ function assertWorkspaceRoot(workspace) {
     }
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
+// Yields to the event loop every SCAN_YIELD_INTERVAL files so a large cold NFS/SMB workspace
+// cannot block the event loop for multiple seconds. discoverFiles() itself remains synchronous
+// (sync walk is load-bearing for importGraph/testSourcePairing callers); the yield here covers
+// the already-async per-file scan pass where the loop overhead is measurable.
+const SCAN_YIELD_INTERVAL = 64;
+async function runScanLoop(runner, candidateSet, state, atoms, candidates) {
+    let loopIndex = 0;
+    for (const file of candidateSet.files) {
+        if (hitLimit(runner, state)) {
+            break;
+        }
+        loopIndex += 1;
+        if (loopIndex % SCAN_YIELD_INTERVAL === 0) {
+            await new Promise((resolve) => {
+                setImmediate(resolve);
+            });
+        }
+        await scanFile(runner, file, state, atoms, candidates);
+    }
+}
 export async function searchText(scope, query, limits = DEFAULT_SEARCH_LIMITS, deps = {}) {
     assertWorkspaceRoot(scope.workspace);
     assertQuery(query);
@@ -72,7 +92,6 @@ export async function searchText(scope, query, limits = DEFAULT_SEARCH_LIMITS, d
         nowMs,
         startMs: nowMs(),
         matcher: buildMatcher(query),
-        ignoreMatcher: compileIgnore(scope.workspace.ignoreLines),
         fingerprint: fingerprintFor(query),
     };
     const candidateSet = gatherCandidates(scope, limits, fs);
@@ -84,12 +103,7 @@ export async function searchText(scope, query, limits = DEFAULT_SEARCH_LIMITS, d
         matchesReturned: 0,
         truncated: candidateSet.truncated,
     };
-    for (const file of candidateSet.files) {
-        if (hitLimit(runner, state)) {
-            break;
-        }
-        await scanFile(runner, file, state, atoms, candidates);
-    }
+    await runScanLoop(runner, candidateSet, state, atoms, candidates);
     return {
         atoms,
         candidates,
@@ -117,7 +131,6 @@ function findFilesSync(scope, query, limits, fs, nowMs) {
     const ctx = {
         scope,
         regex: compileGlob(query.text),
-        ignoreMatcher: compileIgnore(scope.workspace.ignoreLines),
         fingerprint: fingerprintFor(query),
         nowMs,
     };
@@ -132,7 +145,7 @@ function findFilesSync(scope, query, limits, fs, nowMs) {
             truncated = true;
             break;
         }
-        if (isDenied(file.relativePath) || isIgnored(ctx.ignoreMatcher, file.relativePath, false)) {
+        if (isDenied(file.relativePath)) {
             candidates.push(buildCandidate(file.relativePath, "ignored"));
             continue;
         }
@@ -168,12 +181,29 @@ function isWithinSelectedScope(scope, scopePath) {
     }
     return scope.relativePaths.some((selectedPath) => scopePath === selectedPath || scopePath.startsWith(`${selectedPath}/`));
 }
+function normalizeScopePath(scopePath) {
+    return scopePath.split("\\").join("/");
+}
 function assertExcerptWithinSelectedScope(scope, scopePath) {
     if (isWithinSelectedScope(scope, scopePath)) {
         return;
     }
     throw new RepoSearchUnsupportedFileError(`cannot read excerpt outside selected scope: ${scopePath}`, "outside-scope");
 }
+function resolveExcerptTarget(scope, scopePath, fs) {
+    const abs = resolveWithinWorkspace(scope.workspace.root, scopePath);
+    const contained = containedRealPathInfo(fs, scope.workspace.root, abs);
+    const realScopePath = normalizeScopePath(contained.realRelative);
+    return { path: contained.path, realScopePath };
+}
+function assertExcerptReadableByPolicy(requestPath, realScopePath) {
+    // Deny gates must fire BEFORE any byte read (incl. the binary probe) so that a denied path such
+    // as .env is never read at all, including through an in-workspace symlink. .gitignore is not a
+    // context policy boundary; safe ignored/dot files remain readable when the user scopes them in.
+    if (isDenied(requestPath) || isDenied(realScopePath)) {
+        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of denied path: ${requestPath}`, "denied");
+    }
+}
 function assertExcerptRange(request) {
     if (!Number.isInteger(request.startLine) ||
         !Number.isInteger(request.endLine) ||
@@ -190,24 +220,41 @@ function assertExcerptRange(request) {
         throw new RepoSearchInvalidRangeError(`invalid scopePath: ${request.scopePath}`);
     }
 }
+// Probes for binary content and throws RepoSearchUnsupportedFileError on both binary detection
+// and IO errors (EACCES, ENOENT, …) so the caller can treat both as a graceful skip.
+async function assertExcerptNotBinary(fs, absolutePath, size, scopePath) {
+    let isBinary;
+    try {
+        isBinary = await probeBinary(fs, absolutePath, size);
+    }
+    catch (err) {
+        // TOCTOU: permissions or availability may change between stat and probe (EACCES, ENOENT, …).
+        // Re-classify as an unsupported-file skip so readKeptExcerpts degrades gracefully instead
+        // of crashing the whole grounded answer (the comment at grounded-orchestrator readKeptExcerpts
+        // explicitly promises this invariant).
+        if (isIoError(err)) {
+            throw new RepoSearchUnsupportedFileError(`cannot read excerpt of unreadable file: ${scopePath}`, "io-error");
+        }
+        throw err;
+    }
+    if (isBinary) {
+        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of binary file: ${scopePath}`, "binary");
+    }
+}
 export async function readExcerpt(scope, request, deps = {}) {
     assertExcerptRange(request);
     assertWorkspaceRoot(scope.workspace);
     assertExcerptWithinSelectedScope(scope, request.scopePath);
+    if (isImageScopePath(request.scopePath)) {
+        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of image file: ${request.scopePath}`, "binary");
+    }
     const fs = deps.fs ?? nodeWorkspaceFs;
     const nowMs = deps.nowMs ?? Date.now;
-    const abs = resolveWithinWorkspace(scope.workspace.root, request.scopePath);
-    assertContainedRealPath(fs, scope.workspace.root, abs, "scope");
-    // Deny/ignore gates must fire BEFORE any byte read (incl. the binary probe) so that a
-    // denied path such as .env is never read at all (Finding 4).
-    const ignoreMatcher = compileIgnore(scope.workspace.ignoreLines);
-    if (isDenied(request.scopePath) || isIgnored(ignoreMatcher, request.scopePath, false)) {
-        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of denied or ignored path: ${request.scopePath}`, "denied");
-    }
-    const stat = fs.stat(abs);
-    if (await probeBinary(fs, abs, stat.size)) {
-        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of binary file: ${request.scopePath}`, "binary");
-    }
+    const target = resolveExcerptTarget(scope, request.scopePath, fs);
+    assertExcerptReadableByPolicy(request.scopePath, target.realScopePath);
+    assertExcerptWithinSelectedScope(scope, target.realScopePath);
+    const stat = fs.stat(target.path);
+    await assertExcerptNotBinary(fs, target.path, stat.size, request.scopePath);
     // Read enough of the file to reach the requested line window (bounded by MAX_EXCERPT_FILE_BYTES),
     // then clamp the returned content to the caller's request.maxBytes budget. The read cap is
     // intentionally larger than request.maxBytes so a window deep in a multi-kibibyte file is still

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearchEntries.d.ts

@@ -0,0 +1,15 @@
+import type { WorkspaceFs } from "./fs.js";
+import type { DiscoveredFile, WorkspaceInfo } from "./types.js";
+interface ScopeShape {
+    readonly workspace: WorkspaceInfo;
+    readonly relativePaths: readonly string[];
+}
+interface LimitsShape {
+    readonly maxFilesScanned: number;
+}
+export declare function collectFromEntries(scope: ScopeShape, limits: LimitsShape, fs: WorkspaceFs): {
+    files: readonly DiscoveredFile[];
+    truncated: boolean;
+};
+export {};
+//# sourceMappingURL=repoSearchEntries.d.ts.map

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearchEntries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchEntries.d.ts","sourceRoot":"","sources":["../src/repoSearchEntries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,WAAW,EAAE,MAAM,SAAS,CAAC;AAI9D,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhE,UAAU,UAAU;IAClB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAoHD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,EACnB,EAAE,EAAE,WAAW,GACd;IAAE,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAgB1D"}

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearchEntries.js

@@ -0,0 +1,107 @@
+import { isDenied } from "./ignore.js";
+import { resolveWithinWorkspace } from "./paths.js";
+import { containedRealPathInfo } from "./realpath.js";
+import { RepoSearchInvalidQueryError } from "./errors.js";
+function normalizeScopePath(scopePath) {
+    return scopePath.split("\\").join("/");
+}
+function readDirSorted(fs, absoluteDir) {
+    try {
+        return [...fs.readDir(absoluteDir)].sort((a, b) => (a.name < b.name ? -1 : 1));
+    }
+    catch {
+        return [];
+    }
+}
+function pushAllowedFile(walk, relPath, absPath) {
+    if (walk.files.length > walk.limits.maxFilesScanned) {
+        return;
+    }
+    const stat = walk.fs.stat(absPath);
+    if (!stat.isFile) {
+        return;
+    }
+    walk.files.push({ relativePath: relPath, sizeBytes: stat.size });
+    if (walk.files.length > walk.limits.maxFilesScanned) {
+        walk.truncated = true;
+    }
+}
+function allowedByFilters(relPath) {
+    return !isDenied(relPath);
+}
+function handleDirectoryEntry(walk, absoluteDir, dirRel, entry, depth) {
+    if (entry.isSymbolicLink) {
+        return;
+    }
+    const root = walk.scope.workspace.root;
+    const childRel = dirRel.length === 0 ? entry.name : `${dirRel}/${entry.name}`;
+    if (!allowedByFilters(childRel)) {
+        return;
+    }
+    const childAbs = resolveWithinWorkspace(root, childRel);
+    const contained = containedRealPathInfo(walk.fs, root, childAbs);
+    const realRel = normalizeScopePath(contained.realRelative);
+    if (!allowedByFilters(realRel)) {
+        return;
+    }
+    if (entry.isDirectory) {
+        walkEntryDirectory(walk, contained.path, realRel, depth + 1);
+        return;
+    }
+    pushAllowedFile(walk, realRel, contained.path);
+}
+function walkEntryDirectory(walk, absoluteDir, dirRel, depth) {
+    if (depth > 12 || walk.truncated) {
+        return;
+    }
+    for (const entry of readDirSorted(walk.fs, absoluteDir)) {
+        if (walk.files.length > walk.limits.maxFilesScanned) {
+            walk.truncated = true;
+            return;
+        }
+        handleDirectoryEntry(walk, absoluteDir, dirRel, entry, depth);
+    }
+}
+function handleScopeEntry(walk, entry) {
+    const root = walk.scope.workspace.root;
+    const abs = resolveWithinWorkspace(root, entry);
+    const contained = containedRealPathInfo(walk.fs, root, abs);
+    const entryRel = normalizeScopePath(entry);
+    const realRel = normalizeScopePath(contained.realRelative);
+    if (isDenied(entryRel) || isDenied(realRel)) {
+        return;
+    }
+    let stat;
+    try {
+        stat = walk.fs.stat(contained.path);
+    }
+    catch {
+        throw new RepoSearchInvalidQueryError("Connected scope path is not accessible from the selected project.");
+    }
+    if (!allowedByFilters(entryRel) ||
+        !allowedByFilters(realRel)) {
+        return;
+    }
+    if (stat.isDirectory) {
+        walkEntryDirectory(walk, contained.path, realRel, 1);
+        return;
+    }
+    pushAllowedFile(walk, realRel, contained.path);
+}
+export function collectFromEntries(scope, limits, fs) {
+    const out = [];
+    const walk = {
+        scope,
+        limits,
+        fs,
+        files: out,
+        truncated: false,
+    };
+    for (const entry of scope.relativePaths) {
+        if (walk.truncated) {
+            break;
+        }
+        handleScopeEntry(walk, entry);
+    }
+    return { files: out.slice(0, limits.maxFilesScanned), truncated: walk.truncated };
+}

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearchLineSelection.d.ts

@@ -0,0 +1,18 @@
+import type { LineMatcher } from "./repoSearchMatchers.js";
+export interface LineSelectionRunner {
+    readonly limits: {
+        readonly elapsedMsMax: number;
+    };
+    readonly matcher: LineMatcher;
+    readonly nowMs: () => number;
+    readonly startMs: number;
+}
+export interface LineSelectionState {
+    truncated: boolean;
+}
+export interface ScoredLine {
+    readonly line: number;
+    readonly score: number;
+}
+export declare function collectBestLines(runner: LineSelectionRunner, text: string, state: LineSelectionState): readonly ScoredLine[];
+//# sourceMappingURL=repoSearchLineSelection.d.ts.map

package/node_modules/@oscharko-dev/keiko-workspace/dist/repoSearchLineSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchLineSelection.d.ts","sourceRoot":"","sources":["../src/repoSearchLineSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAQ3D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAsBD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,kBAAkB,GACxB,SAAS,UAAU,EAAE,CAmBvB"}