@fml-inc/fml 0.8.6 → 0.8.7

package/dist/hook-handler.js

@@ -1,38 +1,171 @@
 #!/usr/bin/env node
 import {
-  hookCaptureIsDisabled
-} from "./chunk-2DQQXBWM.js";
+  hookCaptureIsDisabled,
+  openObserverLog
+} from "./chunk-LPSZCTTJ.js";
 import {
   getActiveHookDestinationBinding
 } from "./chunk-PJWMSHHZ.js";
 import {
+  HookInboxCapacityError,
+  OBSERVER_HEARTBEAT_STALE_MS,
+  OBSERVER_IDENTITY_HEADER,
+  OBSERVER_SERVICE_NAME,
   SHELL_TOOL_NAMES,
   createHookInboxEntry,
   hookInboxDeliveryPayload,
   normalizeObserverHookCapture,
   persistHookInboxEntry,
-  readObserverAuthToken
-} from "./chunk-5TOOBX7I.js";
+  readObserverAuthToken,
+  readObserverState,
+  recordHookInboxLoss
+} from "./chunk-4YLSKFDU.js";
 import {
   resolveRepositoryRootFromCwd,
   resolveRepositorySlugFromCwd
 } from "./chunk-7V7G7NVF.js";
+import {
+  resolvePackageRoot
+} from "./chunk-F57IFY3K.js";
 import {
   FML_HOOK_CONTEXT_STATE_DIR,
   FML_HOOK_INBOX_DIR,
   FML_OBSERVER_AUTH_TOKEN_FILE,
+  FML_OBSERVER_DIR,
   FML_OBSERVER_ENDPOINT_FILE,
+  FML_OBSERVER_STATE_FILE,
   getValidToken
 } from "./chunk-B3H2YWPJ.js";
 import "./chunk-MLKGABMK.js";
 
 // src/hooks/handler.ts
-import fs2 from "fs";
+import fs3 from "fs";
 
-// src/hooks/context.ts
-import { createHash } from "crypto";
+// src/hooks/observer-revival.ts
+import { spawn } from "child_process";
 import fs from "fs";
 import path from "path";
+var OBSERVER_REVIVAL_MIN_INTERVAL_MS = 10 * 6e4;
+var FML_OBSERVER_REVIVAL_STAMP_DIR = path.join(
+  FML_OBSERVER_DIR,
+  "hook-revival"
+);
+var STAMP_PREFIX = "window-";
+var RETAINED_STAMPS = 3;
+var CLAIM_LOCK_NAME = "claim.lock";
+var OBSERVER_REVIVAL_CLAIM_LOCK_STALE_MS = 3e4;
+function launchDetachedObserver() {
+  const observerScript = path.join(resolvePackageRoot(), "bin", "observer");
+  const logFd = openObserverLog();
+  try {
+    fs.writeSync(
+      logFd,
+      `${(/* @__PURE__ */ new Date()).toISOString()} hook handler relaunching the FML observer (recorded endpoint unreachable); PATH=${process.env.PATH ?? ""}
+`
+    );
+    const child = spawn(process.execPath, [observerScript], {
+      detached: true,
+      env: process.env,
+      shell: false,
+      stdio: ["ignore", logFd, logFd],
+      windowsHide: true
+    });
+    child.once("error", () => {
+    });
+    child.unref();
+  } finally {
+    fs.closeSync(logFd);
+  }
+}
+function pruneOldStamps(stampDir, currentWindow) {
+  try {
+    for (const name of fs.readdirSync(stampDir)) {
+      if (!name.startsWith(STAMP_PREFIX)) continue;
+      const window = Number(name.slice(STAMP_PREFIX.length));
+      if (Number.isFinite(window) && window < currentWindow - RETAINED_STAMPS) {
+        fs.rmSync(path.join(stampDir, name), { force: true });
+      }
+    }
+  } catch {
+  }
+}
+function previousWindowClaimedWithin(stampDir, window, now, minIntervalMs) {
+  const previous = path.join(stampDir, `${STAMP_PREFIX}${window - 1}`);
+  let contents;
+  try {
+    contents = fs.readFileSync(previous, "utf8");
+  } catch (error) {
+    return error.code !== "ENOENT";
+  }
+  const match = /^(\d+)(?:\s|$)/.exec(contents);
+  if (!match) return true;
+  return now - Number(match[1]) < minIntervalMs;
+}
+function acquireClaimLock(lockDir) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs.mkdirSync(lockDir, { mode: 448 });
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") return false;
+    }
+    try {
+      const age = Date.now() - fs.statSync(lockDir).mtimeMs;
+      if (age < OBSERVER_REVIVAL_CLAIM_LOCK_STALE_MS) return false;
+      fs.rmdirSync(lockDir);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function claimWindow(stampDir, window, now, minIntervalMs) {
+  if (previousWindowClaimedWithin(stampDir, window, now, minIntervalMs)) {
+    return false;
+  }
+  const stamp = path.join(stampDir, `${STAMP_PREFIX}${window}`);
+  let fd;
+  try {
+    fd = fs.openSync(stamp, "wx", 384);
+  } catch {
+    return false;
+  }
+  try {
+    fs.writeSync(fd, `${now} pid=${process.pid}
+`);
+  } finally {
+    fs.closeSync(fd);
+  }
+  return true;
+}
+function requestObserverRevival(options = {}) {
+  const stampDir = options.stampDir ?? FML_OBSERVER_REVIVAL_STAMP_DIR;
+  const minIntervalMs = options.minIntervalMs ?? OBSERVER_REVIVAL_MIN_INTERVAL_MS;
+  const now = (options.nowMs ?? Date.now)();
+  const window = Math.floor(now / minIntervalMs);
+  try {
+    fs.mkdirSync(stampDir, { recursive: true, mode: 448 });
+    const lockDir = path.join(stampDir, CLAIM_LOCK_NAME);
+    if (!acquireClaimLock(lockDir)) return false;
+    let claimed;
+    try {
+      claimed = claimWindow(stampDir, window, now, minIntervalMs);
+    } finally {
+      fs.rmSync(lockDir, { recursive: true, force: true });
+    }
+    if (!claimed) return false;
+    pruneOldStamps(stampDir, window);
+    (options.launch ?? launchDetachedObserver)();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/hooks/context.ts
+import { createHash } from "crypto";
+import fs2 from "fs";
+import path2 from "path";
 var HOOK_CONTEXT_ENDPOINT = "/v1/panopticon/hook-context";
 var HOOK_CONTEXT_TIMEOUT_MS = 2e3;
 var MAX_ADDITIONAL_CONTEXT_CHARS = 3700;
@@ -73,11 +206,11 @@ function hookContextInjectionId(target2, syncId) {
 }
 function markerPath(stateDir, kind, value) {
   const digest = createHash("sha256").update(value).digest("hex");
-  return path.join(stateDir, kind, digest);
+  return path2.join(stateDir, kind, digest);
 }
 function ensureMarkerDirectory(filePath) {
   try {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true, mode: 448 });
     return true;
   } catch {
     return false;
@@ -87,12 +220,12 @@ function isSubsequentUserPrompt(sessionId, eventSyncId, stateDir = FML_HOOK_CONT
   const filePath = markerPath(stateDir, "prompt", sessionId);
   if (!ensureMarkerDirectory(filePath)) return false;
   try {
-    fs.writeFileSync(filePath, eventSyncId, { flag: "wx", mode: 384 });
+    fs2.writeFileSync(filePath, eventSyncId, { flag: "wx", mode: 384 });
     return false;
   } catch (error) {
     if (error.code !== "EEXIST") return false;
     try {
-      return fs.readFileSync(filePath, "utf8") !== eventSyncId;
+      return fs2.readFileSync(filePath, "utf8") !== eventSyncId;
     } catch {
       return false;
     }
@@ -100,7 +233,7 @@ function isSubsequentUserPrompt(sessionId, eventSyncId, stateDir = FML_HOOK_CONT
 }
 function pathContextWasEmitted(sessionId, filePath, stateDir) {
   try {
-    return fs.existsSync(
+    return fs2.existsSync(
       markerPath(stateDir, "path", `${sessionId}:${filePath}`)
     );
   } catch {
@@ -111,7 +244,7 @@ function claimPathContext(sessionId, filePath, stateDir) {
   const claim = markerPath(stateDir, "path", `${sessionId}:${filePath}`);
   if (!ensureMarkerDirectory(claim)) return false;
   try {
-    fs.writeFileSync(claim, "", { flag: "wx", mode: 384 });
+    fs2.writeFileSync(claim, "", { flag: "wx", mode: 384 });
     return true;
   } catch {
     return false;
@@ -120,18 +253,18 @@ function claimPathContext(sessionId, filePath, stateDir) {
 function pruneOldMarkers(directory, nowMs) {
   if ((nowMs + process.pid) % 256 !== 0) return;
   for (const kind of ["prompt", "path"]) {
-    const markerDirectory = path.join(directory, kind);
+    const markerDirectory = path2.join(directory, kind);
     let names;
     try {
-      names = fs.readdirSync(markerDirectory).slice(0, 1e3);
+      names = fs2.readdirSync(markerDirectory).slice(0, 1e3);
     } catch {
       continue;
     }
     for (const name of names) {
-      const filePath = path.join(markerDirectory, name);
+      const filePath = path2.join(markerDirectory, name);
       try {
-        if (nowMs - fs.statSync(filePath).mtimeMs > STATE_MAX_AGE_MS) {
-          fs.rmSync(filePath, { force: true });
+        if (nowMs - fs2.statSync(filePath).mtimeMs > STATE_MAX_AGE_MS) {
+          fs2.rmSync(filePath, { force: true });
         }
       } catch {
       }
@@ -142,7 +275,7 @@ function canonicalHookContextFilePath(filePath, cwd, repositoryRoot) {
   const windows = [filePath, cwd, repositoryRoot].some(
     (value) => value !== void 0 && value !== null && /^[A-Za-z]:[\\/]/.test(value)
   );
-  const pathApi = windows ? path.win32 : path.posix;
+  const pathApi = windows ? path2.win32 : path2.posix;
   const normalized = pathApi.normalize(filePath);
   const resolved = pathApi.isAbsolute(normalized) ? normalized : cwd && pathApi.isAbsolute(cwd) ? pathApi.resolve(cwd, normalized) : normalized;
   if (repositoryRoot && pathApi.isAbsolute(resolved)) {
@@ -557,7 +690,7 @@ function parseHookTarget(value) {
 }
 function observerEndpoint(endpointFile) {
   try {
-    const parsed = JSON.parse(fs2.readFileSync(endpointFile, "utf8"));
+    const parsed = JSON.parse(fs3.readFileSync(endpointFile, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
     }
@@ -659,6 +792,7 @@ async function processHookHandler(target2, opts, includeContext) {
   const inboxDir = opts.inboxDir ?? FML_HOOK_INBOX_DIR;
   let inboxEntry;
   let persisted = false;
+  let refusedBytes;
   let destination = null;
   if (event) {
     try {
@@ -673,7 +807,10 @@ async function processHookHandler(target2, opts, includeContext) {
     try {
       persistHookInboxEntry(inboxEntry, inboxDir, opts.inboxLimits);
       persisted = true;
-    } catch {
+    } catch (error) {
+      if (error instanceof HookInboxCapacityError) {
+        refusedBytes = Buffer.byteLength(JSON.stringify(inboxEntry), "utf8") + 1;
+      }
     }
   }
   const contextPromise = includeContext && event && destination ? opts.requestContext ? opts.requestContext(target2, event, destination) : requestServerHookContext(target2, event, destination, {
@@ -687,6 +824,13 @@ async function processHookHandler(target2, opts, includeContext) {
   const authToken = readObserverAuthToken(
     opts.authTokenFile ?? FML_OBSERVER_AUTH_TOKEN_FILE
   );
+  const reviveObserver = () => {
+    try {
+      (opts.reviveObserver ?? requestObserverRevival)();
+    } catch {
+    }
+  };
+  let deliveryUnconfirmed = false;
   const deliveryPromise = (async () => {
     if (!endpoint || !authToken) return persisted;
     const host = endpoint.host === "::1" ? "[::1]" : endpoint.host;
@@ -709,8 +853,21 @@ async function processHookHandler(target2, opts, includeContext) {
         }
       );
       await response.arrayBuffer();
+      if (response.headers.get(OBSERVER_IDENTITY_HEADER) !== OBSERVER_SERVICE_NAME) {
+        reviveObserver();
+        return persisted;
+      }
       return response.ok || persisted;
-    } catch {
+    } catch (error) {
+      if (isTimeoutOrAbort(error)) {
+        deliveryUnconfirmed = true;
+        if (observerHeartbeatIsStale(opts.stateFile ?? FML_OBSERVER_STATE_FILE)) {
+          reviveObserver();
+        }
+        return persisted;
+      }
+      if (!requestNeverReachedObserver(error)) deliveryUnconfirmed = true;
+      reviveObserver();
       return persisted;
     }
   })();
@@ -718,8 +875,43 @@ async function processHookHandler(target2, opts, includeContext) {
     deliveryPromise,
     contextPromise.catch(() => ({}))
   ]);
+  if (refusedBytes !== void 0 && !captured && !deliveryUnconfirmed) {
+    try {
+      recordHookInboxLoss(inboxDir, refusedBytes);
+    } catch {
+    }
+  }
   return { captured, output: output2 };
 }
+function isTimeoutOrAbort(error) {
+  return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+var NEVER_CONNECTED_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EADDRNOTAVAIL"
+]);
+function requestNeverReachedObserver(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error && !seen.has(current)) {
+    seen.add(current);
+    const code = current.code;
+    if (code !== void 0 && NEVER_CONNECTED_CODES.has(code)) return true;
+    for (const known of NEVER_CONNECTED_CODES) {
+      if (current.message.includes(known)) return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+function observerHeartbeatIsStale(stateFile) {
+  const state = readObserverState(stateFile);
+  if (!state) return true;
+  return Date.now() - state.heartbeatAtMs > OBSERVER_HEARTBEAT_STALE_MS;
+}
 async function runHookHandlerForOutput(target2, opts = {}) {
   return (await processHookHandler(target2, opts, true)).output;
 }

package/dist/observer-server.js

@@ -1,17 +1,11 @@
 #!/usr/bin/env node
 import {
-  ObserverStateMutationBusyError,
   checkForUpdate,
-  claimObserverState,
-  createInitialObserverState,
   isUpdatableVersion,
   isWinShim,
-  observerLeaseIsOwned,
   quoteWinArg,
-  removeObserverStateIfOwned,
-  resolveBin,
-  updateObserverState
-} from "./chunk-E2MATWOU.js";
+  resolveBin
+} from "./chunk-XFALHTDL.js";
 import {
   createHookSyncLoop,
   getActiveHookDestinationBinding
@@ -20,25 +14,33 @@ import {
   OBSERVER_PROTOCOL_VERSION,
   OBSERVER_SERVICE_NAME,
   ObserverHookSpoolEntryTooLargeError,
+  ObserverStateMutationBusyError,
   acknowledgeHookInboxEntry,
+  claimObserverState,
+  createInitialObserverState,
   createObserverHttpServer,
   drainHookInbox,
   getOrCreateObserverAuthToken,
   normalizeObserverHookCapture,
+  observerLeaseIsOwned,
   openObserverDatabase,
   parseHookCaptureRequest,
   parseHookInboxMetadata,
   readHookInboxStatusAsync,
-  retireHookInboxEntry
-} from "./chunk-5TOOBX7I.js";
+  removeObserverStateIfOwned,
+  retireHookInboxEntry,
+  updateObserverState
+} from "./chunk-4YLSKFDU.js";
 import "./chunk-7V7G7NVF.js";
 import {
   ObserverSyncCycleAbortedError,
   runObserverSyncCycleSubprocess
-} from "./chunk-YFHZJPTC.js";
+} from "./chunk-6BTC3S7C.js";
 import {
-  createCliRawSync
-} from "./chunk-V2XC7JTB.js";
+  createCliRawSync,
+  invalidateCliRawSyncDiscoveryCache
+} from "./chunk-5JJQWV4G.js";
+import "./chunk-F57IFY3K.js";
 import {
   FML_OBSERVER_AUTH_TOKEN_FILE,
   FML_OBSERVER_ENDPOINT_FILE,
@@ -1046,7 +1048,7 @@ function parseOtlpSpoolMaxBytes(configured) {
 }
 
 // src/observer/sync-loop.ts
-var OBSERVER_IDLE_INTERVAL_MS = 3e4;
+var OBSERVER_IDLE_INTERVAL_MS = 5 * 6e4;
 var OBSERVER_BUSY_INTERVAL_MS = 2e3;
 var OBSERVER_AUTH_INTERVAL_MS = 6e4;
 var OBSERVER_MAX_TIMER_DELAY_MS = 2147483647;
@@ -1084,8 +1086,14 @@ function createObserverSyncLoop(opts) {
   const runOnce = opts.runOnce ?? runObserverSyncCycleSubprocess;
   let stopping = false;
   let wakePending = false;
+  let nudgePending = false;
   let wakeWaiter = null;
   let activeAbort = null;
+  const nudge = () => {
+    nudgePending = true;
+    wakePending = true;
+    wakeWaiter?.();
+  };
   const wake = () => {
     wakePending = true;
     activeAbort?.abort();
@@ -1121,6 +1129,10 @@ function createObserverSyncLoop(opts) {
   };
   const done = (async () => {
     while (!stopping) {
+      if (nudgePending) {
+        nudgePending = false;
+        opts.beforeNudgedCycle?.();
+      }
       const attemptedAtMs = nowMs();
       opts.onUpdate({
         phase: "syncing",
@@ -1189,6 +1201,7 @@ function createObserverSyncLoop(opts) {
   })();
   return {
     done,
+    nudge,
     wake,
     stop: () => {
       if (stopping) return;
@@ -1199,6 +1212,47 @@ function createObserverSyncLoop(opts) {
   };
 }
 
+// src/observer/session-end-sync-wake.ts
+var SESSION_END_SYNC_WAKE_INTERVAL_MS = 6e4;
+function createSessionEndSyncWakeScheduler(options) {
+  const intervalMs = Math.max(
+    1,
+    options.intervalMs ?? SESSION_END_SYNC_WAKE_INTERVAL_MS
+  );
+  const nowMs = options.nowMs ?? Date.now;
+  let lastWakeAtMs = null;
+  let trailingTimer = null;
+  let stopped = false;
+  const wake = () => {
+    lastWakeAtMs = nowMs();
+    options.onWake();
+  };
+  return {
+    request: () => {
+      if (stopped) return;
+      const now = nowMs();
+      const elapsedMs = lastWakeAtMs === null ? intervalMs : now - lastWakeAtMs;
+      if (elapsedMs >= intervalMs || elapsedMs < 0) {
+        if (trailingTimer) clearTimeout(trailingTimer);
+        trailingTimer = null;
+        wake();
+        return;
+      }
+      if (trailingTimer) return;
+      trailingTimer = setTimeout(() => {
+        trailingTimer = null;
+        if (!stopped) wake();
+      }, intervalMs - elapsedMs);
+      trailingTimer.unref();
+    },
+    stop: () => {
+      stopped = true;
+      if (trailingTimer) clearTimeout(trailingTimer);
+      trailingTimer = null;
+    }
+  };
+}
+
 // src/observer/auto-update.ts
 var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var AUTO_UPDATE_JITTER_MS = 10 * 60 * 1e3;
@@ -1285,12 +1339,15 @@ function createAutoUpdater(dependencies) {
 }
 
 // src/observer-server.ts
-var HEARTBEAT_INTERVAL_MS = 5e3;
+var HEARTBEAT_INTERVAL_MS = 3e4;
 var STATE_UPDATE_RETRY_MS = 50;
 var STARTUP_STATE_UPDATE_TIMEOUT_MS = 5e3;
 var PORT_FALLBACK_COUNT = 10;
 var HOOK_REJECTION_WARNING_INTERVAL_MS = 6e4;
-var HOOK_INBOX_DRAIN_INTERVAL_MS = 1e3;
+var HOOK_INBOX_DRAIN_INTERVAL_MS = 15e3;
+var HOOK_INBOX_DRAIN_BUDGET_MS = 5e3;
+var HOOK_INBOX_DRAIN_ENTRIES = 100;
+var HOOK_INBOX_DRAIN_BULK_ENTRIES = 1e3;
 var HOOK_QUARANTINE_PRUNE_INTERVAL_MS = 5 * 60 * 1e3;
 var OBSERVER_DIRECTORY_LEASE = {
   stateFile: FML_OBSERVER_STATE_FILE,
@@ -1436,6 +1493,15 @@ var hookSyncLoop = null;
 var autoUpdater = null;
 var otlpSyncLoop = null;
 var pendingStateUpdate = null;
+var sessionEndSyncWakeScheduler = createSessionEndSyncWakeScheduler({
+  onWake: () => {
+    if (syncLoop) {
+      syncLoop.nudge();
+    } else {
+      invalidateCliRawSyncDiscoveryCache();
+    }
+  }
+});
 var authToken;
 var database;
 try {
@@ -1480,7 +1546,7 @@ var hookRejectionStatus = () => ({
   ...lastRejectedReason !== void 0 ? { lastRejectedReason } : {},
   ...lastRejectedTarget !== void 0 ? { lastRejectedTarget } : {}
 });
-var packageVersion = true ? "0.8.6+f7c7191d" : "dev";
+var packageVersion = true ? "0.8.7+af45d2af" : "dev";
 var health = () => ({
   status: "ok",
   service: OBSERVER_SERVICE_NAME,
@@ -1546,6 +1612,7 @@ var shutdown = async () => {
   if (hookInboxDrainTimer) clearInterval(hookInboxDrainTimer);
   if (hookQuarantinePruneTimer) clearInterval(hookQuarantinePruneTimer);
   if (stateUpdateRetryTimer) clearTimeout(stateUpdateRetryTimer);
+  sessionEndSyncWakeScheduler.stop();
   autoUpdater?.stop();
   if (bothObserverLeasesAreOwned(state.instanceId)) {
     try {
@@ -1674,6 +1741,9 @@ var captureHookRequest = (request, metadata) => {
   if (captured && event.eventType === "SessionStart") {
     autoUpdater?.onSessionStart();
   }
+  if (captured && (event.eventType === "Stop" || event.eventType === "SessionEnd")) {
+    sessionEndSyncWakeScheduler.request();
+  }
   hookSyncLoop?.wake();
   return "committed";
 };
@@ -1681,13 +1751,26 @@ var captureHookInboxEntry = (entry) => captureHookRequest(entry.request, entry);
 var drainPendingHookInbox = () => {
   if (hookInboxDrainPromise) return hookInboxDrainPromise;
   const drainPromise = (async () => {
-    const result = await drainHookInbox(captureHookInboxEntry);
-    if (result.malformed > 0) recordHookRejection("inbox_malformed");
-    if (result.failed > 0) recordHookRejection("inbox_drain_failed");
-    if (result.unsupported > 0 && !unsupportedInboxSchemaReported) {
+    const startedAtMs = Date.now();
+    let sawUnsupported = false;
+    let batch = HOOK_INBOX_DRAIN_ENTRIES;
+    for (; ; ) {
+      const result = await drainHookInbox(captureHookInboxEntry, void 0, {
+        maximumEntries: batch
+      });
+      if (result.malformed > 0) recordHookRejection("inbox_malformed");
+      if (result.failed > 0) recordHookRejection("inbox_drain_failed");
+      if (result.unsupported > 0) sawUnsupported = true;
+      const handled = result.drained + result.rejected + result.malformed;
+      if (handled === 0 || result.failed > 0 || Date.now() - startedAtMs >= HOOK_INBOX_DRAIN_BUDGET_MS) {
+        break;
+      }
+      batch = handled >= batch ? HOOK_INBOX_DRAIN_BULK_ENTRIES : HOOK_INBOX_DRAIN_ENTRIES;
+    }
+    if (sawUnsupported && !unsupportedInboxSchemaReported) {
       recordHookRejection("inbox_unsupported_schema");
       unsupportedInboxSchemaReported = true;
-    } else if (result.unsupported === 0) {
+    } else if (!sawUnsupported) {
       unsupportedInboxSchemaReported = false;
     }
   })();
@@ -1800,6 +1883,9 @@ try {
     if (!shuttingDown) scheduleFatalShutdown(error);
   });
   syncLoop = createObserverSyncLoop({
+    // Clear at the cycle boundary, after any in-flight worker had a chance to
+    // republish its older walk, so a hook nudge always discovers new files.
+    beforeNudgedCycle: invalidateCliRawSyncDiscoveryCache,
     onUpdate: (update) => {
       updateState(update);
     },

package/dist/sync-cycle.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   runObserverSyncCycle
-} from "./chunk-YFHZJPTC.js";
-import "./chunk-V2XC7JTB.js";
+} from "./chunk-6BTC3S7C.js";
+import "./chunk-5JJQWV4G.js";
+import "./chunk-F57IFY3K.js";
 import "./chunk-B3H2YWPJ.js";
 import "./chunk-MLKGABMK.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fml-inc/fml",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "FML CLI and agent tools",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",