@goondocks/myco 0.21.0 → 0.21.2

package/dist/{main-5PRQNEEE.js → main-4HKTZFIM.js}

@@ -18,7 +18,7 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-75Z7UKDY.js";
+} from "./chunk-4D22KTXY.js";
 import {
   deleteSecrets,
   getTeamPackageVersion,
@@ -27,7 +27,7 @@ import {
   readSecrets,
   resolveVaultConfigPath,
   writeSecret
-} from "./chunk-R2JIJBCL.js";
+} from "./chunk-TMAXWERS.js";
 import {
   DEFAULT_OPENAI_URL,
   DEFAULT_OPENROUTER_URL,
@@ -63,6 +63,7 @@ import {
   getSkillRecordByName,
   getSkillSurveyEligibility,
   hasConfiguredProvider,
+  hasSemanticSearchFilters,
   incrementActivityCount,
   incrementSkillUsageCount,
   inferLocalOpenAIBackendKind,
@@ -82,6 +83,7 @@ import {
   listWriteIntents,
   markAllRead,
   markRunningRunsInterrupted,
+  matchesSemanticSearchFilters,
   notify,
   populateBatchResponses,
   register,
@@ -90,28 +92,31 @@ import {
   tryParseJson,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-NGH7U6A3.js";
+} from "./chunk-HCT7RMM2.js";
 import {
-  errorMessage,
   parseCheckpointState,
   runDurationMs
-} from "./chunk-6LB7XELY.js";
+} from "./chunk-QATYARI5.js";
 import {
   fullTextSearch,
-  hydrateSearchResults
-} from "./chunk-LVIY7P35.js";
+  hydrateSearchResults,
+  sanitizeFtsQuery
+} from "./chunk-QLLBJEM7.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-ILJPRYES.js";
+} from "./chunk-USVFEWYL.js";
 import {
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-JZS6GZ6T.js";
+} from "./chunk-AUIXX33A.js";
+import {
+  errorMessage
+} from "./chunk-LQIPXVDH.js";
 import {
   listTurnsByRun
 } from "./chunk-FCJ5JV54.js";
@@ -135,11 +140,11 @@ import {
   cleanStaleBuffers,
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
-import "./chunk-JR54LTPP.js";
+import "./chunk-W5L5IHP5.js";
 import "./chunk-SAKJMNSR.js";
 import {
   SymbiontInstaller
-} from "./chunk-VHNRMM4O.js";
+} from "./chunk-OTQH5KZW.js";
 import {
   checkLocalProvider
 } from "./chunk-TKAJ3JVF.js";
@@ -150,7 +155,7 @@ import {
 import {
   composeSessionStartContext,
   shouldInjectSessionStartDigest
-} from "./chunk-DJ3IHNYO.js";
+} from "./chunk-TFRUDNLI.js";
 import {
   buildCortexInstructionsInput,
   countSpores,
@@ -170,7 +175,7 @@ import {
   shouldInjectCortex,
   updateSporeStatus,
   upsertPlan
-} from "./chunk-F3OEQYLS.js";
+} from "./chunk-DBBO6FHE.js";
 import {
   backfillUnsynced,
   closeSession,
@@ -199,10 +204,10 @@ import {
 import {
   evaluateSessionCaptureRules,
   readTranscriptMeta
-} from "./chunk-XL75KZGI.js";
+} from "./chunk-EKZG2MCD.js";
 import {
   PLAN_STATUSES
-} from "./chunk-CESKJD44.js";
+} from "./chunk-DMPCC7V6.js";
 import {
   EMBEDDING_DIMENSIONS,
   REST_SETTABLE_STATUSES,
@@ -215,7 +220,7 @@ import {
   createSchema,
   humanizePlanToken,
   normalizePlanSourcePath
-} from "./chunk-RL5R4CQU.js";
+} from "./chunk-DTWUHHFI.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
@@ -244,14 +249,14 @@ import {
 } from "./chunk-ZXZPJJN3.js";
 import {
   resolveCliEntryPath
-} from "./chunk-P66DLD6G.js";
+} from "./chunk-6FBLL7MD.js";
 import {
   getPluginVersion
-} from "./chunk-BUTL6IFS.js";
+} from "./chunk-Z55WGA2J.js";
 import {
   loadManifests,
   resolvePackageRoot
-} from "./chunk-NGROSFOH.js";
+} from "./chunk-Z66IT5KL.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -2712,6 +2717,13 @@ var TeamSyncClient = class _TeamSyncClient {
       const params = new URLSearchParams({ q: query });
       if (options.limit) params.set("limit", String(options.limit));
       if (options.tables) params.set("tables", options.tables.join(","));
+      if (options.status) params.set("status", options.status);
+      if (options.observation_type) params.set("observation_type", options.observation_type);
+      if (options.since !== void 0) params.set("since", String(options.since));
+      if (options.until !== void 0) params.set("until", String(options.until));
+      if (options.session_id) params.set("session_id", options.session_id);
+      if (options.source_path) params.set("source_path", options.source_path);
+      if (options.name) params.set("name", options.name);
       const res = await this.fetchFn(`${this.workerUrl}/search?${params}`, {
         method: "GET",
         headers: this.headers(),
@@ -2896,16 +2908,33 @@ function createTeamHandlers(deps) {
     try {
       pendingCount = countPending();
       deadLetterCount = countDeadLettered();
-    } catch {
+    } catch (err) {
+      const detail = errorMessage(err);
+      logger.warn("team-sync.outbox.count-failed", "team-outbox counts unavailable", { error: detail });
     }
     let collectiveStatus = null;
+    let teamConfig = null;
     if (client && config.team.enabled) {
       try {
         collectiveStatus = await client.getCollectiveStatus();
-      } catch {
+      } catch (err) {
+        const detail = errorMessage(err);
+        logger.warn("team-sync.collective.status-failed", "Collective status unavailable", { error: detail });
         collectiveStatus = null;
       }
+      try {
+        teamConfig = await client.getConfig();
+      } catch (err) {
+        const detail = errorMessage(err);
+        logger.warn("team-sync.config.status-failed", "Team config unavailable", { error: detail });
+        teamConfig = null;
+      }
     }
+    const remoteConfig = teamConfig?.config ?? {};
+    const vectorReindexLastRun = typeof remoteConfig.vector_reindex_last_run_at === "string" ? Number(remoteConfig.vector_reindex_last_run_at) : null;
+    const vectorReindexLastProcessed = typeof remoteConfig.vector_reindex_last_processed === "string" ? Number(remoteConfig.vector_reindex_last_processed) : null;
+    const vectorReindexLastReindexed = typeof remoteConfig.vector_reindex_last_reindexed === "string" ? Number(remoteConfig.vector_reindex_last_reindexed) : null;
+    const vectorReindexLastDeleted = typeof remoteConfig.vector_reindex_last_deleted === "string" ? Number(remoteConfig.vector_reindex_last_deleted) : null;
     return {
       body: {
         enabled: config.team.enabled,
@@ -2929,6 +2958,13 @@ function createTeamHandlers(deps) {
         collective_last_heartbeat: collectiveStatus?.last_heartbeat ?? null,
         collective_capabilities: collectiveStatus?.capabilities ?? [],
         collective_settings: collectiveStatus?.settings ?? {},
+        vector_reindex_status: typeof remoteConfig.vector_reindex_status === "string" ? remoteConfig.vector_reindex_status : null,
+        vector_reindex_last_table: typeof remoteConfig.vector_reindex_last_table === "string" ? remoteConfig.vector_reindex_last_table : null,
+        vector_reindex_last_error: typeof remoteConfig.vector_reindex_last_error === "string" && remoteConfig.vector_reindex_last_error.length > 0 ? remoteConfig.vector_reindex_last_error : null,
+        vector_reindex_last_run_at: Number.isFinite(vectorReindexLastRun) ? vectorReindexLastRun : null,
+        vector_reindex_last_processed: Number.isFinite(vectorReindexLastProcessed) ? vectorReindexLastProcessed : null,
+        vector_reindex_last_reindexed: Number.isFinite(vectorReindexLastReindexed) ? vectorReindexLastReindexed : null,
+        vector_reindex_last_deleted: Number.isFinite(vectorReindexLastDeleted) ? vectorReindexLastDeleted : null,
         schema_version: SCHEMA_VERSION,
         sync_protocol_version: SYNC_PROTOCOL_VERSION,
         mcp_token: client?.getMcpToken() ?? null,
@@ -2945,7 +2981,7 @@ function createTeamHandlers(deps) {
     return { body: { retried: count } };
   }
   async function handleUpgradeWorker(_req) {
-    const { upgradeWorker } = await import("./team-JTI5CDUO.js");
+    const { upgradeWorker } = await import("./team-VJ3M263F.js");
     logger.info("team-sync.upgrade.start", "Starting worker upgrade");
     const result = upgradeWorker(vaultDir);
     if (!result.success) {
@@ -2983,7 +3019,7 @@ function createTeamHandlers(deps) {
       logger.info("team-sync.mcp-token.rotated", "MCP access token rotated");
       return { body: { token } };
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+      const message = errorMessage(err);
       logger.error("team-sync.mcp-token.rotate-failed", "MCP token rotation failed", { error: message });
       return {
         status: 500,
@@ -3024,7 +3060,19 @@ function createCollectiveHandlers(deps) {
       const project = req.query.project;
       const limit = req.query.limit ? Number(req.query.limit) : void 0;
       return {
-        body: await client.collectiveQuery("collective_search", { query, project, limit })
+        body: await client.collectiveQuery("collective_search", {
+          query,
+          project,
+          limit,
+          types: req.query.types ? req.query.types.split(",").map((value) => value.trim()).filter(Boolean) : void 0,
+          status: req.query.status || void 0,
+          observation_type: req.query.observation_type || void 0,
+          since: req.query.since ? Number(req.query.since) : void 0,
+          until: req.query.until ? Number(req.query.until) : void 0,
+          session_id: req.query.session_id || void 0,
+          source_path: req.query.source_path || void 0,
+          name: req.query.name || void 0
+        })
       };
     } catch (error) {
       return {
@@ -3337,7 +3385,7 @@ function createSkillRecordDeleteHandler(deps) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill directory", { name: record.name, error: String(err) });
         }
         try {
-          const { syncSkillSymlinks } = await import("./installer-UMH7OJ5A.js");
+          const { syncSkillSymlinks } = await import("./installer-N4UTEACX.js");
           syncSkillSymlinks(projectRoot, record.name, { remove: true });
         } catch (err) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill symlinks", { name: record.name, error: String(err) });
@@ -3618,7 +3666,7 @@ async function fetchRemoteProviderModels(provider, _baseUrl, timeoutMs = REMOTE_
   const modelIds = (data.data ?? []).map((entry) => entry.id).filter((id) => typeof id === "string" && id.length > 0);
   return filterLlmModels(modelIds);
 }
-async function handleGetModels(req) {
+async function handleGetModels(req, logger) {
   const provider = req.query.provider;
   const type = req.query.type;
   const localBackend = req.query.local_backend;
@@ -3626,6 +3674,7 @@ async function handleGetModels(req) {
     return { status: 400, body: { error: "provider query parameter required" } };
   }
   let models = [];
+  let fetchError;
   try {
     const localBackendKind = inferLocalOpenAIBackendKind({
       type: provider === "lm-studio" ? "lmstudio" : provider,
@@ -3640,14 +3689,22 @@ async function handleGetModels(req) {
     } else if (provider === "openai" || provider === "openrouter") {
       models = await fetchRemoteProviderModels(provider, void 0, MODEL_LIST_TIMEOUT_MS);
     }
-  } catch {
+  } catch (err) {
+    fetchError = errorMessage(err);
+    logger?.warn(`models.${provider}.list-unavailable`, `${provider} model list unavailable`, { error: fetchError });
   }
   if (type === "embedding") {
     models = filterEmbeddingModels(models);
   } else if (type === "llm") {
     models = filterLlmModels(models);
   }
-  return { body: { provider, models } };
+  return {
+    body: {
+      provider,
+      models,
+      ...fetchError ? { error: fetchError } : {}
+    }
+  };
 }
 
 // src/daemon/api/stats.ts
@@ -3900,11 +3957,12 @@ async function triggerTitleSummary(sessionId, deps) {
   if (config.agent.summary_batch_interval <= 0) return;
   if (config.agent.event_tasks_enabled === false) return;
   try {
-    const { runAgent: runAgent2 } = await import("./executor-F2YU7HXJ.js");
+    const { runAgent: runAgent2 } = await import("./executor-FJCMNSXM.js");
     runAgent2(vaultDir, {
       task: "title-summary",
       instruction: `Process session ${sessionId} only`,
-      embeddingManager
+      embeddingManager,
+      logger
     }).catch((err) => {
       logger.warn(LOG_KINDS.AGENT_ERROR, "Title-summary task failed", {
         session_id: sessionId,
@@ -4441,15 +4499,48 @@ function createSearchHandler(deps) {
     const type = req.query.type;
     const limit = Number(req.query.limit) || SEARCH_RESULTS_DEFAULT_LIMIT;
     const namespace = req.query.namespace;
+    const metadataFilters = {
+      ...req.query.status ? { status: req.query.status } : {},
+      ...req.query.session_id ? { session_id: req.query.session_id } : {},
+      ...req.query.observation_type ? { observation_type: req.query.observation_type } : {},
+      ...req.query.since ? { created_at_gte: Number(req.query.since) } : {},
+      ...req.query.until ? { created_at_lte: Number(req.query.until) } : {}
+    };
+    const vectorFilters = hasSemanticSearchFilters(metadataFilters) ? metadataFilters : void 0;
+    const sanitized = sanitizeFtsQuery(query);
     if (mode === "fts") {
-      const results = fullTextSearch(query, { type, limit });
-      return { body: { mode: "fts", results } };
+      try {
+        const results = fullTextSearch(sanitized, { type, limit });
+        return { body: { mode: "fts", results } };
+      } catch (err) {
+        return {
+          status: 500,
+          body: {
+            error: "fts_query_failed",
+            message: errorMessage(err),
+            query,
+            sanitized_query: sanitized !== query ? sanitized : void 0
+          }
+        };
+      }
     }
     const queryVector = await deps.embeddingManager.embedQuery(query);
     if (queryVector === null) {
       if (mode === "auto") {
-        const results = fullTextSearch(query, { type, limit });
-        return { body: { mode: "fts", results, fallback: true } };
+        try {
+          const results = fullTextSearch(sanitized, { type, limit });
+          return { body: { mode: "fts", results, fallback: true } };
+        } catch (err) {
+          return {
+            status: 500,
+            body: {
+              error: "fts_fallback_failed",
+              message: errorMessage(err),
+              query,
+              sanitized_query: sanitized !== query ? sanitized : void 0
+            }
+          };
+        }
       }
       return { body: { mode: "semantic", results: [], provider_unavailable: true } };
     }
@@ -4457,9 +4548,11 @@ function createSearchHandler(deps) {
     const vectorResults = deps.embeddingManager.searchVectors(queryVector, {
       namespace: searchNamespace,
       limit,
-      threshold: SEARCH_SIMILARITY_THRESHOLD
+      threshold: SEARCH_SIMILARITY_THRESHOLD,
+      filters: vectorFilters
     });
-    const localResults = hydrateSearchResults(vectorResults).map((r) => ({
+    const filteredVectorResults = vectorFilters ? vectorResults.filter((result) => matchesSemanticSearchFilters(result.metadata, metadataFilters)) : vectorResults;
+    const localResults = hydrateSearchResults(filteredVectorResults).map((r) => ({
       ...r,
       source: "local"
     }));
@@ -4467,7 +4560,15 @@ function createSearchHandler(deps) {
     let teamResults = [];
     if (teamClient) {
       try {
-        const teamResponse = await teamClient.search(query, { limit });
+        const teamResponse = await teamClient.search(query, {
+          limit,
+          tables: searchNamespace ? [searchNamespace] : void 0,
+          status: req.query.status || void 0,
+          observation_type: req.query.observation_type || void 0,
+          since: req.query.since ? Number(req.query.since) : void 0,
+          until: req.query.until ? Number(req.query.until) : void 0,
+          session_id: req.query.session_id || void 0
+        });
         teamResults = teamResponse.results.map((r) => ({
           ...r,
           source: `${TEAM_SOURCE_PREFIX}${r.machine_id}`
@@ -4476,7 +4577,11 @@ function createSearchHandler(deps) {
       }
     }
     const dedupedTeam = deps.machineId ? teamResults.filter((r) => r.machine_id !== deps.machineId) : teamResults;
-    const merged = [...localResults, ...dedupedTeam].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, limit);
+    const filteredTeam = vectorFilters ? dedupedTeam.filter((r) => matchesSemanticSearchFilters(
+      r.metadata,
+      metadataFilters
+    )) : dedupedTeam;
+    const merged = [...localResults, ...filteredTeam].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, limit);
     return { body: { mode: "semantic", results: merged } };
   };
 }
@@ -4604,7 +4709,8 @@ ${goal.trim()}`,
     task: CORTEX_PROMPT_BUILDER_TASK,
     agentId: DEFAULT_AGENT_ID,
     instruction: builderInstruction,
-    embeddingManager: deps.embeddingManager
+    embeddingManager: deps.embeddingManager,
+    logger: deps.logger
   });
   const runId = getLatestRunId(DEFAULT_AGENT_ID, CORTEX_PROMPT_BUILDER_TASK);
   const tracked = resultPromise.catch((err) => {
@@ -4642,7 +4748,7 @@ function getCortexPromptResult(runId) {
 }
 async function triggerCortexInstructions(deps) {
   const { vaultDir, embeddingManager, liveConfig, logger, getTeamClient } = deps;
-  const loadExecutor = deps.loadExecutor ?? (() => import("./executor-F2YU7HXJ.js"));
+  const loadExecutor = deps.loadExecutor ?? (() => import("./executor-FJCMNSXM.js"));
   const config = liveConfig.current;
   if (config.agent.event_tasks_enabled === false) {
     return { started: false, reason: "event-tasks-disabled" };
@@ -4868,7 +4974,10 @@ function createPromptContextHandler(deps) {
     const vectorResults = embeddingManager.searchVectors(queryVector, {
       namespace: "spores",
       limit: maxSpores * PROMPT_VECTOR_OVER_FETCH,
-      threshold: PROMPT_CONTEXT_MIN_SIMILARITY
+      threshold: PROMPT_CONTEXT_MIN_SIMILARITY,
+      filters: {
+        status: "active"
+      }
     });
     logger.debug(LOG_KINDS.CONTEXT_SEARCH, "Prompt vector search completed", {
       session_id,
@@ -5030,6 +5139,68 @@ async function handleGetFeed(req) {
 // src/daemon/api/embedding.ts
 var EMBEDDING_STATUS_IDLE = "idle";
 var EMBEDDING_STATUS_PENDING = "pending";
+var FOREGROUND_EMBEDDING_BATCH_SIZE = 50;
+var FOREGROUND_RECONCILE_MAX_PASSES = 25;
+var FOREGROUND_REEMBED_MAX_PASSES = 25;
+function readQueueDepthSafely() {
+  try {
+    return getEmbeddingQueueDepth().queue_depth;
+  } catch {
+    return 0;
+  }
+}
+async function drainForegroundReconcile(manager) {
+  const startedAt = Date.now();
+  let embedded = 0;
+  let stale_reembedded = 0;
+  let orphans_cleaned = 0;
+  let passes = 0;
+  for (; passes < FOREGROUND_RECONCILE_MAX_PASSES; passes++) {
+    const result = await manager.reconcile(FOREGROUND_EMBEDDING_BATCH_SIZE);
+    embedded += result.embedded;
+    stale_reembedded += result.stale_reembedded;
+    orphans_cleaned += result.orphans_cleaned;
+    const queueDepth = readQueueDepthSafely();
+    if (queueDepth === 0) {
+      return {
+        embedded,
+        stale_reembedded,
+        orphans_cleaned,
+        duration_ms: Date.now() - startedAt,
+        passes: passes + 1,
+        remaining_queue_depth: 0
+      };
+    }
+    if (result.embedded === 0 && result.stale_reembedded === 0 && result.orphans_cleaned === 0) {
+      return {
+        embedded,
+        stale_reembedded,
+        orphans_cleaned,
+        duration_ms: Date.now() - startedAt,
+        passes: passes + 1,
+        remaining_queue_depth: queueDepth
+      };
+    }
+  }
+  return {
+    embedded,
+    stale_reembedded,
+    orphans_cleaned,
+    duration_ms: Date.now() - startedAt,
+    passes,
+    remaining_queue_depth: readQueueDepthSafely()
+  };
+}
+async function drainForegroundReembedStale(manager) {
+  let reembedded = 0;
+  let passes = 0;
+  for (; passes < FOREGROUND_REEMBED_MAX_PASSES; passes++) {
+    const result = await manager.reembedStale(FOREGROUND_EMBEDDING_BATCH_SIZE);
+    reembedded += result.reembedded;
+    if (result.reembedded === 0) break;
+  }
+  return { reembedded, passes };
+}
 async function handleGetEmbeddingStatus(vaultDir) {
   const config = loadMergedConfig(vaultDir);
   const { queue_depth, embedded_count } = getEmbeddingQueueDepth();
@@ -5048,21 +5219,28 @@ function handleEmbeddingDetails(manager) {
   const details = manager.getDetails();
   return { body: details };
 }
-function handleEmbeddingRebuild(manager) {
+async function handleEmbeddingRebuild(manager) {
   const result = manager.rebuildAll();
-  return { body: result };
+  const drained = await drainForegroundReconcile(manager);
+  return {
+    body: {
+      ...result,
+      ...drained,
+      batch_size: FOREGROUND_EMBEDDING_BATCH_SIZE
+    }
+  };
 }
 async function handleEmbeddingReconcile(manager) {
-  const result = await manager.reconcile(EMBEDDING_BATCH_SIZE);
-  return { body: result };
+  const result = await manager.reconcile(FOREGROUND_EMBEDDING_BATCH_SIZE);
+  return { body: { ...result, batch_size: FOREGROUND_EMBEDDING_BATCH_SIZE } };
 }
 function handleEmbeddingCleanOrphans(manager) {
   const result = manager.cleanOrphans();
   return { body: result };
 }
 async function handleEmbeddingReembedStale(manager) {
-  const result = await manager.reembedStale(EMBEDDING_BATCH_SIZE);
-  return { body: result };
+  const result = await drainForegroundReembedStale(manager);
+  return { body: { ...result, batch_size: FOREGROUND_EMBEDDING_BATCH_SIZE } };
 }
 
 // src/daemon/database/types.ts
@@ -5114,7 +5292,33 @@ async function handleDatabaseIntegrityCheck(manager) {
 
 // src/daemon/embedding/manager.ts
 import { createHash as createHash3 } from "crypto";
+
+// src/intelligence/batch.ts
+async function batchExecute(items, fn, options) {
+  const { concurrency, onProgress } = options;
+  let succeeded = 0;
+  let failed = 0;
+  const results = [];
+  for (let i = 0; i < items.length; i += concurrency) {
+    const batch = items.slice(i, i + concurrency);
+    const settled = await Promise.allSettled(batch.map(fn));
+    for (const result of settled) {
+      if (result.status === "fulfilled") {
+        succeeded++;
+        results.push({ status: "fulfilled", value: result.value });
+      } else {
+        failed++;
+        results.push({ status: "rejected", reason: result.reason?.message ?? String(result.reason) });
+      }
+    }
+    onProgress?.(succeeded + failed, items.length);
+  }
+  return { succeeded, failed, results };
+}
+
+// src/daemon/embedding/manager.ts
 var ACTIVE_STATUS = "active";
+var EMBEDDING_MANAGER_CONCURRENCY = 2;
 var EmbeddingManager = class {
   constructor(vectorStore, embeddingProvider, recordSource, logger) {
     this.vectorStore = vectorStore;
@@ -5128,6 +5332,43 @@ var EmbeddingManager = class {
   contentHash(text) {
     return createHash3(CONTENT_HASH_ALGORITHM).update(text).digest("hex");
   }
+  totalPendingCount() {
+    return EMBEDDABLE_TABLES.reduce(
+      (sum, namespace) => sum + this.recordSource.getPendingCount(namespace),
+      0
+    );
+  }
+  async embedRecords(namespace, records, options) {
+    if (records.length === 0) return { processed: 0, unavailable: false };
+    const result = await batchExecute(
+      records,
+      async (record) => {
+        const embedding = await this.embeddingProvider.embed(record.text);
+        if (embedding === null) return { unavailable: true };
+        this.vectorStore.upsert(namespace, record.id, embedding, {
+          model: this.embeddingProvider.model,
+          provider: this.embeddingProvider.providerName,
+          dimensions: this.embeddingProvider.dimensions,
+          content_hash: this.contentHash(record.text),
+          embedded_at: epochSeconds(),
+          domain_metadata: record.metadata
+        });
+        if (options.markEmbedded) {
+          this.recordSource.markEmbedded(namespace, record.id);
+        }
+        return { unavailable: false };
+      },
+      { concurrency: EMBEDDING_MANAGER_CONCURRENCY }
+    );
+    let processed = 0;
+    let unavailable = false;
+    for (const entry of result.results) {
+      if (entry.status !== "fulfilled") continue;
+      if (entry.value.unavailable) unavailable = true;
+      else processed++;
+    }
+    return { processed, unavailable };
+  }
   // -------------------------------------------------------------------------
   // Write-path event handlers
   // -------------------------------------------------------------------------
@@ -5222,12 +5463,30 @@ var EmbeddingManager = class {
     const currentModel = this.embeddingProvider.model;
     for (const namespace of EMBEDDABLE_TABLES) {
       const rows = this.recordSource.getEmbeddableRows(namespace, batchSize);
-      for (const row of rows) {
-        const embedding = await this.embeddingProvider.embed(row.text);
-        if (embedding === null) {
-          this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during reconcile, returning partial progress", {
+      const embeddedBatch = await this.embedRecords(namespace, rows, { markEmbedded: true });
+      embedded += embeddedBatch.processed;
+      if (embeddedBatch.unavailable) {
+        this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during reconcile, returning partial progress", {
+          namespace,
+          embedded
+        });
+        return {
+          embedded,
+          stale_reembedded,
+          orphans_cleaned,
+          duration_ms: Date.now() - start
+        };
+      }
+      const staleIds = this.vectorStore.getStaleIds(namespace, currentModel, batchSize);
+      if (staleIds.length > 0) {
+        const records = this.recordSource.getRecordContent(namespace, staleIds);
+        const foundIds = new Set(records.map((r) => r.id));
+        const staleBatch = await this.embedRecords(namespace, records, { markEmbedded: false });
+        stale_reembedded += staleBatch.processed;
+        if (staleBatch.unavailable) {
+          this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during stale re-embed, returning partial progress", {
             namespace,
-            embedded
+            stale_reembedded
           });
           return {
             embedded,
@@ -5236,46 +5495,6 @@ var EmbeddingManager = class {
             duration_ms: Date.now() - start
           };
         }
-        const hash = this.contentHash(row.text);
-        this.vectorStore.upsert(namespace, row.id, embedding, {
-          model: currentModel,
-          provider: this.embeddingProvider.providerName,
-          dimensions: this.embeddingProvider.dimensions,
-          content_hash: hash,
-          embedded_at: epochSeconds(),
-          domain_metadata: row.metadata
-        });
-        this.recordSource.markEmbedded(namespace, row.id);
-        embedded++;
-      }
-      const staleIds = this.vectorStore.getStaleIds(namespace, currentModel, batchSize);
-      if (staleIds.length > 0) {
-        const records = this.recordSource.getRecordContent(namespace, staleIds);
-        const foundIds = new Set(records.map((r) => r.id));
-        for (const record of records) {
-          const embedding = await this.embeddingProvider.embed(record.text);
-          if (embedding === null) {
-            this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during stale re-embed, returning partial progress", {
-              namespace,
-              stale_reembedded
-            });
-            return {
-              embedded,
-              stale_reembedded,
-              orphans_cleaned,
-              duration_ms: Date.now() - start
-            };
-          }
-          this.vectorStore.upsert(namespace, record.id, embedding, {
-            model: currentModel,
-            provider: this.embeddingProvider.providerName,
-            dimensions: this.embeddingProvider.dimensions,
-            content_hash: this.contentHash(record.text),
-            embedded_at: epochSeconds(),
-            domain_metadata: record.metadata
-          });
-          stale_reembedded++;
-        }
         for (const staleId of staleIds) {
           if (!foundIds.has(staleId)) {
             this.vectorStore.remove(namespace, staleId);
@@ -5291,12 +5510,18 @@ var EmbeddingManager = class {
     }
     const duration_ms = Date.now() - start;
     if (embedded > 0 || stale_reembedded > 0 || orphans_cleaned > 0) {
-      this.logger.info(LOG_KINDS.EMBEDDING_RECONCILE, "Reconcile cycle completed", {
-        embedded,
-        stale_reembedded,
-        orphans_cleaned,
-        duration_ms
-      });
+      this.logger.info(
+        LOG_KINDS.EMBEDDING_RECONCILE,
+        `Reconcile cycle completed: ${embedded} embedded, ${stale_reembedded} stale re-embedded, ${orphans_cleaned} orphan vectors cleaned in ${duration_ms}ms (batch=${batchSize}, concurrency=${EMBEDDING_MANAGER_CONCURRENCY})`,
+        {
+          batch_size: batchSize,
+          concurrency: EMBEDDING_MANAGER_CONCURRENCY,
+          embedded,
+          stale_reembedded,
+          orphans_cleaned,
+          duration_ms
+        }
+      );
     }
     return { embedded, stale_reembedded, orphans_cleaned, duration_ms };
   }
@@ -5320,7 +5545,12 @@ var EmbeddingManager = class {
   rebuildAll() {
     const { cleared } = this.vectorStore.clear();
     this.recordSource.clearAllEmbedded();
-    this.logger.info(LOG_KINDS.EMBEDDING_REBUILD, "Rebuild started", { cleared });
+    const pending = this.totalPendingCount();
+    this.logger.info(
+      LOG_KINDS.EMBEDDING_REBUILD,
+      `Rebuild started: cleared ${cleared} vectors, ${pending} records pending re-embed`,
+      { cleared, pending, concurrency: EMBEDDING_MANAGER_CONCURRENCY }
+    );
     return { queued: cleared };
   }
   /**
@@ -5333,25 +5563,14 @@ var EmbeddingManager = class {
       const staleIds = this.vectorStore.getStaleIds(namespace, currentModel, batchSize);
       if (staleIds.length === 0) continue;
       const records = this.recordSource.getRecordContent(namespace, staleIds);
-      for (const record of records) {
-        const embedding = await this.embeddingProvider.embed(record.text);
-        if (embedding === null) {
-          this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during re-embed", {
-            namespace,
-            reembedded
-          });
-          return { reembedded };
-        }
-        const hash = this.contentHash(record.text);
-        this.vectorStore.upsert(namespace, record.id, embedding, {
-          model: currentModel,
-          provider: this.embeddingProvider.providerName,
-          dimensions: this.embeddingProvider.dimensions,
-          content_hash: hash,
-          embedded_at: epochSeconds(),
-          domain_metadata: record.metadata
+      const staleBatch = await this.embedRecords(namespace, records, { markEmbedded: false });
+      reembedded += staleBatch.processed;
+      if (staleBatch.unavailable) {
+        this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during re-embed", {
+          namespace,
+          reembedded
         });
-        reembedded++;
+        return { reembedded };
       }
     }
     return { reembedded };
@@ -5436,6 +5655,21 @@ var DEFAULT_META_MODEL = "unknown";
 var DEFAULT_META_PROVIDER = "unknown";
 var DEFAULT_META_CONTENT_HASH = "";
 var FILTERABLE_COLUMNS = /* @__PURE__ */ new Set(["model", "provider", "namespace"]);
+var FILTERABLE_DOMAIN_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "status",
+  "session_id",
+  "observation_type",
+  "project_root",
+  "name",
+  "source_path",
+  "created_at"
+]);
+var FILTER_SUFFIX_TO_OPERATOR = {
+  _gte: ">=",
+  _lte: "<=",
+  _gt: ">",
+  _lt: "<"
+};
 function cosineDistanceToSimilarity(distance) {
   return 1 - distance;
 }
@@ -5739,6 +5973,20 @@ var SqliteVecVectorStore = class {
       if (FILTERABLE_COLUMNS.has(key)) {
         conditions.push(`em.${key} = ?`);
         params.push(value);
+        continue;
+      }
+      let metadataKey = key;
+      let operator = "=";
+      for (const [suffix, sqlOperator] of Object.entries(FILTER_SUFFIX_TO_OPERATOR)) {
+        if (key.endsWith(suffix)) {
+          metadataKey = key.slice(0, -suffix.length);
+          operator = sqlOperator;
+          break;
+        }
+      }
+      if (FILTERABLE_DOMAIN_METADATA_KEYS.has(metadataKey)) {
+        conditions.push(`json_extract(em.domain_metadata, '$.${metadataKey}') ${operator} ?`);
+        params.push(value);
       }
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -5826,14 +6074,16 @@ var EmbeddingProviderAdapter = class {
 var ACTIVE_STATUS2 = "active";
 function sessionMetadata(row) {
   return {
-    ...row.project_root != null ? { project_root: row.project_root } : {}
+    ...row.project_root != null ? { project_root: row.project_root } : {},
+    ...row.created_at != null ? { created_at: row.created_at } : {}
   };
 }
 function sporeMetadata(row) {
   return {
     ...row.status != null ? { status: row.status } : {},
     ...row.session_id != null ? { session_id: row.session_id } : {},
-    ...row.observation_type != null ? { observation_type: row.observation_type } : {}
+    ...row.observation_type != null ? { observation_type: row.observation_type } : {},
+    ...row.created_at != null ? { created_at: row.created_at } : {}
   };
 }
 function emptyMetadata() {
@@ -5842,13 +6092,15 @@ function emptyMetadata() {
 function planMetadata(row) {
   return {
     ...row.session_id != null ? { session_id: row.session_id } : {},
-    ...row.source_path != null ? { source_path: row.source_path } : {}
+    ...row.source_path != null ? { source_path: row.source_path } : {},
+    ...row.created_at != null ? { created_at: row.created_at } : {}
   };
 }
 function skillRecordMetadata(row) {
   return {
     ...row.status != null ? { status: row.status } : {},
-    ...row.name != null ? { name: row.name } : {}
+    ...row.name != null ? { name: row.name } : {},
+    ...row.created_at != null ? { created_at: row.created_at } : {}
   };
 }
 function metadataFor(namespace, row) {
@@ -6693,10 +6945,10 @@ var ANTHROPIC_MODELS_CACHE_TTL_MS = 10 * 60 * 1e3;
 var anthropicModelsCache = null;
 var HTTP_OK2 = 200;
 var HTTP_BAD_REQUEST2 = 400;
-async function handleGetProviders() {
+async function handleGetProviders(logger) {
   const detectionPlan = [
     {
-      detect: () => detectAnthropic(),
+      detect: () => detectAnthropic(logger),
       fallback: { type: "anthropic", runtime: "claude-sdk", available: false, models: [] }
     },
     {
@@ -6708,11 +6960,11 @@ async function handleGetProviders() {
       fallback: { type: "lmstudio", runtime: "claude-sdk", available: false, baseUrl: LmStudioBackend.DEFAULT_BASE_URL, models: [] }
     },
     {
-      detect: () => detectRemoteProviderInfo("openai", DEFAULT_OPENAI_URL),
+      detect: () => detectRemoteProviderInfo("openai", DEFAULT_OPENAI_URL, logger),
       fallback: { type: "openai", runtime: "openai-agents", available: false, authConfigured: false, baseUrl: DEFAULT_OPENAI_URL, models: [] }
     },
     {
-      detect: () => detectRemoteProviderInfo("openrouter", DEFAULT_OPENROUTER_URL),
+      detect: () => detectRemoteProviderInfo("openrouter", DEFAULT_OPENROUTER_URL, logger),
       fallback: { type: "openrouter", runtime: "openai-agents", available: false, authConfigured: false, baseUrl: DEFAULT_OPENROUTER_URL, models: [] }
     },
     {
@@ -6771,7 +7023,10 @@ async function handleTestProvider(req) {
       result = testAnthropic();
     }
   } catch (err) {
-    result = { ok: false, error: String(err) };
+    result = {
+      ok: false,
+      error: errorMessage(err)
+    };
   }
   if (result.ok) {
     result.latency_ms = Math.round(performance.now() - start);
@@ -6790,7 +7045,7 @@ async function detectLocalProviderInfo(type, defaultBaseUrl) {
     models
   };
 }
-async function detectAnthropic() {
+async function detectAnthropic(logger) {
   const now = Date.now();
   if (anthropicModelsCache && now - anthropicModelsCache.ts < ANTHROPIC_MODELS_CACHE_TTL_MS) {
     return { type: "anthropic", runtime: "claude-sdk", available: true, models: anthropicModelsCache.models };
@@ -6806,12 +7061,14 @@ async function detectAnthropic() {
     if (liveModels.length > 0) {
       models = liveModels;
     }
-  } catch {
+  } catch (err) {
+    const detail = errorMessage(err);
+    logger?.warn("providers.anthropic.models-unavailable", "Anthropic model list unavailable", { error: detail });
   }
   anthropicModelsCache = { ts: now, models };
   return { type: "anthropic", runtime: "claude-sdk", available: true, models };
 }
-async function detectRemoteProviderInfo(type, baseUrl) {
+async function detectRemoteProviderInfo(type, baseUrl, logger) {
   const authConfigured = Boolean(getRemoteProviderApiKey(type));
   let models = [];
   let available = false;
@@ -6819,8 +7076,10 @@ async function detectRemoteProviderInfo(type, baseUrl) {
     try {
       models = await fetchRemoteProviderModels(type, void 0, ANTHROPIC_MODELS_TIMEOUT_MS);
       available = true;
-    } catch {
+    } catch (err) {
       available = false;
+      const detail = errorMessage(err);
+      logger?.warn(`providers.${type}.models-unavailable`, `${type} model list unavailable`, { error: detail });
     }
   }
   return {
@@ -7009,7 +7268,7 @@ async function registerScheduledTasks(powerManager, deps) {
   if (!lastEnabled) {
     logger.info(LOG_KINDS.AGENT_RUN, "Scheduled agent tasks disabled (agent.scheduled_tasks_enabled: false) \u2014 jobs registered but will no-op until enabled");
   }
-  const { loadAllTasks: loadAllTasks2 } = await import("./registry-M2Z5QBWH.js");
+  const { loadAllTasks: loadAllTasks2 } = await import("./registry-F3THYC5M.js");
   const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
   const taskAgentMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
@@ -7045,7 +7304,7 @@ async function registerScheduledTasks(powerManager, deps) {
         lastEnabled = enabled;
       }
       if (!enabled) return;
-      const { runAgent: runAgent2 } = await import("./executor-F2YU7HXJ.js");
+      const { runAgent: runAgent2 } = await import("./executor-FJCMNSXM.js");
       const resumableRun = getLatestResumableRunForTask(DEFAULT_AGENT_ID, taskName);
       if (resumableRun) {
         const resumed = await runAgent2(vaultDir, {
@@ -7053,7 +7312,8 @@ async function registerScheduledTasks(powerManager, deps) {
           task: taskName,
           resumeRunId: resumableRun.id,
           resumeMode: "scheduled",
-          embeddingManager
+          embeddingManager,
+          logger
         });
         logger.info(LOG_KINDS.AGENT_RUN, `Scheduled task ${taskName} resumed`, {
           status: resumed.status,
@@ -7084,7 +7344,8 @@ async function registerScheduledTasks(powerManager, deps) {
         task: taskName,
         instruction: built?.instruction,
         runContext: built?.context,
-        embeddingManager
+        embeddingManager,
+        logger
       });
       logger.info(LOG_KINDS.AGENT_RUN, `Scheduled task ${taskName} completed`, {
         status: result.status,
@@ -7405,7 +7666,8 @@ function createMcpProxyHandlers(deps) {
     });
     embeddingManager.onContentWritten("spores", spore.id, content, {
       status: "active",
-      observation_type: observationType
+      observation_type: observationType,
+      created_at: now
     }).catch(() => {
     });
     return {
@@ -7482,7 +7744,8 @@ function createMcpProxyHandlers(deps) {
     })();
     embeddingManager.onContentWritten("spores", wisdom.id, consolidated_content, {
       status: "active",
-      observation_type
+      observation_type,
+      created_at: now
     }).catch(() => {
     });
     for (const sourceId of sourcesSuperseded) {
@@ -7873,7 +8136,7 @@ function isPlainObject(value) {
 }
 
 // src/daemon/api/run-serializer.ts
-function buildPhaseCheckpointSummary(checkpointsRaw) {
+function buildPhaseCheckpointSummary(checkpointsRaw, logger) {
   if (!checkpointsRaw) return [];
   try {
     const parsed = JSON.parse(checkpointsRaw);
@@ -7885,7 +8148,9 @@ function buildPhaseCheckpointSummary(checkpointsRaw) {
       ...phase.costUsd !== void 0 ? { costUsd: phase.costUsd } : {},
       ...phase.costSource !== void 0 ? { costSource: phase.costSource } : {}
     }));
-  } catch {
+  } catch (err) {
+    const detail = errorMessage(err);
+    logger?.warn("run-serializer.checkpoints-parse-failed", "checkpoints JSON parse failed", { error: detail });
     return [];
   }
 }
@@ -7905,7 +8170,8 @@ function serializeRun(run, opts = {}) {
     includeResumeFields = true,
     includePhaseCheckpoints = true,
     writeIntents,
-    duration_ms
+    duration_ms,
+    logger
   } = opts;
   const base = {
     id: run.id,
@@ -7944,7 +8210,7 @@ function serializeRun(run, opts = {}) {
       resumed_at: run.resumed_at,
       checkpoints: run.checkpoints
     } : {},
-    ...includePhaseCheckpoints ? { phase_checkpoints: buildPhaseCheckpointSummary(run.checkpoints) } : {},
+    ...includePhaseCheckpoints ? { phase_checkpoints: buildPhaseCheckpointSummary(run.checkpoints, logger) } : {},
     ...writeIntents !== void 0 && writeIntents !== null ? { write_intents: writeIntents } : {},
     ...duration_ms !== void 0 ? { duration_ms } : {}
   };
@@ -8033,7 +8299,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent: runAgent2 } = await import("./executor-F2YU7HXJ.js");
+    const { runAgent: runAgent2 } = await import("./executor-FJCMNSXM.js");
     const resultPromise = runAgent2(vaultDir, {
       task,
       instruction,
@@ -8042,7 +8308,8 @@ function createAgentRunHandlers(deps) {
       runContext,
       dryRun,
       evaluationId,
-      executionOverrides
+      executionOverrides,
+      logger
     });
     const effectiveAgentId = agentId ?? "myco-agent";
     const runId = getLatestRunId(effectiveAgentId, task);
@@ -8094,7 +8361,7 @@ function createAgentRunHandlers(deps) {
     const filterOpts = { agent_id: agentId, status, task, search };
     const runs = listRuns({ ...filterOpts, limit, offset });
     const total = countRuns(filterOpts);
-    return { body: { runs: runs.map((run) => serializeRun(run)), total, offset, limit } };
+    return { body: { runs: runs.map((run) => serializeRun(run, { logger })), total, offset, limit } };
   }
   async function handleGetRun(req) {
     const run = getRun(req.params.id);
@@ -8107,7 +8374,8 @@ function createAgentRunHandlers(deps) {
       body: {
         run: serializeRun(run, {
           writeIntents: { total, by_tool: byTool },
-          duration_ms: runDurationMs(run)
+          duration_ms: runDurationMs(run),
+          logger
         })
       }
     };
@@ -8121,14 +8389,15 @@ function createAgentRunHandlers(deps) {
       return { status: 400, body: { error: "Run is not resumable" } };
     }
     const { mode } = ResumeRunBody.parse(req.body ?? {});
-    const { runAgent: runAgent2 } = await import("./executor-F2YU7HXJ.js");
+    const { runAgent: runAgent2 } = await import("./executor-FJCMNSXM.js");
     const resultPromise = runAgent2(vaultDir, {
       agentId: run.agent_id,
       task: run.task ?? void 0,
       instruction: run.instruction ?? void 0,
       resumeRunId: run.id,
       resumeMode: mode ?? "manual",
-      embeddingManager
+      embeddingManager,
+      logger
     });
     resultPromise.then((result) => {
       logger.info(LOG_KINDS.AGENT_RUN, "Agent run resumed", {
@@ -8351,7 +8620,7 @@ function createAgentEvaluationHandlers(deps) {
     });
     const dryRun = body.matrix.dryRun ?? false;
     void (async () => {
-      const { runAgent: runAgent2 } = await import("./executor-F2YU7HXJ.js");
+      const { runAgent: runAgent2 } = await import("./executor-FJCMNSXM.js");
       let anyCompleted = false;
       let transitionedToRunning = false;
       const sharedPhases = body.matrix.phases;
@@ -8361,6 +8630,7 @@ function createAgentEvaluationHandlers(deps) {
           evaluationId: evalId,
           dryRun,
           embeddingManager,
+          logger,
           executionOverrides: {
             ...cell.runtime ? { runtime: cell.runtime } : {},
             ...cell.reasoningLevel ? { reasoningLevel: cell.reasoningLevel } : {},
@@ -9776,7 +10046,8 @@ function createStopProcessor(deps) {
       }
     }
     const existingSessionMeta = registry.getSession(sessionId);
-    if (!hookTranscriptPath && !existingSessionMeta) {
+    const dbSession = existingSessionMeta ? void 0 : getSession(sessionId);
+    if (!hookTranscriptPath && !existingSessionMeta && !dbSession) {
       logger.info(LOG_KINDS.HOOKS_STOP, "Stop ignored \u2014 ephemeral sub-invocation", {
         session_id: sessionId
       });
@@ -9784,7 +10055,7 @@ function createStopProcessor(deps) {
     }
     if (!existingSessionMeta) {
       registry.register(sessionId, { started_at: (/* @__PURE__ */ new Date()).toISOString() });
-      logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Auto-registered session from stop event", { session_id: sessionId });
+      logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, dbSession ? "Rehydrated registry from DB on stop event" : "Auto-registered session from stop event", { session_id: sessionId });
     }
     const sessionMeta = existingSessionMeta ?? registry.getSession(sessionId);
     logger.info(LOG_KINDS.HOOKS_STOP, "Stop received", {
@@ -9878,44 +10149,55 @@ function createEventDispatcher(deps) {
     };
     logger.debug(LOG_KINDS.HOOKS_EVENT, "Event received", { type: event.type, session_id: event.session_id });
     if (!registry.getSession(event.session_id)) {
-      const cached = droppedSessions.get(event.session_id);
-      const hasTranscriptNow = typeof event.transcript_path === "string" && event.transcript_path.length > 0;
-      const shouldReevaluate = cached && !cached.hadTranscriptMeta && hasTranscriptNow;
-      if (cached && !shouldReevaluate) {
-        const reason = cached.reason ?? "rule";
-        logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Ignored event for previously-dropped session", {
+      const existingRow = getSession(event.session_id);
+      if (existingRow) {
+        registry.register(event.session_id, { started_at: event.timestamp });
+        logger.info(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Rehydrated registry from DB", {
           session_id: event.session_id,
-          type: event.type,
-          reason
+          agent: existingRow.agent,
+          type: event.type
         });
-        return { body: { ok: true, ignored: reason } };
-      }
-      if (shouldReevaluate) {
-        droppedSessions.delete(event.session_id);
-      }
-      const { decision, hadTranscriptMeta } = evaluateAutoRegistration(event);
-      if (decision.action === "drop") {
-        rememberDropped(event.session_id, decision.reason, hadTranscriptMeta);
-        logger.info(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Ignored event that failed session capture rules", {
-          session_id: event.session_id,
-          type: event.type,
-          reason: decision.reason ?? "rule"
+        reconcileSession(event.session_id);
+      } else {
+        const cached = droppedSessions.get(event.session_id);
+        const hasTranscriptNow = typeof event.transcript_path === "string" && event.transcript_path.length > 0;
+        const shouldReevaluate = cached && !cached.hadTranscriptMeta && hasTranscriptNow;
+        if (cached && !shouldReevaluate) {
+          const reason = cached.reason ?? "rule";
+          logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Ignored event for previously-dropped session", {
+            session_id: event.session_id,
+            type: event.type,
+            reason
+          });
+          return { body: { ok: true, ignored: reason } };
+        }
+        if (shouldReevaluate) {
+          droppedSessions.delete(event.session_id);
+        }
+        const { decision, hadTranscriptMeta } = evaluateAutoRegistration(event);
+        if (decision.action === "drop") {
+          rememberDropped(event.session_id, decision.reason, hadTranscriptMeta);
+          logger.info(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Ignored event that failed session capture rules", {
+            session_id: event.session_id,
+            type: event.type,
+            reason: decision.reason ?? "rule"
+          });
+          return { body: { ok: true, ignored: decision.reason ?? "rule" } };
+        }
+        registry.register(event.session_id, { started_at: event.timestamp });
+        logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Auto-registered session from event", { session_id: event.session_id });
+        const now = epochSeconds();
+        const startedEpoch = Math.floor(new Date(event.timestamp).getTime() / 1e3);
+        upsertSession({
+          id: event.session_id,
+          agent: event.agent ?? DEFAULT_SYMBIONT_NAME,
+          status: "active",
+          started_at: startedEpoch,
+          created_at: now,
+          machine_id: machineId
         });
-        return { body: { ok: true, ignored: decision.reason ?? "rule" } };
+        reconcileSession(event.session_id);
       }
-      registry.register(event.session_id, { started_at: event.timestamp });
-      logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Auto-registered session from event", { session_id: event.session_id });
-      const now = epochSeconds();
-      const startedEpoch = Math.floor(new Date(event.timestamp).getTime() / 1e3);
-      upsertSession({
-        id: event.session_id,
-        agent: event.agent ?? DEFAULT_SYMBIONT_NAME,
-        status: "active",
-        started_at: startedEpoch,
-        created_at: now,
-        machine_id: machineId
-      });
-      reconcileSession(event.session_id);
     }
     if (!sessionBuffers.has(event.session_id)) {
       const bufferDir = path23.join(vaultDir, "buffer");
@@ -10352,7 +10634,7 @@ async function main() {
   const databaseManager = new DatabaseMaintenanceManager(vaultDbPath(vaultDir), vaultDir, logger);
   let definitionsDir;
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-NAVVZK63.js");
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-UDNUMEDA.js");
     definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
@@ -10584,7 +10866,7 @@ async function main() {
   server.registerRoute("GET", "/api/logs/stream", handleLogStream);
   server.registerRoute("GET", "/api/logs/:id", handleLogDetail);
   server.registerRoute("POST", "/api/log", createLogIngestionHandler(logger));
-  server.registerRoute("GET", "/api/models", async (req) => handleGetModels(req));
+  server.registerRoute("GET", "/api/models", async (req) => handleGetModels(req, logger));
   server.registerRoute("POST", "/api/restart", async (req) => handleRestart({ vaultDir, progressTracker }, req.body));
   const updateProjectRoot = path24.dirname(vaultDir);
   const updateHandlers = createUpdateHandlers({
@@ -10690,7 +10972,7 @@ async function main() {
     }
     return result;
   });
-  server.registerRoute("GET", "/api/providers", async () => handleGetProviders());
+  server.registerRoute("GET", "/api/providers", async () => handleGetProviders(logger));
   server.registerRoute("POST", "/api/providers/test", async (req) => handleTestProvider(req));
   server.registerRoute("GET", "/api/providers/secrets", async () => handleGetProviderSecrets(vaultDir));
   server.registerRoute("PUT", "/api/providers/secrets/:provider", async (req) => handlePutProviderSecret(vaultDir, req));
@@ -10855,4 +11137,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-5PRQNEEE.js.map
+//# sourceMappingURL=main-4HKTZFIM.js.map