blun-king-cli 9.1.563 → 9.1.564

package/agent-spine-plugin/src/hook.js

@@ -5,7 +5,7 @@ import { recordAttentionEvent } from "./lib/attention.js";
 import { catalogForStateRoot, saveCatalog } from "./lib/catalog.js";
 import { loadGraph } from "./lib/graph.js";
 import { canonicalPath } from "./lib/paths.js";
-import { resolveHostSourceCatalog } from "./lib/source-roots.js";
+import { isInaccessibleScanError, resolveHostSourceCatalog } from "./lib/source-roots.js";
 import { sessionBriefing } from "./lib/briefing.js";
 import { captureContinuityPrompt, loadContinuity } from "./lib/continuity.js";
 import { recordLearningApplications, recordLearningDeliveries } from "./lib/learning.js";
@@ -16,6 +16,7 @@ import { claimChannelEvent } from "./lib/channel-runtime.js";
 import { syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
 import { captureMustRememberPrompt, recordPreflightFailure, runPreflight, verifyPreflightReceipt } from "./lib/preflight.js";
 import { isMainModule } from "./lib/runtime.js";
+import { recordHookScanAudit } from "./lib/hook-audit.js";
 
 const MAX_STDIN_BYTES = 64 * 1024;
 const STANDARD_HOST_CONTEXT_BYTES = 9500;
@@ -471,6 +472,30 @@ function isMutationTool(name = "") {
   return /(^|__)(apply_patch|edit|write|delete|move|rename|bash|exec_command|shell)(_|$)/i.test(name);
 }
 
+function filesystemScanError(error) {
+  return Boolean(error && (isInaccessibleScanError(error)
+    || error.code === "AGENTSPINE_SCAN_INCOMPLETE" || error.agentSpineScan === true));
+}
+
+async function auditSkippedScans(input, phase, skipped = []) {
+  for (const item of skipped) {
+    await recordHookScanAudit({
+      event: "PreToolUse", toolName: input.tool_name || null, phase,
+      error: { code: item.code, message: `${item.code}: ${item.kind || item.operation || "scan"} skipped ${item.relativePath || item.path}` },
+      path: item.path || item.relativePath, operation: item.operation || item.kind,
+      now: input.timestamp || new Date()
+    });
+  }
+}
+
+async function allowScanFailure(input, phase, error) {
+  await recordHookScanAudit({
+    event: "PreToolUse", toolName: input.tool_name || null, phase, error,
+    path: error?.path || input.cwd || process.cwd(), now: input.timestamp || new Date()
+  });
+  return { blocked: false, degraded: true, scanFailedOpen: true, phase, error: error.message };
+}
+
 function stringValues(value, output = []) {
   if (typeof value === "string") output.push(value);
   else if (Array.isArray(value)) value.forEach((item) => stringValues(item, output));
@@ -546,6 +571,19 @@ export async function runHook(payload = null, options = {}) {
     resolvedSources = await resolveHostSourceCatalog({ host: instructionHost, cwd, input });
   } catch (error) {
     const reason = `AgentSpine source resolution failed closed: ${error.message}`;
+    if (event === "PreToolUse" && isMutationTool(input.tool_name) && filesystemScanError(error)) {
+      const allowed = await allowScanFailure(input, "source-resolution", error);
+      const context = JSON.stringify({
+        schema: "agentspine.hook-context/v1", event, loaded: false, failedClosed: false,
+        indexedSources: 0,
+        sourceResolution: { status: "degraded", reason: error.message, auditFinding: "inaccessible-source-scan" },
+        instruction: "The filesystem scan was incomplete. The requested tool remains governed by native host permissions.",
+        authority: "context-only"
+      });
+      if (payload) return { ...allowed, context };
+      process.stdout.write("{}\n");
+      return;
+    }
     if (event === "PreToolUse" && isMutationTool(input.tool_name)) {
       if (payload) return { blocked: true, failedClosed: true, reason };
       deny(reason);
@@ -575,6 +613,11 @@ export async function runHook(payload = null, options = {}) {
   let channelEvent = null;
   let learningDelivery = null;
 
+  if (event === "PreToolUse" && isMutationTool(input.tool_name)
+    && resolvedSources.diagnostics.skippedInaccessibleDirectories?.length) {
+    await auditSkippedScans(input, "source-resolution", resolvedSources.diagnostics.skippedInaccessibleDirectories);
+  }
+
   if (event === "PreToolUse" && isMutationTool(input.tool_name)) {
     const { graph } = await loadGraph(root, catalog);
     const inferredProtected = new Set(graph.annotations
@@ -624,6 +667,12 @@ export async function runHook(payload = null, options = {}) {
         });
       }
     } catch (error) {
+      if (isMutationTool(input.tool_name) && filesystemScanError(error)) {
+        const allowed = await allowScanFailure(input, "self-starter", error);
+        if (payload) return allowed;
+        process.stdout.write("{}\n");
+        return;
+      }
       const reason = `AgentSpine self-starter denied this effect: ${error.message}`;
       if (payload) return { blocked: true, reason, selfstarter: { allowed: false, reason: error.message } };
       deny(reason);

package/agent-spine-plugin/src/lib/audit.js

@@ -288,7 +288,7 @@ export async function runAudit(root = process.cwd(), { host = null } = {}) {
     gate(2, "Discovery", catalog.schema === "agentspine.catalog/v1"
       && (!host || (sourceResolution?.status === "loaded" && !sourceResolutionError)), sourceResolutionError
       ? `${catalog.documents.length} project documents; host-native source resolution failed closed: ${sourceResolutionError}`
-      : sourceResolution ? `${sourceResolution.scopes.user} user, ${sourceResolution.scopes.project} project, and ${sourceResolution.scopes["project-memory"]} memory sources; broad home scan disabled`
+      : sourceResolution ? `${sourceResolution.scopes.user} user, ${sourceResolution.scopes.project} project, and ${sourceResolution.scopes["project-memory"]} memory sources; broad home scan disabled; ${(sourceResolution.skippedInaccessibleDirectories || []).length} inaccessible directories skipped`
         : `${catalog.documents.length} Markdown documents indexed`),
     gate(3, "State isolation", [catalogPath, graphPath, attentionPath, learningPath, continuityPath,
       policyPath, coordinationPath, executionPolicyPath, selfstarterPath, channelPolicyPath,

package/agent-spine-plugin/src/lib/hook-audit.js

@@ -0,0 +1,29 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { stateRoot } from "./paths.js";
+
+export function hookScanAuditPath(env = process.env) {
+  return join(stateRoot(env), "hook-scan-audit.jsonl");
+}
+
+export async function recordHookScanAudit({ event = "PreToolUse", toolName = null, phase, error = null,
+  path = null, operation = null, now = new Date(), env = process.env }) {
+  try {
+    const target = hookScanAuditPath(env);
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    const record = {
+      schema: "agentspine.hook-scan-audit/v1",
+      at: new Date(now).toISOString(), event, toolName, phase,
+      code: String(error?.code || "SCAN_ERROR").slice(0, 64),
+      error: String(error?.message || error || "filesystem scan skipped").slice(0, 2048),
+      path: String(path || error?.path || "unknown").slice(0, 4096),
+      operation: operation || error?.syscall || null,
+      decision: "allow",
+      authority: "diagnostic-only"
+    };
+    await appendFile(target, `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/agent-spine-plugin/src/lib/selfstarter.js

@@ -6,6 +6,7 @@ import { isFileLockContention, replaceFileWithRetry } from "./filesystem-retry.j
 import { loadCoordination } from "./coordination.js";
 import { loadGraph } from "./graph.js";
 import { projectStateDir } from "./paths.js";
+import { isInaccessibleScanError } from "./source-roots.js";
 
 const POLICY_SCHEMA = "agentspine.execution-policy/v1";
 const JOB_SCHEMA = "agentspine.selfstarter/v1";
@@ -149,16 +150,39 @@ async function pathsFor(root, providedCatalog = null) {
 
 async function collectWorkspaceFiles(root) {
   const files = [];
+  const skippedInaccessibleEntries = [];
   let totalBytes = 0;
   async function walk(directory) {
-    const stream = await opendir(directory);
+    let stream;
+    try {
+      stream = await opendir(directory);
+    } catch (error) {
+      if (!isInaccessibleScanError(error)) throw error;
+      skippedInaccessibleEntries.push({
+        relativePath: relative(root, directory).split(sep).join("/") || ".",
+        code: error.code,
+        kind: "directory"
+      });
+      return;
+    }
     const entries = [];
     for await (const entry of stream) entries.push(entry);
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (EXCLUDED_NAMES.has(entry.name)) continue;
       const path = join(directory, entry.name);
-      const metadata = await lstat(path);
+      let metadata;
+      try {
+        metadata = await lstat(path);
+      } catch (error) {
+        if (!isInaccessibleScanError(error)) throw error;
+        skippedInaccessibleEntries.push({
+          relativePath: relative(root, path).split(sep).join("/"),
+          code: error.code,
+          kind: "entry"
+        });
+        continue;
+      }
       if (metadata.isSymbolicLink()) throw new Error(`workspace fingerprint rejects symbolic link: ${relative(root, path)}`);
       if (metadata.isDirectory()) await walk(path);
       else if (metadata.isFile()) {
@@ -171,18 +195,38 @@ async function collectWorkspaceFiles(root) {
     }
   }
   await walk(root);
-  return files;
+  return { files, skippedInaccessibleEntries };
 }
 
 export async function workspaceFingerprint(inputRoot = process.cwd()) {
   const root = resolve(inputRoot);
-  const files = await collectWorkspaceFiles(root);
+  const { files, skippedInaccessibleEntries } = await collectWorkspaceFiles(root);
   const hash = createHash("sha256");
+  for (const skipped of skippedInaccessibleEntries) {
+    hash.update("inaccessible\0").update(skipped.kind).update("\0")
+      .update(skipped.relativePath).update("\0").update(skipped.code).update("\0");
+  }
   for (const file of files) {
     hash.update(file.relativePath).update("\0").update(String(file.size)).update("\0");
     hash.update(await readFile(file.path)).update("\0");
   }
-  return { digest: hash.digest("hex"), files: files.length, bytes: files.reduce((sum, file) => sum + file.size, 0) };
+  return {
+    digest: hash.digest("hex"), files: files.length,
+    bytes: files.reduce((sum, file) => sum + file.size, 0),
+    skippedInaccessibleEntries: skippedInaccessibleEntries.length,
+    skippedInaccessibleDetails: skippedInaccessibleEntries
+  };
+}
+
+function incompleteWorkspaceScan(skipped) {
+  const first = skipped[0];
+  const error = new Error(`workspace scan skipped ${skipped.length} inaccessible path${skipped.length === 1 ? "" : "s"}: ${first.relativePath}`);
+  error.code = "AGENTSPINE_SCAN_INCOMPLETE";
+  error.path = first.relativePath;
+  error.syscall = first.kind;
+  error.agentSpineScan = true;
+  error.skipped = skipped;
+  return error;
 }
 
 function knownActor(graph, id) {
@@ -649,6 +693,9 @@ export async function authorizeJobEffect({
   const deliveryId = stableId(toolUseId, "toolUseId");
   const at = timestamp(now, "now");
   const fingerprint = await workspaceFingerprint(root);
+  if (fingerprint.skippedInaccessibleDetails.length) {
+    throw incompleteWorkspaceScan(fingerprint.skippedInaccessibleDetails);
+  }
   return lockedStates(root, ({ policy, state, coordination, paths }) => {
     const job = state.jobs.find((item) => item.id === scope.jobId);
     if (!job) throw new Error("unknown self-starter job");

package/agent-spine-plugin/src/lib/source-roots.js

@@ -20,6 +20,10 @@ const SOURCE_RESOLUTION_MS = 2000;
 const SAFE_NAME = /^[A-Za-z0-9._-]{1,128}$/;
 const SKIP_EXTRA_DIRS = new Set([".git", ".hg", ".svn", ".claude", ".codex", "node_modules", "vendor", "dist", "build", "coverage"]);
 
+export function isInaccessibleScanError(error) {
+  return error?.code === "EACCES" || error?.code === "EPERM";
+}
+
 function digest(value) { return createHash("sha256").update(value).digest("hex"); }
 function registryPath(env = process.env) { return join(stateRoot(env), "source-roots.json"); }
 function emptyRegistry() { return { schema: SOURCE_REGISTRY_SCHEMA, revision: 0, bindings: [], history: [] }; }
@@ -202,32 +206,41 @@ async function containsEmbeddedHostProfile(directory) {
 async function boundedMarkdownTree(directory, prefix, host, scope, precedenceStart, deadline, {
   projectBoundary = false,
   maxFiles = MAX_RULE_FILES,
-  maxDirectoryEntries = MAX_DIRECTORY_ENTRIES
+  maxDirectoryEntries = MAX_DIRECTORY_ENTRIES,
+  skippedInaccessibleDirectories = []
 } = {}) {
   const root = await existingDirectory(directory);
   if (!root) return [];
   const output = [];
   let visitedEntries = 0;
   async function walk(current) {
-    if (Date.now() > deadline) throw new Error(`host-native source resolution exceeded ${SOURCE_RESOLUTION_MS} ms`);
-    if (projectBoundary && current !== root
-      && (await containsProjectMarker(current) || await containsEmbeddedHostProfile(current))) return;
-    const entries = [];
-    for await (const entry of await opendir(current)) {
-      visitedEntries += 1;
-      if (visitedEntries > maxDirectoryEntries) throw new Error(`host-native source tree exceeds ${maxDirectoryEntries} entries`);
-      entries.push(entry);
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (output.length >= maxFiles) throw new Error(`host-native rule tree exceeds ${maxFiles} files`);
-      if (entry.isSymbolicLink()) continue;
-      const path = join(current, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !skippedExtraDirectory(entry.name)) await walk(path);
-      else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-        output.push({ path, id: `${prefix}/${relative(root, path).replaceAll("\\", "/")}`, host, scope,
-          binding: "host-native-rule-tree", precedence: precedenceStart + output.length });
+    try {
+      if (Date.now() > deadline) throw new Error(`host-native source resolution exceeded ${SOURCE_RESOLUTION_MS} ms`);
+      if (projectBoundary && current !== root
+        && (await containsProjectMarker(current) || await containsEmbeddedHostProfile(current))) return;
+      const entries = [];
+      for await (const entry of await opendir(current)) {
+        visitedEntries += 1;
+        if (visitedEntries > maxDirectoryEntries) throw new Error(`host-native source tree exceeds ${maxDirectoryEntries} entries`);
+        entries.push(entry);
       }
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      for (const entry of entries) {
+        if (output.length >= maxFiles) throw new Error(`host-native rule tree exceeds ${maxFiles} files`);
+        if (entry.isSymbolicLink()) continue;
+        const path = join(current, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".") && !skippedExtraDirectory(entry.name)) await walk(path);
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+          output.push({ path, id: `${prefix}/${relative(root, path).replaceAll("\\", "/")}`, host, scope,
+            binding: "host-native-rule-tree", precedence: precedenceStart + output.length });
+        }
+      }
+    } catch (error) {
+      if (!isInaccessibleScanError(error)) throw error;
+      skippedInaccessibleDirectories.push({
+        relativePath: relative(root, current).replaceAll("\\", "/") || ".",
+        code: error.code
+      });
     }
   }
   await walk(root);
@@ -434,9 +447,11 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
   const knownHomeRoots = await homeRoots(env);
   const skippedHomeTree = knownHomeRoots.some((root) => samePath(root, projectRoot));
   const skippedFallbackHomeTree = skippedHomeTree && rootResolution === "cwd-fallback";
+  const skippedInaccessibleDirectories = [];
   if (!skippedHomeTree) {
     sources.push(...await boundedMarkdownTree(projectRoot, "agentspine:project", host, "project", 3000, deadline,
-      { projectBoundary: true, maxFiles: MAX_PROJECT_FILES, maxDirectoryEntries: MAX_PROJECT_DIRECTORY_ENTRIES }));
+      { projectBoundary: true, maxFiles: MAX_PROJECT_FILES, maxDirectoryEntries: MAX_PROJECT_DIRECTORY_ENTRIES,
+        skippedInaccessibleDirectories }));
   }
   const nativeNames = new Set(host === "codex"
     ? ["AGENTS.override.md", "AGENTS.md", ...(hostDetails.fallbackNames || [])]
@@ -459,6 +474,7 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
     personalContinuityLoaded: documents.some((item) => item.sourceScope === "user") || Boolean(activeUserState),
     broadHomeScan: false, projectTreeScan: skippedFallbackHomeTree ? "skipped-unmarked-home"
       : skippedHomeTree ? "skipped-home-root" : "bounded",
+    skippedInaccessibleDirectories,
     rootResolution, registryRevision: registry.revision,
     ...(host === "claude" ? {
       memoryBound: Boolean(hostDetails.memoryRoot),

package/blun.mjs

@@ -342898,6 +342898,7 @@ function detectedUiLocale() {
 const SOURCE_LOCALE = "en";
 const PLACEHOLDER_PATTERN = /\{([A-Za-z][A-Za-z0-9_]*)\}/g;
 const catalogs = {};
+const missingLocalizedUiTextWarnings = /* @__PURE__ */ new Set();
 let currentUiLocale = SOURCE_LOCALE;
 function registerUiCatalogFragment(fragment) {
 	for (const [locale, copy] of Object.entries(fragment)) {
@@ -342928,7 +342929,13 @@ function uiTextFor(locale, key, params = {}) {
 	const sourceTemplate = catalogs[SOURCE_LOCALE]?.[key];
 	if (sourceTemplate === void 0) throw new Error(`Missing English UI source text for key "${key}".`);
 	const localizedTemplate = catalogs[locale]?.[key];
-	if (locale !== SOURCE_LOCALE && isUiLocaleAvailable(locale) && localizedTemplate === void 0) throw new Error(`Missing UI text for key "${key}" in released locale "${locale}".`);
+	if (locale !== SOURCE_LOCALE && isUiLocaleAvailable(locale) && localizedTemplate === void 0) {
+		const warningKey = `${locale}:${key}`;
+		if (!missingLocalizedUiTextWarnings.has(warningKey)) {
+			missingLocalizedUiTextWarnings.add(warningKey);
+			log?.warn("Missing localized UI text; using English fallback", { locale, key });
+		}
+	}
 	const template = localizedTemplate ?? sourceTemplate;
 	validateCatalogPlaceholders(key, sourceTemplate, template);
 	return interpolate(key, template, params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.563",
+  "version": "9.1.564",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {