blun-king-cli 9.1.565 → 9.1.567

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

@@ -1,11 +1,12 @@
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, open, opendir, readFile, realpath, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { join, relative, resolve, sep } from "node:path";
 import { buildCatalog } from "./catalog.js";
 import { isFileLockContention, replaceFileWithRetry } from "./filesystem-retry.js";
 import { loadCoordination } from "./coordination.js";
 import { loadGraph } from "./graph.js";
-import { projectStateDir } from "./paths.js";
+import { comparablePath, projectStateDir } from "./paths.js";
 
 const POLICY_SCHEMA = "agentspine.execution-policy/v1";
 const JOB_SCHEMA = "agentspine.selfstarter/v1";
@@ -24,6 +25,18 @@ const SECRET_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|gh[opusu])_[A-Za-z
 
 function workspaceScanError(error) { error.agentSpineScan = true; return error; }
 
+function configuredHostProfileRoots(env = process.env) {
+  return [env.CODEX_HOME, env.BLUN_HOME, env.CLAUDE_CONFIG_DIR, join(homedir(), ".codex"), join(homedir(), ".claude")]
+    .filter((value) => typeof value === "string" && value)
+    .map((value) => comparablePath(value));
+}
+
+function isConfiguredHostProfileRoot(root, env = process.env) {
+  const target = comparablePath(root);
+  return configuredHostProfileRoots(env).some((profile) => process.platform === "win32"
+    ? profile.toLowerCase() === target.toLowerCase() : profile === target);
+}
+
 function emptyPolicy(root) {
   return { schema: POLICY_SCHEMA, root, revision: 0, grants: [], history: [] };
 }
@@ -140,6 +153,9 @@ async function withLock(path, read, operation, save = true) {
 }
 
 async function pathsFor(root, providedCatalog = null) {
+  if (isConfiguredHostProfileRoot(root)) {
+    throw new Error("self-starter cannot use a host profile as its workspace root");
+  }
   let catalog = providedCatalog;
   if (!catalog) {
     try {
@@ -224,6 +240,9 @@ export async function collectWorkspaceFiles(root) {
 
 export async function workspaceFingerprint(inputRoot = process.cwd()) {
   const root = resolve(inputRoot);
+  if (isConfiguredHostProfileRoot(root)) {
+    throw new Error("self-starter cannot fingerprint a host profile root");
+  }
   const collected = await collectWorkspaceFiles(root);
   const files = [];
   const skipped = [...collected.skipped];

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

@@ -473,8 +473,9 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
   }
   const knownHomeRoots = await homeRoots(env);
   const skippedHomeTree = knownHomeRoots.some((root) => samePath(root, projectRoot));
+  const skippedProfileTree = samePath(hostHome, projectRoot);
   const skippedFallbackHomeTree = skippedHomeTree && rootResolution === "cwd-fallback";
-  if (!skippedHomeTree) {
+  if (!skippedHomeTree && !skippedProfileTree) {
     sources.push(...await boundedMarkdownTree(projectRoot, "agentspine:project", host, "project", 3000, deadline,
       { projectBoundary: true, maxFiles: MAX_PROJECT_FILES, maxDirectoryEntries: MAX_PROJECT_DIRECTORY_ENTRIES, skipped }));
   }
@@ -504,7 +505,7 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
     reason: documents.length ? null : "No regular, non-symlink host-native Markdown source exists in the checked scope.",
     personalContinuityLoaded: documents.some((item) => item.sourceScope === "user") || Boolean(activeUserState),
     broadHomeScan: false, projectTreeScan: skippedFallbackHomeTree ? "skipped-unmarked-home"
-      : skippedHomeTree ? "skipped-home-root" : "bounded",
+      : skippedHomeTree ? "skipped-home-root" : skippedProfileTree ? "skipped-profile-root" : "bounded",
     skipped: skipped.sort((a, b) => a.path.localeCompare(b.path) || a.operation.localeCompare(b.operation)),
     rootResolution, registryRevision: registry.revision,
     ...(host === "claude" ? {

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

@@ -1 +1 @@
-export const VERSION = "0.54.0";
+export const VERSION = "0.59.1";

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

@@ -3,7 +3,10 @@ import { spawn } from "node:child_process";
 import { watch } from "node:fs";
 import { lstat, realpath } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
-import { claimGatewayWork, completeGatewayRun, deliverPrepared, failGatewayRun, loadGatewayRuntime, reconcileGateway, updateGatewayHealth } from "./lib/gateway-runtime.js";
+import {
+  claimGatewayWork, completeGatewayRun, deliverPrepared, executionAttemptForStep,
+  failGatewayRun, loadGatewayRuntime, reconcileGateway, updateGatewayHealth
+} from "./lib/gateway-runtime.js";
 import { createTelegramAdapter } from "./lib/telegram-adapter.js";
 import { acknowledgeChannelDelivery, loadChannelRuntime } from "./lib/channel-runtime.js";
 import { loadPersonaRuntime, syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
@@ -93,12 +96,15 @@ async function hostWorkItem(root, item) {
   const goalStep = item.goalStepId === null || item.goalStepId === undefined ? null
     : goal?.plan?.steps.find((entry) => entry.stepId === item.goalStepId) || null;
   if (item.goalStepId && !goalStep) throw new Error("claimed work lost its exact goal-plan step");
+  const executionAttempt = executionAttemptForStep(goalStep);
   const event = item.channelEventId === null ? null
     : channel.runtime.events.find((entry) => entry.eventId === item.channelEventId) || null;
   if (item.channelEventId && !event) throw new Error("claimed channel work lost its exact event");
   return {
     ...structuredClone(item), host: identity.host, profileId: identity.profileId, projectRoot: root,
-    goal: goal ? structuredClone(goal) : null, goalStep: goalStep ? structuredClone(goalStep) : null,
+    goal: goal ? structuredClone(goal) : null,
+    goalStep: goalStep ? { ...structuredClone(goalStep),
+      ...(executionAttempt === null ? {} : { executionAttempt }) } : null,
     hostEnvironment: {
       AGENTSPINE_GATEWAY_CONTEXT: "agentspine.gateway-start/v1",
       AGENTSPINE_ENTITY_ID: item.agentId,
@@ -156,9 +162,11 @@ export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-
   }
   const completed = await completeGatewayRun({ root, queueId: claim.item.queueId, workerId, result, now });
   if (!completed.outbox) return {
-    status: completed.clarification ? "needs-clarification" : completed.item.status,
+    status: completed.clarification ? "needs-clarification"
+      : completed.exploration ? "exploring" : completed.item.status,
     processed: true, queueId: completed.item.queueId,
-    ...(completed.clarification ? { clarification: completed.clarification } : {})
+    ...(completed.clarification ? { clarification: completed.clarification } : {}),
+    ...(completed.exploration ? { exploration: completed.exploration } : {})
   };
   const delivery = await deliverPrepared({ root, outboxId: completed.outbox.outboxId,
     adapter: deliveryAdapter, now });

package/bin/native-runtime-cache.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+function isPathInside(root, candidate) {
+  const relative = path.relative(path.resolve(root), path.resolve(candidate));
+  return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+
+function cacheBase(options = {}) {
+  if (options.cacheBase) return path.resolve(options.cacheBase);
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  if (env.BLUN_CACHE_DIR) return path.resolve(env.BLUN_CACHE_DIR);
+  if (platform === 'win32') {
+    return path.resolve(env.LOCALAPPDATA || path.join(options.homeDir || os.homedir(), 'AppData', 'Local'), 'blun');
+  }
+  if (platform === 'darwin') return path.join(options.homeDir || os.homedir(), 'Library', 'Caches', 'blun');
+  return path.join(env.XDG_CACHE_HOME || path.join(options.homeDir || os.homedir(), '.cache'), 'blun');
+}
+
+function sha256(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+function ensureCachedFile(sourcePath, targetPath, expectedHash) {
+  try {
+    if (sha256(fs.readFileSync(targetPath)) === expectedHash) return targetPath;
+  } catch {}
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  const temporary = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+  fs.copyFileSync(sourcePath, temporary);
+  try {
+    fs.renameSync(temporary, targetPath);
+  } catch (error) {
+    try {
+      if (sha256(fs.readFileSync(targetPath)) === expectedHash) {
+        fs.rmSync(temporary, { force: true });
+        return targetPath;
+      }
+    } catch {}
+    fs.rmSync(temporary, { force: true });
+    throw error;
+  }
+  return targetPath;
+}
+
+function resolveNativeRuntimePath(requestPath, options = {}) {
+  if (typeof requestPath !== 'string' || path.extname(requestPath).toLowerCase() !== '.node') return requestPath;
+  const packageRoot = options.packageRoot && path.resolve(options.packageRoot);
+  const sourcePath = path.resolve(requestPath);
+  if (!packageRoot || !isPathInside(packageRoot, sourcePath)) return requestPath;
+  let bytes;
+  try {
+    bytes = fs.readFileSync(sourcePath);
+  } catch {
+    return requestPath;
+  }
+  const hash = sha256(bytes);
+  const relativePath = path.relative(packageRoot, sourcePath);
+  const relativeHash = sha256(Buffer.from(relativePath.replaceAll('\\', '/'))).slice(0, 16);
+  const targetPath = path.join(cacheBase(options), 'native-runtime', hash, `${relativeHash}-${path.basename(sourcePath)}`);
+  try {
+    return ensureCachedFile(sourcePath, targetPath, hash);
+  } catch {
+    return requestPath;
+  }
+}
+
+module.exports = {
+  isPathInside,
+  resolveNativeRuntimePath,
+};

package/blun.mjs

@@ -17,6 +17,7 @@ import sessionScrollbackArchive from "./bin/session-scrollback-archive.cjs";
 import sessionReplayWindowPolicy from "./bin/session-replay-window-policy.cjs";
 import globPatternPolicy from "./bin/glob-pattern-policy.cjs";
 import userHomePathPolicy from "./bin/user-home-path-policy.cjs";
+import nativeRuntimeCachePolicy from "./bin/native-runtime-cache.cjs";
 import editableToolApprovalPolicy from "./bin/editable-tool-approval-policy.cjs";
 import editableToolApprovalRuntime from "./bin/editable-tool-approval-runtime.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
@@ -59,6 +60,7 @@ const { SessionScrollbackArchive, sessionScrollbackArchiveDirectory } = sessionS
 const { replayWindowStartIndex, resolveReplayActiveTurnCount } = sessionReplayWindowPolicy;
 const { globPatternError } = globPatternPolicy;
 const { unsupportedUserHomePathError } = userHomePathPolicy;
+const { resolveNativeRuntimePath } = nativeRuntimeCachePolicy;
 const {
 	buildApprovalEditedEvent,
 	canonicalEditedToolInputJson,
@@ -523527,6 +523529,7 @@ function installNativeModuleHook() {
 	installed = true;
 	const moduleBuiltin = nodeRequire("node:module");
 	const originalLoad = moduleBuiltin._load;
+	const originalResolveFilename = moduleBuiltin._resolveFilename;
 	if (originalLoad === void 0) return;
 	moduleBuiltin._load = function loadWithNativeAssets(request, parent, isMain) {
 		if (request === "node-pty") {
@@ -523543,6 +523546,13 @@ function installNativeModuleHook() {
 				}
 			}
 		}
+		if (typeof request === "string" && request.toLowerCase().endsWith(".node") && typeof originalResolveFilename === "function") {
+			try {
+				const resolvedRequest = originalResolveFilename.call(moduleBuiltin, request, parent, isMain);
+				const cachedRequest = resolveNativeRuntimePath(resolvedRequest, { packageRoot: __dirname });
+				if (cachedRequest !== resolvedRequest) return originalLoad.call(this, cachedRequest, parent, isMain);
+			} catch {}
+		}
 		return originalLoad.call(this, request, parent, isMain);
 	};
 }

package/package.json

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

package/telegram-plugin/dist/bridge.mjs

@@ -212,8 +212,11 @@ function gate(ctx, botUsername) {
 		if (policy === void 0) return { action: "drop" };
 		const groupAllowFrom = policy.allowFrom ?? [];
 		if (groupAllowFrom.length > 0 && !groupAllowFrom.includes(senderId)) return { action: "drop" };
+		const ignored = matchesAny(ctx.text, access.ignorePatterns);
+		const mentioned = !ignored && isMentioned(ctx, botUsername, access.mentionPatterns);
+		if (policy.requireMention === true && !mentioned) return { action: "drop" };
 		const mentionBypass = from.isBot !== true && (policy.alwaysAllowFrom ?? []).includes(senderId);
-		const addressed = !matchesAny(ctx.text, access.ignorePatterns) && (mentionBypass || isMentioned(ctx, botUsername, access.mentionPatterns));
+		const addressed = mentioned || !ignored && mentionBypass;
 		const targetedElsewhere = from.isBot === true && !addressed;
 		return {
 			action: "deliver",