signetai 0.214.41 → 0.216.4

package/dist/mcp-stdio.js

@@ -6640,16 +6640,17 @@ import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { statfsSync } from "node:fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2, resolve } from "node:path";
 import {
   chmodSync,
   closeSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   fsyncSync,
   mkdirSync as mkdirSync2,
   openSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync as readdirSync2,
   renameSync,
   rmdirSync,
@@ -6661,12 +6662,26 @@ import { join as join4 } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { createRequire as createRequire2 } from "node:module";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync6,
+  fsyncSync as fsyncSync2,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
+  readFileSync as readFileSync5,
+  renameSync as renameSync2,
+  rmSync,
+  statSync as statSync3,
+  writeSync
+} from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join7, resolve as resolve2 } from "node:path";
 import { createRequire as createRequire3 } from "node:module";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, join as join8, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join8, resolve as resolve3 } from "node:path";
 import { homedir as homedir6, platform as platform2 } from "node:os";
-import { basename, dirname as dirname5, resolve as resolve4 } from "node:path";
+import { basename, dirname as dirname5, resolve as resolve5 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 function __accessProp2(key) {
   return this[key];
@@ -15620,7 +15635,27 @@ function findSqliteVecExtension() {
   return null;
 }
 function resolveDefaultBasePath() {
-  return process.env.SIGNET_PATH || join2(homedir2(), ".agents");
+  const envPath = process.env.SIGNET_PATH?.trim() || process.env.SIGNET_WORKSPACE?.trim();
+  if (envPath)
+    return resolve(expandHome(envPath));
+  const home = homedir2();
+  const configHome = process.env.XDG_CONFIG_HOME?.trim() ? resolve(expandHome(process.env.XDG_CONFIG_HOME.trim(), home)) : join2(home, ".config");
+  const configPath = join2(configHome, "signet", "workspace.json");
+  if (existsSync2(configPath)) {
+    try {
+      const value = JSON.parse(readFileSync(configPath, "utf8"));
+      if (typeof value.workspace === "string" && value.workspace.trim())
+        return resolve(expandHome(value.workspace, home));
+    } catch {}
+  }
+  return join2(home, ".agents");
+}
+function expandHome(p2, home = homedir2()) {
+  if (p2 === "~")
+    return home;
+  if (p2.startsWith("~/") || p2.startsWith("~\\"))
+    return join2(home, p2.slice(2));
+  return p2;
 }
 function workspaceAccount(workspace) {
   return createHash2("sha256").update(workspace).digest("hex").slice(0, 32);
@@ -15828,11 +15863,11 @@ function cleanupStaleSecretStoreTemps() {
 function loadStore() {
   cleanupStaleSecretStoreTemps();
   const file2 = getSecretsFile();
-  if (!existsSync3(file2)) {
+  if (!existsSync4(file2)) {
     return { version: 1, secrets: {} };
   }
   try {
-    return parseSecretsStore(JSON.parse(readFileSync2(file2, "utf-8")));
+    return parseSecretsStore(JSON.parse(readFileSync3(file2, "utf-8")));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to read secrets store: ${message}`);
@@ -15852,7 +15887,7 @@ function healthForKeyringState(result) {
 function getLocalSecretProviderHealth() {
   try {
     const store = loadStore();
-    if (existsSync3(join4(getSecretsDir(), DEGRADED_WARNING_FILE))) {
+    if (existsSync4(join4(getSecretsDir(), DEGRADED_WARNING_FILE))) {
       return {
         status: "degraded",
         message: "Using legacy machine-id-obfuscated secrets encryption because no native keyring is available",
@@ -16015,6 +16050,146 @@ function resolveSignetDaemonUrl(opts = {}) {
   const port = normalizePort(readEnv(env, "SIGNET_PORT"), fallbackPort);
   return normalizeDaemonUrl(`http://${bracketIpv6Host(host)}:${port}`, "SIGNET_HOST/SIGNET_PORT");
 }
+function normalizeWorkspacePath(pathValue, home = homedir4()) {
+  return resolve2(expandHome(pathValue.trim(), home));
+}
+function readTrimmedEnv(env, name) {
+  const value = env[name];
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function readConfigHome(env, home) {
+  const raw = env.XDG_CONFIG_HOME;
+  if (typeof raw !== "string")
+    return join7(home, ".config");
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? normalizeWorkspacePath(trimmed, home) : join7(home, ".config");
+}
+function isExistingDirectory(path) {
+  try {
+    return statSync3(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getWorkspaceConfigPath(env = process.env, home = homedir4()) {
+  return join7(readConfigHome(env, home), "signet", "workspace.json");
+}
+function readConfiguredWorkspacePath(env = process.env, home = homedir4(), options = {}) {
+  const strict = options.strict ?? true;
+  const configPath = getWorkspaceConfigPath(env, home);
+  if (!existsSync6(configPath))
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync5(configPath, "utf-8"));
+  } catch (err) {
+    if (!strict)
+      return null;
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid Signet workspace config at ${configPath}: ${detail}`);
+  }
+  if (!isRecord5(raw) || !("workspace" in raw)) {
+    if (!strict)
+      return null;
+    throw new Error(`Invalid Signet workspace config at ${configPath}: missing workspace`);
+  }
+  const workspace = raw.workspace;
+  if (typeof workspace !== "string" || workspace.trim().length === 0) {
+    if (!strict)
+      return null;
+    throw new Error(`Invalid Signet workspace config at ${configPath}: workspace must be a non-empty string`);
+  }
+  return normalizeWorkspacePath(workspace, home);
+}
+function resolveWorkspacePath(options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir4();
+  const strict = options.strict ?? true;
+  const requireExistingEnvPath = options.requireExistingEnvPath ?? false;
+  const configPath = getWorkspaceConfigPath(env, home);
+  const envPath = resolveEnvWorkspace(env, home, requireExistingEnvPath);
+  const configValue = readConfiguredWorkspacePath(env, home, { strict: envPath ? false : strict });
+  if (envPath) {
+    return {
+      path: envPath,
+      source: "env",
+      configPath,
+      configuredPath: configValue
+    };
+  }
+  if (configValue) {
+    return {
+      path: configValue,
+      source: "config",
+      configPath,
+      configuredPath: configValue
+    };
+  }
+  return {
+    path: join7(home, DEFAULT_AGENTS_DIRNAME),
+    source: "default",
+    configPath,
+    configuredPath: configValue
+  };
+}
+function preflightWorkspace(options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir4();
+  let resolution;
+  try {
+    resolution = resolveWorkspacePath({ ...options, strict: true });
+  } catch (error51) {
+    const detail = error51 instanceof Error ? error51.message : String(error51);
+    return {
+      path: join7(home, DEFAULT_AGENTS_DIRNAME),
+      source: "default",
+      configPath: getWorkspaceConfigPath(env, home),
+      configuredPath: null,
+      status: "incomplete",
+      reasons: [detail]
+    };
+  }
+  const reasons = [];
+  const hasExplicitConfiguration = resolution.source === "env" || resolution.configuredPath !== null;
+  if (!isExistingDirectory(resolution.path)) {
+    if (hasExplicitConfiguration) {
+      reasons.push("configured workspace directory is missing");
+      return { ...resolution, status: "missing", reasons };
+    }
+    return { ...resolution, status: "fresh", reasons };
+  }
+  const hasAgentConfig = existsSync6(join7(resolution.path, "agent.yaml")) || existsSync6(join7(resolution.path, "config.yaml"));
+  const hasMemoryDb = existsSync6(join7(resolution.path, "memory", "memories.db"));
+  if (hasAgentConfig && hasMemoryDb) {
+    return { ...resolution, status: "ready", reasons };
+  }
+  if (!hasExplicitConfiguration && !hasAgentConfig && !hasMemoryDb) {
+    return { ...resolution, status: "fresh", reasons };
+  }
+  if (!hasAgentConfig)
+    reasons.push("workspace configuration is missing (agent.yaml or config.yaml)");
+  if (!hasMemoryDb)
+    reasons.push("workspace database is missing (memory/memories.db)");
+  return { ...resolution, status: "incomplete", reasons };
+}
+function resolveEnvWorkspace(env, home, requireExisting) {
+  for (const key of WORKSPACE_ENV_KEYS) {
+    const raw = readTrimmedEnv(env, key);
+    if (!raw)
+      continue;
+    const normalized = normalizeWorkspacePath(raw, home);
+    if (!requireExisting || isExistingDirectory(normalized))
+      return normalized;
+    console.warn(`[signet] ${key}="${raw}" does not point to an existing workspace directory; using the default workspace resolution instead.`);
+  }
+  return null;
+}
 function blobToVector(blob) {
   if (blob instanceof ArrayBuffer) {
     return new Float32Array(blob);
@@ -16175,10 +16350,10 @@ function emptyGraphiqState(now = new Date) {
 }
 function readGraphiqState(basePath) {
   const path = getGraphiqStatePath(basePath);
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return emptyGraphiqState();
   try {
-    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
     return parseGraphiqState(parsed);
   } catch {
     return emptyGraphiqState();
@@ -16224,11 +16399,11 @@ function isRecord6(value) {
 function defaultDiscordDesktopCachePath() {
   switch (platform2()) {
     case "darwin":
-      return resolve4(homedir6(), "Library", "Application Support", "discord");
+      return resolve5(homedir6(), "Library", "Application Support", "discord");
     case "win32":
-      return resolve4(process.env.APPDATA || resolve4(homedir6(), "AppData", "Roaming"), "discord");
+      return resolve5(process.env.APPDATA || resolve5(homedir6(), "AppData", "Roaming"), "discord");
     default:
-      return resolve4(process.env.XDG_CONFIG_HOME || resolve4(homedir6(), ".config"), "discord");
+      return resolve5(process.env.XDG_CONFIG_HOME || resolve5(homedir6(), ".config"), "discord");
   }
 }
 var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toESMCache_node2, __toESMCache_esm2, __toESM2 = (mod, isNodeMode, target) => {
@@ -16258,7 +16433,7 @@ var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __hasOwnProp2, __t
       configurable: true,
       set: __exportSetter2.bind(all, name)
     });
-}, __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), __require, require_identity, require_visit, require_directives, require_anchors, require_applyReviver, require_toJS, require_Node, require_Alias, require_Scalar, require_createNode, require_Collection, require_stringifyComment, require_foldFlowLines, require_stringifyString, require_stringify, require_stringifyPair, require_log, require_merge, require_addPairToJSMap, require_Pair, require_stringifyCollection, require_YAMLMap, require_map, require_YAMLSeq, require_seq, require_string, require_null, require_bool, require_stringifyNumber, require_float, require_int, require_schema, require_schema2, require_binary, require_pairs, require_omap, require_bool2, require_float2, require_int2, require_set, require_timestamp, require_schema3, require_tags, require_Schema, require_stringifyDocument, require_Document, require_errors2, require_resolve_props, require_util_contains_newline, require_util_flow_indent_check, require_util_map_includes, require_resolve_block_map, require_resolve_block_seq, require_resolve_end, require_resolve_flow_collection, require_compose_collection, require_resolve_block_scalar, require_resolve_flow_scalar, require_compose_scalar, require_util_empty_scalar_position, require_compose_node, require_compose_doc, require_composer, require_cst_scalar, require_cst_stringify, require_cst_visit, require_cst, require_lexer, require_line_counter, require_parser, require_public_api, require_dist2, require_keyring_linux_x64_musl, require_package, require_keyring_linux_x64_gnu, require_package2, require_keyring, libsodium_default, init_libsodium, exports_libsodium_wrappers, r, t, a, _, n, s, m, libsodium_wrappers_default, init_libsodium_wrappers, PIPELINE_PROVIDER_CHOICES, SYNTHESIS_PROVIDER_CHOICES, DEFAULT_PIPELINE_TIMEOUT_MS = 90000, PIPELINE_PROVIDER_SET, SYNTHESIS_PROVIDER_SET, MEMORY_CONTENT_SAFETY_POLICY_VERSION = "memory-content-safety-v1", MEMORY_CONTENT_WITHHELD_NOTICE = "[memory content withheld by safety policy]", MEMORY_CONTENT_SAFETY_REASONS, INVISIBLE_UNICODE_RE, STRONG_DEFENSIVE_CONTEXT_RE, REPORTING_CONTEXT_RE, REPORTING_BEFORE_RE, REPORTING_AFTER_RE, NEGATED_DIRECTIVE_RE, PROMPT_INJECTION_RES, TOOL_DIRECTIVE_RES, EXFILTRATION_RE, EXFILTRATION_REVERSE, CREDENTIAL_HARVESTING_RE, DANGEROUS_SHELL_RE, DAEMON_DERIVED_MEMORY_SOURCE_TYPES, MEMORIES_FTS_TOKENIZER = "unicode61", FTS_STATE_TABLE = "memories_fts_state", COLUMNS, DEPENDENCY_TYPES, DERIVED_SOURCE_TYPES, TOKEN_COLUMNS, COLUMNS2, COMPLETION_BOUNDARY_REASONS, MIGRATIONS, LATEST_SCHEMA_VERSION, NETWORK_FILESYSTEM_TYPES, __filename2, __dirname2, import_yaml, DEFAULT_EMBEDDING_DIMENSIONS = 768, SERVICE = "ai.signet.secrets", require2, modulePromise = null, syncModule, adapterForTests = null, secretEventRecorder = () => {}, SECRET_STORE_TEMP_PREFIX = "secrets.enc.tmp-", NATIVE_STORE_VERSION = 2, DEGRADED_WARNING_FILE = ".degraded-warning", KEYRING_ACCOUNT_SCOPE = "workspace", SecretKeyringError, NAME_RE, DEFAULT_TELEMETRY_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_TELEMETRY_POSTHOG_API_KEY = "phc_mLsvJmbmp6e9UarrX9Cq5QtTjVNiiphM9mvi5Xnddd8Q", DEFAULT_TELEMETRY_FLUSH_INTERVAL_MS = 60000, DEFAULT_TELEMETRY_FLUSH_BATCH_SIZE = 50, DEFAULT_PROVIDER_RATE_LIMIT, TELEMETRY_DEPLOYMENT_ROLES, TELEMETRY_INSTALL_CHANNELS, ENTITY_TYPES, ATTRIBUTE_KINDS, DEPENDENCY_TYPES2, ONTOLOGY_PROPOSAL_OPERATIONS, LOOPBACK_HOST = "127.0.0.1", LOCAL_BINDS, import_yaml2, native = null, SIGNET_SECRETS_PLUGIN_ID = "signet.secrets", SIGNET_GRAPHIQ_PLUGIN_ID = "signet.graphiq", SIGNET_PLUGIN_REGISTRY_DIR = ".daemon/plugins", SIGNET_PLUGIN_REGISTRY_FILE = "registry-v1.json", SIGNET_GRAPHIQ_STATE_FILE = ".daemon/graphiq/state.json", GRAPHIQ_DEFAULT_INSTALL_DIR, SIGNET_SOURCE_CHECKOUT_DIRNAME = "signetai", SIGNET_GIT_ALLOWED_DIRECTORIES, SIGNET_GIT_PROTECTED_PATHS, SIGNET_GIT_TRACKED_PATHS, SIGNET_GITIGNORE_PROTECTED_PATTERNS, DEFAULT_DISCORD_DESKTOP_CACHE_PATH, DEFAULT_GITHUB_RESOURCE_TYPES, VALID_GITHUB_RESOURCE_TYPES, IDENTITY_FILES, REQUIRED_IDENTITY_KEYS, OPTIONAL_IDENTITY_KEYS, home, SOURCE_NATIVE_TOPOLOGY_ENTITY_TYPES;
+}, __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), __require, require_identity, require_visit, require_directives, require_anchors, require_applyReviver, require_toJS, require_Node, require_Alias, require_Scalar, require_createNode, require_Collection, require_stringifyComment, require_foldFlowLines, require_stringifyString, require_stringify, require_stringifyPair, require_log, require_merge, require_addPairToJSMap, require_Pair, require_stringifyCollection, require_YAMLMap, require_map, require_YAMLSeq, require_seq, require_string, require_null, require_bool, require_stringifyNumber, require_float, require_int, require_schema, require_schema2, require_binary, require_pairs, require_omap, require_bool2, require_float2, require_int2, require_set, require_timestamp, require_schema3, require_tags, require_Schema, require_stringifyDocument, require_Document, require_errors2, require_resolve_props, require_util_contains_newline, require_util_flow_indent_check, require_util_map_includes, require_resolve_block_map, require_resolve_block_seq, require_resolve_end, require_resolve_flow_collection, require_compose_collection, require_resolve_block_scalar, require_resolve_flow_scalar, require_compose_scalar, require_util_empty_scalar_position, require_compose_node, require_compose_doc, require_composer, require_cst_scalar, require_cst_stringify, require_cst_visit, require_cst, require_lexer, require_line_counter, require_parser, require_public_api, require_dist2, require_keyring_linux_x64_musl, require_package, require_keyring_linux_x64_gnu, require_package2, require_keyring, libsodium_default, init_libsodium, exports_libsodium_wrappers, r, t, a, _, n, s, m, libsodium_wrappers_default, init_libsodium_wrappers, PIPELINE_PROVIDER_CHOICES, SYNTHESIS_PROVIDER_CHOICES, DEFAULT_PIPELINE_TIMEOUT_MS = 90000, PIPELINE_PROVIDER_SET, SYNTHESIS_PROVIDER_SET, MEMORY_CONTENT_SAFETY_POLICY_VERSION = "memory-content-safety-v1", MEMORY_CONTENT_WITHHELD_NOTICE = "[memory content withheld by safety policy]", MEMORY_CONTENT_SAFETY_REASONS, INVISIBLE_UNICODE_RE, STRONG_DEFENSIVE_CONTEXT_RE, REPORTING_CONTEXT_RE, REPORTING_BEFORE_RE, REPORTING_AFTER_RE, NEGATED_DIRECTIVE_RE, PROMPT_INJECTION_RES, TOOL_DIRECTIVE_RES, EXFILTRATION_RE, EXFILTRATION_REVERSE, CREDENTIAL_HARVESTING_RE, DANGEROUS_SHELL_RE, DAEMON_DERIVED_MEMORY_SOURCE_TYPES, MEMORIES_FTS_TOKENIZER = "unicode61", FTS_STATE_TABLE = "memories_fts_state", COLUMNS, DEPENDENCY_TYPES, DERIVED_SOURCE_TYPES, TOKEN_COLUMNS, COLUMNS2, COMPLETION_BOUNDARY_REASONS, MIGRATIONS, LATEST_SCHEMA_VERSION, NETWORK_FILESYSTEM_TYPES, __filename2, __dirname2, import_yaml, DEFAULT_EMBEDDING_DIMENSIONS = 768, SERVICE = "ai.signet.secrets", require2, modulePromise = null, syncModule, adapterForTests = null, secretEventRecorder = () => {}, SECRET_STORE_TEMP_PREFIX = "secrets.enc.tmp-", NATIVE_STORE_VERSION = 2, DEGRADED_WARNING_FILE = ".degraded-warning", KEYRING_ACCOUNT_SCOPE = "workspace", SecretKeyringError, NAME_RE, DEFAULT_TELEMETRY_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_TELEMETRY_POSTHOG_API_KEY = "phc_mLsvJmbmp6e9UarrX9Cq5QtTjVNiiphM9mvi5Xnddd8Q", DEFAULT_TELEMETRY_FLUSH_INTERVAL_MS = 60000, DEFAULT_TELEMETRY_FLUSH_BATCH_SIZE = 50, DEFAULT_PROVIDER_RATE_LIMIT, TELEMETRY_DEPLOYMENT_ROLES, TELEMETRY_INSTALL_CHANNELS, ENTITY_TYPES, ATTRIBUTE_KINDS, DEPENDENCY_TYPES2, ONTOLOGY_PROPOSAL_OPERATIONS, LOOPBACK_HOST = "127.0.0.1", LOCAL_BINDS, import_yaml2, WORKSPACE_ENV_KEYS, DEFAULT_AGENTS_DIRNAME = ".agents", native = null, SIGNET_SECRETS_PLUGIN_ID = "signet.secrets", SIGNET_GRAPHIQ_PLUGIN_ID = "signet.graphiq", SIGNET_PLUGIN_REGISTRY_DIR = ".daemon/plugins", SIGNET_PLUGIN_REGISTRY_FILE = "registry-v1.json", SIGNET_GRAPHIQ_STATE_FILE = ".daemon/graphiq/state.json", GRAPHIQ_DEFAULT_INSTALL_DIR, SIGNET_SOURCE_CHECKOUT_DIRNAME = "signetai", SIGNET_GIT_ALLOWED_DIRECTORIES, SIGNET_GIT_PROTECTED_PATHS, SIGNET_GIT_TRACKED_PATHS, SIGNET_GITIGNORE_PROTECTED_PATTERNS, DEFAULT_DISCORD_DESKTOP_CACHE_PATH, DEFAULT_GITHUB_RESOURCE_TYPES, VALID_GITHUB_RESOURCE_TYPES, IDENTITY_FILES, REQUIRED_IDENTITY_KEYS, OPTIONAL_IDENTITY_KEYS, home, SOURCE_NATIVE_TOPOLOGY_ENTITY_TYPES;
 var init_dist = __esm(() => {
   __create2 = Object.create;
   __getProtoOf2 = Object.getPrototypeOf;
@@ -23198,7 +23373,7 @@ ${end.comment}` : end.comment;
     var __filename2 = "/home/runner/work/signetai/signetai/node_modules/.bun/@napi-rs+keyring@1.3.0/node_modules/@napi-rs/keyring/index.js";
     var { createRequire: createRequire22 } = __require("node:module");
     __require = createRequire22(__filename2);
-    var { readFileSync: readFileSync22 } = __require("node:fs");
+    var { readFileSync: readFileSync32 } = __require("node:fs");
     var nativeBinding = null;
     var loadErrors = [];
     var isMusl = () => {
@@ -23217,7 +23392,7 @@ ${end.comment}` : end.comment;
     var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
     var isMuslFromFilesystem = () => {
       try {
-        return readFileSync22("/usr/bin/ldd", "utf-8").includes("musl");
+        return readFileSync32("/usr/bin/ldd", "utf-8").includes("musl");
       } catch {
         return null;
       }
@@ -25250,6 +25425,7 @@ ${end.comment}` : end.comment;
   ];
   LOCAL_BINDS = new Set([LOOPBACK_HOST, "localhost", "::1", "::ffff:127.0.0.1"]);
   import_yaml2 = __toESM2(require_dist2(), 1);
+  WORKSPACE_ENV_KEYS = ["SIGNET_PATH", "SIGNET_WORKSPACE"];
   try {
     const esmRequire = createRequire3(import.meta.url);
     native = esmRequire("@signet/native");
@@ -25386,16 +25562,7 @@ ${end.comment}` : end.comment;
 
 // ../../platform/daemon/src/logger.ts
 import { EventEmitter } from "node:events";
-import {
-  appendFileSync,
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync,
-  readdirSync as readdirSync3,
-  renameSync as renameSync2,
-  statSync as statSync2,
-  unlinkSync as unlinkSync2
-} from "node:fs";
+import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync3, renameSync as renameSync4, statSync as statSync2, unlinkSync as unlinkSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { basename as basename2, dirname as dirname2, join as join3 } from "node:path";
 function resolveLoggerConfig(env = process.env, homeDir = homedir3()) {
@@ -25443,20 +25610,8 @@ var init_logger = __esm(() => {
       super();
       this.config = { ...DEFAULT_CONFIG, ...config2 };
       this.currentLogFile = this.getLogFileName();
-      this.ensureLogDir();
       this.startFlushTimer();
     }
-    ensureLogDir() {
-      try {
-        const dir = this.config.logFilePath ? dirname2(this.config.logFilePath) : this.config.logDir;
-        if (!existsSync2(dir)) {
-          mkdirSync(dir, { recursive: true });
-        }
-      } catch (e) {
-        this.fileOutputEnabled = false;
-        console.error("Failed to initialize log directory, disabling file logging:", e);
-      }
-    }
     getLogFileName() {
       if (this.config.logFilePath) {
         return this.config.logFilePath;
@@ -25504,7 +25659,7 @@ var init_logger = __esm(() => {
         return [];
       }
       if (this.config.logFilePath) {
-        if (!existsSync2(this.config.logFilePath))
+        if (!existsSync3(this.config.logFilePath))
           return [];
         return [
           {
@@ -25513,7 +25668,7 @@ var init_logger = __esm(() => {
           }
         ];
       }
-      if (!existsSync2(this.config.logDir))
+      if (!existsSync3(this.config.logDir))
         return [];
       return readdirSync3(this.config.logDir).filter((f2) => this.parseLogFileName(f2) !== null).map((f2) => ({
         name: f2,
@@ -25551,7 +25706,11 @@ var init_logger = __esm(() => {
     }
     write(entry) {
       if (this.config.consoleOutput) {
-        console.log(this.formatConsole(entry));
+        const message = this.formatConsole(entry);
+        if (process.env.SIGNET_DB_OWNER_WORKER === "1")
+          console.error(message);
+        else
+          console.log(message);
       }
       this.buffer.push(entry);
       this.emit("log", entry);
@@ -25606,7 +25765,7 @@ var init_logger = __esm(() => {
       if (this.config.logFilePath)
         return;
       try {
-        if (!existsSync2(this.currentLogFile))
+        if (!existsSync3(this.currentLogFile))
           return;
         const stats = statSync2(this.currentLogFile);
         if (stats.size > this.config.maxFileSize) {
@@ -25618,7 +25777,7 @@ var init_logger = __esm(() => {
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
       const rotatedName = this.currentLogFile.replace(".log", `-${timestamp}.log`);
       try {
-        renameSync2(this.currentLogFile, rotatedName);
+        renameSync4(this.currentLogFile, rotatedName);
         this.cleanOldLogs();
       } catch {}
     }
@@ -25751,7 +25910,7 @@ var init_logger = __esm(() => {
           if (results.length >= limit * 2)
             break;
           try {
-            const content = readFileSync(file2.path, "utf-8");
+            const content = readFileSync2(file2.path, "utf-8");
             const lines = content.trim().split(`
 `).filter(Boolean);
             const recentLines = lines.slice(-(limit * 2));
@@ -25773,8 +25932,9 @@ var init_logger = __esm(() => {
       } catch {}
       return results.slice(-limit);
     }
-    shutdown() {
-      this.flush(true);
+    shutdown(flush = true) {
+      if (flush)
+        this.flush(true);
       if (this.flushTimer) {
         clearInterval(this.flushTimer);
       }
@@ -25784,8 +25944,8 @@ var init_logger = __esm(() => {
 });
 
 // ../../platform/daemon/src/db-vacuum.ts
-import { statSync as statSync3, statfsSync as statfsSync2 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { statSync as statSync4, statfsSync as statfsSync2 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
 function isDbFullError(error51) {
   if (!(error51 instanceof Error))
     return false;
@@ -25795,7 +25955,7 @@ function isDbFullError(error51) {
 function measureDbSpace(dbPath, deps) {
   try {
     const dbBytes = deps.statSync(dbPath).size;
-    const directory = dirname3(dbPath);
+    const directory = dirname6(dbPath);
     const stats = deps.statfsSync(directory);
     const freeBytes = Number.isFinite(stats.bavail) && stats.bavail >= 0 && Number.isFinite(stats.bsize) && stats.bsize > 0 ? stats.bavail * stats.bsize : null;
     return { dbBytes, freeBytes, requiredBytes: dbBytes * 2 };
@@ -25970,7 +26130,7 @@ var init_db_vacuum = __esm(() => {
       this.name = "DbSpacePreflightError";
     }
   };
-  dbSpaceDeps = { statSync: statSync3, statfsSync: statfsSync2 };
+  dbSpaceDeps = { statSync: statSync4, statfsSync: statfsSync2 };
   UNKNOWN_DB_SPACE_METRICS = { dbBytes: 0, freeBytes: null, requiredBytes: 0 };
   STATE_TABLE_SQL = `
 	CREATE TABLE IF NOT EXISTS ${VACUUM_CONVERSION_STATE_TABLE} (
@@ -26303,7 +26463,7 @@ var init_auth = __esm(() => {
 });
 
 // ../../platform/daemon/src/memory-config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 function detectLocalTimeZone() {
   try {
@@ -26728,10 +26888,10 @@ function loadMemoryConfig(agentsDir) {
   const paths = [join6(agentsDir, "agent.yaml"), join6(agentsDir, "AGENT.yaml"), join6(agentsDir, "config.yaml")];
   const envWarmNative = envBool("SIGNET_EMBEDDING_WARM_NATIVE");
   for (const path of paths) {
-    if (!existsSync4(path))
+    if (!existsSync5(path))
       continue;
     try {
-      const yaml = parseSimpleYaml(readFileSync3(path, "utf-8"));
+      const yaml = parseSimpleYaml(readFileSync4(path, "utf-8"));
       if (isRecord3(yaml))
         rejectRetiredEmbeddingConfig(yaml);
       const emb = yaml.embedding ?? {};
@@ -27338,8 +27498,8 @@ function createDbAccessorLifecycle() {
       const participants = [...closeParticipants.values()].sort((left, right) => left.order - right.order || left.name.localeCompare(right.name));
       let resolveClose;
       let rejectClose;
-      const pendingClose = new Promise((resolve, reject) => {
-        resolveClose = resolve;
+      const pendingClose = new Promise((resolve4, reject) => {
+        resolveClose = resolve4;
         rejectClose = reject;
       });
       closePromise = pendingClose;
@@ -27446,12 +27606,12 @@ __export(exports_db_accessor, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   lstatSync,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync6,
+  mkdirSync,
+  readFileSync as readFileSync7,
   readdirSync as readdirSync5,
-  statSync as statSync4,
+  statSync as statSync6,
   statfsSync as statfsSync3,
   truncateSync,
   unlinkSync as unlinkSync3
@@ -27466,7 +27626,7 @@ import {
 } from "node:fs/promises";
 import { createRequire as createRequire4 } from "node:module";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename3, dirname as dirname6, join as join7 } from "node:path";
+import { basename as basename3, dirname as dirname8, join as join9 } from "node:path";
 function prepareTypedStatement(db, sql) {
   return db.prepare(sql);
 }
@@ -27493,7 +27653,7 @@ function assertDatabaseIntegrityWritesAllowed() {
 }
 function configurePragmas(db, path) {
   db.exec("PRAGMA auto_vacuum = INCREMENTAL");
-  const journal = resolveSqliteJournalConfig({ directory: dirname6(path) });
+  const journal = resolveSqliteJournalConfig({ directory: dirname8(path) });
   db.exec(`PRAGMA journal_mode = ${journal.journalMode}`);
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec(`PRAGMA synchronous = ${journal.networkFilesystem ? "FULL" : "NORMAL"}`);
@@ -27545,17 +27705,17 @@ function readTrimmed(env, key) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
-function readConfigHome(env) {
+function readConfigHome2(env) {
   const dir = readTrimmed(env, "XDG_CONFIG_HOME");
   if (dir !== null)
     return dir;
-  return join7(homedir7(), ".config");
+  return join9(homedir7(), ".config");
 }
 function readWorkspaceConfig(path) {
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return null;
   try {
-    const raw = JSON.parse(readFileSync6(path, "utf8"));
+    const raw = JSON.parse(readFileSync7(path, "utf8"));
     if (typeof raw !== "object" || raw === null)
       return null;
     if (!("workspace" in raw))
@@ -27574,17 +27734,17 @@ function resolveSqliteAgentsDir(opts) {
   const path = readTrimmed(env, "SIGNET_PATH");
   if (path !== null)
     return path;
-  const cfg = readWorkspaceConfig(join7(readConfigHome(env), "signet", "workspace.json"));
+  const cfg = readWorkspaceConfig(join9(readConfigHome2(env), "signet", "workspace.json"));
   if (cfg !== null)
     return cfg;
-  return join7((opts?.home ?? homedir7)(), ".agents");
+  return join9((opts?.home ?? homedir7)(), ".agents");
 }
 function resolveCustomSqlitePath(opts) {
   const platform3 = opts?.platform ?? process.platform;
   if (platform3 !== "darwin")
     return null;
   const env = opts?.env ?? process.env;
-  const exists = opts?.exists ?? existsSync7;
+  const exists = opts?.exists ?? existsSync8;
   const agentsDir = opts?.agentsDir ?? resolveSqliteAgentsDir({ env });
   const envPath = env.SIGNET_SQLITE_PATH;
   if (envPath) {
@@ -27593,7 +27753,7 @@ function resolveCustomSqlitePath(opts) {
     }
     return null;
   }
-  const local = join7(agentsDir, "libsqlite3.dylib");
+  const local = join9(agentsDir, "libsqlite3.dylib");
   if (exists(local)) {
     return { path: local, source: "workspace" };
   }
@@ -27628,7 +27788,7 @@ function resolveSqliteRuntimeConfig(opts) {
     };
   }
   const env = opts?.env ?? process.env;
-  const exists = opts?.exists ?? existsSync7;
+  const exists = opts?.exists ?? existsSync8;
   const set3 = opts?.set ?? ((path) => {
     const sqliteCtor = getDatabaseConstructor();
     if (typeof sqliteCtor.setCustomSQLite === "function") {
@@ -27755,11 +27915,11 @@ function isMissingPathError(err) {
   return err instanceof Error && "code" in err && (err.code === "ENOENT" || err.code === "ENOTDIR");
 }
 function migrationBackups(dbPath2, deps) {
-  const dir = dirname6(dbPath2);
+  const dir = dirname8(dbPath2);
   const base = basename3(dbPath2);
   return deps.readdirSync(dir).filter((f2) => isGeneratedMigrationBackupName(base, f2) && !f2.endsWith(".cursor.json") && !f2.includes(".probe-") && !f2.includes(".space-probe-")).flatMap((f2) => {
     try {
-      const path = join7(dir, f2);
+      const path = join9(dir, f2);
       if (deps.lstatSync !== undefined) {
         const stat2 = deps.lstatSync(path);
         if (!stat2.isFile()) {
@@ -27779,7 +27939,7 @@ function migrationBackups(dbPath2, deps) {
 }
 function readMigrationBackupVerdictStatus(backupPath) {
   try {
-    const parsed = JSON.parse(readFileSync6(`${backupPath}.verdict.json`, "utf8"));
+    const parsed = JSON.parse(readFileSync7(`${backupPath}.verdict.json`, "utf8"));
     return typeof parsed.status === "string" ? parsed.status : undefined;
   } catch {
     return;
@@ -27806,7 +27966,7 @@ function readMigrationBackupCheckpointStatus(backupPath, db, deps) {
 }
 function migrationBackupCursor(dbPath2, backupPath) {
   try {
-    const parsed = JSON.parse(readFileSync6(`${backupPath}.cursor.json`, "utf8"));
+    const parsed = JSON.parse(readFileSync7(`${backupPath}.cursor.json`, "utf8"));
     if (parsed.sourcePath !== dbPath2 || parsed.destination !== backupPath || typeof parsed.sourceSize !== "number" || !Number.isFinite(parsed.sourceSize) || typeof parsed.sourceMtimeMs !== "number" || !Number.isFinite(parsed.sourceMtimeMs) || typeof parsed.offset !== "number" || !Number.isInteger(parsed.offset) || parsed.offset < 0 || parsed.offset > parsed.sourceSize)
       return;
     return { sourceSize: parsed.sourceSize, sourceMtimeMs: parsed.sourceMtimeMs, offset: parsed.offset };
@@ -27815,11 +27975,11 @@ function migrationBackupCursor(dbPath2, backupPath) {
   }
 }
 function isCursorlessLegacyMigrationBackup(backupPath, cursor) {
-  return cursor === undefined && !existsSync7(`${backupPath}.cursor.json`);
+  return cursor === undefined && !existsSync8(`${backupPath}.cursor.json`);
 }
 function pruneStaleMigrationBackups(dbPath2, sourceSize, sourceMtimeMs, deps, db) {
   for (const backup of migrationBackups(dbPath2, deps)) {
-    const backupPath = join7(dirname6(dbPath2), backup.name);
+    const backupPath = join9(dirname8(dbPath2), backup.name);
     const cursor = migrationBackupCursor(dbPath2, backupPath);
     if (isCursorlessLegacyMigrationBackup(backupPath, cursor)) {
       const legacyStatus = readMigrationBackupCheckpointStatus(backupPath, db, deps);
@@ -27859,7 +28019,7 @@ function pruneStaleMigrationBackups(dbPath2, sourceSize, sourceMtimeMs, deps, db
 }
 function assertNoRetainedUnverifiedMigrationBackup(dbPath2, sourceSize, sourceMtimeMs, deps, db) {
   for (const backup of migrationBackups(dbPath2, deps)) {
-    const backupPath = join7(dirname6(dbPath2), backup.name);
+    const backupPath = join9(dirname8(dbPath2), backup.name);
     const cursor = migrationBackupCursor(dbPath2, backupPath);
     if (isCursorlessLegacyMigrationBackup(backupPath, cursor)) {
       const legacyStatus = readMigrationBackupCheckpointStatus(backupPath, db, deps);
@@ -27876,12 +28036,12 @@ function assertNoRetainedUnverifiedMigrationBackup(dbPath2, sourceSize, sourceMt
   }
 }
 function shouldDeferPendingMigration(dbPath2, db, deps) {
-  if (!existsSync7(dbPath2) || !hasPendingMigrations(db))
+  if (!existsSync8(dbPath2) || !hasPendingMigrations(db))
     return false;
   const source = deps.statSync(dbPath2);
   let deferred = false;
   for (const backup of migrationBackups(dbPath2, deps)) {
-    const backupPath = join7(dirname6(dbPath2), backup.name);
+    const backupPath = join9(dirname8(dbPath2), backup.name);
     const cursor = migrationBackupCursor(dbPath2, backupPath);
     if (isCursorlessLegacyMigrationBackup(backupPath, cursor)) {
       const legacyStatus = readMigrationBackupCheckpointStatus(backupPath, db, deps);
@@ -27917,10 +28077,10 @@ function shouldDeferPendingMigration(dbPath2, db, deps) {
   return deferred;
 }
 function pruneMigrationBackups(dbPath2, keep, deps, keepName, strict = false, db, verifiedBackupPath) {
-  const dir = dirname6(dbPath2);
+  const dir = dirname8(dbPath2);
   for (const old of migrationBackups(dbPath2, deps).filter((backup) => backup.name !== keepName).slice(Math.max(0, keep))) {
     try {
-      const backupPath = join7(dir, old.name);
+      const backupPath = join9(dir, old.name);
       const cursor = migrationBackupCursor(dbPath2, backupPath);
       const legacyUnverified = isCursorlessLegacyMigrationBackup(backupPath, cursor) && backupPath !== verifiedBackupPath;
       if ((legacyUnverified || cursor !== undefined) && backupPath !== verifiedBackupPath && readMigrationBackupCheckpointStatus(backupPath, db, deps) !== MIGRATION_CHECKPOINT_COMPLETE_STATUS) {
@@ -27980,7 +28140,7 @@ function isDbFullError2(err) {
 }
 function preflightMigrationBackupSpace(dbPath2, deps) {
   const dbBytes = fileSize(dbPath2, deps);
-  const freeBytes = availableBytes(dirname6(dbPath2), deps);
+  const freeBytes = availableBytes(dirname8(dbPath2), deps);
   if (dbBytes === null)
     return null;
   const metrics = {
@@ -27997,7 +28157,7 @@ function preflightMigrationBackupSpace(dbPath2, deps) {
   return metrics;
 }
 function migrationBackupSpaceError(dbPath2, metrics, deps, err) {
-  const freeBytes = availableBytes(dirname6(dbPath2), deps) ?? metrics.freeBytes;
+  const freeBytes = availableBytes(dirname8(dbPath2), deps) ?? metrics.freeBytes;
   return new DbSpacePreflightError("migration_backup", { ...metrics, freeBytes }, err);
 }
 function backupBeforeMigration(db, dbPath2, schemaVersion, deps = migrationBackupDeps) {
@@ -28039,7 +28199,7 @@ async function streamedMigrationBackup(db, dbPath2, schemaVersion, deadlineAt) {
   try {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
   } catch {}
-  const sourceStat = statSync4(dbPath2);
+  const sourceStat = statSync6(dbPath2);
   const sourceSize = sourceStat.size;
   const sourceMtimeMs = sourceStat.mtimeMs;
   const sourceMode = sourceStat.mode & 4095;
@@ -28068,15 +28228,15 @@ async function streamedMigrationBackup(db, dbPath2, schemaVersion, deadlineAt) {
   return backupDest;
 }
 async function readMigrationBackupCursor(dbPath2, sourceSize, sourceMtimeMs) {
-  const dir = dirname6(dbPath2);
+  const dir = dirname8(dbPath2);
   const base = basename3(dbPath2);
   for (const name of readdirSync5(dir).filter((entry) => entry.endsWith(".cursor.json") && isGeneratedMigrationBackupName(base, entry.slice(0, -".cursor.json".length)))) {
-    const cursorPath = join7(dir, name);
+    const cursorPath = join9(dir, name);
     try {
       const parsed = JSON.parse(await readFileAsync(cursorPath, "utf8"));
       const cursorMatchesSource = parsed.sourcePath === dbPath2 && parsed.sourceSize === sourceSize && parsed.sourceMtimeMs === sourceMtimeMs;
       const destination = typeof parsed.destination === "string" ? parsed.destination : undefined;
-      const safeDestination = destination !== undefined && destination === join7(dir, basename3(destination)) && basename3(destination).startsWith(`${base}.bak-v`);
+      const safeDestination = destination !== undefined && destination === join9(dir, basename3(destination)) && basename3(destination).startsWith(`${base}.bak-v`);
       let destinationStat;
       let destinationExists = false;
       if (destination !== undefined) {
@@ -28231,7 +28391,7 @@ async function copyMigrationBackupChunks(dbPath2, backupDest, sourceSize, source
   }
 }
 function sweepStaleMigrationBackupProbes(dbPath2, deps) {
-  const dir = dirname6(dbPath2);
+  const dir = dirname8(dbPath2);
   const base = basename3(dbPath2);
   let entries;
   try {
@@ -28244,7 +28404,7 @@ function sweepStaleMigrationBackupProbes(dbPath2, deps) {
     const probeName = entry.includes(".space-probe-") ? entry.slice(0, entry.indexOf(".space-probe-")) : entry.slice(0, entry.indexOf(".probe-"));
     if (!isGeneratedMigrationBackupName(base, probeName) || !isProbe || entry.endsWith(`.probe-${process.pid}`) || entry.endsWith(`.space-probe-${process.pid}`))
       continue;
-    const path = join7(dir, entry);
+    const path = join9(dir, entry);
     try {
       deps.unlinkSync(path);
       deps.log(`[db-accessor] Reclaimed stale migration backup probe: ${entry}`);
@@ -28272,7 +28432,7 @@ function preflightResumedMigrationBackupSpace(dbPath2, sourceSize, offset, deps)
   const remaining = sourceSize - offset;
   if (remaining <= 0)
     return;
-  const freeBytes = availableBytes(dirname6(dbPath2), deps);
+  const freeBytes = availableBytes(dirname8(dbPath2), deps);
   const metrics = {
     dbBytes: sourceSize,
     freeBytes,
@@ -28312,7 +28472,7 @@ function hasPendingMigrationBackup(dbPath2) {
 }
 function pendingMigrationBackupPath(dbPath2) {
   const pending = migrationBackups(dbPath2, migrationBackupDeps)[0];
-  return pending === undefined ? null : join7(dirname6(dbPath2), pending.name);
+  return pending === undefined ? null : join9(dirname8(dbPath2), pending.name);
 }
 function pendingMigrationBackupSizeBytes(dbPath2) {
   const pending = migrationBackups(dbPath2, migrationBackupDeps)[0];
@@ -28320,14 +28480,14 @@ function pendingMigrationBackupSizeBytes(dbPath2) {
 }
 function pruneMigrationBackupsAfterIntegrity(dbPath2, deps = migrationBackupDeps, verifiedBackupPath) {
   pruneMigrationBackups(dbPath2, 0, deps, undefined, true, undefined, verifiedBackupPath);
-  const dir = dirname6(dbPath2);
+  const dir = dirname8(dbPath2);
   const base = basename3(dbPath2);
   for (const name of deps.readdirSync(dir).filter((entry) => entry.endsWith(".cursor.json") && isGeneratedMigrationBackupName(base, entry.slice(0, -".cursor.json".length)))) {
     const backupName = name.slice(0, -".cursor.json".length);
     if (migrationBackups(dbPath2, deps).some((backup) => backup.name === backupName))
       continue;
     try {
-      deps.unlinkSync(join7(dir, name));
+      deps.unlinkSync(join9(dir, name));
     } catch {}
   }
 }
@@ -28405,9 +28565,9 @@ function openDbAccessorConnection(path, opts) {
   if (accessor) {
     throw new Error("DbAccessor already initialised");
   }
-  const dir = dirname6(path);
-  if (!existsSync7(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = dirname8(path);
+  if (!existsSync8(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
   dbPath = path;
   configureCustomSqlite(opts?.agentsDir);
@@ -28421,13 +28581,13 @@ function readCurrentSchemaVersion(writeConn) {
   return row && typeof row.version === "number" ? row.version : 0;
 }
 function backupBeforePendingMigrations(writeConn, path) {
-  if (existsSync7(path) && hasPendingMigrations(toMigrationDb(writeConn))) {
+  if (existsSync8(path) && hasPendingMigrations(toMigrationDb(writeConn))) {
     return backupBeforeMigration(writeConn, path, readCurrentSchemaVersion(writeConn));
   }
   return null;
 }
 async function backupBeforePendingMigrationsAsync(writeConn, path, deadlineAt) {
-  if (existsSync7(path) && hasPendingMigrations(toMigrationDb(writeConn))) {
+  if (existsSync8(path) && hasPendingMigrations(toMigrationDb(writeConn))) {
     return await backupBeforeMigrationAsync(writeConn, path, readCurrentSchemaVersion(writeConn), migrationBackupDeps, deadlineAt);
   }
   return null;
@@ -28509,13 +28669,13 @@ function initDbAccessorReadOnly(dbPathParam, vecExtensionPath, opts) {
 function ensureFtsTable(db, options = {}) {
   const sql = readMemoriesFtsSql(toFtsSchemaQueryDb(db));
   if (sql === null) {
-    console.log("[db-accessor] memories_fts missing — recreating FTS5 table");
+    console.error("[db-accessor] memories_fts missing — recreating FTS5 table");
     createMemoriesFts(db);
     if (options.deferBackfill !== true) {
       const backfilled = db.prepare("SELECT COUNT(*) as n FROM memories").get();
       if (backfilled.n > 0) {
         db.exec("INSERT INTO memories_fts(rowid, content) SELECT rowid, content FROM memories");
-        console.log(`[db-accessor] Backfilled ${backfilled.n} rows into memories_fts`);
+        console.error(`[db-accessor] Backfilled ${backfilled.n} rows into memories_fts`);
       }
     }
     if (options.deferBackfill !== true)
@@ -28528,7 +28688,7 @@ function ensureFtsTable(db, options = {}) {
       refreshMemoriesFtsState(db);
     return;
   }
-  console.log("[db-accessor] memories_fts tokenizer drift detected — recreating FTS5 table");
+  console.error("[db-accessor] memories_fts tokenizer drift detected — recreating FTS5 table");
   if (options.deferBackfill === true)
     recreateMemoriesFtsSchema(db);
   else
@@ -28631,7 +28791,7 @@ function missingVecEmbeddingsRows(db, expectedDimensions, lastId, limit) {
 			 ORDER BY e.id LIMIT ?`).all(expectedDimensions, lastId, limit);
 }
 function backfillVecEmbeddings(db, expectedDimensions, deadlineAt, options = {}) {
-  const log = options.log ?? console.log;
+  const log = options.log ?? console.error;
   const warn = options.warn ?? console.warn;
   ensureVecEmbeddingsQuarantineTable(db);
   const batchSize = Math.max(1, Math.min(options.batchSize ?? VEC_EMBEDDING_BACKFILL_BATCH_SIZE, VEC_EMBEDDING_BACKFILL_BATCH_SIZE));
@@ -28758,7 +28918,7 @@ function continuePendingVecBackfill(db, deadlineAt = Date.now() + VEC_EMBEDDING_
   backfillVecEmbeddings(db, dimensions, deadlineAt);
 }
 function yieldToEventLoop() {
-  return new Promise((resolve) => setTimeout(resolve, 0));
+  return new Promise((resolve4) => setTimeout(resolve4, 0));
 }
 function createAccessor(writeConn) {
   let closed = false;
@@ -28867,7 +29027,7 @@ function createAccessor(writeConn) {
       });
       return Promise.reject(new DbReadQueueFullError);
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve4, reject) => {
       let settled = false;
       const enqueuedAt = performance.now();
       const waiter = {};
@@ -28905,7 +29065,7 @@ function createAccessor(writeConn) {
         operation,
         timeoutMs,
         signal: options.signal,
-        resolve,
+        resolve: resolve4,
         reject,
         onAbort,
         timer
@@ -29018,7 +29178,7 @@ function createAccessor(writeConn) {
       });
       return Promise.reject(new DbWriteQueueFullError);
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve4, reject) => {
       const queuedAt = performance.now();
       const job = {};
       const onAbort = () => {
@@ -29054,7 +29214,7 @@ function createAccessor(writeConn) {
         onAbort,
         transactional,
         cancellation: "pending",
-        resolve: (value) => resolve(value),
+        resolve: (value) => resolve4(value),
         reject
       });
       writeQueue.push(job);
@@ -29483,12 +29643,12 @@ var init_db_accessor = __esm(() => {
   migrationBackupDeps = {
     copyFileSync,
     readdirSync: readdirSync5,
-    statSync: statSync4,
+    statSync: statSync6,
     lstatSync,
     statfsSync: statfsSync3,
     unlinkSync: unlinkSync3,
     now: Date.now,
-    log: console.log,
+    log: console.error,
     warn: console.warn
   };
 });
@@ -29933,7 +30093,7 @@ var require_init = __commonJS((exports) => {
 });
 
 // ../../platform/daemon/src/mcp-stdio-runtime.ts
-import { existsSync as existsSync17, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync18, statSync as statSync8 } from "node:fs";
 import { isAbsolute } from "node:path";
 
 // ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
@@ -52600,31 +52760,31 @@ init_dist();
 init_db_accessor();
 init_db_accessor_lifecycle();
 import { stat } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // ../../platform/daemon/src/db-owner-client.ts
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-import { appendFileSync as appendFileSync2, existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync5, unlinkSync as unlinkSync5 } from "node:fs";
-import { dirname as dirname9, join as join11 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync10, statSync as statSync7, unlinkSync as unlinkSync5 } from "node:fs";
+import { dirname as dirname10, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../platform/daemon/src/native-runtime-assets.ts
 import { createHash as createHash3 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync5,
   mkdtempSync,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync6,
-  renameSync as renameSync4,
-  rmSync,
+  renameSync as renameSync6,
+  rmSync as rmSync3,
   unlinkSync as unlinkSync4,
   writeFileSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname8, join as join9 } from "node:path";
+import { dirname as dirname9, join as join11 } from "node:path";
 function nativeRuntimeAssets() {
   return globalThis.__SIGNET_NATIVE_RUNTIME_ASSETS__ ?? {};
 }
@@ -52633,10 +52793,10 @@ function resolveEmbeddedWorkerPath(name) {
   if (!worker)
     return null;
   const hash2 = createHash3("sha256").update(worker.contentBase64).digest("hex").slice(0, 16);
-  const dir = join9(tmpdir(), "signet-native-workers");
-  const path = join9(dir, `${name.replace(/[^a-zA-Z0-9_.-]/g, "_")}-${hash2}.mjs`);
+  const dir = join11(tmpdir(), "signet-native-workers");
+  const path = join11(dir, `${name.replace(/[^a-zA-Z0-9_.-]/g, "_")}-${hash2}.mjs`);
   mkdirSync5(dir, { recursive: true });
-  if (!existsSync9(path)) {
+  if (!existsSync10(path)) {
     writeFileSync(path, Buffer.from(worker.contentBase64, "base64"));
   }
   return path;
@@ -52683,8 +52843,8 @@ class DbOwnerCancelledError extends DbOwnerError {
 }
 
 class DbOwnerDiedError extends DbOwnerError {
-  constructor(message = "DB owner process died; pending jobs failed closed") {
-    super("DB_OWNER_DIED", message);
+  constructor(message = "DB owner process died; pending jobs failed closed", code = "DB_OWNER_DIED", causeFamily, sqliteCode) {
+    super(code, message, causeFamily, sqliteCode);
     this.name = "DbOwnerDiedError";
   }
 }
@@ -52716,9 +52876,9 @@ function sweepStaleCancellationRegistries(directory) {
   for (const entry of entries) {
     if (!entry.startsWith(CANCEL_REGISTRY_PREFIX))
       continue;
-    const path = join11(directory, entry);
+    const path = join12(directory, entry);
     try {
-      if (statSync5(path).mtimeMs < cutoff)
+      if (statSync7(path).mtimeMs < cutoff)
         unlinkSync5(path);
     } catch {}
   }
@@ -52737,9 +52897,9 @@ function workerArguments(workerPath) {
   if (resolveEmbeddedWorkerPath("db-owner-worker") !== null) {
     return [];
   }
-  const directory = dirname9(fileURLToPath2(import.meta.url));
-  const bundled = join11(directory, "db-owner-worker.js");
-  return [existsSync10(bundled) ? bundled : join11(directory, "db-owner-worker.ts")];
+  const directory = dirname10(fileURLToPath2(import.meta.url));
+  const bundled = join12(directory, "db-owner-worker.js");
+  return [existsSync11(bundled) ? bundled : join12(directory, "db-owner-worker.ts")];
 }
 function ownerIsDead(owner) {
   if (owner.exitCode !== null || owner.signalCode !== null || owner.killed)
@@ -52747,7 +52907,7 @@ function ownerIsDead(owner) {
   if (process.platform !== "linux" || owner.pid === undefined)
     return false;
   try {
-    const status = readFileSync9(`/proc/${owner.pid}/status`, "utf8");
+    const status = readFileSync10(`/proc/${owner.pid}/status`, "utf8");
     return /^(?:State:\s+Z|CoreDumping:\s+1)/m.test(status);
   } catch {
     return false;
@@ -52765,6 +52925,8 @@ function oldestAge(first, second) {
 }
 function createSingleDbOwnerClient(options) {
   let child = null;
+  let activeChildClose = null;
+  let retiredChildClose = null;
   let startPromise = null;
   let startupResolve = null;
   let startupReject = null;
@@ -52779,8 +52941,8 @@ function createSingleDbOwnerClient(options) {
   let input = "";
   let stderr = "";
   let writeBlocked = false;
-  sweepStaleCancellationRegistries(dirname9(options.dbPath));
-  const cancellationRegistryPath = join11(dirname9(options.dbPath), `${CANCEL_REGISTRY_PREFIX}${process.pid}-${randomUUID()}`);
+  sweepStaleCancellationRegistries(dirname10(options.dbPath));
+  const cancellationRegistryPath = join12(dirname10(options.dbPath), `${CANCEL_REGISTRY_PREFIX}${process.pid}-${randomUUID()}`);
   const pending = new Map;
   const abandonedMetrics = new Map;
   function unlinkCancellationRegistry() {
@@ -52826,12 +52988,12 @@ function createSingleDbOwnerClient(options) {
     if (child !== owner || stdin === null || stdin === undefined || ownerIsDead(owner) || stdin.destroyed || stdin.writableEnded) {
       return Promise.reject(new DbOwnerDiedError);
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve4, reject) => {
       try {
         stdin.write(`${JSON.stringify(command)}
 `, (error51) => {
           if (error51 === undefined || error51 === null)
-            resolve();
+            resolve4();
           else
             reject(error51);
         });
@@ -52866,7 +53028,11 @@ function createSingleDbOwnerClient(options) {
     if (owner !== null && child !== owner)
       return;
     const retired = child;
+    const retiredClose = activeChildClose;
     child = null;
+    activeChildClose = null;
+    if (retiredClose !== null)
+      retiredChildClose = retiredClose;
     pid = null;
     activeJobId = null;
     input = "";
@@ -52913,13 +53079,8 @@ function createSingleDbOwnerClient(options) {
       return;
     }
     if (event.type === "fatal") {
-      lastError = event.error.message;
-      state = "failed";
-      if (initialization === "running")
-        initialization = "failed";
-      startupReject?.(messageFromError(event.error));
-      startupReject = null;
-      startupResolve = null;
+      const fatalError = messageFromError(event.error);
+      retireOwner(new DbOwnerDiedError(fatalError.message, fatalError.code, fatalError.causeFamily, fatalError.sqliteCode), owner, "failed", true);
       return;
     }
     const pendingJob = pending.get(event.jobId);
@@ -52960,8 +53121,9 @@ function createSingleDbOwnerClient(options) {
       try {
         handleEvent(owner, JSON.parse(line));
       } catch (error51) {
-        lastError = error51 instanceof Error ? error51.message : String(error51);
-        state = "failed";
+        const message = error51 instanceof Error ? error51.message : String(error51);
+        retireOwner(new DbOwnerDiedError(`DB owner emitted malformed protocol output: ${message}`), owner, "failed", true);
+        break;
       }
     }
   }
@@ -52999,20 +53161,27 @@ function createSingleDbOwnerClient(options) {
         retireOwner(new DbOwnerDiedError, owner, "dead", true);
         return await start();
       }
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await new Promise((resolve4) => setTimeout(resolve4, 0));
       if (child !== owner || state !== "ready")
         return await start();
       return;
     }
     if (startPromise !== null)
       return await startPromise;
+    const retiredClose = retiredChildClose;
+    if (retiredClose !== null) {
+      await retiredClose;
+      if (retiredChildClose === retiredClose)
+        retiredChildClose = null;
+      return await start();
+    }
     const timeoutMs = resolveStartupTimeoutMs(options);
     state = "starting";
     lastError = null;
     stderr = "";
     generation++;
-    startPromise = new Promise((resolve, reject) => {
-      startupResolve = resolve;
+    startPromise = new Promise((resolve4, reject) => {
+      startupResolve = resolve4;
       startupReject = reject;
       const workerEnv = {
         ...process.env,
@@ -53028,6 +53197,9 @@ function createSingleDbOwnerClient(options) {
         stdio: ["pipe", "pipe", "pipe"]
       });
       child = owner;
+      activeChildClose = new Promise((resolve6) => {
+        owner.once("close", () => resolve6());
+      });
       const appendStderr = (chunk) => {
         stderr = `${stderr}${chunk}`.slice(-8192);
       };
@@ -53040,10 +53212,8 @@ function createSingleDbOwnerClient(options) {
       owner.once("close", (code, signal) => handleExit(owner, code, signal, stderr.trim() || undefined));
       const timer = setTimeout(() => {
         if (state !== "ready") {
-          lastError = diagnostic(`DB owner did not become ready within ${timeoutMs}ms`);
-          state = "failed";
-          owner.kill("SIGKILL");
-          startupReject?.(new DbOwnerError("DB_OWNER_START_TIMEOUT", diagnostic(lastError)));
+          const error51 = new DbOwnerError("DB_OWNER_START_TIMEOUT", diagnostic(`DB owner did not become ready within ${timeoutMs}ms`));
+          retireOwner(error51, owner, "failed", true);
         }
       }, timeoutMs);
       const resolveStartup = startupResolve;
@@ -53145,10 +53315,10 @@ function createSingleDbOwnerClient(options) {
     };
     let pendingJob = null;
     let resolveMetrics = () => {};
-    const metrics = new Promise((resolve) => {
-      resolveMetrics = resolve;
+    const metrics = new Promise((resolve4) => {
+      resolveMetrics = resolve4;
     });
-    const result = new Promise((resolve, reject) => {
+    const result = new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         const entry = pending.get(job.id);
         if (entry === undefined || entry.settled)
@@ -53168,7 +53338,7 @@ function createSingleDbOwnerClient(options) {
           write(owner, { type: "cancel", jobId: job.id }).catch(() => {});
         }
       }, submitOptions.deadlineMs);
-      pendingJob = { job, resolve, reject, timer, resolveMetrics, settled: false, dispatched: false };
+      pendingJob = { job, resolve: resolve4, reject, timer, resolveMetrics, settled: false, dispatched: false };
       pending.set(job.id, pendingJob);
       if (request.kind === "initialize")
         initialization = "running";
@@ -53214,14 +53384,14 @@ function createSingleDbOwnerClient(options) {
   async function awaitResult(handle, timeoutMs) {
     if (timeoutMs === undefined)
       return await handle.result;
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         handle.cancel();
         reject(new DbOwnerDeadlineError(handle.job.id));
       }, timeoutMs);
       handle.result.then((value) => {
         clearTimeout(timer);
-        resolve(value);
+        resolve4(value);
       }, (error51) => {
         clearTimeout(timer);
         reject(error51);
@@ -53229,21 +53399,25 @@ function createSingleDbOwnerClient(options) {
     });
   }
   async function close() {
+    const owner = child;
+    const ownerClose = activeChildClose;
     closed = true;
-    if (child !== null) {
-      write(child, { type: "shutdown" }).catch(() => {});
-      await new Promise((resolve) => {
-        if (child === null) {
-          resolve();
-          return;
-        }
-        child.once("close", () => resolve());
-        setTimeout(() => {
-          child?.kill("SIGKILL");
-          resolve();
-        }, 250);
-      });
-    }
+    if (owner !== null) {
+      write(owner, { type: "shutdown" }).catch(() => {});
+      const forceKillTimer = setTimeout(() => {
+        try {
+          owner.kill("SIGKILL");
+        } catch {}
+      }, 250);
+      if (ownerClose !== null)
+        await ownerClose;
+      clearTimeout(forceKillTimer);
+    }
+    const retiredClose = retiredChildClose;
+    if (retiredClose !== null)
+      await retiredClose;
+    if (retiredChildClose === retiredClose)
+      retiredChildClose = null;
     state = "closed";
     rejectAll(new DbOwnerDiedError("DB owner client closed"));
     try {
@@ -53447,6 +53621,8 @@ async function executeInlineOwnerRequest(accessor2, request) {
     case "dreaming_hygiene_attention":
     case "dreaming_surprisal_attention":
     case "dreaming_episodic_backlog":
+    case "dreaming_episodic_backlog_probe":
+    case "dreaming_episodic_backlog_exists":
     case "dreaming_evidence_search":
     case "dreaming_evidence_source":
     case "dreaming_pass_finalize":
@@ -53518,6 +53694,7 @@ function inlineOwner(accessor2) {
   };
 }
 var clients = new Map;
+var retiredClientClosures = new Map;
 async function dbIdentity(dbPath2) {
   try {
     const metadata = await stat(dbPath2);
@@ -53526,17 +53703,27 @@ async function dbIdentity(dbPath2) {
     return dbPath2;
   }
 }
-async function startDbOwnerWithRole(dbPath2, workerRole) {
+async function startDbOwnerWithRole(dbPath2, workerRole, options = {}) {
   const identity = await dbIdentity(dbPath2);
   const key = `${workerRole}:${dbPath2}`;
+  const retiredClosure = retiredClientClosures.get(key);
+  if (retiredClosure !== undefined)
+    await retiredClosure;
   const current = clients.get(key);
   if (current !== undefined && (current.identity !== identity || current.owner.health().state === "closed" || current.owner.health().state === "dead" || current.owner.health().state === "failed")) {
     clients.delete(key);
-    await current.owner.close();
+    const closing = current.owner.close();
+    retiredClientClosures.set(key, closing);
+    try {
+      await closing;
+    } finally {
+      if (retiredClientClosures.get(key) === closing)
+        retiredClientClosures.delete(key);
+    }
   }
   let entry = clients.get(key);
   if (entry === undefined) {
-    entry = { owner: createDbOwnerClient({ dbPath: dbPath2, workerRole }), identity, startPromise: null };
+    entry = { owner: createDbOwnerClient({ dbPath: dbPath2, workerRole, ...options }), identity, startPromise: null };
     clients.set(key, entry);
   }
   if (entry.startPromise !== null)
@@ -53552,7 +53739,7 @@ async function startDbOwnerWithRole(dbPath2, workerRole) {
       currentEntry.startPromise = null;
   }
 }
-async function startDbOwner(dbPath2 = join12(resolveSqliteAgentsDir(), "memory", "memories.db")) {
+async function startDbOwner(dbPath2 = join13(resolveSqliteAgentsDir(), "memory", "memories.db")) {
   return await startDbOwnerWithRole(dbPath2, "generic");
 }
 async function getCurrentProcessOwner() {
@@ -53620,7 +53807,7 @@ async function submitWithAdmission(owner, request, options) {
       const remainingMs = deadlineAt - Date.now();
       if (remainingMs <= 0)
         throw error51;
-      await new Promise((resolve) => setTimeout(resolve, Math.min(25, remainingMs)));
+      await new Promise((resolve4) => setTimeout(resolve4, Math.min(25, remainingMs)));
     }
   }
 }
@@ -54197,7 +54384,7 @@ function findEpisodicSourceAgentIds(db, from) {
 }
 function searchEpisodicSources(db, params) {
   const query = params.query.trim();
-  const limit = params.limit === null ? null : Math.max(1, Math.min(Math.floor(params.limit ?? 20), 50));
+  const limit = params.limit === null ? null : Math.max(1, Math.min(Math.floor(params.limit ?? 20), 51));
   const like = `%${query}%`;
   const sinceArgs = params.since !== undefined ? [params.since, EPISODIC_CAPTURED_AT_FLOOR] : [];
   const beforeArgs = params.before !== undefined ? [params.before] : [];
@@ -54303,9 +54490,9 @@ init_db_accessor();
 init_db_accessor();
 
 // ../../platform/daemon/src/pipeline/dreaming-token-cache.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join13 } from "node:path";
-import { dirname as dirname10 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join14 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Worker } from "node:worker_threads";
 
@@ -54348,34 +54535,44 @@ function truncateToTokens(text, limit) {
 
 // ../../platform/daemon/src/pipeline/dreaming-token-cache.ts
 function resolveWorkerPath() {
-  const moduleDir = dirname10(fileURLToPath3(import.meta.url));
-  const bundled = join13(moduleDir, "dreaming-token-worker.js");
-  return existsSync11(bundled) ? bundled : resolveEmbeddedWorkerPath("dreaming-token-worker") ?? join13(moduleDir, "dreaming-token-worker.ts");
+  const moduleDir = dirname11(fileURLToPath3(import.meta.url));
+  const bundled = join14(moduleDir, "dreaming-token-worker.js");
+  return existsSync12(bundled) ? bundled : resolveEmbeddedWorkerPath("dreaming-token-worker") ?? join14(moduleDir, "dreaming-token-worker.ts");
+}
+function ensureTokenCount(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${label} must be a finite non-negative safe integer`);
+  }
+  return value;
+}
+function addTokenCounts(total, count) {
+  return ensureTokenCount(total + count, "Dreaming token count");
+}
+function requestKey(kind, agentId, entries, stopAt) {
+  return JSON.stringify([kind, agentId, entries.map((entry) => [entry.key, entry.revision]), stopAt]);
 }
 
 class DreamingBacklogTokenCache {
   values = new Map;
   entries = new Map;
-  entryValues = new Map;
-  inflight = new Map;
+  exactInflight = new Map;
+  batchInflight = new Map;
+  tails = new Map;
   workers = new Set;
-  async refresh(agentId, entries) {
-    const active = this.inflight.get(agentId);
-    if (active !== undefined)
-      return active;
-    const promise3 = this.refreshNow(agentId, entries);
-    this.inflight.set(agentId, promise3);
-    try {
-      return await promise3;
-    } finally {
-      this.inflight.delete(agentId);
-    }
+  async replaceExactSnapshot(agentId, entries) {
+    const key = requestKey("exact", agentId, entries);
+    return await this.enqueue(agentId, key, this.exactInflight, async () => await this.replaceExactSnapshotNow(agentId, entries));
+  }
+  async countEntries(agentId, entries, stopAtTokens) {
+    const stopAt = stopAtTokens === undefined ? undefined : ensureTokenCount(stopAtTokens, "Dreaming token stop limit");
+    const key = requestKey("batch", agentId, entries, stopAt);
+    return await this.enqueue(agentId, key, this.batchInflight, async () => await this.countEntriesNow(agentId, entries, stopAt));
   }
   get(agentId) {
     return this.values.get(agentId) ?? 0;
   }
-  record(agentId, count) {
-    this.values.set(agentId, count);
+  recordExactTotal(agentId, count) {
+    this.values.set(agentId, ensureTokenCount(count, "Dreaming exact token total"));
   }
   hasValue(agentId) {
     return this.values.has(agentId);
@@ -54384,61 +54581,118 @@ class DreamingBacklogTokenCache {
     for (const worker of this.workers)
       worker.terminate();
     this.workers.clear();
-    this.inflight.clear();
+    this.exactInflight.clear();
+    this.batchInflight.clear();
+    this.tails.clear();
   }
-  async refreshNow(agentId, entries) {
+  async replaceExactSnapshotNow(agentId, entries) {
+    const result = await this.countEntriesNow(agentId, entries);
     const nextKeys = new Set(entries.map((entry) => entry.key));
-    const agentEntries = this.entries.get(agentId) ?? new Map;
-    const agentValues = this.entryValues.get(agentId) ?? new Map;
-    this.entries.set(agentId, agentEntries);
-    this.entryValues.set(agentId, agentValues);
+    const agentEntries = this.entries.get(agentId);
+    if (agentEntries === undefined) {
+      throw new Error(`Missing Dreaming token cache state for ${agentId}`);
+    }
     for (const key of agentEntries.keys()) {
       if (!nextKeys.has(key))
         agentEntries.delete(key);
     }
-    const uncached = entries.filter((entry) => {
-      const cached2 = agentEntries.get(entry.key);
-      return cached2 === undefined || cached2.text !== entry.text;
-    });
-    if (uncached.length > 0) {
-      const counts = await this.count(uncached);
-      for (const entry of uncached) {
-        const result = counts.find((item) => item.key === entry.key);
-        if (result === undefined)
-          throw new Error(`Dreaming token worker omitted ${entry.key}`);
-        agentEntries.set(entry.key, entry);
-        agentValues.set(entry.key, result.count);
-      }
-    }
-    let total = 0;
-    for (const entry of entries) {
-      const count = agentValues.get(entry.key);
-      if (count === undefined)
-        throw new Error(`Missing cached Dreaming token count for ${entry.key}`);
-      total += count;
-    }
-    for (const key of agentValues.keys()) {
-      if (!nextKeys.has(key))
-        agentValues.delete(key);
-    }
-    this.values.set(agentId, total);
-    return total;
+    this.values.set(agentId, result.tokens);
+    return result.tokens;
   }
-  async count(entries) {
+  async countEntriesNow(agentId, entries, stopAtTokens) {
+    const agentEntries = this.entries.get(agentId) ?? new Map;
+    this.entries.set(agentId, agentEntries);
+    if (entries.length === 0 || stopAtTokens === 0)
+      return { tokens: 0, entriesCounted: 0 };
+    let tokens = 0;
+    let entriesCounted = 0;
+    let index = 0;
+    while (index < entries.length) {
+      const entry = entries[index];
+      if (entry === undefined)
+        break;
+      const cached2 = agentEntries.get(entry.key);
+      if (cached2 !== undefined && cached2.revision === entry.revision) {
+        tokens = addTokenCounts(tokens, ensureTokenCount(cached2.count, `Dreaming token count for ${entry.key}`));
+        entriesCounted += 1;
+        index += 1;
+        if (stopAtTokens !== undefined && tokens >= stopAtTokens)
+          return { tokens, entriesCounted };
+        continue;
+      }
+      let end = index;
+      while (end < entries.length) {
+        const candidate = entries[end];
+        if (candidate === undefined)
+          break;
+        const candidateCached = agentEntries.get(candidate.key);
+        if (candidateCached !== undefined && candidateCached.revision === candidate.revision)
+          break;
+        end += 1;
+      }
+      const segment = entries.slice(index, end);
+      const counts = await this.count(segment, stopAtTokens === undefined ? undefined : stopAtTokens - tokens);
+      if (counts.length === 0)
+        throw new Error(`Dreaming token worker omitted ${entry.key}`);
+      for (let resultIndex = 0;resultIndex < counts.length; resultIndex += 1) {
+        const candidate = segment[resultIndex];
+        const result = counts[resultIndex];
+        if (candidate === undefined || result === undefined || result.key !== candidate.key) {
+          throw new Error(`Dreaming token worker returned an unexpected entry near ${entry.key}`);
+        }
+        const count = ensureTokenCount(result.count, `Dreaming token count for ${candidate.key}`);
+        agentEntries.set(candidate.key, { revision: candidate.revision, count });
+        tokens = addTokenCounts(tokens, count);
+        entriesCounted += 1;
+      }
+      if (counts.length < segment.length)
+        return { tokens, entriesCounted };
+      index = end;
+    }
+    return { tokens, entriesCounted };
+  }
+  async count(entries, stopAtTokens) {
     const worker = new Worker(resolveWorkerPath(), { workerData: { tokenizerWasmPath } });
     this.workers.add(worker);
     try {
-      return await new Promise((resolve, reject) => {
-        worker.once("message", (message) => resolve(message.counts));
+      return await new Promise((resolve4, reject) => {
+        worker.once("message", (message) => resolve4(message.counts));
         worker.once("error", reject);
         worker.once("exit", (code) => reject(new Error(`Dreaming token worker exited with code ${code}`)));
-        worker.postMessage({ type: "count", requestId: 1, entries });
+        worker.postMessage({
+          type: "count",
+          requestId: 1,
+          entries,
+          ...stopAtTokens === undefined ? {} : { stopAt: stopAtTokens }
+        });
       });
     } finally {
       this.workers.delete(worker);
       worker.terminate().catch(() => {});
     }
   }
+  enqueue(agentId, key, inflight, operation) {
+    const active = inflight.get(key);
+    if (active !== undefined)
+      return active;
+    const prior = this.tails.get(agentId) ?? Promise.resolve();
+    const promise3 = prior.then(operation, operation);
+    inflight.set(key, promise3);
+    const tail = promise3.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    this.tails.set(agentId, tail);
+    const clear = () => {
+      if (inflight.get(key) === promise3)
+        inflight.delete(key);
+      if (this.tails.get(agentId) === tail)
+        this.tails.delete(agentId);
+    };
+    promise3.then(clear, clear);
+    return promise3;
+  }
 }
 var dreamingBacklogTokenCache = new DreamingBacklogTokenCache;
 
@@ -54957,7 +55211,7 @@ async function getStructuralDensity(_accessor, entityId, agentId) {
 init_dist();
 
 // ../../platform/daemon/src/ontology-evidence.ts
-function isRecord5(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString(record3, key) {
@@ -55007,7 +55261,7 @@ function readOntologyEvidenceRef(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? { sourceKind: null, sourceId: trimmed, sourcePath: null, memoryId: null, quote: null, reference: value } : null;
   }
-  if (!isRecord5(value))
+  if (!isRecord7(value))
     return null;
   const transcriptId = readString(value, "transcript_id");
   const sessionKey = readString(value, "session_key");
@@ -56182,12 +56436,12 @@ function now2() {
 function canonical(value) {
   return value.trim().toLowerCase().replace(/\s+/g, " ");
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseJsonRecord(value) {
   const parsed = JSON.parse(value);
-  return isRecord7(parsed) ? parsed : {};
+  return isRecord9(parsed) ? parsed : {};
 }
 function parseJsonArray3(value) {
   const parsed = JSON.parse(value);
@@ -56314,7 +56568,7 @@ function isDreamingAttentionEvidenceInTx(db, agentId, value) {
 function validateProposalEvidenceSourcesInTx(db, agentId, evidence) {
   for (const value of evidence) {
     const ref = readOntologyEvidenceRef(value);
-    if (ref === null || !isRecord7(ref.reference) || !("source_ref" in ref.reference))
+    if (ref === null || !isRecord9(ref.reference) || !("source_ref" in ref.reference))
       continue;
     if (isDreamingAttentionEvidenceInTx(db, agentId, ref.reference))
       continue;
@@ -57541,7 +57795,7 @@ function wasEntityMergeApplied(db, agentId, sourceId, targetId, sourceSelector)
       if (!Array.isArray(merged))
         continue;
       if (merged.some((item) => {
-        if (!isRecord7(item))
+        if (!isRecord9(item))
           return false;
         if (sourceId !== null)
           return readString2(item, "entityId") === sourceId;
@@ -58456,7 +58710,7 @@ async function awaitPressureClear(timeoutMs = 30000) {
     return true;
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await new Promise((resolve4) => setTimeout(resolve4, 500));
     tickPressureState();
     if (getSystemPressure() === "normal")
       return true;
@@ -58467,7 +58721,7 @@ async function awaitPressureClear(timeoutMs = 30000) {
 }
 
 // ../../platform/daemon/src/yielding-writes.ts
-var yieldToEventLoop2 = () => new Promise((resolve) => setTimeout(resolve, 0));
+var yieldToEventLoop2 = () => new Promise((resolve4) => setTimeout(resolve4, 0));
 async function writeBatch(accessor2, processBatch, label, estimatedWorkUnits) {
   if (accessor2.withWriteTxAsync) {
     return accessor2.withWriteTxAsync(processBatch, {
@@ -59449,11 +59703,11 @@ function collectReviewDueClaims(accessor2, now3, options = {}) {
 init_dist();
 init_db_accessor();
 import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
-import { mkdirSync as mkdirSync6, renameSync as renameSync6, writeFileSync as writeFileSync4, readFileSync as readFileSync10 } from "node:fs";
-import { dirname as dirname11, join as join14 } from "node:path";
+import { mkdirSync as mkdirSync7, renameSync as renameSync7, writeFileSync as writeFileSync4, readFileSync as readFileSync11 } from "node:fs";
+import { dirname as dirname12, join as join15 } from "node:path";
 var CURATED_MEMORY_HEAD_MAX_TOKENS = 1000;
 var hash2 = (text2) => createHash5("sha256").update(text2).digest("hex");
-var pathFor = (agentId) => agentId === "default" ? join14(resolveDefaultBasePath(), "MEMORY.md") : join14(resolveDefaultBasePath(), "agents", agentId, "MEMORY.md");
+var pathFor = (agentId) => agentId === "default" ? join15(resolveDefaultBasePath(), "MEMORY.md") : join15(resolveDefaultBasePath(), "agents", agentId, "MEMORY.md");
 var render = (entries) => entries.map((entry) => `- ${entry.text.trim()}`).join(`
 `);
 async function readCuratedMemoryHead(agentId) {
@@ -59470,17 +59724,17 @@ async function readCuratedMemoryHead(agentId) {
   const content = typeof head?.content === "string" ? head.content : "";
   if (content) {
     const target = pathFor(agentId);
-    mkdirSync6(dirname11(target), { recursive: true });
+    mkdirSync7(dirname12(target), { recursive: true });
     let existing = "";
     try {
-      existing = readFileSync10(target, "utf8");
+      existing = readFileSync11(target, "utf8");
     } catch {}
     if (existing !== `${content}
 `) {
       const temporary = `${target}.recovery-${String(head?.revision ?? 0)}.tmp`;
       writeFileSync4(temporary, `${content}
 `, "utf8");
-      renameSync6(temporary, target);
+      renameSync7(temporary, target);
     }
     if (snapshot.pending?.status === "pending") {
       await getDbAccessor().withWriteTxAsync((writeDb) => {
@@ -59581,12 +59835,12 @@ async function commitCuratedMemoryHead(input) {
   if (!committed.ok || committed.code !== "COMMITTED" || committed.revision === undefined)
     return committed;
   const target = pathFor(input.agentId);
-  mkdirSync6(dirname11(target), { recursive: true });
+  mkdirSync7(dirname12(target), { recursive: true });
   const temporary = `${target}.curated-${committed.revision}.tmp`;
   try {
     writeFileSync4(temporary, `${body}
 `, "utf8");
-    renameSync6(temporary, target);
+    renameSync7(temporary, target);
   } catch (error51) {
     return {
       ...committed,
@@ -59614,8 +59868,8 @@ async function commitCuratedMemoryHead(input) {
 init_dist();
 init_db_accessor();
 import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname12, join as join15 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync12, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname13, join as join16 } from "node:path";
 init_memory_config();
 var MEMORY_HEAD_MAX_TOKENS = 1000;
 function getAgentsDir2() {
@@ -59637,8 +59891,8 @@ function projectMemoryMd(content) {
 }
 function resolveMemoryHeadPath(agentsDir, agentId) {
   if (agentId === "default")
-    return join15(agentsDir, "MEMORY.md");
-  return join15(agentsDir, "agents", agentId, "MEMORY.md");
+    return join16(agentsDir, "MEMORY.md");
+  return join16(agentsDir, "agents", agentId, "MEMORY.md");
 }
 function acquireHeadLease(agentId, owner, ttlMs) {
   try {
@@ -59685,13 +59939,13 @@ function acquireHeadLease(agentId, owner, ttlMs) {
 function writeProjection(file2, agentId) {
   const agentsDir = getAgentsDir2();
   const path = resolveMemoryHeadPath(agentsDir, agentId);
-  const dir = dirname12(path);
-  mkdirSync7(dir, { recursive: true });
-  if (existsSync12(path)) {
+  const dir = dirname13(path);
+  mkdirSync8(dir, { recursive: true });
+  if (existsSync13(path)) {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    const backup = join15(dir, "memory", `MEMORY.backup-${stamp}.md`);
-    mkdirSync7(dirname12(backup), { recursive: true });
-    writeFileSync6(backup, readFileSync11(path, "utf-8"));
+    const backup = join16(dir, "memory", `MEMORY.backup-${stamp}.md`);
+    mkdirSync8(dirname13(backup), { recursive: true });
+    writeFileSync6(backup, readFileSync12(path, "utf-8"));
   }
   writeFileSync6(path, file2);
 }
@@ -59716,7 +59970,7 @@ async function curateMemoryHead(input) {
   const hash3 = hashContent(projected.body);
   const next = lease.row.hash === hash3 ? lease.row.revision : lease.row.revision + 1;
   const path = resolveMemoryHeadPath(getAgentsDir2(), input.agentId);
-  const previous = existsSync12(path) ? readFileSync11(path, "utf-8") : undefined;
+  const previous = existsSync13(path) ? readFileSync12(path, "utf-8") : undefined;
   try {
     await getDbAccessor().withWriteTxAsync((db) => {
       db.prepare(`UPDATE memory_md_heads SET content = ?, content_hash = ?, revision = ?, updated_at = ?, lease_token = NULL, lease_owner = NULL, lease_expires_at = NULL WHERE agent_id = ? AND lease_token = ?`).run(projected.body, hash3, next, new Date().toISOString(), input.agentId, lease.row.token);
@@ -59733,8 +59987,8 @@ async function curateMemoryHead(input) {
   } catch (error51) {
     try {
       if (previous === undefined) {
-        if (existsSync12(path))
-          rmSync3(path);
+        if (existsSync13(path))
+          rmSync5(path);
       } else
         writeFileSync6(path, previous);
     } catch {}
@@ -60348,9 +60602,9 @@ init_dist();
 // ../../platform/daemon/src/graphiq.ts
 init_dist();
 import { spawn as spawn2 } from "node:child_process";
-import { constants, accessSync, existsSync as existsSync13 } from "node:fs";
+import { constants, accessSync, existsSync as existsSync14 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { delimiter, join as join16 } from "node:path";
+import { delimiter, join as join17 } from "node:path";
 function getAgentsDir3() {
   return resolveDefaultBasePath();
 }
@@ -60365,8 +60619,8 @@ function getActiveGraphiqDbPath() {
 }
 function resolveGraphiqBinary() {
   const path = process.env.PATH ?? "";
-  const candidates = path.split(delimiter).filter((entry) => entry.length > 0).map((entry) => join16(entry, "graphiq"));
-  candidates.push(join16(homedir9(), ".local", "bin", "graphiq"));
+  const candidates = path.split(delimiter).filter((entry) => entry.length > 0).map((entry) => join17(entry, "graphiq"));
+  candidates.push(join17(homedir9(), ".local", "bin", "graphiq"));
   for (const candidate of candidates) {
     try {
       accessSync(candidate, constants.X_OK);
@@ -60380,7 +60634,7 @@ async function runGraphiqCli(args, timeoutMs = 15000) {
   if (!active) {
     throw new Error("GraphIQ has no active indexed project. Run `signet index <path>` first.");
   }
-  if (!existsSync13(active.dbPath)) {
+  if (!existsSync14(active.dbPath)) {
     throw new Error(`GraphIQ database not found for active project: ${active.dbPath}`);
   }
   const binary = resolveGraphiqBinary();
@@ -60451,7 +60705,7 @@ function runCommand(command, args, timeoutMs, extraEnv) {
 
 // ../../platform/daemon/src/plugins/index.ts
 init_dist();
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
 
 // ../../platform/daemon/src/secrets.ts
 init_logger();
@@ -60460,17 +60714,20 @@ init_dist();
 // ../../platform/daemon/src/plugins/audit.ts
 init_dist();
 init_logger();
-import { appendFileSync as appendFileSync3, existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname13, join as join17 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync13 } from "node:fs";
+import { dirname as dirname14, join as join18 } from "node:path";
 var SENSITIVE_KEY_RE = /(^|[_-])(api-key|apikey|auth-token|authorization|bearer|client-secret|credential|credentials|password|private-key|refresh-token|secret|secret-value|token|value)([_-]|$)/i;
 var SENSITIVE_ASSIGNMENT_RE = /\b((?:access[_-]?token|api[_-]?key|auth(?:orization)?|bearer|client[_-]?secret|credential|password|refresh[_-]?token|secret|token)\s*[:=]\s*)(["']?)([^"'\s,;&]+)/gi;
 var KNOWN_SECRET_VALUE_RE = /\b(AKIA[0-9A-Z]{16}|github_pat_[A-Za-z0-9_]{20,}|gh[pousr]_[A-Za-z0-9_]{20,}|sk-[A-Za-z0-9_-]{12,}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g;
 function getDefaultPluginAuditPath() {
-  return join17(resolveDefaultBasePath(), ".daemon", "plugins", "audit-v1.ndjson");
+  return join18(resolveDefaultBasePath(), ".daemon", "plugins", "audit-v1.ndjson");
 }
 function recordPluginAuditEvent(input, auditPath) {
   if (auditPath === null)
     return;
+  const workspace = preflightWorkspace();
+  if (workspace.status === "missing" || workspace.status === "incomplete")
+    return;
   const path = auditPath ?? getDefaultPluginAuditPath();
   const event = {
     id: makeAuditId(),
@@ -60483,7 +60740,7 @@ function recordPluginAuditEvent(input, auditPath) {
     data: sanitizeAuditData(input.data ?? {})
   };
   try {
-    mkdirSync8(dirname13(path), { recursive: true });
+    mkdirSync9(dirname14(path), { recursive: true });
     appendFileSync3(path, `${JSON.stringify(event)}
 `, { mode: 384 });
   } catch (err) {
@@ -60516,7 +60773,7 @@ function sanitizeAuditValue(value) {
     return sanitizeAuditString(value);
   if (Array.isArray(value))
     return value.map((entry) => sanitizeAuditValue(entry));
-  if (isRecord9(value))
+  if (isRecord10(value))
     return sanitizeAuditData(value);
   return String(value);
 }
@@ -60526,7 +60783,7 @@ function sanitizeAuditString(value) {
 function makeAuditId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -61058,8 +61315,8 @@ var signetGraphiqManifest = {
 // ../../platform/daemon/src/plugins/host.ts
 init_dist();
 init_logger();
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname14, join as join18 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname15, join as join19 } from "node:path";
 
 // ../../platform/daemon/src/plugins/manifest.ts
 var PLUGIN_ID_RE = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/;
@@ -61407,11 +61664,11 @@ class PluginHostV1 {
     };
   }
   loadStore() {
-    if (!this.storagePath || !existsSync15(this.storagePath)) {
+    if (!this.storagePath || !existsSync16(this.storagePath)) {
       return { version: 1, plugins: {} };
     }
     try {
-      const parsed = JSON.parse(readFileSync13(this.storagePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync14(this.storagePath, "utf-8"));
       return parseStore(parsed);
     } catch (err) {
       this.storeWritable = false;
@@ -61435,13 +61692,16 @@ class PluginHostV1 {
       });
       return;
     }
-    mkdirSync9(dirname14(this.storagePath), { recursive: true });
+    const workspace = preflightWorkspace();
+    if (workspace.status === "missing" || workspace.status === "incomplete")
+      return;
+    mkdirSync10(dirname15(this.storagePath), { recursive: true });
     writeFileSync7(this.storagePath, `${JSON.stringify(this.store, null, 2)}
 `, { mode: 384 });
   }
 }
 function getDefaultPluginRegistryPath() {
-  return join18(resolveDefaultBasePath(), SIGNET_PLUGIN_REGISTRY_DIR, SIGNET_PLUGIN_REGISTRY_FILE);
+  return join19(resolveDefaultBasePath(), SIGNET_PLUGIN_REGISTRY_DIR, SIGNET_PLUGIN_REGISTRY_FILE);
 }
 function resolveState(manifest, enabled, health, validationErrors) {
   if (validationErrors.length > 0) {
@@ -61478,12 +61738,12 @@ function filterSurfacesByCapabilities(surfaces3, grantedCapabilities) {
   };
 }
 function parseStore(value) {
-  if (!isRecord10(value) || value.version !== 1 || !isRecord10(value.plugins)) {
+  if (!isRecord11(value) || value.version !== 1 || !isRecord11(value.plugins)) {
     throw new Error("expected plugin registry version 1 with a plugins object");
   }
   const plugins = {};
   for (const [id, raw] of Object.entries(value.plugins)) {
-    if (!isRecord10(raw)) {
+    if (!isRecord11(raw)) {
       throw new Error(`expected plugin registry entry ${id} to be an object`);
     }
     plugins[id] = {
@@ -61501,7 +61761,7 @@ function parseStringArray(value) {
     return;
   return value.every((entry) => typeof entry === "string") ? value : undefined;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function clipPromptContribution(contribution) {
@@ -61564,9 +61824,9 @@ function auditResultForRecord(record3) {
 // ../../platform/daemon/src/plugins/index.ts
 function resolveGraphiqEnabled() {
   const statePath = getGraphiqStatePath(getAgentsDir3());
-  if (existsSync16(statePath)) {
+  if (existsSync17(statePath)) {
     try {
-      const parsed = JSON.parse(readFileSync14(statePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync15(statePath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && typeof parsed.enabled === "boolean") {
         return parsed.enabled;
       }
@@ -63659,7 +63919,7 @@ function isLocalDaemonUrl(url2) {
 }
 function isValidAgentsDir(dir) {
   try {
-    return isAbsolute(dir) && existsSync17(dir) && statSync6(dir).isDirectory();
+    return isAbsolute(dir) && existsSync18(dir) && statSync8(dir).isDirectory();
   } catch {
     return false;
   }